@resolveio/server-lib 22.3.142 → 22.3.144

package/src/util/support-runner-v5.ts

@@ -1,2065 +0,0 @@
-import {
-	buildResolveIOAIManagerRecoveryCheckpoint,
-	buildResolveIOAIManagerRecoveryActionPacket,
-	buildResolveIOAIManagerRecoveryEvidenceProbe,
-	buildResolveIOAIManagerRecoveryPlan,
-	decideResolveIOAIManagerPolicy,
-	hashResolveIOAIManagerEvidence,
-	ResolveIOAIManagerRecoveryCheckpoint,
-	ResolveIOAIManagerRecoveryActionPacket,
-	ResolveIOAIManagerRecoveryActionDispatchRecord,
-	ResolveIOAIManagerRecoveryExecutionDirective,
-	ResolveIOAIManagerRecoveryEvidenceProbe,
-	ResolveIOAIManagerRecoveryPlan,
-	ResolveIOAIManagerRecoveryPlanInput
-} from './ai-runner-manager-policy';
-
-export type ResolveIOSupportV5StepType =
-	| 'diagnosis_gate'
-	| 'reproduction_probe'
-	| 'issue_class_probe'
-	| 'business_proof'
-	| 'compile_check'
-	| 'startup_check'
-	| 'live_seed'
-	| 'auth_bootstrap'
-	| 'route_probe'
-	| 'qa_row'
-	| 'build_repair'
-	| 'qa_retest'
-	| 'pr_review'
-	| 'artifact_package'
-	| 'cleanup';
-
-export type ResolveIOSupportV5Outcome =
-	| 'pass'
-	| 'needs_repair'
-	| 'retry_same_step'
-	| 'park_manual'
-	| 'budget_stop'
-	| 'infra_retry'
-	| 'ready_for_merge';
-
-export type ResolveIOSupportV5Lane = 'build' | 'qa' | 'review' | 'supervisor';
-
-export type ResolveIOSupportIssueClass =
-	| 'no_op_submit'
-	| 'missing_wrong_data'
-	| 'filter_query_mismatch'
-	| 'invoice_pdf_export'
-	| 'upload_import'
-	| 'route_auth_hydration'
-	| 'slow_query_performance';
-
-export type ResolveIOSupportDiagnosisGateStatus = 'missing' | 'incomplete' | 'blocked' | 'passed';
-
-export type ResolveIOSupportV5FailureClass =
-	| 'diagnosis'
-	| 'infra'
-	| 'compile'
-	| 'route'
-	| 'business'
-	| 'product_code'
-	| 'qa_evidence'
-	| 'release'
-	| 'unknown';
-
-export interface ResolveIOSupportDiagnosisIssueCase {
-	customer_complaint: string;
-	expected_result: string;
-	observed_result: string;
-	route_module: string;
-	account_customer_context: string;
-	reproduction_status: 'reproduced' | 'blocked' | 'classified';
-	reproduction_blocker?: string;
-}
-
-export interface ResolveIOSupportDiagnosisHypothesis {
-	statement: string;
-	falsifiable_test: string;
-	evidence: string[];
-}
-
-export interface ResolveIOSupportDiagnosisFailingPath {
-	frontend?: string;
-	backend?: string;
-	shared_library?: string;
-	data_query?: string;
-	description: string;
-}
-
-export interface ResolveIOSupportDiagnosisProofPlan {
-	before: string;
-	before_state_unavailable_reason?: string;
-	action: string;
-	after: string;
-	business_assertion: string;
-	route?: string;
-	data_assertion?: string;
-	artifact_expectation?: string;
-}
-
-export interface ResolveIOSupportDiagnosisHint {
-	id?: string;
-	ticketNumber?: string;
-	title?: string;
-	outcome?: string;
-	issueClass?: string;
-	ownerFiles?: string[];
-	commitSha?: string;
-	commitMessage?: string;
-	reason?: string;
-}
-
-export interface ResolveIOSupportDiagnosisEvidence {
-	type: 'ticket' | 'browser' | 'mongo' | 'log' | 'code' | 'commit' | 'qa' | 'other';
-	summary: string;
-	artifactPath?: string;
-}
-
-export interface ResolveIOSupportDiagnosisGate {
-	issue_case: ResolveIOSupportDiagnosisIssueCase;
-	issue_class: ResolveIOSupportIssueClass;
-	accepted_hypothesis: ResolveIOSupportDiagnosisHypothesis;
-	rejected_alternatives: string[];
-	failing_path: ResolveIOSupportDiagnosisFailingPath;
-	owner_files: string[];
-	proof_plan: ResolveIOSupportDiagnosisProofPlan;
-	similar_tickets?: ResolveIOSupportDiagnosisHint[];
-	similar_commits?: ResolveIOSupportDiagnosisHint[];
-	evidence: ResolveIOSupportDiagnosisEvidence[];
-	status: ResolveIOSupportDiagnosisGateStatus;
-	updatedAt?: string;
-}
-
-export interface ResolveIOSupportDiagnosisGateValidation {
-	valid: boolean;
-	status: ResolveIOSupportDiagnosisGateStatus;
-	blockers: string[];
-	normalized?: ResolveIOSupportDiagnosisGate;
-}
-
-export interface ResolveIOSupportIssueClassProbe {
-	issue_class: ResolveIOSupportIssueClass;
-	probe_type: ResolveIOSupportV5StepType;
-	objective: string;
-	route?: string;
-	action: string;
-	expected_evidence: string;
-	blocks_acceptance_without_business_assertion: boolean;
-}
-
-export interface ResolveIOSupportV5RepeatStopInput {
-	history: ResolveIOSupportV5StepRecord[];
-	failureClass?: ResolveIOSupportV5FailureClass | string;
-	blocker?: string;
-	evidence?: any;
-	evidenceHash?: string;
-	limit?: number;
-	ignoreInfra?: boolean;
-}
-
-export interface ResolveIOSupportV5RepeatStopDecision {
-	shouldStop: boolean;
-	repeatedCount: number;
-	failureClass: string;
-	blockerFingerprint: string;
-	evidenceHash: string;
-	reason: string;
-}
-
-export type ResolveIOSupportV5RepairGateAction =
-	| 'diagnose_only'
-	| 'infra_repair_only'
-	| 'allow_product_repair'
-	| 'reject_out_of_scope'
-	| 'park_repeated_failure';
-
-export interface ResolveIOSupportV5RepairGateInput {
-	diagnosisGate?: any;
-	activeStepType?: ResolveIOSupportV5StepType | string;
-	changedFiles?: any;
-	failureClass?: ResolveIOSupportV5FailureClass | string;
-	blocker?: string;
-	evidence?: any;
-	evidenceHash?: string;
-	history?: ResolveIOSupportV5StepRecord[];
-	maxOwnerFiles?: number;
-	maxRepeatedNoProgress?: number;
-	allowTestsOutsideOwnerFiles?: boolean;
-}
-
-export interface ResolveIOSupportV5RepairGateDecision {
-	action: ResolveIOSupportV5RepairGateAction;
-	canEditProductCode: boolean;
-	blockers: string[];
-	ownerFiles: string[];
-	issueClass?: ResolveIOSupportIssueClass;
-	proofPlan?: ResolveIOSupportDiagnosisProofPlan;
-	outsideOwnerFiles: string[];
-	repeatedFailure?: ResolveIOSupportV5RepeatStopDecision;
-	diagnosisValidation: ResolveIOSupportDiagnosisGateValidation;
-	recoveryPlan: ResolveIOAIManagerRecoveryPlan;
-	recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
-	recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
-	recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
-}
-
-export type ResolveIOSupportV5MicrotaskStatus =
-	| 'pending'
-	| 'in_progress'
-	| 'pass'
-	| 'needs_repair'
-	| 'blocked'
-	| 'parked';
-
-export type ResolveIOSupportV5MicrotaskType =
-	| ResolveIOSupportV5StepType
-	| 'planning'
-	| 'scope_slice'
-	| 'product_repair'
-	| 'runner_repair';
-
-export interface ResolveIOSupportV5PromptBudget {
-	initialPlannerCap: number;
-	buildMicrotaskCap: number;
-	buildMicrotaskHardCap: number;
-	qaMicrotaskCap: number;
-	qaMicrotaskHardCap: number;
-	repairMicrotaskCap: number;
-	repairMicrotaskHardCap: number;
-}
-
-export interface ResolveIOSupportV5Microtask {
-	microtaskId: string;
-	lane: ResolveIOSupportV5Lane;
-	type: ResolveIOSupportV5MicrotaskType;
-	status: ResolveIOSupportV5MicrotaskStatus;
-	objective: string;
-	targetFiles: string[];
-	contextRefs: string[];
-	selfGate: string;
-	acceptanceProof: string;
-	threadKey: string;
-	promptTokenEstimate?: number;
-	attempts: number;
-	dependsOn: string[];
-	parentScopeId?: string;
-	blocker?: string;
-	createdAt: string;
-	updatedAt: string;
-}
-
-export interface ResolveIOSupportV5UsageSection {
-	name: string;
-	tokenEstimate: number;
-}
-
-export interface ResolveIOSupportV5MicrotaskUsage {
-	microtaskId: string;
-	lane: ResolveIOSupportV5Lane;
-	model?: string;
-	threadKey?: string;
-	reuseThread: boolean;
-	freshReason?: string;
-	promptTokenEstimate: number;
-	promptSections: ResolveIOSupportV5UsageSection[];
-	actualInputTokens?: number;
-	actualCachedInputTokens?: number;
-	actualOutputTokens?: number;
-	durationMs?: number;
-	outcome?: ResolveIOSupportV5Outcome | ResolveIOSupportV5MicrotaskStatus;
-	recordedAt: string;
-}
-
-export interface ResolveIOSupportV5Budget {
-	maxPromptTokensPerNonInitialStep: number;
-	maxLoopsPerTicket: number;
-	maxRepeatedNoProgress: number;
-	maxRuntimeMinutesPerLoop: number;
-	totalPromptTokenEstimate: number;
-	totalRuntimeMs: number;
-	loopCount: number;
-}
-
-export interface ResolveIOSupportV5LaneMemory {
-	lane: ResolveIOSupportV5Lane;
-	model: string;
-	threadKey: string;
-	scopeSummary: string;
-	activeBlocker: string;
-	activeQaRow?: {
-		index?: number;
-		workflow?: string;
-		route?: string;
-		assertion?: string;
-		status?: string;
-	};
-	changedFiles: string[];
-	artifactPaths: string[];
-	latestPromptTokenEstimate?: number;
-	updatedAt: string;
-}
-
-export interface ResolveIOSupportV5FailureFingerprint {
-	stepType: ResolveIOSupportV5StepType;
-	failureClass: string;
-	blockerFingerprint: string;
-	evidenceHash: string;
-	recordedAt: string;
-}
-
-export interface ResolveIOSupportV5SupervisorState {
-	version: 'v5';
-	status: 'active' | 'parked' | 'complete';
-	currentGoal: string;
-	approvedScope: string;
-	prBranch: string;
-	activeStep: ResolveIOSupportV5StepType;
-	activeBlocker: string;
-	lastGoodCheckpoint: string;
-	currentQaRow?: ResolveIOSupportV5LaneMemory['activeQaRow'];
-	processLease?: {
-		runId?: string;
-		token?: string;
-		generation?: number;
-		workspace?: string;
-		lane?: string;
-	};
-	artifactLinks: string[];
-	noEmailUnlessApproved: boolean;
-	updatedAt: string;
-}
-
-export interface ResolveIOSupportV5StepRecord {
-	microtaskId?: string;
-	stepType: ResolveIOSupportV5StepType;
-	outcome: ResolveIOSupportV5Outcome;
-	lane: ResolveIOSupportV5Lane;
-	model?: string;
-	threadKey?: string;
-	promptTokenEstimate?: number;
-	runtimeMs?: number;
-	summary: string;
-	blocker?: string;
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	diagnosisGate?: ResolveIOSupportDiagnosisGate;
-	failureClass?: ResolveIOSupportV5FailureClass | string;
-	blockerFingerprint?: string;
-	evidenceHash?: string;
-	recordedAt: string;
-}
-
-export interface ResolveIOSupportV5RunnerIncident {
-	incidentClass: string;
-	summary: string;
-	stepType?: ResolveIOSupportV5StepType;
-	blockerFingerprint?: string;
-	artifactPaths?: string[];
-	recordedAt: string;
-}
-
-export interface ResolveIOSupportV5StateBundle {
-	supportWorkflowVersion: 'v5';
-	supportV5SupervisorState: ResolveIOSupportV5SupervisorState;
-	supportV5DiagnosisGate?: ResolveIOSupportDiagnosisGate;
-	supportV5LaneMemory: {
-		build: ResolveIOSupportV5LaneMemory;
-		qa: ResolveIOSupportV5LaneMemory;
-	};
-	supportV5StepHistory: ResolveIOSupportV5StepRecord[];
-	supportV5Budget: ResolveIOSupportV5Budget;
-	supportV5RunnerIncidents: ResolveIOSupportV5RunnerIncident[];
-	supportV5MicrotaskLedger: ResolveIOSupportV5Microtask[];
-	supportV5ActiveMicrotaskId?: string;
-	supportV5ScopeDigest?: string;
-	supportV5MicrotaskUsageHistory: ResolveIOSupportV5MicrotaskUsage[];
-	supportV5FailureFingerprints?: ResolveIOSupportV5FailureFingerprint[];
-	supportV5RecoveryPlan?: ResolveIOAIManagerRecoveryPlan;
-	supportV5RecoveryCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
-	supportV5RecoveryEvidenceProbe?: ResolveIOAIManagerRecoveryEvidenceProbe;
-	supportV5RecoveryAction?: ResolveIOAIManagerRecoveryActionPacket;
-	supportV5RecoveryDispatchHistory?: ResolveIOAIManagerRecoveryActionDispatchRecord[];
-	supportV5RecoveryDirective?: ResolveIOAIManagerRecoveryExecutionDirective;
-}
-
-export interface ResolveIOSupportV5InitializeInput {
-	jobId: string;
-	ticketId?: string;
-	ticketNumber?: string;
-	title?: string;
-	description?: string;
-	approvedScopeRequirements?: string[];
-	approvedScopeHours?: number | null;
-	prBranch?: string;
-	buildThreadKey?: string;
-	qaThreadKey?: string;
-	processLease?: ResolveIOSupportV5SupervisorState['processLease'];
-	now?: Date | string;
-	existing?: Partial<ResolveIOSupportV5StateBundle>;
-}
-
-export interface ResolveIOSupportV5StepInput {
-	microtaskId?: string;
-	stepType: ResolveIOSupportV5StepType;
-	outcome: ResolveIOSupportV5Outcome;
-	lane: ResolveIOSupportV5Lane;
-	model?: string;
-	threadKey?: string;
-	promptTokenEstimate?: number;
-	runtimeMs?: number;
-	summary?: string;
-	blocker?: string;
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	diagnosisGate?: ResolveIOSupportDiagnosisGate;
-	failureClass?: ResolveIOSupportV5FailureClass | string;
-	evidenceHash?: string;
-	activeQaRow?: ResolveIOSupportV5LaneMemory['activeQaRow'];
-	now?: Date | string;
-}
-
-export interface ResolveIOSupportV5ContinuationDecision {
-	action: 'continue' | 'park';
-	reason: string;
-	nextStep: ResolveIOSupportV5StepType;
-	repeatedNoProgressCount: number;
-	budgetExceeded: boolean;
-	recoveryPlan: ResolveIOAIManagerRecoveryPlan;
-	recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
-	recoveryEvidenceProbe: ResolveIOAIManagerRecoveryEvidenceProbe;
-	recoveryAction: ResolveIOAIManagerRecoveryActionPacket;
-}
-
-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 cleanObject(value: any): Record<string, any> {
-	return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-}
-
-function pickText(source: Record<string, any>, fields: string[], max = 1000): string {
-	for (const field of fields) {
-		const normalized = cleanText(source?.[field], max);
-		if (normalized) {
-			return normalized;
-		}
-	}
-	return '';
-}
-
-function normalizeIssueClass(value: any): ResolveIOSupportIssueClass | '' {
-	const normalized = cleanText(value, 80)
-		.toLowerCase()
-		.replace(/[\s-]+/g, '_');
-	const aliases: Record<string, ResolveIOSupportIssueClass> = {
-		no_op: 'no_op_submit',
-		no_op_submit: 'no_op_submit',
-		submit_noop: 'no_op_submit',
-		missing_data: 'missing_wrong_data',
-		wrong_data: 'missing_wrong_data',
-		missing_wrong_data: 'missing_wrong_data',
-		filter_mismatch: 'filter_query_mismatch',
-		query_mismatch: 'filter_query_mismatch',
-		filter_query_mismatch: 'filter_query_mismatch',
-		invoice_pdf_export: 'invoice_pdf_export',
-		pdf_export: 'invoice_pdf_export',
-		export: 'invoice_pdf_export',
-		upload: 'upload_import',
-		import: 'upload_import',
-		upload_import: 'upload_import',
-		route_auth: 'route_auth_hydration',
-		auth_hydration: 'route_auth_hydration',
-		route_auth_hydration: 'route_auth_hydration',
-		slow_query: 'slow_query_performance',
-		performance: 'slow_query_performance',
-		slow_query_performance: 'slow_query_performance'
-	};
-	return aliases[normalized] || '';
-}
-
-function normalizeReproductionStatus(value: any): ResolveIOSupportDiagnosisIssueCase['reproduction_status'] {
-	const normalized = cleanText(value, 80).toLowerCase();
-	if (/blocked|unable|cannot/.test(normalized)) {
-		return 'blocked';
-	}
-	if (/classif|triag|inferred/.test(normalized)) {
-		return 'classified';
-	}
-	return 'reproduced';
-}
-
-function normalizeSupportDiagnosisEvidence(values: any): ResolveIOSupportDiagnosisEvidence[] {
-	const allowed = new Set(['ticket', 'browser', 'mongo', 'log', 'code', 'commit', 'qa', 'other']);
-	if (!Array.isArray(values)) {
-		const summary = cleanText(values, 1200);
-		return summary ? [{ type: 'other', summary }] : [];
-	}
-	const stringEvidence: ResolveIOSupportDiagnosisEvidence[] = values
-		.filter((entry) => typeof entry === 'string')
-		.map((entry) => ({
-			type: 'other' as const,
-			summary: cleanText(entry, 1200)
-		}));
-	const objectEvidence: ResolveIOSupportDiagnosisEvidence[] = values
-		.filter((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
-		.map((entry) => {
-			const type = cleanText(entry.type, 80).toLowerCase();
-			return {
-				type: (allowed.has(type) ? type : 'other') as ResolveIOSupportDiagnosisEvidence['type'],
-				summary: cleanText(entry.summary || entry.message || entry.evidence || entry.reason, 1200),
-				artifactPath: cleanText(entry.artifactPath || entry.path || entry.file, 500)
-			};
-		});
-	return stringEvidence.concat(objectEvidence)
-		.filter((entry) => entry.summary)
-		.slice(0, 20);
-}
-
-function normalizeSupportDiagnosisHints(values: any): ResolveIOSupportDiagnosisHint[] {
-	return (Array.isArray(values) ? values : [])
-		.map((entry) => {
-			if (typeof entry === 'string') {
-				return { reason: cleanText(entry, 500) };
-			}
-			const value = cleanObject(entry);
-			return {
-				id: cleanText(value.id || value._id, 160),
-				ticketNumber: cleanText(value.ticketNumber || value.ticket_number || value.sourceTicketNumber, 80),
-				title: cleanText(value.title || value.summary, 300),
-				outcome: cleanText(value.outcome || value.status, 80),
-				issueClass: cleanText(value.issueClass || value.issue_class, 80),
-				ownerFiles: cleanList(value.ownerFiles || value.owner_files || value.files, 8, 240),
-				commitSha: cleanText(value.commitSha || value.commit_sha, 80),
-				commitMessage: cleanText(value.commitMessage || value.commit_message, 300),
-				reason: cleanText(value.reason || value.matchReason || value.match_reason, 500)
-			};
-		})
-		.filter((entry) => entry.id || entry.ticketNumber || entry.title || entry.reason || entry.commitSha)
-		.slice(0, 8);
-}
-
-function normalizeOwnerFilePath(value: any): string {
-	return cleanText(value, 500)
-		.replace(/\\/g, '/')
-		.replace(/^\.\/+/, '')
-		.replace(/^\/+/, '')
-		.replace(/\s+$/g, '');
-}
-
-function ownerFileLooksBroad(value: string): boolean {
-	const normalized = normalizeOwnerFilePath(value);
-	return !normalized
-		|| normalized.includes('*')
-		|| normalized.endsWith('/')
-		|| !/\.[a-z0-9]+$/i.test(normalized)
-		|| /^(\.|src|server|angular|client|app|lib|packages?)$/i.test(normalized)
-		|| /(^|\/)(node_modules|dist|build|coverage|\.git)(\/|$)/i.test(normalized);
-}
-
-function proofPlanLooksRouteOnly(proofPlan: ResolveIOSupportDiagnosisProofPlan): boolean {
-	const assertionText = cleanText([
-		proofPlan.business_assertion,
-		proofPlan.action,
-		proofPlan.after,
-		proofPlan.data_assertion,
-		proofPlan.artifact_expectation
-	].filter(Boolean).join(' '), 3000).toLowerCase();
-	if (!assertionText) {
-		return false;
-	}
-	const routeOnlySignal = /\b(route|page|screen|dashboard|url|component|shell)\b/.test(assertionText)
-		&& /\b(loads?|loaded|renders?|rendered|opens?|opened|visible|visibility|hydrates?|hydrated|screenshot)\b/.test(assertionText);
-	const businessSignal = /\b(save|saved|persist|persisted|create|created|update|updated|delete|deleted|filter|filtered|exclude|excluded|include|included|row|rows|record|records|count|counts|total|totals|value|values|data|mongo|query|result|results|invoice|pdf|export|download|upload|import|dropdown|selection|selected|form|submit|submitted|validation|error message|customer|account|user|permission|auth|control|button|status|calculation|performance|duration|latency)\b/.test(assertionText);
-	return routeOnlySignal && !businessSignal;
-}
-
-export function normalizeResolveIOSupportDiagnosisGate(value: any, now?: Date | string): ResolveIOSupportDiagnosisGate | undefined {
-	const source = cleanObject(value);
-	if (!Object.keys(source).length) {
-		return undefined;
-	}
-	const issueCaseSource = cleanObject(source.issue_case || source.issueCase);
-	const hypothesisSource = cleanObject(source.accepted_hypothesis || source.acceptedHypothesis);
-	const failingPathSource = cleanObject(source.failing_path || source.failingPath);
-	const proofPlanSource = cleanObject(source.proof_plan || source.proofPlan);
-	const issueClass = normalizeIssueClass(source.issue_class || source.issueClass);
-	const ownerFiles = cleanList(source.owner_files || source.ownerFiles, 20, 500)
-		.map(normalizeOwnerFilePath)
-		.filter(Boolean);
-	const gate: ResolveIOSupportDiagnosisGate = {
-		issue_case: {
-			customer_complaint: pickText(issueCaseSource, ['customer_complaint', 'customerComplaint', 'complaint', 'request', 'summary'], 1200),
-			expected_result: pickText(issueCaseSource, ['expected_result', 'expectedResult', 'expected'], 1000),
-			observed_result: pickText(issueCaseSource, ['observed_result', 'observedResult', 'observed', 'actual'], 1000),
-			route_module: pickText(issueCaseSource, ['route_module', 'routeModule', 'route', 'module', 'screen'], 500),
-			account_customer_context: pickText(issueCaseSource, ['account_customer_context', 'accountCustomerContext', 'account', 'customer', 'user', 'context'], 800),
-			reproduction_status: normalizeReproductionStatus(issueCaseSource.reproduction_status || issueCaseSource.reproductionStatus || source.reproduction_status),
-			reproduction_blocker: pickText(issueCaseSource, ['reproduction_blocker', 'reproductionBlocker', 'blocked_reason', 'blockedReason'], 1000)
-		},
-		issue_class: issueClass || 'missing_wrong_data',
-		accepted_hypothesis: {
-			statement: pickText(hypothesisSource, ['statement', 'hypothesis', 'root_cause', 'rootCause', 'summary'], 1200)
-				|| (typeof source.accepted_hypothesis === 'string' ? cleanText(source.accepted_hypothesis, 1200) : ''),
-			falsifiable_test: pickText(hypothesisSource, ['falsifiable_test', 'falsifiableTest', 'test', 'proof', 'falsifier'], 1000),
-			evidence: cleanList(hypothesisSource.evidence || source.hypothesis_evidence || source.hypothesisEvidence, 10, 800)
-		},
-		rejected_alternatives: cleanList(source.rejected_alternatives || source.rejectedAlternatives, 10, 700),
-		failing_path: {
-			frontend: pickText(failingPathSource, ['frontend', 'frontend_path', 'frontendPath', 'eventPath'], 700),
-			backend: pickText(failingPathSource, ['backend', 'backend_path', 'backendPath', 'methodPublicationPath'], 700),
-			shared_library: pickText(failingPathSource, ['shared_library', 'sharedLibrary', 'library', 'lib'], 700),
-			data_query: pickText(failingPathSource, ['data_query', 'dataQuery', 'query'], 700),
-			description: pickText(failingPathSource, ['description', 'path', 'summary'], 1200) || cleanText(source.failing_path, 1200)
-		},
-		owner_files: ownerFiles,
-		proof_plan: {
-			before: pickText(proofPlanSource, ['before', 'before_state', 'beforeState', 'precondition'], 1000),
-			before_state_unavailable_reason: pickText(proofPlanSource, ['before_state_unavailable_reason', 'beforeStateUnavailableReason', 'before_unavailable_reason'], 1000),
-			action: pickText(proofPlanSource, ['action', 'browser_action', 'browserAction', 'steps'], 1000),
-			after: pickText(proofPlanSource, ['after', 'after_state', 'afterState', 'expected_after'], 1000),
-			business_assertion: pickText(proofPlanSource, ['business_assertion', 'businessAssertion', 'assertion'], 1000),
-			route: pickText(proofPlanSource, ['route', 'url'], 500),
-			data_assertion: pickText(proofPlanSource, ['data_assertion', 'dataAssertion', 'mongo_delta', 'mongoDelta'], 1000),
-			artifact_expectation: pickText(proofPlanSource, ['artifact_expectation', 'artifactExpectation', 'artifact', 'screenshot'], 1000)
-		},
-		similar_tickets: normalizeSupportDiagnosisHints(source.similar_tickets || source.similarTickets),
-		similar_commits: normalizeSupportDiagnosisHints(source.similar_commits || source.similarCommits),
-		evidence: normalizeSupportDiagnosisEvidence(source.evidence),
-		status: (cleanText(source.status, 80).toLowerCase() as ResolveIOSupportDiagnosisGateStatus) || 'incomplete',
-		updatedAt: isoNow(now || source.updatedAt || source.updated_at)
-	};
-	if (!['missing', 'incomplete', 'blocked', 'passed'].includes(gate.status)) {
-		gate.status = 'incomplete';
-	}
-	return gate;
-}
-
-export function extractResolveIOSupportDiagnosisGateFromText(value: string, now?: Date | string): ResolveIOSupportDiagnosisGate | undefined {
-	const text = String(value || '').trim();
-	if (!text) {
-		return undefined;
-	}
-	const candidates: string[] = [];
-	const fenced = Array.from(text.matchAll(/```(?:json)?\s*([\s\S]*?)```/gi)).map((match) => match[1]);
-	candidates.push(...fenced);
-	const jsonBlock = text.match(/\{[\s\S]*\}/);
-	if (jsonBlock) {
-		candidates.push(jsonBlock[0]);
-	}
-	for (const candidate of candidates) {
-		try {
-			const parsed = JSON.parse(candidate);
-			const wrapped = parsed?.support_diagnosis_gate || parsed?.supportDiagnosisGate || parsed?.diagnosis_gate || parsed?.diagnosisGate || parsed;
-			const normalized = normalizeResolveIOSupportDiagnosisGate(wrapped, now);
-			if (normalized) {
-				return normalized;
-			}
-		}
-		catch {
-			// Continue trying less exact JSON candidates.
-		}
-	}
-	return undefined;
-}
-
-export function validateResolveIOSupportDiagnosisGate(
-	value: any,
-	options: { maxOwnerFiles?: number } = {}
-): ResolveIOSupportDiagnosisGateValidation {
-	const normalized = normalizeResolveIOSupportDiagnosisGate(value);
-	if (!normalized) {
-		return { valid: false, status: 'missing', blockers: ['SupportDiagnosisGate is missing.'] };
-	}
-	const blockers: string[] = [];
-	const maxOwnerFiles = Math.max(1, Number(options.maxOwnerFiles || 8) || 8);
-	if (!normalized.issue_case.customer_complaint) {
-		blockers.push('Diagnosis issue_case.customer_complaint is required.');
-	}
-	if (!normalized.issue_case.expected_result) {
-		blockers.push('Diagnosis issue_case.expected_result is required.');
-	}
-	if (!normalized.issue_case.observed_result) {
-		blockers.push('Diagnosis issue_case.observed_result is required.');
-	}
-	if (!normalized.issue_case.route_module) {
-		blockers.push('Diagnosis issue_case.route_module is required.');
-	}
-	if (!normalized.issue_case.account_customer_context) {
-		blockers.push('Diagnosis issue_case.account_customer_context is required.');
-	}
-	if (normalized.issue_case.reproduction_status === 'blocked' && !normalized.issue_case.reproduction_blocker) {
-		blockers.push('Diagnosis blocked reproduction requires issue_case.reproduction_blocker.');
-	}
-	if (!normalizeIssueClass(normalized.issue_class)) {
-		blockers.push('Diagnosis issue_class must be one of the supported issue-class probes.');
-	}
-	if (!normalized.accepted_hypothesis.statement) {
-		blockers.push('Diagnosis accepted_hypothesis.statement is required.');
-	}
-	if (!normalized.accepted_hypothesis.falsifiable_test) {
-		blockers.push('Diagnosis accepted_hypothesis.falsifiable_test is required.');
-	}
-	if (!normalized.accepted_hypothesis.evidence.length) {
-		blockers.push('Diagnosis accepted_hypothesis.evidence must cite proof.');
-	}
-	if (!normalized.rejected_alternatives.length) {
-		blockers.push('Diagnosis rejected_alternatives must include at least one rejected theory.');
-	}
-	if (!normalized.failing_path.description
-		&& !normalized.failing_path.frontend
-		&& !normalized.failing_path.backend
-		&& !normalized.failing_path.shared_library
-		&& !normalized.failing_path.data_query) {
-		blockers.push('Diagnosis failing_path must identify frontend, backend, query, shared library, or path description.');
-	}
-	if (!normalized.owner_files.length) {
-		blockers.push('Diagnosis owner_files must contain the small editable file set.');
-	}
-	if (normalized.owner_files.length > maxOwnerFiles) {
-		blockers.push(`Diagnosis owner_files has ${normalized.owner_files.length} entries; maximum is ${maxOwnerFiles}.`);
-	}
-	const broadFiles = normalized.owner_files.filter(ownerFileLooksBroad);
-	if (broadFiles.length) {
-		blockers.push(`Diagnosis owner_files contains broad or unsafe path(s): ${broadFiles.join(', ')}.`);
-	}
-	if (!normalized.proof_plan.before && !normalized.proof_plan.before_state_unavailable_reason) {
-		blockers.push('Diagnosis proof_plan.before is required unless proof_plan.before_state_unavailable_reason explains why before-state proof is impossible.');
-	}
-	if (!normalized.proof_plan.action) {
-		blockers.push('Diagnosis proof_plan.action is required.');
-	}
-	if (!normalized.proof_plan.after) {
-		blockers.push('Diagnosis proof_plan.after is required.');
-	}
-	if (!normalized.proof_plan.business_assertion) {
-		blockers.push('Diagnosis proof_plan.business_assertion is required.');
-	}
-	if (proofPlanLooksRouteOnly(normalized.proof_plan)) {
-		blockers.push('Diagnosis proof_plan cannot be route-load, screen-visible, or screenshot-only; it must name the business state/data/control change that proves the issue is fixed.');
-	}
-	if (!normalized.evidence.length) {
-		blockers.push('Diagnosis evidence must include ticket/code/browser/log/Mongo proof.');
-	}
-	normalized.status = blockers.length ? 'incomplete' : 'passed';
-	return {
-		valid: blockers.length === 0,
-		status: normalized.status,
-		blockers,
-		normalized
-	};
-}
-
-export function buildResolveIOSupportIssueClassProbes(value: any): ResolveIOSupportIssueClassProbe[] {
-	const validation = validateResolveIOSupportDiagnosisGate(value);
-	const gate = validation.normalized || normalizeResolveIOSupportDiagnosisGate(value);
-	if (!gate) {
-		return [];
-	}
-	const route = gate.proof_plan.route || gate.issue_case.route_module;
-	const proof = gate.proof_plan.business_assertion;
-	const common = {
-		issue_class: gate.issue_class,
-		probe_type: 'issue_class_probe' as ResolveIOSupportV5StepType,
-		route,
-		blocks_acceptance_without_business_assertion: true
-	};
-	const map: Record<ResolveIOSupportIssueClass, { action: string; expected: string }> = {
-		no_op_submit: {
-			action: `Submit the customer action on ${route || 'the affected screen'} and assert a persisted state change or explicit validation message.`,
-			expected: proof || 'Before/action/after proof shows the submit is no longer a no-op.'
-		},
-		missing_wrong_data: {
-			action: `Load the named record/list on ${route || 'the affected route'} and compare visible data to the expected persisted source.`,
-			expected: proof || 'Visible data and persisted data match the customer expectation.'
-		},
-		filter_query_mismatch: {
-			action: 'Apply the reported filter/query inputs and assert the returned rows/counts match the expected dataset.',
-			expected: proof || 'Filter/query output contains the correct included rows and excludes the wrong rows.'
-		},
-		invoice_pdf_export: {
-			action: 'Generate the invoice/PDF/export from the affected route and inspect the downloaded/generated artifact.',
-			expected: proof || 'Generated artifact contains the expected customer-visible rows, totals, or fields.'
-		},
-		upload_import: {
-			action: 'Run the upload/import workflow with a representative file and assert parsed plus persisted results.',
-			expected: proof || 'Import shows a success result and persisted rows/counts changed as expected.'
-		},
-		route_auth_hydration: {
-			action: 'Open the route as the affected user and assert authenticated hydration reaches the functional screen, not a shell.',
-			expected: proof || 'Route hydrates with the required controls/data for the affected account.'
-		},
-		slow_query_performance: {
-			action: 'Run the reported query/workflow with timing/log evidence before and after the fix.',
-			expected: proof || 'Performance evidence shows the slow path improved without changing results.'
-		}
-	};
-	const selected = map[gate.issue_class];
-	return [{
-		...common,
-		objective: `Issue-class probe for ${gate.issue_class}: ${gate.issue_case.customer_complaint}`,
-		action: selected.action,
-		expected_evidence: selected.expected
-	}];
-}
-
-export function hashResolveIOSupportV5Evidence(value: any): string {
-	const raw = typeof value === 'string' ? value : JSON.stringify(value || {});
-	const normalized = cleanText(raw, 8000)
-		.toLowerCase()
-		.replace(/[a-f0-9]{16,}/g, '<id>')
-		.replace(/\b\d{2,}\b/g, '<n>');
-	let hash = 0;
-	for (let index = 0; index < normalized.length; index += 1) {
-		hash = ((hash << 5) - hash + normalized.charCodeAt(index)) | 0;
-	}
-	return `ev-${Math.abs(hash).toString(36) || '0'}`;
-}
-
-export function decideResolveIOSupportV5RepeatedFailureStop(input: ResolveIOSupportV5RepeatStopInput): ResolveIOSupportV5RepeatStopDecision {
-	const failureClass = cleanText(input.failureClass || 'unknown', 80).toLowerCase();
-	const blockerFingerprint = fingerprintResolveIOSupportV5Blocker(input.blocker || '');
-	const evidenceHash = cleanText(input.evidenceHash, 80) || hashResolveIOSupportV5Evidence(input.evidence || input.blocker || '');
-	const limit = Math.max(1, Number(input.limit || 2) || 2);
-	if (input.ignoreInfra !== false && /^(infra|compile)$/.test(failureClass)) {
-		return {
-			shouldStop: false,
-			repeatedCount: 0,
-			failureClass,
-			blockerFingerprint,
-			evidenceHash,
-			reason: 'support_v5_infra_failures_do_not_count_as_product_repair_loops'
-		};
-	}
-	const latestRecord = (input.history || [])[(input.history || []).length - 1];
-	const managerDecision = decideResolveIOAIManagerPolicy({
-		history: (input.history || []).map((entry) => ({
-			outcome: entry.outcome,
-			lane: entry.lane,
-			stepType: entry.stepType,
-			failureClass: entry.failureClass,
-			blocker: entry.blocker || entry.summary,
-			blockerFingerprint: entry.blockerFingerprint,
-			evidenceHash: entry.evidenceHash,
-			changedFiles: entry.changedFiles,
-			artifactPaths: entry.artifactPaths,
-			summary: entry.summary,
-			recordedAt: entry.recordedAt
-		})),
-		current: {
-			outcome: 'needs_repair',
-			lane: latestRecord?.lane,
-			stepType: latestRecord?.stepType,
-			failureClass,
-			blocker: input.blocker,
-			blockerFingerprint,
-			evidenceHash
-		},
-		maxSameFailureRepeats: limit,
-		maxPingPongTransitions: 3,
-		infraFailureClasses: input.ignoreInfra !== false ? ['infra', 'compile'] : []
-	});
-	if (managerDecision.action === 'retry_infra') {
-		return {
-			shouldStop: false,
-			repeatedCount: 0,
-			failureClass,
-			blockerFingerprint,
-			evidenceHash,
-			reason: 'support_v5_infra_failures_do_not_count_as_product_repair_loops'
-		};
-	}
-	if (managerDecision.action === 'park_ping_pong') {
-		return {
-			shouldStop: true,
-			repeatedCount: managerDecision.pingPongCount,
-			failureClass,
-			blockerFingerprint,
-			evidenceHash,
-			reason: 'support_v5_ping_pong_failure_loop'
-		};
-	}
-	if (managerDecision.action === 'park_repeated_failure') {
-		return {
-			shouldStop: true,
-			repeatedCount: managerDecision.sameFailureCount,
-			failureClass,
-			blockerFingerprint,
-			evidenceHash,
-			reason: 'support_v5_same_failure_class_without_new_evidence'
-		};
-	}
-	let repeatedCount = 0;
-	for (let index = (input.history || []).length - 1; index >= 0; index -= 1) {
-		const item = input.history[index];
-		if (item.outcome === 'pass' || item.outcome === 'ready_for_merge') {
-			break;
-		}
-		const itemFailureClass = cleanText(item.failureClass || 'unknown', 80).toLowerCase();
-		const itemBlockerFingerprint = cleanText(item.blockerFingerprint, 80)
-			|| fingerprintResolveIOSupportV5Blocker(item.blocker || item.summary || '');
-		const itemEvidenceHash = cleanText(item.evidenceHash, 80)
-			|| hashResolveIOSupportV5Evidence(item.artifactPaths || item.blocker || item.summary || '');
-		if (itemFailureClass !== failureClass || itemBlockerFingerprint !== blockerFingerprint || itemEvidenceHash !== evidenceHash) {
-			break;
-		}
-		repeatedCount += 1;
-	}
-	return {
-		shouldStop: repeatedCount >= limit,
-		repeatedCount,
-		failureClass,
-		blockerFingerprint,
-		evidenceHash,
-		reason: repeatedCount >= limit
-			? 'support_v5_same_failure_class_without_new_evidence'
-			: 'support_v5_retry_allowed_new_or_below_repeat_limit'
-	};
-}
-
-export function changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(
-	diagnosisGate: any,
-	changedFiles: any,
-	options: { allowTests?: boolean } = {}
-): string[] {
-	const validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
-	if (!validation.valid || !validation.normalized) {
-		return cleanList(changedFiles, 80, 500);
-	}
-	const owners = new Set(validation.normalized.owner_files.map(normalizeOwnerFilePath));
-	return cleanList(changedFiles, 120, 500)
-		.map(normalizeOwnerFilePath)
-		.filter((filePath) => {
-			if (!filePath) {
-				return false;
-			}
-			if (owners.has(filePath)) {
-				return false;
-			}
-			if (options.allowTests && /(^|\/)(tests?|spec|__tests__)(\/|$)|\.(?:spec|test)\.[jt]sx?$/i.test(filePath)) {
-				return false;
-			}
-			return true;
-		});
-}
-
-export function decideResolveIOSupportV5RepairGate(input: ResolveIOSupportV5RepairGateInput): ResolveIOSupportV5RepairGateDecision {
-	const activeStepType = cleanText(input.activeStepType, 80);
-	const failureClass = cleanText(input.failureClass, 80).toLowerCase();
-	const diagnosisValidation = validateResolveIOSupportDiagnosisGate(input.diagnosisGate, {
-		maxOwnerFiles: input.maxOwnerFiles
-	});
-	const ownerFiles = diagnosisValidation.normalized?.owner_files || [];
-	const outsideOwnerFiles = changedFilesOutsideResolveIOSupportDiagnosisOwnerFiles(
-		diagnosisValidation.normalized || input.diagnosisGate,
-		input.changedFiles,
-		{ allowTests: input.allowTestsOutsideOwnerFiles === true }
-	);
-	const repeatedFailure = input.history?.length ? decideResolveIOSupportV5RepeatedFailureStop({
-		history: input.history,
-		failureClass,
-		blocker: input.blocker,
-		evidence: input.evidence,
-		evidenceHash: input.evidenceHash,
-		limit: Math.max(1, Number(input.maxRepeatedNoProgress || 2) || 2),
-		ignoreInfra: true
-	}) : undefined;
-	const recoveryPlanFor = (
-		action: string,
-		reason: string,
-		recoveryFailureClass = failureClass || 'unknown',
-		productRepairFailure = false
-	): ResolveIOAIManagerRecoveryPlan => buildResolveIOAIManagerRecoveryPlan({
-		action,
-		reason,
-		failureClass: recoveryFailureClass,
-		lane: 'build',
-		stepType: activeStepType || 'build_repair',
-		blocker: input.blocker || (diagnosisValidation.blockers || []).join(' | '),
-		changedFiles: cleanList(input.changedFiles, 40, 500),
-		maxSameFailureRepeats: Math.max(1, Number(input.maxRepeatedNoProgress || 2) || 2),
-		productRepairFailure
-	});
-	const recoveryCheckpointFor = (
-		recoveryPlan: ResolveIOAIManagerRecoveryPlan
-	): ResolveIOAIManagerRecoveryCheckpoint => buildResolveIOAIManagerRecoveryCheckpoint({
-		plan: recoveryPlan,
-		current: {
-			lane: 'build',
-			stepType: activeStepType || 'build_repair',
-			failureClass: failureClass || 'unknown',
-			blocker: input.blocker || (diagnosisValidation.blockers || []).join(' | '),
-			evidenceHash: input.evidenceHash,
-			changedFiles: cleanList(input.changedFiles, 40, 500),
-			summary: input.blocker
-		}
-	});
-	const recoveryFieldsFor = (
-		recoveryPlan: ResolveIOAIManagerRecoveryPlan
-	): Pick<ResolveIOSupportV5RepairGateDecision, 'recoveryPlan' | 'recoveryCheckpoint' | 'recoveryEvidenceProbe' | 'recoveryAction'> => {
-		const recoveryCheckpoint = recoveryCheckpointFor(recoveryPlan);
-		const recoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-			checkpoint: recoveryCheckpoint,
-			current: {
-				lane: 'build',
-				stepType: activeStepType || 'build_repair',
-				failureClass: failureClass || 'unknown',
-				blocker: input.blocker || (diagnosisValidation.blockers || []).join(' | '),
-				evidenceHash: input.evidenceHash,
-				changedFiles: cleanList(input.changedFiles, 40, 500),
-				summary: input.blocker
-			}
-		});
-		const current = {
-			lane: 'build',
-			stepType: activeStepType || 'build_repair',
-			failureClass: failureClass || 'unknown',
-			blocker: input.blocker || (diagnosisValidation.blockers || []).join(' | '),
-			evidenceHash: input.evidenceHash,
-			changedFiles: cleanList(input.changedFiles, 40, 500),
-			summary: input.blocker
-		};
-		return {
-			recoveryPlan,
-			recoveryCheckpoint,
-			recoveryEvidenceProbe,
-			recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
-				plan: recoveryPlan,
-				checkpoint: recoveryCheckpoint,
-				probe: recoveryEvidenceProbe,
-				current
-			})
-		};
-	};
-	if (repeatedFailure?.shouldStop) {
-		const recoveryPlan = recoveryPlanFor('park_repeated_failure', repeatedFailure.reason, repeatedFailure.failureClass, true);
-		return {
-			action: 'park_repeated_failure',
-			canEditProductCode: false,
-			blockers: [repeatedFailure.reason],
-			ownerFiles,
-			issueClass: diagnosisValidation.normalized?.issue_class,
-			proofPlan: diagnosisValidation.normalized?.proof_plan,
-			outsideOwnerFiles,
-			repeatedFailure,
-			diagnosisValidation,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	if (failureClass === 'infra' || failureClass === 'compile') {
-		const recoveryPlan = recoveryPlanFor('retry_infra', 'support_v5_infra_or_compile_repair_required', failureClass, false);
-		return {
-			action: 'infra_repair_only',
-			canEditProductCode: false,
-			blockers: ['Infra/compile/Puppeteer/startup failures must be repaired in the harness lane before product-code repair.'],
-			ownerFiles,
-			issueClass: diagnosisValidation.normalized?.issue_class,
-			proofPlan: diagnosisValidation.normalized?.proof_plan,
-			outsideOwnerFiles,
-			repeatedFailure,
-			diagnosisValidation,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	if (activeStepType === 'diagnosis_gate' || !diagnosisValidation.valid) {
-		const recoveryPlan = recoveryPlanFor('continue', 'support_v5_diagnosis_gate_required', 'diagnosis', false);
-		return {
-			action: 'diagnose_only',
-			canEditProductCode: false,
-			blockers: diagnosisValidation.blockers.length
-				? diagnosisValidation.blockers
-				: ['SupportDiagnosisGate is required before product-code repair.'],
-			ownerFiles,
-			issueClass: diagnosisValidation.normalized?.issue_class,
-			proofPlan: diagnosisValidation.normalized?.proof_plan,
-			outsideOwnerFiles,
-			repeatedFailure,
-			diagnosisValidation,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	if (outsideOwnerFiles.length) {
-		const recoveryPlan = recoveryPlanFor('continue', 'support_v5_out_of_scope_requires_diagnosis_revision', 'owner_scope', false);
-		return {
-			action: 'reject_out_of_scope',
-			canEditProductCode: false,
-			blockers: [`Changed files outside diagnosis owner_files; revise diagnosis with new evidence before broadening edits: ${outsideOwnerFiles.join(', ')}`],
-			ownerFiles,
-			issueClass: diagnosisValidation.normalized?.issue_class,
-			proofPlan: diagnosisValidation.normalized?.proof_plan,
-			outsideOwnerFiles,
-			repeatedFailure,
-			diagnosisValidation,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	const recoveryPlan = recoveryPlanFor('continue', 'support_v5_product_repair_allowed_after_diagnosis', failureClass || 'product_code', true);
-	return {
-		action: 'allow_product_repair',
-		canEditProductCode: true,
-		blockers: [],
-		ownerFiles,
-		issueClass: diagnosisValidation.normalized?.issue_class,
-		proofPlan: diagnosisValidation.normalized?.proof_plan,
-		outsideOwnerFiles,
-		repeatedFailure,
-		diagnosisValidation,
-		...recoveryFieldsFor(recoveryPlan)
-	};
-}
-
-export function applyResolveIOSupportDiagnosisGateToMicrotasks(
-	bundle: ResolveIOSupportV5StateBundle,
-	diagnosisGate: any
-): ResolveIOSupportV5StateBundle {
-	const validation = validateResolveIOSupportDiagnosisGate(diagnosisGate);
-	const gate = validation.normalized;
-	if (!gate) {
-		return bundle;
-	}
-	const ownerFiles = gate.owner_files;
-	const probes = buildResolveIOSupportIssueClassProbes(gate);
-	const now = isoNow();
-	const diagnosisMicrotaskId = (bundle.supportV5MicrotaskLedger || [])
-		.find((task) => task.type === 'diagnosis_gate')?.microtaskId
-		|| stableIdFromText('diagnosis', `Root-cause-first diagnosis gate for: ${cleanText(bundle.supportV5ScopeDigest || gate.issue_case.customer_complaint, 360) || 'support ticket'}`);
-	const ledger = (bundle.supportV5MicrotaskLedger || []).map((task) => {
-		if (task.type === 'diagnosis_gate') {
-			return {
-				...task,
-				status: validation.valid ? 'pass' as ResolveIOSupportV5MicrotaskStatus : 'needs_repair' as ResolveIOSupportV5MicrotaskStatus,
-				blocker: validation.valid ? '' : validation.blockers.join(' | '),
-				updatedAt: now
-			};
-		}
-		if (task.lane === 'build' && /repair|product_repair|build_repair/i.test(String(task.type || ''))) {
-			return {
-				...task,
-				targetFiles: ownerFiles,
-				contextRefs: Array.from(new Set([...(task.contextRefs || []), 'supportV5DiagnosisGate', 'owner_files'])),
-				selfGate: `Repair only the diagnosed owner files unless you revise the diagnosis with new evidence. Owner files: ${ownerFiles.join(', ')}.`,
-				acceptanceProof: gate.proof_plan.business_assertion,
-				dependsOn: Array.from(new Set([...(task.dependsOn || []), diagnosisMicrotaskId])),
-				updatedAt: now
-			};
-		}
-		if (task.lane === 'qa' && task.type === 'qa_row') {
-			return {
-				...task,
-				contextRefs: Array.from(new Set([...(task.contextRefs || []), 'supportV5DiagnosisGate', 'proof_plan'])),
-				selfGate: probes[0]?.action || task.selfGate,
-				acceptanceProof: gate.proof_plan.business_assertion || task.acceptanceProof,
-				targetFiles: ownerFiles,
-				updatedAt: now
-			};
-		}
-		return task;
-	});
-	const nextActive = selectResolveIOSupportV5ActiveMicrotask(ledger, bundle.supportV5ActiveMicrotaskId);
-	return {
-		...bundle,
-		supportV5DiagnosisGate: gate,
-		supportV5MicrotaskLedger: ledger,
-		supportV5ActiveMicrotaskId: nextActive?.microtaskId,
-		supportV5LaneMemory: {
-			...bundle.supportV5LaneMemory,
-			build: {
-				...bundle.supportV5LaneMemory.build,
-				changedFiles: ownerFiles,
-				scopeSummary: [
-					bundle.supportV5LaneMemory.build.scopeSummary,
-					`Diagnosis issue class: ${gate.issue_class}`,
-					`Accepted hypothesis: ${gate.accepted_hypothesis.statement}`,
-					`Owner files: ${ownerFiles.join(', ')}`
-				].filter(Boolean).join(' | '),
-				updatedAt: now
-			},
-			qa: {
-				...bundle.supportV5LaneMemory.qa,
-				activeQaRow: {
-					workflow: gate.proof_plan.business_assertion,
-					route: gate.proof_plan.route || gate.issue_case.route_module,
-					assertion: gate.proof_plan.after,
-					status: 'pending'
-				},
-				updatedAt: now
-			}
-		}
-	};
-}
-
-function stableIdFromText(prefix: string, value: string): string {
-	const text = cleanText(value, 2000).toLowerCase();
-	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) || '0'}`;
-}
-
-function estimateTextTokens(value: string): number {
-	const text = String(value || '');
-	if (!text) {
-		return 0;
-	}
-	return Math.max(1, Math.ceil(text.length / 4));
-}
-
-export function fingerprintResolveIOSupportV5Blocker(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>');
-	let hash = 0;
-	for (let index = 0; index < text.length; index += 1) {
-		hash = ((hash << 5) - hash + text.charCodeAt(index)) | 0;
-	}
-	return `v5-${Math.abs(hash).toString(36)}`;
-}
-
-export function buildResolveIOSupportV5Budget(existing?: Partial<ResolveIOSupportV5Budget>): ResolveIOSupportV5Budget {
-	return {
-		maxPromptTokensPerNonInitialStep: Number(existing?.maxPromptTokensPerNonInitialStep || 1800),
-		maxLoopsPerTicket: Number(existing?.maxLoopsPerTicket || 24),
-		maxRepeatedNoProgress: Number(existing?.maxRepeatedNoProgress || 2),
-		maxRuntimeMinutesPerLoop: Number(existing?.maxRuntimeMinutesPerLoop || 15),
-		totalPromptTokenEstimate: Number(existing?.totalPromptTokenEstimate || 0),
-		totalRuntimeMs: Number(existing?.totalRuntimeMs || 0),
-		loopCount: Number(existing?.loopCount || 0)
-	};
-}
-
-export function buildResolveIOSupportV5PromptBudget(existing?: Partial<ResolveIOSupportV5PromptBudget>): ResolveIOSupportV5PromptBudget {
-	return {
-		initialPlannerCap: Number(existing?.initialPlannerCap || 6000),
-		buildMicrotaskCap: Number(existing?.buildMicrotaskCap || 1800),
-		buildMicrotaskHardCap: Number(existing?.buildMicrotaskHardCap || 2500),
-		qaMicrotaskCap: Number(existing?.qaMicrotaskCap || 1500),
-		qaMicrotaskHardCap: Number(existing?.qaMicrotaskHardCap || 2200),
-		repairMicrotaskCap: Number(existing?.repairMicrotaskCap || 1200),
-		repairMicrotaskHardCap: Number(existing?.repairMicrotaskHardCap || 1800)
-	};
-}
-
-export function buildResolveIOSupportV5ScopeDigest(input: {
-	goal?: string;
-	approvedScope?: string | string[];
-	prBranch?: string;
-	maxTokens?: number;
-}): string {
-	const scope = Array.isArray(input.approvedScope)
-		? cleanList(input.approvedScope, 30, 220).join(' | ')
-		: cleanText(input.approvedScope, 4000);
-	const raw = [
-		input.goal ? `Goal: ${cleanText(input.goal, 300)}` : '',
-		scope ? `Approved scope: ${scope}` : '',
-		input.prBranch ? `PR branch: ${cleanText(input.prBranch, 160)}` : ''
-	].filter(Boolean).join('\n');
-	const maxChars = Math.max(400, Math.floor(Number(input.maxTokens || 1000) * 4));
-	return raw.slice(0, maxChars);
-}
-
-export function buildResolveIOSupportV5MicrotaskLedger(input: {
-	scopeDigest: string;
-	requirements?: string[];
-	buildThreadKey: string;
-	qaThreadKey: string;
-	now?: Date | string;
-	existing?: ResolveIOSupportV5Microtask[];
-}): ResolveIOSupportV5Microtask[] {
-	const existing = Array.isArray(input.existing) ? input.existing : [];
-	const completedByObjective = new Map<string, ResolveIOSupportV5Microtask>();
-	for (const task of existing) {
-		if (task && (task.status === 'pass' || task.status === 'parked')) {
-			completedByObjective.set(cleanText(task.objective, 500).toLowerCase(), task);
-		}
-	}
-	const now = isoNow(input.now);
-	const requirements = cleanList(input.requirements, 30, 240);
-	const sourceRequirements = requirements.length
-		? requirements
-		: cleanText(input.scopeDigest, 1000).split(/\s+\|\s+|\r?\n/g).map((line) => line.trim()).filter(Boolean).slice(0, 12);
-	const ledger: ResolveIOSupportV5Microtask[] = [];
-	const diagnosisObjective = `Root-cause-first diagnosis gate for: ${cleanText(input.scopeDigest, 360) || 'support ticket'}`;
-	const diagnosisId = stableIdFromText('diagnosis', diagnosisObjective);
-	const existingDiagnosis = existing.find((task) => task?.type === 'diagnosis_gate' || task?.microtaskId === diagnosisId);
-	ledger.push(existingDiagnosis && (existingDiagnosis.status === 'pass' || existingDiagnosis.status === 'parked') ? existingDiagnosis : {
-		microtaskId: diagnosisId,
-		lane: 'build',
-		type: 'diagnosis_gate',
-		status: existingDiagnosis?.status || 'pending',
-		objective: diagnosisObjective,
-		targetFiles: [],
-		contextRefs: ['scope_digest', 'support_context', 'similar_tickets', 'similar_commits'],
-		selfGate: 'Read-only diagnosis only: reproduce or explicitly classify the issue, accept one falsifiable root-cause hypothesis, reject alternatives, identify the failing path, cap owner_files, and define before/action/after business proof.',
-		acceptanceProof: 'Valid ResolveIOSupportDiagnosisGate JSON with issue_case, issue_class, accepted_hypothesis, rejected_alternatives, failing_path, owner_files, proof_plan, evidence, and status=passed.',
-		threadKey: input.buildThreadKey,
-		promptTokenEstimate: existingDiagnosis?.promptTokenEstimate,
-		attempts: existingDiagnosis?.attempts || 0,
-		dependsOn: [],
-		parentScopeId: stableIdFromText('scope', diagnosisObjective),
-		blocker: existingDiagnosis?.blocker,
-		createdAt: existingDiagnosis?.createdAt || now,
-		updatedAt: existingDiagnosis?.updatedAt || now
-	});
-	sourceRequirements.forEach((requirement, index) => {
-		const objective = cleanText(requirement, 240);
-		if (!objective) {
-			return;
-		}
-		const existingCompleted = completedByObjective.get(objective.toLowerCase());
-		const buildId = stableIdFromText(`build-${index + 1}`, objective);
-		const qaId = stableIdFromText(`qa-${index + 1}`, objective);
-		ledger.push(existingCompleted && existingCompleted.lane === 'build' ? existingCompleted : {
-			microtaskId: buildId,
-			lane: 'build',
-			type: 'build_repair',
-			status: 'pending',
-			objective,
-			targetFiles: [],
-			contextRefs: ['scope_digest'],
-			selfGate: 'Run the smallest compile/type/unit check that proves this one behavior.',
-			acceptanceProof: 'Concrete code/data proof for this behavior, with changed files listed.',
-			threadKey: input.buildThreadKey,
-			attempts: 0,
-			dependsOn: [diagnosisId],
-			parentScopeId: stableIdFromText('scope', objective),
-			createdAt: now,
-			updatedAt: now
-		});
-		ledger.push({
-			microtaskId: qaId,
-			lane: 'qa',
-			type: 'qa_row',
-			status: 'pending',
-			objective: `QA proof for: ${objective}`,
-			targetFiles: [],
-			contextRefs: ['scope_digest', buildId],
-			selfGate: 'Drive this one customer-facing workflow row in browser/localhost and capture one captioned proof artifact.',
-			acceptanceProof: 'QA matrix row pass with route/data assertion, screenshot/caption artifact, and persisted before/after row/count/value proof for data-changing workflows.',
-			threadKey: input.qaThreadKey,
-			attempts: 0,
-			dependsOn: [diagnosisId, buildId],
-			parentScopeId: stableIdFromText('scope', objective),
-			createdAt: now,
-			updatedAt: now
-		});
-	});
-	return ledger.length ? ledger : existing.slice(-80);
-}
-
-export function selectResolveIOSupportV5ActiveMicrotask(
-	ledger: ResolveIOSupportV5Microtask[] = [],
-	preferredId?: string
-): ResolveIOSupportV5Microtask | undefined {
-	const byPreferred = preferredId ? ledger.find((task) => task.microtaskId === preferredId && !['pass', 'parked'].includes(task.status)) : undefined;
-	if (byPreferred) {
-		return byPreferred;
-	}
-	return ledger.find((task) => task.status === 'needs_repair')
-		|| ledger.find((task) => task.status === 'in_progress')
-		|| ledger.find((task) => task.lane === 'build' && /repair/i.test(String(task.type || '')) && task.status === 'pending')
-		|| ledger.find((task) => task.status === 'pending')
-		|| ledger.find((task) => task.status === 'blocked');
-}
-
-export function initializeResolveIOSupportV5State(input: ResolveIOSupportV5InitializeInput): ResolveIOSupportV5StateBundle {
-	const now = isoNow(input.now);
-	const existing = input.existing || {};
-	const existingSupervisor = existing.supportV5SupervisorState;
-	const existingLaneMemory = existing.supportV5LaneMemory || {} as ResolveIOSupportV5StateBundle['supportV5LaneMemory'];
-	const scope = cleanList(input.approvedScopeRequirements, 24, 240).join(' | ')
-		|| cleanText(input.description, 1000)
-		|| cleanText(input.title, 300);
-	const ticketLabel = cleanText(input.ticketNumber || input.ticketId || input.jobId, 120);
-	const buildThreadKey = cleanText(input.buildThreadKey || existingLaneMemory.build?.threadKey || `support:${input.ticketId || input.jobId}:job:${input.jobId}:build`, 240);
-	const qaThreadKey = cleanText(input.qaThreadKey || existingLaneMemory.qa?.threadKey || `support:${input.ticketId || input.jobId}:job:${input.jobId}:qa`, 240);
-	const budget = buildResolveIOSupportV5Budget(existing.supportV5Budget);
-	const existingDiagnosisGate = normalizeResolveIOSupportDiagnosisGate((existing as any).supportV5DiagnosisGate);
-	const diagnosisValidation = validateResolveIOSupportDiagnosisGate(existingDiagnosisGate);
-	const scopeDigest = cleanText((existing as any).supportV5ScopeDigest, 4000) || buildResolveIOSupportV5ScopeDigest({
-		goal: existingSupervisor?.currentGoal || `Resolve support ticket ${ticketLabel}`,
-		approvedScope: scope,
-		prBranch: input.prBranch || existingSupervisor?.prBranch || ''
-	});
-	const ledger = buildResolveIOSupportV5MicrotaskLedger({
-		scopeDigest,
-		requirements: cleanList(input.approvedScopeRequirements, 30, 240),
-		buildThreadKey,
-		qaThreadKey,
-		now,
-		existing: (existing as any).supportV5MicrotaskLedger
-	});
-	const activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(ledger, (existing as any).supportV5ActiveMicrotaskId);
-	const initialized: ResolveIOSupportV5StateBundle = {
-		supportWorkflowVersion: 'v5',
-		supportV5SupervisorState: {
-			version: 'v5',
-			status: existingSupervisor?.status || 'active',
-			currentGoal: existingSupervisor?.currentGoal || `Resolve support ticket ${ticketLabel}`,
-			approvedScope: existingSupervisor?.approvedScope || scope,
-			prBranch: cleanText(input.prBranch || existingSupervisor?.prBranch || '', 240),
-			activeStep: existingSupervisor?.activeStep || (diagnosisValidation.valid ? 'compile_check' : 'diagnosis_gate'),
-			activeBlocker: existingSupervisor?.activeBlocker || (diagnosisValidation.valid ? '' : 'SupportDiagnosisGate required before product-code repair.'),
-			lastGoodCheckpoint: existingSupervisor?.lastGoodCheckpoint || 'v5_initialized',
-			currentQaRow: existingSupervisor?.currentQaRow,
-			processLease: input.processLease || existingSupervisor?.processLease,
-			artifactLinks: cleanList(existingSupervisor?.artifactLinks, 40, 500),
-			noEmailUnlessApproved: true,
-			updatedAt: now
-		},
-		supportV5DiagnosisGate: diagnosisValidation.valid ? diagnosisValidation.normalized : existingDiagnosisGate,
-		supportV5LaneMemory: {
-			build: {
-				lane: 'build',
-				model: existingLaneMemory.build?.model || 'gpt-5.3-codex',
-				threadKey: buildThreadKey,
-				scopeSummary: existingLaneMemory.build?.scopeSummary || scope,
-				activeBlocker: existingLaneMemory.build?.activeBlocker || '',
-				activeQaRow: existingLaneMemory.build?.activeQaRow,
-				changedFiles: cleanList(existingLaneMemory.build?.changedFiles, 80, 500),
-				artifactPaths: cleanList(existingLaneMemory.build?.artifactPaths, 80, 500),
-				latestPromptTokenEstimate: Number(existingLaneMemory.build?.latestPromptTokenEstimate || 0) || undefined,
-				updatedAt: existingLaneMemory.build?.updatedAt || now
-			},
-			qa: {
-				lane: 'qa',
-				model: existingLaneMemory.qa?.model || 'gpt-5.4-mini',
-				threadKey: qaThreadKey,
-				scopeSummary: existingLaneMemory.qa?.scopeSummary || scope,
-				activeBlocker: existingLaneMemory.qa?.activeBlocker || '',
-				activeQaRow: existingLaneMemory.qa?.activeQaRow,
-				changedFiles: cleanList(existingLaneMemory.qa?.changedFiles, 80, 500),
-				artifactPaths: cleanList(existingLaneMemory.qa?.artifactPaths, 80, 500),
-				latestPromptTokenEstimate: Number(existingLaneMemory.qa?.latestPromptTokenEstimate || 0) || undefined,
-				updatedAt: existingLaneMemory.qa?.updatedAt || now
-			}
-		},
-		supportV5StepHistory: Array.isArray(existing.supportV5StepHistory)
-			? existing.supportV5StepHistory.slice(-80)
-			: [],
-		supportV5Budget: budget,
-		supportV5RunnerIncidents: Array.isArray(existing.supportV5RunnerIncidents)
-			? existing.supportV5RunnerIncidents.slice(-80)
-			: [],
-		supportV5MicrotaskLedger: ledger,
-		supportV5ActiveMicrotaskId: diagnosisValidation.valid
-			? activeMicrotask?.microtaskId
-			: ledger.find((task) => task.type === 'diagnosis_gate' && !['pass', 'parked'].includes(task.status))?.microtaskId || activeMicrotask?.microtaskId,
-		supportV5ScopeDigest: scopeDigest,
-		supportV5MicrotaskUsageHistory: Array.isArray((existing as any).supportV5MicrotaskUsageHistory)
-			? (existing as any).supportV5MicrotaskUsageHistory.slice(-200)
-			: [],
-		supportV5FailureFingerprints: Array.isArray((existing as any).supportV5FailureFingerprints)
-			? (existing as any).supportV5FailureFingerprints.slice(-200)
-			: [],
-		supportV5RecoveryPlan: (existing as any).supportV5RecoveryPlan,
-		supportV5RecoveryCheckpoint: (existing as any).supportV5RecoveryCheckpoint,
-		supportV5RecoveryEvidenceProbe: (existing as any).supportV5RecoveryEvidenceProbe,
-		supportV5RecoveryAction: (existing as any).supportV5RecoveryAction,
-		supportV5RecoveryDispatchHistory: Array.isArray((existing as any).supportV5RecoveryDispatchHistory)
-			? (existing as any).supportV5RecoveryDispatchHistory.slice(-50)
-			: [],
-		supportV5RecoveryDirective: (existing as any).supportV5RecoveryDirective
-	};
-	return diagnosisValidation.valid && diagnosisValidation.normalized
-		? applyResolveIOSupportDiagnosisGateToMicrotasks(initialized, diagnosisValidation.normalized)
-		: initialized;
-}
-
-export function recordResolveIOSupportV5Step(
-	bundle: ResolveIOSupportV5StateBundle,
-	step: ResolveIOSupportV5StepInput
-): ResolveIOSupportV5StateBundle {
-	const now = isoNow(step.now);
-	const promptTokens = Math.max(0, Number(step.promptTokenEstimate || 0) || 0);
-	const runtimeMs = Math.max(0, Number(step.runtimeMs || 0) || 0);
-	const microtaskId = cleanText(step.microtaskId || bundle.supportV5ActiveMicrotaskId, 160);
-	const normalizedDiagnosisGate = step.diagnosisGate
-		? normalizeResolveIOSupportDiagnosisGate(step.diagnosisGate, now)
-		: undefined;
-	const blockerFingerprint = step.blocker || step.summary
-		? fingerprintResolveIOSupportV5Blocker(step.blocker || step.summary || '')
-		: undefined;
-	const evidenceHash = cleanText(step.evidenceHash, 80)
-		|| (step.artifactPaths?.length || step.blocker || step.summary
-			? hashResolveIOSupportV5Evidence(step.artifactPaths?.length ? step.artifactPaths : `${step.blocker || ''}\n${step.summary || ''}`)
-			: hashResolveIOAIManagerEvidence({
-				failureClass: step.failureClass,
-				blocker: step.blocker,
-				summary: step.summary,
-				changedFiles: step.changedFiles,
-				artifactPaths: step.artifactPaths
-			}));
-	const record: ResolveIOSupportV5StepRecord = {
-		...(microtaskId ? { microtaskId } : {}),
-		stepType: step.stepType,
-		outcome: step.outcome,
-		lane: step.lane,
-		model: cleanText(step.model, 80),
-		threadKey: cleanText(step.threadKey, 240),
-		promptTokenEstimate: promptTokens || undefined,
-		runtimeMs: runtimeMs || undefined,
-		summary: cleanText(step.summary || step.blocker || step.outcome, 1200),
-		blocker: cleanText(step.blocker, 1200),
-		changedFiles: cleanList(step.changedFiles, 80, 500),
-		artifactPaths: cleanList(step.artifactPaths, 80, 500),
-		diagnosisGate: normalizedDiagnosisGate,
-		failureClass: cleanText(step.failureClass, 80) || undefined,
-		blockerFingerprint,
-		evidenceHash,
-		recordedAt: now
-	};
-	const diagnosisGate = normalizedDiagnosisGate || bundle.supportV5DiagnosisGate;
-	const laneMemory = { ...bundle.supportV5LaneMemory };
-	if (step.lane === 'build' || step.lane === 'qa') {
-		const previous = laneMemory[step.lane];
-		laneMemory[step.lane] = {
-			...previous,
-			activeBlocker: record.blocker || previous.activeBlocker || '',
-			activeQaRow: step.activeQaRow || previous.activeQaRow,
-			changedFiles: record.changedFiles?.length ? record.changedFiles : previous.changedFiles,
-			artifactPaths: record.artifactPaths?.length ? record.artifactPaths : previous.artifactPaths,
-			latestPromptTokenEstimate: promptTokens || previous.latestPromptTokenEstimate,
-			updatedAt: now
-		};
-	}
-	const supervisor = {
-		...bundle.supportV5SupervisorState,
-		status: step.outcome === 'ready_for_merge' ? 'complete' as const : (step.outcome === 'park_manual' || step.outcome === 'budget_stop' ? 'parked' as const : 'active' as const),
-		activeStep: step.stepType,
-		activeBlocker: record.blocker || '',
-		currentQaRow: step.activeQaRow || bundle.supportV5SupervisorState.currentQaRow,
-		lastGoodCheckpoint: step.outcome === 'pass' || step.outcome === 'ready_for_merge'
-			? step.stepType
-			: bundle.supportV5SupervisorState.lastGoodCheckpoint,
-		artifactLinks: Array.from(new Set([
-			...bundle.supportV5SupervisorState.artifactLinks,
-			...(record.artifactPaths || [])
-		])).slice(-80),
-		updatedAt: now
-	};
-	const ledger = (bundle.supportV5MicrotaskLedger || []).map((task) => {
-		if (task.microtaskId !== bundle.supportV5ActiveMicrotaskId) {
-			return task;
-		}
-		const status: ResolveIOSupportV5MicrotaskStatus = step.outcome === 'pass' || step.outcome === 'ready_for_merge'
-			? 'pass'
-			: step.outcome === 'park_manual' || step.outcome === 'budget_stop'
-				? 'parked'
-				: step.outcome === 'needs_repair' || step.outcome === 'retry_same_step'
-					? 'needs_repair'
-					: 'in_progress';
-		return {
-			...task,
-			status,
-			blocker: record.blocker || task.blocker,
-			promptTokenEstimate: promptTokens || task.promptTokenEstimate,
-			attempts: task.attempts + (step.outcome === 'pass' || step.outcome === 'ready_for_merge' ? 0 : 1),
-			updatedAt: now
-		};
-	});
-	const failureFingerprint = record.failureClass && record.blockerFingerprint && record.evidenceHash
-		? {
-			stepType: record.stepType,
-			failureClass: cleanText(record.failureClass, 80),
-			blockerFingerprint: record.blockerFingerprint,
-			evidenceHash: record.evidenceHash,
-			recordedAt: now
-		}
-		: undefined;
-	const managerDecision = decideResolveIOAIManagerPolicy({
-		history: [...bundle.supportV5StepHistory, record],
-		current: record,
-		maxSameFailureRepeats: buildResolveIOSupportV5Budget(bundle.supportV5Budget).maxRepeatedNoProgress,
-		maxPingPongTransitions: 3,
-		infraFailureClasses: ['infra', 'compile']
-	});
-	const previousRecord = bundle.supportV5StepHistory[bundle.supportV5StepHistory.length - 1];
-	const nextLoopCount = managerDecision.loopBudgetShouldReset
-		|| previousRecord?.failureClass !== record.failureClass
-		|| previousRecord?.blockerFingerprint !== record.blockerFingerprint
-		|| previousRecord?.evidenceHash !== record.evidenceHash
-		? 1
-		: bundle.supportV5Budget.loopCount + 1;
-	const nextMicrotask = selectResolveIOSupportV5ActiveMicrotask(ledger, bundle.supportV5ActiveMicrotaskId);
-	const nextBundle: ResolveIOSupportV5StateBundle = {
-		...bundle,
-		supportV5SupervisorState: supervisor,
-		supportV5DiagnosisGate: diagnosisGate,
-		supportV5LaneMemory: laneMemory,
-		supportV5StepHistory: [...bundle.supportV5StepHistory, record].slice(-100),
-		supportV5Budget: {
-			...bundle.supportV5Budget,
-			totalPromptTokenEstimate: bundle.supportV5Budget.totalPromptTokenEstimate + promptTokens,
-			totalRuntimeMs: bundle.supportV5Budget.totalRuntimeMs + runtimeMs,
-			loopCount: nextLoopCount
-		},
-		supportV5MicrotaskLedger: ledger,
-		supportV5ActiveMicrotaskId: nextMicrotask?.microtaskId,
-		supportV5MicrotaskUsageHistory: bundle.supportV5MicrotaskUsageHistory || [],
-		supportV5FailureFingerprints: failureFingerprint
-			? [...(bundle.supportV5FailureFingerprints || []), failureFingerprint].slice(-200)
-			: (bundle.supportV5FailureFingerprints || []),
-		supportV5RecoveryPlan: managerDecision.recoveryPlan,
-		supportV5RecoveryCheckpoint: managerDecision.recoveryCheckpoint,
-		supportV5RecoveryEvidenceProbe: managerDecision.recoveryEvidenceProbe,
-		supportV5RecoveryAction: managerDecision.recoveryAction
-	};
-	if (normalizedDiagnosisGate && validateResolveIOSupportDiagnosisGate(normalizedDiagnosisGate).valid) {
-		return applyResolveIOSupportDiagnosisGateToMicrotasks(nextBundle, normalizedDiagnosisGate);
-	}
-	return nextBundle;
-}
-
-export function recordResolveIOSupportV5MicrotaskUsage(
-	bundle: ResolveIOSupportV5StateBundle,
-	usage: Omit<ResolveIOSupportV5MicrotaskUsage, 'recordedAt'>
-): ResolveIOSupportV5StateBundle {
-	const record: ResolveIOSupportV5MicrotaskUsage = {
-		...usage,
-		microtaskId: cleanText(usage.microtaskId, 160),
-		threadKey: cleanText(usage.threadKey, 240),
-		model: cleanText(usage.model, 80),
-		promptTokenEstimate: Math.max(0, Number(usage.promptTokenEstimate || 0) || 0),
-		promptSections: Array.isArray(usage.promptSections)
-			? usage.promptSections.map((section) => ({
-				name: cleanText(section.name, 120),
-				tokenEstimate: Math.max(0, Number(section.tokenEstimate || 0) || 0)
-			})).filter((section) => section.name)
-			: [],
-		recordedAt: isoNow()
-	};
-	const ledger = (bundle.supportV5MicrotaskLedger || []).map((task) => task.microtaskId === record.microtaskId
-		? {
-			...task,
-			promptTokenEstimate: record.promptTokenEstimate,
-			updatedAt: record.recordedAt
-		}
-		: task);
-	return {
-		...bundle,
-		supportV5MicrotaskLedger: ledger,
-		supportV5MicrotaskUsageHistory: [
-			...(bundle.supportV5MicrotaskUsageHistory || []),
-			record
-		].slice(-200)
-	};
-}
-
-export function decideResolveIOSupportV5Continuation(bundle: ResolveIOSupportV5StateBundle): ResolveIOSupportV5ContinuationDecision {
-	const history = bundle.supportV5StepHistory || [];
-	const budget = buildResolveIOSupportV5Budget(bundle.supportV5Budget);
-	const last = history[history.length - 1];
-	const activeMicrotaskId = cleanText(bundle.supportV5ActiveMicrotaskId, 160);
-	const blockerFingerprint = fingerprintResolveIOSupportV5Blocker(last?.blocker || last?.summary || '');
-	let repeatedNoProgressCount = 0;
-	for (let index = history.length - 1; index >= 0; index -= 1) {
-		const item = history[index];
-		if (activeMicrotaskId && cleanText((item as any).microtaskId, 160) !== activeMicrotaskId) {
-			continue;
-		}
-		if (item.outcome === 'pass' || item.outcome === 'ready_for_merge') {
-			break;
-		}
-		if (item.stepType !== last?.stepType) {
-			break;
-		}
-		if (fingerprintResolveIOSupportV5Blocker(item.blocker || item.summary || '') === blockerFingerprint) {
-			repeatedNoProgressCount += 1;
-		}
-	}
-	const budgetExceeded = budget.loopCount >= budget.maxLoopsPerTicket
-		|| (last?.promptTokenEstimate || 0) > budget.maxPromptTokensPerNonInitialStep;
-	const repeatedFailure = last ? decideResolveIOSupportV5RepeatedFailureStop({
-		history,
-		failureClass: last.failureClass,
-		blocker: last.blocker || last.summary,
-		evidenceHash: last.evidenceHash,
-		limit: budget.maxRepeatedNoProgress,
-		ignoreInfra: true
-	}) : null;
-	const recoveryPlanFor = (
-		action: string,
-		reason: string,
-		extra: Partial<ResolveIOAIManagerRecoveryPlanInput> = {}
-	): ResolveIOAIManagerRecoveryPlan => buildResolveIOAIManagerRecoveryPlan({
-		action,
-		reason,
-		failureClass: last?.failureClass,
-		lane: last?.lane || 'supervisor',
-		stepType: last?.stepType || bundle.supportV5SupervisorState.activeStep,
-		blocker: last?.blocker || last?.summary,
-		changedFiles: last?.changedFiles,
-		artifactPaths: last?.artifactPaths,
-		maxSameFailureRepeats: budget.maxRepeatedNoProgress,
-		...extra
-	});
-	const recoveryCheckpointFor = (
-		recoveryPlan: ResolveIOAIManagerRecoveryPlan
-	): ResolveIOAIManagerRecoveryCheckpoint => buildResolveIOAIManagerRecoveryCheckpoint({
-		plan: recoveryPlan,
-		current: last
-	});
-	const recoveryFieldsFor = (
-		recoveryPlan: ResolveIOAIManagerRecoveryPlan
-	): Pick<ResolveIOSupportV5ContinuationDecision, 'recoveryPlan' | 'recoveryCheckpoint' | 'recoveryEvidenceProbe' | 'recoveryAction'> => {
-		const recoveryCheckpoint = recoveryCheckpointFor(recoveryPlan);
-		const recoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
-			checkpoint: recoveryCheckpoint,
-			current: last
-		});
-		return {
-			recoveryPlan,
-			recoveryCheckpoint,
-			recoveryEvidenceProbe,
-			recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
-				plan: recoveryPlan,
-				checkpoint: recoveryCheckpoint,
-				probe: recoveryEvidenceProbe,
-				current: last
-			})
-		};
-	};
-	if (budgetExceeded) {
-		const recoveryPlan = recoveryPlanFor('manual_handoff', 'support_v5_budget_guard', {
-			productRepairFailure: false
-		});
-		return {
-			action: 'park',
-			reason: 'support_v5_budget_guard',
-			nextStep: last?.stepType || 'cleanup',
-			repeatedNoProgressCount,
-			budgetExceeded,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	if (repeatedNoProgressCount > budget.maxRepeatedNoProgress) {
-		const recoveryPlan = recoveryPlanFor('park_repeated_failure', 'support_v5_repeated_no_progress', {
-			productRepairFailure: true
-		});
-		return {
-			action: 'park',
-			reason: 'support_v5_repeated_no_progress',
-			nextStep: last?.stepType || 'cleanup',
-			repeatedNoProgressCount,
-			budgetExceeded,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	if (repeatedFailure?.shouldStop) {
-		const recoveryPlan = recoveryPlanFor(
-			repeatedFailure.reason === 'support_v5_ping_pong_failure_loop' ? 'park_ping_pong' : 'park_repeated_failure',
-			repeatedFailure.reason,
-			{
-				failureClass: repeatedFailure.failureClass,
-				productRepairFailure: true
-			}
-		);
-		return {
-			action: 'park',
-			reason: repeatedFailure.reason,
-			nextStep: last?.stepType || 'cleanup',
-			repeatedNoProgressCount: repeatedFailure.repeatedCount,
-			budgetExceeded,
-			...recoveryFieldsFor(recoveryPlan)
-		};
-	}
-	const recoveryPlan = recoveryPlanFor('continue', 'support_v5_continue');
-	return {
-		action: 'continue',
-		reason: 'support_v5_continue',
-		nextStep: last?.stepType || bundle.supportV5SupervisorState.activeStep,
-		repeatedNoProgressCount,
-		budgetExceeded: false,
-		...recoveryFieldsFor(recoveryPlan)
-	};
-}
-
-export function buildResolveIOSupportV5DiagnoseFirstPrompt(lines: {
-	goal?: string;
-	approvedScope?: string[];
-	activeStep?: ResolveIOSupportV5StepType;
-	activeBlocker?: string;
-	lane?: ResolveIOSupportV5Lane;
-	laneSummary?: string;
-	currentQaRow?: ResolveIOSupportV5LaneMemory['activeQaRow'];
-	artifactPaths?: string[];
-	changedFiles?: string[];
-}): string[] {
-	return [
-		'Support Runner V5 contract: act like a guarded autonomous engineer, not a gate checklist.',
-		'Start with Diagnose First: observed evidence, likely cause, smallest next action, and expected proof.',
-		'Use compact lane memory and current artifacts before asking for broad ticket context.',
-		'Do not send customer email. Do not write production data. Do not spawn duplicate build, QA, server, client, Mongo, browser, or Codex processes.',
-		'If repairing, inspect logs/artifacts/source/diff first; make the smallest code or localhost-data change, then run the smallest finite self-gate.',
-		'For build repairs, prefer `npm run build-prod -- --watch=false`, a targeted `tsc --noEmit`, or a focused unit test. `npm run build-dev` is forbidden for support microtasks because it is slow/watch-oriented and can leave heavy esbuild work. If no finite gate exists, return a blocked self-gate with the exact reason instead of running build-dev.',
-		'If QA fails, retest the failed row before advancing; if the same blocker repeats without new proof, park with the exact blocker.',
-		lines.goal ? `Goal: ${cleanText(lines.goal, 500)}` : '',
-		cleanList(lines.approvedScope, 12, 240).length ? `Approved scope: ${cleanList(lines.approvedScope, 12, 240).join(' | ')}` : '',
-		lines.activeStep ? `Active step: ${lines.activeStep}` : '',
-		lines.lane ? `Lane: ${lines.lane}` : '',
-		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)}` : '',
-		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 buildResolveIOSupportV5MicrotaskPrompt(input: {
-	bundle: ResolveIOSupportV5StateBundle;
-	lane: 'build' | 'qa';
-	model?: string;
-	stage?: string;
-	failureText?: string;
-	changedFiles?: string[];
-	artifactPaths?: string[];
-	targetFiles?: string[];
-	contextSnippets?: string[];
-	activeQaRow?: ResolveIOSupportV5LaneMemory['activeQaRow'];
-}): {
-	prompt: string;
-	promptTokenEstimate: number;
-	promptSections: ResolveIOSupportV5UsageSection[];
-	activeMicrotask?: ResolveIOSupportV5Microtask;
-	withinCap: boolean;
-	withinHardCap: boolean;
-	cap: number;
-	hardCap: number;
-	reason?: string;
-} {
-	const activeMicrotask = selectResolveIOSupportV5ActiveMicrotask(
-		input.bundle.supportV5MicrotaskLedger || [],
-		input.bundle.supportV5ActiveMicrotaskId
-	);
-	const diagnosisValidation = validateResolveIOSupportDiagnosisGate(input.bundle.supportV5DiagnosisGate);
-	const diagnosisGate = diagnosisValidation.normalized || input.bundle.supportV5DiagnosisGate;
-	const diagnosisActive = activeMicrotask?.type === 'diagnosis_gate';
-	const budget = buildResolveIOSupportV5PromptBudget();
-	const repairLike = Boolean(input.failureText || activeMicrotask?.status === 'needs_repair' || /repair/i.test(String(input.stage || activeMicrotask?.type || '')));
-	const cap = repairLike
-		? budget.repairMicrotaskCap
-		: input.lane === 'qa'
-			? budget.qaMicrotaskCap
-			: budget.buildMicrotaskCap;
-	const hardCap = repairLike
-		? budget.repairMicrotaskHardCap
-		: input.lane === 'qa'
-			? budget.qaMicrotaskHardCap
-			: budget.buildMicrotaskHardCap;
-	const laneMemory = input.bundle.supportV5LaneMemory[input.lane];
-	const taskThreadKey = activeMicrotask?.threadKey || laneMemory.threadKey;
-	const changedFiles = cleanList(input.changedFiles?.length ? input.changedFiles : laneMemory.changedFiles, 8, 160);
-	const artifactPaths = cleanList(input.artifactPaths?.length ? input.artifactPaths : laneMemory.artifactPaths, 8, 200);
-	const targetFiles = cleanList(input.targetFiles?.length ? input.targetFiles : activeMicrotask?.targetFiles, 5, 160);
-	const contextSnippets = cleanList(input.contextSnippets, 5, 360);
-	const qaRow = input.activeQaRow || activeMicrotask?.lane === 'qa'
-		? input.activeQaRow || laneMemory.activeQaRow || input.bundle.supportV5SupervisorState.currentQaRow
-		: undefined;
-	const sections = [
-		{
-			name: 'microtask_contract',
-			text: [
-				'Support Runner V5 Microtask Contract.',
-				'Use the existing persistent lane thread. Do not start a fresh thread.',
-				'Do exactly one microtask and one proof gate. Do not replay ticket triage, prior plans, attachments, broad QA checklist, or unrelated scope.',
-				'If context is insufficient, request the smallest missing file/log/artifact by path and park this microtask; do not broaden the prompt.',
-				'Do not send customer email. Do not deploy. Do not spawn duplicate server/client/Mongo/browser/Codex processes.',
-				diagnosisActive
-					? 'Diagnosis gate hard boundary: read-only investigation only. Do not edit source, generated files, package files, tests, fixtures, QA artifacts, or local data. Return the diagnosis JSON contract only.'
-					: input.lane === 'qa'
-					? 'QA lane hard boundary: the platform preflight owns compile, dependency install, Mongo/server/client startup, and Angular startup. This lane owns only browser/data proof and QA artifacts unless the prompt explicitly says preflight was skipped.'
-					: 'Build lane hard boundary: do not run `npm run build-dev`, `ng build`, `npm run server`, `npm run client`, `ng serve`, `run-local-qa.sh`, browser automation, or any watch/long-lived command. If a broad compile gate is needed, run only `npm run build-prod -- --watch=false`; otherwise use a targeted finite check or return the precise blocker.'
-			].join('\n')
-		},
-		diagnosisActive ? {
-			name: 'root_cause_first_diagnosis_contract',
-			text: [
-				'Before any product-code repair, produce strict JSON only:',
-				'{"support_diagnosis_gate":{"issue_case":{"customer_complaint":"","expected_result":"","observed_result":"","route_module":"","account_customer_context":"","reproduction_status":"reproduced|blocked|classified","reproduction_blocker":""},"issue_class":"no_op_submit|missing_wrong_data|filter_query_mismatch|invoice_pdf_export|upload_import|route_auth_hydration|slow_query_performance","accepted_hypothesis":{"statement":"","falsifiable_test":"","evidence":[""]},"rejected_alternatives":[""],"failing_path":{"frontend":"","backend":"","shared_library":"","data_query":"","description":""},"owner_files":["small/exact/file.ts"],"proof_plan":{"before":"","before_state_unavailable_reason":"","action":"","after":"","business_assertion":"","route":"","data_assertion":"","artifact_expectation":""},"similar_tickets":[],"similar_commits":[],"evidence":[{"type":"ticket|browser|mongo|log|code|commit|qa|other","summary":"","artifactPath":""}],"status":"passed"}}',
-				'Owner files must be a small exact editable set, not directories, globs, generated wrappers, or broad repo areas.',
-				'The accepted hypothesis must be falsifiable and backed by evidence; prior similar tickets or commits are hints only and cannot bypass fresh diagnosis.',
-				'The proof plan must be before/action/after business proof. If before-state proof is impossible, explain exactly why in before_state_unavailable_reason.'
-			].join('\n')
-		} : {
-			name: 'diagnosis_gate_context',
-			text: diagnosisValidation.valid && diagnosisGate ? [
-				`Diagnosis issue class: ${(diagnosisGate as ResolveIOSupportDiagnosisGate).issue_class}`,
-				`Accepted hypothesis: ${(diagnosisGate as ResolveIOSupportDiagnosisGate).accepted_hypothesis.statement}`,
-				`Failing path: ${(diagnosisGate as ResolveIOSupportDiagnosisGate).failing_path.description || (diagnosisGate as ResolveIOSupportDiagnosisGate).failing_path.frontend || (diagnosisGate as ResolveIOSupportDiagnosisGate).failing_path.backend || ''}`,
-				`Owner files: ${(diagnosisGate as ResolveIOSupportDiagnosisGate).owner_files.join(', ')}`,
-				`Business proof required: ${(diagnosisGate as ResolveIOSupportDiagnosisGate).proof_plan.business_assertion}`,
-				`Before/action/after: ${(diagnosisGate as ResolveIOSupportDiagnosisGate).proof_plan.before || (diagnosisGate as ResolveIOSupportDiagnosisGate).proof_plan.before_state_unavailable_reason} -> ${(diagnosisGate as ResolveIOSupportDiagnosisGate).proof_plan.action} -> ${(diagnosisGate as ResolveIOSupportDiagnosisGate).proof_plan.after}`
-			].filter(Boolean).join('\n') : 'SupportDiagnosisGate is not valid. Park instead of editing product code.'
-		},
-		{
-			name: 'scope_digest',
-			text: cleanText(input.bundle.supportV5ScopeDigest || input.bundle.supportV5SupervisorState.approvedScope, 900)
-		},
-		{
-			name: 'active_microtask',
-			text: activeMicrotask ? [
-				`Microtask id: ${activeMicrotask.microtaskId}`,
-				`Lane: ${input.lane}`,
-				`Type: ${activeMicrotask.type}`,
-				`Status: ${activeMicrotask.status}`,
-				`Objective: ${cleanText(activeMicrotask.objective, 360)}`,
-				`Self-gate: ${cleanText(activeMicrotask.selfGate, 260)}`,
-				`Acceptance proof: ${cleanText(activeMicrotask.acceptanceProof, 260)}`,
-				`Attempts on this microtask: ${activeMicrotask.attempts}`,
-				`Thread key: ${taskThreadKey}`
-			].join('\n') : 'No active microtask found. Park and report support_v5_microtask_missing.'
-		},
-		{
-			name: 'failure_delta',
-			text: input.failureText ? `Latest blocker/failure delta: ${cleanText(input.failureText, 700)}` : ''
-		},
-		{
-			name: 'target_context',
-			text: [
-				targetFiles.length ? `Target files: ${targetFiles.join(', ')}` : '',
-				changedFiles.length ? `Changed files: ${changedFiles.join(', ')}` : '',
-				artifactPaths.length ? `Artifacts: ${artifactPaths.join(', ')}` : '',
-				qaRow?.workflow ? `QA row workflow: ${cleanText(qaRow.workflow, 220)}` : '',
-				qaRow?.route ? `QA row route: ${cleanText(qaRow.route, 220)}` : '',
-				qaRow?.assertion ? `QA row assertion: ${cleanText(qaRow.assertion, 260)}` : '',
-				contextSnippets.length ? `Relevant snippets:\n${contextSnippets.join('\n---\n')}` : ''
-			].filter(Boolean).join('\n')
-		},
-		input.lane === 'qa' ? {
-			name: 'qa_browser_evidence_contract',
-			text: [
-				'QA lane first action after preflight: collect fresh browser evidence for the active row, not a proof review of existing route/auth artifacts.',
-				'Use the already-running localhost harness and staged env. Before any shell command, run `source .resolveio-support-tools/env.sh 2>/dev/null || source ../.resolveio-support-tools/env.sh 2>/dev/null || true`; then use `$RESOLVEIO_SUPPORT_QA_CLIENT_URL`, `$RESOLVEIO_SUPPORT_QA_SERVER_URL`, `$PUPPETEER_EXECUTABLE_PATH`, and `$CHROME_BIN`.',
-				'Required auth replay helper inside every Puppeteer row script: `const storage=JSON.parse(fs.readFileSync("qa-artifacts/auth-bootstrap-storage-state.json","utf8")); const entries=[...(Array.isArray(storage.localStorageEntries)?storage.localStorageEntries:[]), ...(Array.isArray(storage.localStorage)?storage.localStorage:Object.entries(storage.localStorage||{}).map(([key,value])=>({key,value}))), ...((storage.origins||[]).flatMap(o=>o.localStorage||[]))].map(e=>({key:e.key||e.name,value:e.value})).filter(e=>e.key); const clientUrl=process.env.RESOLVEIO_SUPPORT_QA_CLIENT_URL||process.env.RESOLVEIO_RUNNER_QA_CLIENT_URL; const rowRoute="<ACTIVE_QA_ROUTE>"; await page.goto(clientUrl,{waitUntil:"domcontentloaded"}); await page.evaluate(items=>{localStorage.clear(); for(const item of items)localStorage.setItem(item.key,item.value);}, entries); await page.goto(new URL(rowRoute, clientUrl).href,{waitUntil:"domcontentloaded"});` Replace `<ACTIVE_QA_ROUTE>` with the active row route before running. A screenshot of `/home`, the login screen, or a shell route after this helper means the QA script navigated to the wrong route or storage is stale; rerun the same row with the active route before returning an app blocker.',
-				'Allowed first command shape: one bounded `node`/Puppeteer row script that reads `qa-artifacts/auth-bootstrap-storage-state.json`, opens `$RESOLVEIO_SUPPORT_QA_CLIENT_URL`, seeds localStorage, navigates to the active QA route with `new URL(activeRoute, clientUrl).href`, drives the visible workflow, captures screenshot/caption, and updates the active matrix row. A `/home` proof is invalid for a locked non-home route.',
-				'Forbidden in QA lane after preflight: `npm run build`, `npm run build-dev`, `npm run build-prod`, `ng build`, `npm install`, `npm ci`, `npm run server`, `npm run client`, `ng serve`, `gulp`, `mongod`, `run-local-qa.sh`, and broad source discovery. If a build/startup/dependency problem is suspected, return `blocked` or `needs-fix` with the existing qa-artifacts log paths instead of launching those commands.',
-					'Launch Puppeteer from `PUPPETEER_EXECUTABLE_PATH || CHROME_BIN`, seed localStorage from `qa-artifacts/auth-bootstrap-storage-state.json`, then navigate to the active QA route.',
-					'Before passing, confirm `qa-artifacts/auth-bootstrap-result.json` used the ticket reporter or named affected user when available. If it used generic admin/dev while `qa-live-data-seed-result.json.selected.qa_user_context` names a reporter/affected user, rerun auth as that user or return needs-fix.',
-					'Drive the visible customer workflow for this one row. Capture a new customer-facing screenshot/caption and update `qa-artifacts/qa-coverage-matrix.json` with workflow, route, data id/name, assertion, screenshot path, caption, and pass/failed/blocked status.',
-				'After selecting any From/To, source/target, dropdown, combobox, rio-select, filter, item, customer, yard, chemical, or treatment-plan value, read the visible control text back from the DOM. If it still contains placeholder text such as Select Chemical, Select Yard, Select Customer, Select Treatment Plan Type, Loading..., empty, null, or undefined, do not click the action button and do not mark pass. Capture the selected-state blocker screenshot/DOM text and return needs-fix.',
-				'If the row needs persisted data proof, create that proof yourself in the same bounded QA command by querying localhost QA Mongo through process.env.MONGO_URL after the visible UI action. Write the result under qa-artifacts/ as JSON and reference that path in the matrix. Do not ask for a missing post-action DB artifact while the local QA stack is running; either write it or return needs-fix with the exact query/script error. For update-interchangeables rows, the JSON must include concrete non-placeholder fromText and toText, before/after counts or sample documents for treatment plans and tank/interchangeable records, and must fail if either selected value is only an arrow/placeholder or if the persisted collections are empty.',
-					'If the row names multiple concrete entities such as assets, units, BOLs, invoices, chemicals, customers, yards, or numbered records, prove every named entity. Do not pass by proving only one representative record.',
-					'For customer-reported data bugs, use production-seeded localhost records from `qa-live-data-seed-result.json`. If the exact named record is missing from the seed, fail the row as a seed/query blocker instead of testing a substitute record.',
-					'Route-ready, auth-bootstrap, shell, header-only, and empty-list screenshots do not satisfy this microtask. If the row cannot be proven, capture the blocker screenshot/DOM state and return needs-fix with that exact blocker.',
-				'Do not run compile/startup/npm install, do not spawn another server/client/Mongo, and do not inspect broad source trees before the first browser evidence command.'
-			].join('\n')
-		} : {
-			name: 'non_qa_noop',
-			text: ''
-		},
-		{
-			name: 'return_contract',
-			text: diagnosisActive
-				? 'Return strict JSON only with support_diagnosis_gate. Do not include Markdown and do not edit files.'
-				: input.lane === 'qa'
-				? 'Return strict JSON only: {"status":"pass"|"needs-fix"|"blocked","microtaskId":"","summary":"","evidence":[""],"artifacts":[""],"next_actions":[""]}.'
-				: 'Return concise Markdown with: Microtask Result, Root Cause, Changes, Self-Gate, Acceptance Proof, Residual Risk.'
-		}
-	].filter((section) => cleanText(section.text, 20));
-	const promptSections = sections.map((section) => ({
-		name: section.name,
-		tokenEstimate: estimateTextTokens(section.text)
-	}));
-	const prompt = sections.map((section) => section.text).join('\n\n');
-	const promptTokenEstimate = estimateTextTokens(prompt);
-	return {
-		prompt,
-		promptTokenEstimate,
-		promptSections,
-		activeMicrotask,
-		withinCap: promptTokenEstimate <= cap,
-		withinHardCap: promptTokenEstimate <= hardCap,
-		cap,
-		hardCap,
-		reason: promptTokenEstimate > hardCap
-			? 'support_v5_microtask_prompt_hard_cap'
-			: promptTokenEstimate > cap
-				? 'support_v5_microtask_prompt_soft_cap'
-				: undefined
-	};
-}
-
-export function summarizeResolveIOSupportV5MicrotaskUsage(bundle: ResolveIOSupportV5StateBundle): {
-	totalPromptTokenEstimate: number;
-	byMicrotask: Array<{ microtaskId: string; promptTokenEstimate: number; calls: number }>;
-	bySection: ResolveIOSupportV5UsageSection[];
-	broadPromptViolations: ResolveIOSupportV5MicrotaskUsage[];
-} {
-	const byMicrotask = new Map<string, { microtaskId: string; promptTokenEstimate: number; calls: number }>();
-	const bySection = new Map<string, number>();
-	let totalPromptTokenEstimate = 0;
-	const broadPromptViolations: ResolveIOSupportV5MicrotaskUsage[] = [];
-	const promptBudget = buildResolveIOSupportV5PromptBudget();
-	for (const usage of bundle.supportV5MicrotaskUsageHistory || []) {
-		totalPromptTokenEstimate += usage.promptTokenEstimate || 0;
-		const existing = byMicrotask.get(usage.microtaskId) || { microtaskId: usage.microtaskId, promptTokenEstimate: 0, calls: 0 };
-		existing.promptTokenEstimate += usage.promptTokenEstimate || 0;
-		existing.calls += 1;
-		byMicrotask.set(usage.microtaskId, existing);
-		for (const section of usage.promptSections || []) {
-			bySection.set(section.name, (bySection.get(section.name) || 0) + section.tokenEstimate);
-		}
-		const hardCap = usage.lane === 'qa' ? promptBudget.qaMicrotaskHardCap : promptBudget.buildMicrotaskHardCap;
-		if ((usage.promptTokenEstimate || 0) > hardCap) {
-			broadPromptViolations.push(usage);
-		}
-	}
-	return {
-		totalPromptTokenEstimate,
-		byMicrotask: Array.from(byMicrotask.values()),
-		bySection: Array.from(bySection.entries()).map(([name, tokenEstimate]) => ({ name, tokenEstimate })),
-		broadPromptViolations
-	};
-}
-
-export function buildResolveIOSupportV5Incident(input: {
-	incidentClass: string;
-	summary: string;
-	stepType?: ResolveIOSupportV5StepType;
-	blocker?: string;
-	artifactPaths?: string[];
-	now?: Date | string;
-}): ResolveIOSupportV5RunnerIncident {
-	return {
-		incidentClass: cleanText(input.incidentClass, 120) || 'support_v5_runner_incident',
-		summary: cleanText(input.summary, 1200),
-		stepType: input.stepType,
-		blockerFingerprint: input.blocker ? fingerprintResolveIOSupportV5Blocker(input.blocker) : undefined,
-		artifactPaths: cleanList(input.artifactPaths, 40, 500),
-		recordedAt: isoNow(input.now)
-	};
-}