@resolveio/server-lib 22.3.157 → 22.3.159

package/util/aicoder-runner-v6.js

@@ -51,7 +51,9 @@ exports.extractResolveIOAICoderJourneyContractFromMarkdown = extractResolveIOAIC
 exports.buildResolveIOAICoderWorkflowQaRowsFromJourneyContract = buildResolveIOAICoderWorkflowQaRowsFromJourneyContract;
 exports.validateResolveIOAICoderJourneyContract = validateResolveIOAICoderJourneyContract;
 exports.collectResolveIOAICoderJourneyContractIssues = collectResolveIOAICoderJourneyContractIssues;
+exports.evaluateResolveIOAICoderWorkflowProofReadiness = evaluateResolveIOAICoderWorkflowProofReadiness;
 exports.fingerprintResolveIOAICoderV6Blocker = fingerprintResolveIOAICoderV6Blocker;
+exports.buildResolveIOAICoderV6WorkflowReadiness = buildResolveIOAICoderV6WorkflowReadiness;
 exports.buildResolveIOAICoderV6Budget = buildResolveIOAICoderV6Budget;
 exports.initializeResolveIOAICoderV6State = initializeResolveIOAICoderV6State;
 exports.recordResolveIOAICoderV6Step = recordResolveIOAICoderV6Step;
@@ -268,6 +270,58 @@ function buildWorkflowStepId(step, index) {
         || cleanField(step, ['label', 'title', 'visible_cta'], 120).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
         || "step-".concat(index + 1);
 }
+function normalizeWorkflowProofKind(source, fallbackText) {
+    if (fallbackText === void 0) { fallbackText = ''; }
+    var explicit = cleanField(source, ['proof_kind', 'proofKind', 'coverage', 'type', 'kind'], 120).toLowerCase().replace(/[\s-]+/g, '_');
+    if (explicit) {
+        return explicit;
+    }
+    var text = cleanText([
+        fallbackText,
+        concatFields(source, ['id', 'step_id', 'stepId', 'action', 'browser_steps', 'expected_dom_or_data_proof', 'proof', 'expected_result', 'viewport'], 700)
+    ].filter(Boolean).join(' '), 1800).toLowerCase();
+    if (/\b(mobile|390x844|viewport)\b/.test(text)) {
+        return 'mobile';
+    }
+    if (/\b(export|report|pdf|download)\b/.test(text)) {
+        return 'report_export';
+    }
+    if (/\b(complete|saved|save|result|recommendation|calculated|optimized|final)\b/.test(text)) {
+        return 'workflow_completion';
+    }
+    if (/\b(sample|seeded|non[-\s]?empty|kpi|table|chart|record|row)\b/.test(text)) {
+        return 'non_empty_data';
+    }
+    if (/\b(empty|error|recovery|invalid)\b/.test(text)) {
+        return 'recovery';
+    }
+    if (/\b(hub|dashboard|command center|next up|queue)\b/.test(text)) {
+        return 'hub_action';
+    }
+    return 'business_workflow';
+}
+function buildWorkflowQaRequiredArtifacts(source, proofKind) {
+    var explicit = cleanList(readField(source, ['required_artifacts', 'requiredArtifacts', 'proof_artifacts', 'artifact_expectation', 'artifacts_required']), 12, 180);
+    var defaultsByKind = {
+        hub_action: ['hub screenshot or DOM snapshot', 'next action state proof'],
+        workflow_completion: ['before/action/after trace', 'saved or calculated output proof', 'business assertion artifact'],
+        report_export: ['generated report/export artifact', 'export control proof', 'saved output row proof'],
+        non_empty_data: ['seeded data snapshot', 'non-empty KPI/table/chart proof'],
+        mobile: ['mobile viewport screenshot or trace', 'responsive workflow action proof'],
+        recovery: ['empty/error state screenshot or trace', 'recovery action proof'],
+        business_workflow: ['browser trace or screenshot', 'DOM/data assertion artifact']
+    };
+    return Array.from(new Set(__spreadArray(__spreadArray([], __read(explicit), false), __read((defaultsByKind[proofKind] || defaultsByKind.business_workflow)), false))).slice(0, 16);
+}
+function buildWorkflowQaStateTransition(source, fallback) {
+    if (fallback === void 0) { fallback = {}; }
+    return {
+        before: cleanField(source, ['before', 'setup_state', 'initial_state'], 700) || fallback.expectedState,
+        action: cleanField(source, ['action', 'browser_steps', 'visible_cta', 'cta'], 700) || fallback.action,
+        after: cleanField(source, ['after', 'expected_state', 'expected_result', 'expected_dom_or_data_proof', 'proof'], 700) || fallback.assertion || fallback.expectedState,
+        assertion: cleanField(source, ['assertion', 'expected_dom_or_data_proof', 'proof', 'expected_result'], 700) || fallback.assertion
+    };
+}
 function buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(input) {
     var contract = typeof input === 'string'
         ? extractResolveIOAICoderJourneyContractFromMarkdown(input)
@@ -289,17 +343,14 @@ function buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(input) {
         if (!route && !action && !assertionText) {
             return;
         }
-        rows.push({
-            index: cleanNumber(readField(assertion, ['index', 'order'])) || index + 1,
-            workflowId: cleanField(assertion, ['workflow_id', 'workflowId'], 160) || workflowId,
-            stepId: cleanField(assertion, ['step_id', 'stepId', 'id'], 160) || "qa-".concat(index + 1),
+        var proofKind = normalizeWorkflowProofKind(assertion);
+        var rowBase = {
             route: route || undefined,
             action: action || undefined,
             assertion: assertionText || undefined,
-            expectedState: expectedState || undefined,
-            status: cleanField(assertion, ['status'], 120) || undefined,
-            artifactPaths: cleanList(readField(assertion, ['artifact_paths', 'artifactPaths']), 20, 500)
-        });
+            expectedState: expectedState || undefined
+        };
+        rows.push(__assign(__assign({ index: cleanNumber(readField(assertion, ['index', 'order'])) || index + 1, workflowId: cleanField(assertion, ['workflow_id', 'workflowId'], 160) || workflowId, stepId: cleanField(assertion, ['step_id', 'stepId', 'id'], 160) || "qa-".concat(index + 1) }, rowBase), { expectedOutput: cleanField(assertion, ['expected_output', 'expectedOutput', 'saved_output', 'calculated_output', 'report_output'], 700) || expectedState || assertionText || undefined, proofKind: proofKind, acceptanceGate: 'aiqa_business_assertion', requiredArtifacts: buildWorkflowQaRequiredArtifacts(assertion, proofKind), stateTransition: buildWorkflowQaStateTransition(assertion, rowBase), status: cleanField(assertion, ['status'], 120) || undefined, artifactPaths: cleanList(readField(assertion, ['artifact_paths', 'artifactPaths']), 20, 500) }));
     });
     if (rows.length) {
         return rows.slice(0, 80);
@@ -308,17 +359,14 @@ function buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(input) {
         if (!step || typeof step !== 'object' || Array.isArray(step)) {
             return;
         }
-        rows.push({
-            index: index + 1,
-            workflowId: workflowId,
-            stepId: buildWorkflowStepId(step, index),
+        var proofKind = normalizeWorkflowProofKind(step, normalizeWorkflowStepPosition(step, index, workflow.length));
+        var rowBase = {
             route: cleanField(step, ['route'], 240) || undefined,
             action: cleanField(step, ['visible_cta', 'action', 'cta'], 500) || undefined,
             assertion: cleanField(step, ['success_confirmation', 'expected_state_transition', 'final_result'], 700) || undefined,
-            expectedState: cleanField(step, ['expected_state_transition', 'success_confirmation', 'final_result'], 500) || undefined,
-            status: undefined,
-            artifactPaths: []
-        });
+            expectedState: cleanField(step, ['expected_state_transition', 'success_confirmation', 'final_result'], 500) || undefined
+        };
+        rows.push(__assign(__assign({ index: index + 1, workflowId: workflowId, stepId: buildWorkflowStepId(step, index) }, rowBase), { expectedOutput: cleanField(step, ['final_result', 'saved_exported_reported_result', 'completion_result', 'expected_state_transition'], 700) || rowBase.expectedState || rowBase.assertion, proofKind: proofKind, acceptanceGate: 'aiqa_business_assertion', requiredArtifacts: buildWorkflowQaRequiredArtifacts(step, proofKind), stateTransition: buildWorkflowQaStateTransition(step, rowBase), status: undefined, artifactPaths: [] }));
         void workflow;
     });
     return rows.slice(0, 80);
@@ -689,6 +737,20 @@ function cleanWorkflowQaRows(values, limit) {
                 action: cleanText(value.action, 500) || undefined,
                 assertion: cleanText(value.assertion, 700) || undefined,
                 expectedState: cleanText(value.expectedState || value.expected_state, 500) || undefined,
+                expectedOutput: cleanText(value.expectedOutput || value.expected_output, 700) || undefined,
+                proofKind: cleanText(value.proofKind || value.proof_kind, 120) || undefined,
+                acceptanceGate: (value.acceptanceGate || value.acceptance_gate) === 'aiqa_business_assertion'
+                    ? 'aiqa_business_assertion'
+                    : undefined,
+                requiredArtifacts: cleanList(value.requiredArtifacts || value.required_artifacts, 20, 180),
+                stateTransition: value.stateTransition || value.state_transition
+                    ? {
+                        before: cleanText((value.stateTransition || value.state_transition).before, 700) || undefined,
+                        action: cleanText((value.stateTransition || value.state_transition).action, 700) || undefined,
+                        after: cleanText((value.stateTransition || value.state_transition).after, 700) || undefined,
+                        assertion: cleanText((value.stateTransition || value.state_transition).assertion, 700) || undefined
+                    }
+                    : undefined,
                 status: cleanText(value.status, 120) || undefined,
                 artifactPaths: cleanList(value.artifactPaths || value.artifact_paths, 20, 500)
             };
@@ -709,6 +771,431 @@ function cleanWorkflowQaRows(values, limit) {
     }
     return rows;
 }
+function statusLooksPassed(value) {
+    var normalized = cleanText(value, 120).toLowerCase();
+    return !!normalized && /\b(pass|passed|success|succeeded|ok|done|complete|completed|ready|saved|published|deployed)\b/i.test(normalized);
+}
+function statusLooksFailed(value) {
+    var normalized = cleanText(value, 160).toLowerCase();
+    return !!normalized && /\b(fail|failed|error|blocked|missing|empty|stale|skipped|not ready|not_ready|cannot|could not|invalid)\b/i.test(normalized);
+}
+function normalizeProofKey(value) {
+    return cleanText(value, 500).toLowerCase().replace(/[^a-z0-9]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+function cleanAssertionArtifactPaths(value) {
+    return cleanList(value.artifactPaths
+        || value.artifact_paths
+        || value.artifacts
+        || value.screenshots
+        || (value.screenshot ? [value.screenshot] : []), 20, 500);
+}
+function normalizeWorkflowProofAssertion(value) {
+    var source = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    return {
+        assertion: cleanText(source.assertion || source.name || source.label || source.expected, 1000),
+        status: cleanText(source.status || source.outcome || source.result || (source.passed === true ? 'pass' : source.passed === false ? 'fail' : ''), 120),
+        workflowId: cleanText(source.workflowId || source.workflow_id || source.workflow || source.workflowName || source.workflow_name, 200),
+        stepId: cleanText(source.stepId || source.step_id || source.id || source.key, 200),
+        route: cleanText(source.route || source.path || source.url, 500),
+        action: cleanText(source.action || source.browser_steps || source.action_under_test || source.actionUnderTest, 800),
+        expected: cleanText(source.expected || source.expected_state || source.expectedState || source.expected_business_state_change || source.expectedBusinessStateChange, 1000),
+        observed: cleanText(source.observed || source.actual || source.after || source.after_state || source.afterState, 1000),
+        dataProof: cleanText(source.dataProof || source.data_proof || source.domProof || source.dom_proof || source.proof || source.summary, 1400),
+        artifactPaths: cleanAssertionArtifactPaths(source),
+        metadata: source.metadata && typeof source.metadata === 'object' && !Array.isArray(source.metadata) ? source.metadata : {}
+    };
+}
+function workflowRowKey(row, index) {
+    return cleanText(row.stepId || row.assertion || row.action || row.route || "workflow-row-".concat(index + 1), 200);
+}
+function sameWorkflowRow(left, right) {
+    var leftStep = normalizeProofKey(left.stepId);
+    var rightStep = normalizeProofKey(right.stepId);
+    if (leftStep && rightStep && leftStep === rightStep) {
+        return true;
+    }
+    var leftRoute = normalizeProofKey(left.route);
+    var rightRoute = normalizeProofKey(right.route);
+    var leftAction = normalizeProofKey(left.action || left.assertion);
+    var rightAction = normalizeProofKey(right.action || right.assertion);
+    return !!leftRoute && !!rightRoute && leftRoute === rightRoute && !!leftAction && !!rightAction && (leftAction.includes(rightAction) || rightAction.includes(leftAction));
+}
+function mergeWorkflowQaRows(contractRows, recordedRows) {
+    if (!contractRows.length) {
+        return recordedRows;
+    }
+    return contractRows.map(function (contractRow) {
+        var recorded = recordedRows.find(function (row) { return sameWorkflowRow(contractRow, row); });
+        if (!recorded) {
+            return contractRow;
+        }
+        return __assign(__assign(__assign({}, contractRow), recorded), { workflowId: recorded.workflowId || contractRow.workflowId, stepId: recorded.stepId || contractRow.stepId, route: recorded.route || contractRow.route, action: recorded.action || contractRow.action, assertion: recorded.assertion || contractRow.assertion, expectedState: recorded.expectedState || contractRow.expectedState, expectedOutput: recorded.expectedOutput || contractRow.expectedOutput, proofKind: recorded.proofKind || contractRow.proofKind, acceptanceGate: recorded.acceptanceGate || contractRow.acceptanceGate, requiredArtifacts: Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(contractRow.requiredArtifacts, 20, 180)), false), __read(cleanList(recorded.requiredArtifacts, 20, 180)), false))), stateTransition: recorded.stateTransition || contractRow.stateTransition, artifactPaths: Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(contractRow.artifactPaths, 20, 500)), false), __read(cleanList(recorded.artifactPaths, 20, 500)), false))) });
+    });
+}
+function assertionMatchesWorkflowRow(assertion, row) {
+    var metadata = assertion.metadata || {};
+    if (metadata.workflowQaRowMatched === true || metadata.journeyContractMatched === true || metadata.aicoderWorkflowProof === true) {
+        return true;
+    }
+    var rowStep = normalizeProofKey(row.stepId);
+    var assertionStep = normalizeProofKey(assertion.stepId || metadata.stepId || metadata.step_id);
+    if (rowStep && assertionStep && rowStep === assertionStep) {
+        return true;
+    }
+    var rowRoute = normalizeProofKey(row.route);
+    var assertionRoute = normalizeProofKey(assertion.route);
+    var rowAction = normalizeProofKey(row.action || row.assertion);
+    var assertionAction = normalizeProofKey([
+        assertion.action,
+        assertion.assertion,
+        assertion.expected,
+        assertion.observed,
+        assertion.dataProof
+    ].filter(Boolean).join(' '));
+    return !!rowRoute
+        && !!assertionRoute
+        && rowRoute === assertionRoute
+        && !!rowAction
+        && !!assertionAction
+        && (assertionAction.includes(rowAction) || rowAction.includes(assertionAction));
+}
+function workflowRowPassingAssertion(row, assertions) {
+    return assertions.find(function (assertion) { return statusLooksPassed(assertion.status) && assertionMatchesWorkflowRow(assertion, row); });
+}
+function workflowAssertionHasOutputProof(assertion) {
+    if (!assertion) {
+        return false;
+    }
+    return cleanText(assertion.dataProof, 1000).length >= 8
+        || cleanText(assertion.observed, 1000).length >= 8
+        || cleanText(assertion.expected, 1000).length >= 8
+        || cleanList(assertion.artifactPaths, 20, 500).length > 0;
+}
+function workflowRowArtifactPaths(row, assertion) {
+    return Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(row.artifactPaths, 20, 500)), false), __read(cleanList(assertion === null || assertion === void 0 ? void 0 : assertion.artifactPaths, 20, 500)), false)));
+}
+function workflowRowRequiresOutputProof(row) {
+    var _a, _b;
+    var proofKind = cleanText(row.proofKind, 120).toLowerCase();
+    if (/^(workflow_completion|report_export|non_empty_data|hub_action|business_workflow)$/.test(proofKind)) {
+        return true;
+    }
+    var text = cleanText([
+        row.expectedOutput,
+        row.expectedState,
+        row.assertion,
+        (_a = row.stateTransition) === null || _a === void 0 ? void 0 : _a.after,
+        (_b = row.stateTransition) === null || _b === void 0 ? void 0 : _b.assertion
+    ].filter(Boolean).join(' '), 1600).toLowerCase();
+    return /\b(save|saved|persist|calculated|optimized|recommendation|report|export|result|non[-\s]?empty|record|row|kpi|table|chart)\b/.test(text);
+}
+function workflowRowRequiresMappedBusinessAssertion(row) {
+    var _a;
+    var proofKind = cleanText(row.proofKind, 120).toLowerCase();
+    if (/^(workflow_completion|report_export)$/.test(proofKind)) {
+        return true;
+    }
+    if (/^(mobile|recovery|hub_action|non_empty_data)$/.test(proofKind)) {
+        return false;
+    }
+    var text = cleanText([
+        row.stepId,
+        row.expectedOutput,
+        row.expectedState,
+        row.assertion,
+        (_a = row.stateTransition) === null || _a === void 0 ? void 0 : _a.after
+    ].filter(Boolean).join(' '), 1600).toLowerCase();
+    return /\b(workflow[-_\s]?completion|save|saved|persist|calculated|optimized|recommendation|report|export|final result)\b/.test(text);
+}
+function workflowRowWeakProofReason(row, assertions) {
+    var assertion = workflowRowPassingAssertion(row, assertions);
+    var rowPassed = statusLooksPassed(row.status);
+    if (!rowPassed && !assertion) {
+        return '';
+    }
+    var artifactPaths = workflowRowArtifactPaths(row, assertion);
+    var requiredArtifacts = cleanList(row.requiredArtifacts, 20, 180);
+    if (requiredArtifacts.length && !artifactPaths.length) {
+        return "".concat(workflowRowKey(row, 0), " missing required artifact proof: ").concat(requiredArtifacts.slice(0, 3).join(', '));
+    }
+    if (row.acceptanceGate === 'aiqa_business_assertion' && workflowRowRequiresMappedBusinessAssertion(row) && !assertion) {
+        return "".concat(workflowRowKey(row, 0), " requires mapped AIQaBusinessAssertion proof.");
+    }
+    if (workflowRowRequiresOutputProof(row) && !workflowAssertionHasOutputProof(assertion) && !cleanText(row.expectedOutput || row.expectedState, 700)) {
+        return "".concat(workflowRowKey(row, 0), " missing saved/calculated/report output proof.");
+    }
+    return '';
+}
+function workflowRowHasProof(row, assertions) {
+    if (workflowRowWeakProofReason(row, assertions)) {
+        return false;
+    }
+    if (statusLooksPassed(row.status) && cleanList(row.artifactPaths, 20, 500).length) {
+        return true;
+    }
+    return !!workflowRowPassingAssertion(row, assertions);
+}
+function workflowRowFailed(row, assertions) {
+    if (statusLooksFailed(row.status)) {
+        return true;
+    }
+    return assertions.some(function (assertion) { return statusLooksFailed(assertion.status) && assertionMatchesWorkflowRow(assertion, row); });
+}
+function collectContractArtifactPaths(rows, assertions, extraPaths) {
+    return Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(cleanList(extraPaths, 40, 500)), false), __read(rows.flatMap(function (row) { return cleanList(row.artifactPaths, 20, 500); })), false), __read(assertions.flatMap(function (assertion) { return cleanList(assertion.artifactPaths, 20, 500); })), false))).slice(0, 80);
+}
+function stableProofValue(value) {
+    if (Array.isArray(value)) {
+        return value.map(stableProofValue);
+    }
+    if (value && typeof value === 'object') {
+        return Object.keys(value)
+            .sort()
+            .reduce(function (accumulator, key) {
+            var cleanKey = cleanText(key, 120);
+            if (!cleanKey || /^(evaluatedAt|recordedAt|createdAt|updatedAt|timestamp|durationMs)$/i.test(cleanKey)) {
+                return accumulator;
+            }
+            var nextValue = stableProofValue(value[key]);
+            if (nextValue !== undefined && nextValue !== '' && !(Array.isArray(nextValue) && !nextValue.length)) {
+                accumulator[cleanKey] = nextValue;
+            }
+            return accumulator;
+        }, {});
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    return cleanText(value, 2000);
+}
+function fingerprintResolveIOAICoderWorkflowProofPayload(value, prefix) {
+    var text = JSON.stringify(stableProofValue(value));
+    var hash = 0;
+    for (var index = 0; index < text.length; index += 1) {
+        hash = ((hash << 5) - hash + text.charCodeAt(index)) | 0;
+    }
+    return "".concat(prefix, "-").concat(Math.abs(hash).toString(36));
+}
+function normalizeWorkflowProofFingerprintList() {
+    var e_11, _a, e_12, _b;
+    var values = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        values[_i] = arguments[_i];
+    }
+    var fingerprints = [];
+    try {
+        for (var values_3 = __values(values), values_3_1 = values_3.next(); !values_3_1.done; values_3_1 = values_3.next()) {
+            var value = values_3_1.value;
+            var list = Array.isArray(value) ? value : value ? [value] : [];
+            try {
+                for (var list_1 = (e_12 = void 0, __values(list)), list_1_1 = list_1.next(); !list_1_1.done; list_1_1 = list_1.next()) {
+                    var entry = list_1_1.value;
+                    var normalized = cleanText(entry, 200);
+                    if (normalized && !fingerprints.includes(normalized)) {
+                        fingerprints.push(normalized);
+                    }
+                }
+            }
+            catch (e_12_1) { e_12 = { error: e_12_1 }; }
+            finally {
+                try {
+                    if (list_1_1 && !list_1_1.done && (_b = list_1.return)) _b.call(list_1);
+                }
+                finally { if (e_12) throw e_12.error; }
+            }
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (values_3_1 && !values_3_1.done && (_a = values_3.return)) _a.call(values_3);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    return fingerprints.slice(0, 40);
+}
+function evaluateResolveIOAICoderWorkflowProofReadiness(input) {
+    var _a, _b;
+    if (input === void 0) { input = {}; }
+    var now = isoNow(input.now);
+    var journeyInput = input.journeyContract !== undefined ? input.journeyContract : input.journeyContractMarkdown;
+    var hasJourneyInput = journeyInput !== undefined && journeyInput !== null && cleanText(journeyInput, 100).length > 0;
+    var journeyValidation = hasJourneyInput
+        ? validateResolveIOAICoderJourneyContract(journeyInput, {
+            requireMarkdownEnvelope: typeof journeyInput === 'string'
+        })
+        : {
+            valid: false,
+            contract: null,
+            issues: [{
+                    code: 'missing_contract',
+                    path: 'docs/APP_JOURNEY_CONTRACT.md',
+                    message: 'docs/APP_JOURNEY_CONTRACT.md is required before workflow proof can accept the app.',
+                    severity: 'error'
+                }],
+            workflowQaRows: [],
+            primaryWorkflowId: ''
+        };
+    var recordedRows = cleanWorkflowQaRows(input.workflowQaRows, 120);
+    var rows = mergeWorkflowQaRows(journeyValidation.workflowQaRows, recordedRows);
+    var assertions = asArray(input.businessAssertions).map(normalizeWorkflowProofAssertion).filter(function (assertion) {
+        return assertion.assertion || assertion.route || assertion.action || assertion.dataProof || assertion.status;
+    });
+    var routeOnly = asArray(input.routeProbes).some(function (probe) { return statusLooksPassed((probe === null || probe === void 0 ? void 0 : probe.status) || ((probe === null || probe === void 0 ? void 0 : probe.passed) === true ? 'pass' : '')); })
+        && !assertions.some(function (assertion) { return statusLooksPassed(assertion.status); });
+    var weakProofReasons = rows.map(function (row) { return workflowRowWeakProofReason(row, assertions); }).filter(Boolean);
+    var failedRows = rows.filter(function (row) { return workflowRowFailed(row, assertions); });
+    var passedRows = rows.filter(function (row) { return workflowRowHasProof(row, assertions); });
+    var missingRows = rows.filter(function (row) { return !workflowRowHasProof(row, assertions) && !workflowRowFailed(row, assertions); });
+    var passedAssertions = assertions.filter(function (assertion) { return statusLooksPassed(assertion.status); });
+    var releaseBlockers = [
+        statusLooksFailed(input.deployStatus) ? "deploy=".concat(cleanText(input.deployStatus, 160)) : '',
+        statusLooksFailed(input.publishStatus) ? "publish=".concat(cleanText(input.publishStatus, 160)) : '',
+        statusLooksFailed(input.sampleDataStatus) ? "sample_data=".concat(cleanText(input.sampleDataStatus, 160)) : ''
+    ].filter(Boolean);
+    var hasDataProof = passedAssertions.some(function (assertion) { return cleanText(assertion.dataProof, 1000).length >= 8; });
+    var sampleDataReady = statusLooksPassed(input.sampleDataStatus)
+        || (!statusLooksFailed(input.sampleDataStatus) && hasDataProof);
+    var artifactPaths = collectContractArtifactPaths(rows, assertions, input.artifactPaths);
+    var workflowProofFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
+        primaryWorkflowId: journeyValidation.primaryWorkflowId || cleanText((_a = recordedRows[0]) === null || _a === void 0 ? void 0 : _a.workflowId, 160),
+        passedWorkflowRows: passedRows.map(workflowRowKey),
+        failedWorkflowRows: failedRows.map(workflowRowKey),
+        missingWorkflowRows: missingRows.map(workflowRowKey),
+        passedBusinessAssertions: passedAssertions.map(function (assertion) { return ({
+            assertion: assertion.assertion,
+            workflowId: assertion.workflowId,
+            stepId: assertion.stepId,
+            route: assertion.route,
+            action: assertion.action,
+            expected: assertion.expected,
+            observed: assertion.observed,
+            dataProof: assertion.dataProof,
+            artifactPaths: assertion.artifactPaths
+        }); }),
+        sampleDataStatus: input.sampleDataStatus,
+        sampleDataReady: sampleDataReady,
+        artifactPaths: artifactPaths
+    }, 'aicoder-workflow-proof');
+    var artifactFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
+        artifactPaths: artifactPaths,
+        businessDataProof: passedAssertions.map(function (assertion) { return ({
+            stepId: assertion.stepId,
+            route: assertion.route,
+            dataProof: assertion.dataProof,
+            observed: assertion.observed,
+            artifactPaths: assertion.artifactPaths
+        }); })
+    }, 'aicoder-workflow-artifacts');
+    var previousWorkflowFingerprints = normalizeWorkflowProofFingerprintList(input.previousWorkflowProofFingerprint, input.previousWorkflowProofFingerprints);
+    var previousArtifactFingerprints = normalizeWorkflowProofFingerprintList(input.previousArtifactFingerprint, input.previousArtifactFingerprints);
+    var proofFreshness = 'unknown';
+    if (!passedAssertions.length && !artifactPaths.length) {
+        proofFreshness = 'missing';
+    }
+    else if (previousWorkflowFingerprints.includes(workflowProofFingerprint)) {
+        proofFreshness = 'same_as_previous';
+    }
+    else if (previousArtifactFingerprints.includes(artifactFingerprint)) {
+        proofFreshness = 'stale_artifact';
+    }
+    else {
+        proofFreshness = 'fresh';
+    }
+    var blockers = [];
+    var status = 'ready';
+    var reason = 'Journey contract and workflow business proof are ready.';
+    var nextAction = 'Proceed to the smallest remaining release gate.';
+    if (!hasJourneyInput) {
+        status = 'missing_journey_contract';
+        blockers.push('Generate and validate docs/APP_JOURNEY_CONTRACT.md before build/acceptance.');
+        reason = 'AICoder cannot accept an app without a journey contract.';
+        nextAction = 'Run journey_contract generation and validation first.';
+    }
+    else if (!journeyValidation.valid) {
+        status = 'journey_invalid';
+        blockers.push.apply(blockers, __spreadArray([], __read(journeyValidation.issues.filter(function (issue) { return issue.severity === 'error'; }).map(function (issue) { return issue.message; }).slice(0, 8)), false));
+        reason = 'Journey contract validation failed.';
+        nextAction = 'Repair docs/APP_JOURNEY_CONTRACT.md before product-code repair.';
+    }
+    else if (routeOnly) {
+        status = 'route_only';
+        blockers.push('Route/browser proof passed, but no workflow business assertion passed.');
+        reason = 'Route-only proof cannot accept an AICoder app.';
+        nextAction = 'Run workflow QA generated from the journey contract.';
+    }
+    else if (!rows.length) {
+        status = 'workflow_qa_missing';
+        blockers.push('No workflow QA rows were generated or recorded from the journey contract.');
+        reason = 'Workflow QA evidence is missing.';
+        nextAction = 'Generate workflow QA rows from journey_contract.qa_assertions.';
+    }
+    else if (weakProofReasons.length) {
+        status = 'business_proof_weak';
+        blockers.push.apply(blockers, __spreadArray([], __read(weakProofReasons.slice(0, 8)), false));
+        reason = 'Workflow QA rows passed without the structured artifacts or mapped output proof required by the Journey Contract.';
+        nextAction = 'Rerun the weak workflow QA rows and record AIQaBusinessAssertion plus required artifacts.';
+    }
+    else if (failedRows.length || missingRows.length) {
+        status = 'workflow_qa_incomplete';
+        blockers.push.apply(blockers, __spreadArray(__spreadArray([], __read(failedRows.map(function (row, index) { return "failed:".concat(workflowRowKey(row, index)); }).slice(0, 8)), false), __read(missingRows.map(function (row, index) { return "missing:".concat(workflowRowKey(row, index)); }).slice(0, 8)), false));
+        reason = 'Not all journey contract workflow QA rows have passed business proof.';
+        nextAction = 'Rerun or repair the incomplete workflow QA rows before publish.';
+    }
+    else if (!passedAssertions.length) {
+        status = input.scorecardPassed === true ? 'business_proof_missing' : 'workflow_qa_incomplete';
+        blockers.push('Workflow rows have no mapped AIQaBusinessAssertion business proof.');
+        reason = input.scorecardPassed === true
+            ? 'Scorecard-only proof is not acceptance.'
+            : 'Workflow business proof is missing.';
+        nextAction = 'Record AIQaBusinessAssertion rows tied to the journey contract.';
+    }
+    else if (releaseBlockers.length) {
+        status = 'release_blocked';
+        blockers.push.apply(blockers, __spreadArray([], __read(releaseBlockers), false));
+        reason = 'Workflow proof passed, but release/deploy/sample-data gates block acceptance.';
+        nextAction = 'Repair only the failed release gate or hotfix artifact before rerunning publish/deploy.';
+    }
+    else if (!sampleDataReady) {
+        status = 'sample_data_missing';
+        blockers.push('No non-empty seeded/sample data proof is available for the workflow.');
+        reason = 'AICoder app proof must include meaningful non-empty data.';
+        nextAction = 'Seed meaningful records and rerun workflow QA against that data.';
+    }
+    else if (proofFreshness === 'same_as_previous' || proofFreshness === 'stale_artifact') {
+        status = 'stale_workflow_proof';
+        blockers.push(proofFreshness === 'same_as_previous'
+            ? 'Workflow business proof fingerprint is unchanged from a prior run.'
+            : 'Workflow proof artifacts are unchanged from a prior run.');
+        reason = 'AICoder workflow proof is stale; repeated evidence cannot advance acceptance.';
+        nextAction = 'Rerun workflow QA from journey_contract.qa_assertions and record fresh AIQaBusinessAssertion artifacts.';
+    }
+    return {
+        ready: status === 'ready',
+        status: status,
+        reason: reason,
+        blockers: blockers,
+        journeyContractValid: journeyValidation.valid,
+        primaryWorkflowId: journeyValidation.primaryWorkflowId || cleanText((_b = recordedRows[0]) === null || _b === void 0 ? void 0 : _b.workflowId, 160),
+        passedWorkflowRows: passedRows.map(workflowRowKey),
+        missingWorkflowRows: missingRows.map(workflowRowKey),
+        failedWorkflowRows: failedRows.map(workflowRowKey),
+        passedBusinessAssertions: passedAssertions.map(function (assertion) { return cleanText(assertion.assertion || assertion.stepId || assertion.route, 300); }).filter(Boolean).slice(0, 40),
+        routeOnly: routeOnly,
+        scorecardOnly: input.scorecardPassed === true && !passedAssertions.length,
+        sampleDataReady: sampleDataReady,
+        releaseBlockers: releaseBlockers,
+        artifactPaths: artifactPaths,
+        workflowProofFingerprint: workflowProofFingerprint,
+        artifactFingerprint: artifactFingerprint,
+        proofFreshness: proofFreshness,
+        nextAction: nextAction,
+        evaluatedAt: now
+    };
+}
 function fingerprintResolveIOAICoderV6Blocker(value) {
     var text = cleanText(value, 4000)
         .toLowerCase()
@@ -749,6 +1236,183 @@ function classifyResolveIOAICoderV6FailureClass(step) {
     }
     return 'product_code';
 }
+function aicoderWorkflowReadinessNextCommand(status) {
+    switch (status) {
+        case 'journey_contract_required':
+            return 'Generate and validate docs/APP_JOURNEY_CONTRACT.md before product-code build work.';
+        case 'journey_contract_repair_required':
+            return 'Repair the journey contract until first/next/last workflow QA rows validate.';
+        case 'workflow_build_ready':
+            return 'Build the north-star workflow from the journey contract and seeded data story.';
+        case 'workflow_qa_required':
+            return 'Run workflow QA from journey_contract.qa_assertions and record AIQaBusinessAssertion proof.';
+        case 'workflow_business_proof_ready':
+            return 'Proceed only to release/publish gates; wow UI polish is allowed after business proof.';
+        case 'release_repair_required':
+            return 'Repair the failed publish/deploy/sample-data gate without rebuilding the app shell.';
+        case 'infra_repair_only':
+            return 'Repair Puppeteer, Chrome, Mongo, startup, port, cache, or environment evidence only.';
+        case 'compile_repair_only':
+            return 'Repair compile/build evidence only and rerun the same deterministic build gate.';
+        case 'collect_new_evidence':
+            return 'Collect new evidence for the stuck blocker before another model/code loop.';
+        case 'budget_stopped':
+            return 'Stop autonomous spend and request a bounded human decision.';
+        case 'parked':
+            return 'Park the run until a human chooses the next bounded action.';
+        default:
+            return 'Review workflow evidence before continuing.';
+    }
+}
+function aicoderWorkflowReadinessGateFor(status) {
+    switch (status) {
+        case 'journey_contract_required':
+        case 'journey_contract_repair_required':
+            return 'journey_contract';
+        case 'workflow_build_ready':
+            return 'build';
+        case 'workflow_qa_required':
+        case 'workflow_business_proof_ready':
+            return 'workflow_qa';
+        case 'release_repair_required':
+            return 'release';
+        case 'infra_repair_only':
+            return 'infra';
+        case 'compile_repair_only':
+            return 'compile';
+        case 'collect_new_evidence':
+            return 'evidence';
+        case 'budget_stopped':
+        case 'parked':
+            return 'manual';
+        default:
+            return 'manual';
+    }
+}
+function buildResolveIOAICoderV6WorkflowReadiness(bundle, context) {
+    var _a, _b;
+    if (context === void 0) { context = {}; }
+    var history = Array.isArray(bundle.aiCoderV6StepHistory) ? bundle.aiCoderV6StepHistory : [];
+    var last = history[history.length - 1];
+    var workflowMemory = bundle.aiCoderV6WorkflowMemory || {};
+    var rows = cleanWorkflowQaRows(workflowMemory.workflowQaRows, 80);
+    var proofArtifacts = cleanList(workflowMemory.businessProofArtifacts, 80, 500);
+    var completedSteps = cleanList(workflowMemory.completedWorkflowSteps, 80, 240);
+    var primaryWorkflowId = cleanText(workflowMemory.primaryWorkflowId || ((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.workflowId), 200);
+    var activeWorkflowStep = cleanText(workflowMemory.activeWorkflowStep || workflowMemory.blockedWorkflowStep || ((_b = rows.find(function (row) { return !statusLooksPassed(row.status); })) === null || _b === void 0 ? void 0 : _b.stepId), 200);
+    var failureClass = cleanText(last === null || last === void 0 ? void 0 : last.failureClass, 120).toLowerCase();
+    var reason = cleanText(context.reason || (last === null || last === void 0 ? void 0 : last.blocker) || (last === null || last === void 0 ? void 0 : last.summary), 1000);
+    var combinedText = "".concat(failureClass, "\n").concat(reason, "\n").concat((last === null || last === void 0 ? void 0 : last.stepType) || '', "\n").concat((last === null || last === void 0 ? void 0 : last.lane) || '').toLowerCase();
+    var compileOnly = failureClass === 'compile'
+        || /\b(compile|typescript|ts[0-9]{3,5}|ng build|cannot find name|module not found)\b/i.test(combinedText);
+    var infraOnly = !compileOnly && (failureClass === 'infra'
+        || /\b(puppeteer|chrome|browser executable|mongo|port|startup|settings\.json|node_modules|cache|lock)\b/i.test(combinedText));
+    var releaseBlocked = failureClass === 'release'
+        || context.nextLane === 'publish'
+        || /\b(release|publish|deploy|cloudfront|artifact|sample data|sample_data)\b/i.test(combinedText);
+    var routeOnlyBlocked = /\b(route only|route-only|route loaded|route_probe|browser route|shell only|shell-only)\b/i.test(combinedText);
+    var sameFailureParked = context.action === 'park'
+        || context.reason === 'aicoder_v6_repeated_no_progress'
+        || context.reason === 'aicoder_v6_ping_pong_no_progress';
+    var budgetStopped = context.action === 'budget_stop' || context.budgetExceeded === true;
+    var workflowQaRowsReady = rows.length > 0;
+    var journeyContractReady = !!cleanText(workflowMemory.journeyContractPath, 500)
+        && (!!primaryWorkflowId || workflowQaRowsReady || completedSteps.length > 0);
+    var passedWorkflowRows = rows.filter(function (row) { return statusLooksPassed(row.status); });
+    var businessProofReady = proofArtifacts.length > 0
+        || passedWorkflowRows.some(function (row) { return cleanList(row.artifactPaths, 10, 500).length > 0; })
+        || completedSteps.length > 0;
+    var status = 'workflow_build_ready';
+    var blockers = [];
+    if (budgetStopped) {
+        status = 'budget_stopped';
+        blockers.push('Budget guard stopped autonomous spend.');
+    }
+    else if (sameFailureParked) {
+        status = 'collect_new_evidence';
+        blockers.push('Same failure class repeated without enough new evidence.');
+    }
+    else if (compileOnly && context.action === 'infra_retry') {
+        status = 'compile_repair_only';
+        blockers.push('Compile/build gate failed; do not count this as product workflow failure.');
+    }
+    else if (infraOnly && context.action === 'infra_retry') {
+        status = 'infra_repair_only';
+        blockers.push('Infra gate failed; repair only environment/browser/startup dependencies.');
+    }
+    else if (failureClass === 'journey' || context.reason === 'aicoder_v6_journey_contract_repair_required') {
+        status = 'journey_contract_repair_required';
+        blockers.push('Journey contract failed validation.');
+    }
+    else if (!journeyContractReady) {
+        status = 'journey_contract_required';
+        blockers.push('Journey contract workflow memory is not ready.');
+    }
+    else if (releaseBlocked || context.reason === 'aicoder_v6_release_repair_required') {
+        status = 'release_repair_required';
+        blockers.push('Release/publish/deploy gate blocks acceptance.');
+    }
+    else if (!workflowQaRowsReady || !businessProofReady || routeOnlyBlocked) {
+        status = 'workflow_qa_required';
+        if (!workflowQaRowsReady) {
+            blockers.push('Workflow QA rows are missing.');
+        }
+        if (!businessProofReady) {
+            blockers.push('AIQaBusinessAssertion proof is missing.');
+        }
+        if (routeOnlyBlocked) {
+            blockers.push('Route/browser proof is not workflow business proof.');
+        }
+    }
+    else if (businessProofReady) {
+        status = 'workflow_business_proof_ready';
+    }
+    var canRunWorkflowQa = journeyContractReady
+        && workflowQaRowsReady
+        && !infraOnly
+        && !compileOnly
+        && !sameFailureParked
+        && !budgetStopped;
+    var canPublish = status === 'workflow_business_proof_ready'
+        && !releaseBlocked
+        && !infraOnly
+        && !compileOnly
+        && !sameFailureParked
+        && !budgetStopped;
+    var canRunProductRepair = journeyContractReady
+        && !infraOnly
+        && !compileOnly
+        && !sameFailureParked
+        && !budgetStopped
+        && status !== 'journey_contract_repair_required'
+        && status !== 'release_repair_required'
+        && status !== 'workflow_business_proof_ready';
+    return {
+        status: status,
+        nextGate: aicoderWorkflowReadinessGateFor(status),
+        nextLane: context.nextLane || (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane,
+        nextStep: context.nextStep || (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep,
+        nextCommand: aicoderWorkflowReadinessNextCommand(status),
+        journeyContractReady: journeyContractReady,
+        workflowQaRowsReady: workflowQaRowsReady,
+        businessProofReady: businessProofReady,
+        routeOnlyBlocked: routeOnlyBlocked,
+        releaseBlocked: releaseBlocked,
+        infraOnly: infraOnly,
+        compileOnly: compileOnly,
+        sameFailureParked: sameFailureParked,
+        canRunProductRepair: canRunProductRepair,
+        canRunWorkflowQa: canRunWorkflowQa,
+        canPublish: canPublish,
+        canPolishWowUi: canPublish,
+        requiresHumanDecision: budgetStopped || sameFailureParked,
+        reason: reason || aicoderWorkflowReadinessNextCommand(status),
+        blockers: blockers.slice(0, 8),
+        primaryWorkflowId: primaryWorkflowId,
+        activeWorkflowStep: activeWorkflowStep,
+        businessProofArtifacts: proofArtifacts
+    };
+}
 function buildResolveIOAICoderV6Budget(existing) {
     return {
         maxPromptTokensPerNonInitialStep: Number((existing === null || existing === void 0 ? void 0 : existing.maxPromptTokensPerNonInitialStep) || 4000),
@@ -1018,6 +1682,14 @@ function decideResolveIOAICoderV6Continuation(bundle) {
         };
     };
     var managerRecoveryFields = function () { return recoveryFieldsFor(managerDecision.recoveryPlan, managerDecision.recoveryCheckpoint, managerDecision.recoveryEvidenceProbe); };
+    var withWorkflowReadiness = function (decision) { return (__assign(__assign({}, decision), { workflowReadiness: buildResolveIOAICoderV6WorkflowReadiness(bundle, {
+            action: decision.action,
+            reason: decision.reason,
+            nextLane: decision.nextLane,
+            nextStep: decision.nextStep,
+            budgetExceeded: decision.budgetExceeded,
+            repeatedNoProgressCount: decision.repeatedNoProgressCount
+        }) })); };
     var budgetExceeded = (budget.loopCount >= budget.maxLoopsPerRun && !managerDecision.loopBudgetShouldReset)
         || budget.totalPromptTokenEstimate >= budget.maxTotalPromptTokens
         || ((last === null || last === void 0 ? void 0 : last.promptTokenEstimate) || 0) > budget.maxPromptTokensPerNonInitialStep * 2;
@@ -1025,53 +1697,53 @@ function decideResolveIOAICoderV6Continuation(bundle) {
         var recoveryPlan_1 = recoveryPlanFor('budget_stop', 'aicoder_v6_budget_guard', {
             productRepairFailure: false
         });
-        return __assign({ action: 'budget_stop', reason: 'aicoder_v6_budget_guard', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_1));
+        return withWorkflowReadiness(__assign({ action: 'budget_stop', reason: 'aicoder_v6_budget_guard', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: budgetExceeded }, recoveryFieldsFor(recoveryPlan_1)));
     }
     if (managerDecision.action === 'park_ping_pong') {
-        return __assign({ action: 'park', reason: 'aicoder_v6_ping_pong_no_progress', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: managerDecision.pingPongCount, budgetExceeded: false }, managerRecoveryFields());
+        return withWorkflowReadiness(__assign({ action: 'park', reason: 'aicoder_v6_ping_pong_no_progress', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: managerDecision.pingPongCount, budgetExceeded: false }, managerRecoveryFields()));
     }
     if (managerDecision.action === 'park_repeated_failure') {
-        return __assign({ action: 'park', reason: 'aicoder_v6_repeated_no_progress', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: managerDecision.sameFailureCount, budgetExceeded: false }, managerRecoveryFields());
+        return withWorkflowReadiness(__assign({ action: 'park', reason: 'aicoder_v6_repeated_no_progress', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: managerDecision.sameFailureCount, budgetExceeded: false }, managerRecoveryFields()));
     }
     if (repeatedNoProgressCount > budget.maxRepeatedNoProgress) {
         var recoveryPlan_2 = recoveryPlanFor('park', 'aicoder_v6_repeated_no_progress', {
             action: 'park_repeated_failure',
             productRepairFailure: !/^(?:infra|compile|release)$/i.test(String((last === null || last === void 0 ? void 0 : last.failureClass) || ''))
         });
-        return __assign({ action: 'park', reason: 'aicoder_v6_repeated_no_progress', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan_2));
+        return withWorkflowReadiness(__assign({ action: 'park', reason: 'aicoder_v6_repeated_no_progress', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan_2)));
     }
     if (managerDecision.action === 'retry_infra') {
         var compileRepair = managerDecision.recoveryPlan.recoveryClass === 'compile_repair'
             || managerDecision.failureClass === 'compile'
             || (last === null || last === void 0 ? void 0 : last.failureClass) === 'compile';
-        return __assign({ action: 'infra_retry', reason: compileRepair ? 'aicoder_v6_compile_repair_required' : 'aicoder_v6_infra_retry', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields());
+        return withWorkflowReadiness(__assign({ action: 'infra_retry', reason: compileRepair ? 'aicoder_v6_compile_repair_required' : 'aicoder_v6_infra_retry', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields()));
     }
     if ((last === null || last === void 0 ? void 0 : last.outcome) === 'needs_repair') {
         if (last.failureClass === 'journey') {
-            return __assign({ action: 'retry_same_step', reason: 'aicoder_v6_journey_contract_repair_required', nextLane: 'plan', nextStep: last.stepType === 'journey_validation' ? 'journey_contract' : last.stepType, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields());
+            return withWorkflowReadiness(__assign({ action: 'retry_same_step', reason: 'aicoder_v6_journey_contract_repair_required', nextLane: 'plan', nextStep: last.stepType === 'journey_validation' ? 'journey_contract' : last.stepType, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields()));
         }
         if (last.failureClass === 'release') {
-            return __assign({ action: 'retry_same_step', reason: 'aicoder_v6_release_repair_required', nextLane: 'publish', nextStep: last.stepType, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields());
+            return withWorkflowReadiness(__assign({ action: 'retry_same_step', reason: 'aicoder_v6_release_repair_required', nextLane: 'publish', nextStep: last.stepType, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields()));
         }
-        return __assign({ action: last.lane === 'repair' ? 'retry_same_step' : 'switch_to_repair', reason: 'aicoder_v6_repair_required', nextLane: 'repair', nextStep: 'repair', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields());
+        return withWorkflowReadiness(__assign({ action: last.lane === 'repair' ? 'retry_same_step' : 'switch_to_repair', reason: 'aicoder_v6_repair_required', nextLane: 'repair', nextStep: 'repair', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, managerRecoveryFields()));
     }
     if ((last === null || last === void 0 ? void 0 : last.outcome) === 'infra_retry') {
         var recoveryPlan_3 = recoveryPlanFor('infra_retry', 'aicoder_v6_infra_retry', {
             failureClass: 'infra',
             productRepairFailure: false
         });
-        return __assign({ action: 'infra_retry', reason: 'aicoder_v6_infra_retry', nextLane: last.lane, nextStep: last.stepType, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan_3));
+        return withWorkflowReadiness(__assign({ action: 'infra_retry', reason: 'aicoder_v6_infra_retry', nextLane: last.lane, nextStep: last.stepType, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan_3)));
     }
     if ((last === null || last === void 0 ? void 0 : last.outcome) === 'ready_to_publish') {
         var recoveryPlan_4 = recoveryPlanFor('ready_to_publish', 'aicoder_v6_ready_to_publish', {
             failureClass: 'release',
             productRepairFailure: false
         });
-        return __assign({ action: 'ready_to_publish', reason: 'aicoder_v6_ready_to_publish', nextLane: 'publish', nextStep: 'publish', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan_4));
+        return withWorkflowReadiness(__assign({ action: 'ready_to_publish', reason: 'aicoder_v6_ready_to_publish', nextLane: 'publish', nextStep: 'publish', repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan_4)));
     }
     var recoveryPlan = managerDecision.recoveryPlan || recoveryPlanFor('continue', 'aicoder_v6_continue');
     var fallbackCheckpoint = managerDecision.recoveryCheckpoint || recoveryCheckpointFor(recoveryPlan);
-    return __assign({ action: 'continue', reason: 'aicoder_v6_continue', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan, fallbackCheckpoint, managerDecision.recoveryEvidenceProbe));
+    return withWorkflowReadiness(__assign({ action: 'continue', reason: 'aicoder_v6_continue', nextLane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, nextStep: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, repeatedNoProgressCount: repeatedNoProgressCount, budgetExceeded: false }, recoveryFieldsFor(recoveryPlan, fallbackCheckpoint, managerDecision.recoveryEvidenceProbe)));
 }
 function buildResolveIOAICoderV6DiagnoseFirstPrompt(lines) {
     var _a, _b;