@resolveio/server-lib 22.3.219 → 22.3.221

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

@@ -0,0 +1,822 @@
+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');