@resolveio/server-lib 22.3.140 → 22.3.142

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

@@ -0,0 +1,875 @@
+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;
+	stepId?: string;
+	route?: string;
+	action?: string;
+	assertion?: string;
+	expectedState?: 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 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?: ResolveIOAICoderV6ContinuationDecision['action'];
+	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;
+}
+
+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?: ResolveIOAICoderV6ContinuationDecision['action'];
+	now?: Date | string;
+}
+
+export interface ResolveIOAICoderV6ContinuationDecision {
+	action: 'continue' | 'retry_same_step' | 'switch_to_repair' | 'park' | 'budget_stop' | 'infra_retry' | 'ready_to_publish';
+	reason: string;
+	nextLane: ResolveIOAICoderV6Lane;
+	nextStep: ResolveIOAICoderV6StepType;
+	repeatedNoProgressCount: number;
+	budgetExceeded: boolean;
+	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 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,
+			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,
+			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;
+}
+
+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';
+}
+
+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),
+		...(step.stepType === 'workflow_qa' ? cleanList(step.artifactPaths, 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 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: managerDecision.recoveryPlan,
+		aiCoderV6RecoveryCheckpoint: managerDecision.recoveryCheckpoint,
+		aiCoderV6RecoveryEvidenceProbe: managerDecision.recoveryEvidenceProbe,
+		aiCoderV6RecoveryAction: managerDecision.recoveryAction
+	};
+}
+
+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 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 {
+			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 {
+			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 {
+			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 {
+			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 {
+			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 {
+				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 {
+				action: 'retry_same_step',
+				reason: 'aicoder_v6_release_repair_required',
+				nextLane: 'publish',
+				nextStep: last.stepType,
+				repeatedNoProgressCount,
+				budgetExceeded: false,
+				...managerRecoveryFields()
+			};
+		}
+		return {
+			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 {
+			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 {
+			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 {
+		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)
+	};
+}