agents-relay 1.0.150 → 1.0.152

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

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module';
 const packageVersion = createRequire(import.meta.url)('../package.json').version;
+export const dashboardVersion = packageVersion;
 export const dashboardHtml = `<!doctype html>
 <html lang="en" data-dashboard-contract="safe-dom,named-relay-events,snapshot-events,bounded-event-history">
 <head>
@@ -163,7 +164,7 @@ export const dashboardHtml = `<!doctype html>
 </head>
 <body>
 <header>
-  <div class="brand"><h1>Agents Relay Console</h1><p class="tagline">Durable PR state is authoritative; events are observability.</p><span class="version">v${packageVersion}</span></div>
+  <div class="brand"><h1>Agents Relay Console</h1><p class="tagline">Durable PR state is authoritative; events are observability.</p><span class="version">v${dashboardVersion}</span></div>
   <div id="runtime-summary" class="runtime-summary" aria-label="Runtime summary"></div>
   <div id="rate-limit-warning" class="warning-banner" role="status" hidden></div>
   <nav role="tablist" aria-label="Console views">
@@ -240,6 +241,7 @@ export const dashboardHtml = `<!doctype html>
 // function usageBar(label, window)
 
 const MAX_EVENTS=60;
+const DASHBOARD_VERSION=${JSON.stringify(dashboardVersion)};
 const jobsTab=document.querySelector('#jobs-tab');
 const usageTab=document.querySelector('#usage-tab');
 const rulesTab=document.querySelector('#rules-tab');
@@ -352,6 +354,7 @@ function isTerminalJob(job){return ['COMPLETED','CANCELLED'].includes(job.state)
 function jobGroup(job){if(isTerminalJob(job))return 3;if(job.executionMode==='autonomous')return 1;if(job.draft||job.state==='DRAFT')return 2;return 0;}
 function compareJobs(a,b){const groupDelta=jobGroup(a)-jobGroup(b);if(groupDelta)return groupDelta;const mergePendingDelta=Number(isCompleteUnmerged(b))-Number(isCompleteUnmerged(a));return mergePendingDelta||String(b.updatedAt).localeCompare(String(a.updatedAt));}
 async function loadJSON(url){const response=await fetch(url);if(!response.ok)throw new Error(response.status+' '+response.statusText);return response.json();}
+async function refreshVersion(){try{const live=await loadJSON('/api/version');if(live?.version&&live.version!==DASHBOARD_VERSION)location.reload();}catch{}}
 function renderRateLimitStatus(status){
   if(!status?.limited){rateLimitWarning.hidden=true;rateLimitWarning.textContent='';return;}
   const until=status.cooldownUntil?new Date(status.cooldownUntil):null;
@@ -426,6 +429,7 @@ stream.addEventListener('relay',message=>{const payload=parseMessage(message);if
 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);
 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';}}
 </script>
 </body>

package/dist/dashboard.js

@@ -53,8 +53,8 @@ async function eventHistory(jobId, taskId, limit) {
     }
     return output;
 }
-export { dashboardHtml } from './dashboard-html.js';
-import { dashboardHtml } from './dashboard-html.js';
+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) {
     const legacyActions = typeof exactJobProvider === 'object' && exactJobProvider !== null ? exactJobProvider : undefined;
     const legacyExactJobProvider = !exactJobProvider && githubUsageProvider ? githubUsageProvider : undefined;
@@ -154,6 +154,11 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.end(dashboardHtml);
             return;
         }
+        if (req.url === '/api/version') {
+            res.writeHead(200, { 'content-type': 'application/json', 'cache-control': 'no-store' });
+            res.end(JSON.stringify({ version: dashboardVersion }));
+            return;
+        }
         if (req.url === '/webhooks/github' && req.method === 'POST') {
             const chunks = [];
             for await (const chunk of req)

package/dist/execution-routing.js

@@ -0,0 +1,166 @@
+import { chooseWithDecision } from './decision.js';
+import { makeDecisionAudit } from './decision-audit.js';
+import { discoverModelCandidates } from './model-routing.js';
+import { loadModelRouterRules, loadRoutingPolicy, loadWorkerRouterRules, 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.modelRulesPath);
+    const routes = [];
+    for (const worker of legalWorkers) {
+        const models = await discoverModelCandidates(worker, registered, options.usage, undefined, options.modelRulesPath);
+        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 [workerRules, modelRules] = await Promise.all([
+        loadWorkerRouterRules(options.workerRulesPath),
+        loadModelRouterRules(options.modelRulesPath),
+    ]);
+    const environmentRules = [workerRules.text, modelRules.text].filter(Boolean).join('\n');
+    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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "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