agents-relay 2.0.17 → 2.0.19

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('Calling router with current status…')));try{const response=await fetch('/api/router-test',{method:'POST'});if(!response.ok)throw new Error(response.status+' '+await response.text());const result=await response.json();const selected=result.selected||{};const current=result.current||{};routerTestResults.replaceChildren(element('strong','',text((selected.worker||'—')+' · '+(selected.model||'—'))));routerTestResults.append(element('div','subtle',text('route: '+(selected.route||'—'))),element('div','subtle',text('fallback: '+String(Boolean(result.fallback)))),element('pre','',text('probabilities: '+JSON.stringify(result.probabilities||{},null,2)+String.fromCharCode(10)+'browser workspace: '+JSON.stringify(current.browserWorkspace||null,null,2)+String.fromCharCode(10)+'chatgpt running: '+String(current.chatgptRunning??0))));}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

@@ -57,7 +57,7 @@ async function eventHistory(jobId, taskId, limit) {
 }
 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, routerTestProvider, decisionAuditProvider) {
     const legacyActions = typeof exactJobProvider === 'object' && exactJobProvider !== null ? exactJobProvider : undefined;
     const legacyExactJobProvider = !exactJobProvider && githubUsageProvider ? githubUsageProvider : undefined;
     const resolvedExactJobProvider = typeof exactJobProvider === 'function' ? exactJobProvider : legacyExactJobProvider;
@@ -442,6 +442,50 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.end('Method not allowed');
             return;
         }
+        if (req.url === '/api/router-test') {
+            if (req.method !== 'POST') {
+                res.writeHead(405, { allow: 'POST' });
+                res.end('Method not allowed');
+                return;
+            }
+            if (!routerTestProvider) {
+                res.writeHead(503);
+                res.end('Router test unavailable');
+                return;
+            }
+            try {
+                const result = await routerTestProvider();
+                res.writeHead(200, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(result));
+            }
+            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/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,8 @@ 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 { workerCandidates } from './worker-routing.js';
+import { routeExecution } from './execution-routing.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 +348,42 @@ export async function runDaemon(argv) {
         taskCancel: workspaceTaskAction('cancel'),
         taskComplete: workspaceTaskComplete,
         taskSetState: workspaceTaskSetState,
-    });
+    }, async () => {
+        const usage = await usageRegistry.snapshot();
+        const runtime = summarizeRuntime(cachedOverviews.map(item => item.job));
+        const workers = workerCandidates([
+            { name: 'codex', id: 'codex', capabilities: ['model', 'codex'] },
+            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-harness'] },
+        ], [], usage);
+        const result = await routeExecution(workers, { capabilities: [] }, {
+            decisionEngine: new LayaCliDecisionEngine(),
+            decisionMode: 'active',
+            taskFacts: { storySize: 'M', role: 'router-test' },
+            usage,
+            chatgptRunning: runtime.workers.chatgpt,
+        });
+        return {
+            selected: {
+                route: result.audit?.selected?.id,
+                worker: result.selection.workerId,
+                adapter: result.selection.adapter,
+                provider: result.candidate.routing.provider,
+                model: result.candidate.routing.model,
+                profile: result.candidate.routing.profile,
+                reasoning: result.candidate.routing.reasoning,
+            },
+            probabilities: result.candidate.routing.decisionEvidence?.probabilities ?? {},
+            fallback: result.candidate.routing.decisionEvidence?.fallback ?? false,
+            current: {
+                chatgptRunning: runtime.workers.chatgpt,
+                browserWorkspace: usage.browserWorkspace ?? null,
+                providers: usage.providers,
+                credits: usage.credits,
+            },
+            decisionInput: result.audit?.decision_input ?? null,
+            gates: result.audit?.gate_results ?? [],
+        };
+    }, 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.17",
+  "version": "2.0.19",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {