@resolveio/server-lib 22.3.221 → 22.3.223

package/util/aicoder-runner-v6.js

@@ -0,0 +1,2464 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResolveIOAICoderJourneyContractFromMarkdown = extractResolveIOAICoderJourneyContractFromMarkdown;
+exports.buildResolveIOAICoderWorkflowQaRowsFromJourneyContract = buildResolveIOAICoderWorkflowQaRowsFromJourneyContract;
+exports.validateResolveIOAICoderJourneyContract = validateResolveIOAICoderJourneyContract;
+exports.collectResolveIOAICoderJourneyContractIssues = collectResolveIOAICoderJourneyContractIssues;
+exports.evaluateResolveIOAICoderWorkflowProofReadiness = evaluateResolveIOAICoderWorkflowProofReadiness;
+exports.fingerprintResolveIOAICoderV6Blocker = fingerprintResolveIOAICoderV6Blocker;
+exports.buildResolveIOAICoderWorkflowProofCheckpoint = buildResolveIOAICoderWorkflowProofCheckpoint;
+exports.buildResolveIOAICoderV6WorkflowReadiness = buildResolveIOAICoderV6WorkflowReadiness;
+exports.buildResolveIOAICoderNextActionContract = buildResolveIOAICoderNextActionContract;
+exports.buildResolveIOAICoderV6Budget = buildResolveIOAICoderV6Budget;
+exports.initializeResolveIOAICoderV6State = initializeResolveIOAICoderV6State;
+exports.recordResolveIOAICoderV6Step = recordResolveIOAICoderV6Step;
+exports.decideResolveIOAICoderV6Continuation = decideResolveIOAICoderV6Continuation;
+exports.buildResolveIOAICoderV6DiagnoseFirstPrompt = buildResolveIOAICoderV6DiagnoseFirstPrompt;
+exports.buildResolveIOAICoderV6Incident = buildResolveIOAICoderV6Incident;
+var ai_runner_manager_policy_1 = require("./ai-runner-manager-policy");
+var LANES = ['intake', 'plan', 'build', 'qa', 'repair', 'review', 'publish'];
+function isoNow(value) {
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    var parsed = value ? new Date(value) : new Date();
+    if (Number.isFinite(parsed.getTime())) {
+        return parsed.toISOString();
+    }
+    return new Date().toISOString();
+}
+function cleanText(value, max) {
+    if (max === void 0) { max = 2000; }
+    return String(value || '').replace(/\s+/g, ' ').trim().slice(0, max);
+}
+function cleanList(values, limit, max) {
+    var e_1, _a;
+    if (limit === void 0) { limit = 20; }
+    if (max === void 0) { max = 500; }
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    var result = [];
+    try {
+        for (var values_1 = __values(values), values_1_1 = values_1.next(); !values_1_1.done; values_1_1 = values_1.next()) {
+            var value = values_1_1.value;
+            var normalized = cleanText(value, max);
+            if (normalized && !result.includes(normalized)) {
+                result.push(normalized);
+            }
+            if (result.length >= limit) {
+                break;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (values_1_1 && !values_1_1.done && (_a = values_1.return)) _a.call(values_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return result;
+}
+function readField(source, keys) {
+    var e_2, _a;
+    if (!source || typeof source !== 'object') {
+        return undefined;
+    }
+    try {
+        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
+            var key = keys_1_1.value;
+            if (source[key] !== undefined && source[key] !== null) {
+                return source[key];
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    return undefined;
+}
+function cleanField(source, keys, max) {
+    if (max === void 0) { max = 500; }
+    return cleanText(readField(source, keys), max);
+}
+function concatFields(source, keys, maxEach) {
+    if (maxEach === void 0) { maxEach = 500; }
+    if (!source || typeof source !== 'object') {
+        return '';
+    }
+    return keys
+        .map(function (key) { return cleanText(source[key], maxEach); })
+        .filter(Boolean)
+        .join(' ');
+}
+function asArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value;
+}
+function stripJsonComments(value) {
+    var output = '';
+    var inString = false;
+    var escaped = false;
+    for (var index = 0; index < value.length; index += 1) {
+        var char = value[index];
+        var next = value[index + 1];
+        if (inString) {
+            output += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            output += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            while (index < value.length && value[index] !== '\n') {
+                index += 1;
+            }
+            output += '\n';
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            index += 2;
+            while (index < value.length && !(value[index] === '*' && value[index + 1] === '/')) {
+                index += 1;
+            }
+            index += 1;
+            continue;
+        }
+        output += char;
+    }
+    return output;
+}
+function parseJsonObject(value) {
+    try {
+        var parsed = JSON.parse(stripJsonComments(value));
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function extractResolveIOAICoderJourneyContractFromMarkdown(content) {
+    var normalized = String(content || '').replace(/\r\n/g, '\n');
+    var sectionMatch = normalized.match(/##\s*journey_contract[\s\S]*?```json\s*([\s\S]*?)```/i)
+        || normalized.match(/##\s*journey_contract[\s\S]*?```\s*([\s\S]*?)```/i);
+    if (sectionMatch === null || sectionMatch === void 0 ? void 0 : sectionMatch[1]) {
+        return parseJsonObject(sectionMatch[1].trim());
+    }
+    var fencedMatch = normalized.match(/```json\s*([\s\S]*?)```/i);
+    if (fencedMatch === null || fencedMatch === void 0 ? void 0 : fencedMatch[1]) {
+        return parseJsonObject(fencedMatch[1].trim());
+    }
+    var objectMatch = normalized.match(/\{\s*"app_archetype"[\s\S]*\}\s*$/m);
+    if (objectMatch === null || objectMatch === void 0 ? void 0 : objectMatch[0]) {
+        return parseJsonObject(objectMatch[0].trim());
+    }
+    return null;
+}
+function looksLikeAbsoluteRoute(value) {
+    return value.startsWith('/') && !/\s/.test(value);
+}
+function looksPlaceholder(value) {
+    return /\b(tbd|todo|placeholder|generic crud|crud-only|lorem ipsum|add details|fill in|coming soon)\b/i.test(value || '');
+}
+function isNavigationOnlyAction(source) {
+    var effect = cleanField(source, ['effect', 'outcome', 'state_change', 'expected_state_transition', 'expected_next_state'], 500).toLowerCase();
+    var implementation = cleanField(source, [
+        'method_or_calculation',
+        'server_method_or_publication',
+        'local_calculation_path',
+        'action_implementation',
+        'calculation_path',
+        'data_mutation',
+        'mutation',
+        'persisted_result'
+    ], 500);
+    if (implementation) {
+        return false;
+    }
+    var actionType = cleanField(source, ['action_type', 'type', 'kind'], 120).toLowerCase();
+    var actionText = [
+        cleanField(source, ['action', 'visible_cta', 'cta', 'label'], 300),
+        cleanField(source, ['next_step_destination', 'next_step', 'destination'], 300)
+    ].join(' ').toLowerCase();
+    var navigationSignals = /\b(navigate|go to|open|view|link|route|page)\b/.test(actionText)
+        || /^(?:link|nav|navigation|route)$/i.test(actionType);
+    var productiveEffect = /\b(save|saved|create|created|update|updated|calculate|calculated|optimize|optimized|import|export|report|persist|queued|submitted|validated|generated|compare|recommendation|complete|completed)\b/.test(effect);
+    return navigationSignals && !productiveEffect;
+}
+function addJourneyIssue(issues, code, path, message, severity) {
+    if (severity === void 0) { severity = 'error'; }
+    issues.push({ code: code, path: path, message: message, severity: severity });
+}
+function normalizeWorkflowStepPosition(step, index, total) {
+    var explicit = cleanField(step, ['position', 'phase', 'order_role'], 60).toLowerCase();
+    if (explicit) {
+        return explicit;
+    }
+    if (index === 0) {
+        return 'first';
+    }
+    if (index === total - 1) {
+        return 'last';
+    }
+    return 'next';
+}
+function normalizeJourneyReferenceKey(value) {
+    return cleanText(value, 160).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+function normalizeJourneyRouteKey(value) {
+    var raw = cleanText(value, 240);
+    if (!raw) {
+        return '';
+    }
+    var route = raw.split(/[?#]/)[0].replace(/\/+$/g, '') || '/';
+    return route.toLowerCase();
+}
+function normalizeJourneyActionText(value) {
+    return cleanText(value, 1000).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+}
+function buildWorkflowStepId(step, index) {
+    return cleanField(step, ['id', 'step_id', 'key'], 120)
+        || cleanField(step, ['label', 'title', 'visible_cta'], 120).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '')
+        || "step-".concat(index + 1);
+}
+function workflowStepVisibleAction(step) {
+    return cleanField(step, ['visible_cta', 'cta', 'label', 'action', 'embedded_hub_action', 'hub_action'], 500);
+}
+function journeySourceVisibleAction(source) {
+    return concatFields(source, [
+        'visible_cta',
+        'cta',
+        'label',
+        'action',
+        'browser_steps',
+        'expected_dom_or_data_proof',
+        'proof',
+        'assertion',
+        'expected_result'
+    ], 700);
+}
+function actionTextReferencesLabel(actionText, label) {
+    var action = normalizeJourneyActionText(actionText);
+    var expected = normalizeJourneyActionText(label);
+    if (!action || !expected || expected.length < 4) {
+        return false;
+    }
+    if (action === expected || action.includes(expected) || expected.includes(action)) {
+        return true;
+    }
+    var actionTokens = new Set(action.split(/\s+/).filter(function (token) { return token.length > 2; }));
+    var expectedTokens = expected.split(/\s+/).filter(function (token) { return token.length > 2; });
+    if (!expectedTokens.length) {
+        return false;
+    }
+    var matched = expectedTokens.filter(function (token) { return actionTokens.has(token); }).length;
+    return matched >= Math.min(expectedTokens.length, Math.max(2, Math.ceil(expectedTokens.length * 0.67)));
+}
+function collectJourneyReferenceKeys(source) {
+    var e_3, _a;
+    if (!source || typeof source !== 'object') {
+        return [];
+    }
+    var values = [];
+    try {
+        for (var _b = __values([
+            'workflow_step_id',
+            'workflowStepId',
+            'workflow_step_ids',
+            'workflowStepIds',
+            'covers_workflow_step_id',
+            'coversWorkflowStepId',
+            'covers_workflow_step_ids',
+            'coversWorkflowStepIds',
+            'north_star_step_id',
+            'northStarStepId',
+            'step_ref',
+            'stepRef'
+        ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var key = _c.value;
+            var value = source[key];
+            if (Array.isArray(value)) {
+                values.push.apply(values, __spreadArray([], __read(value), false));
+            }
+            else if (value !== undefined && value !== null) {
+                values.push(value);
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    return Array.from(new Set(values.map(normalizeJourneyReferenceKey).filter(Boolean))).slice(0, 20);
+}
+function journeySourceMapsToWorkflowStep(source, step, index) {
+    var stepId = normalizeJourneyReferenceKey(buildWorkflowStepId(step, index));
+    var refs = collectJourneyReferenceKeys(source);
+    if (stepId && refs.includes(stepId)) {
+        return true;
+    }
+    var sourceRoute = normalizeJourneyRouteKey(cleanField(source, ['route', 'screen_route', 'path'], 240));
+    var stepRoute = normalizeJourneyRouteKey(cleanField(step, ['route'], 240));
+    if (!sourceRoute || !stepRoute || sourceRoute !== stepRoute) {
+        return false;
+    }
+    return actionTextReferencesLabel(journeySourceVisibleAction(source), workflowStepVisibleAction(step));
+}
+function normalizeWorkflowProofKind(source, fallbackText) {
+    if (fallbackText === void 0) { fallbackText = ''; }
+    var explicit = cleanField(source, ['proof_kind', 'proofKind', 'qa_proof_kind', 'qaProofKind', '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 normalizeWorkflowQaCoverageTag(value) {
+    var normalized = cleanText(value, 120).toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_+|_+$/g, '');
+    if (!normalized) {
+        return '';
+    }
+    var aliases = {
+        auth: 'login',
+        authentication: 'login',
+        authenticated_session: 'login',
+        signed_in: 'login',
+        dashboard: 'hub_action',
+        dashboard_hub: 'hub_action',
+        hub: 'hub_action',
+        primary_hub_action: 'hub_action',
+        command_center: 'hub_action',
+        embedded_hub_action: 'hub_action',
+        completion: 'workflow_completion',
+        business_completion: 'workflow_completion',
+        final_result: 'workflow_completion',
+        result: 'workflow_completion',
+        saved_result: 'workflow_completion',
+        saved_output: 'workflow_completion',
+        calculated_result: 'workflow_completion',
+        export: 'report_export',
+        report: 'report_export',
+        pdf_export: 'report_export',
+        report_download: 'report_export',
+        sample_data: 'non_empty_data',
+        seed_data: 'non_empty_data',
+        seeded_data: 'non_empty_data',
+        non_empty: 'non_empty_data',
+        nonempty: 'non_empty_data',
+        kpi_data: 'non_empty_data',
+        responsive: 'mobile',
+        responsive_mobile: 'mobile',
+        mobile_viewport: 'mobile',
+        phone: 'mobile',
+        empty_state: 'recovery',
+        error_state: 'recovery',
+        error_recovery: 'recovery',
+        empty_error_recovery: 'recovery',
+        invalid_input_recovery: 'recovery'
+    };
+    return aliases[normalized] || normalized;
+}
+function appendWorkflowQaCoverageValues(target, value) {
+    var e_4, _a, e_5, _b;
+    if (Array.isArray(value)) {
+        value.forEach(function (entry) { return appendWorkflowQaCoverageValues(target, entry); });
+        return;
+    }
+    if (value && typeof value === 'object') {
+        try {
+            for (var _c = __values(Object.entries(value)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var _e = __read(_d.value, 2), key = _e[0], entry = _e[1];
+                if (entry === true) {
+                    target.push(normalizeWorkflowQaCoverageTag(key));
+                }
+                else if (typeof entry === 'string' || Array.isArray(entry) || (entry && typeof entry === 'object')) {
+                    appendWorkflowQaCoverageValues(target, entry);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        return;
+    }
+    var text = cleanText(value, 500);
+    if (!text) {
+        return;
+    }
+    try {
+        for (var _f = __values(text.split(/[|,;]/)), _g = _f.next(); !_g.done; _g = _f.next()) {
+            var entry = _g.value;
+            target.push(normalizeWorkflowQaCoverageTag(entry));
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_g && !_g.done && (_b = _f.return)) _b.call(_f);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+}
+function normalizeWorkflowQaCoverageTags(source, options) {
+    var e_6, _a, e_7, _b;
+    if (options === void 0) { options = {}; }
+    var tags = [];
+    try {
+        for (var _c = __values([
+            'coverage',
+            'coverage_tags',
+            'coverageTags',
+            'qa_coverage',
+            'qaCoverage',
+            'required_coverage',
+            'requiredCoverage',
+            'business_coverage',
+            'businessCoverage'
+        ]), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var key = _d.value;
+            appendWorkflowQaCoverageValues(tags, readField(source, [key]));
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    if (options.includeProofKind !== false) {
+        try {
+            for (var _e = __values(['proof_kind', 'proofKind', 'proof_kinds', 'proofKinds']), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var key = _f.value;
+                appendWorkflowQaCoverageValues(tags, readField(source, [key]));
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+    }
+    return Array.from(new Set(tags.filter(Boolean))).slice(0, 20);
+}
+function buildWorkflowQaRequiredArtifacts(source, proofKind) {
+    var explicit = cleanList(readField(source, ['required_artifacts', 'requiredArtifacts', 'proof_artifacts', 'artifact_expectation', 'artifacts_required']), 12, 180);
+    var defaultsByKind = {
+        login: ['authenticated session proof', 'post-login hub route proof'],
+        hub_action: ['hub screenshot or DOM snapshot', 'next action state proof'],
+        workflow_completion: ['before/action/after trace', 'saved or calculated output proof', 'business assertion artifact'],
+        report_export: ['generated report/export artifact', 'export control proof', 'saved output row proof'],
+        non_empty_data: ['seeded data snapshot', 'non-empty KPI/table/chart proof'],
+        mobile: ['mobile viewport screenshot or trace', 'responsive workflow action proof'],
+        recovery: ['empty/error state screenshot or trace', 'recovery action proof'],
+        business_workflow: ['browser trace or screenshot', 'DOM/data assertion artifact']
+    };
+    return Array.from(new Set(__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)
+        : (input && typeof input === 'object' && !Array.isArray(input) ? input : null);
+    if (!contract) {
+        return [];
+    }
+    var workflowId = cleanField(contract, ['primary_workflow_id', 'workflow_id', 'id'], 160) || 'north-star';
+    var rows = [];
+    var qaAssertions = asArray(contract.qa_assertions);
+    qaAssertions.forEach(function (assertion, index) {
+        if (!assertion || typeof assertion !== 'object' || Array.isArray(assertion)) {
+            return;
+        }
+        var route = cleanField(assertion, ['route', 'screen_route', 'path'], 240);
+        var action = cleanField(assertion, ['action', 'browser_steps', 'cta', 'visible_cta'], 500);
+        var expectedState = cleanField(assertion, ['expected_state', 'expected_result', 'expected_dom_or_data_proof', 'proof'], 500);
+        var assertionText = cleanField(assertion, ['assertion', 'expected_dom_or_data_proof', 'proof', 'expected_result'], 700);
+        if (!route && !action && !assertionText) {
+            return;
+        }
+        var proofKind = normalizeWorkflowProofKind(assertion);
+        var coverageTags = normalizeWorkflowQaCoverageTags(assertion);
+        var rowBase = {
+            route: route || undefined,
+            action: action || undefined,
+            assertion: assertionText || undefined,
+            expectedState: expectedState || undefined
+        };
+        rows.push(__assign(__assign({ index: cleanNumber(readField(assertion, ['index', 'order'])) || index + 1, workflowId: cleanField(assertion, ['workflow_id', 'workflowId'], 160) || workflowId, workflowStepId: cleanField(assertion, [
+                'workflow_step_id',
+                'workflowStepId',
+                'covers_workflow_step_id',
+                'coversWorkflowStepId',
+                'north_star_step_id',
+                'northStarStepId'
+            ], 160) || undefined, workflowStepIds: collectJourneyReferenceKeys(assertion), stepId: cleanField(assertion, ['step_id', 'stepId', 'id'], 160) || "qa-".concat(index + 1) }, rowBase), { expectedOutput: cleanField(assertion, ['expected_output', 'expectedOutput', 'saved_output', 'calculated_output', 'report_output'], 700) || expectedState || assertionText || undefined, proofKind: proofKind, coverageTags: coverageTags, acceptanceGate: 'aiqa_business_assertion', requiredArtifacts: buildWorkflowQaRequiredArtifacts(assertion, proofKind), stateTransition: buildWorkflowQaStateTransition(assertion, rowBase), status: cleanField(assertion, ['status'], 120) || undefined, artifactPaths: cleanList(readField(assertion, ['artifact_paths', 'artifactPaths']), 20, 500) }));
+    });
+    if (rows.length) {
+        return rows.slice(0, 80);
+    }
+    asArray(contract.north_star_workflow).forEach(function (step, index, workflow) {
+        if (!step || typeof step !== 'object' || Array.isArray(step)) {
+            return;
+        }
+        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
+        };
+        rows.push(__assign(__assign({ index: index + 1, workflowId: workflowId, workflowStepId: buildWorkflowStepId(step, index), workflowStepIds: [buildWorkflowStepId(step, index)], stepId: buildWorkflowStepId(step, index) }, rowBase), { expectedOutput: cleanField(step, ['final_result', 'saved_exported_reported_result', 'completion_result', 'expected_state_transition'], 700) || rowBase.expectedState || rowBase.assertion, proofKind: proofKind, coverageTags: Array.from(new Set([proofKind, normalizeWorkflowStepPosition(step, index, workflow.length)].map(normalizeWorkflowQaCoverageTag).filter(Boolean))), acceptanceGate: 'aiqa_business_assertion', requiredArtifacts: buildWorkflowQaRequiredArtifacts(step, proofKind), stateTransition: buildWorkflowQaStateTransition(step, rowBase), status: undefined, artifactPaths: [] }));
+        void workflow;
+    });
+    return rows.slice(0, 80);
+}
+function validateResolveIOAICoderJourneyContract(input, options) {
+    var e_8, _a, e_9, _b, e_10, _c, e_11, _d;
+    if (options === void 0) { options = {}; }
+    var pathLabel = cleanText(options.pathLabel || 'docs/APP_JOURNEY_CONTRACT.md', 240) || 'docs/APP_JOURNEY_CONTRACT.md';
+    var issues = [];
+    var contract = null;
+    if (typeof input === 'string') {
+        var normalized = input.replace(/\r\n/g, '\n');
+        if (!normalized.trim()) {
+            addJourneyIssue(issues, 'missing_contract', pathLabel, "".concat(pathLabel, ": missing app journey contract."));
+            return { valid: false, contract: null, issues: issues, workflowQaRows: [], primaryWorkflowId: '' };
+        }
+        if (options.requireMarkdownEnvelope !== false && !/^\s*#\s+App Journey Contract/im.test(normalized)) {
+            addJourneyIssue(issues, 'missing_heading', pathLabel, "".concat(pathLabel, ": missing \"# App Journey Contract\" heading."));
+        }
+        if (options.requireMarkdownEnvelope !== false && !/##\s*journey_contract/i.test(normalized)) {
+            addJourneyIssue(issues, 'missing_json_section', pathLabel, "".concat(pathLabel, ": missing \"## journey_contract\" JSON section."));
+        }
+        if (looksPlaceholder(normalized)) {
+            addJourneyIssue(issues, 'placeholder_text', pathLabel, "".concat(pathLabel, ": contains placeholder or generic journey text."));
+        }
+        contract = extractResolveIOAICoderJourneyContractFromMarkdown(normalized);
+    }
+    else if (input && typeof input === 'object' && !Array.isArray(input)) {
+        contract = input;
+    }
+    if (!contract) {
+        addJourneyIssue(issues, 'invalid_json', pathLabel, "".concat(pathLabel, ": journey_contract JSON is missing or invalid."));
+        return { valid: false, contract: null, issues: issues, workflowQaRows: [], primaryWorkflowId: '' };
+    }
+    var requiredKeys = [
+        'app_archetype',
+        'primary_actor',
+        'primary_goal',
+        'first_screen',
+        'north_star_workflow',
+        'secondary_workflows',
+        'screen_sequence',
+        'data_story',
+        'completion_states',
+        'qa_assertions'
+    ];
+    try {
+        for (var requiredKeys_1 = __values(requiredKeys), requiredKeys_1_1 = requiredKeys_1.next(); !requiredKeys_1_1.done; requiredKeys_1_1 = requiredKeys_1.next()) {
+            var key = requiredKeys_1_1.value;
+            if (!(key in contract)) {
+                addJourneyIssue(issues, 'missing_key', "".concat(pathLabel, ".journey_contract.").concat(key), "".concat(pathLabel, ": journey_contract missing key \"").concat(key, "\"."));
+            }
+        }
+    }
+    catch (e_8_1) { e_8 = { error: e_8_1 }; }
+    finally {
+        try {
+            if (requiredKeys_1_1 && !requiredKeys_1_1.done && (_a = requiredKeys_1.return)) _a.call(requiredKeys_1);
+        }
+        finally { if (e_8) throw e_8.error; }
+    }
+    try {
+        for (var _e = __values(['app_archetype', 'primary_actor', 'primary_goal']), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var key = _f.value;
+            var value = cleanText(contract[key], 500);
+            if (value.length < 4) {
+                addJourneyIssue(issues, 'empty_core_field', "".concat(pathLabel, ".journey_contract.").concat(key), "".concat(pathLabel, ": journey_contract.").concat(key, " must be non-empty."));
+            }
+            if (looksPlaceholder(value)) {
+                addJourneyIssue(issues, 'placeholder_core_field', "".concat(pathLabel, ".journey_contract.").concat(key), "".concat(pathLabel, ": journey_contract.").concat(key, " is placeholder text."));
+            }
+        }
+    }
+    catch (e_9_1) { e_9 = { error: e_9_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_9) throw e_9.error; }
+    }
+    var firstScreen = contract.first_screen;
+    if (!firstScreen || typeof firstScreen !== 'object' || Array.isArray(firstScreen)) {
+        addJourneyIssue(issues, 'invalid_first_screen', "".concat(pathLabel, ".journey_contract.first_screen"), "".concat(pathLabel, ": first_screen must be an object."));
+    }
+    else {
+        var route = cleanField(firstScreen, ['route'], 240);
+        try {
+            for (var _g = __values([
+                ['route', ['route']],
+                ['purpose', ['purpose', 'screen_purpose']],
+                ['visible_cta', ['visible_cta', 'cta', 'primary_cta']],
+                ['next_step', ['next_step', 'next_step_destination', 'expected_next_state']]
+            ]), _h = _g.next(); !_h.done; _h = _g.next()) {
+                var _j = __read(_h.value, 2), label = _j[0], keys = _j[1];
+                if (cleanField(firstScreen, keys, 500).length < 4) {
+                    addJourneyIssue(issues, 'incomplete_first_screen', "".concat(pathLabel, ".journey_contract.first_screen.").concat(label), "".concat(pathLabel, ": first_screen.").concat(label, " must be non-empty."));
+                }
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        if (route && !looksLikeAbsoluteRoute(route)) {
+            addJourneyIssue(issues, 'relative_first_screen_route', "".concat(pathLabel, ".journey_contract.first_screen.route"), "".concat(pathLabel, ": first_screen.route must be an absolute app route."));
+        }
+    }
+    var workflow = asArray(contract.north_star_workflow);
+    if (workflow.length < 3) {
+        addJourneyIssue(issues, 'workflow_too_short', "".concat(pathLabel, ".journey_contract.north_star_workflow"), "".concat(pathLabel, ": north_star_workflow must include at least first, next, and last steps."));
+    }
+    var positions = new Set(workflow.map(function (step, index) { return normalizeWorkflowStepPosition(step, index, workflow.length); }));
+    try {
+        for (var _k = __values(['first', 'next', 'last']), _l = _k.next(); !_l.done; _l = _k.next()) {
+            var requiredPosition = _l.value;
+            if (!positions.has(requiredPosition)) {
+                addJourneyIssue(issues, 'missing_workflow_position', "".concat(pathLabel, ".journey_contract.north_star_workflow"), "".concat(pathLabel, ": north_star_workflow missing position \"").concat(requiredPosition, "\"."));
+            }
+        }
+    }
+    catch (e_11_1) { e_11 = { error: e_11_1 }; }
+    finally {
+        try {
+            if (_l && !_l.done && (_d = _k.return)) _d.call(_k);
+        }
+        finally { if (e_11) throw e_11.error; }
+    }
+    workflow.forEach(function (step, index) {
+        var e_12, _a;
+        var stepPath = "".concat(pathLabel, ".journey_contract.north_star_workflow[").concat(index, "]");
+        if (!step || typeof step !== 'object' || Array.isArray(step)) {
+            addJourneyIssue(issues, 'invalid_workflow_step', stepPath, "".concat(pathLabel, ": north_star_workflow[").concat(index, "] must be an object."));
+            return;
+        }
+        var position = normalizeWorkflowStepPosition(step, index, workflow.length);
+        var route = cleanField(step, ['route'], 240);
+        var embeddedAction = cleanField(step, ['embedded_hub_action', 'hub_action'], 240);
+        var implementation = cleanField(step, [
+            'method_or_calculation',
+            'server_method_or_publication',
+            'local_calculation_path',
+            'action_implementation',
+            'calculation_path',
+            'data_mutation',
+            'mutation',
+            'persisted_result'
+        ], 500);
+        var requiredStepFields = [
+            ['position', ['position']],
+            ['visible_cta', ['visible_cta', 'cta', 'label']],
+            ['data_input_or_selection', ['data_input_or_selection', 'data_input', 'selection', 'input']],
+            ['expected_state_transition', ['expected_state_transition', 'expected_next_state', 'state_change']],
+            ['success_confirmation', ['success_confirmation', 'confirmation', 'success_message']],
+            ['next_step_destination', ['next_step_destination', 'next_step', 'destination']]
+        ];
+        try {
+            for (var requiredStepFields_1 = __values(requiredStepFields), requiredStepFields_1_1 = requiredStepFields_1.next(); !requiredStepFields_1_1.done; requiredStepFields_1_1 = requiredStepFields_1.next()) {
+                var _b = __read(requiredStepFields_1_1.value, 2), fieldName = _b[0], keys = _b[1];
+                if (fieldName === 'next_step_destination' && position === 'last') {
+                    continue;
+                }
+                if (cleanField(step, keys, 500).length < 3) {
+                    addJourneyIssue(issues, 'incomplete_workflow_step', "".concat(stepPath, ".").concat(fieldName), "".concat(pathLabel, ": north_star_workflow[").concat(index, "].").concat(fieldName, " must be non-empty."));
+                }
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (requiredStepFields_1_1 && !requiredStepFields_1_1.done && (_a = requiredStepFields_1.return)) _a.call(requiredStepFields_1);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
+        if (!route && !embeddedAction) {
+            addJourneyIssue(issues, 'workflow_step_missing_route_or_hub_action', stepPath, "".concat(pathLabel, ": north_star_workflow[").concat(index, "] must specify a route or embedded hub action."));
+        }
+        if (route && !looksLikeAbsoluteRoute(route)) {
+            addJourneyIssue(issues, 'relative_workflow_route', "".concat(stepPath, ".route"), "".concat(pathLabel, ": north_star_workflow[").concat(index, "].route must be an absolute app route."));
+        }
+        if (!implementation) {
+            addJourneyIssue(issues, 'workflow_step_missing_implementation', stepPath, "".concat(pathLabel, ": north_star_workflow[").concat(index, "] must map the CTA to a server method, publication, local calculation, persisted mutation, or export/report action."));
+        }
+        if (isNavigationOnlyAction(step)) {
+            addJourneyIssue(issues, 'navigation_only_workflow_step', stepPath, "".concat(pathLabel, ": north_star_workflow[").concat(index, "] appears to be navigation-only instead of advancing state."));
+        }
+        if (position === 'last' && cleanField(step, ['final_result', 'saved_exported_reported_result', 'completion_result'], 700).length < 8) {
+            addJourneyIssue(issues, 'last_step_missing_final_result', "".concat(stepPath, ".final_result"), "".concat(pathLabel, ": last workflow step must define the saved, exported, reported, or calculated final result."));
+        }
+    });
+    var secondaryWorkflows = asArray(contract.secondary_workflows);
+    if (secondaryWorkflows.length < 3) {
+        addJourneyIssue(issues, 'missing_secondary_workflows', "".concat(pathLabel, ".journey_contract.secondary_workflows"), "".concat(pathLabel, ": secondary_workflows must include setup, manage, report/export, settings/secrets, or recovery coverage."));
+    }
+    var screenSequence = asArray(contract.screen_sequence);
+    if (screenSequence.length < Math.min(3, Math.max(workflow.length, 3))) {
+        addJourneyIssue(issues, 'screen_sequence_too_short', "".concat(pathLabel, ".journey_contract.screen_sequence"), "".concat(pathLabel, ": screen_sequence must map workflow steps to routes, CTAs, data, and next state."));
+    }
+    screenSequence.forEach(function (screen, index) {
+        var e_13, _a;
+        var screenPath = "".concat(pathLabel, ".journey_contract.screen_sequence[").concat(index, "]");
+        if (!screen || typeof screen !== 'object' || Array.isArray(screen)) {
+            addJourneyIssue(issues, 'invalid_screen_sequence_row', screenPath, "".concat(pathLabel, ": screen_sequence[").concat(index, "] must be an object."));
+            return;
+        }
+        try {
+            for (var _b = __values([
+                ['route', ['route']],
+                ['screen_purpose', ['screen_purpose', 'purpose']],
+                ['visible_cta', ['visible_cta', 'cta']],
+                ['expected_next_state', ['expected_next_state', 'expected_state_transition']],
+                ['data_shown', ['data_shown', 'data', 'records_shown']]
+            ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), fieldName = _d[0], keys = _d[1];
+                if (cleanField(screen, keys, 500).length < 3) {
+                    addJourneyIssue(issues, 'incomplete_screen_sequence_row', "".concat(screenPath, ".").concat(fieldName), "".concat(pathLabel, ": screen_sequence[").concat(index, "].").concat(fieldName, " must be non-empty."));
+                }
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        var route = cleanField(screen, ['route'], 240);
+        if (route && !looksLikeAbsoluteRoute(route)) {
+            addJourneyIssue(issues, 'relative_screen_route', "".concat(screenPath, ".route"), "".concat(pathLabel, ": screen_sequence[").concat(index, "].route must be an absolute app route."));
+        }
+        if (isNavigationOnlyAction(screen)) {
+            addJourneyIssue(issues, 'navigation_only_screen_action', screenPath, "".concat(pathLabel, ": screen_sequence[").concat(index, "] CTA appears to navigate without changing workflow state."));
+        }
+        if (workflow.length && !workflow.some(function (step, workflowIndex) { return journeySourceMapsToWorkflowStep(screen, step, workflowIndex); })) {
+            addJourneyIssue(issues, 'screen_sequence_unmapped_to_workflow', screenPath, "".concat(pathLabel, ": screen_sequence[").concat(index, "] must reference a north_star_workflow step by workflow_step_id or match that step's route and CTA."));
+        }
+    });
+    workflow.forEach(function (step, index) {
+        if (!step || typeof step !== 'object' || Array.isArray(step)) {
+            return;
+        }
+        var stepPath = "".concat(pathLabel, ".journey_contract.north_star_workflow[").concat(index, "]");
+        var matchingScreens = screenSequence.filter(function (screen) { return journeySourceMapsToWorkflowStep(screen, step, index); });
+        if (!matchingScreens.length) {
+            addJourneyIssue(issues, 'workflow_step_missing_screen_mapping', stepPath, "".concat(pathLabel, ": north_star_workflow[").concat(index, "] must have a matching screen_sequence row with the same step id or route/CTA mapping."));
+        }
+    });
+    var firstScreenRoute = cleanField(firstScreen, ['route'], 240);
+    var hubScreens = screenSequence.filter(function (screen) {
+        var route = cleanField(screen, ['route'], 240);
+        return route === firstScreenRoute || /hub|dashboard/i.test(route);
+    });
+    var hubHasEmbeddedAction = hubScreens.some(function (screen) {
+        var text = [
+            cleanField(screen, ['embedded_action', 'hub_action', 'action'], 500),
+            cleanField(screen, ['method_or_calculation', 'server_method_or_publication', 'local_calculation_path', 'action_implementation'], 500),
+            cleanField(screen, ['expected_next_state', 'expected_state_transition'], 500)
+        ].join(' ');
+        return text.trim().length >= 8 && !isNavigationOnlyAction(screen);
+    });
+    if (!hubHasEmbeddedAction) {
+        addJourneyIssue(issues, 'hub_missing_embedded_action', "".concat(pathLabel, ".journey_contract.screen_sequence"), "".concat(pathLabel, ": dashboard hub/first screen must embed at least one primary workflow action instead of acting as a link farm."));
+    }
+    var dataStory = contract.data_story;
+    if (!dataStory || typeof dataStory !== 'object' || Array.isArray(dataStory)) {
+        addJourneyIssue(issues, 'invalid_data_story', "".concat(pathLabel, ".journey_contract.data_story"), "".concat(pathLabel, ": data_story must be an object."));
+    }
+    else {
+        if (cleanField(dataStory, ['seeded_scenario', 'scenario'], 800).length < 12) {
+            addJourneyIssue(issues, 'missing_seeded_scenario', "".concat(pathLabel, ".journey_contract.data_story.seeded_scenario"), "".concat(pathLabel, ": data_story.seeded_scenario must describe the launch sample scenario."));
+        }
+        if (!asArray(readField(dataStory, ['records', 'seed_records'])).length) {
+            addJourneyIssue(issues, 'missing_seed_records', "".concat(pathLabel, ".journey_contract.data_story.records"), "".concat(pathLabel, ": data_story.records must list seeded records."));
+        }
+        if (!asArray(readField(dataStory, ['relationships', 'record_relationships'])).length) {
+            addJourneyIssue(issues, 'missing_seed_relationships', "".concat(pathLabel, ".journey_contract.data_story.relationships"), "".concat(pathLabel, ": data_story.relationships must list seeded data relationships."));
+        }
+        if (asArray(readField(dataStory, ['non_empty_states', 'non_empty_dashboard_states'])).length < 2) {
+            addJourneyIssue(issues, 'missing_non_empty_states', "".concat(pathLabel, ".journey_contract.data_story.non_empty_states"), "".concat(pathLabel, ": data_story.non_empty_states must list non-empty dashboard, workflow, or report states."));
+        }
+    }
+    if (asArray(contract.completion_states).length < 2) {
+        addJourneyIssue(issues, 'missing_completion_states', "".concat(pathLabel, ".journey_contract.completion_states"), "".concat(pathLabel, ": completion_states must define what done looks like to the user."));
+    }
+    var qaAssertions = asArray(contract.qa_assertions);
+    if (qaAssertions.length < 5) {
+        addJourneyIssue(issues, 'qa_assertions_too_short', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions must include login, hub action, workflow completion, sample data, and mobile proof."));
+    }
+    var workflowStepsWithQa = new Set();
+    var hasMobileQa = false;
+    var hasRecoveryQa = false;
+    var hasCompletionQa = false;
+    var hasNonEmptyQa = false;
+    var hasLoginQa = false;
+    var hasHubActionQa = false;
+    qaAssertions.forEach(function (assertion, index) {
+        var e_14, _a;
+        var qaPath = "".concat(pathLabel, ".journey_contract.qa_assertions[").concat(index, "]");
+        if (!assertion || typeof assertion !== 'object' || Array.isArray(assertion)) {
+            addJourneyIssue(issues, 'invalid_qa_assertion', qaPath, "".concat(pathLabel, ": qa_assertions[").concat(index, "] must be an object."));
+            return;
+        }
+        try {
+            for (var _b = __values([
+                ['route', ['route', 'screen_route', 'path']],
+                ['action', ['action', 'browser_steps', 'visible_cta']],
+                ['expected_dom_or_data_proof', ['expected_dom_or_data_proof', 'proof', 'expected_result']]
+            ]), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var _d = __read(_c.value, 2), fieldName = _d[0], keys = _d[1];
+                if (cleanField(assertion, keys, 700).length < 3) {
+                    addJourneyIssue(issues, 'incomplete_qa_assertion', "".concat(qaPath, ".").concat(fieldName), "".concat(pathLabel, ": qa_assertions[").concat(index, "].").concat(fieldName, " must be non-empty."));
+                }
+            }
+        }
+        catch (e_14_1) { e_14 = { error: e_14_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_14) throw e_14.error; }
+        }
+        var route = cleanField(assertion, ['route', 'screen_route', 'path'], 240);
+        if (route && !looksLikeAbsoluteRoute(route)) {
+            addJourneyIssue(issues, 'relative_qa_route', "".concat(qaPath, ".route"), "".concat(pathLabel, ": qa_assertions[").concat(index, "].route must be an absolute app route."));
+        }
+        var explicitCoverageTags = normalizeWorkflowQaCoverageTags(assertion, { includeProofKind: false });
+        var coverageTags = normalizeWorkflowQaCoverageTags(assertion);
+        if (!explicitCoverageTags.length) {
+            addJourneyIssue(issues, 'qa_assertion_missing_structured_coverage', "".concat(qaPath, ".coverage_tags"), "".concat(pathLabel, ": qa_assertions[").concat(index, "] must declare coverage_tags such as login, hub_action, workflow_completion, non_empty_data, mobile, or recovery; prose-only keyword detection is not accepted."));
+        }
+        hasLoginQa = hasLoginQa || coverageTags.includes('login');
+        hasHubActionQa = hasHubActionQa || coverageTags.includes('hub_action');
+        hasMobileQa = hasMobileQa || coverageTags.includes('mobile');
+        hasRecoveryQa = hasRecoveryQa || coverageTags.includes('recovery');
+        hasCompletionQa = hasCompletionQa || coverageTags.includes('workflow_completion');
+        hasNonEmptyQa = hasNonEmptyQa || coverageTags.includes('non_empty_data');
+        var mappedWorkflowStepIds = workflow
+            .map(function (step, workflowIndex) { return journeySourceMapsToWorkflowStep(assertion, step, workflowIndex) ? buildWorkflowStepId(step, workflowIndex) : ''; })
+            .filter(Boolean);
+        mappedWorkflowStepIds.forEach(function (stepId) { return workflowStepsWithQa.add(stepId); });
+        if (workflow.length && !mappedWorkflowStepIds.length) {
+            addJourneyIssue(issues, 'qa_assertion_unmapped_to_workflow', qaPath, "".concat(pathLabel, ": qa_assertions[").concat(index, "] must reference a north_star_workflow step by workflow_step_id/covers_workflow_step_ids or match that step's route and CTA/action."));
+        }
+    });
+    if (!hasLoginQa) {
+        addJourneyIssue(issues, 'missing_login_qa', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions missing structured login coverage."));
+    }
+    if (!hasHubActionQa) {
+        addJourneyIssue(issues, 'missing_hub_action_qa', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions missing structured dashboard hub action coverage."));
+    }
+    if (!hasCompletionQa) {
+        addJourneyIssue(issues, 'missing_completion_qa', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions missing business completion proof."));
+    }
+    if (!hasNonEmptyQa) {
+        addJourneyIssue(issues, 'missing_non_empty_qa', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions missing non-empty seeded data proof."));
+    }
+    if (!hasMobileQa) {
+        addJourneyIssue(issues, 'missing_mobile_qa', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions missing mobile viewport proof."));
+    }
+    if (!hasRecoveryQa) {
+        addJourneyIssue(issues, 'missing_recovery_qa', "".concat(pathLabel, ".journey_contract.qa_assertions"), "".concat(pathLabel, ": qa_assertions missing empty/error recovery proof."));
+    }
+    workflow.forEach(function (step, index) {
+        if (!step || typeof step !== 'object' || Array.isArray(step)) {
+            return;
+        }
+        var stepId = buildWorkflowStepId(step, index);
+        if (!workflowStepsWithQa.has(stepId)) {
+            addJourneyIssue(issues, 'workflow_step_missing_qa_assertion', "".concat(pathLabel, ".journey_contract.north_star_workflow[").concat(index, "]"), "".concat(pathLabel, ": north_star_workflow[").concat(index, "] must be covered by at least one qa_assertions row using workflow_step_id/covers_workflow_step_ids or matching route/CTA."));
+        }
+    });
+    var workflowQaRows = buildResolveIOAICoderWorkflowQaRowsFromJourneyContract(contract);
+    return {
+        valid: !issues.some(function (issue) { return issue.severity === 'error'; }),
+        contract: contract,
+        issues: issues,
+        workflowQaRows: workflowQaRows,
+        primaryWorkflowId: cleanField(contract, ['primary_workflow_id', 'workflow_id', 'id'], 160) || 'north-star'
+    };
+}
+function collectResolveIOAICoderJourneyContractIssues(input, options) {
+    if (options === void 0) { options = {}; }
+    return validateResolveIOAICoderJourneyContract(input, options).issues.map(function (issue) { return issue.message; });
+}
+function cleanNumber(value) {
+    var parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.floor(parsed) : 0;
+}
+function cleanWorkflowQaRows(values, limit) {
+    var e_15, _a;
+    if (limit === void 0) { limit = 40; }
+    if (!Array.isArray(values)) {
+        return [];
+    }
+    var rows = [];
+    try {
+        for (var values_2 = __values(values), values_2_1 = values_2.next(); !values_2_1.done; values_2_1 = values_2.next()) {
+            var value = values_2_1.value;
+            if (!value || typeof value !== 'object') {
+                continue;
+            }
+            var row = {
+                index: cleanNumber(value.index) || undefined,
+                workflowId: cleanText(value.workflowId || value.workflow_id, 160) || undefined,
+                workflowStepId: cleanText(value.workflowStepId || value.workflow_step_id, 160) || undefined,
+                workflowStepIds: cleanList(value.workflowStepIds || value.workflow_step_ids, 20, 160),
+                stepId: cleanText(value.stepId || value.step_id, 160) || undefined,
+                route: cleanText(value.route, 240) || undefined,
+                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,
+                coverageTags: normalizeWorkflowQaCoverageTags(value),
+                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)
+            };
+            if (row.workflowId || row.stepId || row.route || row.action || row.assertion) {
+                rows.push(row);
+            }
+            if (rows.length >= limit) {
+                break;
+            }
+        }
+    }
+    catch (e_15_1) { e_15 = { error: e_15_1 }; }
+    finally {
+        try {
+            if (values_2_1 && !values_2_1.done && (_a = values_2.return)) _a.call(values_2);
+        }
+        finally { if (e_15) throw e_15.error; }
+    }
+    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, coverageTags: Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(contractRow.coverageTags, 20, 120)), false), __read(cleanList(recorded.coverageTags, 20, 120)), false))), 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 workflowAssertionHasObservedOutputProof(assertion) {
+    if (!assertion) {
+        return false;
+    }
+    return cleanText(assertion.dataProof, 1000).length >= 8
+        || cleanText(assertion.observed, 1000).length >= 8;
+}
+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) && !workflowAssertionHasObservedOutputProof(assertion)) {
+        return "".concat(workflowRowKey(row, 0), " missing observed DOM/data proof for the saved/calculated/report output.");
+    }
+    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_16, _a, e_17, _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_17 = 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_17_1) { e_17 = { error: e_17_1 }; }
+            finally {
+                try {
+                    if (list_1_1 && !list_1_1.done && (_b = list_1.return)) _b.call(list_1);
+                }
+                finally { if (e_17) throw e_17.error; }
+            }
+        }
+    }
+    catch (e_16_1) { e_16 = { error: e_16_1 }; }
+    finally {
+        try {
+            if (values_3_1 && !values_3_1.done && (_a = values_3.return)) _a.call(values_3);
+        }
+        finally { if (e_16) throw e_16.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()
+        .replace(/[a-f0-9]{16,}/g, '<id>')
+        .replace(/\b\d{2,}\b/g, '<n>')
+        .replace(/\bline\s+<n>\b/g, 'line <n>')
+        .replace(/https?:\/\/\S+/g, '<url>');
+    var hash = 0;
+    for (var index = 0; index < text.length; index += 1) {
+        hash = ((hash << 5) - hash + text.charCodeAt(index)) | 0;
+    }
+    return "aicoder-v6-".concat(Math.abs(hash).toString(36));
+}
+function classifyResolveIOAICoderV6FailureClass(step) {
+    var explicit = cleanText(step.failureClass, 80).toLowerCase().replace(/[\s-]+/g, '_');
+    if (explicit) {
+        return explicit;
+    }
+    if (step.outcome === 'infra_retry') {
+        return 'infra';
+    }
+    var text = "".concat(step.stepType || '', "\n").concat(step.lane || '', "\n").concat(step.blocker || '', "\n").concat(step.summary || '').toLowerCase();
+    if (/\b(puppeteer|chrome|browser executable|mongo|port|startup|settings\.json|node_modules|npm install|cache|lock)\b/.test(text)) {
+        return 'infra';
+    }
+    if (/\b(ts[0-9]{3,5}|typescript|compile|build failed|ng build|cannot find name|module not found|syntax error)\b/.test(text)
+        || step.stepType === 'build') {
+        return 'compile';
+    }
+    if (step.stepType === 'journey_contract' || step.stepType === 'journey_validation') {
+        return 'journey';
+    }
+    if (step.stepType === 'workflow_qa' || step.lane === 'qa') {
+        return 'business';
+    }
+    if (step.stepType === 'publish' || step.stepType === 'test_deploy' || step.stepType === 'live_deploy' || step.lane === 'publish') {
+        return 'release';
+    }
+    return 'product_code';
+}
+function aicoderWorkflowReadinessNextCommand(status) {
+    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 buildResolveIOAICoderWorkflowProofCheckpoint(input) {
+    var _a, _b, _c, _d, _e;
+    var status = input.status;
+    var nextGate = input.nextGate;
+    var proofArtifacts = cleanList(input.businessProofArtifacts, 80, 500);
+    var workflowRows = cleanWorkflowQaRows(input.workflowQaRows, 80);
+    var completedWorkflowSteps = cleanList(input.completedWorkflowSteps, 80, 240);
+    var workflowProofFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
+        primaryWorkflowId: input.primaryWorkflowId,
+        activeWorkflowStep: input.activeWorkflowStep,
+        workflowRows: workflowRows.map(function (row) { return ({
+            workflowId: row.workflowId,
+            stepId: row.stepId,
+            status: row.status,
+            acceptanceGate: row.acceptanceGate,
+            assertion: row.assertion
+        }); }),
+        completedWorkflowSteps: completedWorkflowSteps,
+        proofArtifacts: proofArtifacts
+    }, 'aicoder-workflow-readiness');
+    var artifactFingerprint = fingerprintResolveIOAICoderWorkflowProofPayload({
+        proofArtifacts: proofArtifacts,
+        rowArtifacts: workflowRows.flatMap(function (row) { return cleanList(row.artifactPaths, 10, 500); })
+    }, 'aicoder-workflow-artifacts');
+    var requiredEvidenceByStatus = {
+        journey_contract_required: [
+            'docs/APP_JOURNEY_CONTRACT.md with validated journey_contract JSON',
+            'first/next/last north_star_workflow steps',
+            'workflow QA rows generated from journey_contract.qa_assertions'
+        ],
+        journey_contract_repair_required: [
+            'repaired journey contract validation result',
+            'command-center hub action mapped to workflow state transition'
+        ],
+        workflow_build_ready: [
+            'implemented north-star workflow from the Journey Contract',
+            'seeded data story available in the app'
+        ],
+        workflow_qa_required: [
+            'AIQaBusinessAssertion for the north-star workflow',
+            'non-empty data proof',
+            'saved/calculated output proof',
+            'report/export proof when promised'
+        ],
+        workflow_business_proof_ready: [
+            'deterministic release gate before publish',
+            'workflow proof artifact retained for acceptance'
+        ],
+        release_repair_required: [
+            'publish/deploy/sample-data failure artifact',
+            'hotfix or release-gate evidence before another full deploy'
+        ],
+        infra_repair_only: [
+            'Puppeteer/Chrome/Mongo/startup/preflight evidence',
+            'infra failure class changed or preflight passed'
+        ],
+        compile_repair_only: [
+            'compile/build log evidence',
+            'compile failure class changed or build passed'
+        ],
+        collect_new_evidence: [
+            'changed blocker fingerprint or evidence hash',
+            'fresh workflow QA artifact',
+            'AIQaBusinessAssertion or precise workflow blocker artifact'
+        ],
+        budget_stopped: [
+            'budget summary',
+            'one human decision for next bounded action'
+        ],
+        parked: [
+            'operator decision',
+            'new evidence before retry'
+        ]
+    };
+    var waitingStatus = status === 'workflow_business_proof_ready'
+        ? 'ready_to_continue'
+        : status === 'release_repair_required'
+            ? 'waiting_for_release_gate'
+            : status === 'collect_new_evidence' || input.sameFailureParked === true
+                ? 'waiting_for_new_evidence'
+                : status === 'infra_repair_only' || status === 'compile_repair_only'
+                    ? 'waiting_for_infra_or_compile'
+                    : status === 'journey_contract_required' || status === 'journey_contract_repair_required'
+                        ? 'waiting_for_journey_contract'
+                        : 'waiting_for_workflow_proof';
+    var blocksProductRepairUntilJourneyContract = input.journeyContractReady !== true
+        || status === 'journey_contract_required'
+        || status === 'journey_contract_repair_required';
+    var blocksPublishUntilWorkflowProof = input.businessProofReady !== true
+        || input.routeOnlyBlocked === true
+        || input.sameFailureParked === true
+        || blocksProductRepairUntilJourneyContract
+        || status === 'workflow_qa_required'
+        || status === 'workflow_build_ready'
+        || status === 'collect_new_evidence';
+    return {
+        required: true,
+        status: waitingStatus,
+        readinessStatus: status,
+        nextGate: nextGate,
+        startingFailureClass: cleanText((_a = input.last) === null || _a === void 0 ? void 0 : _a.failureClass, 120),
+        startingBlockerFingerprint: cleanText(((_b = input.last) === null || _b === void 0 ? void 0 : _b.blockerFingerprint) || fingerprintResolveIOAICoderV6Blocker(((_c = input.last) === null || _c === void 0 ? void 0 : _c.blocker) || ((_d = input.last) === null || _d === void 0 ? void 0 : _d.summary) || ''), 160),
+        startingEvidenceHash: cleanText((_e = input.last) === null || _e === void 0 ? void 0 : _e.evidenceHash, 160),
+        workflowProofFingerprint: workflowProofFingerprint,
+        artifactFingerprint: artifactFingerprint,
+        requiredEvidence: (requiredEvidenceByStatus[status] || []).slice(0, 20),
+        requiredResetEvidence: Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read((requiredEvidenceByStatus[status] || [])), false), __read((input.sameFailureParked === true ? ['new workflow proof fingerprint', 'new artifact fingerprint'] : [])), false), __read((input.releaseBlocked === true ? ['changed release gate fingerprint'] : [])), false))).slice(0, 20),
+        successRequiresWorkflowBusinessProof: status !== 'infra_repair_only' && status !== 'compile_repair_only' && status !== 'budget_stopped',
+        blocksProductRepairUntilJourneyContract: blocksProductRepairUntilJourneyContract,
+        blocksPublishUntilWorkflowProof: blocksPublishUntilWorkflowProof,
+        blocksPublishUntilReleaseGate: input.releaseBlocked === true || status === 'release_repair_required',
+        blocksWowUiUntilWorkflowProof: blocksPublishUntilWorkflowProof,
+        nextAction: cleanText(input.nextAction, 500) || aicoderWorkflowReadinessNextCommand(status)
+    };
+}
+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 contextReason = cleanText(context.reason, 1000);
+    var observedBlocker = cleanText((last === null || last === void 0 ? void 0 : last.blocker) || (last === null || last === void 0 ? void 0 : last.summary), 1000);
+    var reason = contextReason || observedBlocker;
+    var combinedText = "".concat(failureClass, "\n").concat(contextReason, "\n").concat(observedBlocker, "\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 businessProofReady = proofArtifacts.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';
+    var nextGate = aicoderWorkflowReadinessGateFor(status);
+    var nextCommand = aicoderWorkflowReadinessNextCommand(status);
+    var workflowProofCheckpoint = buildResolveIOAICoderWorkflowProofCheckpoint({
+        status: status,
+        nextGate: nextGate,
+        nextAction: nextCommand,
+        last: last,
+        journeyContractReady: journeyContractReady,
+        businessProofReady: businessProofReady,
+        routeOnlyBlocked: routeOnlyBlocked,
+        releaseBlocked: releaseBlocked,
+        infraOnly: infraOnly,
+        compileOnly: compileOnly,
+        sameFailureParked: sameFailureParked,
+        primaryWorkflowId: primaryWorkflowId,
+        activeWorkflowStep: activeWorkflowStep,
+        workflowQaRows: rows,
+        businessProofArtifacts: proofArtifacts,
+        completedWorkflowSteps: completedSteps
+    });
+    return {
+        status: status,
+        nextGate: nextGate,
+        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: nextCommand,
+        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,
+        workflowProofCheckpoint: workflowProofCheckpoint
+    };
+}
+function aicoderNextActionLabel(command) {
+    switch (command) {
+        case 'repair_aicoder_journey_contract':
+            return 'Repair Journey Contract';
+        case 'run_aicoder_workflow_build':
+            return 'Build North-Star Workflow';
+        case 'run_aicoder_workflow_qa':
+            return 'Run Workflow QA';
+        case 'repair_aicoder_release_gate':
+            return 'Repair Release Gate';
+        case 'repair_aicoder_compile_gate':
+            return 'Repair Compile Gate';
+        case 'repair_aicoder_infra_gate':
+            return 'Repair Infra Gate';
+        case 'run_aicoder_owner_scoped_repair':
+            return 'Run Scoped Repair';
+        case 'publish_aicoder_after_workflow_proof':
+            return 'Publish After Workflow Proof';
+        case 'park_aicoder_until_new_evidence':
+            return 'Park Until New Evidence';
+        case 'park_aicoder_budget_stop':
+            return 'Park Budget Stop';
+        default:
+            return 'Continue Workflow';
+    }
+}
+function aicoderNextActionPrimaryCommand(action, readiness) {
+    if (action === 'budget_stop') {
+        return 'park_aicoder_budget_stop';
+    }
+    if (action === 'park') {
+        return 'park_aicoder_until_new_evidence';
+    }
+    if (action === 'infra_retry') {
+        return readiness.compileOnly ? 'repair_aicoder_compile_gate' : 'repair_aicoder_infra_gate';
+    }
+    if (readiness.status === 'journey_contract_required' || readiness.status === 'journey_contract_repair_required') {
+        return 'repair_aicoder_journey_contract';
+    }
+    if (readiness.status === 'workflow_build_ready') {
+        return 'run_aicoder_workflow_build';
+    }
+    if (readiness.status === 'workflow_qa_required') {
+        return 'run_aicoder_workflow_qa';
+    }
+    if (readiness.status === 'release_repair_required') {
+        return 'repair_aicoder_release_gate';
+    }
+    if (action === 'ready_to_publish') {
+        return 'publish_aicoder_after_workflow_proof';
+    }
+    if (action === 'switch_to_repair' || action === 'retry_same_step') {
+        return 'run_aicoder_owner_scoped_repair';
+    }
+    return 'continue_aicoder_workflow';
+}
+function aicoderNextActionCostRisk(action, command, readiness) {
+    if (action === 'park' || action === 'budget_stop' || readiness.requiresHumanDecision) {
+        return 'manual_blocked';
+    }
+    if (action === 'ready_to_publish' || command === 'repair_aicoder_release_gate' || readiness.nextGate === 'release') {
+        return 'release_or_customer_send';
+    }
+    if (command === 'run_aicoder_workflow_qa' || command === 'repair_aicoder_compile_gate' || command === 'repair_aicoder_infra_gate') {
+        return 'small_model_or_qa';
+    }
+    if (command === 'continue_aicoder_workflow') {
+        return 'free_or_deterministic';
+    }
+    return 'expensive_model';
+}
+function aicoderNextActionExpectedTransition(command) {
+    switch (command) {
+        case 'repair_aicoder_journey_contract':
+            return 'Missing or invalid journey contract becomes a validated first/next/last workflow graph with QA rows.';
+        case 'run_aicoder_workflow_build':
+            return 'Journey contract becomes implemented workflow screens, hub action, data story, and reachable completion state.';
+        case 'run_aicoder_workflow_qa':
+            return 'Route/browser evidence becomes AIQaBusinessAssertion proof for the north-star workflow.';
+        case 'repair_aicoder_release_gate':
+            return 'Publish/deploy/sample-data blocker becomes hotfix evidence, release-gate evidence, or one explicit force-deploy decision.';
+        case 'repair_aicoder_compile_gate':
+            return 'Compile failure becomes a passing build or a new compile blocker fingerprint.';
+        case 'repair_aicoder_infra_gate':
+            return 'Infra/preflight failure becomes a passing startup/browser/Mongo gate or a new infra blocker fingerprint.';
+        case 'run_aicoder_owner_scoped_repair':
+            return 'Current blocker changes to passed, a new evidence hash, or a parked manual decision.';
+        case 'publish_aicoder_after_workflow_proof':
+            return 'Workflow-proven artifact moves through the release gate exactly once with publish/deploy evidence recorded.';
+        case 'park_aicoder_budget_stop':
+        case 'park_aicoder_until_new_evidence':
+            return 'Runner stops spending until an operator records new evidence or an explicit next action.';
+        default:
+            return 'Runner advances to the next workflow-first gate with evidence recorded.';
+    }
+}
+function buildResolveIOAICoderNextActionStopConditions(readiness, command) {
+    var stopConditions = [
+        'Do not accept scorecard, wow score, or route load as app success without AIQaBusinessAssertion workflow proof.'
+    ];
+    if (!readiness.journeyContractReady || command === 'repair_aicoder_journey_contract') {
+        stopConditions.push('Do not run build tasks until docs/APP_JOURNEY_CONTRACT.md validates with first/next/last workflow steps.');
+    }
+    if (!readiness.businessProofReady || readiness.routeOnlyBlocked || command === 'run_aicoder_workflow_qa') {
+        stopConditions.push('Do not publish or run wow UI polish until workflow business proof passes.');
+        stopConditions.push('Route-only proof must stay labeled as route evidence, not acceptance.');
+    }
+    if (readiness.releaseBlocked || command === 'repair_aicoder_release_gate') {
+        stopConditions.push('Do not repeat a full publish/deploy until release blocker evidence changes or hotfix/force evidence is recorded.');
+    }
+    if (readiness.infraOnly || readiness.compileOnly) {
+        stopConditions.push('Infra, startup, Puppeteer, Chrome, Mongo, and compile failures stay in infra/compile repair; do not charge them as product workflow failure.');
+    }
+    if (readiness.sameFailureParked) {
+        stopConditions.push('Do not retry the same model/code repair until the blocker fingerprint, evidence hash, or workflow proof artifact changes.');
+    }
+    if (readiness.requiresHumanDecision) {
+        stopConditions.push('Do not spend additional model or release budget until an operator records the next bounded action.');
+    }
+    return Array.from(new Set(stopConditions)).slice(0, 12);
+}
+function buildResolveIOAICoderNextActionContract(input) {
+    var workflowReadiness = input.workflowReadiness;
+    var workflowProofCheckpoint = input.workflowProofCheckpoint;
+    var history = Array.isArray(input.bundle.aiCoderV6StepHistory) ? input.bundle.aiCoderV6StepHistory : [];
+    var last = history[history.length - 1];
+    var command = aicoderNextActionPrimaryCommand(input.action, workflowReadiness);
+    var costRisk = aicoderNextActionCostRisk(input.action, command, workflowReadiness);
+    var hotfixCommitRequired = command === 'repair_aicoder_release_gate'
+        || workflowReadiness.releaseBlocked
+        || workflowReadiness.nextGate === 'release';
+    var liveHotfixBlockedUntilCommit = hotfixCommitRequired;
+    var requiredHotfixCommitProof = hotfixCommitRequired
+        ? ['sourceCommitSha', 'githubCommitUrl', 'gitCommitStatus=passed', 'gitPushStatus=passed']
+        : [];
+    var requiresHumanApproval = input.action === 'park'
+        || input.action === 'budget_stop'
+        || input.action === 'ready_to_publish'
+        || input.budgetExceeded === true
+        || workflowReadiness.requiresHumanDecision === true;
+    var workflowFirstSatisfied = workflowReadiness.journeyContractReady
+        && workflowReadiness.businessProofReady
+        && !workflowReadiness.releaseBlocked
+        && !workflowReadiness.routeOnlyBlocked
+        && !workflowReadiness.infraOnly
+        && !workflowReadiness.compileOnly
+        && !workflowReadiness.sameFailureParked;
+    var safeToAutoRun = !requiresHumanApproval && (command === 'repair_aicoder_journey_contract'
+        || command === 'run_aicoder_workflow_build'
+        || command === 'run_aicoder_workflow_qa'
+        || command === 'repair_aicoder_release_gate'
+        || command === 'repair_aicoder_compile_gate'
+        || command === 'repair_aicoder_infra_gate'
+        || (command === 'run_aicoder_owner_scoped_repair' && workflowReadiness.canRunProductRepair)
+        || (command === 'continue_aicoder_workflow' && !workflowReadiness.blockers.length));
+    var canRunWithoutCodexMonitor = safeToAutoRun
+        && workflowProofCheckpoint.requiredEvidence.length > 0
+        && workflowProofCheckpoint.nextAction.length > 0;
+    var blockers = Array.from(new Set(__spreadArray(__spreadArray([], __read(workflowReadiness.blockers), false), __read((workflowProofCheckpoint.status === 'waiting_for_new_evidence' ? workflowProofCheckpoint.requiredResetEvidence : [])), false))).slice(0, 12);
+    var preconditions = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        workflowProofCheckpoint.nextAction
+    ], __read(workflowProofCheckpoint.requiredEvidence), false), __read((workflowReadiness.journeyContractReady ? [] : ['validated APP_JOURNEY_CONTRACT.md journey_contract JSON'])), false), __read((workflowReadiness.canRunWorkflowQa ? ['workflow QA rows generated from the journey contract'] : [])), false), __read((workflowReadiness.releaseBlocked ? ['release blocker artifact or hotfix-first release evidence'] : [])), false), __read((hotfixCommitRequired ? ['sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus before live hotfix apply'] : [])), false).map(function (entry) { return cleanText(entry, 300); }).filter(Boolean))).slice(0, 12);
+    var successEvidence = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(workflowProofCheckpoint.requiredEvidence), false), __read((workflowReadiness.businessProofReady ? ['retained AIQaBusinessAssertion artifact'] : [])), false), __read((workflowReadiness.canPublish ? ['release gate accepts the workflow-proven artifact'] : [])), false), __read((command === 'repair_aicoder_release_gate' ? ['hotfix evidence or explicit one-time force release decision'] : [])), false), __read((hotfixCommitRequired ? ['GitHub commit and push proof for any manager-applied hotfix'] : [])), false).map(function (entry) { return cleanText(entry, 300); }).filter(Boolean))).slice(0, 12);
+    var stopConditions = buildResolveIOAICoderNextActionStopConditions(workflowReadiness, command);
+    if (hotfixCommitRequired) {
+        stopConditions.push('Do not apply a live AICoder backend/static hotfix until sourceCommitSha, githubCommitUrl, passed gitCommitStatus, and passed gitPushStatus are recorded.');
+    }
+    var forbiddenActions = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        'accepting route-only proof as app success',
+        'accepting scorecard-only or wow-score-only proof as app success'
+    ], __read((workflowReadiness.journeyContractReady ? [] : ['building product routes before the journey contract validates'])), false), __read((workflowReadiness.businessProofReady ? [] : ['publishing before north-star workflow business proof passes'])), false), __read((workflowReadiness.releaseBlocked ? ['rerunning full deploy/publish without changed release evidence'] : [])), false), __read((hotfixCommitRequired ? ['applying live hotfix before pushed GitHub commit proof'] : [])), false), __read((workflowReadiness.sameFailureParked ? ['retrying the same repair loop without new evidence'] : [])), false))).slice(0, 12);
+    var nextCommands = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([
+        command
+    ], __read((command === 'repair_aicoder_journey_contract' ? ['validate_aicoder_journey_contract', 'generate_workflow_qa_rows'] : [])), false), __read((command === 'run_aicoder_workflow_qa' ? ['execute_contract_qa_assertions', 'record_aiqa_business_assertion'] : [])), false), __read((command === 'repair_aicoder_release_gate' ? [
+        'collect_release_blocker_evidence',
+        'prefer_hotfix_before_full_deploy',
+        'prepare_hotfix_patch_without_live_apply',
+        'commit_and_push_hotfix_to_github',
+        'record_github_commit_for_hotfix',
+        'apply_live_hotfix_only_after_github_commit_proof'
+    ] : [])), false), __read((command === 'repair_aicoder_compile_gate' ? ['rerun_compile_gate_only', 'record_compile_evidence_hash'] : [])), false), __read((command === 'repair_aicoder_infra_gate' ? ['rerun_preflight_gate_only', 'record_infra_evidence_hash'] : [])), false), [
+        'record_aicoder_next_action_result'
+    ], false))).slice(0, 12);
+    var contractBasis = {
+        action: input.action,
+        reason: cleanText(input.reason, 500),
+        command: command,
+        readinessStatus: workflowReadiness.status,
+        checkpointStatus: workflowProofCheckpoint.status,
+        failureClass: cleanText(last === null || last === void 0 ? void 0 : last.failureClass, 120),
+        evidenceHash: (0, ai_runner_manager_policy_1.hashResolveIOAIManagerEvidence)(last)
+    };
+    return {
+        contractId: "aicoder-next-".concat((0, ai_runner_manager_policy_1.hashResolveIOAIManagerEvidence)({
+            failureClass: contractBasis.failureClass,
+            summary: "".concat(contractBasis.reason, ":").concat(contractBasis.command, ":").concat(contractBasis.readinessStatus, ":").concat(contractBasis.checkpointStatus),
+            evidenceHash: contractBasis.evidenceHash,
+            changedFiles: last === null || last === void 0 ? void 0 : last.changedFiles,
+            artifactPaths: last === null || last === void 0 ? void 0 : last.artifactPaths
+        })),
+        action: input.action,
+        label: aicoderNextActionLabel(command),
+        primaryCommand: command,
+        lane: input.nextLane,
+        stepType: input.nextStep,
+        safeToAutoRun: safeToAutoRun,
+        requiresHumanApproval: requiresHumanApproval,
+        canRunWithoutCodexMonitor: canRunWithoutCodexMonitor,
+        codexFallbackRequired: !canRunWithoutCodexMonitor && !requiresHumanApproval,
+        codexFallbackReason: canRunWithoutCodexMonitor
+            ? ''
+            : requiresHumanApproval
+                ? 'Operator approval is required before the next action.'
+                : 'Next action needs stronger deterministic evidence before it can run unattended.',
+        costRisk: costRisk,
+        workflowFirstSatisfied: workflowFirstSatisfied,
+        decisionBasis: {
+            journeyContractReady: workflowReadiness.journeyContractReady,
+            workflowProofReady: workflowReadiness.businessProofReady,
+            sampleDataReady: workflowReadiness.businessProofReady && !workflowReadiness.releaseBlocked,
+            releaseBlocked: workflowReadiness.releaseBlocked,
+            routeOnlyBlocked: workflowReadiness.routeOnlyBlocked,
+            infraOnly: workflowReadiness.infraOnly,
+            compileOnly: workflowReadiness.compileOnly,
+            sameFailureParked: workflowReadiness.sameFailureParked,
+            canPublish: workflowReadiness.canPublish,
+            canPolishWowUi: workflowReadiness.canPolishWowUi,
+            workflowReadinessStatus: workflowReadiness.status,
+            workflowProofCheckpointStatus: workflowProofCheckpoint.status,
+            failureClass: contractBasis.failureClass,
+            evidenceHash: cleanText((last === null || last === void 0 ? void 0 : last.evidenceHash) || contractBasis.evidenceHash, 160),
+            hotfixCommitRequired: hotfixCommitRequired,
+            liveHotfixBlockedUntilCommit: liveHotfixBlockedUntilCommit
+        },
+        preconditions: preconditions,
+        expectedStateTransition: aicoderNextActionExpectedTransition(command),
+        successEvidence: successEvidence,
+        requiredHotfixCommitProof: requiredHotfixCommitProof,
+        stopConditions: stopConditions,
+        forbiddenActions: forbiddenActions,
+        nextCommands: nextCommands,
+        blockers: blockers,
+        ownerFiles: cleanList(last === null || last === void 0 ? void 0 : last.changedFiles, 20, 500),
+        createdAt: isoNow(input.now)
+    };
+}
+function buildResolveIOAICoderV6Budget(existing) {
+    return {
+        maxPromptTokensPerNonInitialStep: Number((existing === null || existing === void 0 ? void 0 : existing.maxPromptTokensPerNonInitialStep) || 4000),
+        maxTotalPromptTokens: Number((existing === null || existing === void 0 ? void 0 : existing.maxTotalPromptTokens) || 120000),
+        maxLoopsPerRun: Number((existing === null || existing === void 0 ? void 0 : existing.maxLoopsPerRun) || 24),
+        maxRepeatedNoProgress: Number((existing === null || existing === void 0 ? void 0 : existing.maxRepeatedNoProgress) || 2),
+        maxRuntimeMinutesPerLane: Number((existing === null || existing === void 0 ? void 0 : existing.maxRuntimeMinutesPerLane) || 30),
+        softBudgetUsd: Number((existing === null || existing === void 0 ? void 0 : existing.softBudgetUsd) || 30),
+        hardBudgetUsd: Number((existing === null || existing === void 0 ? void 0 : existing.hardBudgetUsd) || 60),
+        totalPromptTokenEstimate: cleanNumber(existing === null || existing === void 0 ? void 0 : existing.totalPromptTokenEstimate),
+        totalInputTokens: cleanNumber(existing === null || existing === void 0 ? void 0 : existing.totalInputTokens),
+        totalCachedInputTokens: cleanNumber(existing === null || existing === void 0 ? void 0 : existing.totalCachedInputTokens),
+        totalOutputTokens: cleanNumber(existing === null || existing === void 0 ? void 0 : existing.totalOutputTokens),
+        totalRuntimeMs: cleanNumber(existing === null || existing === void 0 ? void 0 : existing.totalRuntimeMs),
+        loopCount: cleanNumber(existing === null || existing === void 0 ? void 0 : existing.loopCount)
+    };
+}
+function initializeResolveIOAICoderV6State(input) {
+    var now = isoNow(input.now);
+    var existing = input.existing || {};
+    var existingSupervisor = existing.aiCoderV6SupervisorState;
+    var existingLaneMemory = existing.aiCoderV6LaneMemory || {};
+    var existingWorkflowMemory = existing.aiCoderV6WorkflowMemory || {};
+    var scope = cleanList(input.approvedScopeRequirements, 24, 240).join(' | ')
+        || cleanText(input.description, 1000)
+        || cleanText(input.title, 300);
+    var runId = cleanText(input.conversationId || input.jobId || input.appId, 120);
+    var defaultModel = cleanText(input.defaultModel || 'gpt-5.3-codex', 80);
+    var buildLaneMemory = function (lane) {
+        var _a;
+        var previous = existingLaneMemory[lane] || {};
+        return {
+            lane: lane,
+            model: cleanText(previous.model || defaultModel, 80),
+            threadKey: cleanText(((_a = input.laneThreadKeys) === null || _a === void 0 ? void 0 : _a[lane]) || previous.threadKey || "aicoder:".concat(input.runKind, ":").concat(runId, ":").concat(lane), 240),
+            scopeSummary: cleanText(previous.scopeSummary || scope, 1200),
+            activeStep: previous.activeStep || (lane === 'plan' ? 'plan' : lane === 'qa' ? 'qa' : lane === 'review' ? 'review' : lane === 'publish' ? 'publish' : 'task'),
+            activeBlocker: cleanText(previous.activeBlocker, 1200),
+            activeQaRow: previous.activeQaRow,
+            changedFiles: cleanList(previous.changedFiles, 80, 500),
+            artifactPaths: cleanList(previous.artifactPaths, 80, 500),
+            latestPromptVersion: cleanText(previous.latestPromptVersion, 120) || undefined,
+            latestPromptTokenEstimate: cleanNumber(previous.latestPromptTokenEstimate) || undefined,
+            updatedAt: previous.updatedAt || now
+        };
+    };
+    var laneMemory = LANES.reduce(function (accumulator, lane) {
+        accumulator[lane] = buildLaneMemory(lane);
+        return accumulator;
+    }, {});
+    var activeLane = (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeLane) || (input.runKind === 'initial_builder' ? 'plan' : 'build');
+    return {
+        aiCoderRunnerVersion: 'v6',
+        aiCoderV6SupervisorState: {
+            version: 'v6',
+            runKind: input.runKind,
+            status: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.status) || 'active',
+            currentGoal: cleanText((existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.currentGoal) || "Run AICoder ".concat(input.runKind, " ").concat(runId), 500),
+            approvedScope: cleanText((existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.approvedScope) || scope, 1400),
+            branchName: cleanText(input.branchName || (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.branchName), 240),
+            activeLane: activeLane,
+            activeStep: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeStep) || laneMemory[activeLane].activeStep,
+            activeBlocker: cleanText(existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.activeBlocker, 1200),
+            lastGoodCheckpoint: (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.lastGoodCheckpoint) || 'v6_initialized',
+            lastGoodCommit: cleanText(existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.lastGoodCommit, 240) || undefined,
+            testDeployStatus: cleanText(existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.testDeployStatus, 120) || undefined,
+            liveDeployStatus: cleanText(existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.liveDeployStatus, 120) || undefined,
+            processLease: input.processLease || (existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.processLease),
+            artifactLinks: cleanList(existingSupervisor === null || existingSupervisor === void 0 ? void 0 : existingSupervisor.artifactLinks, 80, 500),
+            updatedAt: now
+        },
+        aiCoderV6LaneMemory: laneMemory,
+        aiCoderV6WorkflowMemory: {
+            journeyContractPath: cleanText(input.journeyContractPath || existingWorkflowMemory.journeyContractPath || 'docs/APP_JOURNEY_CONTRACT.md', 500),
+            primaryWorkflowId: cleanText(existingWorkflowMemory.primaryWorkflowId, 200),
+            activeWorkflowStep: cleanText(existingWorkflowMemory.activeWorkflowStep, 200),
+            workflowQaRows: cleanWorkflowQaRows(existingWorkflowMemory.workflowQaRows, 80),
+            completedWorkflowSteps: cleanList(existingWorkflowMemory.completedWorkflowSteps, 80, 240),
+            blockedWorkflowStep: cleanText(existingWorkflowMemory.blockedWorkflowStep, 240),
+            businessProofArtifacts: cleanList(existingWorkflowMemory.businessProofArtifacts, 80, 500),
+            updatedAt: existingWorkflowMemory.updatedAt || now
+        },
+        aiCoderV6StepHistory: Array.isArray(existing.aiCoderV6StepHistory)
+            ? existing.aiCoderV6StepHistory.slice(-100)
+            : [],
+        aiCoderV6Budget: buildResolveIOAICoderV6Budget(existing.aiCoderV6Budget),
+        aiCoderV6RunnerIncidents: Array.isArray(existing.aiCoderV6RunnerIncidents)
+            ? existing.aiCoderV6RunnerIncidents.slice(-100)
+            : [],
+        aiCoderV6RecoveryPlan: existing.aiCoderV6RecoveryPlan,
+        aiCoderV6RecoveryCheckpoint: existing.aiCoderV6RecoveryCheckpoint,
+        aiCoderV6RecoveryEvidenceProbe: existing.aiCoderV6RecoveryEvidenceProbe,
+        aiCoderV6RecoveryAction: existing.aiCoderV6RecoveryAction,
+        aiCoderV6RecoveryDispatchHistory: Array.isArray(existing.aiCoderV6RecoveryDispatchHistory)
+            ? existing.aiCoderV6RecoveryDispatchHistory.slice(-50)
+            : [],
+        aiCoderV6RecoveryDirective: existing.aiCoderV6RecoveryDirective
+    };
+}
+function recordResolveIOAICoderV6Step(bundle, step) {
+    var _a;
+    var _b, _c;
+    var now = isoNow(step.now);
+    var promptTokens = cleanNumber(step.promptTokenEstimate);
+    var inputTokens = cleanNumber(step.inputTokens);
+    var cachedInputTokens = cleanNumber(step.cachedInputTokens);
+    var outputTokens = cleanNumber(step.outputTokens);
+    var runtimeMs = cleanNumber(step.runtimeMs);
+    var blocker = cleanText(step.blocker, 1200);
+    var failureClass = classifyResolveIOAICoderV6FailureClass({
+        outcome: step.outcome,
+        lane: step.lane,
+        stepType: step.stepType,
+        blocker: blocker,
+        summary: step.summary,
+        failureClass: step.failureClass
+    });
+    var previousWorkflowMemory = bundle.aiCoderV6WorkflowMemory || {};
+    var activeWorkflowStep = cleanText(step.activeWorkflowStep || previousWorkflowMemory.activeWorkflowStep, 200);
+    var explicitCompletedSteps = cleanList(step.completedWorkflowSteps, 40, 240);
+    var completedWorkflowSteps = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(cleanList(previousWorkflowMemory.completedWorkflowSteps, 80, 240)), false), __read(explicitCompletedSteps), false), __read((step.outcome === 'pass' && activeWorkflowStep ? [activeWorkflowStep] : [])), false))).slice(-80);
+    var businessProofArtifacts = Array.from(new Set(__spreadArray(__spreadArray([], __read(cleanList(previousWorkflowMemory.businessProofArtifacts, 80, 500)), false), __read(cleanList(step.businessProofArtifacts, 40, 500)), false))).slice(-80);
+    var workflowQaRows = step.workflowQaRows !== undefined
+        ? cleanWorkflowQaRows(step.workflowQaRows, 80)
+        : cleanWorkflowQaRows(previousWorkflowMemory.workflowQaRows, 80);
+    var blockedWorkflowStep = cleanText(step.blockedWorkflowStep
+        || ((step.outcome === 'needs_repair' || step.outcome === 'park_manual') ? activeWorkflowStep : '')
+        || previousWorkflowMemory.blockedWorkflowStep, 240);
+    var record = {
+        stepType: step.stepType,
+        outcome: step.outcome,
+        lane: step.lane,
+        model: cleanText(step.model, 80) || undefined,
+        threadKey: cleanText(step.threadKey, 240) || undefined,
+        promptVersion: cleanText(step.promptVersion, 120) || undefined,
+        promptTokenEstimate: promptTokens || undefined,
+        inputTokens: inputTokens || undefined,
+        cachedInputTokens: cachedInputTokens || undefined,
+        outputTokens: outputTokens || undefined,
+        runtimeMs: runtimeMs || undefined,
+        summary: cleanText(step.summary || blocker || step.outcome, 1200),
+        blocker: blocker || undefined,
+        blockerFingerprint: blocker ? fingerprintResolveIOAICoderV6Blocker(blocker) : undefined,
+        failureClass: failureClass,
+        changedFiles: cleanList(step.changedFiles, 80, 500),
+        artifactPaths: cleanList(step.artifactPaths, 80, 500),
+        nextAction: step.nextAction,
+        recordedAt: now
+    };
+    record.evidenceHash = cleanText(step.evidenceHash, 120)
+        || (0, ai_runner_manager_policy_1.hashResolveIOAIManagerEvidence)(record);
+    var previousRecord = bundle.aiCoderV6StepHistory[bundle.aiCoderV6StepHistory.length - 1];
+    var managerDecision = (0, ai_runner_manager_policy_1.decideResolveIOAIManagerPolicy)({
+        history: __spreadArray(__spreadArray([], __read(bundle.aiCoderV6StepHistory), false), [record], false),
+        current: record,
+        maxSameFailureRepeats: buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget).maxRepeatedNoProgress + 1
+    });
+    var nextLoopCount = managerDecision.loopBudgetShouldReset
+        || (previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.failureClass) !== record.failureClass
+        || (previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.blockerFingerprint) !== record.blockerFingerprint
+        || (previousRecord === null || previousRecord === void 0 ? void 0 : previousRecord.evidenceHash) !== record.evidenceHash
+        ? 1
+        : bundle.aiCoderV6Budget.loopCount + 1;
+    var budget = buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget);
+    var shouldParkForRepeatedNoProgress = !managerDecision.loopBudgetShouldReset
+        && nextLoopCount > budget.maxRepeatedNoProgress
+        && step.outcome !== 'pass'
+        && step.outcome !== 'ready_to_publish'
+        && step.outcome !== 'published';
+    var recordedRecoveryPlan = shouldParkForRepeatedNoProgress
+        ? (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryPlan)({
+            action: 'park_repeated_failure',
+            reason: 'aicoder_v6_repeated_no_progress',
+            failureClass: record.failureClass,
+            lane: record.lane,
+            stepType: record.stepType,
+            blocker: record.blocker || record.summary,
+            changedFiles: record.changedFiles,
+            artifactPaths: record.artifactPaths,
+            maxSameFailureRepeats: budget.maxRepeatedNoProgress + 1
+        })
+        : managerDecision.recoveryPlan;
+    var recordedRecoveryCheckpoint = shouldParkForRepeatedNoProgress
+        ? (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryCheckpoint)({
+            plan: recordedRecoveryPlan,
+            current: record
+        })
+        : managerDecision.recoveryCheckpoint;
+    var recordedRecoveryEvidenceProbe = shouldParkForRepeatedNoProgress
+        ? (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryEvidenceProbe)({
+            checkpoint: recordedRecoveryCheckpoint,
+            current: record
+        })
+        : managerDecision.recoveryEvidenceProbe;
+    var recordedRecoveryAction = shouldParkForRepeatedNoProgress
+        ? (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryActionPacket)({
+            plan: recordedRecoveryPlan,
+            checkpoint: recordedRecoveryCheckpoint,
+            probe: recordedRecoveryEvidenceProbe,
+            current: record
+        })
+        : managerDecision.recoveryAction;
+    var previousLane = bundle.aiCoderV6LaneMemory[step.lane];
+    var laneMemory = __assign(__assign({}, bundle.aiCoderV6LaneMemory), (_a = {}, _a[step.lane] = __assign(__assign({}, previousLane), { model: record.model || previousLane.model, threadKey: record.threadKey || previousLane.threadKey, activeStep: step.stepType, activeBlocker: record.blocker || previousLane.activeBlocker || '', activeQaRow: step.activeQaRow || previousLane.activeQaRow, changedFiles: ((_b = record.changedFiles) === null || _b === void 0 ? void 0 : _b.length) ? record.changedFiles : previousLane.changedFiles, artifactPaths: ((_c = record.artifactPaths) === null || _c === void 0 ? void 0 : _c.length) ? record.artifactPaths : previousLane.artifactPaths, latestPromptVersion: record.promptVersion || previousLane.latestPromptVersion, latestPromptTokenEstimate: promptTokens || previousLane.latestPromptTokenEstimate, updatedAt: now }), _a));
+    var complete = step.outcome === 'published' || step.outcome === 'ready_to_publish';
+    var parked = step.outcome === 'park_manual' || step.outcome === 'budget_stop';
+    return __assign(__assign({}, bundle), { aiCoderV6SupervisorState: __assign(__assign({}, bundle.aiCoderV6SupervisorState), { status: complete ? 'complete' : (parked ? 'parked' : 'active'), activeLane: step.lane, activeStep: step.stepType, activeBlocker: record.blocker || '', lastGoodCheckpoint: step.outcome === 'pass' || complete ? step.stepType : bundle.aiCoderV6SupervisorState.lastGoodCheckpoint, artifactLinks: Array.from(new Set(__spreadArray(__spreadArray([], __read(bundle.aiCoderV6SupervisorState.artifactLinks), false), __read((record.artifactPaths || [])), false))).slice(-80), updatedAt: now }), aiCoderV6LaneMemory: laneMemory, aiCoderV6WorkflowMemory: {
+            journeyContractPath: cleanText(previousWorkflowMemory.journeyContractPath || 'docs/APP_JOURNEY_CONTRACT.md', 500),
+            primaryWorkflowId: cleanText(step.primaryWorkflowId || previousWorkflowMemory.primaryWorkflowId, 200),
+            activeWorkflowStep: activeWorkflowStep,
+            workflowQaRows: workflowQaRows,
+            completedWorkflowSteps: completedWorkflowSteps,
+            blockedWorkflowStep: blockedWorkflowStep,
+            businessProofArtifacts: businessProofArtifacts,
+            updatedAt: now
+        }, aiCoderV6StepHistory: __spreadArray(__spreadArray([], __read(bundle.aiCoderV6StepHistory), false), [record], false).slice(-120), aiCoderV6Budget: __assign(__assign({}, bundle.aiCoderV6Budget), { totalPromptTokenEstimate: bundle.aiCoderV6Budget.totalPromptTokenEstimate + promptTokens, totalInputTokens: bundle.aiCoderV6Budget.totalInputTokens + inputTokens, totalCachedInputTokens: bundle.aiCoderV6Budget.totalCachedInputTokens + cachedInputTokens, totalOutputTokens: bundle.aiCoderV6Budget.totalOutputTokens + outputTokens, totalRuntimeMs: bundle.aiCoderV6Budget.totalRuntimeMs + runtimeMs, loopCount: nextLoopCount }), aiCoderV6RecoveryPlan: recordedRecoveryPlan, aiCoderV6RecoveryCheckpoint: recordedRecoveryCheckpoint, aiCoderV6RecoveryEvidenceProbe: recordedRecoveryEvidenceProbe, aiCoderV6RecoveryAction: recordedRecoveryAction });
+}
+function decideResolveIOAICoderV6Continuation(bundle) {
+    var history = bundle.aiCoderV6StepHistory || [];
+    var budget = buildResolveIOAICoderV6Budget(bundle.aiCoderV6Budget);
+    var last = history[history.length - 1];
+    var lastFingerprint = fingerprintResolveIOAICoderV6Blocker((last === null || last === void 0 ? void 0 : last.blocker) || (last === null || last === void 0 ? void 0 : last.summary) || '');
+    var repeatedNoProgressCount = 0;
+    for (var index = history.length - 1; index >= 0; index -= 1) {
+        var item = history[index];
+        if (item.outcome === 'pass' || item.outcome === 'ready_to_publish' || item.outcome === 'published') {
+            break;
+        }
+        if (item.stepType !== (last === null || last === void 0 ? void 0 : last.stepType) || item.lane !== (last === null || last === void 0 ? void 0 : last.lane)) {
+            break;
+        }
+        if (fingerprintResolveIOAICoderV6Blocker(item.blocker || item.summary || '') === lastFingerprint) {
+            repeatedNoProgressCount += 1;
+        }
+    }
+    var managerDecision = (0, ai_runner_manager_policy_1.decideResolveIOAIManagerPolicy)({
+        history: history,
+        current: last,
+        maxSameFailureRepeats: budget.maxRepeatedNoProgress + 1,
+        maxPingPongTransitions: 3,
+        infraFailureClasses: ['infra', 'compile']
+    });
+    var recoveryPlanFor = function (action, reason, extra) {
+        if (extra === void 0) { extra = {}; }
+        return (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryPlan)(__assign({ action: action, reason: reason, failureClass: last === null || last === void 0 ? void 0 : last.failureClass, lane: (last === null || last === void 0 ? void 0 : last.lane) || bundle.aiCoderV6SupervisorState.activeLane, stepType: (last === null || last === void 0 ? void 0 : last.stepType) || bundle.aiCoderV6SupervisorState.activeStep, blocker: (last === null || last === void 0 ? void 0 : last.blocker) || (last === null || last === void 0 ? void 0 : last.summary), changedFiles: last === null || last === void 0 ? void 0 : last.changedFiles, artifactPaths: last === null || last === void 0 ? void 0 : last.artifactPaths, maxSameFailureRepeats: budget.maxRepeatedNoProgress + 1 }, extra));
+    };
+    var recoveryCheckpointFor = function (recoveryPlan) { return (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryCheckpoint)({
+        plan: recoveryPlan,
+        current: last
+    }); };
+    var recoveryFieldsFor = function (recoveryPlan, recoveryCheckpoint, recoveryEvidenceProbe) {
+        var checkpoint = recoveryCheckpoint || recoveryCheckpointFor(recoveryPlan);
+        var probe = recoveryEvidenceProbe || (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryEvidenceProbe)({
+            checkpoint: checkpoint,
+            current: last
+        });
+        return {
+            recoveryPlan: recoveryPlan,
+            recoveryCheckpoint: checkpoint,
+            recoveryEvidenceProbe: probe,
+            recoveryAction: (0, ai_runner_manager_policy_1.buildResolveIOAIManagerRecoveryActionPacket)({
+                plan: recoveryPlan,
+                checkpoint: checkpoint,
+                probe: probe,
+                current: last
+            })
+        };
+    };
+    var managerRecoveryFields = function () { return recoveryFieldsFor(managerDecision.recoveryPlan, managerDecision.recoveryCheckpoint, managerDecision.recoveryEvidenceProbe); };
+    var withWorkflowReadiness = function (decision) {
+        var workflowReadiness = buildResolveIOAICoderV6WorkflowReadiness(bundle, {
+            action: decision.action,
+            reason: decision.reason,
+            nextLane: decision.nextLane,
+            nextStep: decision.nextStep,
+            budgetExceeded: decision.budgetExceeded,
+            repeatedNoProgressCount: decision.repeatedNoProgressCount
+        });
+        var workflowProofCheckpoint = workflowReadiness.workflowProofCheckpoint;
+        return __assign(__assign({}, decision), { workflowReadiness: workflowReadiness, workflowProofCheckpoint: workflowProofCheckpoint, nextActionContract: buildResolveIOAICoderNextActionContract({
+                bundle: bundle,
+                action: decision.action,
+                reason: decision.reason,
+                nextLane: decision.nextLane,
+                nextStep: decision.nextStep,
+                budgetExceeded: decision.budgetExceeded,
+                workflowReadiness: workflowReadiness,
+                workflowProofCheckpoint: workflowProofCheckpoint
+            }) });
+    };
+    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;
+    if (budgetExceeded) {
+        var recoveryPlan_1 = recoveryPlanFor('budget_stop', 'aicoder_v6_budget_guard', {
+            productRepairFailure: false
+        });
+        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 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 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 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 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 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 withWorkflowReadiness(__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: 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 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 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 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;
+    return [
+        'AICoder Runner V6 contract: use compact lane memory, diagnose first, then make the smallest proven next move.',
+        'Start with Diagnose First: observed evidence, likely cause, smallest next action, and expected proof.',
+        'Use current artifacts, changed files, and lane memory before asking for broad context.',
+        'Do not spawn duplicate build, QA, browser, server, Mongo, or Codex processes.',
+        'If repairing, inspect logs/artifacts/source/diff first; retest the failed check before advancing.',
+        'If the same blocker repeats without new proof, park with the exact blocker instead of burning more tokens.',
+        lines.goal ? "Goal: ".concat(cleanText(lines.goal, 500)) : '',
+        cleanList(lines.approvedScope, 12, 240).length ? "Approved scope: ".concat(cleanList(lines.approvedScope, 12, 240).join(' | ')) : '',
+        lines.activeLane ? "Active lane: ".concat(lines.activeLane) : '',
+        lines.activeStep ? "Active step: ".concat(lines.activeStep) : '',
+        lines.laneSummary ? "Lane memory: ".concat(cleanText(lines.laneSummary, 700)) : '',
+        lines.activeBlocker ? "Active blocker: ".concat(cleanText(lines.activeBlocker, 800)) : '',
+        ((_a = lines.currentQaRow) === null || _a === void 0 ? void 0 : _a.workflow) ? "Current QA row: ".concat(cleanText(lines.currentQaRow.workflow, 300)) : '',
+        ((_b = lines.currentQaRow) === null || _b === void 0 ? void 0 : _b.route) ? "Current QA route: ".concat(cleanText(lines.currentQaRow.route, 300)) : '',
+        lines.journeyContractPath ? "Journey contract: ".concat(cleanText(lines.journeyContractPath, 240)) : '',
+        lines.activeWorkflowStep ? "Active workflow step: ".concat(cleanText(lines.activeWorkflowStep, 240)) : '',
+        cleanList(lines.changedFiles, 12, 200).length ? "Changed files: ".concat(cleanList(lines.changedFiles, 12, 200).join(', ')) : '',
+        cleanList(lines.artifactPaths, 12, 240).length ? "Artifacts: ".concat(cleanList(lines.artifactPaths, 12, 240).join(', ')) : ''
+    ].filter(Boolean);
+}
+function buildResolveIOAICoderV6Incident(input) {
+    return {
+        incidentClass: cleanText(input.incidentClass, 120) || 'aicoder_v6_runner_incident',
+        summary: cleanText(input.summary, 1200),
+        stepType: input.stepType,
+        lane: input.lane,
+        blockerFingerprint: input.blocker ? fingerprintResolveIOAICoderV6Blocker(input.blocker) : undefined,
+        artifactPaths: cleanList(input.artifactPaths, 40, 500),
+        recordedAt: isoNow(input.now)
+    };
+}
+
+//# sourceMappingURL=aicoder-runner-v6.js.map