@resolveio/server-lib 22.3.221 → 22.3.222

package/tests/aicoder-runner-v6.test.ts

@@ -1,822 +0,0 @@
-import * as assert from 'node:assert/strict';
-import {
-	buildResolveIOAICoderWorkflowProofCheckpoint,
-	buildResolveIOAICoderWorkflowQaRowsFromJourneyContract,
-	buildResolveIOAICoderV6DiagnoseFirstPrompt,
-	collectResolveIOAICoderJourneyContractIssues,
-	decideResolveIOAICoderV6Continuation,
-	evaluateResolveIOAICoderWorkflowProofReadiness,
-	extractResolveIOAICoderJourneyContractFromMarkdown,
-	fingerprintResolveIOAICoderV6Blocker,
-	initializeResolveIOAICoderV6State,
-	recordResolveIOAICoderV6Step,
-	validateResolveIOAICoderJourneyContract
-} from '../src/util/aicoder-runner-v6';
-
-const initialized = initializeResolveIOAICoderV6State({
-	runKind: 'initial_builder',
-	jobId: 'job-1',
-	appId: 'app-1',
-	title: 'Build crypto dashboard',
-	description: 'Create a complete crypto trading dashboard.',
-	branchName: 'ai/crypto-dashboard',
-	now: '2026-06-07T12:00:00.000Z'
-});
-
-assert.equal(initialized.aiCoderRunnerVersion, 'v6');
-assert.equal(initialized.aiCoderV6SupervisorState.runKind, 'initial_builder');
-assert.equal(initialized.aiCoderV6SupervisorState.activeLane, 'plan');
-assert.equal(initialized.aiCoderV6LaneMemory.build.threadKey, 'aicoder:initial_builder:job-1:build');
-assert.equal(initialized.aiCoderV6Budget.maxRepeatedNoProgress, 2);
-assert.equal(initialized.aiCoderV6WorkflowMemory.journeyContractPath, 'docs/APP_JOURNEY_CONTRACT.md');
-assert.deepEqual(initialized.aiCoderV6RecoveryDispatchHistory, []);
-assert.equal(initialized.aiCoderV6RecoveryDirective, undefined);
-
-const validJourneyContract = {
-	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 the recommended next optimizer action.',
-		visible_cta: 'Start optimizer scenario',
-		next_step: 'Open scenario assumptions with seeded route data.'
-	},
-	north_star_workflow: [{
-		position: 'first',
-		id: 'start-scenario',
-		route: '/dashboard/hub',
-		visible_cta: 'Start optimizer scenario',
-		data_input_or_selection: 'Select the seeded North Field route scenario.',
-		method_or_calculation: 'local calculation path optimizerScenarioDraft plus server method saveOptimizerScenarioDraft',
-		expected_state_transition: 'Scenario assumptions panel opens with route, elevation, pump, and hose records loaded.',
-		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 elevation, 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 from the comparison table.',
-		method_or_calculation: 'server method publishOptimizerRecommendation and report export path optimizerRecommendationPdf',
-		expected_state_transition: 'Saved report row appears with export controls.',
-		success_confirmation: 'Recommendation saved and report ready message appears.',
-		final_result: 'Saved optimizer recommendation with exportable pressure report.'
-	}],
-	secondary_workflows: [
-		{ id: 'setup', route: '/manage/settings', purpose: 'Maintain pump and hose defaults.' },
-		{ id: 'report-export', route: '/reports/optimizer', purpose: 'Review and export saved recommendations.' },
-		{ id: 'recovery', route: '/dashboard/hub', purpose: 'Show empty and invalid pressure recovery states.' }
-	],
-	screen_sequence: [{
-		workflow_step_id: 'start-scenario',
-		route: '/dashboard/hub',
-		screen_purpose: 'Command center with seeded scenario, KPIs, next-up work queue, and embedded optimizer action.',
-		visible_cta: 'Start optimizer scenario',
-		action: 'Open scenario assumptions',
-		method_or_calculation: 'local calculation path optimizerScenarioDraft',
-		expected_next_state: 'Scenario assumptions are visible.',
-		data_shown: 'Seeded route, elevation, pump, hose, and pressure-limit records.'
-	}, {
-		workflow_step_id: 'run-optimizer',
-		route: '/dashboard/hub',
-		screen_purpose: 'Run optimizer and compare alternatives.',
-		visible_cta: 'Run optimization',
-		action: 'Calculate pressure recommendation',
-		method_or_calculation: 'local calculation path runLayflatPressureOptimizer',
-		expected_next_state: 'Recommendation and alternatives update.',
-		data_shown: 'Comparison table, pressure KPIs, and recommendation card.'
-	}, {
-		workflow_step_id: 'save-report',
-		route: '/reports/optimizer',
-		screen_purpose: 'Save and export recommendation report.',
-		visible_cta: 'Save recommendation report',
-		action: 'Persist recommendation report',
-		method_or_calculation: 'server method publishOptimizerRecommendation',
-		expected_next_state: 'Saved report row and export button visible.',
-		data_shown: 'Saved recommendation, route assumptions, calculated pressure, and export status.'
-	}],
-	data_story: {
-		seeded_scenario: 'North Field irrigation route with elevation changes, two pump options, and three 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 KPI cards show pressure, flow, and route length.', 'Reports table shows saved recommendation row.']
-	},
-	completion_states: [
-		'Recommendation card shows selected hose and pressure margin.',
-		'Report route lists saved recommendation with export action.'
-	],
-	qa_assertions: [{
-		id: 'login-hub',
-		workflow_step_id: 'start-scenario',
-		route: '/dashboard/hub',
-		coverage_tags: ['login', 'hub_action', 'non_empty_data'],
-		proof_kind: 'login',
-		action: 'Login and land on dashboard hub.',
-		expected_dom_or_data_proof: 'Hub shows seeded North Field scenario and non-empty KPI cards.'
-	}, {
-		id: 'primary-hub-action',
-		workflow_step_id: 'start-scenario',
-		route: '/dashboard/hub',
-		coverage_tags: ['hub_action'],
-		proof_kind: 'hub_action',
-		action: 'Click Start optimizer scenario.',
-		expected_dom_or_data_proof: 'Scenario assumptions panel opens with seeded route and pump records.'
-	}, {
-		id: 'workflow-completion',
-		covers_workflow_step_ids: ['run-optimizer', 'save-report'],
-		route: '/dashboard/hub',
-		coverage_tags: ['workflow_completion', 'report_export'],
-		proof_kind: 'report_export',
-		action: 'Run optimization and save recommendation.',
-		expected_dom_or_data_proof: 'Saved recommendation report row appears with calculated pressure result.'
-	}, {
-		id: 'mobile-viewport',
-		covers_workflow_step_ids: ['start-scenario', 'run-optimizer', 'save-report'],
-		route: '/dashboard/hub',
-		coverage_tags: ['mobile', 'workflow_completion'],
-		proof_kind: 'mobile',
-		action: 'Repeat primary optimizer path at mobile viewport 390x844.',
-		expected_dom_or_data_proof: 'Mobile hub shows non-empty scenario and recommendation controls.',
-		viewport: '390x844 mobile'
-	}, {
-		id: 'empty-error-recovery',
-		workflow_step_id: 'start-scenario',
-		route: '/dashboard/hub',
-		coverage_tags: ['recovery'],
-		proof_kind: 'recovery',
-		action: 'Clear scenario input and submit invalid pressure limit.',
-		expected_dom_or_data_proof: 'Empty/error recovery message appears and Start optimizer scenario remains available.'
-	}]
-};
-
-const validJourneyValidation = validateResolveIOAICoderJourneyContract(validJourneyContract);
-assert.equal(validJourneyValidation.valid, true);
-assert.equal(validJourneyValidation.primaryWorkflowId, 'layflat-optimizer');
-assert.equal(validJourneyValidation.workflowQaRows.length, 5);
-assert.equal(validJourneyValidation.workflowQaRows[2].stepId, 'workflow-completion');
-assert.equal(validJourneyValidation.workflowQaRows[2].workflowStepId, undefined);
-assert.deepEqual(validJourneyValidation.workflowQaRows[2].workflowStepIds, ['run-optimizer', 'save-report']);
-assert.equal(validJourneyValidation.workflowQaRows[2].acceptanceGate, 'aiqa_business_assertion');
-assert.equal(validJourneyValidation.workflowQaRows[2].proofKind, 'report_export');
-assert.deepEqual(validJourneyValidation.workflowQaRows[2].coverageTags, ['workflow_completion', 'report_export']);
-assert.ok(validJourneyValidation.workflowQaRows[2].requiredArtifacts?.some((artifact) => /saved output row proof|generated report\/export artifact/i.test(artifact)));
-assert.equal(validJourneyValidation.workflowQaRows[2].stateTransition?.assertion, 'Saved recommendation report row appears with calculated pressure result.');
-assert.equal(buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(validJourneyContract)[0].workflowId, 'layflat-optimizer');
-
-const validJourneyMarkdown = `# App Journey Contract
-
-## journey_contract
-\`\`\`json
-${JSON.stringify(validJourneyContract, null, 2)}
-\`\`\`
-`;
-assert.equal(extractResolveIOAICoderJourneyContractFromMarkdown(validJourneyMarkdown)?.app_archetype, 'optimizer');
-assert.equal(validateResolveIOAICoderJourneyContract(validJourneyMarkdown).valid, true);
-
-const passingWorkflowQaRows = buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(validJourneyContract).map((row) => ({
-	...row,
-	status: 'pass',
-	artifactPaths: [`qa-artifacts/${row.stepId || row.index}.json`]
-}));
-const passingWorkflowBusinessAssertions = passingWorkflowQaRows.map((row) => ({
-	stepId: row.stepId,
-	workflowId: row.workflowId,
-	route: row.route,
-	action: row.action,
-	assertion: row.assertion || row.expectedState,
-	status: 'pass',
-	observed: `${row.stepId || row.index} produced the expected visible state in the north-star workflow.`,
-	dataProof: `${row.stepId || row.index} has observed DOM/data proof from seeded Layflat records.`,
-	artifactPaths: row.artifactPaths
-}));
-const workflowProofReady = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	workflowQaRows: passingWorkflowQaRows,
-	businessAssertions: passingWorkflowBusinessAssertions,
-	routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
-	scorecardPassed: true,
-	deployStatus: 'pass',
-	publishStatus: 'published',
-	sampleDataStatus: 'pass',
-	now: '2026-06-07T12:00:00.000Z'
-});
-assert.equal(workflowProofReady.ready, true);
-assert.equal(workflowProofReady.status, 'ready');
-assert.equal(workflowProofReady.passedWorkflowRows.length, 5);
-assert.equal(workflowProofReady.sampleDataReady, true);
-assert.match(workflowProofReady.workflowProofFingerprint, /^aicoder-workflow-proof-/);
-assert.match(workflowProofReady.artifactFingerprint, /^aicoder-workflow-artifacts-/);
-assert.equal(workflowProofReady.proofFreshness, 'fresh');
-
-const staleWorkflowProof = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	workflowQaRows: passingWorkflowQaRows,
-	businessAssertions: passingWorkflowBusinessAssertions,
-	routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
-	scorecardPassed: true,
-	deployStatus: 'pass',
-	publishStatus: 'published',
-	sampleDataStatus: 'pass',
-	previousWorkflowProofFingerprint: workflowProofReady.workflowProofFingerprint,
-	now: '2026-06-07T12:03:00.000Z'
-});
-assert.equal(staleWorkflowProof.ready, false);
-assert.equal(staleWorkflowProof.status, 'stale_workflow_proof');
-assert.equal(staleWorkflowProof.proofFreshness, 'same_as_previous');
-assert.ok(staleWorkflowProof.nextAction.includes('Rerun workflow QA'));
-
-const routeOnlyWorkflowProof = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	routeProbes: [{ route: '/dashboard/hub', status: 'pass' }],
-	scorecardPassed: true
-});
-assert.equal(routeOnlyWorkflowProof.ready, false);
-assert.equal(routeOnlyWorkflowProof.status, 'route_only');
-assert.equal(routeOnlyWorkflowProof.scorecardOnly, true);
-
-const screenshotOnlyWorkflowProof = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	workflowQaRows: passingWorkflowQaRows,
-	businessAssertions: passingWorkflowBusinessAssertions.map((assertion) => ({
-		...assertion,
-		observed: '',
-		dataProof: '',
-		artifactPaths: assertion.artifactPaths
-	})),
-	scorecardPassed: true,
-	sampleDataStatus: 'pass'
-});
-assert.equal(screenshotOnlyWorkflowProof.ready, false);
-assert.equal(screenshotOnlyWorkflowProof.status, 'business_proof_weak');
-assert.ok(screenshotOnlyWorkflowProof.blockers.some((blocker) => /observed DOM\/data proof/i.test(blocker)));
-
-const weakWorkflowProofRows = buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(validJourneyContract).map((row) => ({
-	...row,
-	status: 'pass',
-	artifactPaths: []
-}));
-const weakWorkflowProof = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	workflowQaRows: weakWorkflowProofRows,
-	businessAssertions: [{
-		stepId: 'workflow-completion',
-		workflowId: 'layflat-optimizer',
-		route: '/dashboard/hub',
-		assertion: 'Saved recommendation report row appears with calculated pressure result.',
-		status: 'pass',
-		dataProof: 'North Field seeded hose records produced saved optimizer recommendation pressure output.'
-	}],
-	scorecardPassed: true,
-	sampleDataStatus: 'pass'
-});
-assert.equal(weakWorkflowProof.ready, false);
-assert.equal(weakWorkflowProof.status, 'business_proof_weak');
-assert.ok(weakWorkflowProof.blockers.some((blocker) => /missing required artifact proof|AIQaBusinessAssertion/i.test(blocker)));
-
-const partialWorkflowProof = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	workflowQaRows: passingWorkflowQaRows.slice(0, 2),
-	businessAssertions: passingWorkflowBusinessAssertions.slice(0, 2),
-	sampleDataStatus: 'pass'
-});
-assert.equal(partialWorkflowProof.ready, false);
-assert.equal(partialWorkflowProof.status, 'workflow_qa_incomplete');
-assert.ok(partialWorkflowProof.missingWorkflowRows.length > 0);
-
-const releaseBlockedWorkflowProof = evaluateResolveIOAICoderWorkflowProofReadiness({
-	journeyContract: validJourneyContract,
-	workflowQaRows: passingWorkflowQaRows,
-	businessAssertions: passingWorkflowBusinessAssertions,
-	sampleDataStatus: 'pass',
-	deployStatus: 'pass',
-	publishStatus: 'publish failed'
-});
-assert.equal(releaseBlockedWorkflowProof.ready, false);
-assert.equal(releaseBlockedWorkflowProof.status, 'release_blocked');
-assert.ok(releaseBlockedWorkflowProof.releaseBlockers.some((blocker) => /publish/.test(blocker)));
-
-const missingOrderedWorkflowIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	north_star_workflow: validJourneyContract.north_star_workflow.slice(0, 2)
-}, { requireMarkdownEnvelope: false });
-assert.ok(missingOrderedWorkflowIssues.some((issue) => /first, next, and last/i.test(issue)));
-
-const ctaWithoutImplementationIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	north_star_workflow: validJourneyContract.north_star_workflow.map((step, index) => index === 1
-		? { ...step, method_or_calculation: '' }
-		: step)
-}, { requireMarkdownEnvelope: false });
-assert.ok(ctaWithoutImplementationIssues.some((issue) => /server method, publication, local calculation/i.test(issue)));
-
-const linkOnlyHubIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	screen_sequence: validJourneyContract.screen_sequence.map((screen, index) => index === 0
-		? {
-			route: '/dashboard/hub',
-			screen_purpose: 'Command center link list.',
-			visible_cta: 'Open optimizer page',
-			action: 'Navigate to optimizer route',
-			expected_next_state: 'Route opens.',
-			data_shown: 'Links to pages.'
-		}
-		: screen)
-}, { requireMarkdownEnvelope: false });
-assert.ok(linkOnlyHubIssues.some((issue) => /link farm|navigate without changing workflow state/i.test(issue)));
-
-const disconnectedScreenIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	screen_sequence: validJourneyContract.screen_sequence.map((screen, index) => index === 1
-		? {
-			workflow_step_id: 'unrelated-review-step',
-			route: '/reports/summary',
-			screen_purpose: 'Review unrelated summary data.',
-			visible_cta: 'Review summary',
-			action: 'Review unrelated summary output',
-			method_or_calculation: 'local calculation path unrelatedSummary',
-			expected_next_state: 'Summary panel updates.',
-			data_shown: 'Unrelated summary rows.'
-		}
-		: screen)
-}, { requireMarkdownEnvelope: false });
-assert.ok(disconnectedScreenIssues.some((issue) => /screen_sequence\[1\].*north_star_workflow step/i.test(issue)));
-assert.ok(disconnectedScreenIssues.some((issue) => /north_star_workflow\[1\].*matching screen_sequence row/i.test(issue)));
-
-const weakDataStoryIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	data_story: {
-		seeded_scenario: 'Short',
-		records: [],
-		relationships: [],
-		non_empty_states: []
-	}
-}, { requireMarkdownEnvelope: false });
-assert.ok(weakDataStoryIssues.some((issue) => /seeded records/i.test(issue)));
-assert.ok(weakDataStoryIssues.some((issue) => /non-empty dashboard/i.test(issue)));
-
-const routeOnlyQaIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	qa_assertions: [{
-		id: 'route-load',
-		route: '/dashboard/hub',
-		action: 'Open route',
-		expected_dom_or_data_proof: 'Route loaded'
-	}]
-}, { requireMarkdownEnvelope: false });
-assert.ok(routeOnlyQaIssues.some((issue) => /workflow completion|business completion|mobile viewport|non-empty/i.test(issue)));
-
-const proseOnlyQaIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	qa_assertions: [{
-		id: 'login-hub',
-		route: '/dashboard/hub',
-		action: 'Login and land on dashboard hub.',
-		expected_dom_or_data_proof: 'Hub shows seeded North Field scenario and non-empty KPI cards.'
-	}, {
-		id: 'primary-hub-action',
-		route: '/dashboard/hub',
-		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',
-		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',
-		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',
-		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.'
-	}]
-}, { requireMarkdownEnvelope: false });
-assert.ok(proseOnlyQaIssues.some((issue) => /coverage_tags|prose-only keyword/i.test(issue)));
-
-const disconnectedQaIssues = collectResolveIOAICoderJourneyContractIssues({
-	...validJourneyContract,
-	qa_assertions: [{
-		id: 'login-hub',
-		route: '/dashboard/hub',
-		coverage_tags: ['login', 'hub_action', 'non_empty_data'],
-		proof_kind: 'login',
-		action: 'Authenticate and confirm the dashboard shell is visible.',
-		expected_dom_or_data_proof: 'Dashboard shell loaded with a title.'
-	}, {
-		id: 'primary-hub-action',
-		route: '/dashboard/hub',
-		coverage_tags: ['hub_action'],
-		proof_kind: 'hub_action',
-		action: 'Confirm a generic command exists.',
-		expected_dom_or_data_proof: 'A command button is visible.'
-	}, {
-		id: 'workflow-completion',
-		route: '/dashboard/hub',
-		coverage_tags: ['workflow_completion', 'report_export'],
-		proof_kind: 'report_export',
-		action: 'Confirm a workflow finished.',
-		expected_dom_or_data_proof: 'A generic success message is visible.'
-	}, {
-		id: 'mobile-viewport',
-		route: '/dashboard/hub',
-		coverage_tags: ['mobile', 'workflow_completion'],
-		proof_kind: 'mobile',
-		action: 'Open the mobile dashboard.',
-		expected_dom_or_data_proof: 'Mobile shell is visible.',
-		viewport: '390x844 mobile'
-	}, {
-		id: 'empty-error-recovery',
-		route: '/dashboard/hub',
-		coverage_tags: ['recovery'],
-		proof_kind: 'recovery',
-		action: 'Trigger generic validation.',
-		expected_dom_or_data_proof: 'A generic error message is visible.'
-	}]
-}, { requireMarkdownEnvelope: false });
-assert.ok(disconnectedQaIssues.some((issue) => /qa_assertions\[0\].*workflow_step_id|qa_assertions\[0\].*covers_workflow_step_ids/i.test(issue)));
-assert.ok(disconnectedQaIssues.some((issue) => /north_star_workflow\[1\].*covered by at least one qa_assertions row/i.test(issue)));
-
-const withBuildFailure = recordResolveIOAICoderV6Step(initialized, {
-	lane: 'build',
-	stepType: 'build',
-	outcome: 'needs_repair',
-	model: 'gpt-5.3-codex',
-	threadKey: 'job-1:build',
-	promptVersion: 'abc123',
-	promptTokenEstimate: 1200,
-	inputTokens: 1000,
-	cachedInputTokens: 200,
-	outputTokens: 300,
-	summary: 'Angular build failed.',
-	blocker: 'TS2304 line 42 cannot find name InvoiceModel',
-	changedFiles: ['angular/app/dashboard/hub/dashboard-hub.component.ts'],
-	artifactPaths: ['.dashboard-output/build-client.log'],
-	now: '2026-06-07T12:01:00.000Z'
-});
-
-assert.equal(withBuildFailure.aiCoderV6SupervisorState.activeLane, 'build');
-assert.equal(withBuildFailure.aiCoderV6SupervisorState.activeStep, 'build');
-assert.equal(withBuildFailure.aiCoderV6LaneMemory.build.latestPromptVersion, 'abc123');
-assert.equal(withBuildFailure.aiCoderV6Budget.totalInputTokens, 1000);
-assert.equal(withBuildFailure.aiCoderV6Budget.totalCachedInputTokens, 200);
-assert.equal(withBuildFailure.aiCoderV6Budget.totalOutputTokens, 300);
-assert.equal(withBuildFailure.aiCoderV6StepHistory[0].blockerFingerprint, fingerprintResolveIOAICoderV6Blocker('TS2304 line 99 cannot find name InvoiceModel'));
-assert.equal(withBuildFailure.aiCoderV6RecoveryPlan?.recoveryClass, 'compile_repair');
-assert.equal(withBuildFailure.aiCoderV6RecoveryCheckpoint?.recoveryClass, 'compile_repair');
-assert.equal(withBuildFailure.aiCoderV6RecoveryAction?.checkpointId, withBuildFailure.aiCoderV6RecoveryCheckpoint?.checkpointId);
-const buildFailureDecision = decideResolveIOAICoderV6Continuation(withBuildFailure);
-assert.equal(buildFailureDecision.action, 'infra_retry');
-assert.equal(buildFailureDecision.reason, 'aicoder_v6_compile_repair_required');
-assert.equal(buildFailureDecision.recoveryPlan.recoveryClass, 'compile_repair');
-assert.equal(buildFailureDecision.recoveryPlan.productRepairAllowed, false);
-assert.ok(buildFailureDecision.recoveryPlan.requiredEvidence.includes('compile log artifact'));
-assert.equal(buildFailureDecision.recoveryCheckpoint.recoveryClass, 'compile_repair');
-assert.equal(buildFailureDecision.recoveryCheckpoint.productRepairAllowed, false);
-assert.equal(buildFailureDecision.workflowReadiness.status, 'compile_repair_only');
-assert.equal(buildFailureDecision.workflowReadiness.compileOnly, true);
-assert.equal(buildFailureDecision.workflowReadiness.canRunProductRepair, false);
-assert.equal(buildFailureDecision.nextActionContract.primaryCommand, 'repair_aicoder_compile_gate');
-assert.equal(buildFailureDecision.nextActionContract.costRisk, 'small_model_or_qa');
-assert.equal(buildFailureDecision.nextActionContract.canRunWithoutCodexMonitor, true);
-assert.ok(buildFailureDecision.nextActionContract.stopConditions.some((entry) => /compile failures stay in infra\/compile repair/i.test(entry)));
-
-const withWorkflowQa = recordResolveIOAICoderV6Step(initialized, {
-	lane: 'qa',
-	stepType: 'workflow_qa',
-	outcome: 'pass',
-	primaryWorkflowId: 'north-star',
-	activeWorkflowStep: 'save-result',
-	workflowQaRows: [{
-		index: 1,
-		workflowId: 'north-star',
-		stepId: 'save-result',
-		route: '/dashboard/hub',
-		action: 'Save recommendation',
-		assertion: 'Saved result appears in the recommendations table.',
-		expectedState: 'Recommendation saved',
-		status: 'pass',
-		artifactPaths: ['.build-output/workflow-save-result.png']
-	}],
-	artifactPaths: ['.build-output/workflow-save-result.png'],
-	businessProofArtifacts: ['.build-output/workflow-save-result-business-proof.json'],
-	summary: 'North-star workflow QA passed.'
-});
-
-assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.primaryWorkflowId, 'north-star');
-assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.activeWorkflowStep, 'save-result');
-assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.completedWorkflowSteps.includes('save-result'), true);
-assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.workflowQaRows[0].route, '/dashboard/hub');
-assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.businessProofArtifacts.includes('.build-output/workflow-save-result-business-proof.json'), true);
-const workflowReadyDecision = decideResolveIOAICoderV6Continuation(withWorkflowQa);
-assert.equal(workflowReadyDecision.workflowReadiness.status, 'workflow_business_proof_ready');
-assert.equal(workflowReadyDecision.workflowReadiness.businessProofReady, true);
-assert.equal(workflowReadyDecision.workflowReadiness.canPublish, true);
-assert.equal(workflowReadyDecision.workflowReadiness.canPolishWowUi, true);
-assert.equal(workflowReadyDecision.workflowProofCheckpoint.status, 'ready_to_continue');
-assert.equal(workflowReadyDecision.workflowProofCheckpoint.blocksPublishUntilWorkflowProof, false);
-assert.equal(workflowReadyDecision.workflowProofCheckpoint.blocksWowUiUntilWorkflowProof, false);
-assert.equal(workflowReadyDecision.nextActionContract.primaryCommand, 'continue_aicoder_workflow');
-assert.equal(workflowReadyDecision.nextActionContract.workflowFirstSatisfied, true);
-assert.equal(workflowReadyDecision.nextActionContract.codexFallbackRequired, false);
-assert.equal(workflowReadyDecision.nextActionContract.decisionBasis.canPublish, true);
-
-let repeated = withBuildFailure;
-for (let index = 0; index < 3; index += 1) {
-	repeated = recordResolveIOAICoderV6Step(repeated, {
-		lane: 'build',
-		stepType: 'build',
-		outcome: 'needs_repair',
-		summary: 'Angular build failed.',
-		blocker: 'TS2304 line 77 cannot find name InvoiceModel',
-		now: `2026-06-07T12:0${index + 2}:00.000Z`
-	});
-}
-
-const repeatedDecision = decideResolveIOAICoderV6Continuation(repeated);
-assert.equal(repeatedDecision.action, 'park');
-assert.equal(repeatedDecision.reason, 'aicoder_v6_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.steps.some((step) => step.kind === 'rerun_same_gate'));
-assert.equal(repeatedDecision.recoveryAction.mode, 'collect_evidence');
-assert.equal(repeatedDecision.recoveryAction.retryPolicy.requireNewEvidence, true);
-assert.equal(repeatedDecision.recoveryAction.productRepairAllowed, false);
-assert.equal(repeatedDecision.workflowReadiness.status, 'collect_new_evidence');
-assert.equal(repeatedDecision.workflowReadiness.sameFailureParked, true);
-assert.equal(repeatedDecision.workflowReadiness.canRunProductRepair, false);
-assert.equal(repeatedDecision.workflowProofCheckpoint.status, 'waiting_for_new_evidence');
-assert.equal(repeatedDecision.workflowProofCheckpoint.blocksPublishUntilWorkflowProof, true);
-assert.equal(repeatedDecision.workflowProofCheckpoint.blocksWowUiUntilWorkflowProof, true);
-assert.ok(repeatedDecision.workflowProofCheckpoint.requiredResetEvidence.some((entry) => /new workflow proof fingerprint|changed blocker fingerprint|fresh workflow QA artifact/i.test(entry)));
-assert.equal(repeated.aiCoderV6RecoveryPlan?.recoveryClass, 'blocked_until_new_evidence');
-assert.equal(repeated.aiCoderV6RecoveryCheckpoint?.status, 'parked');
-assert.equal(repeated.aiCoderV6RecoveryEvidenceProbe?.checkpointId, repeated.aiCoderV6RecoveryCheckpoint?.checkpointId);
-
-const newEvidenceRetry = recordResolveIOAICoderV6Step(withBuildFailure, {
-	lane: 'build',
-	stepType: 'build',
-	outcome: 'needs_repair',
-	failureClass: 'compile',
-	summary: 'Angular build failed with the same root blocker after a targeted change.',
-	blocker: 'TS2304 line 88 cannot find name InvoiceModel',
-	evidenceHash: 'compile-log-after-import-fix',
-	changedFiles: ['angular/app/dashboard/hub/dashboard-hub.component.ts'],
-	artifactPaths: ['.dashboard-output/build-client-after-import.log']
-});
-assert.equal(newEvidenceRetry.aiCoderV6Budget.loopCount, 1);
-const newEvidenceDecision = decideResolveIOAICoderV6Continuation(newEvidenceRetry);
-assert.equal(newEvidenceDecision.action, 'infra_retry');
-assert.equal(newEvidenceDecision.recoveryPlan.recoveryClass, 'compile_repair');
-assert.equal(newEvidenceDecision.recoveryPlan.productRepairAllowed, false);
-assert.equal(newEvidenceDecision.workflowReadiness.status, 'compile_repair_only');
-assert.ok(newEvidenceDecision.recoveryPlan.loopResetEvidence.some((entry) => /same check now passes|new infra\/compile blocker hash/.test(entry)));
-
-const infraFailure = recordResolveIOAICoderV6Step(initialized, {
-	lane: 'qa',
-	stepType: 'workflow_qa',
-	outcome: 'needs_repair',
-	failureClass: 'infra',
-	summary: 'Puppeteer could not launch Chrome.',
-	blocker: 'Puppeteer could not launch Chrome from the configured executable path.'
-});
-const infraDecision = decideResolveIOAICoderV6Continuation(infraFailure);
-assert.equal(infraDecision.action, 'infra_retry');
-assert.equal(infraDecision.nextLane, 'qa');
-assert.equal(infraDecision.reason, 'aicoder_v6_infra_retry');
-assert.equal(infraDecision.recoveryPlan.recoveryClass, 'infra_repair');
-assert.equal(infraDecision.recoveryPlan.expensiveModelAllowed, false);
-assert.ok(infraDecision.recoveryPlan.forbiddenActions.some((action) => /product-code model repair/.test(action)));
-assert.equal(infraDecision.workflowReadiness.status, 'infra_repair_only');
-assert.equal(infraDecision.workflowReadiness.infraOnly, true);
-assert.equal(infraDecision.workflowReadiness.canRunProductRepair, false);
-assert.equal(infraDecision.nextActionContract.primaryCommand, 'repair_aicoder_infra_gate');
-assert.equal(infraDecision.nextActionContract.costRisk, 'small_model_or_qa');
-assert.equal(infraDecision.nextActionContract.decisionBasis.infraOnly, true);
-
-const journeyFailure = recordResolveIOAICoderV6Step(initialized, {
-	lane: 'plan',
-	stepType: 'journey_validation',
-	outcome: 'needs_repair',
-	summary: 'Journey contract is missing first/next/last steps.',
-	blocker: 'docs/APP_JOURNEY_CONTRACT.md journey_contract.north_star_workflow has fewer than 3 ordered steps.'
-});
-const journeyDecision = decideResolveIOAICoderV6Continuation(journeyFailure);
-assert.equal(journeyDecision.action, 'retry_same_step');
-assert.equal(journeyDecision.nextLane, 'plan');
-assert.equal(journeyDecision.nextStep, 'journey_contract');
-assert.equal(journeyDecision.reason, 'aicoder_v6_journey_contract_repair_required');
-assert.equal(journeyDecision.recoveryPlan.recoveryClass, 'journey_contract_repair');
-assert.equal(journeyDecision.recoveryPlan.productRepairAllowed, false);
-assert.ok(journeyDecision.recoveryPlan.forbiddenActions.some((action) => /empty routes/.test(action)));
-assert.equal(journeyDecision.workflowReadiness.status, 'journey_contract_repair_required');
-assert.equal(journeyDecision.workflowReadiness.nextGate, 'journey_contract');
-assert.equal(journeyDecision.workflowReadiness.canRunProductRepair, false);
-assert.equal(journeyDecision.nextActionContract.action, 'retry_same_step');
-assert.equal(journeyDecision.nextActionContract.primaryCommand, 'repair_aicoder_journey_contract');
-assert.equal(journeyDecision.nextActionContract.safeToAutoRun, true);
-assert.equal(journeyDecision.nextActionContract.canRunWithoutCodexMonitor, true);
-assert.equal(journeyDecision.nextActionContract.decisionBasis.journeyContractReady, false);
-assert.ok(journeyDecision.nextActionContract.stopConditions.some((entry) => /APP_JOURNEY_CONTRACT\.md validates/i.test(entry)));
-
-const releaseFailure = recordResolveIOAICoderV6Step(withWorkflowQa, {
-	lane: 'publish',
-	stepType: 'test_deploy',
-	outcome: 'needs_repair',
-	summary: 'Test deploy failed after workflow QA passed.',
-	blocker: 'CloudFront invalidation failed during test deploy.'
-});
-const releaseDecision = decideResolveIOAICoderV6Continuation(releaseFailure);
-assert.equal(releaseDecision.action, 'retry_same_step');
-assert.equal(releaseDecision.nextLane, 'publish');
-assert.equal(releaseDecision.nextStep, 'test_deploy');
-assert.equal(releaseDecision.reason, 'aicoder_v6_release_repair_required');
-assert.equal(releaseDecision.recoveryPlan.recoveryClass, 'release_repair');
-assert.equal(releaseDecision.recoveryPlan.expensiveModelAllowed, false);
-assert.ok(releaseDecision.recoveryPlan.forbiddenActions.some((action) => /scorecard only/.test(action)));
-assert.equal(releaseDecision.workflowReadiness.status, 'release_repair_required');
-assert.equal(releaseDecision.workflowReadiness.releaseBlocked, true);
-assert.equal(releaseDecision.workflowReadiness.canPublish, false);
-assert.equal(releaseDecision.workflowProofCheckpoint.status, 'waiting_for_release_gate');
-assert.equal(releaseDecision.workflowProofCheckpoint.blocksPublishUntilWorkflowProof, false);
-assert.equal(releaseDecision.workflowProofCheckpoint.blocksPublishUntilReleaseGate, true);
-assert.equal(releaseDecision.nextActionContract.primaryCommand, 'repair_aicoder_release_gate');
-assert.equal(releaseDecision.nextActionContract.costRisk, 'release_or_customer_send');
-assert.equal(releaseDecision.nextActionContract.decisionBasis.releaseBlocked, true);
-assert.equal(releaseDecision.nextActionContract.decisionBasis.hotfixCommitRequired, true);
-assert.equal(releaseDecision.nextActionContract.decisionBasis.liveHotfixBlockedUntilCommit, true);
-assert.deepEqual(releaseDecision.nextActionContract.requiredHotfixCommitProof, ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed']);
-assert.ok(releaseDecision.nextActionContract.nextCommands.includes('prefer_hotfix_before_full_deploy'));
-assert.ok(releaseDecision.nextActionContract.nextCommands.indexOf('commit_and_push_hotfix_to_github') < releaseDecision.nextActionContract.nextCommands.indexOf('apply_live_hotfix_only_after_github_commit_proof'));
-assert.ok(releaseDecision.nextActionContract.stopConditions.some((entry) => /repeat a full publish\/deploy/i.test(entry)));
-assert.ok(releaseDecision.nextActionContract.stopConditions.some((entry) => /sourceCommitSha.*githubCommitUrl.*gitCommitStatus.*gitPushStatus/i.test(entry)));
-
-const routeOnlyWorkflowBundle = recordResolveIOAICoderV6Step(withWorkflowQa, {
-	lane: 'qa',
-	stepType: 'workflow_qa',
-	outcome: 'needs_repair',
-	failureClass: 'business',
-	summary: 'Route loaded but workflow result was not saved.',
-	blocker: 'Route-only browser proof: /dashboard/hub loaded without saved recommendation output.',
-	evidenceHash: 'route-only-proof',
-	artifactPaths: ['.build-output/route-loaded-only.png']
-});
-const routeOnlyWorkflowDecision = decideResolveIOAICoderV6Continuation(routeOnlyWorkflowBundle);
-assert.equal(routeOnlyWorkflowDecision.workflowReadiness.status, 'workflow_qa_required');
-assert.equal(routeOnlyWorkflowDecision.workflowReadiness.routeOnlyBlocked, true);
-assert.equal(routeOnlyWorkflowDecision.workflowProofCheckpoint.status, 'waiting_for_workflow_proof');
-assert.equal(routeOnlyWorkflowDecision.workflowProofCheckpoint.blocksPublishUntilWorkflowProof, true);
-assert.equal(routeOnlyWorkflowDecision.workflowProofCheckpoint.blocksWowUiUntilWorkflowProof, true);
-assert.equal(routeOnlyWorkflowDecision.nextActionContract.primaryCommand, 'run_aicoder_workflow_qa');
-assert.equal(routeOnlyWorkflowDecision.nextActionContract.costRisk, 'small_model_or_qa');
-assert.equal(routeOnlyWorkflowDecision.nextActionContract.decisionBasis.routeOnlyBlocked, true);
-assert.ok(routeOnlyWorkflowDecision.nextActionContract.stopConditions.some((entry) => /Route-only proof/i.test(entry)));
-assert.ok(routeOnlyWorkflowDecision.nextActionContract.forbiddenActions.some((entry) => /route-only proof/i.test(entry)));
-
-const directRouteOnlyCheckpoint = buildResolveIOAICoderWorkflowProofCheckpoint({
-	status: 'workflow_qa_required',
-	nextGate: 'workflow_qa',
-	routeOnlyBlocked: true,
-	journeyContractReady: true,
-	businessProofReady: false,
-	last: routeOnlyWorkflowBundle.aiCoderV6StepHistory[routeOnlyWorkflowBundle.aiCoderV6StepHistory.length - 1],
-	workflowQaRows: routeOnlyWorkflowBundle.aiCoderV6WorkflowMemory.workflowQaRows,
-	businessProofArtifacts: []
-});
-assert.equal(directRouteOnlyCheckpoint.blocksPublishUntilWorkflowProof, true);
-assert.ok(directRouteOnlyCheckpoint.requiredEvidence.some((entry) => /AIQaBusinessAssertion|saved\/calculated output/i.test(entry)));
-
-let pingPong = initialized;
-for (const blocker of ['Workflow save button is disabled', 'Workflow save button is enabled but does not persist', 'Workflow save button is disabled', 'Workflow save button is enabled but does not persist']) {
-	pingPong = recordResolveIOAICoderV6Step(pingPong, {
-		lane: 'qa',
-		stepType: 'workflow_qa',
-		outcome: 'needs_repair',
-		failureClass: 'business',
-		summary: blocker,
-		blocker,
-		evidenceHash: blocker
-	});
-}
-const pingPongDecision = decideResolveIOAICoderV6Continuation(pingPong);
-assert.equal(pingPongDecision.action, 'park');
-assert.equal(pingPongDecision.reason, 'aicoder_v6_ping_pong_no_progress');
-assert.equal(pingPongDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
-assert.ok(pingPongDecision.recoveryPlan.forbiddenActions.some((action) => /alternate between two failed patches/.test(action)));
-
-let terminalReplay = initializeResolveIOAICoderV6State({
-	runKind: 'terminal_helper',
-	jobId: 'terminal-job-1',
-	appId: 'app-1',
-	conversationId: 'conversation-1',
-	title: 'Fix app dashboard save action',
-	description: 'Terminal helper should recover from repeated dashboard save failures.',
-	branchName: 'ai/terminal-dashboard-fix',
-	now: '2026-06-07T12:20:00.000Z'
-});
-for (let index = 0; index < 3; index += 1) {
-	terminalReplay = recordResolveIOAICoderV6Step(terminalReplay, {
-		lane: 'repair',
-		stepType: 'repair',
-		outcome: 'needs_repair',
-		failureClass: 'product_code',
-		summary: 'Dashboard save action throws TypeError.',
-		blocker: 'Dashboard save action throws TypeError cannot read property id.',
-		evidenceHash: 'terminal-save-typeerror',
-		artifactPaths: ['.terminal-output/save-typeerror.log']
-	});
-}
-const terminalReplayDecision = decideResolveIOAICoderV6Continuation(terminalReplay);
-assert.equal(terminalReplayDecision.action, 'park');
-assert.equal(terminalReplayDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
-assert.equal(terminalReplayDecision.recoveryPlan.allowedAction, 'collect_new_evidence_only');
-assert.ok(terminalReplayDecision.recoveryPlan.loopResetEvidence.some((evidence) => /new artifact path/.test(evidence)));
-assert.equal(terminalReplayDecision.recoveryCheckpoint.status, 'parked');
-assert.equal(terminalReplayDecision.recoveryCheckpoint.recoveryClass, 'blocked_until_new_evidence');
-assert.equal(terminalReplayDecision.recoveryEvidenceProbe.evidenceOnly, true);
-assert.ok(terminalReplayDecision.recoveryEvidenceProbe.acceptanceEvidence.some((evidence) => /new artifact path|changed evidence hash/i.test(evidence)));
-assert.equal(terminalReplayDecision.recoveryAction.mode, 'collect_evidence');
-assert.equal(terminalReplayDecision.recoveryAction.evidenceOnly, true);
-assert.ok(terminalReplayDecision.recoveryAction.successCriteria.some((evidence) => /new artifact path|changed evidence hash/i.test(evidence)));
-
-const terminalCompileFailure = recordResolveIOAICoderV6Step(initializeResolveIOAICoderV6State({
-	runKind: 'terminal_helper',
-	jobId: 'terminal-job-2',
-	appId: 'app-1',
-	conversationId: 'conversation-2',
-	title: 'Fix app dashboard compile failure',
-	description: 'Terminal helper should route app-dashboard compile failures to compile repair.',
-	branchName: 'ai/terminal-compile-fix',
-	now: '2026-06-07T12:26:00.000Z'
-}), {
-	lane: 'build',
-	stepType: 'build',
-	outcome: 'needs_repair',
-	failureClass: 'compile',
-	summary: 'AI terminal dashboard build failed.',
-	blocker: 'TS2304 cannot find name DashboardWidgetModel',
-	evidenceHash: 'terminal-compile-before-import-fix',
-	artifactPaths: ['.terminal-output/build-client.log'],
-	now: '2026-06-07T12:27:00.000Z'
-});
-const terminalCompileDecision = decideResolveIOAICoderV6Continuation(terminalCompileFailure);
-assert.equal(terminalCompileDecision.action, 'infra_retry');
-assert.equal(terminalCompileDecision.reason, 'aicoder_v6_compile_repair_required');
-assert.equal(terminalCompileDecision.nextLane, 'build');
-assert.equal(terminalCompileDecision.nextStep, 'build');
-assert.equal(terminalCompileDecision.recoveryPlan.recoveryClass, 'compile_repair');
-assert.equal(terminalCompileDecision.recoveryPlan.productRepairAllowed, false);
-assert.equal(terminalCompileDecision.recoveryPlan.expensiveModelAllowed, false);
-assert.ok(terminalCompileDecision.recoveryPlan.forbiddenActions.some((action) => /product-code model repair|count this as product failure/i.test(action)));
-assert.equal(terminalCompileDecision.workflowReadiness.status, 'compile_repair_only');
-
-const prompt = buildResolveIOAICoderV6DiagnoseFirstPrompt({
-	goal: 'Ship a full-featured app update',
-	activeLane: 'repair',
-	activeStep: 'repair',
-	activeBlocker: 'Build failed',
-	journeyContractPath: 'docs/APP_JOURNEY_CONTRACT.md',
-	activeWorkflowStep: 'save-result',
-	changedFiles: ['server/src/methods/invoices.ts'],
-	artifactPaths: ['qa-artifacts/mobile.png']
-});
-
-assert.ok(prompt.some((line) => /Diagnose First/i.test(line)));
-assert.ok(prompt.some((line) => /Active lane: repair/i.test(line)));
-assert.ok(prompt.some((line) => /server\/src\/methods\/invoices\.ts/i.test(line)));
-assert.ok(prompt.some((line) => /Journey contract: docs\/APP_JOURNEY_CONTRACT\.md/i.test(line)));
-
-const budgeted = recordResolveIOAICoderV6Step(initialized, {
-	lane: 'plan',
-	stepType: 'plan',
-	outcome: 'pass',
-	promptTokenEstimate: 9000,
-	summary: 'Large plan prompt.'
-});
-
-const budgetDecision = decideResolveIOAICoderV6Continuation(budgeted);
-assert.equal(budgetDecision.action, 'budget_stop');
-assert.equal(budgetDecision.recoveryPlan.recoveryClass, 'manual_handoff');
-assert.equal(budgetDecision.workflowReadiness.status, 'budget_stopped');
-assert.equal(budgetDecision.workflowReadiness.requiresHumanDecision, true);
-
-console.log('aicoder runner v6 tests passed');