fix(golden-path): current-focus fallback rows round-trip through parseGoldenPath (#15092) (#15093)

The never-empty focus-as-route floor rendered `N. **issue-N**:` rows without
the indented `- *desc*` continuation line that AgentOrchestrator.parseGoldenPath()
requires, so the autonomous orchestrator extracted ZERO directives in the
no-survivor-contradiction state — the floor was silently unroutable. A false-green
test (asserted the render substring + claimed 'parseGoldenPath-compatible' but
never ran the parser) masked it.

- render: emit the continuation line per routed focus row (mirrors the canonical row shape)
- test: real render->parseGoldenPath round-trip in AgentOrchestrator.spec (red-before-green
  verified) + honest render-shape assertion replacing the false-green substring check
- test: lock the declared-intent fallback as advisory/non-executed (zero directives, by design)

Co-authored-by: tobiu <tobiasuhlig78@gmail.com>
Co-authored-by: Ada <ada@neo-opus-ada.ai>

Author: 3 people

ai/services/graph/computedGoldenPathRouting.mjs

@@ -240,7 +240,13 @@ export function renderComputedGoldenPathContradictionSection({
             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})`)
+            // Emit the indented `- *…*` continuation line the AgentOrchestrator route parser requires:
+            // a bare `N. **issue-N**:` row without it renders for humans but extracts ZERO directives,
+            // leaving the never-empty floor silently unroutable. Mirrors the canonical route row shape.
+            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

test/playwright/unit/ai/AgentOrchestrator.spec.mjs

@@ -5,6 +5,9 @@ import Neo               from '../../../../src/Neo.mjs';
 import * as core         from '../../../../src/core/_export.mjs';
 import AgentOrchestrator from '../../../../ai/agent/AgentOrchestrator.mjs';
 
+import {findComputedFocusContradiction, renderComputedGoldenPathContradictionSection} from '../../../../ai/services/graph/computedGoldenPathRouting.mjs';
+import {rankByDeclaredIntent, renderDeclaredIntentFallback}                           from '../../../../ai/services/graph/goldenPathPickupBridge.mjs';
+
 const createTestHandoff = (filename, content) => {
           const filePath = path.resolve(process.cwd(), filename);
           fs.writeFileSync(filePath, content, 'utf-8');
@@ -127,6 +130,67 @@ Based on priorities, the following tasks are mathematically recommended:
         }
     });
 
+    test('the current-focus contradiction fallback render round-trips through parseGoldenPath (the never-empty floor actually routes)', async () => {
+        // The producer render (routing module) and the consumer parser (this class) form a byte-format
+        // contract. A render-substring assertion is NOT proof of routability — only feeding the real
+        // render through the real parser is. This guards the regression where the focus-as-route rows
+        // lacked the `- *…*` continuation line and silently extracted ZERO directives.
+        const contradiction = findComputedFocusContradiction({
+            currentFocusCandidates: [{number: 14988, reasons: ['incident'], labels: ['bug'], title: 'Fleet auth restart supervised'}],
+            topNodes              : [{
+                node : {id: 'issue-200', type: 'ISSUE', properties: {labels: ['documentation'], title: 'docs: release notes'}},
+                score: 1, semantic: 1, structural: 0
+            }]
+        });
+
+        test.expect(contradiction).not.toBeNull();
+
+        const section = renderComputedGoldenPathContradictionSection({contradiction, stats: {}, renderLimit: 5}),
+              content = `# Autonomous Handoff\n${section}`,
+              handoff = createTestHandoff('.neo-test-handoff-contradiction.md', content);
+
+        try {
+            const orchestrator = Neo.create(AgentOrchestrator, {handoffPath: handoff}),
+                  directives   = orchestrator.parseGoldenPath();
+
+            test.expect(directives).not.toBeNull();
+            test.expect(directives.length).toBe(1);
+            test.expect(directives[0].issueId).toBe('14988');
+            // the blocked content candidate is diagnostic-only, never a routed directive
+            test.expect(directives.map(directive => directive.issueId)).not.toContain('200');
+        } finally {
+            if (fs.existsSync(handoff)) {
+                fs.unlinkSync(handoff);
+            }
+        }
+    });
+
+    test('the declared-intent frontier-empty fallback render yields ZERO parseGoldenPath directives (advisory, not executed route — by design)', async () => {
+        // The declared-intent fallback is a provisional cold-cache rescue, explicitly "not the semantic
+        // ranking" and additive-never-gating per the direction contract. It renders as a separate `### …`
+        // section with `#N` rows so the executed-route parser deliberately does NOT consume it. Elevating
+        // it into the executed route would make declared intent gate execution — this locks the boundary.
+        const section = renderDeclaredIntentFallback(
+                  rankByDeclaredIntent([{id: '14620', inOpenEpic: true, epicActivity: 3, blocked: false, filedAt: '2026-07-10'}]),
+                  5,
+                  {code: 'COLD_START', phrase: 'cold cache'}
+              ),
+              content = `# Autonomous Handoff\n${section}`,
+              handoff = createTestHandoff('.neo-test-handoff-declared-intent.md', content);
+
+        try {
+            const orchestrator = Neo.create(AgentOrchestrator, {handoffPath: handoff}),
+                  directives   = orchestrator.parseGoldenPath();
+
+            // section-shaped but non-executable: no `**issue-N**:` rows → an empty directive list, never a route
+            test.expect(directives).toEqual([]);
+        } finally {
+            if (fs.existsSync(handoff)) {
+                fs.unlinkSync(handoff);
+            }
+        }
+    });
+
     test('execute records completed outcomes for exhausted Golden Path directives', async () => {
         const content = `
 # Autonomous Handoff

test/playwright/unit/ai/services/graph/computedGoldenPathRouting.spec.mjs

@@ -103,9 +103,10 @@ test.describe('computedGoldenPathRouting — the contradiction guard (routing-de
 
         const section = renderComputedGoldenPathContradictionSection({contradiction, stats: {selectedTopNodes: 0}});
 
-        // never empty: the live Current Focus item IS the numbered route (parseGoldenPath-compatible)
-        expect(section).toContain('1. **issue-100**');
-        expect(section).toContain('incident: cockpit auth relaunch');
+        // never empty: the live Current Focus item IS the numbered route. Parser-SHAPED at the render
+        // level — the `**issue-N**:` row is followed by the `- *…*` continuation line the route parser
+        // requires (the full render→parseGoldenPath round-trip is asserted in AgentOrchestrator.spec).
+        expect(section).toMatch(/1\. \*\*issue-100\*\*:[^\n]*\n\s+-\s\*incident: cockpit auth relaunch\*/);
         // the blocked content is filtered-only — it appears in the diagnostic, never as a numbered route
         expect(section).toMatch(/Contradictory computed candidates filtered:.*issue-200/);
         expect(section).not.toMatch(/^\d+\.\s+\*\*issue-20[01]\*\*/m);