@resolveio/server-lib 22.3.199 → 22.3.200

package/util/ai-runner-manager-policy.js

@@ -442,6 +442,60 @@ function normalizeHotfixEvidenceTarget(value) {
         seedKey: cleanText(source.seedKey || source.seed_key || source.fixture, 240)
     };
 }
+function normalizeHotfixEvidenceTargets(value, fallback) {
+    var rawTargets = Array.isArray(value) ? value : [];
+    var targets = rawTargets
+        .map(normalizeHotfixEvidenceTarget)
+        .filter(function (target) { return Object.values(target).some(function (entry) { return cleanText(entry, 500); }); });
+    if (!targets.length && fallback && Object.values(fallback).some(function (entry) { return cleanText(entry, 500); })) {
+        targets.push(fallback);
+    }
+    var seen = new Set();
+    return targets.filter(function (target) {
+        var key = "".concat(cleanText(target.host, 240).toLowerCase(), "::").concat(cleanText(target.path || target.processName || target.configKey || target.seedKey || target.cacheKey, 500));
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    }).slice(0, 20);
+}
+function normalizeHotfixRemoteChecksumProof(value) {
+    var source = cleanObject(value);
+    return {
+        host: cleanText(source.host || source.hostname || source.domain, 240),
+        path: cleanText(source.path || source.remotePath || source.remote_path, 500),
+        checksumBefore: cleanText(source.checksumBefore || source.checksum_before || source.remoteChecksumBefore || source.remote_checksum_before, 160),
+        checksumAfter: cleanText(source.checksumAfter || source.checksum_after || source.remoteChecksumAfter || source.remote_checksum_after, 160),
+        checksum: cleanText(source.checksum || source.remoteChecksum || source.remote_checksum, 160),
+        status: cleanText(source.status, 160)
+    };
+}
+function normalizeHotfixRemoteChecksumProofs(value) {
+    return (Array.isArray(value) ? value : [])
+        .map(normalizeHotfixRemoteChecksumProof)
+        .filter(function (entry) { return entry.host || entry.path || entry.checksumAfter || entry.checksum || entry.status; })
+        .slice(0, 40);
+}
+function normalizeHotfixHostStatusProof(value) {
+    var _a, _b;
+    var source = cleanObject(value);
+    var checkCount = Number((_a = source.checkCount) !== null && _a !== void 0 ? _a : source.check_count);
+    var failedCount = Number((_b = source.failedCount) !== null && _b !== void 0 ? _b : source.failed_count);
+    return {
+        host: cleanText(source.host || source.hostname || source.domain, 240),
+        status: cleanText(source.status || source.result, 160),
+        evidence: cleanText(source.evidence || source.message || source.summary, 1000),
+        checkCount: Number.isFinite(checkCount) ? Math.max(0, Math.floor(checkCount)) : undefined,
+        failedCount: Number.isFinite(failedCount) ? Math.max(0, Math.floor(failedCount)) : undefined
+    };
+}
+function normalizeHotfixHostStatusProofs(value) {
+    return (Array.isArray(value) ? value : [])
+        .map(normalizeHotfixHostStatusProof)
+        .filter(function (entry) { return entry.host || entry.status || entry.evidence; })
+        .slice(0, 40);
+}
 function normalizeResolveIOAIManagerHotfixEvidence(value, policy) {
     var _a;
     var source = cleanObject(value);
@@ -453,18 +507,24 @@ function normalizeResolveIOAIManagerHotfixEvidence(value, policy) {
         return undefined;
     }
     var target = normalizeHotfixEvidenceTarget(source.target || source);
+    var targets = normalizeHotfixEvidenceTargets(source.targets || source.hotfixTargets || source.hotfix_targets, target);
     return {
         channel: channel,
         status: normalizeHotfixStatus(source.status),
         target: target,
+        targets: targets,
         compiledArtifactPath: cleanText(source.compiledArtifactPath || source.compiled_artifact_path || target.artifactPath, 500),
         builtDistPath: cleanText(source.builtDistPath || source.built_dist_path || target.artifactPath, 500),
         remoteChecksumBefore: cleanText(source.remoteChecksumBefore || source.remote_checksum_before || source.checksumBefore || source.checksum_before, 160),
         remoteChecksumAfter: cleanText(source.remoteChecksumAfter || source.remote_checksum_after || source.checksumAfter || source.checksum_after, 160),
         remoteChecksum: cleanText(source.remoteChecksum || source.remote_checksum || source.checksum, 160),
+        remoteChecksums: normalizeHotfixRemoteChecksumProofs(source.remoteChecksums || source.remote_checksums || source.checksums || source.hostChecksums || source.host_checksums),
         restartEvidence: cleanText(source.restartEvidence || source.restart_evidence, 1000),
+        restartResults: normalizeHotfixHostStatusProofs(source.restartResults || source.restart_results || source.restarts || source.serviceRestartResults || source.service_restart_results),
         healthCheckStatus: cleanText(source.healthCheckStatus || source.health_check_status || source.health, 160),
+        healthChecks: normalizeHotfixHostStatusProofs(source.healthChecks || source.health_checks || source.hostHealthChecks || source.host_health_checks),
         selfTestStatus: cleanText(source.selfTestStatus || source.self_test_status || source.selfTest || source.self_test, 160),
+        selfTests: normalizeHotfixHostStatusProofs(source.selfTests || source.self_tests || source.runnerManagerSelfTests || source.runner_manager_self_tests),
         releaseGateStatus: cleanText(source.releaseGateStatus || source.release_gate_status || source.releaseGate || source.release_gate, 160),
         s3UploadResult: cleanText(source.s3UploadResult || source.s3_upload_result || source.uploadResult || source.upload_result, 1000),
         cloudfrontInvalidationId: cleanText(source.cloudfrontInvalidationId || source.cloudfront_invalidation_id || source.invalidationId || source.invalidation_id, 240),
@@ -509,6 +569,95 @@ function isFullGitCommitSha(value) {
 function isStrongRemoteChecksum(value) {
     return /^[a-f0-9]{12,128}$/i.test(cleanText(value, 160));
 }
+function hotfixTargetLabel(target, fallbackIndex) {
+    return cleanText([target.host, target.path].filter(Boolean).join(':'), 800) || "target[".concat(fallbackIndex, "]");
+}
+function hotfixTargetsForBackendEvidence(evidence) {
+    var targets = normalizeHotfixEvidenceTargets(evidence.targets, evidence.target);
+    return targets.length ? targets : [evidence.target].filter(function (target) { return !!target; });
+}
+function targetMatchesHostPath(sourceHost, sourcePath, target) {
+    var host = cleanText(sourceHost, 240).toLowerCase();
+    var path = cleanText(sourcePath, 500);
+    var targetHost = cleanText(target.host, 240).toLowerCase();
+    var targetPath = cleanText(target.path, 500);
+    if (targetHost && host && targetHost !== host) {
+        return false;
+    }
+    if (targetPath && path && targetPath !== path) {
+        return false;
+    }
+    return (!!targetHost && !!host) || (!!targetPath && !!path);
+}
+function checksumProofForBackendTarget(evidence, target, allowLegacyGlobal) {
+    var proof = (evidence.remoteChecksums || []).find(function (entry) { return targetMatchesHostPath(entry.host, entry.path, target); });
+    if (proof) {
+        return proof;
+    }
+    if (allowLegacyGlobal && (evidence.remoteChecksumAfter || evidence.remoteChecksum)) {
+        return {
+            host: target.host,
+            path: target.path,
+            checksumBefore: evidence.remoteChecksumBefore,
+            checksumAfter: evidence.remoteChecksumAfter,
+            checksum: evidence.remoteChecksum,
+            status: evidence.status
+        };
+    }
+    return undefined;
+}
+function hostStatusProofForBackendTarget(records, target, allowLegacyGlobalStatus) {
+    var proof = (records || []).find(function (entry) { return targetMatchesHostPath(entry.host, undefined, target); });
+    if (proof) {
+        return proof;
+    }
+    if (allowLegacyGlobalStatus) {
+        return {
+            host: target.host,
+            status: cleanText(allowLegacyGlobalStatus, 160)
+        };
+    }
+    return undefined;
+}
+function validateBackendHotfixTargetCoverage(evidence, blockers) {
+    var targets = hotfixTargetsForBackendEvidence(evidence);
+    var structuredMultiTarget = targets.length > 1;
+    if (structuredMultiTarget && !(evidence.remoteChecksums || []).length) {
+        blockers.push('Backend JS hotfix with multiple targets requires remoteChecksums[] with a strong checksumAfter per host/path.');
+    }
+    if (structuredMultiTarget && !(evidence.restartResults || []).length) {
+        blockers.push('Backend JS hotfix with multiple targets requires restartResults[] with passed status per host.');
+    }
+    if (structuredMultiTarget && !(evidence.healthChecks || []).length) {
+        blockers.push('Backend JS hotfix with multiple targets requires healthChecks[] with passed status per host.');
+    }
+    if (structuredMultiTarget && !(evidence.selfTests || []).length) {
+        blockers.push('Backend JS hotfix with multiple targets requires selfTests[] with passed status per host.');
+    }
+    targets.forEach(function (target, index) {
+        var label = hotfixTargetLabel(target, index);
+        pushMissing(blockers, !!target.host, "Backend JS hotfix ".concat(label, " requires target host."));
+        pushMissing(blockers, !!target.path, "Backend JS hotfix ".concat(label, " requires target path."));
+        var checksumProof = checksumProofForBackendTarget(evidence, target, !structuredMultiTarget);
+        var checksumAfter = (checksumProof === null || checksumProof === void 0 ? void 0 : checksumProof.checksumAfter) || (checksumProof === null || checksumProof === void 0 ? void 0 : checksumProof.checksum) || '';
+        pushMissing(blockers, !!checksumAfter, "Backend JS hotfix ".concat(label, " requires remote checksum after replacement."));
+        if (checksumAfter && !isStrongRemoteChecksum(checksumAfter)) {
+            blockers.push("Backend JS hotfix ".concat(label, " remote checksum after replacement must be a strong hex checksum, not a label or placeholder."));
+        }
+        if ((checksumProof === null || checksumProof === void 0 ? void 0 : checksumProof.checksumBefore) && checksumAfter && checksumProof.checksumBefore === checksumAfter) {
+            blockers.push("Backend JS hotfix ".concat(label, " checksum did not change; record force/no-op evidence or do not claim a hotfix."));
+        }
+        var restartProof = hostStatusProofForBackendTarget(evidence.restartResults, target, structuredMultiTarget ? '' : (evidence.restartEvidence || evidence.serviceRestartEvidence ? 'passed' : ''));
+        pushMissing(blockers, !!restartProof && hotfixStatusPassed(restartProof.status || restartProof.evidence), "Backend JS hotfix ".concat(label, " requires restart evidence or passed restartResults status."));
+        var healthProof = hostStatusProofForBackendTarget(evidence.healthChecks, target, structuredMultiTarget ? '' : evidence.healthCheckStatus);
+        pushMissing(blockers, !!healthProof && hotfixStatusPassed(healthProof.status), "Backend JS hotfix ".concat(label, " requires passed healthCheckStatus or healthChecks status."));
+        var selfTestProof = hostStatusProofForBackendTarget(evidence.selfTests, target, structuredMultiTarget ? '' : evidence.selfTestStatus);
+        pushMissing(blockers, !!selfTestProof && hotfixStatusPassed(selfTestProof.status), "Backend JS hotfix ".concat(label, " requires passed selfTestStatus or selfTests status."));
+        if (selfTestProof && Number.isFinite(Number(selfTestProof.failedCount)) && Number(selfTestProof.failedCount) > 0) {
+            blockers.push("Backend JS hotfix ".concat(label, " selfTests failedCount must be 0."));
+        }
+    });
+}
 function githubCommitProofBlockers(value, channel) {
     var blockers = [];
     var sourceCommitSha = cleanText(value.sourceCommitSha, 120);
@@ -635,18 +784,7 @@ function validateResolveIOAIManagerHotfixEvidence(value, options) {
     }
     if (channel === 'backend_js') {
         pushMissing(blockers, !!normalized.compiledArtifactPath, 'Backend JS hotfix requires compiledArtifactPath.');
-        pushMissing(blockers, !!target.host, 'Backend JS hotfix requires target.host.');
-        pushMissing(blockers, !!target.path, 'Backend JS hotfix requires target.path.');
-        pushMissing(blockers, !!(normalized.remoteChecksumAfter || normalized.remoteChecksum), 'Backend JS hotfix requires remote checksum after replacement.');
-        if ((normalized.remoteChecksumAfter || normalized.remoteChecksum) && !isStrongRemoteChecksum(normalized.remoteChecksumAfter || normalized.remoteChecksum || '')) {
-            blockers.push('Backend JS hotfix remote checksum after replacement must be a strong hex checksum, not a label or placeholder.');
-        }
-        pushMissing(blockers, !!(normalized.restartEvidence || normalized.serviceRestartEvidence), 'Backend JS hotfix requires restart evidence.');
-        pushMissing(blockers, hotfixStatusPassed(normalized.healthCheckStatus), 'Backend JS hotfix requires passed healthCheckStatus.');
-        pushMissing(blockers, hotfixStatusPassed(normalized.selfTestStatus), 'Backend JS hotfix requires passed selfTestStatus.');
-        if (normalized.remoteChecksumBefore && normalized.remoteChecksumAfter && normalized.remoteChecksumBefore === normalized.remoteChecksumAfter) {
-            blockers.push('Backend JS hotfix checksum did not change; record force/no-op evidence or do not claim a hotfix.');
-        }
+        validateBackendHotfixTargetCoverage(normalized, blockers);
     }
     else if (channel === 'static_ui') {
         pushMissing(blockers, !!normalized.builtDistPath, 'Static UI hotfix requires builtDistPath.');
@@ -744,14 +882,19 @@ function mergeHotfixEvidenceRecordInput(input) {
         'channel',
         'status',
         'target',
+        'targets',
         'compiledArtifactPath',
         'builtDistPath',
         'remoteChecksumBefore',
         'remoteChecksumAfter',
         'remoteChecksum',
+        'remoteChecksums',
         'restartEvidence',
+        'restartResults',
         'healthCheckStatus',
+        'healthChecks',
         'selfTestStatus',
+        'selfTests',
         'releaseGateStatus',
         's3UploadResult',
         'cloudfrontInvalidationId',
@@ -2838,9 +2981,11 @@ function buildResolveIOAIManagerRecoveryPlan(input) {
         return makePlan('journey_contract_repair', 'Repair Journey Contract', 'Fix the first/next/last workflow contract before app code work continues.', 'journey_contract_repair', false, true, [
             'Open docs/APP_JOURNEY_CONTRACT.md.',
             'Define first_screen, north_star_workflow, screen_sequence, data_story, completion_states, and qa_assertions.',
+            'Give every north_star_workflow step a stable id and map each screen_sequence row with workflow_step_id or exact route/CTA.',
+            'Map every qa_assertions row to workflow_step_id or covers_workflow_step_ids so QA can walk first/next/last deterministically.',
             'Ensure each CTA maps to an action, route, method, calculation, or state transition.',
             'Validate that sample data can drive the promised workflow.'
-        ], ['validated journey_contract JSON', 'CTA-to-action mapping', 'workflow QA assertions'], ['journey validation passes', 'new workflow QA rows generated'], ['build empty routes', 'add link-only dashboard actions', 'defer workflow design to wow pass']);
+        ], ['validated journey_contract JSON', 'CTA-to-action mapping', 'screen-to-workflow mapping', 'workflow QA assertions mapped to step ids'], ['journey validation passes', 'new workflow QA rows generated'], ['build empty routes', 'add link-only dashboard actions', 'defer workflow design to wow pass']);
     }
     if (failureClass === 'release') {
         return makePlan('release_repair', 'Repair Release Gate', 'Repair deploy/publish/sample-data release evidence with a hotfix-first path before any repeated full deploy.', 'release_repair_only', false, false, [