agents-relay 1.0.151 → 1.0.153

package/README.md

@@ -81,7 +81,7 @@ Planner-created tasks use stable IDs and the existing parent/subtask tree, so
 retries and daemon restarts do not create duplicate work.
 Task producers must follow `skills/agents-relay/contracts/task-job-contract.md`; that shared skill contract defines story size, lifecycle events, review, and auto-merge semantics.
 
-Worker/model routing is code-driven: Relay gathers authoritative worker/model/resource facts, applies hard gates, then can call the generic typed `decide(request, contract)` boundary for judgment among legal candidates. The optional Laya implementation is a transient CLI subprocess per decision (no resident model/service), with active Laya decisions and deterministic fallback on decision failure. See [Worker Router, Model Router, and typed decisions](docs/worker-model-routers.md).
+Execution routing is code-driven: Relay builds complete executable worker+model routes from authoritative runtime/model/resource facts, removes only impossible routes, then calls the generic typed `decide(request, contract)` boundary once. Free-text routing guidance and task/resource/capability signals are soft decision facts; decision failure falls back deterministically to a usable Codex default route. See [Execution Router and typed decisions](docs/worker-model-routers.md).
 All task producers use the same story-size contract: `S`≈5 minutes, `M`≈15 minutes, and `L`≈45 minutes of normal-reasoning execution, with `M` as the default. `high` reasoning doubles that overall window. ChatGPT Browser Worker start-ack timeout is derived as one third of the effective overall timeout, clamped between 1 and 5 minutes. Orchestrators and planners should choose `storySize`, not raw timeout milliseconds; `--timeout` remains only as an explicit compatibility/debug override.
 
 Autonomous jobs can also be scheduled without a Relay database. The job marker

package/dist/cli-help.js

@@ -99,7 +99,7 @@ Actions:
     'task create': `Create one durable Task under an existing Job.
 
 Required: normal Job storage options plus --input-file PATH|- (preferred) or --input MARKDOWN, and --output task-pr|file. --input and --input-file are mutually exclusive.
-Common: --task-id ID, --priority P0|P1|P2|P3, --story-size S|M|L, --agent NAME, --agent-graph-file PATH|-, --deps a,b, --parent ID, --draft. Normal model-backed Tasks omit adapter/provider/model so Relay runs worker-router then model-router. Use --adapter orchestrator only for synchronous self-work; explicit adapter/provider/model remain compatibility/debug constraints.\nTasks with dependencies start DRAFT; tasks without dependencies start QUEUED unless --draft is given.
+Common: --task-id ID, --priority P0|P1|P2|P3, --story-size S|M|L, --agent NAME, --agent-graph-file PATH|-, --deps a,b, --parent ID, --draft. Normal model-backed Tasks omit adapter/provider/model so Relay runs one Execution Router decision over complete worker+model routes. Use --adapter orchestrator only for synchronous self-work; explicit adapter/provider/model remain compatibility/debug constraints.\nTasks with dependencies start DRAFT; tasks without dependencies start QUEUED unless --draft is given.
 Directly-created Tasks are not wrapped in a synthetic Plan. Planner-generated Tasks are created internally by Relay from planner output.
 
 Example:

package/dist/dashboard-html.js

@@ -170,8 +170,7 @@ export const dashboardHtml = `<!doctype html>
   <nav role="tablist" aria-label="Console views">
     <button id="jobs-tab" type="button" role="tab" aria-selected="true" aria-controls="jobs-view">Jobs</button>
     <button id="usage-tab" type="button" role="tab" aria-selected="false" aria-controls="usage-view">Usage</button>
-    <button id="rules-tab" type="button" role="tab" aria-selected="false" aria-controls="rules-view">Model Rules</button>
-    <button id="worker-rules-tab" type="button" role="tab" aria-selected="false" aria-controls="worker-rules-view">Worker Rules</button>
+    <button id="rules-tab" type="button" role="tab" aria-selected="false" aria-controls="rules-view">Execution Rules</button>
   </nav>
 </header>
 <main>
@@ -203,28 +202,16 @@ export const dashboardHtml = `<!doctype html>
   </section>
   <section id="rules-view" role="tabpanel" aria-labelledby="rules-tab" hidden>
     <div class="panel">
-      <div class="panel-head"><h2>Model Router Rules</h2><span id="rules-meta" class="subtle"></span></div>
+      <div class="panel-head"><h2>Execution 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 guidance loaded by the model decider for every routing decision. Hard capability and health gates remain enforced by code.</p>
-          <textarea id="rules-text" class="rules-textarea" spellcheck="true" aria-label="Model router rules" placeholder="Example: ZAI only glm-5.3-flash high thinking. Prefer it while paid quota is abundant. Non-OpenAI models enter the candidate set only when the provider is configured and the concrete model is named here."></textarea>
+          <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="worker-rules-view" role="tabpanel" aria-labelledby="worker-rules-tab" hidden>
-    <div class="panel">
-      <div class="panel-head"><h2>Worker Router Rules</h2><span id="worker-rules-meta" class="subtle"></span></div>
-      <div class="panel-body">
-        <div class="rules-editor">
-          <p class="rules-help">Free-text guidance loaded by the worker decider when choosing ChatGPT versus Codex. Use this for local preferences; worker legality and Model Router remain separate.</p>
-          <textarea id="worker-rules-text" class="rules-textarea" spellcheck="true" aria-label="Worker router rules" placeholder="Example: Prefer ChatGPT unless the task requires native local execution or computer-use that ChatGPT plus MacBridge cannot perform."></textarea>
-          <div class="rules-footer"><span id="worker-rules-status" class="subtle" aria-live="polite"></span><button id="worker-rules-save" class="rules-save" type="button">Save rules</button></div>
-        </div>
-      </div>
-    </div>
-  </section>
 </main>
 <script>
 'use strict';
@@ -245,11 +232,9 @@ const DASHBOARD_VERSION=${JSON.stringify(dashboardVersion)};
 const jobsTab=document.querySelector('#jobs-tab');
 const usageTab=document.querySelector('#usage-tab');
 const rulesTab=document.querySelector('#rules-tab');
-const workerRulesTab=document.querySelector('#worker-rules-tab');
 const jobsView=document.querySelector('#jobs-view');
 const usageView=document.querySelector('#usage-view');
 const rulesView=document.querySelector('#rules-view');
-const workerRulesView=document.querySelector('#worker-rules-view');
 const jobsWorkspace=document.querySelector('#jobs-workspace');
 const jobList=document.querySelector('#job-list');
 const jobsRefresh=document.querySelector('#jobs-refresh');
@@ -275,10 +260,6 @@ 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 workerRulesText=document.querySelector('#worker-rules-text');
-const workerRulesMeta=document.querySelector('#worker-rules-meta');
-const workerRulesStatus=document.querySelector('#worker-rules-status');
-const workerRulesSave=document.querySelector('#worker-rules-save');
 const rateLimitWarning=document.querySelector('#rate-limit-warning');
 const runtimeSummary=document.querySelector('#runtime-summary');
 let jobs=[];
@@ -397,11 +378,9 @@ function githubUsageCard(snapshot,status){
   return card;
 }
 async function drawUsage(){try{const overview=await loadJSON('/api/usage');usageRoot.replaceChildren();usageMeta.textContent='Real account telemetry when available';const providers=Array.isArray(overview.providers)?overview.providers:[];const credits=Array.isArray(overview.credits)?overview.credits:[];const grid=element('div','usage-providers');if(overview.github||overview.githubStatus)grid.append(githubUsageCard(overview.github,overview.githubStatus));for(const provider of providers)grid.append(usageProvider(provider));for(const provider of credits)grid.append(creditProvider(provider));if(!grid.children.length){usageRoot.append(element('p','empty',text('Usage telemetry is unavailable.')));return;}usageRoot.append(grid);}catch(error){usageMeta.textContent='Unavailable';usageRoot.replaceChildren(element('p','error-state',text('Usage unavailable: '+error.message)));}}
-async function drawRules(){rulesStatus.textContent='';try{const rules=await loadJSON('/api/model-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;}}
-async function saveRules(){rulesSave.disabled=true;rulesStatus.textContent='Saving…';try{const response=await fetch('/api/model-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 drawWorkerRules(){workerRulesStatus.textContent='';try{const rules=await loadJSON('/api/worker-router-rules');workerRulesText.value=typeof rules.text==='string'?rules.text:'';workerRulesMeta.textContent=rules.hash&&rules.hash!=='none'?'Loaded · '+rules.hash.slice(0,12):'No custom rules saved';}catch(error){workerRulesMeta.textContent='Unavailable';workerRulesStatus.textContent='Could not load rules: '+error.message;}}
-async function saveWorkerRules(){workerRulesSave.disabled=true;workerRulesStatus.textContent='Saving…';try{const response=await fetch('/api/worker-router-rules',{method:'PUT',headers:{'content-type':'text/plain; charset=utf-8'},body:workerRulesText.value});if(!response.ok)throw new Error(response.status+' '+await response.text());const rules=await response.json();workerRulesMeta.textContent='Saved · '+rules.hash.slice(0,12);workerRulesStatus.textContent='Saved. New worker decisions will load these rules.';}catch(error){workerRulesStatus.textContent='Save failed: '+error.message;}finally{workerRulesSave.disabled=false;}}
-function showView(view){const isJobs=view==='jobs';const isUsage=view==='usage';const isRules=view==='rules';const isWorkerRules=view==='worker-rules';jobsView.hidden=!isJobs;jobsWorkspace.hidden=!isJobs;usageView.hidden=!isUsage;rulesView.hidden=!isRules;workerRulesView.hidden=!isWorkerRules;jobsTab.setAttribute('aria-selected',String(isJobs));usageTab.setAttribute('aria-selected',String(isUsage));rulesTab.setAttribute('aria-selected',String(isRules));workerRulesTab.setAttribute('aria-selected',String(isWorkerRules));if(isJobs)void refresh();else if(isUsage)void drawUsage();else if(isRules)void drawRules();else void drawWorkerRules();}
+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;}}
+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;}}
+function showView(view){const isJobs=view==='jobs';const isUsage=view==='usage';const isRules=view==='rules';jobsView.hidden=!isJobs;jobsWorkspace.hidden=!isJobs;usageView.hidden=!isUsage;rulesView.hidden=!isRules;jobsTab.setAttribute('aria-selected',String(isJobs));usageTab.setAttribute('aria-selected',String(isUsage));rulesTab.setAttribute('aria-selected',String(isRules));if(isJobs)void refresh();else if(isUsage)void drawUsage();else void drawRules();}
 jobsTab.addEventListener('click',()=>{location.hash=selectedJob?'#/jobs/'+encodeURIComponent(selectedJob):'#/jobs';showView('jobs');});
 jobsRefresh.addEventListener('click',()=>void refresh(true));
 eventsAllTasks.addEventListener('click',()=>{eventTaskId=null;clearEvents();renderEventScope();void loadEventHistory();});
@@ -415,19 +394,17 @@ mobileJobsBack.addEventListener('click',()=>{location.hash='#/jobs';syncMobileJo
 mobileJobs.addEventListener('change',syncMobileJobsView);
 window.addEventListener('hashchange',syncMobileJobsView);
 usageTab.addEventListener('click',()=>{location.hash='#/usage';showView('usage');});
-rulesTab.addEventListener('click',()=>{location.hash='#/model-router-rules';showView('rules');});
-workerRulesTab.addEventListener('click',()=>{location.hash='#/worker-router-rules';showView('worker-rules');});
+rulesTab.addEventListener('click',()=>{location.hash='#/execution-router-rules';showView('rules');});
 rulesSave.addEventListener('click',()=>void saveRules());
-workerRulesSave.addEventListener('click',()=>void saveWorkerRules());
-window.addEventListener('keydown',event=>{if(event.key==='Tab'&&event.altKey){event.preventDefault();const next=location.hash==='#/usage'?'rules':location.hash==='#/model-router-rules'?'worker-rules':location.hash==='#/worker-router-rules'?'jobs':'usage';location.hash=next==='usage'?'#/usage':next==='rules'?'#/model-router-rules':next==='worker-rules'?'#/worker-router-rules':(selectedJob?'#/jobs/'+encodeURIComponent(selectedJob):'#/jobs');showView(next);}});
+window.addEventListener('keydown',event=>{if(event.key==='Tab'&&event.altKey){event.preventDefault();const next=location.hash==='#/usage'?'rules':location.hash==='#/execution-router-rules'?'jobs':'usage';location.hash=next==='usage'?'#/usage':next==='rules'?'#/execution-router-rules':(selectedJob?'#/jobs/'+encodeURIComponent(selectedJob):'#/jobs');showView(next);}});
 function parseMessage(message){try{return JSON.parse(message.data);}catch{return null;}}
 const stream=new EventSource('/events');
 stream.onopen=()=>{connection.textContent='';connection.setAttribute('aria-label','Event stream connected');connection.className='status-pill ok';};
 stream.onerror=()=>{connection.textContent='';connection.setAttribute('aria-label','Event stream reconnecting');connection.className='status-pill warn';};
 stream.onmessage=message=>{const payload=parseMessage(message);if(payload?.job){const index=jobs.findIndex(job=>job.id===payload.job.id);if(index>=0)jobs[index]=payload.job;else jobs.push(payload.job);renderAll();void drawRuntimeSummary();}};
 stream.addEventListener('relay',message=>{const payload=parseMessage(message);if(payload?.job){const index=jobs.findIndex(job=>job.id===payload.job.id);if(index>=0)jobs[index]=payload.job;else jobs.push(payload.job);}if(payload?.event)addEvent(payload.event);renderAll();void drawRuntimeSummary();});
-if(location.hash==='#/usage')showView('usage');else if(location.hash==='#/model-router-rules')showView('rules');else if(location.hash==='#/worker-router-rules')showView('worker-rules');else showView('jobs');
-setInterval(()=>{if(location.hash!=='#/usage'&&location.hash!=='#/model-router-rules'&&location.hash!=='#/worker-router-rules')void refresh();},300000);
+if(location.hash==='#/usage')showView('usage');else if(location.hash==='#/execution-router-rules')showView('rules');else showView('jobs');
+setInterval(()=>{if(location.hash!=='#/usage'&&location.hash!=='#/execution-router-rules')void refresh();},300000);
 setInterval(()=>{if(location.hash==='#/usage')void drawUsage();},30000);
 setInterval(()=>void refreshVersion(),30000);
 async function refreshSelected(){if(!selectedJob){await refresh();return;}selectedJobRefresh.disabled=true;selectedJobRefresh.textContent='Refreshing…';try{const updated=await loadJSON('/api/job?id='+encodeURIComponent(selectedJob));const index=jobs.findIndex(job=>job.id===selectedJob);if(index>=0)jobs[index]=updated;else jobs.push(updated);rememberSelection();renderAll();connection.textContent='';connection.setAttribute('aria-label','Live durable state connected');connection.className='status-pill ok';}catch(error){connection.textContent='';connection.setAttribute('aria-label','Durable state unavailable');connection.className='status-pill bad';}finally{selectedJobRefresh.disabled=false;selectedJobRefresh.textContent='Refresh';}}

package/dist/dashboard.js

@@ -5,7 +5,7 @@ import { join } from 'node:path';
 import { readUsageSnapshot } from './usage.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
-import { loadModelRouterRules, loadWorkerRouterRules, saveModelRouterRules, saveWorkerRouterRules } from './routing-policy.js';
+import { loadExecutionRouterRules, saveExecutionRouterRules } from './routing-policy.js';
 import { summarizeRuntime } from './runtime-summary.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;
@@ -327,10 +327,10 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.end(JSON.stringify(events));
             return;
         }
-        if (req.url === '/api/model-router-rules') {
+        if (req.url === '/api/execution-router-rules') {
             if (req.method === 'GET') {
                 try {
-                    const rules = await loadModelRouterRules();
+                    const rules = await loadExecutionRouterRules();
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(JSON.stringify(rules));
                 }
@@ -348,54 +348,13 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
                     size += buffer.length;
                     if (size > 64 * 1024) {
                         res.writeHead(413);
-                        res.end('Model router rules exceed 64 KiB');
+                        res.end('Execution router rules exceed 64 KiB');
                         return;
                     }
                     chunks.push(buffer);
                 }
                 try {
-                    const rules = await saveModelRouterRules(Buffer.concat(chunks).toString('utf8'));
-                    res.writeHead(200, { 'content-type': 'application/json' });
-                    res.end(JSON.stringify(rules));
-                }
-                catch (error) {
-                    res.writeHead(500);
-                    res.end(error instanceof Error ? error.message : String(error));
-                }
-                return;
-            }
-            res.writeHead(405, { allow: 'GET, PUT' });
-            res.end('Method not allowed');
-            return;
-        }
-        if (req.url === '/api/worker-router-rules') {
-            if (req.method === 'GET') {
-                try {
-                    const rules = await loadWorkerRouterRules();
-                    res.writeHead(200, { 'content-type': 'application/json' });
-                    res.end(JSON.stringify(rules));
-                }
-                catch (error) {
-                    res.writeHead(500);
-                    res.end(error instanceof Error ? error.message : String(error));
-                }
-                return;
-            }
-            if (req.method === 'PUT') {
-                const chunks = [];
-                let size = 0;
-                for await (const chunk of req) {
-                    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-                    size += buffer.length;
-                    if (size > 64 * 1024) {
-                        res.writeHead(413);
-                        res.end('Worker router rules exceed 64 KiB');
-                        return;
-                    }
-                    chunks.push(buffer);
-                }
-                try {
-                    const rules = await saveWorkerRouterRules(Buffer.concat(chunks).toString('utf8'));
+                    const rules = await saveExecutionRouterRules(Buffer.concat(chunks).toString('utf8'));
                     res.writeHead(200, { 'content-type': 'application/json' });
                     res.end(JSON.stringify(rules));
                 }

package/dist/execution-routing.js

@@ -0,0 +1,163 @@
+import { chooseWithDecision } from './decision.js';
+import { makeDecisionAudit } from './decision-audit.js';
+import { discoverModelCandidates } from './model-routing.js';
+import { loadExecutionRouterRules, loadRoutingPolicy, policyAllows } from './routing-policy.js';
+import { DEFAULT_CHATGPT_PREFERRED_CONCURRENCY, eligibleWorkerCandidates } from './worker-routing.js';
+function sameModelRoute(candidate, route) {
+    return (!route.provider || candidate.provider === route.provider)
+        && (!route.model || candidate.model === route.model)
+        && (route.profile === undefined || candidate.profile === route.profile);
+}
+function modelUsable(candidate, constraints, excludedRoutes, policy) {
+    if (candidate.resourceHealthy === false)
+        return false;
+    if ((excludedRoutes ?? []).some(route => sameModelRoute(candidate, route)))
+        return false;
+    if (!policyAllows(candidate, policy.policy))
+        return false;
+    if (constraints?.provider && candidate.provider !== constraints.provider)
+        return false;
+    if (constraints?.model && candidate.model !== constraints.model)
+        return false;
+    if (constraints?.profile && candidate.profile !== constraints.profile)
+        return false;
+    if (constraints?.reasoning && candidate.reasoning && candidate.reasoning !== constraints.reasoning)
+        return false;
+    return true;
+}
+function routeId(worker, model) {
+    return `${worker.workerId}::${model.id}`;
+}
+function fallbackRoute(routes) {
+    const codex = routes.filter(route => route.worker.adapter === 'codex');
+    return codex.find(route => route.model.id.startsWith('default:')) ?? codex[0] ?? routes[0];
+}
+function workerSelection(worker, selectedBy, evidence) {
+    return {
+        workerId: worker.workerId,
+        adapter: worker.adapter,
+        capabilities: [...worker.capabilities],
+        selectedBy,
+        selectedAt: new Date().toISOString(),
+        resourceHealthy: worker.resourceHealthy,
+        resourceProvider: worker.resourceProvider,
+        resourceUsedPercent: worker.resourceUsedPercent,
+        resourceRemainingPercent: worker.resourceRemainingPercent,
+        resourceResetAt: worker.resourceResetAt,
+        resourceResetInMinutes: worker.resourceResetInMinutes,
+        resourceWindows: worker.resourceWindows,
+        browserWorkspaceCapacity: worker.browserWorkspaceCapacity,
+        decisionEvidence: evidence,
+    };
+}
+export async function discoverExecutionRoutes(workers, requirements, options = {}) {
+    const legalWorkers = eligibleWorkerCandidates(workers, requirements);
+    const registered = options.registered ?? [];
+    const policy = await loadRoutingPolicy(options.policyPath, options.rulesPath);
+    const routes = [];
+    for (const worker of legalWorkers) {
+        const models = await discoverModelCandidates(worker, registered, options.usage, undefined, options.rulesPath);
+        for (const model of models) {
+            if (!modelUsable(model, options.routingConstraints, options.excludedRoutes, policy))
+                continue;
+            routes.push({ id: routeId(worker, model), worker, model });
+        }
+    }
+    return { routes, policy };
+}
+export async function routeExecution(workers, requirements, options = {}) {
+    const { routes, policy } = await discoverExecutionRoutes(workers, requirements, options);
+    if (routes.length === 0)
+        throw new Error('No executable worker+model route satisfies authoritative constraints');
+    const fallback = fallbackRoute(routes);
+    const rules = await loadExecutionRouterRules(options.rulesPath);
+    const environmentRules = rules.text;
+    const preferredChatgptConcurrency = options.preferredChatgptConcurrency ?? DEFAULT_CHATGPT_PREFERRED_CONCURRENCY;
+    const chatgptRunning = options.chatgptRunning ?? 0;
+    const facts = JSON.parse(JSON.stringify({
+        task: options.taskFacts ?? {},
+        worker_requirements: requirements,
+        explicit_routing_constraints: options.routingConstraints ?? {},
+        environment_rules: environmentRules,
+        structured_policy: policy.snapshot,
+        usage_snapshot: options.usage ?? 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.',
+        ],
+        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,
+                model: route.model.model,
+                profile: route.model.profile ?? null,
+                reasoning: route.model.reasoning ?? null,
+                resourceHealthy: route.model.resourceHealthy ?? null,
+                resourceUsedPercent: route.model.resourceUsedPercent ?? null,
+                resourceRemainingPercent: route.model.resourceRemainingPercent ?? null,
+                resourceResetAt: route.model.resourceResetAt ?? null,
+                resourceResetInMinutes: route.model.resourceResetInMinutes ?? null,
+                resourceWindows: route.model.resourceWindows ?? null,
+            },
+        })),
+    }));
+    const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, {
+        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.',
+        choices: routes.map(route => route.id),
+    }, () => fallback.id);
+    const selected = routes.find(route => route.id === choice.choice) ?? fallback;
+    const selectedBy = choice.evidence.engine && !choice.evidence.fallback ? 'execution-router:laya' : 'execution-router:fallback';
+    const routing = {
+        provider: selected.model.provider,
+        model: selected.model.model,
+        profile: selected.model.profile,
+        reasoning: options.routingConstraints?.reasoning ?? selected.model.reasoning,
+        decidedBy: selectedBy,
+        decidedAt: new Date().toISOString(),
+        decisionEvidence: choice.evidence,
+    };
+    const audit = makeDecisionAudit({
+        task: options.auditTask,
+        worker: { id: selected.worker.workerId, adapter: selected.worker.adapter, capabilities: [...selected.worker.capabilities], route_id: selected.id },
+        contract: {
+            question: 'execution-route-selection',
+            task: options.taskFacts ?? {},
+            workerRequirements: requirements,
+            constraints: options.routingConstraints ?? {},
+            excludedRoutes: options.excludedRoutes ?? [],
+            candidateRoutes: routes.map(route => ({ id: route.id, workerId: route.worker.workerId, adapter: route.worker.adapter })),
+        },
+        policy,
+        candidates: routes.map(route => ({ ...route.model, id: route.id })),
+        eligibleCandidates: routes.map(route => ({ ...route.model, id: route.id })),
+        selected: { ...selected.model, id: selected.id },
+        routing,
+    });
+    routing.decisionId = audit.decision_id;
+    if (options.auditStore)
+        await options.auditStore.append(audit);
+    return {
+        candidate: { ...selected.worker, routing },
+        selection: workerSelection(selected.worker, selectedBy, choice.evidence),
+        model: selected.model,
+        audit,
+    };
+}

package/dist/model-routing.js

@@ -4,7 +4,7 @@ import { readdir, readFile } from 'node:fs/promises';
 import { chooseWithDecision } from './decision.js';
 import { usageForProvider } from './worker-routing.js';
 import { makeDecisionAudit } from './decision-audit.js';
-import { loadModelRouterRules, loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
+import { loadExecutionRouterRules, loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
 function topLevelCodexConfig(text) {
     const result = {};
     let inSection = false;
@@ -63,7 +63,7 @@ function withResource(candidate, usage) {
 export async function discoverModelCandidates(worker, registered, usage, codexHome = process.env.CODEX_HOME ?? join(homedir(), '.codex'), rulesPath) {
     const registration = registered.find(item => item.id === worker.workerId);
     if (registration?.runtime.provider && registration.runtime.model) {
-        const rules = await loadModelRouterRules(rulesPath);
+        const rules = await loadExecutionRouterRules(rulesPath);
         if (!nonOpenAiModelAuthorized(registration.runtime.provider, registration.runtime.model, rules.text))
             return [];
         return [withResource({
@@ -76,7 +76,7 @@ export async function discoverModelCandidates(worker, registered, usage, codexHo
         return [withResource({ id: 'chatgpt/account-defaults', provider: 'chatgpt', model: 'account-defaults' }, usage)];
     }
     const base = await readConfig(join(codexHome, 'config.toml')) ?? {};
-    const rules = await loadModelRouterRules(rulesPath);
+    const rules = await loadExecutionRouterRules(rulesPath);
     const candidates = [];
     if (base.model) {
         const provider = base.provider ?? 'openai';

package/dist/reconciler-review.js

@@ -2,8 +2,8 @@ import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
 import { completionGateSatisfied, schedule, transitionTaskEvent, transitionJobEvent, tryTransitionTaskEvent } from './scheduler.js';
 import { implementationComplete, implementationTasks } from './runtime-status.js';
 import { eventFor } from './events.js';
-import { routeWorker, workerCandidates } from './worker-routing.js';
-import { discoverModelCandidates, routeModel } from './model-routing.js';
+import { workerCandidates } from './worker-routing.js';
+import { routeExecution } from './execution-routing.js';
 import { ReconcilerRuntimeBase } from './reconciler-runtime.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) { return await this.store.headSha?.() ?? job.headSha ?? job.review?.headSha ?? null; }
@@ -84,23 +84,18 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             },
         };
         const runtimeSummary = this.options.runtimeSummaryProvider?.();
-        const routedWorker = await routeWorker(workers, configured?.requirements ?? { capabilities: ['model'] }, {
+        const routed = await routeExecution(workers, configured?.requirements ?? { capabilities: ['model'] }, {
             decisionEngine: this.options.decisionEngine,
             decisionMode: this.options.decisionMode,
             taskFacts,
             usage,
+            registered,
             chatgptRunning: runtimeSummary?.chatgptRunning ?? 0,
-        });
-        const models = await discoverModelCandidates(routedWorker.candidate, registered, usage);
-        const routedModel = await routeModel(routedWorker.candidate, models, {
-            decisionEngine: this.options.decisionEngine,
-            decisionMode: this.options.decisionMode,
-            constraints: configured?.routing,
-            taskFacts,
+            routingConstraints: configured?.routing,
         });
         return {
-            candidate: { ...routedWorker.candidate, routing: routedModel.routing },
-            selection: routedWorker.selection,
+            candidate: routed.candidate,
+            selection: routed.selection,
             reason: 'worker-router',
         };
     }
@@ -120,28 +115,31 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 attachments: task.attachments ?? [],
                 output: task.output ?? null,
             };
-            const routedWorker = await routeWorker(candidates, requirements, {
-                decisionEngine: this.options.decisionEngine,
-                decisionMode: this.options.decisionMode,
-                taskFacts,
-                usage,
-                chatgptRunning: runtimeSummary?.chatgptRunning ?? 0,
-            });
-            const models = await discoverModelCandidates(routedWorker.candidate, registered, usage);
             const routingConstraints = task.routing ? { provider: task.routing.provider, model: task.routing.model, profile: task.routing.profile, reasoning: task.routing.reasoning } : undefined;
             const parent = task.agentName === 'troubleshooter' && task.parentTaskId ? job.tasks.find(item => item.id === task.parentTaskId) : undefined;
             const parentRouteFailedBeforeStart = Boolean(parent?.routing && /exited before publishing task\.started|worker_exit_before_start|launch failed/i.test(parent.error ?? parent.failureReason ?? ''));
             const excludedRoutes = parentRouteFailedBeforeStart && parent?.routing
                 ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
                 : [];
-            const routedModel = await routeModel(routedWorker.candidate, models, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts: { ...taskFacts, recovery_parent_failed_route: excludedRoutes[0] ?? null }, constraints: routingConstraints, excludedRoutes, auditStore: this.options.decisionAuditStore, auditTask: task });
-            task.workerSelection = routedWorker.selection;
-            task.adapter = routedWorker.candidate.adapter;
-            task.routing = routedModel.routing;
+            const routed = await routeExecution(candidates, requirements, {
+                decisionEngine: this.options.decisionEngine,
+                decisionMode: this.options.decisionMode,
+                taskFacts: { ...taskFacts, recovery_parent_failed_route: excludedRoutes[0] ?? null },
+                usage,
+                registered,
+                chatgptRunning: runtimeSummary?.chatgptRunning ?? 0,
+                routingConstraints,
+                excludedRoutes,
+                auditStore: this.options.decisionAuditStore,
+                auditTask: task,
+            });
+            task.workerSelection = routed.selection;
+            task.adapter = routed.candidate.adapter;
+            task.routing = routed.candidate.routing;
             task.timeoutMs = task.timeoutMs || taskOverallTimeoutMs(task.storySize ?? 'M', task.routing.reasoning);
             task.updatedAt = new Date().toISOString();
             await this.store.saveTask(task);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'worker.selected', 'queued', `Worker ${routedWorker.selection.workerId} selected for task ${task.id}`, 'user', { workerSelection: routedWorker.selection, workerRequirements: requirements }, { agent: 'relay', component: 'agents-relay' }));
+            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'worker.selected', 'queued', `Worker ${routed.selection.workerId} selected for task ${task.id}`, 'user', { workerSelection: routed.selection, workerRequirements: requirements }, { agent: 'relay', component: 'agents-relay' }));
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', `Selected ${task.routing.model} · thinking ${task.routing.reasoning ?? 'unknown'}`, 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
         }
     }

package/dist/routing-policy.js

@@ -44,27 +44,18 @@ async function saveRouterRules(path, text) {
     await writeFile(path, text, 'utf8');
     return { path, hash: createHash('sha256').update(text).digest('hex'), text };
 }
-export function modelRouterRulesPath(explicit) {
-    return explicit ?? process.env.AGENTS_RELAY_MODEL_ROUTER_RULES ?? join(process.cwd(), '.agents-relay-model-router-rules.md');
+export function executionRouterRulesPath(explicit) {
+    return explicit ?? process.env.AGENTS_RELAY_EXECUTION_ROUTER_RULES ?? join(process.cwd(), '.agents-relay-execution-router-rules.md');
 }
-export function workerRouterRulesPath(explicit) {
-    return explicit ?? process.env.AGENTS_RELAY_WORKER_ROUTER_RULES ?? join(process.cwd(), '.agents-relay-worker-router-rules.md');
+export async function loadExecutionRouterRules(explicit) {
+    return await loadRouterRules(executionRouterRulesPath(explicit));
 }
-export async function loadModelRouterRules(explicit) {
-    return await loadRouterRules(modelRouterRulesPath(explicit));
-}
-export async function saveModelRouterRules(text, explicit) {
-    return await saveRouterRules(modelRouterRulesPath(explicit), text);
-}
-export async function loadWorkerRouterRules(explicit) {
-    return await loadRouterRules(workerRouterRulesPath(explicit));
-}
-export async function saveWorkerRouterRules(text, explicit) {
-    return await saveRouterRules(workerRouterRulesPath(explicit), text);
+export async function saveExecutionRouterRules(text, explicit) {
+    return await saveRouterRules(executionRouterRulesPath(explicit), text);
 }
 export async function loadRoutingPolicy(explicit, explicitRules) {
     const path = policyPath(explicit);
-    const rules = await loadModelRouterRules(explicitRules);
+    const rules = await loadExecutionRouterRules(explicitRules);
     try {
         const text = await readFile(path, 'utf8');
         const policy = safePolicy(JSON.parse(text));

package/dist/worker-routing.js

@@ -1,5 +1,5 @@
 import { chooseWithDecision } from './decision.js';
-import { loadWorkerRouterRules } from './routing-policy.js';
+import { loadExecutionRouterRules } from './routing-policy.js';
 export const DEFAULT_CHATGPT_PREFERRED_CONCURRENCY = 10;
 export const DEFAULT_WORKER_ROUTER_PRINCIPLES = [
     'User-provided environment_rules are higher-priority routing guidance than these built-in defaults. Follow user guidance when it conflicts with a default unless doing so would violate an authoritative hard constraint.',
@@ -137,7 +137,7 @@ export async function routeWorker(candidates, requirements, options = {}) {
         const evidence = { mode: options.decisionMode ?? 'off', fallback: true };
         return { candidate: deterministic, selection: selection(deterministic, 'worker-router:constraint', evidence) };
     }
-    const rules = await loadWorkerRouterRules(options.rulesPath);
+    const rules = await loadExecutionRouterRules(options.rulesPath);
     const facts = JSON.parse(JSON.stringify({
         task: options.taskFacts ?? {},
         explicit_constraints: { runtime: requirements.runtime ?? null },

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -28,7 +28,7 @@ Every model-backed task producer normally declares:
   - `task_pr`: the managed task/PR is the authoritative result; or
   - `file`: an exact file path is the authoritative result.
 
-Relay then runs worker-router followed by model-router and persists the selected worker/adapter and model routing before launch. Explicit adapter/provider/model values are compatibility/debug constraints, not normal producer requirements.
+Relay then runs one Execution Router decision over complete worker+model routes and persists the selected worker/adapter and model routing before launch. Explicit adapter/provider/model values are compatibility/debug constraints, not normal producer requirements.
 
 ## Lifecycle contract
 
@@ -105,7 +105,7 @@ Each successful planner invocation is one real `plan-N` planning round. Relay pe
 
 A zero-task autonomous Job remains idle. After a direct orchestrator-created initial batch completes, Relay may start the first real planner round. Fixed Jobs do not automatically create planner rounds.
 
-Planner-created child Tasks remain descriptive agent work and must include worker requirements, output contract, and `storySize`; worker-router/model-router choose execution routing afterward.
+Planner-created child Tasks remain descriptive agent work and must include the output contract and `storySize`; worker requirements are optional soft routing facts unless an explicit runtime constraint is known. Execution Router chooses the complete runtime route afterward.
 
 ## Durable truth
 

package/skills/agents-relay/contracts/task-job-contract.md

@@ -56,12 +56,12 @@ Every new model-backed executable task follows this order:
 
 1. The planner describes the executable Task precisely. It does not invent a capability matrix for Codex versus ChatGPT. workerRequirements is optional compatibility metadata; an explicit runtime may be used only when the caller already knows the Task must use that runtime.
 2. worker-router gathers factual Task context, discovered worker availability, the current shared usage snapshot, built-in routing principles, and optional local free-text rules. Only authoritative legality facts such as an explicitly offline worker or an explicit caller-owned runtime constraint are hard gates. Descriptive capability labels, region/trust labels, and provider quota are decision facts rather than ordinary worker hard gates.
-3. When more than one legal model-backed worker exists, worker-router calls the generic typed decide(request, contract) primitive to choose the execution worker. Its default principles prefer ChatGPT when both workers can execute the Task, prefer Codex when native/local execution is necessary, and treat Codex/OpenAI quota pressure as a preference rather than proof that the Codex worker is unusable.
-4. model-router runs only after worker selection and independently chooses provider/model/profile for that worker. In particular, an exhausted OpenAI quota must not eliminate the Codex worker before Model Router has a chance to choose another Codex provider/profile.
-5. decide() owns no routing facts or legality policy. Its optional Laya implementation is a transient CLI subprocess per decision; unavailable/invalid decisions fall back deterministically. src/usage.ts remains the shared resource-fact source.
-6. Relay persists the selected worker and model routing on the durable task before launch.
+3. Execution Router builds complete executable routes that pair a discovered worker with one configured/authorized model profile. Only authoritative impossibility facts are hard gates: explicit runtime/routing constraints, offline/unavailable execution surfaces, zero allocatable Browser Workspace capacity, unconfigured/unauthorized models, or provider/profile state known to make execution impossible.
+4. Capabilities, task kind, trust/region/labels, quota pressure, cost, latency, runtime load, reviewer diversity, and free-text environment guidance are soft decision facts unless the caller has explicitly promoted one to a hard constraint. The full workerRequirements object must be passed into the decision facts.
+5. When more than one executable route exists, Execution Router calls the generic typed decide(request, contract) primitive exactly once to choose worker+provider/model/profile/reasoning together. If the decision engine is unavailable, invalid, or fails, Relay deterministically falls back to a usable Codex route, preferring Codex's configured default profile. Codex fallback is not a normal preference when decide() succeeds.
+6. decide() owns no discovery facts or legality policy. Its optional Laya implementation is a transient CLI subprocess per decision; src/usage.ts remains the shared resource-fact source. Relay persists the selected worker and model routing on the durable task before launch.
 
-Planner output must not hard-code codex/chatgpt, provider preference, inferred worker capabilities, or usage probes. Worker Router and Model Router are separate responsibilities. Legacy task records that already contain adapter/routing/worker-requirement metadata remain readable.
+Planner output must not hard-code codex/chatgpt, provider preference, inferred worker capabilities, or usage probes. Execution Router owns runtime route selection; legacy task records that already contain adapter/routing/worker-requirement metadata remain readable.
 
 ## Story size