agents-relay 2.0.16 → 2.0.18

package/dist/cli-support.js

@@ -4,6 +4,7 @@ import { githubAuthContext } from './github-auth.js';
 import { NatsEventBus, eventFor } from './events.js';
 import { parseJobSchedule } from './scheduler.js';
 import { parseJobTagJson } from './task-tag.js';
+import { resolveEventsBusRuntime } from './events-bus-runtime.js';
 export const SERVICE_DEFAULTS = { port: 8787, watchdogMs: 300000, webhookWatchdogMs: 300000, dashboardRefreshMs: 300000, projectionFlushMs: 1000 };
 export class ServiceEventBus {
     upstream;
@@ -101,19 +102,21 @@ export async function relayTaskCommand(args, body) {
 export async function resolveEventBus(args, probe) {
     const explicit = hasArg(args, '--events');
     const requested = arg(args, '--events');
-    const natsUrl = arg(args, '--nats-url', process.env.NEO_NATS_URL || 'nats://127.0.0.1:4222');
+    const runtime = resolveEventsBusRuntime();
+    const natsUrl = arg(args, '--nats-url', runtime.natsUrl);
     if (!explicit && hasArg(args, '--file'))
         return { bus: undefined, transport: 'none', source: 'local', natsUrl };
     if (explicit && requested !== 'nats')
         return { bus: undefined, transport: 'none', source: 'explicit', natsUrl };
-    const bus = new NatsEventBus(natsUrl, arg(args, '--subject-prefix', 'neo.events.job'));
+    const subjectPrefix = arg(args, '--subject-prefix', runtime.subjectPrefix);
+    const bus = new NatsEventBus(natsUrl, subjectPrefix);
     if (explicit)
         return { bus, transport: 'nats', source: 'explicit', natsUrl };
     const reachable = probe ? await probe(bus) : await bus.ping().then(() => true, () => false);
     await bus.close().catch(() => undefined);
     if (!reachable)
         return { bus: undefined, transport: 'none', source: 'unavailable', natsUrl };
-    return { bus: new NatsEventBus(natsUrl, arg(args, '--subject-prefix', 'neo.events.job')), transport: 'nats', source: 'auto', natsUrl };
+    return { bus: new NatsEventBus(natsUrl, subjectPrefix), transport: 'nats', source: 'auto', natsUrl };
 }
 export function eventBusResolutionMessage(resolution) {
     if (resolution.transport === 'nats')

package/dist/dashboard-html.js

@@ -176,7 +176,9 @@ export const dashboardHtml = `<!doctype html>
       .tagline { display:none; }
     }
     @media (prefers-reduced-motion:reduce) { .skeleton { animation:none; } .usage-fill { transition:none; } }
-  </style>
+
+  .router-rules-workspace{display:grid;grid-template-columns:minmax(0,1fr) minmax(0,1fr);gap:16px;align-items:start}.router-rules-pane{min-width:0}.audit-log{display:flex;flex-direction:column;gap:8px;max-height:560px;overflow:auto}.audit-entry{border:1px solid var(--border);border-radius:10px;padding:10px;background:var(--surface)}.audit-entry-head{display:flex;justify-content:space-between;gap:8px;align-items:center}.audit-entry pre{white-space:pre-wrap;word-break:break-word;margin:8px 0 0;font-size:11px}.router-test-results{margin-top:12px;display:flex;flex-direction:column;gap:6px}.router-test-row{display:grid;grid-template-columns:minmax(0,1fr) auto auto;gap:8px;padding:7px 0;border-bottom:1px solid var(--border)}@media(max-width:900px){.router-rules-workspace{grid-template-columns:1fr}}
+</style>
 </head>
 <body>
 <header>
@@ -233,18 +235,7 @@ export const dashboardHtml = `<!doctype html>
       </div>
     </div>
   </section>
-  <section id="rules-view" role="tabpanel" aria-labelledby="rules-tab" hidden>
-    <div class="panel">
-      <div class="panel-head"><h2>Router Rules</h2><span id="rules-meta" class="subtle"></span></div>
-      <div class="panel-body">
-        <div class="rules-editor">
-          <p class="rules-help">Free-text soft policy loaded by the Execution Router for every worker+model routing decision. Impossible routes remain excluded by code; Codex remains the deterministic fallback if decision fails.</p>
-          <textarea id="rules-text" class="rules-textarea" spellcheck="true" aria-label="Execution router rules" placeholder="Example: Prefer ZAI glm-5.3-flash high while quota is available. Use ChatGPT for research when appropriate. Codex is fallback only."></textarea>
-          <div class="rules-footer"><span id="rules-status" class="subtle" aria-live="polite"></span><button id="rules-save" class="rules-save" type="button">Save rules</button></div>
-        </div>
-      </div>
-    </div>
-  </section>
+  <section id="rules-view" role="tabpanel" aria-labelledby="rules-tab" hidden><div class="panel"><div class="panel-head"><h2>Router Rules</h2><span id="rules-meta" class="subtle"></span></div><div class="panel-body"><div class="router-rules-workspace"><div class="router-rules-pane rules-editor"><h3>Rules Editor</h3><p class="rules-help">Free-text soft policy loaded by the Execution Router for every worker+model routing decision. Impossible routes remain excluded by code; Codex remains the deterministic fallback if decision fails.</p><textarea id="rules-text" class="rules-textarea" spellcheck="true" aria-label="Execution router rules" placeholder="Example: Prefer ZAI glm-5.3-flash high while quota is available. Use ChatGPT for research when appropriate. Codex is fallback only."></textarea><div class="rules-footer"><span id="rules-status" class="subtle" aria-live="polite"></span><div><button id="rules-test" class="rules-save" type="button">Test Router</button> <button id="rules-save" class="rules-save" type="button">Save rules</button></div></div><div id="router-test-results" class="router-test-results" aria-live="polite"></div></div><div class="router-rules-pane"><div class="panel-head"><h3>Audit Log</h3><button id="audit-refresh" type="button">Refresh</button></div><div id="audit-log" class="audit-log" aria-live="polite"><p class="empty">Loading latest routing decisions…</p></div></div></div></div></div></section>
   <section id="shortcuts-view" role="tabpanel" aria-labelledby="shortcuts-tab" hidden>
     <div class="panel">
       <div class="panel-head"><h2>ChatGPT Shortcuts</h2><span class="subtle">One per line · %1 = current repo/pr</span></div>
@@ -315,7 +306,7 @@ const graphSource=document.querySelector('#graph-source');
 const rulesText=document.querySelector('#rules-text');
 const rulesMeta=document.querySelector('#rules-meta');
 const rulesStatus=document.querySelector('#rules-status');
-const rulesSave=document.querySelector('#rules-save');
+const rulesSave=document.querySelector('#rules-save');const rulesTest=document.querySelector('#rules-test');const routerTestResults=document.querySelector('#router-test-results');const auditLog=document.querySelector('#audit-log');const auditRefresh=document.querySelector('#audit-refresh');
 const shortcutsText=document.querySelector('#shortcuts-text');
 const shortcutsStatus=document.querySelector('#shortcuts-status');
 const shortcutsSave=document.querySelector('#shortcuts-save');
@@ -456,7 +447,11 @@ function selectedWorkflowGraph(){return workflowGraphs.find(graph=>graph.id===se
 function renderGraphList(){graphList.replaceChildren();if(!workflowGraphs.length){graphList.append(element('p','empty',text('No workflow graphs found.')));return;}for(const graph of workflowGraphs){const button=document.createElement('button');button.type='button';button.className='graph-button';button.setAttribute('aria-current',String(graph.id===selectedGraphId));button.append(element('strong','',text(graph.name)),element('span','',text(graph.path)));button.addEventListener('click',()=>{selectedGraphId=graph.id;sessionStorage.setItem('agents-relay:selected-graph',selectedGraphId);renderGraphList();void renderSelectedGraph();});graphList.append(button);}}
 async function renderSelectedGraph(){const graph=selectedWorkflowGraph();if(!graph){graphTitle.textContent='Select a graph';graphPath.textContent='';graphSource.textContent='';graphCanvas.replaceChildren(element('p','empty',text('No workflow graphs found.')));return;}selectedGraphId=graph.id;sessionStorage.setItem('agents-relay:selected-graph',selectedGraphId);graphTitle.textContent=graph.name;graphPath.textContent=graph.path;graphSource.textContent=graph.source;graphCanvas.replaceChildren(element('p','subtle',text('Rendering…')));try{if(!window.mermaid)throw new Error('Mermaid renderer unavailable');if(!window.__relayMermaidReady){window.mermaid.initialize({startOnLoad:false,securityLevel:'strict'});window.__relayMermaidReady=true;}const rendered=await window.mermaid.render('relay-graph-'+graph.id.replace(/[^A-Za-z0-9_-]/g,'-'),graph.source);const parsed=new DOMParser().parseFromString(rendered.svg,'image/svg+xml');const svg=parsed.documentElement;if(svg.nodeName.toLowerCase()!=='svg')throw new Error('Mermaid did not return SVG');graphCanvas.replaceChildren(document.importNode(svg,true));}catch(error){graphCanvas.replaceChildren(element('p','error-state',text('Visual preview unavailable: '+error.message)));}}
 async function drawGraphs(){try{const graphs=await loadJSON('/api/graphs');workflowGraphs=Array.isArray(graphs)?graphs:[];if(!workflowGraphs.some(graph=>graph.id===selectedGraphId))selectedGraphId=workflowGraphs[0]?.id||'';graphsMeta.textContent=workflowGraphs.length+' graph'+(workflowGraphs.length===1?'':'s')+' · workflow/*.mmd';renderGraphList();await renderSelectedGraph();}catch(error){graphsMeta.textContent='Unavailable';workflowGraphs=[];renderGraphList();graphCanvas.replaceChildren(element('p','error-state',text('Graphs unavailable: '+error.message)));}}
-async function drawRules(){rulesStatus.textContent='';try{const rules=await loadJSON('/api/execution-router-rules');rulesText.value=typeof rules.text==='string'?rules.text:'';rulesMeta.textContent=rules.hash&&rules.hash!=='none'?'Loaded · '+rules.hash.slice(0,12):'No custom rules saved';}catch(error){rulesMeta.textContent='Unavailable';rulesStatus.textContent='Could not load rules: '+error.message;}}
+function routeWorker(record){const id=record?.selected?.worker?.id||record?.worker?.id||'';return String(id).startsWith('chatgpt')?'ChatGPT':String(id).startsWith('codex')?'Codex':value(id);}
+function renderAudit(records){auditLog.replaceChildren();if(!Array.isArray(records)||!records.length){auditLog.append(element('p','empty',text('No schema v5 routing decisions yet.')));return;}for(const record of records){const card=element('article','audit-entry');const head=element('div','audit-entry-head');head.append(element('strong','',text(routeWorker(record)+' · '+value(record?.selected?.model?.model))),element('span','subtle',text(new Date(record.timestamp).toLocaleString())));card.append(head);const correlation=record.correlation||{};card.append(element('div','subtle',text([correlation.job_id,correlation.task_id].filter(Boolean).join(' / ')||'uncorrelated')));const probabilities=record.decision_evidence?.probabilities||{};const gates=(record.gate_results||[]).filter(item=>!item.eligible).map(item=>item.candidate_id+': '+item.rejection_reasons.join(', '));const nl=String.fromCharCode(10);const details=document.createElement('pre');details.textContent='fallback: '+String(Boolean(record.decision_evidence?.fallback))+(Object.keys(probabilities).length?nl+'probabilities: '+JSON.stringify(probabilities,null,2):'')+(gates.length?nl+'rejected: '+gates.join(nl):'');card.append(details);auditLog.append(card);}}
+async function drawAudit(){auditRefresh.disabled=true;try{renderAudit(await loadJSON('/api/decision-audit'));}catch(error){auditLog.replaceChildren(element('p','error-state',text('Audit unavailable: '+error.message)));}finally{auditRefresh.disabled=false;}}
+async function drawRules(){rulesStatus.textContent='';try{const rules=await loadJSON('/api/execution-router-rules');rulesText.value=typeof rules.text==='string'?rules.text:'';rulesMeta.textContent=rules.hash&&rules.hash!=='none'?'Loaded · '+rules.hash.slice(0,12):'No custom rules saved';}catch(error){rulesMeta.textContent='Unavailable';rulesStatus.textContent='Could not load rules: '+error.message;}void drawAudit();}
+async function testRouter(){rulesTest.disabled=true;routerTestResults.replaceChildren(element('p','subtle',text('Running 10 Laya evals…')));try{const response=await fetch('/api/router-evals',{method:'POST'});if(!response.ok)throw new Error(response.status+' '+await response.text());const report=await response.json();routerTestResults.replaceChildren(element('strong','',text(report.passed+' / '+report.total+' passed')));for(const item of report.results||[]){const row=element('div','router-test-row');row.append(element('span','',text(item.id)),element('span',item.pass?'ok-text':'error-text',text(item.selectedWorker+' → expected '+item.expectedWorker)),element('span','subtle',text(item.pass?'PASS':'FAIL')));routerTestResults.append(row);}}catch(error){routerTestResults.replaceChildren(element('p','error-state',text('Router test failed: '+error.message)));}finally{rulesTest.disabled=false;}}
 async function saveRules(){rulesSave.disabled=true;rulesStatus.textContent='Saving…';try{const response=await fetch('/api/execution-router-rules',{method:'PUT',headers:{'content-type':'text/plain; charset=utf-8'},body:rulesText.value});if(!response.ok)throw new Error(response.status+' '+await response.text());const rules=await response.json();rulesMeta.textContent='Saved · '+rules.hash.slice(0,12);rulesStatus.textContent='Saved. New routing decisions will load these rules.';}catch(error){rulesStatus.textContent='Save failed: '+error.message;}finally{rulesSave.disabled=false;}}
 async function drawShortcuts(){shortcutsStatus.textContent='';shortcutsText.value=chatShortcutText();}
 function saveShortcuts(){const value=shortcutsText.value.trim();if(value)localStorage.setItem(CHAT_SHORTCUTS_KEY,value);else localStorage.removeItem(CHAT_SHORTCUTS_KEY);shortcutsText.value=chatShortcutText();shortcutsStatus.textContent='Saved.';}
@@ -478,6 +473,8 @@ graphsTab.addEventListener('click',()=>{location.hash='#/graphs';showView('graph
 rulesTab.addEventListener('click',()=>{location.hash='#/execution-router-rules';showView('rules');});
 shortcutsTab.addEventListener('click',()=>{location.hash='#/shortcuts';showView('shortcuts');});
 rulesSave.addEventListener('click',()=>void saveRules());
+rulesTest.addEventListener('click',()=>void testRouter());
+auditRefresh.addEventListener('click',()=>void drawAudit());
 shortcutsSave.addEventListener('click',saveShortcuts);
 window.addEventListener('keydown',event=>{if(event.key==='Tab'&&event.altKey){event.preventDefault();const views=['jobs','usage','graphs','rules','shortcuts'];const current=location.hash==='#/usage'?'usage':location.hash==='#/graphs'?'graphs':location.hash==='#/execution-router-rules'?'rules':location.hash==='#/shortcuts'?'shortcuts':'jobs';const next=views[(views.indexOf(current)+1)%views.length];location.hash=next==='usage'?'#/usage':next==='graphs'?'#/graphs':next==='rules'?'#/execution-router-rules':next==='shortcuts'?'#/shortcuts':(selectedJob?'#/jobs/'+encodeURIComponent(selectedJob):'#/jobs');showView(next);}});
 function parseMessage(message){try{return JSON.parse(message.data);}catch{return null;}}

package/dist/dashboard.js

@@ -1,6 +1,5 @@
 import { createServer } from 'node:http';
 import { readFile, readdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { readUsageSnapshot } from './usage.js';
@@ -8,9 +7,9 @@ import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
 import { loadExecutionRouterRules, saveExecutionRouterRules } from './routing-policy.js';
 import { summarizeRuntime } from './runtime-summary.js';
+import { eventsBusHistory } from './events-bus-runtime.js';
 const GITHUB_REPOSITORY_PATTERN = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
 const SSE_HEARTBEAT_MS = 15000;
-const EVENTS_HISTORY_FILE = process.env.EVENTS_BUS_DATA_DIR ? join(process.env.EVENTS_BUS_DATA_DIR, 'events.jsonl') : join(homedir(), 'Library', 'Application Support', 'EventsBus', 'events.jsonl');
 const WORKFLOW_DIR = fileURLToPath(new URL('../workflow/', import.meta.url));
 export async function dashboardWorkflowGraphs() {
     const names = (await readdir(WORKFLOW_DIR)).filter(name => name.endsWith('.mmd')).sort();
@@ -49,34 +48,16 @@ export function githubPrUrl(repository, prNumber) {
     return `https://github.com/${owner}/${repo}/pull/${prNumber}`;
 }
 async function eventHistory(jobId, taskId, limit) {
-    const boundedLimit = Math.max(1, Math.min(60, limit));
-    let content = '';
     try {
-        content = await readFile(EVENTS_HISTORY_FILE, 'utf8');
+        return await eventsBusHistory(jobId, taskId, limit);
     }
     catch {
         return [];
     }
-    const output = [];
-    const lines = content.split(/\r?\n/);
-    for (let index = lines.length - 1; index >= 0 && output.length < boundedLimit; index -= 1) {
-        const line = lines[index];
-        if (!line)
-            continue;
-        try {
-            const row = JSON.parse(line);
-            const event = row.event;
-            if (!event || event.job_id !== jobId || (taskId && event.task_id !== taskId))
-                continue;
-            output.push(event);
-        }
-        catch { /* ignore malformed historical rows */ }
-    }
-    return output;
 }
 export { dashboardHtml, dashboardVersion } from './dashboard-html.js';
 import { dashboardHtml, dashboardVersion } from './dashboard-html.js';
-export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobId, usageRegistry, overviewProvider, webhook, statusProvider, githubUsageProvider, exactJobProvider, actions) {
+export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobId, usageRegistry, overviewProvider, webhook, statusProvider, githubUsageProvider, exactJobProvider, actions, routerEvalProvider, decisionAuditProvider) {
     const legacyActions = typeof exactJobProvider === 'object' && exactJobProvider !== null ? exactJobProvider : undefined;
     const legacyExactJobProvider = !exactJobProvider && githubUsageProvider ? githubUsageProvider : undefined;
     const resolvedExactJobProvider = typeof exactJobProvider === 'function' ? exactJobProvider : legacyExactJobProvider;
@@ -461,6 +442,50 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.end('Method not allowed');
             return;
         }
+        if (req.url === '/api/router-evals') {
+            if (req.method !== 'POST') {
+                res.writeHead(405, { allow: 'POST' });
+                res.end('Method not allowed');
+                return;
+            }
+            if (!routerEvalProvider) {
+                res.writeHead(503);
+                res.end('Router evals unavailable');
+                return;
+            }
+            try {
+                const report = await routerEvalProvider();
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(report));
+            }
+            catch (error) {
+                res.writeHead(500);
+                res.end(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
+        if (req.url === '/api/decision-audit') {
+            if (req.method !== 'GET') {
+                res.writeHead(405, { allow: 'GET' });
+                res.end('Method not allowed');
+                return;
+            }
+            if (!decisionAuditProvider) {
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end('[]');
+                return;
+            }
+            try {
+                const records = await decisionAuditProvider();
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(records.slice(-30).reverse()));
+            }
+            catch (error) {
+                res.writeHead(500);
+                res.end(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         if (req.url === '/api/runtime-summary') {
             try {
                 const jobs = await discoveredJobs();

package/dist/events-bus-runtime.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+export function eventsBusConfigPath(env = process.env) {
+    if (env.NEO_EVENTS_BUS_CONFIG)
+        return env.NEO_EVENTS_BUS_CONFIG;
+    const dataDir = env.EVENTS_BUS_DATA_DIR || join(homedir(), 'Library', 'Application Support', 'EventsBus');
+    return join(dataDir, 'runtime.json');
+}
+export function resolveEventsBusRuntime(env = process.env) {
+    const configPath = eventsBusConfigPath(env);
+    let saved = {};
+    try {
+        saved = JSON.parse(readFileSync(configPath, 'utf8'));
+    }
+    catch { /* fall through to protocol defaults */ }
+    return {
+        configPath,
+        natsUrl: env.NEO_NATS_URL || String(saved.natsUrl || 'nats://127.0.0.1:4222'),
+        apiUrl: env.NEO_EVENTS_API_URL || String(saved.apiUrl || 'http://127.0.0.1:4223'),
+        subjectPrefix: env.NEO_EVENTS_SUBJECT_PREFIX || String(saved.subjectPrefix || 'neo.events.job'),
+    };
+}
+export async function eventsBusHistory(jobId, taskId, limit, env = process.env) {
+    const runtime = resolveEventsBusRuntime(env);
+    const url = new URL('/events', runtime.apiUrl);
+    url.searchParams.set('job', jobId);
+    if (taskId)
+        url.searchParams.set('task', taskId);
+    const boundedLimit = Math.max(1, Math.min(60, limit));
+    url.searchParams.set('limit', String(boundedLimit));
+    url.searchParams.set('order', 'desc');
+    const response = await fetch(url);
+    if (!response.ok)
+        throw new Error(`events-bus history unavailable: HTTP ${response.status}`);
+    const body = await response.json();
+    const rows = Array.isArray(body.events) ? body.events : [];
+    return rows.map(row => row.event).filter((event) => Boolean(event));
+}

package/dist/execution-routing.js

@@ -3,6 +3,27 @@ import { makeExecutionDecisionAudit } from './decision-audit.js';
 import { discoverModelCandidates } from './model-routing.js';
 import { loadExecutionRouterRules, loadRoutingPolicy, policyAllows } from './routing-policy.js';
 import { DEFAULT_CHATGPT_PREFERRED_CONCURRENCY } from './worker-routing.js';
+export function executionTaskShape(taskFacts = {}) {
+    const raw = taskFacts.storySize;
+    const storySize = raw === 'S' || raw === 'L' ? raw : 'M';
+    const sustainedWork = storySize === 'L';
+    return {
+        storySize,
+        sustainedWork,
+        preferredWorker: sustainedWork ? 'codex' : 'chatgpt',
+        reason: sustainedWork
+            ? 'Large/sustained tasks favor Codex.'
+            : 'Small/medium tasks favor ChatGPT when Browser Workspace capacity is available.',
+    };
+}
+export const EXECUTION_ROUTING_PRINCIPLES = [
+    'Choose one complete executable route: worker plus provider/model/profile/reasoning.',
+    'ChatGPT with MacBridge and Codex have broadly overlapping execution capabilities.',
+    'preferred_routes is the primary soft worker-fit preference derived from task size: S/M prefer ChatGPT, L prefers Codex.',
+    "Browser Workspace exhaustion is ChatGPT's primary hard execution constraint.",
+    'Concrete user rules, resource health, quota, or load facts may override preferred_routes.',
+    'Codex is only the deterministic fallback when the decision engine fails.',
+];
 function sameModelRoute(candidate, route) {
     return (!route.provider || candidate.provider === route.provider)
         && (!route.model || candidate.model === route.model)
@@ -94,35 +115,29 @@ export async function routeExecution(workers, requirements, options = {}) {
     const environmentRules = rules.text;
     const preferredChatgptConcurrency = options.preferredChatgptConcurrency ?? DEFAULT_CHATGPT_PREFERRED_CONCURRENCY;
     const chatgptRunning = options.chatgptRunning ?? 0;
+    const taskFacts = options.taskFacts ?? {};
+    const taskShape = executionTaskShape(taskFacts);
     const facts = JSON.parse(JSON.stringify({
-        task: options.taskFacts ?? {},
-        worker_requirements: requirements,
-        explicit_routing_constraints: options.routingConstraints ?? {},
+        task_shape: {
+            story_size: taskShape.storySize,
+            sustained_work: taskShape.sustainedWork,
+            preferred_worker: taskShape.preferredWorker,
+            reason: taskShape.reason,
+        },
         environment_rules: environmentRules,
-        structured_policy: policy.snapshot,
-        usage_snapshot: options.usage ?? null,
+        reviewer_context: taskFacts.reviewer_diversity ? {
+            role: taskFacts.role ?? null,
+            reviewer_diversity: taskFacts.reviewer_diversity,
+        } : null,
         runtime_load: {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
         },
-        routing_principles: [
-            'Choose one complete executable route: worker plus provider/model/profile/reasoning.',
-            'Only authoritative impossibility constraints are hard gates; all other task fit, capability, trust, region, labels, quota, cost, latency, load, reviewer diversity, and quality signals are soft facts.',
-            'User free-text environment rules are soft routing guidance and should be followed when they express a clear preference.',
-            'Codex is only the deterministic fallback when the decision engine fails; Codex is not a normal preference when decide() succeeds.',
-        ],
+        preferred_routes: routes.filter(route => route.worker.adapter === taskShape.preferredWorker).map(route => route.id),
         candidates: routes.map(route => ({
             id: route.id,
             worker: {
-                id: route.worker.workerId,
                 adapter: route.worker.adapter,
-                runtime: route.worker.runtime ?? null,
-                availability: route.worker.availability ?? null,
-                capabilities: [...route.worker.capabilities],
-                trustDomains: route.worker.trustDomains ?? [],
-                region: route.worker.region ?? null,
-                labels: route.worker.labels ?? {},
-                browserWorkspaceCapacity: route.worker.browserWorkspaceCapacity ?? null,
             },
             model: {
                 provider: route.model.provider,
@@ -141,7 +156,7 @@ export async function routeExecution(workers, requirements, options = {}) {
     const decisionRequest = { facts };
     const decisionContract = {
         type: 'choice',
-        question: 'Choose the best complete execution route for this task. The listed candidates are already executable. Treat all non-impossibility signals as soft facts, follow free-text user guidance, and choose worker+model together in this one decision.',
+        question: 'Choose the best complete execution route. If preferred_routes is non-empty, choose from preferred_routes unless environment_rules explicitly override it or a preferred route is unhealthy/unavailable. Choose worker+model together in one decision.',
         choices: routes.map(route => route.id),
     };
     const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', decisionRequest, decisionContract, () => fallback.id);

package/dist/relayd.js

@@ -24,6 +24,7 @@ import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 import { JsonlDecisionAuditStore } from './decision-audit.js';
 import { summarizeRuntime } from './runtime-summary.js';
 import { executionRouterRulesPath } from './routing-policy.js';
+import { runRouterEvals } from './router-evals.js';
 export async function overlayOperationalOverviews(overviews, storeFor) {
     return await Promise.all(overviews.map(async (item) => {
         const store = storeFor(item.job.repository, item.job.prNumber);
@@ -346,7 +347,7 @@ export async function runDaemon(argv) {
         taskCancel: workspaceTaskAction('cancel'),
         taskComplete: workspaceTaskComplete,
         taskSetState: workspaceTaskSetState,
-    });
+    }, async () => await runRouterEvals(new LayaCliDecisionEngine()), async () => (await decisionAuditStore.read()).filter((record) => record.record_type === 'decision' && record.schema_version === 5));
     await once(server, 'listening');
     const reconcileSafely = async () => {
         try {

package/dist/router-evals.js

@@ -0,0 +1,70 @@
+import { executionTaskShape } from './execution-routing.js';
+import { loadExecutionRouterRules } from './routing-policy.js';
+export const ROUTER_EVAL_CASES = [
+    { id: 'small-review', storySize: 'S', task: 'Review a focused PR and explain any correctness issue.', chatgptAvailable: true, expectedWorker: 'chatgpt' },
+    { id: 'medium-investigation', storySize: 'M', task: 'Investigate why a Relay job is blocked and propose a focused fix.', chatgptAvailable: true, expectedWorker: 'chatgpt' },
+    { id: 'small-code-fix', storySize: 'S', task: 'Apply a small configuration or one-file code fix and verify it.', chatgptAvailable: true, expectedWorker: 'chatgpt' },
+    { id: 'medium-browser-operation', storySize: 'M', task: 'Use browser and MacBridge tools to inspect state and make a bounded change.', chatgptAvailable: true, expectedWorker: 'chatgpt' },
+    { id: 'medium-near-capacity', storySize: 'M', task: 'Complete a normal engineering task while other ChatGPT work is active.', chatgptAvailable: true, chatgptRunning: 8, expectedWorker: 'chatgpt' },
+    { id: 'large-refactor', storySize: 'L', task: 'Implement a broad multi-file repository refactor with tests.', chatgptAvailable: true, expectedWorker: 'codex' },
+    { id: 'large-test-fix-loop', storySize: 'L', task: 'Run a sustained code-test-debug loop across a large change.', chatgptAvailable: true, expectedWorker: 'codex' },
+    { id: 'small-one-slot-left', storySize: 'S', task: 'Perform a short reasoning and operational task.', chatgptAvailable: true, chatgptSlots: 1, expectedWorker: 'chatgpt' },
+    { id: 'workspace-exhausted', storySize: 'S', task: 'Review a focused issue while Browser Workspace has no free slot.', chatgptAvailable: false, chatgptSlots: 0, expectedWorker: 'codex' },
+    { id: 'large-workspace-available', storySize: 'L', task: 'Implement a large feature even though ChatGPT workspace capacity is healthy.', chatgptAvailable: true, expectedWorker: 'codex' },
+];
+const CODEX_ROUTE = 'codex::default:openai/gpt-5.6-sol';
+const CHATGPT_ROUTE = 'chatgpt/browser-worker::chatgpt/account-defaults';
+function workerForRoute(route) {
+    if (route.startsWith('chatgpt/'))
+        return 'chatgpt';
+    if (route.startsWith('codex::'))
+        return 'codex';
+    return 'unknown';
+}
+export async function runRouterEvals(engine, rulesPath) {
+    const rules = await loadExecutionRouterRules(rulesPath);
+    const results = [];
+    for (const testCase of ROUTER_EVAL_CASES) {
+        const taskShape = executionTaskShape({ storySize: testCase.storySize });
+        const available = testCase.chatgptAvailable;
+        const slots = testCase.chatgptSlots ?? (available ? 5 : 0);
+        const choices = available ? [CODEX_ROUTE, CHATGPT_ROUTE] : [CODEX_ROUTE];
+        const facts = {
+            task_shape: {
+                story_size: taskShape.storySize,
+                sustained_work: taskShape.sustainedWork,
+                preferred_worker: taskShape.preferredWorker,
+                reason: taskShape.reason,
+            },
+            environment_rules: rules.text,
+            runtime_load: { chatgpt_running: testCase.chatgptRunning ?? 0, preferred_chatgpt_concurrency: 10 },
+            preferred_routes: choices.filter(route => taskShape.preferredWorker === 'chatgpt' ? route.startsWith('chatgpt/') : route.startsWith('codex::')),
+            candidates: [
+                {
+                    id: CODEX_ROUTE,
+                    worker: { adapter: 'codex' },
+                    model: { provider: 'openai', model: 'gpt-5.6-sol', profile: 'default', resourceHealthy: true },
+                },
+                ...(available ? [{
+                        id: CHATGPT_ROUTE,
+                        worker: { adapter: 'chatgpt' },
+                        model: { provider: 'chatgpt', model: 'account-defaults', profile: 'account-defaults', resourceHealthy: true },
+                    }] : []),
+            ],
+        };
+        const decision = await engine.decide({ facts }, {
+            type: 'choice',
+            question: 'Choose the best complete execution route. If preferred_routes is non-empty, choose from preferred_routes unless environment_rules explicitly override it or a preferred route is unhealthy/unavailable.',
+            choices,
+        });
+        const selectedWorker = workerForRoute(decision.choice);
+        results.push({
+            ...testCase,
+            selectedWorker,
+            selectedRoute: decision.choice,
+            pass: selectedWorker === testCase.expectedWorker,
+            probabilities: decision.probabilities,
+        });
+    }
+    return { passed: results.filter(item => item.pass).length, total: results.length, results };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {

package/skills/agents-relay/SKILL.md

@@ -41,7 +41,7 @@ A running agent MUST use the canonical Neo `events-bus` protocol and publish exa
 - `task.failed` when the task cannot complete;
 - `task.blocked` when external or human action is required.
 
-Event publishing is not an Agents Relay CLI responsibility. Sandboxed Codex and hosted ChatGPT workers use the federated `events__publish` MCP tool from `events-bus`; direct non-sandbox local workers may use the caller-provided `NEO_EVENTS_EMIT`. Agents Relay subscribes to the canonical `neo.events.job.<job_id>.>` stream and maps terminal events into durable task state.
+Event publishing is not an Agents Relay CLI responsibility. Sandboxed Codex and hosted ChatGPT workers use the federated `events__publish` MCP tool from `events-bus`; direct non-sandbox local workers may use the caller-provided `NEO_EVENTS_EMIT`. Agents Relay subscribes to the canonical `neo.events.job.<job_id>.>` stream and maps terminal events into durable task state. Relay resolves its native NATS endpoint and subject prefix from the canonical events-bus runtime configuration (with explicit Relay CLI flags remaining authoritative). The same runtime configuration supplies the events-bus HTTP API used for replay/history. Relay and its dashboard must not read the events-bus private history file or maintain a second event-history backend.
 
 The event must carry the exact durable `job_id` and `task_id`. Progress events are optional.