@resolveio/server-lib 22.3.140 → 22.3.142

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

@@ -1,997 +0,0 @@
-"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 (infraClasses.has(failureClass)) {
-        return withPlan('retry_infra', 'manager_policy_infra_failure_routes_to_infra_repair', {
-            productRepairFailure: false
-        });
-    }
-    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 (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