@resolveio/server-lib 22.3.153 → 22.3.155

package/util/aicoder-runner-v6.js

@@ -47,6 +47,10 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     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.fingerprintResolveIOAICoderV6Blocker = fingerprintResolveIOAICoderV6Blocker;
 exports.buildResolveIOAICoderV6Budget = buildResolveIOAICoderV6Budget;
 exports.initializeResolveIOAICoderV6State = initializeResolveIOAICoderV6State;
@@ -99,12 +103,573 @@ function cleanList(values, limit, max) {
     }
     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 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 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;
+        }
+        rows.push({
+            index: cleanNumber(readField(assertion, ['index', 'order'])) || index + 1,
+            workflowId: cleanField(assertion, ['workflow_id', 'workflowId'], 160) || workflowId,
+            stepId: cleanField(assertion, ['step_id', 'stepId', 'id'], 160) || "qa-".concat(index + 1),
+            route: route || undefined,
+            action: action || undefined,
+            assertion: assertionText || undefined,
+            expectedState: expectedState || undefined,
+            status: cleanField(assertion, ['status'], 120) || undefined,
+            artifactPaths: cleanList(readField(assertion, ['artifact_paths', 'artifactPaths']), 20, 500)
+        });
+    });
+    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;
+        }
+        rows.push({
+            index: index + 1,
+            workflowId: workflowId,
+            stepId: buildWorkflowStepId(step, index),
+            route: cleanField(step, ['route'], 240) || undefined,
+            action: cleanField(step, ['visible_cta', 'action', 'cta'], 500) || undefined,
+            assertion: cleanField(step, ['success_confirmation', 'expected_state_transition', 'final_result'], 700) || undefined,
+            expectedState: cleanField(step, ['expected_state_transition', 'success_confirmation', 'final_result'], 500) || undefined,
+            status: undefined,
+            artifactPaths: []
+        });
+        void workflow;
+    });
+    return rows.slice(0, 80);
+}
+function validateResolveIOAICoderJourneyContract(input, options) {
+    var e_3, _a, e_4, _b, e_5, _c, e_6, _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_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (requiredKeys_1_1 && !requiredKeys_1_1.done && (_a = requiredKeys_1.return)) _a.call(requiredKeys_1);
+        }
+        finally { if (e_3) throw e_3.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_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_4) throw e_4.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_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_h && !_h.done && (_c = _g.return)) _c.call(_g);
+            }
+            finally { if (e_5) throw e_5.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_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (_l && !_l.done && (_d = _k.return)) _d.call(_k);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    workflow.forEach(function (step, index) {
+        var e_7, _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_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (requiredStepFields_1_1 && !requiredStepFields_1_1.done && (_a = requiredStepFields_1.return)) _a.call(requiredStepFields_1);
+            }
+            finally { if (e_7) throw e_7.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_8, _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_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_8) throw e_8.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."));
+        }
+    });
+    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 hasMobileQa = false;
+    var hasRecoveryQa = false;
+    var hasCompletionQa = false;
+    var hasNonEmptyQa = false;
+    qaAssertions.forEach(function (assertion, index) {
+        var e_9, _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_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_9) throw e_9.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 text = [
+            concatFields(assertion, ['id', 'type', 'kind', 'coverage', 'viewport'], 300),
+            concatFields(assertion, ['action', 'browser_steps', 'expected_dom_or_data_proof', 'proof', 'expected_result'], 1000)
+        ].join(' ').toLowerCase();
+        hasMobileQa = hasMobileQa || /\b(mobile|390x844|viewport)\b/.test(text);
+        hasRecoveryQa = hasRecoveryQa || /\b(empty|error|recovery|invalid)\b/.test(text);
+        hasCompletionQa = hasCompletionQa || /\b(complete|saved|export|report|result|recommendation|calculated|optimized)\b/.test(text);
+        hasNonEmptyQa = hasNonEmptyQa || /\b(sample|seeded|non[-\s]?empty|kpi|table|chart|record|row)\b/.test(text);
+    });
+    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."));
+    }
+    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_2, _a;
+    var e_10, _a;
     if (limit === void 0) { limit = 40; }
     if (!Array.isArray(values)) {
         return [];
@@ -135,12 +700,12 @@ function cleanWorkflowQaRows(values, limit) {
             }
         }
     }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    catch (e_10_1) { e_10 = { error: e_10_1 }; }
     finally {
         try {
             if (values_2_1 && !values_2_1.done && (_a = values_2.return)) _a.call(values_2);
         }
-        finally { if (e_2) throw e_2.error; }
+        finally { if (e_10) throw e_10.error; }
     }
     return rows;
 }
@@ -347,6 +912,45 @@ function recordResolveIOAICoderV6Step(bundle, step) {
         || (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';
@@ -360,7 +964,7 @@ function recordResolveIOAICoderV6Step(bundle, step) {
             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: managerDecision.recoveryPlan, aiCoderV6RecoveryCheckpoint: managerDecision.recoveryCheckpoint, aiCoderV6RecoveryEvidenceProbe: managerDecision.recoveryEvidenceProbe, aiCoderV6RecoveryAction: managerDecision.recoveryAction });
+        }, 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 || [];