@resolveio/server-lib 22.3.142 → 22.3.144

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

@@ -0,0 +1,997 @@
+"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.normalizeResolveIOAIManagerFailureClass = normalizeResolveIOAIManagerFailureClass;
+exports.fingerprintResolveIOAIManagerBlocker = fingerprintResolveIOAIManagerBlocker;
+exports.hashResolveIOAIManagerEvidence = hashResolveIOAIManagerEvidence;
+exports.buildResolveIOAIManagerRecoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint;
+exports.buildResolveIOAIManagerRecoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe;
+exports.buildResolveIOAIManagerRecoveryActionPacket = buildResolveIOAIManagerRecoveryActionPacket;
+exports.decideResolveIOAIManagerRecoveryActionDispatch = decideResolveIOAIManagerRecoveryActionDispatch;
+exports.appendResolveIOAIManagerRecoveryActionDispatch = appendResolveIOAIManagerRecoveryActionDispatch;
+exports.buildResolveIOAIManagerRecoveryExecutionDirective = buildResolveIOAIManagerRecoveryExecutionDirective;
+exports.decideResolveIOAIManagerRecoveryGate = decideResolveIOAIManagerRecoveryGate;
+exports.buildResolveIOAIManagerRecoveryPlan = buildResolveIOAIManagerRecoveryPlan;
+exports.decideResolveIOAIManagerPolicy = decideResolveIOAIManagerPolicy;
+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 = 40; }
+    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 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 stableHash(prefix, value) {
+    var normalized = typeof value === 'string'
+        ? cleanText(value, 12000)
+        : JSON.stringify(value || {});
+    var hash = 0;
+    for (var index = 0; index < normalized.length; index += 1) {
+        hash = ((hash << 5) - hash + normalized.charCodeAt(index)) | 0;
+    }
+    return "".concat(prefix, "-").concat(Math.abs(hash).toString(36) || '0');
+}
+function normalizeResolveIOAIManagerFailureClass(value) {
+    var normalized = cleanText(value, 80)
+        .toLowerCase()
+        .replace(/[\s-]+/g, '_');
+    if (!normalized) {
+        return 'unknown';
+    }
+    if (/^(qa_infra|infrastructure|harness|puppeteer|chrome|mongo|port|startup)$/.test(normalized)) {
+        return 'infra';
+    }
+    if (/^(build|compile|typescript|tsc|angular_build|ng_build)$/.test(normalized)) {
+        return 'compile';
+    }
+    if (/^(false_pass|route_only|missing_business_proof)$/.test(normalized)) {
+        return 'business';
+    }
+    return normalized.slice(0, 80);
+}
+function fingerprintResolveIOAIManagerBlocker(value) {
+    var normalized = 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>')
+        .replace(/\s+/g, ' ')
+        .trim();
+    return stableHash('mgr-blocker', normalized);
+}
+function resolveResolveIOAIManagerBlockerFingerprint(record, fallback) {
+    var blockerText = cleanText((record === null || record === void 0 ? void 0 : record.blocker) || (record === null || record === void 0 ? void 0 : record.summary), 4000);
+    if (blockerText) {
+        return fingerprintResolveIOAIManagerBlocker(blockerText);
+    }
+    var explicit = cleanText(record === null || record === void 0 ? void 0 : record.blockerFingerprint, 120);
+    if (explicit) {
+        return explicit;
+    }
+    return fingerprintResolveIOAIManagerBlocker(fallback || '');
+}
+function hashResolveIOAIManagerEvidence(record) {
+    if (!record) {
+        return stableHash('mgr-evidence', '');
+    }
+    var explicit = cleanText(record.evidenceHash, 120);
+    if (explicit) {
+        return explicit;
+    }
+    return stableHash('mgr-evidence', {
+        failureClass: normalizeResolveIOAIManagerFailureClass(record.failureClass),
+        blocker: cleanText(record.blocker || record.summary, 2000),
+        changedFiles: cleanList(record.changedFiles, 80, 500).sort(),
+        artifactPaths: cleanList(record.artifactPaths, 80, 500).sort()
+    });
+}
+function buildResolveIOAIManagerRecoveryCheckpoint(input) {
+    var plan = input.plan;
+    var current = input.current || {};
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, plan.objective);
+    var evidenceHash = hashResolveIOAIManagerEvidence(current);
+    var changedFiles = cleanList(current.changedFiles, 80, 500);
+    var artifactPaths = cleanList(current.artifactPaths, 80, 500);
+    var previous = input.previousCheckpoint;
+    var sameCheckpointBase = previous
+        && previous.recoveryClass === plan.recoveryClass
+        && previous.lane === plan.lane
+        && previous.stepType === plan.stepType
+        && previous.blockerFingerprint === blockerFingerprint
+        && previous.evidenceHash === evidenceHash;
+    var attempts = sameCheckpointBase ? Math.max(0, Number(previous.attempts || 0)) + 1 : 1;
+    var status = plan.recoveryClass === 'manual_handoff'
+        ? 'manual_handoff'
+        : plan.recoveryClass === 'blocked_until_new_evidence'
+            ? 'parked'
+            : plan.recoveryClass === 'advance_after_proof'
+                ? 'complete'
+                : 'active';
+    var now = isoNow(input.now);
+    var checkpointId = stableHash('mgr-recovery', {
+        recoveryClass: plan.recoveryClass,
+        lane: plan.lane,
+        stepType: plan.stepType,
+        allowedAction: plan.allowedAction,
+        blockerFingerprint: blockerFingerprint,
+        evidenceHash: evidenceHash
+    });
+    return {
+        checkpointId: checkpointId,
+        recoveryClass: plan.recoveryClass,
+        status: status,
+        lane: plan.lane,
+        stepType: plan.stepType,
+        allowedAction: plan.allowedAction,
+        productRepairAllowed: plan.productRepairAllowed,
+        expensiveModelAllowed: plan.expensiveModelAllowed,
+        attempts: attempts,
+        maxAttemptsBeforePark: plan.maxAttemptsBeforePark,
+        blockerFingerprint: blockerFingerprint,
+        evidenceHash: evidenceHash,
+        changedFiles: changedFiles,
+        artifactPaths: artifactPaths,
+        requiredEvidence: cleanList(plan.requiredEvidence, 40, 500),
+        loopResetEvidence: cleanList(plan.loopResetEvidence, 40, 500),
+        forbiddenActions: cleanList(plan.forbiddenActions, 40, 500),
+        objective: cleanText(plan.objective, 1000),
+        nextActionLabel: cleanText(plan.nextActionLabel, 160),
+        createdAt: sameCheckpointBase && (previous === null || previous === void 0 ? void 0 : previous.createdAt) ? previous.createdAt : now,
+        updatedAt: now
+    };
+}
+function makeRecoveryEvidenceProbeStep(id, kind, label, objective, artifactExpectation, successSignal, options) {
+    if (options === void 0) { options = {}; }
+    return __assign(__assign({ id: id, kind: kind, label: label, objective: cleanText(objective, 1000), required: options.required !== false }, (options.commandHint ? { commandHint: cleanText(options.commandHint, 500) } : {})), { artifactExpectation: cleanText(artifactExpectation, 500), successSignal: cleanText(successSignal, 500) });
+}
+function recoveryEvidenceProbeStepsFor(checkpoint) {
+    var base = [
+        makeRecoveryEvidenceProbeStep('snapshot_current_blocker', 'rerun_same_gate', 'Snapshot Current Blocker', 'Capture the current blocker, failure class, evidence hash, changed files, and artifact paths before any new repair.', 'runner-evidence/current-blocker.json', 'Snapshot includes the same checkpointId, blockerFingerprint, and evidenceHashBefore.')
+    ];
+    if (checkpoint.recoveryClass === 'diagnosis_only' || checkpoint.recoveryClass === 'diagnosis_revision') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('collect_read_only_root_cause_evidence', 'read_only_diagnosis', 'Collect Read-Only Root-Cause Evidence', checkpoint.recoveryClass === 'diagnosis_revision'
+                ? 'Collect new evidence that proves the current owner_files or failing_path is wrong before broadening scope.'
+                : 'Reproduce or classify the issue and record the exact customer complaint, expected result, observed result, route/module, and account context.', 'runner-evidence/diagnosis-readonly.md', 'Evidence supports one falsifiable accepted hypothesis and at least one rejected alternative.'),
+            makeRecoveryEvidenceProbeStep('validate_diagnosis_gate', 'read_only_diagnosis', 'Validate Diagnosis Gate', 'Validate issue_case, accepted_hypothesis, rejected_alternatives, failing_path, owner_files, and before/action/after proof_plan.', 'runner-evidence/diagnosis-gate.json', 'Diagnosis gate validates before product-code repair is allowed.')
+        ], false);
+    }
+    if (checkpoint.recoveryClass === 'infra_repair') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('run_infra_preflight', 'infra_preflight', 'Run Infra Preflight', 'Check Puppeteer/Chrome, ports, Mongo/settings, cache state, startup commands, and server/client process health.', 'runner-evidence/infra-preflight.log', 'The same infra gate either passes or returns a new infra blocker hash.', { commandHint: 'runner preflight: puppeteer/chrome/mongo/ports/startup' })
+        ], false);
+    }
+    if (checkpoint.recoveryClass === 'compile_repair') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('rerun_compile_gate', 'compile_check', 'Rerun Compile Gate', 'Rerun the same deterministic compile/build command and capture the first actionable error.', 'runner-evidence/compile.log', 'Compile passes or the first failing error changes.', { commandHint: 'same finite build/compile command from the failed gate' })
+        ], false);
+    }
+    if (checkpoint.recoveryClass === 'journey_contract_repair') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('validate_journey_contract', 'journey_validation', 'Validate Journey Contract', 'Validate docs/APP_JOURNEY_CONTRACT.md has first/next/last workflow, route/action/method mapping, seeded data story, completion states, and QA assertions.', 'runner-evidence/journey-contract-validation.json', 'Journey contract validates before build tasks continue.'),
+            makeRecoveryEvidenceProbeStep('verify_hub_workflow_mapping', 'journey_validation', 'Verify Hub Workflow Mapping', 'Confirm the hub CTA and screen sequence implement the journey contract instead of link-only navigation.', 'runner-evidence/hub-workflow-map.json', 'Primary hub action maps to a real route/action/method/calculation and next state.')
+        ], false);
+    }
+    if (checkpoint.recoveryClass === 'business_proof_repair' || checkpoint.recoveryClass === 'product_code_repair') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('rerun_business_assertion', 'business_assertion', 'Rerun Business Assertion', 'Run the exact issue/app promise proof and capture before/action/after DOM/data evidence.', 'runner-evidence/business-assertion.json', 'Business assertion passes, or the observed failure changes with a new artifact path.'),
+            makeRecoveryEvidenceProbeStep('check_diff_scope', 'diff_scope_check', 'Check Diff Scope', 'Compare changed files against the current diagnosis/journey owner scope before another code repair.', 'runner-evidence/diff-scope.json', 'Changed files are in scope, or diagnosis/journey scope is revised with evidence.')
+        ], false);
+    }
+    if (checkpoint.recoveryClass === 'release_repair') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('collect_release_status', 'release_status', 'Collect Release Status', 'Collect publish/deploy/build-instance/domain/CloudFront status and the last actionable deploy error.', 'runner-evidence/release-status.json', 'Release gate passes or returns a new release blocker hash without product-code repair.')
+        ], false);
+    }
+    if (checkpoint.recoveryClass === 'manual_handoff') {
+        return __spreadArray(__spreadArray([], __read(base), false), [
+            makeRecoveryEvidenceProbeStep('operator_review_checkpoint', 'operator_review', 'Operator Review Checkpoint', 'Expose budget, blocker, evidence hash, and the minimum policy/scope change needed before another expensive loop.', 'runner-evidence/operator-review.json', 'Operator approves a new scope/policy or provides new external evidence.')
+        ], false);
+    }
+    return __spreadArray(__spreadArray([], __read(base), false), [
+        makeRecoveryEvidenceProbeStep('rerun_same_deterministic_gate', 'rerun_same_gate', 'Rerun Same Deterministic Gate', 'Rerun the exact failed check and capture new logs/artifacts without changing product code first.', 'runner-evidence/retry-gate.log', 'Gate passes, or evidenceHash/blockerFingerprint/artifactPaths change.')
+    ], false);
+}
+function buildResolveIOAIManagerRecoveryEvidenceProbe(input) {
+    var checkpoint = input.checkpoint;
+    var now = isoNow(input.now);
+    var steps = recoveryEvidenceProbeStepsFor(checkpoint);
+    var requiredArtifacts = Array.from(new Set(steps
+        .filter(function (step) { return step.required; })
+        .map(function (step) { return step.artifactExpectation; })
+        .filter(Boolean)));
+    return {
+        probeId: stableHash('mgr-probe', {
+            checkpointId: checkpoint.checkpointId,
+            recoveryClass: checkpoint.recoveryClass,
+            evidenceHash: checkpoint.evidenceHash,
+            blockerFingerprint: checkpoint.blockerFingerprint
+        }),
+        checkpointId: checkpoint.checkpointId,
+        recoveryClass: checkpoint.recoveryClass,
+        lane: checkpoint.lane,
+        stepType: checkpoint.stepType,
+        objective: checkpoint.status === 'parked'
+            ? 'Collect new evidence before any additional expensive model/code repair.'
+            : cleanText(checkpoint.objective, 1000),
+        evidenceOnly: checkpoint.status === 'parked'
+            || checkpoint.recoveryClass === 'diagnosis_only'
+            || checkpoint.recoveryClass === 'diagnosis_revision'
+            || checkpoint.recoveryClass === 'infra_repair'
+            || checkpoint.recoveryClass === 'compile_repair'
+            || checkpoint.recoveryClass === 'release_repair',
+        productRepairAllowed: checkpoint.productRepairAllowed && checkpoint.status !== 'parked',
+        expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked',
+        evidenceHashBefore: checkpoint.evidenceHash,
+        blockerFingerprint: checkpoint.blockerFingerprint,
+        steps: steps,
+        requiredArtifacts: requiredArtifacts,
+        acceptanceEvidence: Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(checkpoint.requiredEvidence), false), __read(checkpoint.loopResetEvidence), false), __read(steps.map(function (step) { return step.successSignal; })), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30),
+        stopConditions: Array.from(new Set(__spreadArray(__spreadArray([], __read(checkpoint.forbiddenActions), false), [
+            'no new evidence hash',
+            'no new artifact path',
+            'product-code repair requested while evidenceOnly is true'
+        ], false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30),
+        loopResetEvidence: checkpoint.loopResetEvidence,
+        createdAt: now
+    };
+}
+function recoveryAutomationModeFor(checkpoint) {
+    if (checkpoint.status === 'manual_handoff' || checkpoint.recoveryClass === 'manual_handoff') {
+        return 'manual_review';
+    }
+    if (checkpoint.status === 'complete' || checkpoint.recoveryClass === 'advance_after_proof') {
+        return 'advance';
+    }
+    if (checkpoint.status === 'parked' || checkpoint.recoveryClass === 'blocked_until_new_evidence') {
+        return 'collect_evidence';
+    }
+    if (checkpoint.recoveryClass === 'diagnosis_only' || checkpoint.recoveryClass === 'diagnosis_revision') {
+        return 'read_only_diagnosis';
+    }
+    if (checkpoint.recoveryClass === 'infra_repair') {
+        return 'repair_infra';
+    }
+    if (checkpoint.recoveryClass === 'compile_repair') {
+        return 'repair_compile';
+    }
+    if (checkpoint.recoveryClass === 'journey_contract_repair') {
+        return 'repair_journey_contract';
+    }
+    if (checkpoint.recoveryClass === 'business_proof_repair') {
+        return 'repair_business_assertion';
+    }
+    if (checkpoint.recoveryClass === 'release_repair') {
+        return 'repair_release';
+    }
+    if (checkpoint.recoveryClass === 'product_code_repair') {
+        return 'targeted_product_repair';
+    }
+    return 'continue_gate';
+}
+function recoveryActionLabelFor(mode, checkpoint) {
+    var explicit = cleanText(checkpoint.nextActionLabel, 120);
+    if (explicit && mode !== 'collect_evidence') {
+        return explicit;
+    }
+    var labels = {
+        advance: 'Advance To Next Gate',
+        collect_evidence: 'Collect New Evidence',
+        read_only_diagnosis: 'Run Diagnosis Evidence Pass',
+        repair_infra: 'Repair Infra Gate',
+        repair_compile: 'Repair Compile Gate',
+        repair_journey_contract: 'Repair Journey Contract',
+        repair_business_assertion: 'Repair Business Proof',
+        repair_release: 'Repair Release Gate',
+        targeted_product_repair: 'Run Targeted Repair',
+        manual_review: 'Manual Review',
+        continue_gate: 'Continue Current Gate'
+    };
+    return labels[mode];
+}
+function recoveryActionAutoRunnable(mode, probe) {
+    if (mode === 'manual_review') {
+        return false;
+    }
+    if (mode === 'advance' || mode === 'continue_gate') {
+        return true;
+    }
+    if (mode === 'targeted_product_repair' || mode === 'read_only_diagnosis' || mode === 'repair_journey_contract' || mode === 'repair_business_assertion') {
+        return true;
+    }
+    return probe.steps.some(function (step) { return step.commandHint || step.kind === 'rerun_same_gate' || step.kind === 'release_status' || step.kind === 'diff_scope_check'; });
+}
+function buildResolveIOAIManagerRecoveryActionPacket(input) {
+    var checkpoint = input.checkpoint;
+    var probe = input.probe || buildResolveIOAIManagerRecoveryEvidenceProbe({
+        checkpoint: checkpoint,
+        current: input.current,
+        now: input.now
+    });
+    var mode = recoveryAutomationModeFor(checkpoint);
+    var primaryStep = probe.steps.find(function (step) { return step.required && step.id !== 'snapshot_current_blocker'; })
+        || probe.steps.find(function (step) { return step.required; })
+        || probe.steps[0];
+    var evidenceOnly = probe.evidenceOnly || mode === 'collect_evidence' || mode === 'repair_infra' || mode === 'repair_compile' || mode === 'repair_release';
+    var requireNewEvidence = mode === 'collect_evidence'
+        || checkpoint.status === 'parked'
+        || checkpoint.attempts >= checkpoint.maxAttemptsBeforePark;
+    var stopWhen = Array.from(new Set(__spreadArray(__spreadArray([], __read(probe.stopConditions), false), __read((requireNewEvidence ? ['same blocker fingerprint and same evidence hash after probe'] : [])), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30);
+    var resetLoopWhen = Array.from(new Set(__spreadArray(__spreadArray(__spreadArray([], __read(checkpoint.loopResetEvidence), false), __read(probe.loopResetEvidence), false), __read((requireNewEvidence ? ['changed evidence hash', 'new artifact path'] : [])), false).map(function (entry) { return cleanText(entry, 500); }).filter(Boolean))).slice(0, 30);
+    var nextCommands = probe.steps
+        .map(function (step) { return cleanText(step.commandHint || "".concat(step.kind, ":").concat(step.id), 500); })
+        .filter(Boolean)
+        .slice(0, 12);
+    var now = isoNow(input.now);
+    return __assign(__assign({ actionId: stableHash('mgr-action', {
+            checkpointId: checkpoint.checkpointId,
+            probeId: probe.probeId,
+            mode: mode,
+            evidenceHash: checkpoint.evidenceHash,
+            blockerFingerprint: checkpoint.blockerFingerprint
+        }), checkpointId: checkpoint.checkpointId, probeId: probe.probeId, recoveryClass: checkpoint.recoveryClass, mode: mode, label: recoveryActionLabelFor(mode, checkpoint), lane: checkpoint.lane, stepType: checkpoint.stepType, primaryStepKind: (primaryStep === null || primaryStep === void 0 ? void 0 : primaryStep.kind) || 'none', objective: mode === 'collect_evidence'
+            ? probe.objective
+            : cleanText(checkpoint.objective || probe.objective, 1000), evidenceOnly: evidenceOnly, autoRunnable: recoveryActionAutoRunnable(mode, probe), productRepairAllowed: checkpoint.productRepairAllowed && !evidenceOnly && checkpoint.status !== 'parked', expensiveModelAllowed: checkpoint.expensiveModelAllowed && checkpoint.status !== 'parked', canResetLoopAfterEvidence: resetLoopWhen.length > 0, maxAttemptsBeforePark: checkpoint.maxAttemptsBeforePark, requiredArtifacts: probe.requiredArtifacts.slice(0, 20), nextCommands: nextCommands, successCriteria: probe.acceptanceEvidence.slice(0, 20), retryPolicy: {
+            allowImmediateRetry: checkpoint.status !== 'parked' && mode !== 'manual_review',
+            requireNewEvidence: requireNewEvidence,
+            resetLoopWhen: resetLoopWhen,
+            stopWhen: stopWhen
+        } }, (mode === 'collect_evidence' ? { blockedReason: 'Manager parked this loop until the recovery action records new evidence.' } : {})), { createdAt: now });
+}
+function dispatchActionForMode(mode) {
+    var map = {
+        advance: 'advance',
+        collect_evidence: 'run_evidence_probe',
+        read_only_diagnosis: 'run_read_only_diagnosis',
+        repair_infra: 'run_infra_repair',
+        repair_compile: 'run_compile_repair',
+        repair_journey_contract: 'run_journey_contract_repair',
+        repair_business_assertion: 'run_business_assertion_repair',
+        repair_release: 'run_release_repair',
+        targeted_product_repair: 'run_targeted_product_repair',
+        manual_review: 'park_manual',
+        continue_gate: 'continue_gate'
+    };
+    return map[mode] || 'park_manual';
+}
+function buildRecoveryDispatchRecord(action, dispatchAction, status, reason, current, now) {
+    var evidenceHash = (current === null || current === void 0 ? void 0 : current.evidenceHash) || action.checkpointId || action.actionId;
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
+    var artifactPaths = cleanList(current === null || current === void 0 ? void 0 : current.artifactPaths, 20, 500);
+    var createdAt = isoNow(now);
+    return __assign(__assign(__assign({ dispatchId: stableHash('mgr-dispatch', {
+            actionId: action.actionId,
+            dispatchAction: dispatchAction,
+            evidenceHash: evidenceHash,
+            blockerFingerprint: blockerFingerprint,
+            status: status
+        }), actionId: action.actionId, checkpointId: action.checkpointId, probeId: action.probeId, mode: action.mode, dispatchAction: dispatchAction, status: status, evidenceHash: evidenceHash, blockerFingerprint: blockerFingerprint, productRepairAllowed: action.productRepairAllowed && dispatchAction === 'run_targeted_product_repair', expensiveModelAllowed: action.expensiveModelAllowed && dispatchAction !== 'run_evidence_probe', reason: reason, artifactPaths: artifactPaths }, (status === 'started' ? { startedAt: createdAt } : {})), (status === 'completed' ? { completedAt: createdAt } : {})), { createdAt: createdAt });
+}
+function decideResolveIOAIManagerRecoveryActionDispatch(input) {
+    var action = input.action;
+    var history = Array.isArray(input.history) ? input.history.filter(Boolean).slice(-50) : [];
+    var current = input.current || {};
+    if (!action) {
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: 'recovery_dispatch_missing_action',
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: false,
+            requiresNewEvidence: true,
+            newEvidence: false
+        };
+    }
+    var dispatchAction = dispatchActionForMode(action.mode);
+    var evidenceHash = current.evidenceHash || action.checkpointId || action.actionId;
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current, action.objective);
+    var sameActionHistory = history.filter(function (entry) { return entry.actionId === action.actionId; });
+    var sameEvidenceHistory = sameActionHistory.filter(function (entry) { return entry.evidenceHash === evidenceHash
+        && entry.blockerFingerprint === blockerFingerprint; });
+    var activeDispatch = sameEvidenceHistory.find(function (entry) { return entry.status === 'queued' || entry.status === 'started'; });
+    var completedDispatch = sameEvidenceHistory.find(function (entry) { return entry.status === 'completed' || entry.status === 'failed'; });
+    var newEvidence = sameActionHistory.length > 0 && sameEvidenceHistory.length === 0;
+    var requiresNewEvidence = action.retryPolicy.requireNewEvidence === true;
+    var manualOnly = action.mode === 'manual_review' || !action.autoRunnable;
+    var productDispatch = dispatchAction === 'run_targeted_product_repair';
+    var expensiveDispatch = !['run_evidence_probe', 'advance', 'continue_gate', 'park_manual'].includes(dispatchAction);
+    if (manualOnly && input.operatorApproved !== true) {
+        var record_1 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_requires_manual_review', current, input.now);
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: record_1.reason,
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: true,
+            requiresNewEvidence: requiresNewEvidence,
+            newEvidence: newEvidence,
+            dispatchRecord: record_1
+        };
+    }
+    if (productDispatch && action.productRepairAllowed !== true) {
+        var record_2 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_product_repair_not_allowed', current, input.now);
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: record_2.reason,
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: true,
+            requiresNewEvidence: true,
+            newEvidence: newEvidence,
+            dispatchRecord: record_2
+        };
+    }
+    if (activeDispatch) {
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: 'recovery_dispatch_already_running_for_same_evidence',
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: false,
+            requiresNewEvidence: true,
+            newEvidence: false
+        };
+    }
+    if (completedDispatch && requiresNewEvidence && !newEvidence) {
+        var record_3 = buildRecoveryDispatchRecord(action, 'park_manual', 'parked', 'recovery_dispatch_same_evidence_already_attempted', current, input.now);
+        return {
+            dispatchAction: 'park_manual',
+            allowed: false,
+            reason: record_3.reason,
+            status: 'parked',
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldRecordDispatch: true,
+            requiresNewEvidence: true,
+            newEvidence: false,
+            dispatchRecord: record_3
+        };
+    }
+    var status = dispatchAction === 'advance' || dispatchAction === 'continue_gate'
+        ? 'completed'
+        : 'started';
+    var record = buildRecoveryDispatchRecord(action, dispatchAction, status, 'recovery_dispatch_allowed', current, input.now);
+    return {
+        dispatchAction: dispatchAction,
+        allowed: true,
+        reason: 'recovery_dispatch_allowed',
+        status: status,
+        canRunProductRepair: productDispatch && action.productRepairAllowed === true,
+        canRunExpensiveModel: expensiveDispatch && action.expensiveModelAllowed === true,
+        shouldRecordDispatch: true,
+        requiresNewEvidence: requiresNewEvidence,
+        newEvidence: newEvidence,
+        dispatchRecord: record
+    };
+}
+function appendResolveIOAIManagerRecoveryActionDispatch(history, record, limit) {
+    if (limit === void 0) { limit = 50; }
+    var existing = Array.isArray(history) ? history.filter(Boolean) : [];
+    if (!record) {
+        return existing.slice(-limit);
+    }
+    var deduped = existing.filter(function (entry) { return entry.dispatchId !== record.dispatchId; });
+    return __spreadArray(__spreadArray([], __read(deduped), false), [record], false).slice(-limit);
+}
+function recoveryExecutionPhaseForDispatch(dispatchAction) {
+    var map = {
+        run_evidence_probe: 'evidence',
+        run_read_only_diagnosis: 'diagnosis',
+        run_infra_repair: 'infra',
+        run_compile_repair: 'compile',
+        run_journey_contract_repair: 'journey',
+        run_business_assertion_repair: 'business_proof',
+        run_release_repair: 'release',
+        run_targeted_product_repair: 'product_repair',
+        advance: 'advance',
+        continue_gate: 'advance',
+        park_manual: 'manual'
+    };
+    return map[dispatchAction] || 'manual';
+}
+function recoveryDirectiveReason(action, decision, current) {
+    var blocker = cleanText((current === null || current === void 0 ? void 0 : current.blocker) || (current === null || current === void 0 ? void 0 : current.summary) || '', 260);
+    var label = cleanText(action === null || action === void 0 ? void 0 : action.label, 120) || decision.dispatchAction;
+    var objective = cleanText(action === null || action === void 0 ? void 0 : action.objective, 260);
+    return [
+        "MANAGER_RECOVERY:".concat(decision.dispatchAction),
+        "label=".concat(label),
+        decision.reason ? "reason=".concat(decision.reason) : '',
+        blocker ? "blocker=".concat(blocker) : '',
+        objective ? "objective=".concat(objective) : ''
+    ].filter(Boolean).join(' | ');
+}
+function buildResolveIOAIManagerRecoveryExecutionDirective(input) {
+    var _a, _b, _c, _d;
+    var action = input.action;
+    var dispatchDecision = input.dispatchDecision || decideResolveIOAIManagerRecoveryActionDispatch({
+        action: action,
+        current: input.current,
+        now: input.now
+    });
+    var dispatchAction = dispatchDecision.dispatchAction;
+    var now = isoNow(input.now);
+    var phase = recoveryExecutionPhaseForDispatch(dispatchAction);
+    var lane = cleanText((action === null || action === void 0 ? void 0 : action.lane) || ((_a = input.current) === null || _a === void 0 ? void 0 : _a.lane) || '', 120);
+    var stepType = cleanText((action === null || action === void 0 ? void 0 : action.stepType) || ((_b = input.current) === null || _b === void 0 ? void 0 : _b.stepType) || '', 120);
+    var rerunReason = recoveryDirectiveReason(action, dispatchDecision, input.current);
+    var surface = cleanText(input.surface || 'runner', 120);
+    return __assign(__assign({ directiveId: stableHash('mgr-directive', {
+            surface: surface,
+            actionId: (action === null || action === void 0 ? void 0 : action.actionId) || '',
+            dispatchAction: dispatchAction,
+            reason: dispatchDecision.reason,
+            evidenceHash: ((_c = dispatchDecision.dispatchRecord) === null || _c === void 0 ? void 0 : _c.evidenceHash) || ((_d = input.current) === null || _d === void 0 ? void 0 : _d.evidenceHash) || ''
+        }), surface: surface, dispatchAction: dispatchAction, phase: phase, allowed: dispatchDecision.allowed, status: dispatchDecision.status, reason: dispatchDecision.reason, lane: lane, stepType: stepType, nextActionLabel: cleanText(action === null || action === void 0 ? void 0 : action.label, 160) || dispatchAction, rerunReason: rerunReason, evidenceOnly: (action === null || action === void 0 ? void 0 : action.evidenceOnly) !== false || dispatchAction === 'run_evidence_probe', autoRunnable: (action === null || action === void 0 ? void 0 : action.autoRunnable) === true, productRepairAllowed: (action === null || action === void 0 ? void 0 : action.productRepairAllowed) === true, expensiveModelAllowed: (action === null || action === void 0 ? void 0 : action.expensiveModelAllowed) === true, canRunProductRepair: dispatchDecision.canRunProductRepair, canRunExpensiveModel: dispatchDecision.canRunExpensiveModel, canResetLoopAfterEvidence: (action === null || action === void 0 ? void 0 : action.canResetLoopAfterEvidence) === true, requiresNewEvidence: dispatchDecision.requiresNewEvidence, newEvidence: dispatchDecision.newEvidence, maxAttemptsBeforePark: Math.max(1, Number((action === null || action === void 0 ? void 0 : action.maxAttemptsBeforePark) || 1) || 1), requiredArtifacts: cleanList(action === null || action === void 0 ? void 0 : action.requiredArtifacts, 20, 500), nextCommands: cleanList(action === null || action === void 0 ? void 0 : action.nextCommands, 20, 500), successCriteria: cleanList(action === null || action === void 0 ? void 0 : action.successCriteria, 20, 500), forbiddenActions: (action === null || action === void 0 ? void 0 : action.productRepairAllowed) === true
+            ? []
+            : ['Do not run product-code repair from this directive unless canRunProductRepair is true.'] }, (dispatchDecision.dispatchRecord ? { dispatchRecord: dispatchDecision.dispatchRecord } : {})), { createdAt: now });
+}
+function listHasNewEntry(current, previous) {
+    var existing = new Set(previous.map(function (entry) { return cleanText(entry, 500); }).filter(Boolean));
+    return current.some(function (entry) {
+        var normalized = cleanText(entry, 500);
+        return !!normalized && !existing.has(normalized);
+    });
+}
+function proposedActionIsProductRepair(value) {
+    var normalized = cleanText(value, 120);
+    return /product|code|repair|build|business|journey|workflow/i.test(normalized)
+        && !/infra|compile|diagnosis|manual|evidence|release|publish/i.test(normalized);
+}
+function decideResolveIOAIManagerRecoveryGate(input) {
+    var checkpoint = input.checkpoint;
+    var hasCurrent = !!input.current;
+    var current = input.current || {};
+    var blockerFingerprint = hasCurrent
+        ? resolveResolveIOAIManagerBlockerFingerprint(current, checkpoint.objective)
+        : checkpoint.blockerFingerprint;
+    var evidenceHash = hasCurrent ? hashResolveIOAIManagerEvidence(current) : checkpoint.evidenceHash;
+    var changedFiles = hasCurrent ? cleanList(current.changedFiles, 80, 500) : checkpoint.changedFiles;
+    var artifactPaths = hasCurrent ? cleanList(current.artifactPaths, 80, 500) : checkpoint.artifactPaths;
+    var evidenceChanged = evidenceHash !== checkpoint.evidenceHash
+        || blockerFingerprint !== checkpoint.blockerFingerprint
+        || listHasNewEntry(changedFiles, checkpoint.changedFiles)
+        || listHasNewEntry(artifactPaths, checkpoint.artifactPaths);
+    var proposedAction = cleanText(input.proposedAction || checkpoint.allowedAction, 120);
+    var productRepairRequested = proposedActionIsProductRepair(proposedAction);
+    var missingEvidence = checkpoint.requiredEvidence.filter(function (required) {
+        var normalized = cleanText(required, 120).toLowerCase();
+        if (!normalized) {
+            return false;
+        }
+        if (/artifact|log|proof|gate|evidence/.test(normalized)) {
+            return !artifactPaths.length && !current.evidenceHash;
+        }
+        if (/diff|changed files|owner|scope|file/.test(normalized)) {
+            return !changedFiles.length;
+        }
+        return false;
+    });
+    var makeDecision = function (action, reason, overrides) {
+        if (overrides === void 0) { overrides = {}; }
+        return (__assign({ action: action, reason: reason, canRunProductRepair: checkpoint.productRepairAllowed, canRunExpensiveModel: checkpoint.expensiveModelAllowed, shouldResetLoopBudget: false, shouldIncrementAttempt: action === 'allow', newEvidence: evidenceChanged, blockerFingerprint: blockerFingerprint, evidenceHash: evidenceHash, missingEvidence: missingEvidence, checkpoint: __assign(__assign({}, checkpoint), { updatedAt: isoNow(input.now) }) }, overrides));
+    };
+    if (checkpoint.status === 'complete') {
+        return makeDecision('complete', 'recovery_gate_checkpoint_already_complete', {
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldIncrementAttempt: false
+        });
+    }
+    if (checkpoint.status === 'manual_handoff' && input.operatorApproved !== true) {
+        return makeDecision('manual_handoff', 'recovery_gate_manual_handoff_requires_operator_approval', {
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldIncrementAttempt: false
+        });
+    }
+    if (productRepairRequested && !checkpoint.productRepairAllowed) {
+        return makeDecision('reject_action', 'recovery_gate_product_repair_not_allowed_for_checkpoint', {
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldIncrementAttempt: false
+        });
+    }
+    if (checkpoint.status === 'parked' && !evidenceChanged) {
+        return makeDecision('collect_new_evidence', 'recovery_gate_parked_until_new_evidence', {
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldIncrementAttempt: false
+        });
+    }
+    if (checkpoint.attempts >= checkpoint.maxAttemptsBeforePark && !evidenceChanged) {
+        return makeDecision('collect_new_evidence', 'recovery_gate_attempt_limit_requires_new_evidence', {
+            canRunProductRepair: false,
+            canRunExpensiveModel: false,
+            shouldIncrementAttempt: false
+        });
+    }
+    if (evidenceChanged) {
+        var currentFailureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass);
+        var currentCanRunProductRepair = checkpoint.productRepairAllowed
+            || !/^(infra|compile|diagnosis|release)$/i.test(currentFailureClass);
+        return makeDecision('allow', 'recovery_gate_new_evidence_unblocks_retry', {
+            canRunProductRepair: currentCanRunProductRepair,
+            canRunExpensiveModel: checkpoint.expensiveModelAllowed || currentCanRunProductRepair,
+            shouldResetLoopBudget: true
+        });
+    }
+    return makeDecision('allow', 'recovery_gate_action_allowed');
+}
+function failureKey(record) {
+    if (!record) {
+        return '';
+    }
+    var failureClass = normalizeResolveIOAIManagerFailureClass(record.failureClass);
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(record);
+    return "".concat(cleanText(record.lane, 80), ":").concat(cleanText(record.stepType, 80), ":").concat(failureClass, ":").concat(blockerFingerprint);
+}
+function failureEvidenceKey(record) {
+    return "".concat(failureKey(record), ":").concat(hashResolveIOAIManagerEvidence(record));
+}
+function isPassingOutcome(record) {
+    return /^(pass|accepted|ready_to_publish|published|ready_for_merge|complete|completed)$/i.test(cleanText(record === null || record === void 0 ? void 0 : record.outcome, 80));
+}
+function isManualOutcome(record) {
+    return /^(manual_handoff|park_manual|stopped)$/i.test(cleanText(record === null || record === void 0 ? void 0 : record.outcome, 80));
+}
+function buildResolveIOAIManagerRecoveryPlan(input) {
+    if (input === void 0) { input = {}; }
+    var action = cleanText(input.action, 80) || 'continue';
+    var reason = cleanText(input.reason, 240);
+    var failureClass = normalizeResolveIOAIManagerFailureClass(input.failureClass);
+    var lane = cleanText(input.lane, 80) || 'supervisor';
+    var stepType = cleanText(input.stepType, 80) || 'unknown';
+    var blocker = cleanText(input.blocker, 700);
+    var changedFiles = cleanList(input.changedFiles, 12, 240);
+    var artifactPaths = cleanList(input.artifactPaths, 12, 240);
+    var maxAttemptsBeforePark = Math.max(1, Number(input.maxSameFailureRepeats || 3) || 3);
+    var commonNotes = [
+        reason ? "policy_reason=".concat(reason) : '',
+        blocker ? "blocker=".concat(blocker) : '',
+        changedFiles.length ? "changed_files=".concat(changedFiles.join(', ')) : '',
+        artifactPaths.length ? "artifacts=".concat(artifactPaths.join(', ')) : ''
+    ].filter(Boolean);
+    var base = {
+        lane: lane,
+        stepType: stepType,
+        maxAttemptsBeforePark: maxAttemptsBeforePark,
+        notes: commonNotes
+    };
+    var makePlan = function (recoveryClass, nextActionLabel, objective, allowedAction, productRepairAllowed, expensiveModelAllowed, finiteSteps, requiredEvidence, loopResetEvidence, forbiddenActions) { return (__assign(__assign({}, base), { recoveryClass: recoveryClass, nextActionLabel: nextActionLabel, objective: objective, allowedAction: allowedAction, productRepairAllowed: productRepairAllowed, expensiveModelAllowed: expensiveModelAllowed, finiteSteps: finiteSteps, requiredEvidence: requiredEvidence, loopResetEvidence: loopResetEvidence, forbiddenActions: forbiddenActions })); };
+    if (action === 'reset_loop_budget') {
+        return makePlan('advance_after_proof', 'Advance After Proof', 'Checkpoint the passing evidence and move to the next required gate.', 'advance_to_next_gate', false, false, [
+            'Record the passing artifact, changed files, and gate result.',
+            'Reset the loop counter because a real gate passed.',
+            'Select the next unmet deterministic gate instead of repeating the previous repair.'
+        ], ['passing gate record', 'artifact or log proving the passed check'], ['new passing gate result', 'new business proof artifact'], ['rerun the same repair after a pass', 'mark accepted without the required downstream gate']);
+    }
+    if (action === 'manual_handoff') {
+        return makePlan('manual_handoff', 'Manual Review', 'Stop autonomous repair and expose the blocker, evidence, and last safe state.', 'manual_review_only', false, false, [
+            'Freeze further product-code edits.',
+            'Show the blocker fingerprint, evidence hash, and prior attempts.',
+            'Require a human edit to classification, scope, or retry policy before another model/code loop.'
+        ], ['blocker fingerprint', 'evidence hash', 'attempt history'], ['manual policy change', 'new external evidence'], ['start another automatic model repair', 'hide the failed evidence']);
+    }
+    if (action === 'budget_stop') {
+        return makePlan('manual_handoff', 'Budget Stop Review', 'Stop autonomous model/code loops until a cheaper scoped next action is selected.', 'budget_review_only', false, false, [
+            'Freeze further model repair loops.',
+            'Show the prompt/token/runtime budget that tripped the guard.',
+            'Select a cheaper deterministic gate, infra repair, diagnosis revision, or manual scope edit before resuming.'
+        ], ['budget guard reason', 'latest prompt estimate', 'last blocker/evidence hash'], ['manual scope reduction', 'new deterministic evidence', 'approved budget policy change'], ['start another broad model prompt', 'reset budget without new evidence', 'hide cost context']);
+    }
+    if (failureClass === 'diagnosis' || stepType === 'diagnosis_gate') {
+        return makePlan('diagnosis_only', 'Run Diagnosis Gate', 'Produce a falsifiable root-cause diagnosis before any repair.', 'read_only_diagnosis', false, true, [
+            'Reproduce or explicitly classify the customer issue.',
+            'Accept one falsifiable hypothesis and record rejected alternatives.',
+            'Identify the frontend/backend/shared failing path.',
+            'Select a small owner_files set.',
+            'Define exact before/action/after business proof.'
+        ], ['issue_case', 'accepted_hypothesis', 'rejected_alternatives', 'failing_path', 'owner_files', 'proof_plan'], ['new reproduction artifact', 'new query/log/code evidence', 'validated diagnosis gate'], ['edit product code', 'run broad repo repair', 'accept route-load evidence as success']);
+    }
+    if (failureClass === 'owner_scope' || failureClass === 'out_of_scope' || /out.?of.?scope|owner_files/i.test(reason)) {
+        return makePlan('diagnosis_revision', 'Revise Diagnosis Scope', 'Revise owner_files only when new evidence proves the current scope is wrong.', 'diagnosis_revision_only', false, true, [
+            'Compare changed files against the diagnosis owner_files.',
+            'Collect evidence proving why the new file is in the failing path.',
+            'Update accepted_hypothesis, failing_path, owner_files, and proof_plan together.',
+            'Resume repair only after the revised gate validates.'
+        ], ['out-of-scope file list', 'new failing-path evidence', 'revalidated diagnosis gate'], ['revised owner_files with evidence', 'new business proof requirement'], ['keep broad edits without diagnosis', 'add convenience refactors', 'continue repair outside owner_files']);
+    }
+    if (action === 'retry_infra') {
+        var isCompile = failureClass === 'compile';
+        return makePlan(isCompile ? 'compile_repair' : 'infra_repair', isCompile ? 'Repair Compile Gate' : 'Repair Infra Gate', isCompile
+            ? 'Fix the deterministic compile/build blocker before spending another product repair loop.'
+            : 'Fix the deterministic harness/browser/server/Mongo blocker before product repair.', isCompile ? 'compile_repair_only' : 'infra_repair_only', false, false, isCompile
+            ? [
+                'Read the exact compile/build log and identify the first actionable error.',
+                'Fix missing dependency, stale artifact, command, cache, or type wiring required by the compile gate.',
+                'Rerun the same finite compile command.',
+                'Return the compile log artifact and status.'
+            ]
+            : [
+                'Run preflight for Puppeteer, Chrome executable, ports, Mongo/settings, and startup command.',
+                'Repair only the failing harness/environment item.',
+                'Rerun the same infra check.',
+                'Return the infra log and pass/fail status.'
+            ], isCompile
+            ? ['compile command', 'compile log artifact', 'first failing error fixed or still failing']
+            : ['preflight command', 'infra log artifact', 'specific repaired environment item'], ['same check now passes', 'new infra/compile blocker hash'], ['run product-code model repair', 'count this as product failure', 'accept route/business success without the compile/infra gate']);
+    }
+    if (action === 'park_repeated_failure' || action === 'park_ping_pong') {
+        return makePlan('blocked_until_new_evidence', action === 'park_ping_pong' ? 'Park Ping-Pong Loop' : 'Park Repeated Failure', 'Stop the current loop until new evidence changes the diagnosis, route, or repair target.', 'collect_new_evidence_only', false, false, [
+            'Do not rerun the same prompt or same repair.',
+            'Show the repeated blocker and evidence hash.',
+            'Collect a new artifact: failing DOM state, stack trace, network response, Mongo delta, compile log, or revised diagnosis.',
+            'Reset the loop only after the new evidence hash changes.'
+        ], ['same failure count', 'blocker fingerprint', 'evidence hash'], ['changed evidence hash', 'new artifact path', 'revised diagnosis or journey contract'], ['alternate between two failed patches', 'increase loop budget without evidence', 'hide the park reason']);
+    }
+    if (failureClass === 'journey') {
+        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.',
+            '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']);
+    }
+    if (failureClass === 'release') {
+        return makePlan('release_repair', 'Repair Release Gate', 'Repair deploy/publish/sample-data release evidence without rewriting working app flow.', 'release_repair_only', false, false, [
+            'Read the deploy/publish/sample-data log.',
+            'Identify whether the blocker is domain, asset, seed data, route, permission, or CDN.',
+            'Repair the release artifact/config/seed issue.',
+            'Rerun only the failed release gate.'
+        ], ['deploy or publish log', 'sample-data status', 'failed release gate rerun'], ['release gate passes', 'new release blocker hash'], ['change core workflow after business QA passed', 'mark accepted from scorecard only', 'rerun full builder loop']);
+    }
+    if (failureClass === 'business' || failureClass === 'qa_evidence' || failureClass === 'route') {
+        return makePlan('business_proof_repair', 'Repair Business Proof', 'Fix the exact failing workflow assertion and prove before/action/after behavior.', 'business_repair', true, true, [
+            'Open the failing QA row or proof_plan.',
+            'Trace the UI action to method/publication/query/calculation.',
+            'Patch the smallest owner or workflow files.',
+            'Rerun only the failed business assertion.',
+            'Record DOM/data/Mongo/artifact proof.'
+        ], ['failing assertion', 'action trace', 'business proof artifact'], ['business assertion passes', 'new failed assertion with new evidence'], ['treat route load as success', 'rerun unrelated QA rows first', 'accept scorecard-only evidence']);
+    }
+    if (input.productRepairFailure !== false || failureClass === 'product_code') {
+        return makePlan('product_code_repair', 'Run Targeted Product Repair', 'Repair the current product-code blocker with the smallest scoped edit and immediate proof.', 'targeted_product_repair', true, true, [
+            'Inspect the current blocker, artifacts, changed files, and owner/workflow scope.',
+            'Form one small repair hypothesis.',
+            'Patch only files justified by the active diagnosis or journey contract.',
+            'Rerun the smallest failed gate.',
+            'Record new evidence before any additional loop.'
+        ], ['owner/workflow scope', 'repair diff', 'failed gate rerun artifact'], ['new evidence hash', 'same gate passes'], ['broad repo search-and-edit', 'rerun the same prompt without inspecting artifacts', 'change unrelated UI polish']);
+    }
+    return makePlan('continue', 'Continue Current Gate', 'Continue the current lane because no blocking loop or infra condition was detected.', 'continue', false, false, [
+        'Use the active lane memory.',
+        'Run the next finite gate.',
+        'Record artifacts and evidence hash.'
+    ], ['active lane memory', 'finite gate artifact'], ['new gate result', 'new artifact path'], ['spawn duplicate runners', 'advance without evidence']);
+}
+function collectOpenTail(records) {
+    var tail = [];
+    for (var index = records.length - 1; index >= 0; index -= 1) {
+        var record = records[index];
+        if (isPassingOutcome(record)) {
+            break;
+        }
+        tail.unshift(record);
+    }
+    return tail;
+}
+function countSameFailure(records, current) {
+    var currentKey = failureEvidenceKey(current);
+    var count = 0;
+    for (var index = records.length - 1; index >= 0; index -= 1) {
+        var record = records[index];
+        if (isPassingOutcome(record)) {
+            break;
+        }
+        if (failureEvidenceKey(record) !== currentKey) {
+            break;
+        }
+        count += 1;
+    }
+    return count;
+}
+function countPingPong(records, current) {
+    var tail = collectOpenTail(records).filter(function (record) {
+        return cleanText(record.lane, 80) === cleanText(current.lane, 80)
+            && cleanText(record.stepType, 80) === cleanText(current.stepType, 80);
+    });
+    if (tail.length < 4) {
+        return 0;
+    }
+    var keys = tail.map(failureKey).filter(Boolean);
+    var last = keys.slice(-6);
+    if (last.length < 4) {
+        return 0;
+    }
+    var distinct = Array.from(new Set(last));
+    if (distinct.length !== 2) {
+        return 0;
+    }
+    for (var index = 2; index < last.length; index += 1) {
+        if (last[index] !== last[index - 2]) {
+            return 0;
+        }
+    }
+    return last.length - 1;
+}
+function decideResolveIOAIManagerPolicy(input) {
+    var history = Array.isArray(input.history) ? input.history : [];
+    var current = input.current || history[history.length - 1] || {};
+    var failureClass = normalizeResolveIOAIManagerFailureClass(current.failureClass);
+    var blockerFingerprint = resolveResolveIOAIManagerBlockerFingerprint(current);
+    var evidenceHash = hashResolveIOAIManagerEvidence(current);
+    var previous = history.length > 1 ? history[history.length - 2] : undefined;
+    var previousSameFailure = previous && failureKey(previous) === failureKey(current);
+    var previousEvidenceHash = previousSameFailure ? hashResolveIOAIManagerEvidence(previous) : '';
+    var newEvidence = !!previousSameFailure && !!previousEvidenceHash && previousEvidenceHash !== evidenceHash;
+    var sameFailureCount = countSameFailure(history, current);
+    var pingPongCount = countPingPong(history, current);
+    var maxSameFailureRepeats = Math.max(1, Number(input.maxSameFailureRepeats || 3) || 3);
+    var maxPingPongTransitions = Math.max(3, Number(input.maxPingPongTransitions || 3) || 3);
+    var infraClasses = new Set((input.infraFailureClasses || ['infra', 'compile']).map(normalizeResolveIOAIManagerFailureClass));
+    var ignoredClasses = new Set((input.ignoredFailureClasses || []).map(normalizeResolveIOAIManagerFailureClass));
+    var base = {
+        failureClass: failureClass,
+        blockerFingerprint: blockerFingerprint,
+        evidenceHash: evidenceHash,
+        sameFailureCount: sameFailureCount,
+        pingPongCount: pingPongCount,
+        newEvidence: newEvidence,
+        loopBudgetShouldReset: false,
+        productRepairFailure: !infraClasses.has(failureClass) && !ignoredClasses.has(failureClass)
+    };
+    var withPlan = function (action, reason, overrides) {
+        if (overrides === void 0) { overrides = {}; }
+        var merged = __assign(__assign({}, base), overrides);
+        var recoveryPlan = buildResolveIOAIManagerRecoveryPlan({
+            action: action,
+            reason: reason,
+            failureClass: merged.failureClass,
+            lane: current.lane,
+            stepType: current.stepType,
+            blocker: current.blocker || current.summary,
+            sameFailureCount: merged.sameFailureCount,
+            pingPongCount: merged.pingPongCount,
+            newEvidence: merged.newEvidence,
+            productRepairFailure: merged.productRepairFailure,
+            changedFiles: current.changedFiles,
+            artifactPaths: current.artifactPaths,
+            maxSameFailureRepeats: maxSameFailureRepeats
+        });
+        var recoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint({
+            plan: recoveryPlan,
+            current: current
+        });
+        var recoveryEvidenceProbe = buildResolveIOAIManagerRecoveryEvidenceProbe({
+            checkpoint: recoveryCheckpoint,
+            current: current
+        });
+        return __assign(__assign({}, merged), { action: action, reason: reason, recoveryPlan: recoveryPlan, recoveryCheckpoint: recoveryCheckpoint, recoveryEvidenceProbe: recoveryEvidenceProbe, recoveryAction: buildResolveIOAIManagerRecoveryActionPacket({
+                plan: recoveryPlan,
+                checkpoint: recoveryCheckpoint,
+                probe: recoveryEvidenceProbe,
+                current: current
+            }) });
+    };
+    if (isPassingOutcome(current)) {
+        return withPlan('reset_loop_budget', 'manager_policy_progress_passed', {
+            loopBudgetShouldReset: true,
+            productRepairFailure: false
+        });
+    }
+    if (isManualOutcome(current)) {
+        return withPlan('manual_handoff', 'manager_policy_manual_or_stopped');
+    }
+    if (pingPongCount >= maxPingPongTransitions) {
+        return withPlan('park_ping_pong', 'manager_policy_ping_pong_failure_loop');
+    }
+    if (sameFailureCount >= maxSameFailureRepeats && !newEvidence) {
+        return withPlan('park_repeated_failure', 'manager_policy_same_failure_without_new_evidence');
+    }
+    if (infraClasses.has(failureClass)) {
+        return withPlan('retry_infra', 'manager_policy_infra_failure_routes_to_infra_repair', {
+            productRepairFailure: false
+        });
+    }
+    if (newEvidence || !previousSameFailure) {
+        return withPlan('continue', newEvidence
+            ? 'manager_policy_new_evidence_resets_loop_budget'
+            : 'manager_policy_new_failure_or_lane', {
+            loopBudgetShouldReset: true
+        });
+    }
+    return withPlan('continue', 'manager_policy_retry_below_repeat_limit');
+}
+
+//# sourceMappingURL=ai-runner-manager-policy.js.map