feat(graph): computed GP never-empty actionable focus-as-route + release-window config leaf (#15066) (#15058)

* feat(graph): computed GP no-survivor focus-as-route fallback — never empty (#14609)

Behavior 1 of the GP-guard follow-up split (parent defect merged via PR #14596):
when the contradiction guard blocks EVERY computed candidate (the no-survivor
state — the operator-verified zero-route class), the section now surfaces the
live Current Release / Incident Focus items as the numbered '**issue-N**:'
recommendation instead of rendering zero routes. parseGoldenPath then routes the
incident/release work rather than leaving the agent with no route.

- renderComputedGoldenPathContradictionSection (reached only when routedTopNodes
  is empty) renders the focus candidates as numbered routes; the blocked content
  stays in the diagnostic filtered line, never routed. The 'does not boost focus
  into routing' clause gains its documented no-survivor exception — focus becomes
  the route ONLY when nothing else survives, never alongside a surviving candidate.
- Title-less focus candidates fall back to their reasons label.

Tests: 2 new routing unit cases + the GoldenPathSynthesizer integration assertion
updated to the never-empty behavior. 9/9 routing + 47/47 synthesizer specs green.

Remaining behaviors (separate commits): guard-filter ledger recording + the
release-window config leaf.

* feat(graph): release-window config leaf — GP focus tracks the current release, not a shipped one (#14609)

Behavior 3 of the GP-guard follow-up split: the 'current release focus' version was hardcoded
as v13.1 in issueFocusSections.mjs, so a SHIPPED release kept scoring as current focus (the
operator-verified release-gate-blind class). Now sourced from a declarative AiConfig leaf
(ADR-0019 sanctioned form), read at the use site.

- ai/config.template.mjs: currentReleaseVersion leaf (default 'v13.2', NEO_CURRENT_RELEASE) —
  advanced by publish.mjs at release (follow-on half of this behavior).
- issueFocusSections.mjs: reads aiConfig.currentReleaseVersion at the use site (never a stale
  module-load capture), builds the title matcher regex-escaped, emits the release as the focus
  reason. No release-version literal remains (AC falsifier: grep 'v13.1|V13_1_PATTERN' -> zero).
- Tests made release-agnostic: fixtures read aiConfig.currentReleaseVersion so they never re-stale.

47/47 GoldenPathSynthesizer + 9/9 routing specs green. config.mjs is gitignored; only the
template leaf is committed.

Remaining behavior: guard-filter ledger recording (behavior 2).

* fix(graph): no-survivor fallback routes only ACTIONABLE focus, epic→diagnostic (#14609)

Cycle-2 RA-2 (@neo-gpt review on #15058). The behavior-1 never-empty fallback
rendered EVERY live Current Focus candidate as a numbered machine route — including
epic umbrellas and not-code-ready items, which an agent would then try to route at.
Now the fallback filters focus candidates through the SAME isActionableComputedRecom-
mendation authority the computed surface uses (not a divergent label list): only
actionable leaves render as numbered routes, bounded to the caller-supplied Golden
Path render limit (aiConfig.goldenPathTopNodeRenderLimit, read at the synthesizer
use site). Epic-only / no-actionable focus renders diagnostically (named, never a
numbered route) rather than lying that an umbrella is immediate work.

3 new exact cases: epic+actionable-leaf (leaf routes, epic doesn't), epic-only (zero
routes, diagnostic), noisy-set (bounded to render limit). 59 passed / 0 failed.

---------

Co-authored-by: tobiu <tobiasuhlig78@gmail.com>

Author: neo-opus-ada

ai/config.template.mjs

@@ -39,6 +39,15 @@ class Config extends ConfigProvider {
         data: {
             neoRootDir : leaf(neoRootDir),
             projectRoot: leaf(projectRoot),
+            /**
+             * The current in-flight release version whose milestone / epic work counts as "current
+             * release focus" for the Golden Path emitter. Set at cut-prep, advanced by
+             * `buildScripts/release/publish.mjs` at release — so a shipped release never lingers as
+             * current focus (the release-gate-blind class). Consumers read it at the use site; never
+             * a hardcoded release literal.
+             * @type {string}
+             */
+            currentReleaseVersion: leaf('v13.2', 'NEO_CURRENT_RELEASE', 'string'),
             /**
              * Universal JSONL backup/export directory for Agent OS databases.
              * @type {string}

ai/services/graph/GoldenPathSynthesizer.mjs

@@ -1110,6 +1110,7 @@ DO NOT output markdown, \`\`\`json blocks, or any other explanations. Provide pu
             markdownAppend = this.constructor.renderComputedGoldenPathContradictionSection({
                 capturedAt   : handoffTimestamp,
                 contradiction: focusContradiction,
+                renderLimit  : aiConfig.goldenPathTopNodeRenderLimit,
                 stats        : scoringStats
             });
             logger.info('[GoldenPathSynthesizer] Computed route contradicted Current Focus; rendered diagnostic instead of routing content work.');

ai/services/graph/computedGoldenPathRouting.mjs

@@ -161,39 +161,84 @@ export function findComputedFocusContradiction({
 }
 
 /**
- * @summary Renders the computed-route contradiction diagnostic.
+ * @summary Renders the no-survivor contradiction fallback — the never-empty focus-as-route surface.
  *
- * The section intentionally contains no numbered `**issue-N**:` entries, so
- * `AgentOrchestrator.parseGoldenPath()` will not treat filtered content work
- * as an immediate route.
+ * Reached only in the no-survivor state: EVERY computed content/narrative candidate contradicted live
+ * Current Release / Incident Focus, so zero computed candidates survived the guard (the caller routes
+ * surviving computed candidates directly and never calls this while any survive). Rather than emit zero
+ * routes, the section surfaces the live Current Focus items as the numbered `**issue-N**:` recommendation
+ * so `AgentOrchestrator.parseGoldenPath()` routes the incident/release work instead of leaving the agent
+ * with no route. The BLOCKED content is never routed — it appears only in the diagnostic
+ * filtered-candidates line. This is the explicit no-survivor exception to the "does not boost focus
+ * nodes into routing" clause: focus becomes the route only when nothing else survives, never alongside
+ * a surviving computed candidate.
  *
  * @param {Object} options
- * @param {Object} options.contradiction Result from `findComputedFocusContradiction`.
+ * @param {Object} options.contradiction Result from `findComputedFocusContradiction` (carries the focus
+ *   candidates surfaced as the route + the blocked computed candidates).
  * @param {Object} [options.stats={}] Candidate-count diagnostics for the current pass.
  * @param {Date|String} [options.capturedAt=new Date()] Current pass capture timestamp.
  * @returns {String} Markdown section.
  */
 export function renderComputedGoldenPathContradictionSection({
     contradiction,
-    stats      = {},
-    capturedAt = new Date()
+    stats       = {},
+    capturedAt  = new Date(),
+    renderLimit
 } = {}) {
-    const count     = value => Number.isFinite(Number(value)) ? Number(value) : 0;
-    const focusRefs = (contradiction?.focusCandidates || [])
-        .slice(0, 3)
-        .map(candidate => `#${candidate.number}`)
-        .join(', ') || 'none';
+    const count       = value => Number.isFinite(Number(value)) ? Number(value) : 0;
+    const focusItems  = contradiction?.focusCandidates || [];
+    const focusRefs   = focusItems.slice(0, 3).map(candidate => `#${candidate.number}`).join(', ') || 'none';
     const blockedRefs = (contradiction?.blockedNodes || [])
         .map(item => item.node.id)
         .join(', ') || 'none';
 
-    return [
+    // Route ONLY focus candidates that pass the SAME actionability authority the computed surface uses —
+    // an epic umbrella / not-code-ready item is visibility, never an immediate machine route. Reusing
+    // isActionableComputedRecommendation (not a divergent label list) keeps a single authority.
+    const routableFocus = focusItems.filter(candidate => isActionableComputedRecommendation({
+        id        : `issue-${candidate.number}`,
+        type      : 'ISSUE',
+        properties: {labels: candidate.labels, title: candidate.title}
+    }));
+    // Bound to the caller's Golden Path render limit — no hidden default: unbounded only when the caller
+    // supplies none (the synthesizer passes aiConfig.goldenPathTopNodeRenderLimit).
+    const routedFocus = Number.isFinite(renderLimit) ? routableFocus.slice(0, renderLimit) : routableFocus;
+
+    const lines = [
         '',
         '## Computed Golden Path (Strategic Recommendation)',
         '',
         `Captured at: ${formatGoldenPathTimestamp(capturedAt)}`,
-        '',
-        'Computed routing paused because the surviving content/narrative recommendation contradicts live Current Release / Incident Focus.',
+        ''
+    ];
+
+    if (routedFocus.length > 0) {
+        // No-survivor focus-as-route fallback: render the live ACTIONABLE Current Focus items as the
+        // numbered route so the pass is never empty (the zero-route class). Blocked computed content is
+        // NOT routed — it stays in the diagnostic filtered line below.
+        lines.push(
+            'Every surviving computed content/narrative candidate contradicted live Current Release / Incident Focus, so no computed candidate survived the guard. The live actionable focus work is surfaced as the immediate route instead of an empty pass:',
+            ''
+        );
+
+        routedFocus.forEach((candidate, index) => {
+            const label = candidate.title || candidate.name ||
+                (Array.isArray(candidate.reasons) ? candidate.reasons.join(', ') : 'Current Release / Incident Focus');
+
+            lines.push(`${index + 1}. **issue-${candidate.number}**: Current Release / Incident Focus (${label})`)
+        });
+    } else {
+        // Epic-only / no-actionable-focus: the honest state is NO immediate route — an epic umbrella or
+        // not-code-ready item is not immediate machine work. Render the focus diagnostically (named, never
+        // as a numbered route) rather than lying that an umbrella is the immediate route.
+        lines.push(
+            'No computed candidate survived the contradiction guard, and the live Current Release / Incident Focus is visibility-only this pass (epic umbrella / not-code-ready) — there is no actionable immediate computed route. The focus context is surfaced diagnostically below, NOT as a machine route.',
+            ''
+        );
+    }
+
+    lines.push(
         '',
         `- Active incident/release focus candidates: ${focusRefs}`,
         `- Contradictory computed candidates filtered: ${blockedRefs}`,
@@ -203,9 +248,11 @@ export function renderComputedGoldenPathContradictionSection({
         `- Selected routed nodes: ${count(stats.selectedTopNodes)}`,
         `- Stale frontier GUIDES pruned: ${count(stats.prunedGuideEdges)}`,
         '',
-        'No numbered immediate recommendation is rendered for this pass; use the Current Release / Incident Focus section for visibility and rerun after the incident/release focus clears or the computed route aligns.',
+        '> **Routing Guard:** any numbered items above are the live ACTIONABLE Current Release / Incident Focus, surfaced as the route ONLY because zero computed candidate survived the contradiction filter; epic / visibility-only focus is never rendered as a route. Focus is never boosted into routing while a computed candidate survives — that state routes the computed candidate directly.',
         ''
-    ].join('\n')
+    );
+
+    return lines.join('\n')
 }
 
 /**