@resolveio/server-lib 22.3.131 → 22.3.133

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@resolveio/server-lib",
-  "version": "22.3.131",
+  "version": "22.3.133",
   "description": "",
   "scripts": {
     "package": "./build_package.sh",

package/util/ai-runner-manager-policy.d.ts

@@ -12,6 +12,89 @@ export interface ResolveIOAIManagerFailureRecord {
     summary?: string;
     recordedAt?: Date | string;
 }
+export type ResolveIOAIManagerRecoveryClass = 'advance_after_proof' | 'diagnosis_only' | 'diagnosis_revision' | 'infra_repair' | 'compile_repair' | 'journey_contract_repair' | 'business_proof_repair' | 'release_repair' | 'product_code_repair' | 'blocked_until_new_evidence' | 'manual_handoff' | 'continue';
+export interface ResolveIOAIManagerRecoveryPlan {
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    lane: string;
+    stepType: string;
+    nextActionLabel: string;
+    objective: string;
+    allowedAction: string;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    maxAttemptsBeforePark: number;
+    finiteSteps: string[];
+    requiredEvidence: string[];
+    loopResetEvidence: string[];
+    forbiddenActions: string[];
+    notes: string[];
+}
+export type ResolveIOAIManagerRecoveryCheckpointStatus = 'active' | 'parked' | 'manual_handoff' | 'complete';
+export interface ResolveIOAIManagerRecoveryCheckpoint {
+    checkpointId: string;
+    recoveryClass: ResolveIOAIManagerRecoveryClass;
+    status: ResolveIOAIManagerRecoveryCheckpointStatus;
+    lane: string;
+    stepType: string;
+    allowedAction: string;
+    productRepairAllowed: boolean;
+    expensiveModelAllowed: boolean;
+    attempts: number;
+    maxAttemptsBeforePark: number;
+    blockerFingerprint: string;
+    evidenceHash: string;
+    changedFiles: string[];
+    artifactPaths: string[];
+    requiredEvidence: string[];
+    loopResetEvidence: string[];
+    forbiddenActions: string[];
+    objective: string;
+    nextActionLabel: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ResolveIOAIManagerRecoveryCheckpointInput {
+    plan: ResolveIOAIManagerRecoveryPlan;
+    current?: ResolveIOAIManagerFailureRecord;
+    previousCheckpoint?: ResolveIOAIManagerRecoveryCheckpoint;
+    now?: Date | string;
+}
+export type ResolveIOAIManagerRecoveryGateAction = 'allow' | 'collect_new_evidence' | 'reject_action' | 'manual_handoff' | 'complete';
+export interface ResolveIOAIManagerRecoveryGateInput {
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+    current?: ResolveIOAIManagerFailureRecord;
+    proposedAction?: string;
+    operatorApproved?: boolean;
+    now?: Date | string;
+}
+export interface ResolveIOAIManagerRecoveryGateDecision {
+    action: ResolveIOAIManagerRecoveryGateAction;
+    reason: string;
+    canRunProductRepair: boolean;
+    canRunExpensiveModel: boolean;
+    shouldResetLoopBudget: boolean;
+    shouldIncrementAttempt: boolean;
+    newEvidence: boolean;
+    blockerFingerprint: string;
+    evidenceHash: string;
+    missingEvidence: string[];
+    checkpoint: ResolveIOAIManagerRecoveryCheckpoint;
+}
+export interface ResolveIOAIManagerRecoveryPlanInput {
+    action?: ResolveIOAIManagerAction | string;
+    reason?: string;
+    failureClass?: string;
+    lane?: string;
+    stepType?: string;
+    blocker?: string;
+    sameFailureCount?: number;
+    pingPongCount?: number;
+    newEvidence?: boolean;
+    productRepairFailure?: boolean;
+    changedFiles?: string[];
+    artifactPaths?: string[];
+    maxSameFailureRepeats?: number;
+}
 export interface ResolveIOAIManagerPolicyInput {
     history?: ResolveIOAIManagerFailureRecord[];
     current?: ResolveIOAIManagerFailureRecord;
@@ -31,8 +114,13 @@ export interface ResolveIOAIManagerPolicyDecision {
     newEvidence: boolean;
     loopBudgetShouldReset: boolean;
     productRepairFailure: boolean;
+    recoveryPlan: ResolveIOAIManagerRecoveryPlan;
+    recoveryCheckpoint: ResolveIOAIManagerRecoveryCheckpoint;
 }
 export declare function normalizeResolveIOAIManagerFailureClass(value: any): string;
 export declare function fingerprintResolveIOAIManagerBlocker(value: any): string;
 export declare function hashResolveIOAIManagerEvidence(record: ResolveIOAIManagerFailureRecord | undefined): string;
+export declare function buildResolveIOAIManagerRecoveryCheckpoint(input: ResolveIOAIManagerRecoveryCheckpointInput): ResolveIOAIManagerRecoveryCheckpoint;
+export declare function decideResolveIOAIManagerRecoveryGate(input: ResolveIOAIManagerRecoveryGateInput): ResolveIOAIManagerRecoveryGateDecision;
+export declare function buildResolveIOAIManagerRecoveryPlan(input?: ResolveIOAIManagerRecoveryPlanInput): ResolveIOAIManagerRecoveryPlan;
 export declare function decideResolveIOAIManagerPolicy(input: ResolveIOAIManagerPolicyInput): ResolveIOAIManagerPolicyDecision;

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

@@ -25,6 +25,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeResolveIOAIManagerFailureClass = normalizeResolveIOAIManagerFailureClass;
 exports.fingerprintResolveIOAIManagerBlocker = fingerprintResolveIOAIManagerBlocker;
 exports.hashResolveIOAIManagerEvidence = hashResolveIOAIManagerEvidence;
+exports.buildResolveIOAIManagerRecoveryCheckpoint = buildResolveIOAIManagerRecoveryCheckpoint;
+exports.decideResolveIOAIManagerRecoveryGate = decideResolveIOAIManagerRecoveryGate;
+exports.buildResolveIOAIManagerRecoveryPlan = buildResolveIOAIManagerRecoveryPlan;
 exports.decideResolveIOAIManagerPolicy = decideResolveIOAIManagerPolicy;
 function cleanText(value, max) {
     if (max === void 0) { max = 2000; }
@@ -59,6 +62,16 @@ function cleanList(values, limit, max) {
     }
     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)
@@ -113,6 +126,152 @@ function hashResolveIOAIManagerEvidence(record) {
         artifactPaths: cleanList(record.artifactPaths, 80, 500).sort()
     });
 }
+function buildResolveIOAIManagerRecoveryCheckpoint(input) {
+    var plan = input.plan;
+    var current = input.current || {};
+    var blockerFingerprint = cleanText(current.blockerFingerprint, 120)
+        || fingerprintResolveIOAIManagerBlocker(current.blocker || current.summary || 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 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 current = input.current || {};
+    var blockerFingerprint = cleanText(current.blockerFingerprint, 120)
+        || fingerprintResolveIOAIManagerBlocker(current.blocker || current.summary || checkpoint.objective || '');
+    var evidenceHash = hashResolveIOAIManagerEvidence(current);
+    var changedFiles = cleanList(current.changedFiles, 80, 500);
+    var artifactPaths = cleanList(current.artifactPaths, 80, 500);
+    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 '';
@@ -131,6 +290,136 @@ function isPassingOutcome(record) {
 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) {
@@ -208,27 +497,57 @@ function decideResolveIOAIManagerPolicy(input) {
         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
+        });
+        return __assign(__assign({}, merged), { action: action, reason: reason, recoveryPlan: recoveryPlan, recoveryCheckpoint: buildResolveIOAIManagerRecoveryCheckpoint({
+                plan: recoveryPlan,
+                current: current
+            }) });
+    };
     if (isPassingOutcome(current)) {
-        return __assign(__assign({}, base), { action: 'reset_loop_budget', reason: 'manager_policy_progress_passed', loopBudgetShouldReset: true, productRepairFailure: false });
+        return withPlan('reset_loop_budget', 'manager_policy_progress_passed', {
+            loopBudgetShouldReset: true,
+            productRepairFailure: false
+        });
     }
     if (isManualOutcome(current)) {
-        return __assign(__assign({}, base), { action: 'manual_handoff', reason: 'manager_policy_manual_or_stopped' });
+        return withPlan('manual_handoff', 'manager_policy_manual_or_stopped');
     }
     if (infraClasses.has(failureClass)) {
-        return __assign(__assign({}, base), { action: 'retry_infra', reason: 'manager_policy_infra_failure_routes_to_infra_repair', productRepairFailure: false });
+        return withPlan('retry_infra', 'manager_policy_infra_failure_routes_to_infra_repair', {
+            productRepairFailure: false
+        });
     }
     if (pingPongCount >= maxPingPongTransitions) {
-        return __assign(__assign({}, base), { action: 'park_ping_pong', reason: 'manager_policy_ping_pong_failure_loop' });
+        return withPlan('park_ping_pong', 'manager_policy_ping_pong_failure_loop');
     }
     if (sameFailureCount >= maxSameFailureRepeats && !newEvidence) {
-        return __assign(__assign({}, base), { action: 'park_repeated_failure', reason: 'manager_policy_same_failure_without_new_evidence' });
+        return withPlan('park_repeated_failure', 'manager_policy_same_failure_without_new_evidence');
     }
     if (newEvidence || !previousSameFailure) {
-        return __assign(__assign({}, base), { action: 'continue', reason: newEvidence
-                ? 'manager_policy_new_evidence_resets_loop_budget'
-                : 'manager_policy_new_failure_or_lane', loopBudgetShouldReset: true });
+        return withPlan('continue', newEvidence
+            ? 'manager_policy_new_evidence_resets_loop_budget'
+            : 'manager_policy_new_failure_or_lane', {
+            loopBudgetShouldReset: true
+        });
     }
-    return __assign(__assign({}, base), { action: 'continue', reason: 'manager_policy_retry_below_repeat_limit' });
+    return withPlan('continue', 'manager_policy_retry_below_repeat_limit');
 }
 
 //# sourceMappingURL=ai-runner-manager-policy.js.map