@resolveio/server-lib 22.3.221 → 22.3.222

package/src/util/aicoder-runner-v6.ts

@@ -1,3121 +0,0 @@
-import {
-	buildResolveIOAIManagerRecoveryCheckpoint,
-	buildResolveIOAIManagerRecoveryActionPacket,
-	buildResolveIOAIManagerRecoveryEvidenceProbe,
-	buildResolveIOAIManagerRecoveryPlan,
-	decideResolveIOAIManagerPolicy,
-	hashResolveIOAIManagerEvidence,
-	ResolveIOAIManagerRecoveryCheckpoint,
-	ResolveIOAIManagerRecoveryActionPacket,
-	ResolveIOAIManagerRecoveryActionDispatchRecord,
-	ResolveIOAIManagerRecoveryExecutionDirective,
-	ResolveIOAIManagerRecoveryEvidenceProbe,
-	ResolveIOAIManagerRecoveryPlan,
-	ResolveIOAIManagerRecoveryPlanInput
-} from './ai-runner-manager-policy';
-
-export type ResolveIOAICoderV6Lane =
-	| 'intake'
-	| 'plan'
-	| 'build'
-	| 'qa'
-	| 'repair'
-	| 'review'
-	| 'publish';
-
-export type ResolveIOAICoderV6StepType =
-	| 'intake'
-	| 'journey_contract'
-	| 'journey_validation'
-	| 'plan'
-	| 'task'
-	| 'workflow_build'
-	| 'workflow_qa'
-	| 'build'
-	| 'qa'
-	| 'repair'
-	| 'review'
-	| 'test_deploy'
-	| 'live_deploy'
-	| 'publish'
-	| 'cleanup';
-
-export type ResolveIOAICoderV6Outcome =
-	| 'pass'
-	| 'needs_repair'
-	| 'retry_same_step'
-	| 'park_manual'
-	| 'budget_stop'
-	| 'infra_retry'
-	| 'ready_to_publish'
-	| 'published';
-
-export type ResolveIOAICoderV6RunKind = 'initial_builder' | 'terminal_helper';
-
-export interface ResolveIOAICoderV6Budget {
-	maxPromptTokensPerNonInitialStep: number;
-	maxTotalPromptTokens: number;
-	maxLoopsPerRun: number;
-	maxRepeatedNoProgress: number;
-	maxRuntimeMinutesPerLane: number;
-	softBudgetUsd: number;
-	hardBudgetUsd: number;
-	totalPromptTokenEstimate: number;
-	totalInputTokens: number;
-	totalCachedInputTokens: number;
-	totalOutputTokens: number;
-	totalRuntimeMs: number;
-	loopCount: number;
-}
-
-export interface ResolveIOAICoderV6LaneMemory {
-	lane: ResolveIOAICoderV6Lane;
-	model: string;
-	threadKey: string;
-	scopeSummary: string;
-	activeStep: ResolveIOAICoderV6StepType;
-	activeBlocker: string;
-	activeQaRow?: {
-		index?: number;
-		workflow?: string;
-		route?: string;
-		assertion?: string;
-		status?: string;
-	};
-	changedFiles: string[];
-	artifactPaths: string[];
-	latestPromptVersion?: string;
-	latestPromptTokenEstimate?: number;
-	updatedAt: string;
-}
-
-export interface ResolveIOAICoderV6WorkflowQaRow {
-	index?: number;
-	workflowId?: string;
-	workflowStepId?: string;
-	workflowStepIds?: string[];
-	stepId?: string;
-	route?: string;
-	action?: string;
-	assertion?: string;
-	expectedState?: string;
-	expectedOutput?: string;
-	proofKind?: string;
-	coverageTags?: string[];
-	acceptanceGate?: 'aiqa_business_assertion';
-	requiredArtifacts?: string[];
-	stateTransition?: {
-		before?: string;
-		action?: string;
-		after?: string;
-		assertion?: string;
-	};
-	status?: string;
-	artifactPaths?: string[];
-}
-
-export interface ResolveIOAICoderV6WorkflowMemory {
-	journeyContractPath: string;
-	primaryWorkflowId: string;
-	activeWorkflowStep: string;
-	workflowQaRows: ResolveIOAICoderV6WorkflowQaRow[];
-	completedWorkflowSteps: string[];
-	blockedWorkflowStep: string;
-	businessProofArtifacts: string[];
-	updatedAt: string;
-}
-
-export interface ResolveIOAICoderJourneyContractValidationIssue {
-	code: string;
-	path: string;
-	message: string;
-	severity: 'error' | 'warning';
-}
-
-export interface ResolveIOAICoderJourneyContractValidationResult {
-	valid: boolean;
-	contract: Record<string, any> | null;
-	issues: ResolveIOAICoderJourneyContractValidationIssue[];
-	workflowQaRows: ResolveIOAICoderV6WorkflowQaRow[];
-	primaryWorkflowId: string;
-}
-
-export type ResolveIOAICoderWorkflowProofReadinessStatus =
-	| 'ready'
-	| 'missing_journey_contract'
-	| 'journey_invalid'
-	| 'route_only'
-	| 'workflow_qa_missing'
-	| 'workflow_qa_incomplete'
-	| 'business_proof_missing'
-	| 'business_proof_weak'
-	| 'sample_data_missing'
-	| 'release_blocked'
-	| 'stale_workflow_proof'
-	| 'blocked';
-
-export interface ResolveIOAICoderWorkflowProofReadinessInput {
-	journeyContract?: any;
-	journeyContractMarkdown?: string;
-	workflowQaRows?: ResolveIOAICoderV6WorkflowQaRow[];
-	businessAssertions?: Array<Record<string, any>>;
-	routeProbes?: Array<Record<string, any>>;
-	artifactPaths?: string[];
-	scorecardPassed?: boolean;
-	deployStatus?: string;
-	publishStatus?: string;
-	sampleDataStatus?: string;
-	previousWorkflowProofFingerprint?: string;
-	previousArtifactFingerprint?: string;
-	previousWorkflowProofFingerprints?: string[];
-	previousArtifactFingerprints?: string[];
-	now?: Date | string;
-}
-
-export type ResolveIOAICoderWorkflowProofFreshness =
-	| 'fresh'
-	| 'same_as_previous'
-	| 'stale_artifact'
-	| 'missing'
-	| 'unknown';
-
-export interface ResolveIOAICoderWorkflowProofReadiness {
-	ready: boolean;
-	status: ResolveIOAICoderWorkflowProofReadinessStatus;
-	reason: string;
-	blockers: string[];
-	journeyContractValid: boolean;
-	primaryWorkflowId: string;
-	passedWorkflowRows: string[];
-	missingWorkflowRows: string[];
-	failedWorkflowRows: string[];
-	passedBusinessAssertions: string[];
-	routeOnly: boolean;
-	scorecardOnly: boolean;
-	sampleDataReady: boolean;
-	releaseBlockers: string[];
-	artifactPaths: string[];
-	workflowProofFingerprint: string;
-	artifactFingerprint: string;
-	proofFreshness: ResolveIOAICoderWorkflowProofFreshness;
-	nextAction: string;
-	evaluatedAt: string;
-}
-
-export type ResolveIOAICoderV6ContinuationAction =
-	| 'continue'
-	| 'retry_same_step'
-	| 'switch_to_repair'
-	| 'park'
-	| 'budget_stop'
-	| 'infra_retry'
-	| 'ready_to_publish';
-
-export type ResolveIOAICoderNextActionCostRisk =
-	| 'free_or_deterministic'
-	| 'small_model_or_qa'
-	| 'expensive_model'
-	| 'release_or_customer_send'
-	| 'manual_blocked';
-
-export type ResolveIOAICoderWorkflowReadinessStatus =
-	| 'journey_contract_required'
-	| 'journey_contract_repair_required'
-	| 'workflow_build_ready'
-	| 'workflow_qa_required'
-	| 'workflow_business_proof_ready'
-	| 'release_repair_required'
-	| 'infra_repair_only'
-	| 'compile_repair_only'
-	| 'collect_new_evidence'
-	| 'budget_stopped'
-	| 'parked';
-
-export type ResolveIOAICoderWorkflowReadinessGate =
-	| 'journey_contract'
-	| 'build'
-	| 'workflow_qa'
-	| 'release'
-	| 'infra'
-	| 'compile'
-	| 'evidence'
-	| 'manual';
-
-export type ResolveIOAICoderWorkflowProofCheckpointStatus =
-	| 'waiting_for_journey_contract'
-	| 'waiting_for_workflow_proof'
-	| 'waiting_for_new_evidence'
-	| 'waiting_for_release_gate'
-	| 'waiting_for_infra_or_compile'
-	| 'ready_to_continue';
-
-export interface ResolveIOAICoderWorkflowProofCheckpoint {
-	required: boolean;
-	status: ResolveIOAICoderWorkflowProofCheckpointStatus;
-	readinessStatus: ResolveIOAICoderWorkflowReadinessStatus;
-	nextGate: ResolveIOAICoderWorkflowReadinessGate;
-	startingFailureClass: string;
-	startingBlockerFingerprint: string;
-	startingEvidenceHash: string;
-	workflowProofFingerprint: string;
-	artifactFingerprint: string;
-	requiredEvidence: string[];
-	requiredResetEvidence: string[];
-	successRequiresWorkflowBusinessProof: boolean;
-	blocksProductRepairUntilJourneyContract: boolean;
-	blocksPublishUntilWorkflowProof: boolean;
-	blocksPublishUntilReleaseGate: boolean;
-	blocksWowUiUntilWorkflowProof: boolean;
-	nextAction: string;
-}
-
-export interface ResolveIOAICoderWorkflowReadiness {
-	status: ResolveIOAICoderWorkflowReadinessStatus;
-	nextGate: ResolveIOAICoderWorkflowReadinessGate;
-	nextLane: ResolveIOAICoderV6Lane;
-	nextStep: ResolveIOAICoderV6StepType;
-	nextCommand: string;
-	journeyContractReady: boolean;
-	workflowQaRowsReady: boolean;
-	businessProofReady: boolean;
-	routeOnlyBlocked: boolean;
-	releaseBlocked: boolean;
-	infraOnly: boolean;
-	compileOnly: boolean;
-	sameFailureParked: boolean;
-	canRunProductRepair: boolean;
-	canRunWorkflowQa: boolean;
-	canPublish: boolean;
-	canPolishWowUi: boolean;
-	requiresHumanDecision: boolean;
-	reason: string;
-	blockers: string[];
-	primaryWorkflowId: string;
-	activeWorkflowStep: string;
-	businessProofArtifacts: string[];
-	workflowProofCheckpoint: ResolveIOAICoderWorkflowProofCheckpoint;
-}
-
-export interface ResolveIOAICoderNextActionContract {
-	contractId: string;
-	action: ResolveIOAICoderV6ContinuationAction;
-	label: string;
-	primaryCommand: string;
-	lane: ResolveIOAICoderV6Lane;
-	stepType: ResolveIOAICoderV6StepType;
-	safeToAutoRun: boolean;
-	requiresHumanApproval: boolean;
-	canRunWithoutCodexMonitor: boolean;
-	codexFallbackRequired: boolean;
-	codexFallbackReason: string;
-	costRisk: ResolveIOAICoderNextActionCostRisk;
-	workflowFirstSatisfied: boolean;
-	decisionBasis: {
-		journeyContractReady: boolean;
-		workflowProofReady: boolean;
-		sampleDataReady: boolean;
-		releaseBlocked: boolean;
-		routeOnlyBlocked: boolean;
-		infraOnly: boolean;
-		compileOnly: boolean;
-		sameFailureParked: boolean;
-		canPublish: boolean;
-		canPolishWowUi: boolean;
-		workflowReadinessStatus: string;
-		workflowProofCheckpointStatus: string;
-		failureClass: string;
-		evidenceHash: string;
-		hotfixCommitRequired: boolean;
-		liveHotfixBlockedUntilCommit: boolean;
-	};
-	preconditions: string[];
-	expectedStateTransition: string;
-	successEvidence: string[];
-	requiredHotfixCommitProof: string[];
-	stopConditions: string[];
-	forbiddenActions: string[];
-	nextCommands: string[];
-	blockers: string[];
-	ownerFiles?: string[];
-	createdAt: string;
-}
-
-export interface ResolveIOAICoderV6SupervisorState {
-	version: 'v6';
-	runKind: ResolveIOAICoderV6RunKind;
-	status: 'active' | 'parked' | 'complete';
-	currentGoal: string;
-	approvedScope: string;
-	branchName: string;
-	activeLane: ResolveIOAICoderV6Lane;
-	activeStep: ResolveIOAICoderV6StepType;
-	activeBlocker: string;
-	lastGoodCheckpoint: string;
-	lastGoodCommit?: string;
-	testDeployStatus?: string;
-	liveDeployStatus?: string;
-	processLease?: {
-		runId?: string;
-		token?: string;
-		generation?: number;
-		workspace?: string;
-		lane?: string;
-	};
-	artifactLinks: string[];
-	updatedAt: string;
-}
-
-export interface ResolveIOAICoderV6StepRecord {
-	stepType: ResolveIOAICoderV6StepType;
-	outcome: ResolveIOAICoderV6Outcome;
-	lane: ResolveIOAICoderV6Lane;
-	model?: string;
-	threadKey?: string;
-	promptVersion?: string;
-	promptTokenEstimate?: number;
-	inputTokens?: number;
-	cachedInputTokens?: number;
-	outputTokens?: number;
-	runtimeMs?: number;
-	summary: string;
-	blocker?: string;
-	blockerFingerprint?: string;
-	failureClass?: string;
-	evidenceHash?: string;
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	nextAction?: ResolveIOAICoderV6ContinuationAction;
-	recordedAt: string;
-}
-
-export interface ResolveIOAICoderV6RunnerIncident {
-	incidentClass: string;
-	summary: string;
-	stepType?: ResolveIOAICoderV6StepType;
-	lane?: ResolveIOAICoderV6Lane;
-	blockerFingerprint?: string;
-	artifactPaths?: string[];
-	recordedAt: string;
-}
-
-export interface ResolveIOAICoderV6StateBundle {
-	aiCoderRunnerVersion: 'v6';
-	aiCoderV6SupervisorState: ResolveIOAICoderV6SupervisorState;
-	aiCoderV6LaneMemory: Record<ResolveIOAICoderV6Lane, ResolveIOAICoderV6LaneMemory>;
-	aiCoderV6WorkflowMemory: ResolveIOAICoderV6WorkflowMemory;
-	aiCoderV6StepHistory: ResolveIOAICoderV6StepRecord[];
-	aiCoderV6Budget: ResolveIOAICoderV6Budget;
-	aiCoderV6RunnerIncidents: ResolveIOAICoderV6RunnerIncident[];
-	aiCoderV6RecoveryPlan?: ResolveIOAIManagerRecoveryPlan;
-	aiCoderV6RecoveryCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
-	aiCoderV6RecoveryEvidenceProbe?: ResolveIOAIManagerRecoveryEvidenceProbe;
-	aiCoderV6RecoveryAction?: ResolveIOAIManagerRecoveryActionPacket;
-	aiCoderV6RecoveryDispatchHistory?: ResolveIOAIManagerRecoveryActionDispatchRecord[];
-	aiCoderV6RecoveryDirective?: ResolveIOAIManagerRecoveryExecutionDirective;
-	aiCoderV6WorkflowReadiness?: ResolveIOAICoderWorkflowReadiness;
-}
-
-export interface ResolveIOAICoderV6InitializeInput {
-	runKind: ResolveIOAICoderV6RunKind;
-	jobId: string;
-	appId?: string;
-	conversationId?: string;
-	title?: string;
-	description?: string;
-	approvedScopeRequirements?: string[];
-	branchName?: string;
-	journeyContractPath?: string;
-	defaultModel?: string;
-	laneThreadKeys?: Partial<Record<ResolveIOAICoderV6Lane, string>>;
-	processLease?: ResolveIOAICoderV6SupervisorState['processLease'];
-	now?: Date | string;
-	existing?: Partial<ResolveIOAICoderV6StateBundle>;
-}
-
-export interface ResolveIOAICoderV6StepInput {
-	stepType: ResolveIOAICoderV6StepType;
-	outcome: ResolveIOAICoderV6Outcome;
-	lane: ResolveIOAICoderV6Lane;
-	model?: string;
-	threadKey?: string;
-	promptVersion?: string;
-	promptTokenEstimate?: number;
-	inputTokens?: number;
-	cachedInputTokens?: number;
-	outputTokens?: number;
-	runtimeMs?: number;
-	summary?: string;
-	blocker?: string;
-	failureClass?: string;
-	evidenceHash?: string;
-	primaryWorkflowId?: string;
-	activeWorkflowStep?: string;
-	workflowQaRows?: ResolveIOAICoderV6WorkflowQaRow[];
-	completedWorkflowSteps?: string[];
-	blockedWorkflowStep?: string;
-	businessProofArtifacts?: string[];
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	activeQaRow?: ResolveIOAICoderV6LaneMemory['activeQaRow'];
-	nextAction?: ResolveIOAICoderV6ContinuationAction;
-	now?: Date | string;
-}
-
-export interface ResolveIOAICoderV6ContinuationDecision {
-	action: ResolveIOAICoderV6ContinuationAction;
-	reason: string;
-	nextLane: ResolveIOAICoderV6Lane;
-	nextStep: ResolveIOAICoderV6StepType;
-	repeatedNoProgressCount: number;
-	budgetExceeded: boolean;
-	workflowReadiness: ResolveIOAICoderWorkflowReadiness;
-	workflowProofCheckpoint: ResolveIOAICoderWorkflowProofCheckpoint;
-	nextActionContract: ResolveIOAICoderNextActionContract;
-	recoveryPlan: ResolveIOAIManagerRecoveryPlan;
-	recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
-	recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
-	recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
-}
-
-const LANES: ResolveIOAICoderV6Lane[] = ['intake', 'plan', 'build', 'qa', 'repair', 'review', 'publish'];
-
-function isoNow(value?: Date | string): string {
-	if (value instanceof Date) {
-		return value.toISOString();
-	}
-	const parsed = value ? new Date(value) : new Date();
-	if (Number.isFinite(parsed.getTime())) {
-		return parsed.toISOString();
-	}
-	return new Date().toISOString();
-}
-
-function cleanText(value: any, max = 2000): string {
-	return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
-}
-
-function cleanList(values: any, limit = 20, max = 500): string[] {
-	if (!Array.isArray(values)) {
-		return [];
-	}
-	const result: string[] = [];
-	for (const value of values) {
-		const normalized = cleanText(value, max);
-		if (normalized && !result.includes(normalized)) {
-			result.push(normalized);
-		}
-		if (result.length >= limit) {
-			break;
-		}
-	}
-	return result;
-}
-
-function readField(source: any, keys: string[]): any {
-	if (!source || typeof source !== 'object') {
-		return undefined;
-	}
-	for (const key of keys) {
-		if (source[key] !== undefined && source[key] !== null) {
-			return source[key];
-		}
-	}
-	return undefined;
-}
-
-function cleanField(source: any, keys: string[], max = 500): string {
-	return cleanText(readField(source, keys), max);
-}
-
-function concatFields(source: any, keys: string[], maxEach = 500): string {
-	if (!source || typeof source !== 'object') {
-		return '';
-	}
-	return keys
-		.map((key) => cleanText(source[key], maxEach))
-		.filter(Boolean)
-		.join(' ');
-}
-
-function asArray(value: any): any[] {
-	if (!Array.isArray(value)) {
-		return [];
-	}
-	return value;
-}
-
-function stripJsonComments(value: string): string {
-	let output = '';
-	let inString = false;
-	let escaped = false;
-	for (let index = 0; index < value.length; index += 1) {
-		const char = value[index];
-		const next = value[index + 1];
-		if (inString) {
-			output += char;
-			if (escaped) {
-				escaped = false;
-			}
-			else if (char === '\\') {
-				escaped = true;
-			}
-			else if (char === '"') {
-				inString = false;
-			}
-			continue;
-		}
-		if (char === '"') {
-			inString = true;
-			output += char;
-			continue;
-		}
-		if (char === '/' && next === '/') {
-			while (index < value.length && value[index] !== '\n') {
-				index += 1;
-			}
-			output += '\n';
-			continue;
-		}
-		if (char === '/' && next === '*') {
-			index += 2;
-			while (index < value.length && !(value[index] === '*' && value[index + 1] === '/')) {
-				index += 1;
-			}
-			index += 1;
-			continue;
-		}
-		output += char;
-	}
-	return output;
-}
-
-function parseJsonObject(value: string): Record<string, any> | null {
-	try {
-		const parsed = JSON.parse(stripJsonComments(value));
-		return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
-	}
-	catch {
-		return null;
-	}
-}
-
-export function extractResolveIOAICoderJourneyContractFromMarkdown(content: string | null | undefined): Record<string, any> | null {
-	const normalized = String(content || '').replace(/\r\n/g, '\n');
-	const sectionMatch = normalized.match(/##\s*journey_contract[\s\S]*?```json\s*([\s\S]*?)```/i)
-		|| normalized.match(/##\s*journey_contract[\s\S]*?```\s*([\s\S]*?)```/i);
-	if (sectionMatch?.[1]) {
-		return parseJsonObject(sectionMatch[1].trim());
-	}
-	const fencedMatch = normalized.match(/```json\s*([\s\S]*?)```/i);
-	if (fencedMatch?.[1]) {
-		return parseJsonObject(fencedMatch[1].trim());
-	}
-	const objectMatch = normalized.match(/\{\s*"app_archetype"[\s\S]*\}\s*$/m);
-	if (objectMatch?.[0]) {
-		return parseJsonObject(objectMatch[0].trim());
-	}
-	return null;
-}
-
-function looksLikeAbsoluteRoute(value: string): boolean {
-	return value.startsWith('/') && !/\s/.test(value);
-}
-
-function looksPlaceholder(value: string): boolean {
-	return /\b(tbd|todo|placeholder|generic crud|crud-only|lorem ipsum|add details|fill in|coming soon)\b/i.test(value || '');
-}
-
-function isNavigationOnlyAction(source: any): boolean {
-	const effect = cleanField(source, ['effect', 'outcome', 'state_change', 'expected_state_transition', 'expected_next_state'], 500).toLowerCase();
-	const implementation = cleanField(source, [
-		'method_or_calculation',
-		'server_method_or_publication',
-		'local_calculation_path',
-		'action_implementation',
-		'calculation_path',
-		'data_mutation',
-		'mutation',
-		'persisted_result'
-	], 500);
-	if (implementation) {
-		return false;
-	}
-	const actionType = cleanField(source, ['action_type', 'type', 'kind'], 120).toLowerCase();
-	const actionText = [
-		cleanField(source, ['action', 'visible_cta', 'cta', 'label'], 300),
-		cleanField(source, ['next_step_destination', 'next_step', 'destination'], 300)
-	].join(' ').toLowerCase();
-	const navigationSignals = /\b(navigate|go to|open|view|link|route|page)\b/.test(actionText)
-		|| /^(?:link|nav|navigation|route)$/i.test(actionType);
-	const productiveEffect = /\b(save|saved|create|created|update|updated|calculate|calculated|optimize|optimized|import|export|report|persist|queued|submitted|validated|generated|compare|recommendation|complete|completed)\b/.test(effect);
-	return navigationSignals && !productiveEffect;
-}
-
-function addJourneyIssue(
-	issues: ResolveIOAICoderJourneyContractValidationIssue[],
-	code: string,
-	path: string,
-	message: string,
-	severity: 'error' | 'warning' = 'error'
-): void {
-	issues.push({ code, path, message, severity });
-}
-
-function normalizeWorkflowStepPosition(step: any, index: number, total: number): string {
-	const explicit = cleanField(step, ['position', 'phase', 'order_role'], 60).toLowerCase();
-	if (explicit) {
-		return explicit;
-	}
-	if (index === 0) {
-		return 'first';
-	}
-	if (index === total - 1) {
-		return 'last';
-	}
-	return 'next';
-}
-
-function normalizeJourneyReferenceKey(value: any): string {
-	return cleanText(value, 160).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
-}
-
-function normalizeJourneyRouteKey(value: any): string {
-	const raw = cleanText(value, 240);
-	if (!raw) {
-		return '';
-	}
-	const route = raw.split(/[?#]/)[0].replace(/\/+$/g, '') || '/';
-	return route.toLowerCase();
-}
-
-function normalizeJourneyActionText(value: any): string {
-	return cleanText(value, 1000).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
-}
-
-function buildWorkflowStepId(step: any, index: number): string {
-	return cleanField(step, ['id', 'step_id', 'key'], 120)
-		|| cleanField(step, ['label', 'title', 'visible_cta'], 120).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
-		|| `step-${index + 1}`;
-}
-
-function workflowStepVisibleAction(step: any): string {
-	return cleanField(step, ['visible_cta', 'cta', 'label', 'action', 'embedded_hub_action', 'hub_action'], 500);
-}
-
-function journeySourceVisibleAction(source: any): string {
-	return concatFields(source, [
-		'visible_cta',
-		'cta',
-		'label',
-		'action',
-		'browser_steps',
-		'expected_dom_or_data_proof',
-		'proof',
-		'assertion',
-		'expected_result'
-	], 700);
-}
-
-function actionTextReferencesLabel(actionText: string, label: string): boolean {
-	const action = normalizeJourneyActionText(actionText);
-	const expected = normalizeJourneyActionText(label);
-	if (!action || !expected || expected.length < 4) {
-		return false;
-	}
-	if (action === expected || action.includes(expected) || expected.includes(action)) {
-		return true;
-	}
-	const actionTokens = new Set(action.split(/\s+/).filter((token) => token.length > 2));
-	const expectedTokens = expected.split(/\s+/).filter((token) => token.length > 2);
-	if (!expectedTokens.length) {
-		return false;
-	}
-	const matched = expectedTokens.filter((token) => actionTokens.has(token)).length;
-	return matched >= Math.min(expectedTokens.length, Math.max(2, Math.ceil(expectedTokens.length * 0.67)));
-}
-
-function collectJourneyReferenceKeys(source: any): string[] {
-	if (!source || typeof source !== 'object') {
-		return [];
-	}
-	const values: any[] = [];
-	for (const key of [
-		'workflow_step_id',
-		'workflowStepId',
-		'workflow_step_ids',
-		'workflowStepIds',
-		'covers_workflow_step_id',
-		'coversWorkflowStepId',
-		'covers_workflow_step_ids',
-		'coversWorkflowStepIds',
-		'north_star_step_id',
-		'northStarStepId',
-		'step_ref',
-		'stepRef'
-	]) {
-		const value = source[key];
-		if (Array.isArray(value)) {
-			values.push(...value);
-		}
-		else if (value !== undefined && value !== null) {
-			values.push(value);
-		}
-	}
-	return Array.from(new Set(values.map(normalizeJourneyReferenceKey).filter(Boolean))).slice(0, 20);
-}
-
-function journeySourceMapsToWorkflowStep(source: any, step: any, index: number): boolean {
-	const stepId = normalizeJourneyReferenceKey(buildWorkflowStepId(step, index));
-	const refs = collectJourneyReferenceKeys(source);
-	if (stepId && refs.includes(stepId)) {
-		return true;
-	}
-	const sourceRoute = normalizeJourneyRouteKey(cleanField(source, ['route', 'screen_route', 'path'], 240));
-	const stepRoute = normalizeJourneyRouteKey(cleanField(step, ['route'], 240));
-	if (!sourceRoute || !stepRoute || sourceRoute !== stepRoute) {
-		return false;
-	}
-	return actionTextReferencesLabel(journeySourceVisibleAction(source), workflowStepVisibleAction(step));
-}
-
-function normalizeWorkflowProofKind(source: any, fallbackText = ''): string {
-	const explicit = cleanField(source, ['proof_kind', 'proofKind', 'qa_proof_kind', 'qaProofKind', 'type', 'kind'], 120).toLowerCase().replace(/[\s-]+/g, '_');
-	if (explicit) {
-		return explicit;
-	}
-	const text = cleanText([
-		fallbackText,
-		concatFields(source, ['id', 'step_id', 'stepId', 'action', 'browser_steps', 'expected_dom_or_data_proof', 'proof', 'expected_result', 'viewport'], 700)
-	].filter(Boolean).join(' '), 1800).toLowerCase();
-	if (/\b(mobile|390x844|viewport)\b/.test(text)) {
-		return 'mobile';
-	}
-	if (/\b(export|report|pdf|download)\b/.test(text)) {
-		return 'report_export';
-	}
-	if (/\b(complete|saved|save|result|recommendation|calculated|optimized|final)\b/.test(text)) {
-		return 'workflow_completion';
-	}
-	if (/\b(sample|seeded|non[-\s]?empty|kpi|table|chart|record|row)\b/.test(text)) {
-		return 'non_empty_data';
-	}
-	if (/\b(empty|error|recovery|invalid)\b/.test(text)) {
-		return 'recovery';
-	}
-	if (/\b(hub|dashboard|command center|next up|queue)\b/.test(text)) {
-		return 'hub_action';
-	}
-	return 'business_workflow';
-}
-
-function normalizeWorkflowQaCoverageTag(value: any): string {
-	const normalized = cleanText(value, 120).toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
-	if (!normalized) {
-		return '';
-	}
-	const aliases: Record<string, string> = {
-		auth: 'login',
-		authentication: 'login',
-		authenticated_session: 'login',
-		signed_in: 'login',
-		dashboard: 'hub_action',
-		dashboard_hub: 'hub_action',
-		hub: 'hub_action',
-		primary_hub_action: 'hub_action',
-		command_center: 'hub_action',
-		embedded_hub_action: 'hub_action',
-		completion: 'workflow_completion',
-		business_completion: 'workflow_completion',
-		final_result: 'workflow_completion',
-		result: 'workflow_completion',
-		saved_result: 'workflow_completion',
-		saved_output: 'workflow_completion',
-		calculated_result: 'workflow_completion',
-		export: 'report_export',
-		report: 'report_export',
-		pdf_export: 'report_export',
-		report_download: 'report_export',
-		sample_data: 'non_empty_data',
-		seed_data: 'non_empty_data',
-		seeded_data: 'non_empty_data',
-		non_empty: 'non_empty_data',
-		nonempty: 'non_empty_data',
-		kpi_data: 'non_empty_data',
-		responsive: 'mobile',
-		responsive_mobile: 'mobile',
-		mobile_viewport: 'mobile',
-		phone: 'mobile',
-		empty_state: 'recovery',
-		error_state: 'recovery',
-		error_recovery: 'recovery',
-		empty_error_recovery: 'recovery',
-		invalid_input_recovery: 'recovery'
-	};
-	return aliases[normalized] || normalized;
-}
-
-function appendWorkflowQaCoverageValues(target: string[], value: any): void {
-	if (Array.isArray(value)) {
-		value.forEach((entry) => appendWorkflowQaCoverageValues(target, entry));
-		return;
-	}
-	if (value && typeof value === 'object') {
-		for (const [key, entry] of Object.entries(value)) {
-			if (entry === true) {
-				target.push(normalizeWorkflowQaCoverageTag(key));
-			}
-			else if (typeof entry === 'string' || Array.isArray(entry) || (entry && typeof entry === 'object')) {
-				appendWorkflowQaCoverageValues(target, entry);
-			}
-		}
-		return;
-	}
-	const text = cleanText(value, 500);
-	if (!text) {
-		return;
-	}
-	for (const entry of text.split(/[|,;]/)) {
-		target.push(normalizeWorkflowQaCoverageTag(entry));
-	}
-}
-
-function normalizeWorkflowQaCoverageTags(source: any, options: { includeProofKind?: boolean } = {}): string[] {
-	const tags: string[] = [];
-	for (const key of [
-		'coverage',
-		'coverage_tags',
-		'coverageTags',
-		'qa_coverage',
-		'qaCoverage',
-		'required_coverage',
-		'requiredCoverage',
-		'business_coverage',
-		'businessCoverage'
-	]) {
-		appendWorkflowQaCoverageValues(tags, readField(source, [key]));
-	}
-	if (options.includeProofKind !== false) {
-		for (const key of ['proof_kind', 'proofKind', 'proof_kinds', 'proofKinds']) {
-			appendWorkflowQaCoverageValues(tags, readField(source, [key]));
-		}
-	}
-	return Array.from(new Set(tags.filter(Boolean))).slice(0, 20);
-}
-
-function buildWorkflowQaRequiredArtifacts(source: any, proofKind: string): string[] {
-	const explicit = cleanList(readField(source, ['required_artifacts', 'requiredArtifacts', 'proof_artifacts', 'artifact_expectation', 'artifacts_required']), 12, 180);
-	const defaultsByKind: Record<string, string[]> = {
-		login: ['authenticated session proof', 'post-login hub route proof'],
-		hub_action: ['hub screenshot or DOM snapshot', 'next action state proof'],
-		workflow_completion: ['before/action/after trace', 'saved or calculated output proof', 'business assertion artifact'],
-		report_export: ['generated report/export artifact', 'export control proof', 'saved output row proof'],
-		non_empty_data: ['seeded data snapshot', 'non-empty KPI/table/chart proof'],
-		mobile: ['mobile viewport screenshot or trace', 'responsive workflow action proof'],
-		recovery: ['empty/error state screenshot or trace', 'recovery action proof'],
-		business_workflow: ['browser trace or screenshot', 'DOM/data assertion artifact']
-	};
-	return Array.from(new Set([
-		...explicit,
-		...(defaultsByKind[proofKind] || defaultsByKind.business_workflow)
-	])).slice(0, 16);
-}
-
-function buildWorkflowQaStateTransition(source: any, fallback: Partial<ResolveIOAICoderV6WorkflowQaRow> = {}): ResolveIOAICoderV6WorkflowQaRow['stateTransition'] {
-	return {
-		before: cleanField(source, ['before', 'setup_state', 'initial_state'], 700) || fallback.expectedState,
-		action: cleanField(source, ['action', 'browser_steps', 'visible_cta', 'cta'], 700) || fallback.action,
-		after: cleanField(source, ['after', 'expected_state', 'expected_result', 'expected_dom_or_data_proof', 'proof'], 700) || fallback.assertion || fallback.expectedState,
-		assertion: cleanField(source, ['assertion', 'expected_dom_or_data_proof', 'proof', 'expected_result'], 700) || fallback.assertion
-	};
-}
-
-export function buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(input: any): ResolveIOAICoderV6WorkflowQaRow[] {
-	const contract = typeof input === 'string'
-		? extractResolveIOAICoderJourneyContractFromMarkdown(input)
-		: (input && typeof input === 'object' && !Array.isArray(input) ? input : null);
-	if (!contract) {
-		return [];
-	}
-	const workflowId = cleanField(contract, ['primary_workflow_id', 'workflow_id', 'id'], 160) || 'north-star';
-	const rows: ResolveIOAICoderV6WorkflowQaRow[] = [];
-	const qaAssertions = asArray(contract.qa_assertions);
-	qaAssertions.forEach((assertion, index) => {
-		if (!assertion || typeof assertion !== 'object' || Array.isArray(assertion)) {
-			return;
-		}
-		const route = cleanField(assertion, ['route', 'screen_route', 'path'], 240);
-		const action = cleanField(assertion, ['action', 'browser_steps', 'cta', 'visible_cta'], 500);
-		const expectedState = cleanField(assertion, ['expected_state', 'expected_result', 'expected_dom_or_data_proof', 'proof'], 500);
-		const assertionText = cleanField(assertion, ['assertion', 'expected_dom_or_data_proof', 'proof', 'expected_result'], 700);
-		if (!route && !action && !assertionText) {
-			return;
-		}
-		const proofKind = normalizeWorkflowProofKind(assertion);
-		const coverageTags = normalizeWorkflowQaCoverageTags(assertion);
-		const rowBase = {
-			route: route || undefined,
-			action: action || undefined,
-			assertion: assertionText || undefined,
-			expectedState: expectedState || undefined
-		};
-		rows.push({
-			index: cleanNumber(readField(assertion, ['index', 'order'])) || index + 1,
-			workflowId: cleanField(assertion, ['workflow_id', 'workflowId'], 160) || workflowId,
-			workflowStepId: cleanField(assertion, [
-				'workflow_step_id',
-				'workflowStepId',
-				'covers_workflow_step_id',
-				'coversWorkflowStepId',
-				'north_star_step_id',
-				'northStarStepId'
-			], 160) || undefined,
-			workflowStepIds: collectJourneyReferenceKeys(assertion),
-			stepId: cleanField(assertion, ['step_id', 'stepId', 'id'], 160) || `qa-${index + 1}`,
-			...rowBase,
-			expectedOutput: cleanField(assertion, ['expected_output', 'expectedOutput', 'saved_output', 'calculated_output', 'report_output'], 700) || expectedState || assertionText || undefined,
-			proofKind,
-			coverageTags,
-			acceptanceGate: 'aiqa_business_assertion',
-			requiredArtifacts: buildWorkflowQaRequiredArtifacts(assertion, proofKind),
-			stateTransition: buildWorkflowQaStateTransition(assertion, rowBase),
-			status: cleanField(assertion, ['status'], 120) || undefined,
-			artifactPaths: cleanList(readField(assertion, ['artifact_paths', 'artifactPaths']), 20, 500)
-		});
-	});
-	if (rows.length) {
-		return rows.slice(0, 80);
-	}
-	asArray(contract.north_star_workflow).forEach((step, index, workflow) => {
-		if (!step || typeof step !== 'object' || Array.isArray(step)) {
-			return;
-		}
-		const proofKind = normalizeWorkflowProofKind(step, normalizeWorkflowStepPosition(step, index, workflow.length));
-		const rowBase = {
-			route: cleanField(step, ['route'], 240) || undefined,
-			action: cleanField(step, ['visible_cta', 'action', 'cta'], 500) || undefined,
-			assertion: cleanField(step, ['success_confirmation', 'expected_state_transition', 'final_result'], 700) || undefined,
-			expectedState: cleanField(step, ['expected_state_transition', 'success_confirmation', 'final_result'], 500) || undefined
-		};
-		rows.push({
-			index: index + 1,
-			workflowId,
-			workflowStepId: buildWorkflowStepId(step, index),
-			workflowStepIds: [buildWorkflowStepId(step, index)],
-			stepId: buildWorkflowStepId(step, index),
-			...rowBase,
-			expectedOutput: cleanField(step, ['final_result', 'saved_exported_reported_result', 'completion_result', 'expected_state_transition'], 700) || rowBase.expectedState || rowBase.assertion,
-			proofKind,
-			coverageTags: Array.from(new Set([proofKind, normalizeWorkflowStepPosition(step, index, workflow.length)].map(normalizeWorkflowQaCoverageTag).filter(Boolean))),
-			acceptanceGate: 'aiqa_business_assertion',
-			requiredArtifacts: buildWorkflowQaRequiredArtifacts(step, proofKind),
-			stateTransition: buildWorkflowQaStateTransition(step, rowBase),
-			status: undefined,
-			artifactPaths: []
-		});
-		void workflow;
-	});
-	return rows.slice(0, 80);
-}
-
-export function validateResolveIOAICoderJourneyContract(input: any, options: {
-	pathLabel?: string;
-	requireMarkdownEnvelope?: boolean;
-} = {}): ResolveIOAICoderJourneyContractValidationResult {
-	const pathLabel = cleanText(options.pathLabel || 'docs/APP_JOURNEY_CONTRACT.md', 240) || 'docs/APP_JOURNEY_CONTRACT.md';
-	const issues: ResolveIOAICoderJourneyContractValidationIssue[] = [];
-	let contract: Record<string, any> | null = null;
-	if (typeof input === 'string') {
-		const normalized = input.replace(/\r\n/g, '\n');
-		if (!normalized.trim()) {
-			addJourneyIssue(issues, 'missing_contract', pathLabel, `${pathLabel}: missing app journey contract.`);
-			return { valid: false, contract: null, issues, workflowQaRows: [], primaryWorkflowId: '' };
-		}
-		if (options.requireMarkdownEnvelope !== false && !/^\s*#\s+App Journey Contract/im.test(normalized)) {
-			addJourneyIssue(issues, 'missing_heading', pathLabel, `${pathLabel}: missing "# App Journey Contract" heading.`);
-		}
-		if (options.requireMarkdownEnvelope !== false && !/##\s*journey_contract/i.test(normalized)) {
-			addJourneyIssue(issues, 'missing_json_section', pathLabel, `${pathLabel}: missing "## journey_contract" JSON section.`);
-		}
-		if (looksPlaceholder(normalized)) {
-			addJourneyIssue(issues, 'placeholder_text', pathLabel, `${pathLabel}: contains placeholder or generic journey text.`);
-		}
-		contract = extractResolveIOAICoderJourneyContractFromMarkdown(normalized);
-	}
-	else if (input && typeof input === 'object' && !Array.isArray(input)) {
-		contract = input;
-	}
-	if (!contract) {
-		addJourneyIssue(issues, 'invalid_json', pathLabel, `${pathLabel}: journey_contract JSON is missing or invalid.`);
-		return { valid: false, contract: null, issues, workflowQaRows: [], primaryWorkflowId: '' };
-	}
-	const requiredKeys = [
-		'app_archetype',
-		'primary_actor',
-		'primary_goal',
-		'first_screen',
-		'north_star_workflow',
-		'secondary_workflows',
-		'screen_sequence',
-		'data_story',
-		'completion_states',
-		'qa_assertions'
-	];
-	for (const key of requiredKeys) {
-		if (!(key in contract)) {
-			addJourneyIssue(issues, 'missing_key', `${pathLabel}.journey_contract.${key}`, `${pathLabel}: journey_contract missing key "${key}".`);
-		}
-	}
-	for (const key of ['app_archetype', 'primary_actor', 'primary_goal']) {
-		const value = cleanText(contract[key], 500);
-		if (value.length < 4) {
-			addJourneyIssue(issues, 'empty_core_field', `${pathLabel}.journey_contract.${key}`, `${pathLabel}: journey_contract.${key} must be non-empty.`);
-		}
-		if (looksPlaceholder(value)) {
-			addJourneyIssue(issues, 'placeholder_core_field', `${pathLabel}.journey_contract.${key}`, `${pathLabel}: journey_contract.${key} is placeholder text.`);
-		}
-	}
-	const firstScreen = contract.first_screen;
-	if (!firstScreen || typeof firstScreen !== 'object' || Array.isArray(firstScreen)) {
-		addJourneyIssue(issues, 'invalid_first_screen', `${pathLabel}.journey_contract.first_screen`, `${pathLabel}: first_screen must be an object.`);
-	}
-	else {
-		const route = cleanField(firstScreen, ['route'], 240);
-		for (const [label, keys] of [
-			['route', ['route']],
-			['purpose', ['purpose', 'screen_purpose']],
-			['visible_cta', ['visible_cta', 'cta', 'primary_cta']],
-			['next_step', ['next_step', 'next_step_destination', 'expected_next_state']]
-		] as Array<[string, string[]]>) {
-			if (cleanField(firstScreen, keys, 500).length < 4) {
-				addJourneyIssue(issues, 'incomplete_first_screen', `${pathLabel}.journey_contract.first_screen.${label}`, `${pathLabel}: first_screen.${label} must be non-empty.`);
-			}
-		}
-		if (route && !looksLikeAbsoluteRoute(route)) {
-			addJourneyIssue(issues, 'relative_first_screen_route', `${pathLabel}.journey_contract.first_screen.route`, `${pathLabel}: first_screen.route must be an absolute app route.`);
-		}
-	}
-	const workflow = asArray(contract.north_star_workflow);
-	if (workflow.length < 3) {
-		addJourneyIssue(issues, 'workflow_too_short', `${pathLabel}.journey_contract.north_star_workflow`, `${pathLabel}: north_star_workflow must include at least first, next, and last steps.`);
-	}
-	const positions = new Set(workflow.map((step: any, index: number) => normalizeWorkflowStepPosition(step, index, workflow.length)));
-	for (const requiredPosition of ['first', 'next', 'last']) {
-		if (!positions.has(requiredPosition)) {
-			addJourneyIssue(issues, 'missing_workflow_position', `${pathLabel}.journey_contract.north_star_workflow`, `${pathLabel}: north_star_workflow missing position "${requiredPosition}".`);
-		}
-	}
-	workflow.forEach((step: any, index: number) => {
-		const stepPath = `${pathLabel}.journey_contract.north_star_workflow[${index}]`;
-		if (!step || typeof step !== 'object' || Array.isArray(step)) {
-			addJourneyIssue(issues, 'invalid_workflow_step', stepPath, `${pathLabel}: north_star_workflow[${index}] must be an object.`);
-			return;
-		}
-		const position = normalizeWorkflowStepPosition(step, index, workflow.length);
-		const route = cleanField(step, ['route'], 240);
-		const embeddedAction = cleanField(step, ['embedded_hub_action', 'hub_action'], 240);
-		const implementation = cleanField(step, [
-			'method_or_calculation',
-			'server_method_or_publication',
-			'local_calculation_path',
-			'action_implementation',
-			'calculation_path',
-			'data_mutation',
-			'mutation',
-			'persisted_result'
-		], 500);
-		const requiredStepFields: Array<[string, string[]]> = [
-			['position', ['position']],
-			['visible_cta', ['visible_cta', 'cta', 'label']],
-			['data_input_or_selection', ['data_input_or_selection', 'data_input', 'selection', 'input']],
-			['expected_state_transition', ['expected_state_transition', 'expected_next_state', 'state_change']],
-			['success_confirmation', ['success_confirmation', 'confirmation', 'success_message']],
-			['next_step_destination', ['next_step_destination', 'next_step', 'destination']]
-		];
-		for (const [fieldName, keys] of requiredStepFields) {
-			if (fieldName === 'next_step_destination' && position === 'last') {
-				continue;
-			}
-			if (cleanField(step, keys, 500).length < 3) {
-				addJourneyIssue(issues, 'incomplete_workflow_step', `${stepPath}.${fieldName}`, `${pathLabel}: north_star_workflow[${index}].${fieldName} must be non-empty.`);
-			}
-		}
-		if (!route && !embeddedAction) {
-			addJourneyIssue(issues, 'workflow_step_missing_route_or_hub_action', stepPath, `${pathLabel}: north_star_workflow[${index}] must specify a route or embedded hub action.`);
-		}
-		if (route && !looksLikeAbsoluteRoute(route)) {
-			addJourneyIssue(issues, 'relative_workflow_route', `${stepPath}.route`, `${pathLabel}: north_star_workflow[${index}].route must be an absolute app route.`);
-		}
-		if (!implementation) {
-			addJourneyIssue(issues, 'workflow_step_missing_implementation', stepPath, `${pathLabel}: north_star_workflow[${index}] must map the CTA to a server method, publication, local calculation, persisted mutation, or export/report action.`);
-		}
-		if (isNavigationOnlyAction(step)) {
-			addJourneyIssue(issues, 'navigation_only_workflow_step', stepPath, `${pathLabel}: north_star_workflow[${index}] appears to be navigation-only instead of advancing state.`);
-		}
-		if (position === 'last' && cleanField(step, ['final_result', 'saved_exported_reported_result', 'completion_result'], 700).length < 8) {
-			addJourneyIssue(issues, 'last_step_missing_final_result', `${stepPath}.final_result`, `${pathLabel}: last workflow step must define the saved, exported, reported, or calculated final result.`);
-		}
-	});
-	const secondaryWorkflows = asArray(contract.secondary_workflows);
-	if (secondaryWorkflows.length < 3) {
-		addJourneyIssue(issues, 'missing_secondary_workflows', `${pathLabel}.journey_contract.secondary_workflows`, `${pathLabel}: secondary_workflows must include setup, manage, report/export, settings/secrets, or recovery coverage.`);
-	}
-	const screenSequence = asArray(contract.screen_sequence);
-	if (screenSequence.length < Math.min(3, Math.max(workflow.length, 3))) {
-		addJourneyIssue(issues, 'screen_sequence_too_short', `${pathLabel}.journey_contract.screen_sequence`, `${pathLabel}: screen_sequence must map workflow steps to routes, CTAs, data, and next state.`);
-	}
-	screenSequence.forEach((screen: any, index: number) => {
-		const screenPath = `${pathLabel}.journey_contract.screen_sequence[${index}]`;
-		if (!screen || typeof screen !== 'object' || Array.isArray(screen)) {
-			addJourneyIssue(issues, 'invalid_screen_sequence_row', screenPath, `${pathLabel}: screen_sequence[${index}] must be an object.`);
-			return;
-		}
-		for (const [fieldName, keys] of [
-			['route', ['route']],
-			['screen_purpose', ['screen_purpose', 'purpose']],
-			['visible_cta', ['visible_cta', 'cta']],
-			['expected_next_state', ['expected_next_state', 'expected_state_transition']],
-			['data_shown', ['data_shown', 'data', 'records_shown']]
-		] as Array<[string, string[]]>) {
-			if (cleanField(screen, keys, 500).length < 3) {
-				addJourneyIssue(issues, 'incomplete_screen_sequence_row', `${screenPath}.${fieldName}`, `${pathLabel}: screen_sequence[${index}].${fieldName} must be non-empty.`);
-			}
-		}
-		const route = cleanField(screen, ['route'], 240);
-		if (route && !looksLikeAbsoluteRoute(route)) {
-			addJourneyIssue(issues, 'relative_screen_route', `${screenPath}.route`, `${pathLabel}: screen_sequence[${index}].route must be an absolute app route.`);
-		}
-		if (isNavigationOnlyAction(screen)) {
-			addJourneyIssue(issues, 'navigation_only_screen_action', screenPath, `${pathLabel}: screen_sequence[${index}] CTA appears to navigate without changing workflow state.`);
-		}
-		if (workflow.length && !workflow.some((step: any, workflowIndex: number) => journeySourceMapsToWorkflowStep(screen, step, workflowIndex))) {
-			addJourneyIssue(issues, 'screen_sequence_unmapped_to_workflow', screenPath, `${pathLabel}: screen_sequence[${index}] must reference a north_star_workflow step by workflow_step_id or match that step's route and CTA.`);
-		}
-	});
-	workflow.forEach((step: any, index: number) => {
-		if (!step || typeof step !== 'object' || Array.isArray(step)) {
-			return;
-		}
-		const stepPath = `${pathLabel}.journey_contract.north_star_workflow[${index}]`;
-		const matchingScreens = screenSequence.filter((screen: any) => journeySourceMapsToWorkflowStep(screen, step, index));
-		if (!matchingScreens.length) {
-			addJourneyIssue(issues, 'workflow_step_missing_screen_mapping', stepPath, `${pathLabel}: north_star_workflow[${index}] must have a matching screen_sequence row with the same step id or route/CTA mapping.`);
-		}
-	});
-	const firstScreenRoute = cleanField(firstScreen, ['route'], 240);
-	const hubScreens = screenSequence.filter((screen: any) => {
-		const route = cleanField(screen, ['route'], 240);
-		return route === firstScreenRoute || /hub|dashboard/i.test(route);
-	});
-	const hubHasEmbeddedAction = hubScreens.some((screen: any) => {
-		const text = [
-			cleanField(screen, ['embedded_action', 'hub_action', 'action'], 500),
-			cleanField(screen, ['method_or_calculation', 'server_method_or_publication', 'local_calculation_path', 'action_implementation'], 500),
-			cleanField(screen, ['expected_next_state', 'expected_state_transition'], 500)
-		].join(' ');
-		return text.trim().length >= 8 && !isNavigationOnlyAction(screen);
-	});
-	if (!hubHasEmbeddedAction) {
-		addJourneyIssue(issues, 'hub_missing_embedded_action', `${pathLabel}.journey_contract.screen_sequence`, `${pathLabel}: dashboard hub/first screen must embed at least one primary workflow action instead of acting as a link farm.`);
-	}
-	const dataStory = contract.data_story;
-	if (!dataStory || typeof dataStory !== 'object' || Array.isArray(dataStory)) {
-		addJourneyIssue(issues, 'invalid_data_story', `${pathLabel}.journey_contract.data_story`, `${pathLabel}: data_story must be an object.`);
-	}
-	else {
-		if (cleanField(dataStory, ['seeded_scenario', 'scenario'], 800).length < 12) {
-			addJourneyIssue(issues, 'missing_seeded_scenario', `${pathLabel}.journey_contract.data_story.seeded_scenario`, `${pathLabel}: data_story.seeded_scenario must describe the launch sample scenario.`);
-		}
-		if (!asArray(readField(dataStory, ['records', 'seed_records'])).length) {
-			addJourneyIssue(issues, 'missing_seed_records', `${pathLabel}.journey_contract.data_story.records`, `${pathLabel}: data_story.records must list seeded records.`);
-		}
-		if (!asArray(readField(dataStory, ['relationships', 'record_relationships'])).length) {
-			addJourneyIssue(issues, 'missing_seed_relationships', `${pathLabel}.journey_contract.data_story.relationships`, `${pathLabel}: data_story.relationships must list seeded data relationships.`);
-		}
-		if (asArray(readField(dataStory, ['non_empty_states', 'non_empty_dashboard_states'])).length < 2) {
-			addJourneyIssue(issues, 'missing_non_empty_states', `${pathLabel}.journey_contract.data_story.non_empty_states`, `${pathLabel}: data_story.non_empty_states must list non-empty dashboard, workflow, or report states.`);
-		}
-	}
-	if (asArray(contract.completion_states).length < 2) {
-		addJourneyIssue(issues, 'missing_completion_states', `${pathLabel}.journey_contract.completion_states`, `${pathLabel}: completion_states must define what done looks like to the user.`);
-	}
-	const qaAssertions = asArray(contract.qa_assertions);
-	if (qaAssertions.length < 5) {
-		addJourneyIssue(issues, 'qa_assertions_too_short', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions must include login, hub action, workflow completion, sample data, and mobile proof.`);
-	}
-	const workflowStepsWithQa = new Set<string>();
-	let hasMobileQa = false;
-	let hasRecoveryQa = false;
-	let hasCompletionQa = false;
-	let hasNonEmptyQa = false;
-	let hasLoginQa = false;
-	let hasHubActionQa = false;
-	qaAssertions.forEach((assertion: any, index: number) => {
-		const qaPath = `${pathLabel}.journey_contract.qa_assertions[${index}]`;
-		if (!assertion || typeof assertion !== 'object' || Array.isArray(assertion)) {
-			addJourneyIssue(issues, 'invalid_qa_assertion', qaPath, `${pathLabel}: qa_assertions[${index}] must be an object.`);
-			return;
-		}
-		for (const [fieldName, keys] of [
-			['route', ['route', 'screen_route', 'path']],
-			['action', ['action', 'browser_steps', 'visible_cta']],
-			['expected_dom_or_data_proof', ['expected_dom_or_data_proof', 'proof', 'expected_result']]
-		] as Array<[string, string[]]>) {
-			if (cleanField(assertion, keys, 700).length < 3) {
-				addJourneyIssue(issues, 'incomplete_qa_assertion', `${qaPath}.${fieldName}`, `${pathLabel}: qa_assertions[${index}].${fieldName} must be non-empty.`);
-			}
-		}
-		const route = cleanField(assertion, ['route', 'screen_route', 'path'], 240);
-		if (route && !looksLikeAbsoluteRoute(route)) {
-			addJourneyIssue(issues, 'relative_qa_route', `${qaPath}.route`, `${pathLabel}: qa_assertions[${index}].route must be an absolute app route.`);
-		}
-		const explicitCoverageTags = normalizeWorkflowQaCoverageTags(assertion, { includeProofKind: false });
-		const coverageTags = normalizeWorkflowQaCoverageTags(assertion);
-		if (!explicitCoverageTags.length) {
-			addJourneyIssue(issues, 'qa_assertion_missing_structured_coverage', `${qaPath}.coverage_tags`, `${pathLabel}: qa_assertions[${index}] must declare coverage_tags such as login, hub_action, workflow_completion, non_empty_data, mobile, or recovery; prose-only keyword detection is not accepted.`);
-		}
-		hasLoginQa = hasLoginQa || coverageTags.includes('login');
-		hasHubActionQa = hasHubActionQa || coverageTags.includes('hub_action');
-		hasMobileQa = hasMobileQa || coverageTags.includes('mobile');
-		hasRecoveryQa = hasRecoveryQa || coverageTags.includes('recovery');
-		hasCompletionQa = hasCompletionQa || coverageTags.includes('workflow_completion');
-		hasNonEmptyQa = hasNonEmptyQa || coverageTags.includes('non_empty_data');
-		const mappedWorkflowStepIds = workflow
-			.map((step: any, workflowIndex: number) => journeySourceMapsToWorkflowStep(assertion, step, workflowIndex) ? buildWorkflowStepId(step, workflowIndex) : '')
-			.filter(Boolean);
-		mappedWorkflowStepIds.forEach((stepId: string) => workflowStepsWithQa.add(stepId));
-		if (workflow.length && !mappedWorkflowStepIds.length) {
-			addJourneyIssue(issues, 'qa_assertion_unmapped_to_workflow', qaPath, `${pathLabel}: qa_assertions[${index}] must reference a north_star_workflow step by workflow_step_id/covers_workflow_step_ids or match that step's route and CTA/action.`);
-		}
-	});
-	if (!hasLoginQa) {
-		addJourneyIssue(issues, 'missing_login_qa', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions missing structured login coverage.`);
-	}
-	if (!hasHubActionQa) {
-		addJourneyIssue(issues, 'missing_hub_action_qa', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions missing structured dashboard hub action coverage.`);
-	}
-	if (!hasCompletionQa) {
-		addJourneyIssue(issues, 'missing_completion_qa', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions missing business completion proof.`);
-	}
-	if (!hasNonEmptyQa) {
-		addJourneyIssue(issues, 'missing_non_empty_qa', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions missing non-empty seeded data proof.`);
-	}
-	if (!hasMobileQa) {
-		addJourneyIssue(issues, 'missing_mobile_qa', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions missing mobile viewport proof.`);
-	}
-	if (!hasRecoveryQa) {
-		addJourneyIssue(issues, 'missing_recovery_qa', `${pathLabel}.journey_contract.qa_assertions`, `${pathLabel}: qa_assertions missing empty/error recovery proof.`);
-	}
-	workflow.forEach((step: any, index: number) => {
-		if (!step || typeof step !== 'object' || Array.isArray(step)) {
-			return;
-		}
-		const stepId = buildWorkflowStepId(step, index);
-		if (!workflowStepsWithQa.has(stepId)) {
-			addJourneyIssue(issues, 'workflow_step_missing_qa_assertion', `${pathLabel}.journey_contract.north_star_workflow[${index}]`, `${pathLabel}: north_star_workflow[${index}] must be covered by at least one qa_assertions row using workflow_step_id/covers_workflow_step_ids or matching route/CTA.`);
-		}
-	});
-	const workflowQaRows = buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(contract);
-	return {
-		valid: !issues.some((issue) => issue.severity === 'error'),
-		contract,
-		issues,
-		workflowQaRows,
-		primaryWorkflowId: cleanField(contract, ['primary_workflow_id', 'workflow_id', 'id'], 160) || 'north-star'
-	};
-}
-
-export function collectResolveIOAICoderJourneyContractIssues(input: any, options: {
-	pathLabel?: string;
-	requireMarkdownEnvelope?: boolean;
-} = {}): string[] {
-	return validateResolveIOAICoderJourneyContract(input, options).issues.map((issue) => issue.message);
-}
-
-function cleanNumber(value: any): number {
-	const parsed = Number(value);
-	return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
-}
-
-function cleanWorkflowQaRows(values: any, limit = 40): ResolveIOAICoderV6WorkflowQaRow[] {
-	if (!Array.isArray(values)) {
-		return [];
-	}
-	const rows: ResolveIOAICoderV6WorkflowQaRow[] = [];
-	for (const value of values) {
-		if (!value || typeof value !== 'object') {
-			continue;
-		}
-		const row: ResolveIOAICoderV6WorkflowQaRow = {
-			index: cleanNumber((value as any).index) || undefined,
-			workflowId: cleanText((value as any).workflowId || (value as any).workflow_id, 160) || undefined,
-			workflowStepId: cleanText((value as any).workflowStepId || (value as any).workflow_step_id, 160) || undefined,
-			workflowStepIds: cleanList((value as any).workflowStepIds || (value as any).workflow_step_ids, 20, 160),
-			stepId: cleanText((value as any).stepId || (value as any).step_id, 160) || undefined,
-			route: cleanText((value as any).route, 240) || undefined,
-			action: cleanText((value as any).action, 500) || undefined,
-			assertion: cleanText((value as any).assertion, 700) || undefined,
-			expectedState: cleanText((value as any).expectedState || (value as any).expected_state, 500) || undefined,
-			expectedOutput: cleanText((value as any).expectedOutput || (value as any).expected_output, 700) || undefined,
-			proofKind: cleanText((value as any).proofKind || (value as any).proof_kind, 120) || undefined,
-			coverageTags: normalizeWorkflowQaCoverageTags(value),
-			acceptanceGate: ((value as any).acceptanceGate || (value as any).acceptance_gate) === 'aiqa_business_assertion'
-				? 'aiqa_business_assertion'
-				: undefined,
-			requiredArtifacts: cleanList((value as any).requiredArtifacts || (value as any).required_artifacts, 20, 180),
-			stateTransition: (value as any).stateTransition || (value as any).state_transition
-				? {
-					before: cleanText(((value as any).stateTransition || (value as any).state_transition).before, 700) || undefined,
-					action: cleanText(((value as any).stateTransition || (value as any).state_transition).action, 700) || undefined,
-					after: cleanText(((value as any).stateTransition || (value as any).state_transition).after, 700) || undefined,
-					assertion: cleanText(((value as any).stateTransition || (value as any).state_transition).assertion, 700) || undefined
-				}
-				: undefined,
-			status: cleanText((value as any).status, 120) || undefined,
-			artifactPaths: cleanList((value as any).artifactPaths || (value as any).artifact_paths, 20, 500)
-		};
-		if (row.workflowId || row.stepId || row.route || row.action || row.assertion) {
-			rows.push(row);
-		}
-		if (rows.length >= limit) {
-			break;
-		}
-	}
-	return rows;
-}
-
-function statusLooksPassed(value: any): boolean {
-	const normalized = cleanText(value, 120).toLowerCase();
-	return !!normalized && /\b(pass|passed|success|succeeded|ok|done|complete|completed|ready|saved|published|deployed)\b/i.test(normalized);
-}
-
-function statusLooksFailed(value: any): boolean {
-	const normalized = cleanText(value, 160).toLowerCase();
-	return !!normalized && /\b(fail|failed|error|blocked|missing|empty|stale|skipped|not ready|not_ready|cannot|could not|invalid)\b/i.test(normalized);
-}
-
-function normalizeProofKey(value: any): string {
-	return cleanText(value, 500).toLowerCase().replace(/[^a-z0-9]+/g, ' ').replace(/\s+/g, ' ').trim();
-}
-
-function cleanAssertionArtifactPaths(value: Record<string, any>): string[] {
-	return cleanList(
-		value.artifactPaths
-			|| value.artifact_paths
-			|| value.artifacts
-			|| value.screenshots
-			|| (value.screenshot ? [value.screenshot] : []),
-		20,
-		500
-	);
-}
-
-function normalizeWorkflowProofAssertion(value: any): Record<string, any> {
-	const source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-	return {
-		assertion: cleanText(source.assertion || source.name || source.label || source.expected, 1000),
-		status: cleanText(source.status || source.outcome || source.result || (source.passed === true ? 'pass' : source.passed === false ? 'fail' : ''), 120),
-		workflowId: cleanText(source.workflowId || source.workflow_id || source.workflow || source.workflowName || source.workflow_name, 200),
-		stepId: cleanText(source.stepId || source.step_id || source.id || source.key, 200),
-		route: cleanText(source.route || source.path || source.url, 500),
-		action: cleanText(source.action || source.browser_steps || source.action_under_test || source.actionUnderTest, 800),
-		expected: cleanText(source.expected || source.expected_state || source.expectedState || source.expected_business_state_change || source.expectedBusinessStateChange, 1000),
-		observed: cleanText(source.observed || source.actual || source.after || source.after_state || source.afterState, 1000),
-		dataProof: cleanText(source.dataProof || source.data_proof || source.domProof || source.dom_proof || source.proof || source.summary, 1400),
-		artifactPaths: cleanAssertionArtifactPaths(source),
-		metadata: source.metadata && typeof source.metadata === 'object' && !Array.isArray(source.metadata) ? source.metadata : {}
-	};
-}
-
-function workflowRowKey(row: ResolveIOAICoderV6WorkflowQaRow, index: number): string {
-	return cleanText(row.stepId || row.assertion || row.action || row.route || `workflow-row-${index + 1}`, 200);
-}
-
-function sameWorkflowRow(left: ResolveIOAICoderV6WorkflowQaRow, right: ResolveIOAICoderV6WorkflowQaRow): boolean {
-	const leftStep = normalizeProofKey(left.stepId);
-	const rightStep = normalizeProofKey(right.stepId);
-	if (leftStep && rightStep && leftStep === rightStep) {
-		return true;
-	}
-	const leftRoute = normalizeProofKey(left.route);
-	const rightRoute = normalizeProofKey(right.route);
-	const leftAction = normalizeProofKey(left.action || left.assertion);
-	const rightAction = normalizeProofKey(right.action || right.assertion);
-	return !!leftRoute && !!rightRoute && leftRoute === rightRoute && !!leftAction && !!rightAction && (leftAction.includes(rightAction) || rightAction.includes(leftAction));
-}
-
-function mergeWorkflowQaRows(
-	contractRows: ResolveIOAICoderV6WorkflowQaRow[],
-	recordedRows: ResolveIOAICoderV6WorkflowQaRow[]
-): ResolveIOAICoderV6WorkflowQaRow[] {
-	if (!contractRows.length) {
-		return recordedRows;
-	}
-	return contractRows.map((contractRow) => {
-		const recorded = recordedRows.find((row) => sameWorkflowRow(contractRow, row));
-		if (!recorded) {
-			return contractRow;
-		}
-		return {
-			...contractRow,
-			...recorded,
-			workflowId: recorded.workflowId || contractRow.workflowId,
-			stepId: recorded.stepId || contractRow.stepId,
-			route: recorded.route || contractRow.route,
-			action: recorded.action || contractRow.action,
-			assertion: recorded.assertion || contractRow.assertion,
-			expectedState: recorded.expectedState || contractRow.expectedState,
-			expectedOutput: recorded.expectedOutput || contractRow.expectedOutput,
-			proofKind: recorded.proofKind || contractRow.proofKind,
-			coverageTags: Array.from(new Set([
-				...cleanList(contractRow.coverageTags, 20, 120),
-				...cleanList(recorded.coverageTags, 20, 120)
-			])),
-			acceptanceGate: recorded.acceptanceGate || contractRow.acceptanceGate,
-			requiredArtifacts: Array.from(new Set([
-				...cleanList(contractRow.requiredArtifacts, 20, 180),
-				...cleanList(recorded.requiredArtifacts, 20, 180)
-			])),
-			stateTransition: recorded.stateTransition || contractRow.stateTransition,
-			artifactPaths: Array.from(new Set([
-				...cleanList(contractRow.artifactPaths, 20, 500),
-				...cleanList(recorded.artifactPaths, 20, 500)
-			]))
-		};
-	});
-}
-
-function assertionMatchesWorkflowRow(assertion: Record<string, any>, row: ResolveIOAICoderV6WorkflowQaRow): boolean {
-	const metadata = assertion.metadata || {};
-	if (metadata.workflowQaRowMatched === true || metadata.journeyContractMatched === true || metadata.aicoderWorkflowProof === true) {
-		return true;
-	}
-	const rowStep = normalizeProofKey(row.stepId);
-	const assertionStep = normalizeProofKey(assertion.stepId || metadata.stepId || metadata.step_id);
-	if (rowStep && assertionStep && rowStep === assertionStep) {
-		return true;
-	}
-	const rowRoute = normalizeProofKey(row.route);
-	const assertionRoute = normalizeProofKey(assertion.route);
-	const rowAction = normalizeProofKey(row.action || row.assertion);
-	const assertionAction = normalizeProofKey([
-		assertion.action,
-		assertion.assertion,
-		assertion.expected,
-		assertion.observed,
-		assertion.dataProof
-	].filter(Boolean).join(' '));
-	return !!rowRoute
-		&& !!assertionRoute
-		&& rowRoute === assertionRoute
-		&& !!rowAction
-		&& !!assertionAction
-		&& (assertionAction.includes(rowAction) || rowAction.includes(assertionAction));
-}
-
-function workflowRowPassingAssertion(row: ResolveIOAICoderV6WorkflowQaRow, assertions: Record<string, any>[]): Record<string, any> | undefined {
-	return assertions.find((assertion) => statusLooksPassed(assertion.status) && assertionMatchesWorkflowRow(assertion, row));
-}
-
-function workflowAssertionHasObservedOutputProof(assertion: Record<string, any> | undefined): boolean {
-	if (!assertion) {
-		return false;
-	}
-	return cleanText(assertion.dataProof, 1000).length >= 8
-		|| cleanText(assertion.observed, 1000).length >= 8;
-}
-
-function workflowRowArtifactPaths(row: ResolveIOAICoderV6WorkflowQaRow, assertion?: Record<string, any>): string[] {
-	return Array.from(new Set([
-		...cleanList(row.artifactPaths, 20, 500),
-		...cleanList(assertion?.artifactPaths, 20, 500)
-	]));
-}
-
-function workflowRowRequiresOutputProof(row: ResolveIOAICoderV6WorkflowQaRow): boolean {
-	const proofKind = cleanText(row.proofKind, 120).toLowerCase();
-	if (/^(workflow_completion|report_export|non_empty_data|hub_action|business_workflow)$/.test(proofKind)) {
-		return true;
-	}
-	const text = cleanText([
-		row.expectedOutput,
-		row.expectedState,
-		row.assertion,
-		row.stateTransition?.after,
-		row.stateTransition?.assertion
-	].filter(Boolean).join(' '), 1600).toLowerCase();
-	return /\b(save|saved|persist|calculated|optimized|recommendation|report|export|result|non[-\s]?empty|record|row|kpi|table|chart)\b/.test(text);
-}
-
-function workflowRowRequiresMappedBusinessAssertion(row: ResolveIOAICoderV6WorkflowQaRow): boolean {
-	const proofKind = cleanText(row.proofKind, 120).toLowerCase();
-	if (/^(workflow_completion|report_export)$/.test(proofKind)) {
-		return true;
-	}
-	if (/^(mobile|recovery|hub_action|non_empty_data)$/.test(proofKind)) {
-		return false;
-	}
-	const text = cleanText([
-		row.stepId,
-		row.expectedOutput,
-		row.expectedState,
-		row.assertion,
-		row.stateTransition?.after
-	].filter(Boolean).join(' '), 1600).toLowerCase();
-	return /\b(workflow[-_\s]?completion|save|saved|persist|calculated|optimized|recommendation|report|export|final result)\b/.test(text);
-}
-
-function workflowRowWeakProofReason(row: ResolveIOAICoderV6WorkflowQaRow, assertions: Record<string, any>[]): string {
-	const assertion = workflowRowPassingAssertion(row, assertions);
-	const rowPassed = statusLooksPassed(row.status);
-	if (!rowPassed && !assertion) {
-		return '';
-	}
-	const artifactPaths = workflowRowArtifactPaths(row, assertion);
-	const requiredArtifacts = cleanList(row.requiredArtifacts, 20, 180);
-	if (requiredArtifacts.length && !artifactPaths.length) {
-		return `${workflowRowKey(row, 0)} missing required artifact proof: ${requiredArtifacts.slice(0, 3).join(', ')}`;
-	}
-	if (row.acceptanceGate === 'aiqa_business_assertion' && workflowRowRequiresMappedBusinessAssertion(row) && !assertion) {
-		return `${workflowRowKey(row, 0)} requires mapped AIQaBusinessAssertion proof.`;
-	}
-	if (workflowRowRequiresOutputProof(row) && !workflowAssertionHasObservedOutputProof(assertion)) {
-		return `${workflowRowKey(row, 0)} missing observed DOM/data proof for the saved/calculated/report output.`;
-	}
-	return '';
-}
-
-function workflowRowHasProof(row: ResolveIOAICoderV6WorkflowQaRow, assertions: Record<string, any>[]): boolean {
-	if (workflowRowWeakProofReason(row, assertions)) {
-		return false;
-	}
-	if (statusLooksPassed(row.status) && cleanList(row.artifactPaths, 20, 500).length) {
-		return true;
-	}
-	return !!workflowRowPassingAssertion(row, assertions);
-}
-
-function workflowRowFailed(row: ResolveIOAICoderV6WorkflowQaRow, assertions: Record<string, any>[]): boolean {
-	if (statusLooksFailed(row.status)) {
-		return true;
-	}
-	return assertions.some((assertion) => statusLooksFailed(assertion.status) && assertionMatchesWorkflowRow(assertion, row));
-}
-
-function collectContractArtifactPaths(
-	rows: ResolveIOAICoderV6WorkflowQaRow[],
-	assertions: Record<string, any>[],
-	extraPaths: any
-): string[] {
-	return Array.from(new Set([
-		...cleanList(extraPaths, 40, 500),
-		...rows.flatMap((row) => cleanList(row.artifactPaths, 20, 500)),
-		...assertions.flatMap((assertion) => cleanList(assertion.artifactPaths, 20, 500))
-	])).slice(0, 80);
-}
-
-function stableProofValue(value: any): any {
-	if (Array.isArray(value)) {
-		return value.map(stableProofValue);
-	}
-	if (value && typeof value === 'object') {
-		return Object.keys(value)
-			.sort()
-			.reduce((accumulator, key) => {
-				const cleanKey = cleanText(key, 120);
-				if (!cleanKey || /^(evaluatedAt|recordedAt|createdAt|updatedAt|timestamp|durationMs)$/i.test(cleanKey)) {
-					return accumulator;
-				}
-				const nextValue = stableProofValue(value[key]);
-				if (nextValue !== undefined && nextValue !== '' && !(Array.isArray(nextValue) && !nextValue.length)) {
-					accumulator[cleanKey] = nextValue;
-				}
-				return accumulator;
-			}, {} as Record<string, any>);
-	}
-	if (typeof value === 'number') {
-		return Number.isFinite(value) ? value : undefined;
-	}
-	if (typeof value === 'boolean') {
-		return value;
-	}
-	return cleanText(value, 2000);
-}
-
-function fingerprintResolveIOAICoderWorkflowProofPayload(value: any, prefix: string): string {
-	const text = JSON.stringify(stableProofValue(value));
-	let hash = 0;
-	for (let index = 0; index < text.length; index += 1) {
-		hash = ((hash << 5) - hash + text.charCodeAt(index)) | 0;
-	}
-	return `${prefix}-${Math.abs(hash).toString(36)}`;
-}
-
-function normalizeWorkflowProofFingerprintList(...values: any[]): string[] {
-	const fingerprints: string[] = [];
-	for (const value of values) {
-		const list = Array.isArray(value) ? value : value ? [value] : [];
-		for (const entry of list) {
-			const normalized = cleanText(entry, 200);
-			if (normalized && !fingerprints.includes(normalized)) {
-				fingerprints.push(normalized);
-			}
-		}
-	}
-	return fingerprints.slice(0, 40);
-}
-
-export function evaluateResolveIOAICoderWorkflowProofReadiness(
-	input: ResolveIOAICoderWorkflowProofReadinessInput = {}
-): ResolveIOAICoderWorkflowProofReadiness {
-	const now = isoNow(input.now);
-	const journeyInput = input.journeyContract !== undefined ? input.journeyContract : input.journeyContractMarkdown;
-	const hasJourneyInput = journeyInput !== undefined && journeyInput !== null && cleanText(journeyInput, 100).length > 0;
-	const journeyValidation = hasJourneyInput
-		? validateResolveIOAICoderJourneyContract(journeyInput, {
-			requireMarkdownEnvelope: typeof journeyInput === 'string'
-		})
-		: {
-			valid: false,
-			contract: null,
-			issues: [{
-				code: 'missing_contract',
-				path: 'docs/APP_JOURNEY_CONTRACT.md',
-				message: 'docs/APP_JOURNEY_CONTRACT.md is required before workflow proof can accept the app.',
-				severity: 'error' as const
-			}],
-			workflowQaRows: [],
-			primaryWorkflowId: ''
-		};
-	const recordedRows = cleanWorkflowQaRows(input.workflowQaRows, 120);
-	const rows = mergeWorkflowQaRows(journeyValidation.workflowQaRows, recordedRows);
-	const assertions = asArray(input.businessAssertions).map(normalizeWorkflowProofAssertion).filter((assertion) => {
-		return assertion.assertion || assertion.route || assertion.action || assertion.dataProof || assertion.status;
-	});
-	const routeOnly = asArray(input.routeProbes).some((probe) => statusLooksPassed((probe as any)?.status || ((probe as any)?.passed === true ? 'pass' : '')))
-		&& !assertions.some((assertion) => statusLooksPassed(assertion.status));
-	const weakProofReasons = rows.map((row) => workflowRowWeakProofReason(row, assertions)).filter(Boolean);
-	const failedRows = rows.filter((row) => workflowRowFailed(row, assertions));
-	const passedRows = rows.filter((row) => workflowRowHasProof(row, assertions));
-	const missingRows = rows.filter((row) => !workflowRowHasProof(row, assertions) && !workflowRowFailed(row, assertions));
-	const passedAssertions = assertions.filter((assertion) => statusLooksPassed(assertion.status));
-	const releaseBlockers = [
-		statusLooksFailed(input.deployStatus) ? `deploy=${cleanText(input.deployStatus, 160)}` : '',
-		statusLooksFailed(input.publishStatus) ? `publish=${cleanText(input.publishStatus, 160)}` : '',
-		statusLooksFailed(input.sampleDataStatus) ? `sample_data=${cleanText(input.sampleDataStatus, 160)}` : ''
-	].filter(Boolean);
-	const hasDataProof = passedAssertions.some((assertion) => cleanText(assertion.dataProof, 1000).length >= 8);
-	const sampleDataReady = statusLooksPassed(input.sampleDataStatus)
-		|| (!statusLooksFailed(input.sampleDataStatus) && hasDataProof);
-	const artifactPaths = collectContractArtifactPaths(rows, assertions, input.artifactPaths);
-	const workflowProofFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
-		primaryWorkflowId: journeyValidation.primaryWorkflowId || cleanText(recordedRows[0]?.workflowId, 160),
-		passedWorkflowRows: passedRows.map(workflowRowKey),
-		failedWorkflowRows: failedRows.map(workflowRowKey),
-		missingWorkflowRows: missingRows.map(workflowRowKey),
-		passedBusinessAssertions: passedAssertions.map((assertion) => ({
-			assertion: assertion.assertion,
-			workflowId: assertion.workflowId,
-			stepId: assertion.stepId,
-			route: assertion.route,
-			action: assertion.action,
-			expected: assertion.expected,
-			observed: assertion.observed,
-			dataProof: assertion.dataProof,
-			artifactPaths: assertion.artifactPaths
-		})),
-		sampleDataStatus: input.sampleDataStatus,
-		sampleDataReady,
-		artifactPaths
-	}, 'aicoder-workflow-proof');
-	const artifactFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
-		artifactPaths,
-		businessDataProof: passedAssertions.map((assertion) => ({
-			stepId: assertion.stepId,
-			route: assertion.route,
-			dataProof: assertion.dataProof,
-			observed: assertion.observed,
-			artifactPaths: assertion.artifactPaths
-		}))
-	}, 'aicoder-workflow-artifacts');
-	const previousWorkflowFingerprints = normalizeWorkflowProofFingerprintList(
-		input.previousWorkflowProofFingerprint,
-		input.previousWorkflowProofFingerprints
-	);
-	const previousArtifactFingerprints = normalizeWorkflowProofFingerprintList(
-		input.previousArtifactFingerprint,
-		input.previousArtifactFingerprints
-	);
-	let proofFreshness: ResolveIOAICoderWorkflowProofFreshness = 'unknown';
-	if (!passedAssertions.length && !artifactPaths.length) {
-		proofFreshness = 'missing';
-	}
-	else if (previousWorkflowFingerprints.includes(workflowProofFingerprint)) {
-		proofFreshness = 'same_as_previous';
-	}
-	else if (previousArtifactFingerprints.includes(artifactFingerprint)) {
-		proofFreshness = 'stale_artifact';
-	}
-	else {
-		proofFreshness = 'fresh';
-	}
-	const blockers: string[] = [];
-	let status: ResolveIOAICoderWorkflowProofReadinessStatus = 'ready';
-	let reason = 'Journey contract and workflow business proof are ready.';
-	let nextAction = 'Proceed to the smallest remaining release gate.';
-	if (!hasJourneyInput) {
-		status = 'missing_journey_contract';
-		blockers.push('Generate and validate docs/APP_JOURNEY_CONTRACT.md before build/acceptance.');
-		reason = 'AICoder cannot accept an app without a journey contract.';
-		nextAction = 'Run journey_contract generation and validation first.';
-	}
-	else if (!journeyValidation.valid) {
-		status = 'journey_invalid';
-		blockers.push(...journeyValidation.issues.filter((issue) => issue.severity === 'error').map((issue) => issue.message).slice(0, 8));
-		reason = 'Journey contract validation failed.';
-		nextAction = 'Repair docs/APP_JOURNEY_CONTRACT.md before product-code repair.';
-	}
-	else if (routeOnly) {
-		status = 'route_only';
-		blockers.push('Route/browser proof passed, but no workflow business assertion passed.');
-		reason = 'Route-only proof cannot accept an AICoder app.';
-		nextAction = 'Run workflow QA generated from the journey contract.';
-	}
-	else if (!rows.length) {
-		status = 'workflow_qa_missing';
-		blockers.push('No workflow QA rows were generated or recorded from the journey contract.');
-		reason = 'Workflow QA evidence is missing.';
-		nextAction = 'Generate workflow QA rows from journey_contract.qa_assertions.';
-	}
-	else if (weakProofReasons.length) {
-		status = 'business_proof_weak';
-		blockers.push(...weakProofReasons.slice(0, 8));
-		reason = 'Workflow QA rows passed without the structured artifacts or mapped output proof required by the Journey Contract.';
-		nextAction = 'Rerun the weak workflow QA rows and record AIQaBusinessAssertion plus required artifacts.';
-	}
-	else if (failedRows.length || missingRows.length) {
-		status = 'workflow_qa_incomplete';
-		blockers.push(
-			...failedRows.map((row, index) => `failed:${workflowRowKey(row, index)}`).slice(0, 8),
-			...missingRows.map((row, index) => `missing:${workflowRowKey(row, index)}`).slice(0, 8)
-		);
-		reason = 'Not all journey contract workflow QA rows have passed business proof.';
-		nextAction = 'Rerun or repair the incomplete workflow QA rows before publish.';
-	}
-	else if (!passedAssertions.length) {
-		status = input.scorecardPassed === true ? 'business_proof_missing' : 'workflow_qa_incomplete';
-		blockers.push('Workflow rows have no mapped AIQaBusinessAssertion business proof.');
-		reason = input.scorecardPassed === true
-			? 'Scorecard-only proof is not acceptance.'
-			: 'Workflow business proof is missing.';
-		nextAction = 'Record AIQaBusinessAssertion rows tied to the journey contract.';
-	}
-	else if (releaseBlockers.length) {
-		status = 'release_blocked';
-		blockers.push(...releaseBlockers);
-		reason = 'Workflow proof passed, but release/deploy/sample-data gates block acceptance.';
-		nextAction = 'Repair only the failed release gate or hotfix artifact before rerunning publish/deploy.';
-	}
-	else if (!sampleDataReady) {
-		status = 'sample_data_missing';
-		blockers.push('No non-empty seeded/sample data proof is available for the workflow.');
-		reason = 'AICoder app proof must include meaningful non-empty data.';
-		nextAction = 'Seed meaningful records and rerun workflow QA against that data.';
-	}
-	else if (proofFreshness === 'same_as_previous' || proofFreshness === 'stale_artifact') {
-		status = 'stale_workflow_proof';
-		blockers.push(proofFreshness === 'same_as_previous'
-			? 'Workflow business proof fingerprint is unchanged from a prior run.'
-			: 'Workflow proof artifacts are unchanged from a prior run.');
-		reason = 'AICoder workflow proof is stale; repeated evidence cannot advance acceptance.';
-		nextAction = 'Rerun workflow QA from journey_contract.qa_assertions and record fresh AIQaBusinessAssertion artifacts.';
-	}
-	return {
-		ready: status === 'ready',
-		status,
-		reason,
-		blockers,
-		journeyContractValid: journeyValidation.valid,
-		primaryWorkflowId: journeyValidation.primaryWorkflowId || cleanText(recordedRows[0]?.workflowId, 160),
-		passedWorkflowRows: passedRows.map(workflowRowKey),
-		missingWorkflowRows: missingRows.map(workflowRowKey),
-		failedWorkflowRows: failedRows.map(workflowRowKey),
-		passedBusinessAssertions: passedAssertions.map((assertion) => cleanText(assertion.assertion || assertion.stepId || assertion.route, 300)).filter(Boolean).slice(0, 40),
-		routeOnly,
-		scorecardOnly: input.scorecardPassed === true && !passedAssertions.length,
-		sampleDataReady,
-		releaseBlockers,
-		artifactPaths,
-		workflowProofFingerprint,
-		artifactFingerprint,
-		proofFreshness,
-		nextAction,
-		evaluatedAt: now
-	};
-}
-
-export function fingerprintResolveIOAICoderV6Blocker(value: any): string {
-	const text = cleanText(value, 4000)
-		.toLowerCase()
-		.replace(/[a-f0-9]{16,}/g, '<id>')
-		.replace(/\b\d{2,}\b/g, '<n>')
-		.replace(/\bline\s+<n>\b/g, 'line <n>')
-		.replace(/https?:\/\/\S+/g, '<url>');
-	let hash = 0;
-	for (let index = 0; index < text.length; index += 1) {
-		hash = ((hash << 5) - hash + text.charCodeAt(index)) | 0;
-	}
-	return `aicoder-v6-${Math.abs(hash).toString(36)}`;
-}
-
-function classifyResolveIOAICoderV6FailureClass(step: {
-	outcome?: ResolveIOAICoderV6Outcome;
-	lane?: ResolveIOAICoderV6Lane;
-	stepType?: ResolveIOAICoderV6StepType;
-	blocker?: string;
-	summary?: string;
-	failureClass?: string;
-}): string {
-	const explicit = cleanText(step.failureClass, 80).toLowerCase().replace(/[\s-]+/g, '_');
-	if (explicit) {
-		return explicit;
-	}
-	if (step.outcome === 'infra_retry') {
-		return 'infra';
-	}
-	const text = `${step.stepType || ''}\n${step.lane || ''}\n${step.blocker || ''}\n${step.summary || ''}`.toLowerCase();
-	if (/\b(puppeteer|chrome|browser executable|mongo|port|startup|settings\.json|node_modules|npm install|cache|lock)\b/.test(text)) {
-		return 'infra';
-	}
-	if (/\b(ts[0-9]{3,5}|typescript|compile|build failed|ng build|cannot find name|module not found|syntax error)\b/.test(text)
-		|| step.stepType === 'build') {
-		return 'compile';
-	}
-	if (step.stepType === 'journey_contract' || step.stepType === 'journey_validation') {
-		return 'journey';
-	}
-	if (step.stepType === 'workflow_qa' || step.lane === 'qa') {
-		return 'business';
-	}
-	if (step.stepType === 'publish' || step.stepType === 'test_deploy' || step.stepType === 'live_deploy' || step.lane === 'publish') {
-		return 'release';
-	}
-	return 'product_code';
-}
-
-function aicoderWorkflowReadinessNextCommand(status: ResolveIOAICoderWorkflowReadinessStatus): string {
-	switch (status) {
-		case 'journey_contract_required':
-			return 'Generate and validate docs/APP_JOURNEY_CONTRACT.md before product-code build work.';
-		case 'journey_contract_repair_required':
-			return 'Repair the journey contract until first/next/last workflow QA rows validate.';
-		case 'workflow_build_ready':
-			return 'Build the north-star workflow from the journey contract and seeded data story.';
-		case 'workflow_qa_required':
-			return 'Run workflow QA from journey_contract.qa_assertions and record AIQaBusinessAssertion proof.';
-		case 'workflow_business_proof_ready':
-			return 'Proceed only to release/publish gates; wow UI polish is allowed after business proof.';
-		case 'release_repair_required':
-			return 'Repair the failed publish/deploy/sample-data gate without rebuilding the app shell.';
-		case 'infra_repair_only':
-			return 'Repair Puppeteer, Chrome, Mongo, startup, port, cache, or environment evidence only.';
-		case 'compile_repair_only':
-			return 'Repair compile/build evidence only and rerun the same deterministic build gate.';
-		case 'collect_new_evidence':
-			return 'Collect new evidence for the stuck blocker before another model/code loop.';
-		case 'budget_stopped':
-			return 'Stop autonomous spend and request a bounded human decision.';
-		case 'parked':
-			return 'Park the run until a human chooses the next bounded action.';
-		default:
-			return 'Review workflow evidence before continuing.';
-	}
-}
-
-function aicoderWorkflowReadinessGateFor(status: ResolveIOAICoderWorkflowReadinessStatus): ResolveIOAICoderWorkflowReadinessGate {
-	switch (status) {
-		case 'journey_contract_required':
-		case 'journey_contract_repair_required':
-			return 'journey_contract';
-		case 'workflow_build_ready':
-			return 'build';
-		case 'workflow_qa_required':
-		case 'workflow_business_proof_ready':
-			return 'workflow_qa';
-		case 'release_repair_required':
-			return 'release';
-		case 'infra_repair_only':
-			return 'infra';
-		case 'compile_repair_only':
-			return 'compile';
-		case 'collect_new_evidence':
-			return 'evidence';
-		case 'budget_stopped':
-		case 'parked':
-			return 'manual';
-		default:
-			return 'manual';
-	}
-}
-
-export function buildResolveIOAICoderWorkflowProofCheckpoint(input: {
-	status: ResolveIOAICoderWorkflowReadinessStatus;
-	nextGate: ResolveIOAICoderWorkflowReadinessGate;
-	nextAction?: any;
-	last?: Partial<ResolveIOAICoderV6StepRecord>;
-	journeyContractReady?: boolean;
-	businessProofReady?: boolean;
-	routeOnlyBlocked?: boolean;
-	releaseBlocked?: boolean;
-	infraOnly?: boolean;
-	compileOnly?: boolean;
-	sameFailureParked?: boolean;
-	primaryWorkflowId?: any;
-	activeWorkflowStep?: any;
-	workflowQaRows?: any;
-	businessProofArtifacts?: any;
-	completedWorkflowSteps?: any;
-}): ResolveIOAICoderWorkflowProofCheckpoint {
-	const status = input.status;
-	const nextGate = input.nextGate;
-	const proofArtifacts = cleanList(input.businessProofArtifacts, 80, 500);
-	const workflowRows = cleanWorkflowQaRows(input.workflowQaRows, 80);
-	const completedWorkflowSteps = cleanList(input.completedWorkflowSteps, 80, 240);
-	const workflowProofFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
-		primaryWorkflowId: input.primaryWorkflowId,
-		activeWorkflowStep: input.activeWorkflowStep,
-		workflowRows: workflowRows.map((row) => ({
-			workflowId: row.workflowId,
-			stepId: row.stepId,
-			status: row.status,
-			acceptanceGate: row.acceptanceGate,
-			assertion: row.assertion
-		})),
-		completedWorkflowSteps,
-		proofArtifacts
-	}, 'aicoder-workflow-readiness');
-	const artifactFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
-		proofArtifacts,
-		rowArtifacts: workflowRows.flatMap((row) => cleanList(row.artifactPaths, 10, 500))
-	}, 'aicoder-workflow-artifacts');
-	const requiredEvidenceByStatus: Record<ResolveIOAICoderWorkflowReadinessStatus, string[]> = {
-		journey_contract_required: [
-			'docs/APP_JOURNEY_CONTRACT.md with validated journey_contract JSON',
-			'first/next/last north_star_workflow steps',
-			'workflow QA rows generated from journey_contract.qa_assertions'
-		],
-		journey_contract_repair_required: [
-			'repaired journey contract validation result',
-			'command-center hub action mapped to workflow state transition'
-		],
-		workflow_build_ready: [
-			'implemented north-star workflow from the Journey Contract',
-			'seeded data story available in the app'
-		],
-		workflow_qa_required: [
-			'AIQaBusinessAssertion for the north-star workflow',
-			'non-empty data proof',
-			'saved/calculated output proof',
-			'report/export proof when promised'
-		],
-		workflow_business_proof_ready: [
-			'deterministic release gate before publish',
-			'workflow proof artifact retained for acceptance'
-		],
-		release_repair_required: [
-			'publish/deploy/sample-data failure artifact',
-			'hotfix or release-gate evidence before another full deploy'
-		],
-		infra_repair_only: [
-			'Puppeteer/Chrome/Mongo/startup/preflight evidence',
-			'infra failure class changed or preflight passed'
-		],
-		compile_repair_only: [
-			'compile/build log evidence',
-			'compile failure class changed or build passed'
-		],
-		collect_new_evidence: [
-			'changed blocker fingerprint or evidence hash',
-			'fresh workflow QA artifact',
-			'AIQaBusinessAssertion or precise workflow blocker artifact'
-		],
-		budget_stopped: [
-			'budget summary',
-			'one human decision for next bounded action'
-		],
-		parked: [
-			'operator decision',
-			'new evidence before retry'
-		]
-	};
-	const waitingStatus: ResolveIOAICoderWorkflowProofCheckpointStatus = status === 'workflow_business_proof_ready'
-		? 'ready_to_continue'
-		: status === 'release_repair_required'
-			? 'waiting_for_release_gate'
-			: status === 'collect_new_evidence' || input.sameFailureParked === true
-				? 'waiting_for_new_evidence'
-				: status === 'infra_repair_only' || status === 'compile_repair_only'
-					? 'waiting_for_infra_or_compile'
-					: status === 'journey_contract_required' || status === 'journey_contract_repair_required'
-						? 'waiting_for_journey_contract'
-						: 'waiting_for_workflow_proof';
-	const blocksProductRepairUntilJourneyContract = input.journeyContractReady !== true
-		|| status === 'journey_contract_required'
-		|| status === 'journey_contract_repair_required';
-	const blocksPublishUntilWorkflowProof = input.businessProofReady !== true
-		|| input.routeOnlyBlocked === true
-		|| input.sameFailureParked === true
-		|| blocksProductRepairUntilJourneyContract
-		|| status === 'workflow_qa_required'
-		|| status === 'workflow_build_ready'
-		|| status === 'collect_new_evidence';
-	return {
-		required: true,
-		status: waitingStatus,
-		readinessStatus: status,
-		nextGate,
-		startingFailureClass: cleanText(input.last?.failureClass, 120),
-		startingBlockerFingerprint: cleanText(input.last?.blockerFingerprint || fingerprintResolveIOAICoderV6Blocker(input.last?.blocker || input.last?.summary || ''), 160),
-		startingEvidenceHash: cleanText(input.last?.evidenceHash, 160),
-		workflowProofFingerprint,
-		artifactFingerprint,
-		requiredEvidence: (requiredEvidenceByStatus[status] || []).slice(0, 20),
-		requiredResetEvidence: Array.from(new Set([
-			...(requiredEvidenceByStatus[status] || []),
-			...(input.sameFailureParked === true ? ['new workflow proof fingerprint', 'new artifact fingerprint'] : []),
-			...(input.releaseBlocked === true ? ['changed release gate fingerprint'] : [])
-		])).slice(0, 20),
-		successRequiresWorkflowBusinessProof: status !== 'infra_repair_only' && status !== 'compile_repair_only' && status !== 'budget_stopped',
-		blocksProductRepairUntilJourneyContract,
-		blocksPublishUntilWorkflowProof,
-		blocksPublishUntilReleaseGate: input.releaseBlocked === true || status === 'release_repair_required',
-		blocksWowUiUntilWorkflowProof: blocksPublishUntilWorkflowProof,
-		nextAction: cleanText(input.nextAction, 500) || aicoderWorkflowReadinessNextCommand(status)
-	};
-}
-
-export function buildResolveIOAICoderV6WorkflowReadiness(
-	bundle: ResolveIOAICoderV6StateBundle,
-	context: {
-		action?: ResolveIOAICoderV6ContinuationAction;
-		reason?: string;
-		nextLane?: ResolveIOAICoderV6Lane;
-		nextStep?: ResolveIOAICoderV6StepType;
-		budgetExceeded?: boolean;
-		repeatedNoProgressCount?: number;
-	} = {}
-): ResolveIOAICoderWorkflowReadiness {
-	const history = Array.isArray(bundle.aiCoderV6StepHistory) ? bundle.aiCoderV6StepHistory : [];
-	const last = history[history.length - 1];
-	const workflowMemory = bundle.aiCoderV6WorkflowMemory || {} as ResolveIOAICoderV6WorkflowMemory;
-	const rows = cleanWorkflowQaRows(workflowMemory.workflowQaRows, 80);
-	const proofArtifacts = cleanList(workflowMemory.businessProofArtifacts, 80, 500);
-	const completedSteps = cleanList(workflowMemory.completedWorkflowSteps, 80, 240);
-	const primaryWorkflowId = cleanText(workflowMemory.primaryWorkflowId || rows[0]?.workflowId, 200);
-	const activeWorkflowStep = cleanText(workflowMemory.activeWorkflowStep || workflowMemory.blockedWorkflowStep || rows.find((row) => !statusLooksPassed(row.status))?.stepId, 200);
-	const failureClass = cleanText(last?.failureClass, 120).toLowerCase();
-	const contextReason = cleanText(context.reason, 1000);
-	const observedBlocker = cleanText(last?.blocker || last?.summary, 1000);
-	const reason = contextReason || observedBlocker;
-	const combinedText = `${failureClass}\n${contextReason}\n${observedBlocker}\n${last?.stepType || ''}\n${last?.lane || ''}`.toLowerCase();
-	const compileOnly = failureClass === 'compile'
-		|| /\b(compile|typescript|ts[0-9]{3,5}|ng build|cannot find name|module not found)\b/i.test(combinedText);
-	const infraOnly = !compileOnly && (failureClass === 'infra'
-		|| /\b(puppeteer|chrome|browser executable|mongo|port|startup|settings\.json|node_modules|cache|lock)\b/i.test(combinedText));
-	const releaseBlocked = failureClass === 'release'
-		|| context.nextLane === 'publish'
-		|| /\b(release|publish|deploy|cloudfront|artifact|sample data|sample_data)\b/i.test(combinedText);
-	const routeOnlyBlocked = /\b(route only|route-only|route loaded|route_probe|browser route|shell only|shell-only)\b/i.test(combinedText);
-	const sameFailureParked = context.action === 'park'
-		|| context.reason === 'aicoder_v6_repeated_no_progress'
-		|| context.reason === 'aicoder_v6_ping_pong_no_progress';
-	const budgetStopped = context.action === 'budget_stop' || context.budgetExceeded === true;
-	const workflowQaRowsReady = rows.length > 0;
-	const journeyContractReady = !!cleanText(workflowMemory.journeyContractPath, 500)
-		&& (!!primaryWorkflowId || workflowQaRowsReady || completedSteps.length > 0);
-	const businessProofReady = proofArtifacts.length > 0;
-	let status: ResolveIOAICoderWorkflowReadinessStatus = 'workflow_build_ready';
-	const blockers: string[] = [];
-	if (budgetStopped) {
-		status = 'budget_stopped';
-		blockers.push('Budget guard stopped autonomous spend.');
-	}
-	else if (sameFailureParked) {
-		status = 'collect_new_evidence';
-		blockers.push('Same failure class repeated without enough new evidence.');
-	}
-	else if (compileOnly && context.action === 'infra_retry') {
-		status = 'compile_repair_only';
-		blockers.push('Compile/build gate failed; do not count this as product workflow failure.');
-	}
-	else if (infraOnly && context.action === 'infra_retry') {
-		status = 'infra_repair_only';
-		blockers.push('Infra gate failed; repair only environment/browser/startup dependencies.');
-	}
-	else if (failureClass === 'journey' || context.reason === 'aicoder_v6_journey_contract_repair_required') {
-		status = 'journey_contract_repair_required';
-		blockers.push('Journey contract failed validation.');
-	}
-	else if (!journeyContractReady) {
-		status = 'journey_contract_required';
-		blockers.push('Journey contract workflow memory is not ready.');
-	}
-	else if (releaseBlocked || context.reason === 'aicoder_v6_release_repair_required') {
-		status = 'release_repair_required';
-		blockers.push('Release/publish/deploy gate blocks acceptance.');
-	}
-	else if (!workflowQaRowsReady || !businessProofReady || routeOnlyBlocked) {
-		status = 'workflow_qa_required';
-		if (!workflowQaRowsReady) {
-			blockers.push('Workflow QA rows are missing.');
-		}
-		if (!businessProofReady) {
-			blockers.push('AIQaBusinessAssertion proof is missing.');
-		}
-		if (routeOnlyBlocked) {
-			blockers.push('Route/browser proof is not workflow business proof.');
-		}
-	}
-	else if (businessProofReady) {
-		status = 'workflow_business_proof_ready';
-	}
-	const canRunWorkflowQa = journeyContractReady
-		&& workflowQaRowsReady
-		&& !infraOnly
-		&& !compileOnly
-		&& !sameFailureParked
-		&& !budgetStopped;
-	const canPublish = status === 'workflow_business_proof_ready'
-		&& !releaseBlocked
-		&& !infraOnly
-		&& !compileOnly
-		&& !sameFailureParked
-		&& !budgetStopped;
-	const canRunProductRepair = journeyContractReady
-		&& !infraOnly
-		&& !compileOnly
-		&& !sameFailureParked
-		&& !budgetStopped
-		&& status !== 'journey_contract_repair_required'
-		&& status !== 'release_repair_required'
-		&& status !== 'workflow_business_proof_ready';
-	const nextGate = aicoderWorkflowReadinessGateFor(status);
-	const nextCommand = aicoderWorkflowReadinessNextCommand(status);
-	const workflowProofCheckpoint = buildResolveIOAICoderWorkflowProofCheckpoint({
-		status,
-		nextGate,
-		nextAction: nextCommand,
-		last,
-		journeyContractReady,
-		businessProofReady,
-		routeOnlyBlocked,
-		releaseBlocked,
-		infraOnly,
-		compileOnly,
-		sameFailureParked,
-		primaryWorkflowId,
-		activeWorkflowStep,
-		workflowQaRows: rows,
-		businessProofArtifacts: proofArtifacts,
-		completedWorkflowSteps: completedSteps
-	});
-	return {
-		status,
-		nextGate,
-		nextLane: context.nextLane || last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-		nextStep: context.nextStep || last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-		nextCommand,
-		journeyContractReady,
-		workflowQaRowsReady,
-		businessProofReady,
-		routeOnlyBlocked,
-		releaseBlocked,
-		infraOnly,
-		compileOnly,
-		sameFailureParked,
-		canRunProductRepair,
-		canRunWorkflowQa,
-		canPublish,
-		canPolishWowUi: canPublish,
-		requiresHumanDecision: budgetStopped || sameFailureParked,
-		reason: reason || aicoderWorkflowReadinessNextCommand(status),
-		blockers: blockers.slice(0, 8),
-		primaryWorkflowId,
-		activeWorkflowStep,
-		businessProofArtifacts: proofArtifacts,
-		workflowProofCheckpoint
-	};
-}
-
-function aicoderNextActionLabel(command: string): string {
-	switch (command) {
-		case 'repair_aicoder_journey_contract':
-			return 'Repair Journey Contract';
-		case 'run_aicoder_workflow_build':
-			return 'Build North-Star Workflow';
-		case 'run_aicoder_workflow_qa':
-			return 'Run Workflow QA';
-		case 'repair_aicoder_release_gate':
-			return 'Repair Release Gate';
-		case 'repair_aicoder_compile_gate':
-			return 'Repair Compile Gate';
-		case 'repair_aicoder_infra_gate':
-			return 'Repair Infra Gate';
-		case 'run_aicoder_owner_scoped_repair':
-			return 'Run Scoped Repair';
-		case 'publish_aicoder_after_workflow_proof':
-			return 'Publish After Workflow Proof';
-		case 'park_aicoder_until_new_evidence':
-			return 'Park Until New Evidence';
-		case 'park_aicoder_budget_stop':
-			return 'Park Budget Stop';
-		default:
-			return 'Continue Workflow';
-	}
-}
-
-function aicoderNextActionPrimaryCommand(
-	action: ResolveIOAICoderV6ContinuationAction,
-	readiness: ResolveIOAICoderWorkflowReadiness
-): string {
-	if (action === 'budget_stop') {
-		return 'park_aicoder_budget_stop';
-	}
-	if (action === 'park') {
-		return 'park_aicoder_until_new_evidence';
-	}
-	if (action === 'infra_retry') {
-		return readiness.compileOnly ? 'repair_aicoder_compile_gate' : 'repair_aicoder_infra_gate';
-	}
-	if (readiness.status === 'journey_contract_required' || readiness.status === 'journey_contract_repair_required') {
-		return 'repair_aicoder_journey_contract';
-	}
-	if (readiness.status === 'workflow_build_ready') {
-		return 'run_aicoder_workflow_build';
-	}
-	if (readiness.status === 'workflow_qa_required') {
-		return 'run_aicoder_workflow_qa';
-	}
-	if (readiness.status === 'release_repair_required') {
-		return 'repair_aicoder_release_gate';
-	}
-	if (action === 'ready_to_publish') {
-		return 'publish_aicoder_after_workflow_proof';
-	}
-	if (action === 'switch_to_repair' || action === 'retry_same_step') {
-		return 'run_aicoder_owner_scoped_repair';
-	}
-	return 'continue_aicoder_workflow';
-}
-
-function aicoderNextActionCostRisk(
-	action: ResolveIOAICoderV6ContinuationAction,
-	command: string,
-	readiness: ResolveIOAICoderWorkflowReadiness
-): ResolveIOAICoderNextActionCostRisk {
-	if (action === 'park' || action === 'budget_stop' || readiness.requiresHumanDecision) {
-		return 'manual_blocked';
-	}
-	if (action === 'ready_to_publish' || command === 'repair_aicoder_release_gate' || readiness.nextGate === 'release') {
-		return 'release_or_customer_send';
-	}
-	if (command === 'run_aicoder_workflow_qa' || command === 'repair_aicoder_compile_gate' || command === 'repair_aicoder_infra_gate') {
-		return 'small_model_or_qa';
-	}
-	if (command === 'continue_aicoder_workflow') {
-		return 'free_or_deterministic';
-	}
-	return 'expensive_model';
-}
-
-function aicoderNextActionExpectedTransition(command: string): string {
-	switch (command) {
-		case 'repair_aicoder_journey_contract':
-			return 'Missing or invalid journey contract becomes a validated first/next/last workflow graph with QA rows.';
-		case 'run_aicoder_workflow_build':
-			return 'Journey contract becomes implemented workflow screens, hub action, data story, and reachable completion state.';
-		case 'run_aicoder_workflow_qa':
-			return 'Route/browser evidence becomes AIQaBusinessAssertion proof for the north-star workflow.';
-		case 'repair_aicoder_release_gate':
-			return 'Publish/deploy/sample-data blocker becomes hotfix evidence, release-gate evidence, or one explicit force-deploy decision.';
-		case 'repair_aicoder_compile_gate':
-			return 'Compile failure becomes a passing build or a new compile blocker fingerprint.';
-		case 'repair_aicoder_infra_gate':
-			return 'Infra/preflight failure becomes a passing startup/browser/Mongo gate or a new infra blocker fingerprint.';
-		case 'run_aicoder_owner_scoped_repair':
-			return 'Current blocker changes to passed, a new evidence hash, or a parked manual decision.';
-		case 'publish_aicoder_after_workflow_proof':
-			return 'Workflow-proven artifact moves through the release gate exactly once with publish/deploy evidence recorded.';
-		case 'park_aicoder_budget_stop':
-		case 'park_aicoder_until_new_evidence':
-			return 'Runner stops spending until an operator records new evidence or an explicit next action.';
-		default:
-			return 'Runner advances to the next workflow-first gate with evidence recorded.';
-	}
-}
-
-function buildResolveIOAICoderNextActionStopConditions(
-	readiness: ResolveIOAICoderWorkflowReadiness,
-	command: string
-): string[] {
-	const stopConditions = [
-		'Do not accept scorecard, wow score, or route load as app success without AIQaBusinessAssertion workflow proof.'
-	];
-	if (!readiness.journeyContractReady || command === 'repair_aicoder_journey_contract') {
-		stopConditions.push('Do not run build tasks until docs/APP_JOURNEY_CONTRACT.md validates with first/next/last workflow steps.');
-	}
-	if (!readiness.businessProofReady || readiness.routeOnlyBlocked || command === 'run_aicoder_workflow_qa') {
-		stopConditions.push('Do not publish or run wow UI polish until workflow business proof passes.');
-		stopConditions.push('Route-only proof must stay labeled as route evidence, not acceptance.');
-	}
-	if (readiness.releaseBlocked || command === 'repair_aicoder_release_gate') {
-		stopConditions.push('Do not repeat a full publish/deploy until release blocker evidence changes or hotfix/force evidence is recorded.');
-	}
-	if (readiness.infraOnly || readiness.compileOnly) {
-		stopConditions.push('Infra, startup, Puppeteer, Chrome, Mongo, and compile failures stay in infra/compile repair; do not charge them as product workflow failure.');
-	}
-	if (readiness.sameFailureParked) {
-		stopConditions.push('Do not retry the same model/code repair until the blocker fingerprint, evidence hash, or workflow proof artifact changes.');
-	}
-	if (readiness.requiresHumanDecision) {
-		stopConditions.push('Do not spend additional model or release budget until an operator records the next bounded action.');
-	}
-	return Array.from(new Set(stopConditions)).slice(0, 12);
-}
-
-export function buildResolveIOAICoderNextActionContract(input: {
-	bundle: ResolveIOAICoderV6StateBundle;
-	action: ResolveIOAICoderV6ContinuationAction;
-	reason: string;
-	nextLane: ResolveIOAICoderV6Lane;
-	nextStep: ResolveIOAICoderV6StepType;
-	budgetExceeded?: boolean;
-	workflowReadiness: ResolveIOAICoderWorkflowReadiness;
-	workflowProofCheckpoint: ResolveIOAICoderWorkflowProofCheckpoint;
-	now?: Date | string;
-}): ResolveIOAICoderNextActionContract {
-	const workflowReadiness = input.workflowReadiness;
-	const workflowProofCheckpoint = input.workflowProofCheckpoint;
-	const history = Array.isArray(input.bundle.aiCoderV6StepHistory) ? input.bundle.aiCoderV6StepHistory : [];
-	const last = history[history.length - 1];
-	const command = aicoderNextActionPrimaryCommand(input.action, workflowReadiness);
-	const costRisk = aicoderNextActionCostRisk(input.action, command, workflowReadiness);
-	const hotfixCommitRequired = command === 'repair_aicoder_release_gate'
-		|| workflowReadiness.releaseBlocked
-		|| workflowReadiness.nextGate === 'release';
-	const liveHotfixBlockedUntilCommit = hotfixCommitRequired;
-	const requiredHotfixCommitProof = hotfixCommitRequired
-		? ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed']
-		: [];
-	const requiresHumanApproval = input.action === 'park'
-		|| input.action === 'budget_stop'
-		|| input.action === 'ready_to_publish'
-		|| input.budgetExceeded === true
-		|| workflowReadiness.requiresHumanDecision === true;
-	const workflowFirstSatisfied = workflowReadiness.journeyContractReady
-		&& workflowReadiness.businessProofReady
-		&& !workflowReadiness.releaseBlocked
-		&& !workflowReadiness.routeOnlyBlocked
-		&& !workflowReadiness.infraOnly
-		&& !workflowReadiness.compileOnly
-		&& !workflowReadiness.sameFailureParked;
-	const safeToAutoRun = !requiresHumanApproval && (
-		command === 'repair_aicoder_journey_contract'
-		|| command === 'run_aicoder_workflow_build'
-		|| command === 'run_aicoder_workflow_qa'
-		|| command === 'repair_aicoder_release_gate'
-		|| command === 'repair_aicoder_compile_gate'
-		|| command === 'repair_aicoder_infra_gate'
-		|| (command === 'run_aicoder_owner_scoped_repair' && workflowReadiness.canRunProductRepair)
-		|| (command === 'continue_aicoder_workflow' && !workflowReadiness.blockers.length)
-	);
-	const canRunWithoutCodexMonitor = safeToAutoRun
-		&& workflowProofCheckpoint.requiredEvidence.length > 0
-		&& workflowProofCheckpoint.nextAction.length > 0;
-	const blockers = Array.from(new Set([
-		...workflowReadiness.blockers,
-		...(workflowProofCheckpoint.status === 'waiting_for_new_evidence' ? workflowProofCheckpoint.requiredResetEvidence : [])
-	])).slice(0, 12);
-	const preconditions = Array.from(new Set([
-		workflowProofCheckpoint.nextAction,
-		...workflowProofCheckpoint.requiredEvidence,
-		...(workflowReadiness.journeyContractReady ? [] : ['validated APP_JOURNEY_CONTRACT.md journey_contract JSON']),
-		...(workflowReadiness.canRunWorkflowQa ? ['workflow QA rows generated from the journey contract'] : []),
-		...(workflowReadiness.releaseBlocked ? ['release blocker artifact or hotfix-first release evidence'] : []),
-		...(hotfixCommitRequired ? ['sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus before live hotfix apply'] : [])
-	].map((entry) => cleanText(entry, 300)).filter(Boolean))).slice(0, 12);
-	const successEvidence = Array.from(new Set([
-		...workflowProofCheckpoint.requiredEvidence,
-		...(workflowReadiness.businessProofReady ? ['retained AIQaBusinessAssertion artifact'] : []),
-		...(workflowReadiness.canPublish ? ['release gate accepts the workflow-proven artifact'] : []),
-		...(command === 'repair_aicoder_release_gate' ? ['hotfix evidence or explicit one-time force release decision'] : []),
-		...(hotfixCommitRequired ? ['GitHub commit and push proof for any manager-applied hotfix'] : [])
-	].map((entry) => cleanText(entry, 300)).filter(Boolean))).slice(0, 12);
-	const stopConditions = buildResolveIOAICoderNextActionStopConditions(workflowReadiness, command);
-	if (hotfixCommitRequired) {
-		stopConditions.push('Do not apply a live AICoder backend/static hotfix until sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus are recorded.');
-	}
-	const forbiddenActions = Array.from(new Set([
-		'accepting route-only proof as app success',
-		'accepting scorecard-only or wow-score-only proof as app success',
-		...(workflowReadiness.journeyContractReady ? [] : ['building product routes before the journey contract validates']),
-		...(workflowReadiness.businessProofReady ? [] : ['publishing before north-star workflow business proof passes']),
-		...(workflowReadiness.releaseBlocked ? ['rerunning full deploy/publish without changed release evidence'] : []),
-		...(hotfixCommitRequired ? ['applying live hotfix before pushed GitHub commit proof'] : []),
-		...(workflowReadiness.sameFailureParked ? ['retrying the same repair loop without new evidence'] : [])
-	])).slice(0, 12);
-	const nextCommands = Array.from(new Set([
-		command,
-		...(command === 'repair_aicoder_journey_contract' ? ['validate_aicoder_journey_contract', 'generate_workflow_qa_rows'] : []),
-		...(command === 'run_aicoder_workflow_qa' ? ['execute_contract_qa_assertions', 'record_aiqa_business_assertion'] : []),
-		...(command === 'repair_aicoder_release_gate' ? [
-			'collect_release_blocker_evidence',
-			'prefer_hotfix_before_full_deploy',
-			'prepare_hotfix_patch_without_live_apply',
-			'commit_and_push_hotfix_to_github',
-			'record_github_commit_for_hotfix',
-			'apply_live_hotfix_only_after_github_commit_proof'
-		] : []),
-		...(command === 'repair_aicoder_compile_gate' ? ['rerun_compile_gate_only', 'record_compile_evidence_hash'] : []),
-		...(command === 'repair_aicoder_infra_gate' ? ['rerun_preflight_gate_only', 'record_infra_evidence_hash'] : []),
-		'record_aicoder_next_action_result'
-	])).slice(0, 12);
-	const contractBasis = {
-		action: input.action,
-		reason: cleanText(input.reason, 500),
-		command,
-		readinessStatus: workflowReadiness.status,
-		checkpointStatus: workflowProofCheckpoint.status,
-		failureClass: cleanText(last?.failureClass, 120),
-		evidenceHash: hashResolveIOAIManagerEvidence(last as any)
-	};
-	return {
-		contractId: `aicoder-next-${hashResolveIOAIManagerEvidence({
-			failureClass: contractBasis.failureClass,
-			summary: `${contractBasis.reason}:${contractBasis.command}:${contractBasis.readinessStatus}:${contractBasis.checkpointStatus}`,
-			evidenceHash: contractBasis.evidenceHash,
-			changedFiles: last?.changedFiles,
-			artifactPaths: last?.artifactPaths
-		} as any)}`,
-		action: input.action,
-		label: aicoderNextActionLabel(command),
-		primaryCommand: command,
-		lane: input.nextLane,
-		stepType: input.nextStep,
-		safeToAutoRun,
-		requiresHumanApproval,
-		canRunWithoutCodexMonitor,
-		codexFallbackRequired: !canRunWithoutCodexMonitor && !requiresHumanApproval,
-		codexFallbackReason: canRunWithoutCodexMonitor
-			? ''
-			: requiresHumanApproval
-				? 'Operator approval is required before the next action.'
-				: 'Next action needs stronger deterministic evidence before it can run unattended.',
-		costRisk,
-		workflowFirstSatisfied,
-		decisionBasis: {
-			journeyContractReady: workflowReadiness.journeyContractReady,
-			workflowProofReady: workflowReadiness.businessProofReady,
-			sampleDataReady: workflowReadiness.businessProofReady && !workflowReadiness.releaseBlocked,
-			releaseBlocked: workflowReadiness.releaseBlocked,
-			routeOnlyBlocked: workflowReadiness.routeOnlyBlocked,
-			infraOnly: workflowReadiness.infraOnly,
-			compileOnly: workflowReadiness.compileOnly,
-			sameFailureParked: workflowReadiness.sameFailureParked,
-			canPublish: workflowReadiness.canPublish,
-			canPolishWowUi: workflowReadiness.canPolishWowUi,
-			workflowReadinessStatus: workflowReadiness.status,
-			workflowProofCheckpointStatus: workflowProofCheckpoint.status,
-			failureClass: contractBasis.failureClass,
-			evidenceHash: cleanText(last?.evidenceHash || contractBasis.evidenceHash, 160),
-			hotfixCommitRequired,
-			liveHotfixBlockedUntilCommit
-		},
-		preconditions,
-		expectedStateTransition: aicoderNextActionExpectedTransition(command),
-		successEvidence,
-		requiredHotfixCommitProof,
-		stopConditions,
-		forbiddenActions,
-		nextCommands,
-		blockers,
-		ownerFiles: cleanList(last?.changedFiles, 20, 500),
-		createdAt: isoNow(input.now)
-	};
-}
-
-export function buildResolveIOAICoderV6Budget(existing?: Partial<ResolveIOAICoderV6Budget>): ResolveIOAICoderV6Budget {
-	return {
-		maxPromptTokensPerNonInitialStep: Number(existing?.maxPromptTokensPerNonInitialStep || 4000),
-		maxTotalPromptTokens: Number(existing?.maxTotalPromptTokens || 120000),
-		maxLoopsPerRun: Number(existing?.maxLoopsPerRun || 24),
-		maxRepeatedNoProgress: Number(existing?.maxRepeatedNoProgress || 2),
-		maxRuntimeMinutesPerLane: Number(existing?.maxRuntimeMinutesPerLane || 30),
-		softBudgetUsd: Number(existing?.softBudgetUsd || 30),
-		hardBudgetUsd: Number(existing?.hardBudgetUsd || 60),
-		totalPromptTokenEstimate: cleanNumber(existing?.totalPromptTokenEstimate),
-		totalInputTokens: cleanNumber(existing?.totalInputTokens),
-		totalCachedInputTokens: cleanNumber(existing?.totalCachedInputTokens),
-		totalOutputTokens: cleanNumber(existing?.totalOutputTokens),
-		totalRuntimeMs: cleanNumber(existing?.totalRuntimeMs),
-		loopCount: cleanNumber(existing?.loopCount)
-	};
-}
-
-export function initializeResolveIOAICoderV6State(input: ResolveIOAICoderV6InitializeInput): ResolveIOAICoderV6StateBundle {
-	const now = isoNow(input.now);
-	const existing = input.existing || {};
-	const existingSupervisor = existing.aiCoderV6SupervisorState;
-	const existingLaneMemory = existing.aiCoderV6LaneMemory || {} as ResolveIOAICoderV6StateBundle['aiCoderV6LaneMemory'];
-	const existingWorkflowMemory = existing.aiCoderV6WorkflowMemory || {} as Partial<ResolveIOAICoderV6WorkflowMemory>;
-	const scope = cleanList(input.approvedScopeRequirements, 24, 240).join(' | ')
-		|| cleanText(input.description, 1000)
-		|| cleanText(input.title, 300);
-	const runId = cleanText(input.conversationId || input.jobId || input.appId, 120);
-	const defaultModel = cleanText(input.defaultModel || 'gpt-5.3-codex', 80);
-	const buildLaneMemory = (lane: ResolveIOAICoderV6Lane): ResolveIOAICoderV6LaneMemory => {
-		const previous = existingLaneMemory[lane] || {} as Partial<ResolveIOAICoderV6LaneMemory>;
-		return {
-			lane,
-			model: cleanText(previous.model || defaultModel, 80),
-			threadKey: cleanText(input.laneThreadKeys?.[lane] || previous.threadKey || `aicoder:${input.runKind}:${runId}:${lane}`, 240),
-			scopeSummary: cleanText(previous.scopeSummary || scope, 1200),
-			activeStep: previous.activeStep || (lane === 'plan' ? 'plan' : lane === 'qa' ? 'qa' : lane === 'review' ? 'review' : lane === 'publish' ? 'publish' : 'task'),
-			activeBlocker: cleanText(previous.activeBlocker, 1200),
-			activeQaRow: previous.activeQaRow,
-			changedFiles: cleanList(previous.changedFiles, 80, 500),
-			artifactPaths: cleanList(previous.artifactPaths, 80, 500),
-			latestPromptVersion: cleanText(previous.latestPromptVersion, 120) || undefined,
-			latestPromptTokenEstimate: cleanNumber(previous.latestPromptTokenEstimate) || undefined,
-			updatedAt: previous.updatedAt || now
-		};
-	};
-	const laneMemory = LANES.reduce((accumulator, lane) => {
-		accumulator[lane] = buildLaneMemory(lane);
-		return accumulator;
-	}, {} as Record<ResolveIOAICoderV6Lane, ResolveIOAICoderV6LaneMemory>);
-	const activeLane = existingSupervisor?.activeLane || (input.runKind === 'initial_builder' ? 'plan' : 'build');
-	return {
-		aiCoderRunnerVersion: 'v6',
-		aiCoderV6SupervisorState: {
-			version: 'v6',
-			runKind: input.runKind,
-			status: existingSupervisor?.status || 'active',
-			currentGoal: cleanText(existingSupervisor?.currentGoal || `Run AICoder ${input.runKind} ${runId}`, 500),
-			approvedScope: cleanText(existingSupervisor?.approvedScope || scope, 1400),
-			branchName: cleanText(input.branchName || existingSupervisor?.branchName, 240),
-			activeLane,
-			activeStep: existingSupervisor?.activeStep || laneMemory[activeLane].activeStep,
-			activeBlocker: cleanText(existingSupervisor?.activeBlocker, 1200),
-			lastGoodCheckpoint: existingSupervisor?.lastGoodCheckpoint || 'v6_initialized',
-			lastGoodCommit: cleanText(existingSupervisor?.lastGoodCommit, 240) || undefined,
-			testDeployStatus: cleanText(existingSupervisor?.testDeployStatus, 120) || undefined,
-			liveDeployStatus: cleanText(existingSupervisor?.liveDeployStatus, 120) || undefined,
-			processLease: input.processLease || existingSupervisor?.processLease,
-			artifactLinks: cleanList(existingSupervisor?.artifactLinks, 80, 500),
-			updatedAt: now
-		},
-		aiCoderV6LaneMemory: laneMemory,
-		aiCoderV6WorkflowMemory: {
-			journeyContractPath: cleanText(input.journeyContractPath || existingWorkflowMemory.journeyContractPath || 'docs/APP_JOURNEY_CONTRACT.md', 500),
-			primaryWorkflowId: cleanText(existingWorkflowMemory.primaryWorkflowId, 200),
-			activeWorkflowStep: cleanText(existingWorkflowMemory.activeWorkflowStep, 200),
-			workflowQaRows: cleanWorkflowQaRows(existingWorkflowMemory.workflowQaRows, 80),
-			completedWorkflowSteps: cleanList(existingWorkflowMemory.completedWorkflowSteps, 80, 240),
-			blockedWorkflowStep: cleanText(existingWorkflowMemory.blockedWorkflowStep, 240),
-			businessProofArtifacts: cleanList(existingWorkflowMemory.businessProofArtifacts, 80, 500),
-			updatedAt: existingWorkflowMemory.updatedAt || now
-		},
-		aiCoderV6StepHistory: Array.isArray(existing.aiCoderV6StepHistory)
-			? existing.aiCoderV6StepHistory.slice(-100)
-			: [],
-		aiCoderV6Budget: buildResolveIOAICoderV6Budget(existing.aiCoderV6Budget),
-		aiCoderV6RunnerIncidents: Array.isArray(existing.aiCoderV6RunnerIncidents)
-			? existing.aiCoderV6RunnerIncidents.slice(-100)
-			: [],
-		aiCoderV6RecoveryPlan: (existing as any).aiCoderV6RecoveryPlan,
-		aiCoderV6RecoveryCheckpoint: (existing as any).aiCoderV6RecoveryCheckpoint,
-		aiCoderV6RecoveryEvidenceProbe: (existing as any).aiCoderV6RecoveryEvidenceProbe,
-		aiCoderV6RecoveryAction: (existing as any).aiCoderV6RecoveryAction,
-		aiCoderV6RecoveryDispatchHistory: Array.isArray((existing as any).aiCoderV6RecoveryDispatchHistory)
-			? (existing as any).aiCoderV6RecoveryDispatchHistory.slice(-50)
-			: [],
-		aiCoderV6RecoveryDirective: (existing as any).aiCoderV6RecoveryDirective
-	};
-}
-
-export function recordResolveIOAICoderV6Step(
-	bundle: ResolveIOAICoderV6StateBundle,
-	step: ResolveIOAICoderV6StepInput
-): ResolveIOAICoderV6StateBundle {
-	const now = isoNow(step.now);
-	const promptTokens = cleanNumber(step.promptTokenEstimate);
-	const inputTokens = cleanNumber(step.inputTokens);
-	const cachedInputTokens = cleanNumber(step.cachedInputTokens);
-	const outputTokens = cleanNumber(step.outputTokens);
-	const runtimeMs = cleanNumber(step.runtimeMs);
-	const blocker = cleanText(step.blocker, 1200);
-	const failureClass = classifyResolveIOAICoderV6FailureClass({
-		outcome: step.outcome,
-		lane: step.lane,
-		stepType: step.stepType,
-		blocker,
-		summary: step.summary,
-		failureClass: step.failureClass
-	});
-	const previousWorkflowMemory = bundle.aiCoderV6WorkflowMemory || {} as ResolveIOAICoderV6WorkflowMemory;
-	const activeWorkflowStep = cleanText(step.activeWorkflowStep || previousWorkflowMemory.activeWorkflowStep, 200);
-	const explicitCompletedSteps = cleanList(step.completedWorkflowSteps, 40, 240);
-	const completedWorkflowSteps = Array.from(new Set([
-		...cleanList(previousWorkflowMemory.completedWorkflowSteps, 80, 240),
-		...explicitCompletedSteps,
-		...(step.outcome === 'pass' && activeWorkflowStep ? [activeWorkflowStep] : [])
-	])).slice(-80);
-	const businessProofArtifacts = Array.from(new Set([
-		...cleanList(previousWorkflowMemory.businessProofArtifacts, 80, 500),
-		...cleanList(step.businessProofArtifacts, 40, 500)
-	])).slice(-80);
-	const workflowQaRows = step.workflowQaRows !== undefined
-		? cleanWorkflowQaRows(step.workflowQaRows, 80)
-		: cleanWorkflowQaRows(previousWorkflowMemory.workflowQaRows, 80);
-	const blockedWorkflowStep = cleanText(
-		step.blockedWorkflowStep
-			|| ((step.outcome === 'needs_repair' || step.outcome === 'park_manual') ? activeWorkflowStep : '')
-			|| previousWorkflowMemory.blockedWorkflowStep,
-		240
-	);
-	const record: ResolveIOAICoderV6StepRecord = {
-		stepType: step.stepType,
-		outcome: step.outcome,
-		lane: step.lane,
-		model: cleanText(step.model, 80) || undefined,
-		threadKey: cleanText(step.threadKey, 240) || undefined,
-		promptVersion: cleanText(step.promptVersion, 120) || undefined,
-		promptTokenEstimate: promptTokens || undefined,
-		inputTokens: inputTokens || undefined,
-		cachedInputTokens: cachedInputTokens || undefined,
-		outputTokens: outputTokens || undefined,
-		runtimeMs: runtimeMs || undefined,
-		summary: cleanText(step.summary || blocker || step.outcome, 1200),
-		blocker: blocker || undefined,
-		blockerFingerprint: blocker ? fingerprintResolveIOAICoderV6Blocker(blocker) : undefined,
-		failureClass,
-		changedFiles: cleanList(step.changedFiles, 80, 500),
-		artifactPaths: cleanList(step.artifactPaths, 80, 500),
-		nextAction: step.nextAction,
-		recordedAt: now
-	};
-	record.evidenceHash = cleanText(step.evidenceHash, 120)
-		|| hashResolveIOAIManagerEvidence(record);
-	const previousRecord = bundle.aiCoderV6StepHistory[bundle.aiCoderV6StepHistory.length - 1];
-	const managerDecision = decideResolveIOAIManagerPolicy({
-		history: [...bundle.aiCoderV6StepHistory, record],
-		current: record,
-		maxSameFailureRepeats: buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget).maxRepeatedNoProgress + 1
-	});
-	const nextLoopCount = managerDecision.loopBudgetShouldReset
-		|| previousRecord?.failureClass !== record.failureClass
-		|| previousRecord?.blockerFingerprint !== record.blockerFingerprint
-		|| previousRecord?.evidenceHash !== record.evidenceHash
-		? 1
-		: bundle.aiCoderV6Budget.loopCount + 1;
-	const budget = buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget);
-	const shouldParkForRepeatedNoProgress = !managerDecision.loopBudgetShouldReset
-		&& nextLoopCount > budget.maxRepeatedNoProgress
-		&& step.outcome !== 'pass'
-		&& step.outcome !== 'ready_to_publish'
-		&& step.outcome !== 'published';
-	const recordedRecoveryPlan = shouldParkForRepeatedNoProgress
-		? buildResolveIOAIManagerRecoveryPlan({
-			action: 'park_repeated_failure',
-			reason: 'aicoder_v6_repeated_no_progress',
-			failureClass: record.failureClass,
-			lane: record.lane,
-			stepType: record.stepType,
-			blocker: record.blocker || record.summary,
-			changedFiles: record.changedFiles,
-			artifactPaths: record.artifactPaths,
-			maxSameFailureRepeats: budget.maxRepeatedNoProgress + 1
-		})
-		: managerDecision.recoveryPlan;
-	const recordedRecoveryCheckpoint = shouldParkForRepeatedNoProgress
-		? buildResolveIOAIManagerRecoveryCheckpoint({
-			plan: recordedRecoveryPlan,
-			current: record
-		})
-		: managerDecision.recoveryCheckpoint;
-	const recordedRecoveryEvidenceProbe = shouldParkForRepeatedNoProgress
-		? buildResolveIOAIManagerRecoveryEvidenceProbe({
-			checkpoint: recordedRecoveryCheckpoint,
-			current: record
-		})
-		: managerDecision.recoveryEvidenceProbe;
-	const recordedRecoveryAction = shouldParkForRepeatedNoProgress
-		? buildResolveIOAIManagerRecoveryActionPacket({
-			plan: recordedRecoveryPlan,
-			checkpoint: recordedRecoveryCheckpoint,
-			probe: recordedRecoveryEvidenceProbe,
-			current: record
-		})
-		: managerDecision.recoveryAction;
-	const previousLane = bundle.aiCoderV6LaneMemory[step.lane];
-	const laneMemory = {
-		...bundle.aiCoderV6LaneMemory,
-		[step.lane]: {
-			...previousLane,
-			model: record.model || previousLane.model,
-			threadKey: record.threadKey || previousLane.threadKey,
-			activeStep: step.stepType,
-			activeBlocker: record.blocker || previousLane.activeBlocker || '',
-			activeQaRow: step.activeQaRow || previousLane.activeQaRow,
-			changedFiles: record.changedFiles?.length ? record.changedFiles : previousLane.changedFiles,
-			artifactPaths: record.artifactPaths?.length ? record.artifactPaths : previousLane.artifactPaths,
-			latestPromptVersion: record.promptVersion || previousLane.latestPromptVersion,
-			latestPromptTokenEstimate: promptTokens || previousLane.latestPromptTokenEstimate,
-			updatedAt: now
-		}
-	};
-	const complete = step.outcome === 'published' || step.outcome === 'ready_to_publish';
-	const parked = step.outcome === 'park_manual' || step.outcome === 'budget_stop';
-	return {
-		...bundle,
-		aiCoderV6SupervisorState: {
-			...bundle.aiCoderV6SupervisorState,
-			status: complete ? 'complete' : (parked ? 'parked' : 'active'),
-			activeLane: step.lane,
-			activeStep: step.stepType,
-			activeBlocker: record.blocker || '',
-			lastGoodCheckpoint: step.outcome === 'pass' || complete ? step.stepType : bundle.aiCoderV6SupervisorState.lastGoodCheckpoint,
-			artifactLinks: Array.from(new Set([
-				...bundle.aiCoderV6SupervisorState.artifactLinks,
-				...(record.artifactPaths || [])
-			])).slice(-80),
-			updatedAt: now
-		},
-		aiCoderV6LaneMemory: laneMemory,
-		aiCoderV6WorkflowMemory: {
-			journeyContractPath: cleanText(previousWorkflowMemory.journeyContractPath || 'docs/APP_JOURNEY_CONTRACT.md', 500),
-			primaryWorkflowId: cleanText(step.primaryWorkflowId || previousWorkflowMemory.primaryWorkflowId, 200),
-			activeWorkflowStep,
-			workflowQaRows,
-			completedWorkflowSteps,
-			blockedWorkflowStep,
-			businessProofArtifacts,
-			updatedAt: now
-		},
-		aiCoderV6StepHistory: [...bundle.aiCoderV6StepHistory, record].slice(-120),
-		aiCoderV6Budget: {
-			...bundle.aiCoderV6Budget,
-			totalPromptTokenEstimate: bundle.aiCoderV6Budget.totalPromptTokenEstimate + promptTokens,
-			totalInputTokens: bundle.aiCoderV6Budget.totalInputTokens + inputTokens,
-			totalCachedInputTokens: bundle.aiCoderV6Budget.totalCachedInputTokens + cachedInputTokens,
-			totalOutputTokens: bundle.aiCoderV6Budget.totalOutputTokens + outputTokens,
-			totalRuntimeMs: bundle.aiCoderV6Budget.totalRuntimeMs + runtimeMs,
-			loopCount: nextLoopCount
-		},
-		aiCoderV6RecoveryPlan: recordedRecoveryPlan,
-		aiCoderV6RecoveryCheckpoint: recordedRecoveryCheckpoint,
-		aiCoderV6RecoveryEvidenceProbe: recordedRecoveryEvidenceProbe,
-		aiCoderV6RecoveryAction: recordedRecoveryAction
-	};
-}
-
-export function decideResolveIOAICoderV6Continuation(bundle: ResolveIOAICoderV6StateBundle): ResolveIOAICoderV6ContinuationDecision {
-	const history = bundle.aiCoderV6StepHistory || [];
-	const budget = buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget);
-	const last = history[history.length - 1];
-	const lastFingerprint = fingerprintResolveIOAICoderV6Blocker(last?.blocker || last?.summary || '');
-	let repeatedNoProgressCount = 0;
-	for (let index = history.length - 1; index >= 0; index -= 1) {
-		const item = history[index];
-		if (item.outcome === 'pass' || item.outcome === 'ready_to_publish' || item.outcome === 'published') {
-			break;
-		}
-		if (item.stepType !== last?.stepType || item.lane !== last?.lane) {
-			break;
-		}
-		if (fingerprintResolveIOAICoderV6Blocker(item.blocker || item.summary || '') === lastFingerprint) {
-			repeatedNoProgressCount += 1;
-		}
-	}
-	const managerDecision = decideResolveIOAIManagerPolicy({
-		history,
-		current: last,
-		maxSameFailureRepeats: budget.maxRepeatedNoProgress + 1,
-		maxPingPongTransitions: 3,
-		infraFailureClasses: ['infra', 'compile']
-	});
-	const recoveryPlanFor = (
-		action: ResolveIOAICoderV6ContinuationDecision['action'] | string,
-		reason: string,
-		extra: Partial<ResolveIOAIManagerRecoveryPlanInput> = {}
-	): ResolveIOAIManagerRecoveryPlan => buildResolveIOAIManagerRecoveryPlan({
-		action,
-		reason,
-		failureClass: last?.failureClass,
-		lane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-		stepType: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-		blocker: last?.blocker || last?.summary,
-		changedFiles: last?.changedFiles,
-		artifactPaths: last?.artifactPaths,
-		maxSameFailureRepeats: budget.maxRepeatedNoProgress + 1,
-		...extra
-	});
-	const recoveryCheckpointFor = (
-		recoveryPlan: ResolveIOAIManagerRecoveryPlan
-	): ResolveIOAIManagerRecoveryCheckpoint => buildResolveIOAIManagerRecoveryCheckpoint({
-		plan: recoveryPlan,
-		current: last
-	});
-	const recoveryFieldsFor = (
-		recoveryPlan: ResolveIOAIManagerRecoveryPlan,
-		recoveryCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint,
-		recoveryEvidenceProbe?: ResolveIOAIManagerRecoveryEvidenceProbe
-	): Pick<ResolveIOAICoderV6ContinuationDecision, 'recoveryPlan' | 'recoveryCheckpoint' | 'recoveryEvidenceProbe' | 'recoveryAction'> => {
-		const checkpoint = recoveryCheckpoint || recoveryCheckpointFor(recoveryPlan);
-		const probe = recoveryEvidenceProbe || buildResolveIOAIManagerRecoveryEvidenceProbe({
-			checkpoint,
-			current: last
-		});
-		return {
-			recoveryPlan,
-			recoveryCheckpoint: checkpoint,
-			recoveryEvidenceProbe: probe,
-			recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
-				plan: recoveryPlan,
-				checkpoint,
-				probe,
-				current: last
-			})
-		};
-	};
-	const managerRecoveryFields = () => recoveryFieldsFor(
-		managerDecision.recoveryPlan,
-		managerDecision.recoveryCheckpoint,
-		managerDecision.recoveryEvidenceProbe
-	);
-	const withWorkflowReadiness = (
-		decision: Omit<ResolveIOAICoderV6ContinuationDecision, 'workflowReadiness' | 'workflowProofCheckpoint' | 'nextActionContract'>
-	): ResolveIOAICoderV6ContinuationDecision => {
-		const workflowReadiness = buildResolveIOAICoderV6WorkflowReadiness(bundle, {
-			action: decision.action,
-			reason: decision.reason,
-			nextLane: decision.nextLane,
-			nextStep: decision.nextStep,
-			budgetExceeded: decision.budgetExceeded,
-			repeatedNoProgressCount: decision.repeatedNoProgressCount
-		});
-		const workflowProofCheckpoint = workflowReadiness.workflowProofCheckpoint;
-		return {
-			...decision,
-			workflowReadiness,
-			workflowProofCheckpoint,
-			nextActionContract: buildResolveIOAICoderNextActionContract({
-				bundle,
-				action: decision.action,
-				reason: decision.reason,
-				nextLane: decision.nextLane,
-				nextStep: decision.nextStep,
-				budgetExceeded: decision.budgetExceeded,
-				workflowReadiness,
-				workflowProofCheckpoint
-			})
-		};
-	};
-	const budgetExceeded = (budget.loopCount >= budget.maxLoopsPerRun && !managerDecision.loopBudgetShouldReset)
-		|| budget.totalPromptTokenEstimate >= budget.maxTotalPromptTokens
-		|| (last?.promptTokenEstimate || 0) > budget.maxPromptTokensPerNonInitialStep * 2;
-	if (budgetExceeded) {
-		const recoveryPlan = recoveryPlanFor('budget_stop', 'aicoder_v6_budget_guard', {
-			productRepairFailure: false
-		});
-		return withWorkflowReadiness({
-			action: 'budget_stop',
-			reason: 'aicoder_v6_budget_guard',
-			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-			repeatedNoProgressCount,
-			budgetExceeded,
-			...recoveryFieldsFor(recoveryPlan)
-		});
-	}
-	if (managerDecision.action === 'park_ping_pong') {
-		return withWorkflowReadiness({
-			action: 'park',
-			reason: 'aicoder_v6_ping_pong_no_progress',
-			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-			repeatedNoProgressCount: managerDecision.pingPongCount,
-			budgetExceeded: false,
-			...managerRecoveryFields()
-		});
-	}
-	if (managerDecision.action === 'park_repeated_failure') {
-		return withWorkflowReadiness({
-			action: 'park',
-			reason: 'aicoder_v6_repeated_no_progress',
-			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-			repeatedNoProgressCount: managerDecision.sameFailureCount,
-			budgetExceeded: false,
-			...managerRecoveryFields()
-		});
-	}
-	if (repeatedNoProgressCount > budget.maxRepeatedNoProgress) {
-		const recoveryPlan = recoveryPlanFor('park', 'aicoder_v6_repeated_no_progress', {
-			action: 'park_repeated_failure',
-			productRepairFailure: !/^(?:infra|compile|release)$/i.test(String(last?.failureClass || ''))
-		});
-		return withWorkflowReadiness({
-			action: 'park',
-			reason: 'aicoder_v6_repeated_no_progress',
-			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-			repeatedNoProgressCount,
-			budgetExceeded: false,
-			...recoveryFieldsFor(recoveryPlan)
-		});
-	}
-	if (managerDecision.action === 'retry_infra') {
-		const compileRepair = managerDecision.recoveryPlan.recoveryClass === 'compile_repair'
-			|| managerDecision.failureClass === 'compile'
-			|| last?.failureClass === 'compile';
-		return withWorkflowReadiness({
-			action: 'infra_retry',
-			reason: compileRepair ? 'aicoder_v6_compile_repair_required' : 'aicoder_v6_infra_retry',
-			nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-			nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-			repeatedNoProgressCount,
-			budgetExceeded: false,
-			...managerRecoveryFields()
-		});
-	}
-	if (last?.outcome === 'needs_repair') {
-		if (last.failureClass === 'journey') {
-			return withWorkflowReadiness({
-				action: 'retry_same_step',
-				reason: 'aicoder_v6_journey_contract_repair_required',
-				nextLane: 'plan',
-				nextStep: last.stepType === 'journey_validation' ? 'journey_contract' : last.stepType,
-				repeatedNoProgressCount,
-				budgetExceeded: false,
-				...managerRecoveryFields()
-			});
-		}
-		if (last.failureClass === 'release') {
-			return withWorkflowReadiness({
-				action: 'retry_same_step',
-				reason: 'aicoder_v6_release_repair_required',
-				nextLane: 'publish',
-				nextStep: last.stepType,
-				repeatedNoProgressCount,
-				budgetExceeded: false,
-				...managerRecoveryFields()
-			});
-		}
-		return withWorkflowReadiness({
-			action: last.lane === 'repair' ? 'retry_same_step' : 'switch_to_repair',
-			reason: 'aicoder_v6_repair_required',
-			nextLane: 'repair',
-			nextStep: 'repair',
-			repeatedNoProgressCount,
-			budgetExceeded: false,
-			...managerRecoveryFields()
-		});
-	}
-	if (last?.outcome === 'infra_retry') {
-		const recoveryPlan = recoveryPlanFor('infra_retry', 'aicoder_v6_infra_retry', {
-			failureClass: 'infra',
-			productRepairFailure: false
-		});
-		return withWorkflowReadiness({
-			action: 'infra_retry',
-			reason: 'aicoder_v6_infra_retry',
-			nextLane: last.lane,
-			nextStep: last.stepType,
-			repeatedNoProgressCount,
-			budgetExceeded: false,
-			...recoveryFieldsFor(recoveryPlan)
-		});
-	}
-	if (last?.outcome === 'ready_to_publish') {
-		const recoveryPlan = recoveryPlanFor('ready_to_publish', 'aicoder_v6_ready_to_publish', {
-			failureClass: 'release',
-			productRepairFailure: false
-		});
-		return withWorkflowReadiness({
-			action: 'ready_to_publish',
-			reason: 'aicoder_v6_ready_to_publish',
-			nextLane: 'publish',
-			nextStep: 'publish',
-			repeatedNoProgressCount,
-			budgetExceeded: false,
-			...recoveryFieldsFor(recoveryPlan)
-		});
-	}
-	const recoveryPlan = managerDecision.recoveryPlan || recoveryPlanFor('continue', 'aicoder_v6_continue');
-	const fallbackCheckpoint = managerDecision.recoveryCheckpoint || recoveryCheckpointFor(recoveryPlan);
-	return withWorkflowReadiness({
-		action: 'continue',
-		reason: 'aicoder_v6_continue',
-		nextLane: last?.lane || bundle.aiCoderV6SupervisorState.activeLane,
-		nextStep: last?.stepType || bundle.aiCoderV6SupervisorState.activeStep,
-		repeatedNoProgressCount,
-		budgetExceeded: false,
-		...recoveryFieldsFor(recoveryPlan, fallbackCheckpoint, managerDecision.recoveryEvidenceProbe)
-	});
-}
-
-export function buildResolveIOAICoderV6DiagnoseFirstPrompt(lines: {
-	goal?: string;
-	approvedScope?: string[];
-	activeLane?: ResolveIOAICoderV6Lane;
-	activeStep?: ResolveIOAICoderV6StepType;
-	activeBlocker?: string;
-	laneSummary?: string;
-	currentQaRow?: ResolveIOAICoderV6LaneMemory['activeQaRow'];
-	journeyContractPath?: string;
-	activeWorkflowStep?: string;
-	artifactPaths?: string[];
-	changedFiles?: string[];
-}): string[] {
-	return [
-		'AICoder Runner V6 contract: use compact lane memory, diagnose first, then make the smallest proven next move.',
-		'Start with Diagnose First: observed evidence, likely cause, smallest next action, and expected proof.',
-		'Use current artifacts, changed files, and lane memory before asking for broad context.',
-		'Do not spawn duplicate build, QA, browser, server, Mongo, or Codex processes.',
-		'If repairing, inspect logs/artifacts/source/diff first; retest the failed check before advancing.',
-		'If the same blocker repeats without new proof, park with the exact blocker instead of burning more tokens.',
-		lines.goal ? `Goal: ${cleanText(lines.goal, 500)}` : '',
-		cleanList(lines.approvedScope, 12, 240).length ? `Approved scope: ${cleanList(lines.approvedScope, 12, 240).join(' | ')}` : '',
-		lines.activeLane ? `Active lane: ${lines.activeLane}` : '',
-		lines.activeStep ? `Active step: ${lines.activeStep}` : '',
-		lines.laneSummary ? `Lane memory: ${cleanText(lines.laneSummary, 700)}` : '',
-		lines.activeBlocker ? `Active blocker: ${cleanText(lines.activeBlocker, 800)}` : '',
-		lines.currentQaRow?.workflow ? `Current QA row: ${cleanText(lines.currentQaRow.workflow, 300)}` : '',
-		lines.currentQaRow?.route ? `Current QA route: ${cleanText(lines.currentQaRow.route, 300)}` : '',
-		lines.journeyContractPath ? `Journey contract: ${cleanText(lines.journeyContractPath, 240)}` : '',
-		lines.activeWorkflowStep ? `Active workflow step: ${cleanText(lines.activeWorkflowStep, 240)}` : '',
-		cleanList(lines.changedFiles, 12, 200).length ? `Changed files: ${cleanList(lines.changedFiles, 12, 200).join(', ')}` : '',
-		cleanList(lines.artifactPaths, 12, 240).length ? `Artifacts: ${cleanList(lines.artifactPaths, 12, 240).join(', ')}` : ''
-	].filter(Boolean);
-}
-
-export function buildResolveIOAICoderV6Incident(input: {
-	incidentClass: string;
-	summary: string;
-	stepType?: ResolveIOAICoderV6StepType;
-	lane?: ResolveIOAICoderV6Lane;
-	blocker?: string;
-	artifactPaths?: string[];
-	now?: Date | string;
-}): ResolveIOAICoderV6RunnerIncident {
-	return {
-		incidentClass: cleanText(input.incidentClass, 120) || 'aicoder_v6_runner_incident',
-		summary: cleanText(input.summary, 1200),
-		stepType: input.stepType,
-		lane: input.lane,
-		blockerFingerprint: input.blocker ? fingerprintResolveIOAICoderV6Blocker(input.blocker) : undefined,
-		artifactPaths: cleanList(input.artifactPaths, 40, 500),
-		recordedAt: isoNow(input.now)
-	};
-}