@revisium/orchestrator 0.2.0-alpha.3 → 0.2.0-alpha.5

package/dist/control-plane/default-playbook-policy.js

@@ -1,3 +1,4 @@
+import { PR_LIFECYCLE_NODES } from './run-profiles.js';
 export const DEFAULT_PLAYBOOK_POLICY_DIAGNOSTIC_CODES = [
     'DEFAULT_POLICY_WRONG_PIPELINE',
     'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
@@ -8,7 +9,19 @@ export const DEFAULT_PLAYBOOK_POLICY_DIAGNOSTIC_CODES = [
     'DEFAULT_POLICY_BLOCKED_TERMINAL_MISSING',
     'DEFAULT_POLICY_CANCELLED_TERMINAL_MISSING',
     'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+    'DEFAULT_POLICY_RECOVERABLE_CATCH_TERMINAL',
+    'DEFAULT_POLICY_CAP_EXHAUSTION_OFFRAMP_MISSING',
+    'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+    'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
+    'DEFAULT_POLICY_MERGE_READINESS_FRESHNESS_MISSING',
+    'DEFAULT_POLICY_CONFIRM_MERGE_FAILURE_TERMINAL',
+    'DEFAULT_POLICY_POST_MERGE_CLEANUP_MISSING',
+    'DEFAULT_POLICY_GATE_OUTCOMES_IMPLICIT',
 ];
+export const POLICY_VERSION = '1';
+const SUPPORTED_PIPELINE_IDS = ['feature-development'];
+const POLL_LOOP_SCOPE = 'pollLoop';
+const POLL_LOOP_CAP = 8;
 class PolicySink {
     pipelineId;
     diagnostics = [];
@@ -25,19 +38,28 @@ class PolicySink {
         });
     }
 }
-export function validateDefaultFeatureDevelopmentPolicy(template) {
+export function validateDefaultPlaybookPolicy(template) {
     const sink = new PolicySink(template.pipelineId);
-    if (template.pipelineId !== 'feature-development') {
-        sink.error('DEFAULT_POLICY_WRONG_PIPELINE', 'default playbook policy verifier only applies to feature-development', { expected: 'feature-development', actual: template.pipelineId });
+    if (!SUPPORTED_PIPELINE_IDS.includes(template.pipelineId)) {
+        sink.error('DEFAULT_POLICY_WRONG_PIPELINE', 'default playbook policy verifier only applies to feature-development variants', { expected: SUPPORTED_PIPELINE_IDS.join('|'), actual: template.pipelineId });
         return sink.diagnostics;
     }
     checkBlockedTerminal(template, sink);
     checkCancelledTerminal(template, sink);
     checkProducedChangeHandoff(template, sink);
     checkPrFreshnessWiring(template, sink);
+    checkApproveReverifyBeforeMerge(template, sink);
+    checkOverrideMergeRouting(template, sink);
+    checkMergeConsumesFreshReadiness(template, sink);
     checkMergeGateRecheckRouting(template, sink);
+    checkRecoveryGateRouting(template, sink);
     checkReviewFeedbackLoop(template, sink);
     checkLoopExhaustionEscalation(template, sink);
+    checkRecoverableCatches(template, sink);
+    checkCapExhaustionOffRamp(template, sink);
+    checkConfirmMergeFailureRecoverable(template, sink);
+    checkPostMergeCleanup(template, sink);
+    checkGateOutcomesExplicit(template, sink);
     return sink.diagnostics;
 }
 function checkBlockedTerminal(template, sink) {
@@ -61,23 +83,43 @@ function checkCancelledTerminal(template, sink) {
     });
 }
 function checkProducedChangeHandoff(template, sink) {
-    for (const nodeId of ['developer', 'reworkDeveloper', 'stuckReworkDeveloper', 'ciRework', 'reviewRework']) {
+    for (const nodeId of ['developer', 'reworkDeveloper', 'stuckReworkDeveloper', 'ciRework', 'reviewRework', 'questionReviewRework']) {
         expectChangeProducer(template, sink, nodeId);
     }
-    expectConsume(template, sink, {
-        code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
-        consumerId: 'codeReview',
-        producerId: 'developer',
-        as: 'developerChange',
-        staleOk: true,
-    });
-    expectConsume(template, sink, {
-        code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
-        consumerId: 'codeReview',
-        producerId: 'reworkDeveloper',
-        as: 'reworkChange',
-        optional: true,
-    });
+    if (template.nodes['codeReviewFanout']) {
+        for (const branchId of ['codeReviewPrimary', 'codeReviewSecondary']) {
+            expectConsume(template, sink, {
+                code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
+                consumerId: branchId,
+                producerId: 'developer',
+                as: 'developerChange',
+                staleOk: true,
+            });
+            expectConsume(template, sink, {
+                code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
+                consumerId: branchId,
+                producerId: 'reworkDeveloper',
+                as: 'reworkChange',
+                optional: true,
+            });
+        }
+    }
+    else {
+        expectConsume(template, sink, {
+            code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
+            consumerId: 'codeReview',
+            producerId: 'developer',
+            as: 'developerChange',
+            staleOk: true,
+        });
+        expectConsume(template, sink, {
+            code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
+            consumerId: 'codeReview',
+            producerId: 'reworkDeveloper',
+            as: 'reworkChange',
+            optional: true,
+        });
+    }
     expectConsume(template, sink, {
         code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
         consumerId: 'integrator',
@@ -113,52 +155,129 @@ function checkProducedChangeHandoff(template, sink) {
         producerId: 'reviewRework',
         as: 'reviewChange',
     });
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_CHANGE_HANDOFF_MISSING',
+        consumerId: 'questionReviewIntegrator',
+        producerId: 'questionReviewRework',
+        as: 'reviewChange',
+    });
 }
 function checkPrFreshnessWiring(template, sink) {
-    expectScript(template, sink, {
+    expectScopeConfig(template, sink, {
+        scopeId: POLL_LOOP_SCOPE,
+        cap: POLL_LOOP_CAP,
+        parent: null,
+    });
+    for (const hop of [
+        { scriptId: 'pollPr', routerId: 'prRouter', cleanTarget: 'mergeReadiness', recheckTarget: 'pollPr' },
+        {
+            scriptId: 'mergeReadiness',
+            routerId: 'mergeReadinessRouter',
+            cleanTarget: 'mergeGate',
+            recheckTarget: 'mergeReadiness',
+        },
+    ]) {
+        expectPollPrFeedbackHop(template, sink, hop);
+    }
+    expectGateArtifact(template, sink, {
         code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
-        nodeId: 'pollPr',
-        scriptRef: 'script:pollPr',
-        next: 'prRouter',
-        resultSchema: 'schema:prFeedback',
-        produces: 'prFeedback',
+        nodeId: 'mergeGate',
+        producerId: 'mergeReadiness',
+        as: 'prFeedback',
     });
+}
+function checkApproveReverifyBeforeMerge(template, sink) {
     expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
-        nodeId: 'prRouter',
-        verdict: 'clean',
-        target: 'mergeReadiness',
+        code: 'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+        nodeId: 'mergeGate',
+        verdict: 'approved',
+        target: 'mergeApproveReverify',
     });
     expectScript(template, sink, {
-        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
-        nodeId: 'mergeReadiness',
+        code: 'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+        nodeId: 'mergeApproveReverify',
         scriptRef: 'script:pollPr',
-        next: 'mergeReadinessRouter',
+        next: 'mergeApproveReverifyRouter',
         resultSchema: 'schema:prFeedback',
         produces: 'prFeedback',
     });
     expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
-        nodeId: 'mergeReadinessRouter',
+        code: 'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+        nodeId: 'mergeApproveReverifyRouter',
         verdict: 'clean',
-        target: 'mergeGate',
+        target: 'confirmMerge',
     });
-    expectGateArtifact(template, sink, {
-        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
-        nodeId: 'mergeGate',
-        producerId: 'mergeReadiness',
-        as: 'prFeedback',
+    expectRoute(template, sink, {
+        code: 'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+        nodeId: 'mergeApproveReverifyRouter',
+        verdict: 'merged',
+        target: 'cleanupWorktree',
     });
     expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
+        code: 'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+        nodeId: 'mergeApproveReverifyRouter',
+        verdict: 'closed',
+        target: 'recoveryGate',
+    });
+    expectDefaultRoute(template, sink, {
+        code: 'DEFAULT_POLICY_APPROVE_REVERIFY_MISSING',
+        nodeId: 'mergeApproveReverifyRouter',
+        target: 'classifyRecovery',
+    });
+}
+function checkOverrideMergeRouting(template, sink) {
+    expectRoute(template, sink, {
+        code: 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
         nodeId: 'mergeGate',
-        verdict: 'approved',
-        target: 'confirmMerge',
+        verdict: 'override_merge',
+        target: 'overrideMerge',
+    });
+    expectScript(template, sink, {
+        code: 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
+        nodeId: 'overrideMerge',
+        scriptRef: 'script:overrideMerge',
+        next: 'overrideMergeRouter',
+        resultSchema: 'schema:prFeedback',
+        produces: 'prFeedback',
     });
     expectConsume(template, sink, {
-        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
+        code: 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
+        consumerId: 'overrideMerge',
+        producerId: 'mergeGate',
+        as: 'gateResolution',
+    });
+    expectRoutesWithDefault(template, sink, 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING', 'overrideMergeRouter', [
+        ['clean', 'overrideConfirmMerge'],
+        ['merged', 'cleanupWorktree'],
+        ['closed', 'recoveryGate'],
+    ], 'classifyRecovery');
+    expectScript(template, sink, {
+        code: 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
+        nodeId: 'overrideConfirmMerge',
+        scriptRef: 'script:confirmMerge',
+        next: 'cleanupWorktree',
+        resultSchema: 'schema:integration',
+    });
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
+        consumerId: 'overrideConfirmMerge',
+        producerId: 'overrideMerge',
+        as: 'mergeReadiness',
+    });
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_OVERRIDE_MERGE_ROUTE_MISSING',
+        consumerId: 'classifyRecovery',
+        producerId: 'overrideMerge',
+        as: 'overrideFeedback',
+        optional: true,
+        staleOk: true,
+    });
+}
+function checkMergeConsumesFreshReadiness(template, sink) {
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_MERGE_READINESS_FRESHNESS_MISSING',
         consumerId: 'confirmMerge',
-        producerId: 'mergeReadiness',
+        producerId: 'mergeApproveReverify',
         as: 'mergeReadiness',
     });
 }
@@ -168,36 +287,13 @@ function checkMergeGateRecheckRouting(template, sink) {
         nodeId: 'mergeGate',
         outcomes: ['approved', 'recheck', 'address_review_threads', 'return_to_development', 'override_merge', 'cancel'],
     });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeGate',
-        verdict: 'recheck',
-        target: 'mergeRecheck',
-    });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeGate',
-        verdict: 'address_review_threads',
-        target: 'triage',
-    });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeGate',
-        verdict: 'return_to_development',
-        target: 'triage',
-    });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeGate',
-        verdict: 'override_merge',
-        target: 'confirmMerge',
-    });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeGate',
-        verdict: 'cancel',
-        target: 'cancelledEnd',
-    });
+    expectRoutes(template, sink, 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING', 'mergeGate', [
+        ['recheck', 'mergeRecheck'],
+        ['address_review_threads', 'triage'],
+        ['return_to_development', 'triage'],
+        ['override_merge', 'overrideMerge'],
+        ['cancel', 'cancelledEnd'],
+    ]);
     expectScript(template, sink, {
         code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
         nodeId: 'mergeRecheck',
@@ -206,18 +302,13 @@ function checkMergeGateRecheckRouting(template, sink) {
         resultSchema: 'schema:prFeedback',
         produces: 'prFeedback',
     });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeRecheckRouter',
-        verdict: 'clean',
-        target: 'blockedEnd',
-    });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeRecheckRouter',
-        verdict: 'review_changes',
-        target: 'triage',
-    });
+    expectRoutes(template, sink, 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING', 'mergeRecheckRouter', [
+        ['clean', 'mergeGate'],
+        ['merged', 'cleanupWorktree'],
+        ['closed', 'recoveryGate'],
+        ['review_changes', 'triage'],
+        ['recheck', 'mergeReadiness'],
+    ]);
     expectBoundedRoute(template, sink, {
         code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
         nodeId: 'mergeRecheckRouter',
@@ -226,16 +317,10 @@ function checkMergeGateRecheckRouting(template, sink) {
         scope: 'ciLoop',
         value: 3,
     });
-    expectRoute(template, sink, {
-        code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
-        nodeId: 'mergeRecheckRouter',
-        verdict: 'recheck',
-        target: 'mergeReadiness',
-    });
     expectDefaultRoute(template, sink, {
         code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
         nodeId: 'mergeRecheckRouter',
-        target: 'blockedEnd',
+        target: 'recoveryGate',
     });
     expectConsume(template, sink, {
         code: 'DEFAULT_POLICY_MERGE_RECHECK_ROUTE_MISSING',
@@ -254,6 +339,22 @@ function checkMergeGateRecheckRouting(template, sink) {
         staleOk: true,
     });
 }
+function checkRecoveryGateRouting(template, sink) {
+    expectHumanGateOutcomes(template, sink, {
+        code: 'DEFAULT_POLICY_GATE_OUTCOMES_IMPLICIT',
+        nodeId: 'recoveryGate',
+        outcomes: ['recheck', 'cancel'],
+    });
+    expectRoutes(template, sink, 'DEFAULT_POLICY_GATE_OUTCOMES_IMPLICIT', 'recoveryGate', [
+        ['recheck', 'pollPr'],
+        ['cancel', 'cancelledEnd'],
+    ]);
+    expectDefaultRoute(template, sink, {
+        code: 'DEFAULT_POLICY_GATE_OUTCOMES_IMPLICIT',
+        nodeId: 'recoveryGate',
+        target: 'blockedEnd',
+    });
+}
 function checkReviewFeedbackLoop(template, sink) {
     expectRoute(template, sink, {
         code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
@@ -316,6 +417,16 @@ function checkReviewFeedbackLoop(template, sink) {
         verdict: 'question',
         target: 'questionGate',
     });
+    expectHumanGateOutcomes(template, sink, {
+        code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
+        nodeId: 'questionGate',
+        outcomes: ['fix', 'wontfix', 'cancel'],
+    });
+    expectRoutesWithDefault(template, sink, 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING', 'questionGate', [
+        ['fix', 'questionReviewRework'],
+        ['wontfix', 'respondThreads'],
+        ['cancel', 'cancelledEnd'],
+    ], 'recoveryGate');
     expectRoute(template, sink, {
         code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
         nodeId: 'triageRouter',
@@ -328,6 +439,30 @@ function checkReviewFeedbackLoop(template, sink) {
         verdict: 'wontfix',
         target: 'respondThreads',
     });
+    expectNodeNext(template, sink, {
+        code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
+        nodeId: 'questionReviewRework',
+        target: 'questionReviewIntegrator',
+    });
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
+        consumerId: 'questionReviewRework',
+        producerId: 'triage',
+        as: 'triage',
+    });
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
+        consumerId: 'questionReviewRework',
+        producerId: 'questionGate',
+        as: 'gateResolution',
+    });
+    expectScript(template, sink, {
+        code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
+        nodeId: 'questionReviewIntegrator',
+        scriptRef: 'script:integrator',
+        next: 'respondThreads',
+        resultSchema: 'schema:integration',
+    });
     expectNodeNext(template, sink, {
         code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
         nodeId: 'reviewRework',
@@ -353,13 +488,47 @@ function checkReviewFeedbackLoop(template, sink) {
         producerId: 'triage',
         as: 'triage',
     });
+    expectConsume(template, sink, {
+        code: 'DEFAULT_POLICY_REVIEW_CHANGES_ROUTE_MISSING',
+        consumerId: 'respondThreads',
+        producerId: 'questionGate',
+        as: 'gateResolution',
+        optional: true,
+        staleOk: true,
+    });
 }
 function checkLoopExhaustionEscalation(template, sink) {
+    expectRoutes(template, sink, 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING', 'planReviewRouter', [
+        ['approved', 'planGate'],
+        ['clean', 'planGate'],
+    ]);
+    expectBoundedRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: 'planReviewRouter',
+        verdict: 'blocker',
+        target: 'analyst',
+        scope: 'planReviewLoop',
+        value: 4,
+    });
+    expectBoundedRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: 'planReviewRouter',
+        verdict: 'changes_requested',
+        target: 'analyst',
+        scope: 'planReviewLoop',
+        value: 4,
+    });
     expectHumanGateOutcomes(template, sink, {
         code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
         nodeId: 'planGate',
         outcomes: ['approved', 'rework', 'cancel'],
     });
+    expectRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: 'planGate',
+        verdict: 'approved',
+        target: 'developer',
+    });
     expectRoute(template, sink, {
         code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
         nodeId: 'planGate',
@@ -372,6 +541,11 @@ function checkLoopExhaustionEscalation(template, sink) {
         verdict: 'cancel',
         target: 'cancelledEnd',
     });
+    expectDefaultRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: 'planGate',
+        target: 'blockedEnd',
+    });
     expectRouterDefaultGate(template, sink, {
         routerId: 'planReviewRouter',
         gateId: 'planStuckGate',
@@ -394,6 +568,26 @@ function checkLoopExhaustionEscalation(template, sink) {
         verdict: 'cancel',
         target: 'cancelledEnd',
     });
+    expectRoutes(template, sink, 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING', 'codeReviewRouter', [
+        ['approved', 'integrator'],
+        ['clean', 'integrator'],
+    ]);
+    expectBoundedRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: 'codeReviewRouter',
+        verdict: 'blocker',
+        target: 'reworkDeveloper',
+        scope: 'codeReviewLoop',
+        value: 3,
+    });
+    expectBoundedRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: 'codeReviewRouter',
+        verdict: 'changes_requested',
+        target: 'reworkDeveloper',
+        scope: 'codeReviewLoop',
+        value: 3,
+    });
     expectRouterDefaultGate(template, sink, {
         routerId: 'codeReviewRouter',
         gateId: 'codeStuckGate',
@@ -435,6 +629,168 @@ function checkLoopExhaustionEscalation(template, sink) {
         parent: null,
     });
 }
+function checkRecoverableCatches(template, sink) {
+    const recoverableNodes = PR_LIFECYCLE_NODES.filter((nodeId) => nodeId !== 'confirmMerge' && nodeId !== 'overrideConfirmMerge');
+    for (const nodeId of recoverableNodes) {
+        const node = effectNode(template, nodeId);
+        if (!node)
+            continue;
+        for (const entry of node.catch ?? []) {
+            if (isTerminalNode(template, entry.goto)) {
+                sink.error('DEFAULT_POLICY_RECOVERABLE_CATCH_TERMINAL', `node ${nodeId} catch for ${entry.onError} must not route to a terminal`, {
+                    nodeId,
+                    expected: `${entry.onError} -> non-terminal`,
+                    actual: `${entry.onError} -> ${entry.goto}`,
+                });
+            }
+        }
+    }
+}
+function checkCapExhaustionOffRamp(template, sink) {
+    const capRouters = [
+        'prRouter',
+        'mergeReadinessRouter',
+        'mergeRecheckRouter',
+        'overrideMergeRouter',
+        'triageRouter',
+        'recoveryRouter',
+        'planReviewRouter',
+        'codeReviewRouter',
+    ];
+    for (const nodeId of capRouters) {
+        const node = routingNode(template, nodeId);
+        if (!node)
+            continue;
+        const target = defaultBranchTarget(node);
+        const targetNode = target ? template.nodes[target] : undefined;
+        const isHumanGate = targetNode?.kind === 'humanGate';
+        const isClassifier = target === 'classifyRecovery';
+        if (!isHumanGate && !isClassifier) {
+            sink.error('DEFAULT_POLICY_CAP_EXHAUSTION_OFFRAMP_MISSING', `cap-router ${nodeId} default must route to a humanGate or classifyRecovery, not a terminal`, {
+                nodeId,
+                expected: 'default -> humanGate or classifyRecovery',
+                actual: target ? `default -> ${target} (${targetNode?.kind ?? 'missing'})` : 'missing default branch',
+            });
+        }
+    }
+}
+function checkConfirmMergeFailureRecoverable(template, sink) {
+    for (const nodeId of ['confirmMerge', 'overrideConfirmMerge']) {
+        const node = effectNode(template, nodeId);
+        if (!node)
+            continue;
+        for (const entry of node.catch ?? []) {
+            if (isTerminalNode(template, entry.goto)) {
+                sink.error('DEFAULT_POLICY_CONFIRM_MERGE_FAILURE_TERMINAL', `${nodeId} catch for ${entry.onError} must not route to a terminal`, {
+                    nodeId,
+                    expected: `${entry.onError} -> non-terminal`,
+                    actual: `${entry.onError} -> ${entry.goto}`,
+                });
+            }
+        }
+    }
+}
+function checkPostMergeCleanup(template, sink) {
+    for (const nodeId of ['confirmMerge', 'overrideConfirmMerge']) {
+        expectNodeNext(template, sink, {
+            code: 'DEFAULT_POLICY_POST_MERGE_CLEANUP_MISSING',
+            nodeId,
+            target: 'cleanupWorktree',
+        });
+    }
+    expectScript(template, sink, {
+        code: 'DEFAULT_POLICY_POST_MERGE_CLEANUP_MISSING',
+        nodeId: 'cleanupWorktree',
+        scriptRef: 'script:cleanupWorktree',
+        next: 'mergedEnd',
+        resultSchema: 'schema:integration',
+    });
+    for (const onError of ['revo.ScriptBlocked', 'revo.ScriptFailed']) {
+        expectCatch(template, sink, {
+            code: 'DEFAULT_POLICY_POST_MERGE_CLEANUP_MISSING',
+            nodeId: 'cleanupWorktree',
+            onError,
+            target: 'mergedEnd',
+        });
+    }
+}
+function checkGateOutcomesExplicit(template, sink) {
+    const expectedDefaults = {
+        mergeGate: 'blockedEnd',
+    };
+    for (const [nodeId, node] of Object.entries(template.nodes)) {
+        if (node.kind !== 'humanGate')
+            continue;
+        for (const outcome of node.outcomes) {
+            const branch = guardedBranchForVerdict(node, outcome);
+            if (!branch) {
+                sink.error('DEFAULT_POLICY_GATE_OUTCOMES_IMPLICIT', `gate ${nodeId} declares ${outcome} but has no guarded branch for it`, {
+                    nodeId,
+                    expected: `guarded branch for ${outcome}`,
+                    actual: 'missing guarded branch',
+                });
+            }
+        }
+        const defaultTarget = expectedDefaults[nodeId];
+        if (defaultTarget) {
+            expectDefaultRoute(template, sink, {
+                code: 'DEFAULT_POLICY_GATE_OUTCOMES_IMPLICIT',
+                nodeId,
+                target: defaultTarget,
+            });
+        }
+    }
+}
+function expectPollPrFeedbackHop(template, sink, hop) {
+    expectScript(template, sink, {
+        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
+        nodeId: hop.scriptId,
+        scriptRef: 'script:pollPr',
+        next: hop.routerId,
+        resultSchema: 'schema:prFeedback',
+        produces: 'prFeedback',
+    });
+    expectIncrementCounters(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: hop.scriptId,
+        scopes: [POLL_LOOP_SCOPE],
+    });
+    expectRoute(template, sink, {
+        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
+        nodeId: hop.routerId,
+        verdict: 'clean',
+        target: hop.cleanTarget,
+    });
+    expectRoute(template, sink, {
+        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
+        nodeId: hop.routerId,
+        verdict: 'merged',
+        target: 'cleanupWorktree',
+    });
+    expectRoute(template, sink, {
+        code: 'DEFAULT_POLICY_PR_FRESHNESS_WIRING_MISSING',
+        nodeId: hop.routerId,
+        verdict: 'closed',
+        target: 'recoveryGate',
+    });
+    expectBoundedRoute(template, sink, {
+        code: 'DEFAULT_POLICY_LOOP_EXHAUSTION_ESCALATION_MISSING',
+        nodeId: hop.routerId,
+        verdict: 'recheck',
+        target: hop.recheckTarget,
+        scope: POLL_LOOP_SCOPE,
+        value: POLL_LOOP_CAP,
+    });
+}
+function expectRoutes(template, sink, code, nodeId, routes) {
+    for (const [verdict, target] of routes) {
+        expectRoute(template, sink, { code, nodeId, verdict, target });
+    }
+}
+function expectRoutesWithDefault(template, sink, code, nodeId, routes, defaultTarget) {
+    expectRoutes(template, sink, code, nodeId, routes);
+    expectDefaultRoute(template, sink, { code, nodeId, target: defaultTarget });
+}
 function expectChangeProducer(template, sink, nodeId) {
     const node = effectNode(template, nodeId);
     if (node?.resultSchema === 'schema:change' && node.produces?.name === 'change')
@@ -475,6 +831,41 @@ function expectScript(template, sink, rule) {
         actual: describeNode(node),
     });
 }
+function expectCatch(template, sink, rule) {
+    const node = effectNode(template, rule.nodeId);
+    const actual = node?.catch?.find((entry) => entry.onError === rule.onError)?.goto;
+    if (actual === rule.target)
+        return;
+    let actualDescription;
+    if (actual) {
+        actualDescription = `${rule.onError} -> ${actual}`;
+    }
+    else if (node) {
+        actualDescription = `missing catch for ${rule.onError}`;
+    }
+    else {
+        actualDescription = describeNode(template.nodes[rule.nodeId]);
+    }
+    sink.error(rule.code, `node ${rule.nodeId} must route ${rule.onError} to ${rule.target}`, {
+        nodeId: rule.nodeId,
+        path: 'catch',
+        expected: `${rule.onError} -> ${rule.target}`,
+        actual: actualDescription,
+    });
+}
+function expectIncrementCounters(template, sink, rule) {
+    const node = effectNode(template, rule.nodeId);
+    const actual = node?.incrementCounters ?? [];
+    if (node && actual.length === rule.scopes.length && actual.every((scope, index) => scope === rule.scopes[index])) {
+        return;
+    }
+    sink.error(rule.code, `node ${rule.nodeId} must increment ${rule.scopes.join(',')}`, {
+        nodeId: rule.nodeId,
+        path: 'incrementCounters',
+        expected: `incrementCounters=${rule.scopes.join(',')}`,
+        actual: node ? `incrementCounters=${actual.join(',')}` : describeNode(template.nodes[rule.nodeId]),
+    });
+}
 function expectGateOutcomes(template, sink, rule) {
     const node = template.nodes[rule.nodeId];
     if (node?.kind === 'humanGate' &&
@@ -482,7 +873,7 @@ function expectGateOutcomes(template, sink, rule) {
         node.outcomes.every((outcome, index) => outcome === rule.outcomes[index])) {
         return;
     }
-    sink.error(rule.code, `gate ${rule.nodeId} must map approve to ${rule.outcomes[0]} and reject to ${rule.outcomes.at(-1)}`, {
+    sink.error(rule.code, `gate ${rule.nodeId} must declare explicit outcomes in order: ${rule.outcomes.join(',')}`, {
         nodeId: rule.nodeId,
         path: 'outcomes',
         expected: rule.outcomes.join(','),
@@ -621,6 +1012,9 @@ function expectRouterDefaultGate(template, sink, rule) {
         actual: gate ? `kind=${gate.kind} ${approveVerdict}=${approveTarget ?? 'missing'} default=${gateDefault ?? 'missing'}` : 'missing gate',
     });
 }
+function isTerminalNode(template, nodeId) {
+    return template.nodes[nodeId]?.kind === 'terminal';
+}
 function effectNode(template, nodeId) {
     const node = template.nodes[nodeId];
     if (node?.kind === 'agent' || node?.kind === 'script')