agents-relay 2.0.27 → 2.0.29

package/dist/dashboard-html.js

@@ -329,6 +329,8 @@ const displayedEventIds=new Set();
 function value(input){return input===null||input===undefined||input===''?'—':String(input);}
 function text(input){return document.createTextNode(value(input));}
 function element(name,className,child){const node=document.createElement(name);if(className)node.className=className;if(child)node.append(child);return node;}
+function yamlScalar(input){if(input===null)return 'null';if(typeof input==='boolean'||typeof input==='number')return String(input);return JSON.stringify(String(input));}
+function yamlDump(input,indent=0){const pad=' '.repeat(indent);if(Array.isArray(input)){if(!input.length)return pad+'[]';return input.map(item=>{if(item&&typeof item==='object'){return pad+'-\\n'+yamlDump(item,indent+2);}return pad+'- '+yamlScalar(item);}).join('\\n');}if(input&&typeof input==='object'){const entries=Object.entries(input);if(!entries.length)return pad+'{}';const lines=[];for(const [key,item] of entries){if(typeof item==='string'&&item.includes('\\n')){lines.push(pad+key+': |');for(const line of item.replace(/\\n$/,'').split('\\n'))lines.push(' '.repeat(indent+2)+line);continue;}if(item&&typeof item==='object'){lines.push(pad+key+':');lines.push(yamlDump(item,indent+2));}else{lines.push(pad+key+': '+yamlScalar(item));}}return lines.join('\\n');}return pad+yamlScalar(input);}
 function field(label,input){const box=element('div','detail-group');box.append(element('p','detail-label',text(label)),element('p','detail-value',text(input)));return box;}
 function markdownField(label,input){const box=element('div','detail-group');box.append(element('p','detail-label',text(label)),markdownValue(input));return box;}
 function rememberSelection(){if(selectedJob)sessionStorage.setItem('agents-relay:selected-job',selectedJob);else sessionStorage.removeItem('agents-relay:selected-job');if(selectedTaskId)sessionStorage.setItem('agents-relay:selected-task',selectedTaskId);else sessionStorage.removeItem('agents-relay:selected-task');}
@@ -451,7 +453,7 @@ function routeWorker(record){const id=record?.selected?.worker?.id||record?.work
 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{if(!selectedJob||!selectedTaskId)throw new Error('Select a Job and Task first');const response=await fetch('/api/router-test',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({jobId:selectedJob,taskId:selectedTaskId})});if(!response.ok)throw new Error(response.status+' '+await response.text());const result=await response.json();const selected=result.selected||{};const payload={selected,probabilities:result.probabilities||{},fallback:Boolean(result.fallback),hard_gates:result.gates||[],laya_input:result.decisionInput||null};routerTestResults.replaceChildren(element('strong','',text((selected.worker||'—')+' · '+(selected.model||'—'))));routerTestResults.append(element('div','subtle',text('route: '+(selected.route||'—'))),element('pre','',text(JSON.stringify(payload,null,2))));}catch(error){routerTestResults.replaceChildren(element('p','error-state',text('Router test failed: '+error.message)));}finally{rulesTest.disabled=false;}}
+async function testRouter(){rulesTest.disabled=true;routerTestResults.replaceChildren(element('p','subtle',text('Calling router with current status…')));try{if(!selectedJob||!selectedTaskId)throw new Error('Select a Job and Task first');const response=await fetch('/api/router-test',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({jobId:selectedJob,taskId:selectedTaskId})});if(!response.ok)throw new Error(response.status+' '+await response.text());const result=await response.json();const selected=result.selected||{};const payload={selected,proposed_fields:result.proposedFields||{},probabilities:result.probabilities||{},fallback:Boolean(result.fallback),hard_gates:result.gates||[],laya_input:result.decisionInput||null};routerTestResults.replaceChildren(element('strong','',text((selected.worker||'—')+' · '+(selected.model||'—'))));routerTestResults.append(element('div','subtle',text('route: '+(selected.route||'—'))),element('pre','',text(yamlDump(payload))));}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.';}

package/dist/decision-audit.js

@@ -135,12 +135,21 @@ export function makeExecutionDecisionAudit(input) {
         fallback: { used: input.routing.decisionEvidence?.fallback ?? false, reason: input.routing.decisionEvidence?.error },
         decision_evidence: input.routing.decisionEvidence,
         decision_input: {
-            facts: input.decisionRequest.facts,
-            contract: {
-                type: input.decisionContract.type,
-                question: input.decisionContract.question,
-                choices: [...input.decisionContract.choices],
-            },
+            type: 'staged_route_decision',
+            stages: input.decisionStages.map(stage => ({
+                name: stage.name,
+                facts: stage.facts,
+                contract: {
+                    type: stage.contract.type,
+                    question: stage.contract.question,
+                    choices: [...stage.contract.choices],
+                },
+                result: {
+                    choice: stage.result.choice,
+                    probabilities: stage.result.probabilities ?? null,
+                    bypassed: stage.result.bypassed ?? false,
+                },
+            })),
         },
         worker_candidates: input.workers.map(workerAuditCandidate),
         worker_gate_results: input.workerGateEvaluations.map(item => ({

package/dist/execution-routing.js

@@ -1,4 +1,3 @@
-import { chooseWithDecision } from './decision.js';
 import { makeExecutionDecisionAudit } from './decision-audit.js';
 import { discoverModelCandidates } from './model-routing.js';
 import { loadExecutionRouterRules, loadRoutingPolicy, policyAllows } from './routing-policy.js';
@@ -60,6 +59,65 @@ function modelGateReasons(candidate, constraints, excludedRoutes, policy) {
         reasons.push('reasoning_constraint');
     return reasons;
 }
+function codePlan(model) {
+    return {
+        five_hour: model.resourceWindows?.fiveHour ? {
+            remaining_percent: model.resourceWindows.fiveHour.remainingPercent ?? null,
+            reset_at: model.resourceWindows.fiveHour.resetAt ?? null,
+            reset_in_minutes: model.resourceWindows.fiveHour.resetInMinutes ?? null,
+        } : null,
+        weekly: model.resourceWindows?.weekly ? {
+            remaining_percent: model.resourceWindows.weekly.remainingPercent ?? null,
+            reset_at: model.resourceWindows.weekly.resetAt ?? null,
+            reset_in_minutes: model.resourceWindows.weekly.resetInMinutes ?? null,
+        } : null,
+    };
+}
+function workerProviderFacts(routes) {
+    const workers = new Map();
+    for (const route of routes) {
+        const list = workers.get(route.worker.workerId) ?? [];
+        list.push(route);
+        workers.set(route.worker.workerId, list);
+    }
+    return [...workers.entries()].map(([workerId, workerRoutes]) => {
+        const providers = new Map();
+        for (const route of workerRoutes) {
+            const list = providers.get(route.model.provider) ?? [];
+            list.push(route);
+            providers.set(route.model.provider, list);
+        }
+        return {
+            id: workerId,
+            adapter: workerRoutes[0].worker.adapter,
+            providers: Object.fromEntries([...providers.entries()].map(([provider, providerRoutes]) => {
+                const configured = providerRoutes.find(route => !route.model.id.startsWith('catalog:')) ?? providerRoutes[0];
+                return [provider, {
+                        default: { model: configured.model.model, reasoning: configured.model.reasoning ?? null },
+                        code_plan: codePlan(configured.model),
+                    }];
+            })),
+        };
+    });
+}
+async function decideStage(engine, name, facts, question, choices) {
+    if (choices.length === 0)
+        throw new Error('No choices available for ' + name + ' stage');
+    const contract = { type: 'choice', question, choices };
+    if (choices.length === 1)
+        return { name, facts, contract, result: { choice: choices[0], bypassed: true } };
+    const decision = await engine.decide({ facts }, contract);
+    if (decision.type !== 'choice')
+        throw new Error('Execution router expected a choice result for ' + name);
+    return { name, facts, contract, result: { choice: decision.choice, probabilities: decision.probabilities } };
+}
+function stageFacts(baseFacts, selected, candidates) {
+    return JSON.parse(JSON.stringify({
+        ...baseFacts,
+        selected,
+        ...candidates,
+    }));
+}
 function routeId(worker, model) {
     return worker.workerId + '::' + model.id + (model.reasoning ? '@' + model.reasoning : '');
 }
@@ -116,7 +174,7 @@ export async function routeExecution(workers, requirements, options = {}) {
     const chatgptRunning = options.chatgptRunning ?? 0;
     const taskFacts = options.taskFacts ?? {};
     const taskShape = executionTaskShape(taskFacts);
-    const facts = JSON.parse(JSON.stringify({
+    const baseFacts = JSON.parse(JSON.stringify({
         context: {
             job: taskFacts.job ?? null,
             task: taskFacts.task ?? taskFacts,
@@ -136,36 +194,109 @@ export async function routeExecution(workers, requirements, options = {}) {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
         },
-        eligible_routes: routes.map(route => ({
-            id: route.id,
-            worker: route.worker.adapter,
-            provider: route.model.provider,
-            model: route.model.model,
-            profile: route.model.profile ?? null,
-            reasoning: route.model.reasoning ?? null,
-            code_plan: {
-                five_hour: route.model.resourceWindows?.fiveHour ? {
-                    remaining_percent: route.model.resourceWindows.fiveHour.remainingPercent ?? null,
-                    reset_at: route.model.resourceWindows.fiveHour.resetAt ?? null,
-                    reset_in_minutes: route.model.resourceWindows.fiveHour.resetInMinutes ?? null,
-                } : null,
-                weekly: route.model.resourceWindows?.weekly ? {
-                    remaining_percent: route.model.resourceWindows.weekly.remainingPercent ?? null,
-                    reset_at: route.model.resourceWindows.weekly.resetAt ?? null,
-                    reset_in_minutes: route.model.resourceWindows.weekly.resetInMinutes ?? null,
-                } : null,
-            },
-        })),
+        worker_candidates: workerProviderFacts(routes),
+        routing_instruction: 'Interpret user_input_rules directly. Choose among the runtime-provided legal candidates at each stage. Relay does not parse user_input_rules into model or reasoning choices.',
     }));
-    const decisionRequest = { facts };
-    const decisionContract = {
-        type: 'choice',
-        question: 'Choose one eligible complete execution route. Treat context.task_shape.preferred_worker as the default worker-fit signal; user_input_rules and concrete runtime or code-plan resource facts may override it. The choice identifies worker, provider, model, profile, and reasoning together.',
-        choices: routes.map(route => route.id),
-    };
-    const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', decisionRequest, decisionContract, () => 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';
+    let selected = fallback;
+    let evidence = { mode: options.decisionMode ?? 'off', fallback: true };
+    const decisionStages = [];
+    if ((options.decisionMode ?? 'off') !== 'off' && options.decisionEngine) {
+        try {
+            const providerKeys = [...new Set(routes.map(route => route.worker.workerId + '::' + route.model.provider))];
+            const providerOptions = providerKeys.map(key => {
+                const splitAt = key.lastIndexOf('::');
+                const worker = key.slice(0, splitAt);
+                const provider = key.slice(splitAt + 2);
+                const providerRoutes = routes.filter(route => route.worker.workerId === worker && route.model.provider === provider);
+                const configured = providerRoutes.find(route => !route.model.id.startsWith('catalog:')) ?? providerRoutes[0];
+                return {
+                    key,
+                    worker,
+                    provider,
+                    default_model: configured.model.model,
+                    label: 'worker=' + worker + ' provider=' + provider + ' default_model=' + configured.model.model,
+                };
+            });
+            const providerFacts = stageFacts(baseFacts, {}, {
+                provider_candidates: providerOptions.map(({ label: _label, key: _key, ...option }) => option),
+            });
+            const providerStage = await decideStage(options.decisionEngine, 'provider', providerFacts, 'Choose the best worker/provider pair. Interpret user_input_rules directly together with task context, runtime load, provider defaults, and code-plan quota. When user_input_rules explicitly names providers as routing options, prefer those named providers when applicable; treat unmentioned providers as fallbacks unless other facts clearly require them.', providerOptions.map(option => option.label));
+            decisionStages.push(providerStage);
+            const selectedProvider = providerOptions.find(option => option.label === providerStage.result.choice);
+            if (!selectedProvider)
+                throw new Error('Laya selected an unknown worker/provider option');
+            const workerId = selectedProvider.worker;
+            const provider = selectedProvider.provider;
+            const providerRoutes = routes.filter(route => route.worker.workerId === workerId && route.model.provider === provider);
+            if (providerRoutes.length === 0)
+                throw new Error('Laya selected a worker/provider pair with no eligible routes');
+            const modelGroups = new Map();
+            for (const route of providerRoutes) {
+                const group = modelGroups.get(route.model.model) ?? [];
+                group.push(route);
+                modelGroups.set(route.model.model, group);
+            }
+            const modelChoices = [...modelGroups.keys()];
+            const modelOptions = modelChoices.map(model => {
+                const group = modelGroups.get(model) ?? [];
+                const configured = group.some(route => !route.model.id.startsWith('catalog:'));
+                return {
+                    model,
+                    configured_default: configured,
+                    supported_reasoning: [...new Set(group.map(route => route.model.reasoning).filter((value) => Boolean(value)))],
+                    label: 'model=' + model + ' configured_default=' + String(configured),
+                };
+            });
+            const modelFacts = stageFacts(baseFacts, { worker: workerId, provider }, {
+                model_candidates: modelOptions.map(({ label: _label, ...option }) => option),
+            });
+            const modelStage = await decideStage(options.decisionEngine, 'model', modelFacts, 'Choose the best model for the selected worker/provider. Interpret user_input_rules directly. Candidate model names come from current runtime/configuration and are not derived from the free-text rules. If user_input_rules explicitly maps a model to the current task type, size, complexity, or other current condition, follow that mapping instead of the provider default.', modelOptions.map(option => option.label));
+            decisionStages.push(modelStage);
+            const selectedModel = modelOptions.find(option => option.label === modelStage.result.choice);
+            if (!selectedModel)
+                throw new Error('Laya selected an unknown model option');
+            const modelRoutes = modelGroups.get(selectedModel.model) ?? [];
+            const reasoningChoices = [...new Set(modelRoutes.map(route => route.model.reasoning ?? 'provider-default'))];
+            const reasoningOptions = reasoningChoices.map(reasoning => ({
+                reasoning,
+                label: 'reasoning=' + reasoning,
+            }));
+            const reasoningFacts = stageFacts(baseFacts, { worker: workerId, provider, model: selectedModel.model }, {
+                reasoning_candidates: reasoningChoices,
+            });
+            const reasoningStage = await decideStage(options.decisionEngine, 'reasoning', reasoningFacts, 'Choose the reasoning level for the selected model. Interpret user_input_rules directly. If user_input_rules explicitly assigns a reasoning level to the selected model for the current conditions, follow that assignment. Use provider-default only when the model does not expose a specific reasoning level.', reasoningOptions.map(option => option.label));
+            decisionStages.push(reasoningStage);
+            const selectedReasoning = reasoningOptions.find(option => option.label === reasoningStage.result.choice);
+            if (!selectedReasoning)
+                throw new Error('Laya selected an unknown reasoning option');
+            const reasoning = selectedReasoning.reasoning === 'provider-default' ? null : selectedReasoning.reasoning;
+            const proposed = modelRoutes.find(route => (route.model.reasoning ?? null) === reasoning);
+            if (!proposed)
+                throw new Error('Laya selected a model/reasoning combination with no eligible route');
+            selected = proposed;
+            evidence = {
+                mode: options.decisionMode ?? 'active',
+                engine: options.decisionEngine.name,
+                proposed: providerStage.result.choice + '/' + selectedModel.model + '@' + selectedReasoning.reasoning,
+                proposedFields: {
+                    worker: selected.worker.workerId,
+                    provider: selected.model.provider,
+                    model: selected.model.model,
+                    reasoning: selected.model.reasoning ?? '',
+                },
+                fallback: false,
+            };
+        }
+        catch (error) {
+            evidence = {
+                mode: options.decisionMode ?? 'active',
+                engine: options.decisionEngine.name,
+                fallback: true,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    const selectedBy = evidence.engine && !evidence.fallback ? 'execution-router:laya' : 'execution-router:fallback';
     const routing = {
         provider: selected.model.provider,
         model: selected.model.model,
@@ -173,7 +304,7 @@ export async function routeExecution(workers, requirements, options = {}) {
         reasoning: options.routingConstraints?.reasoning ?? selected.model.reasoning,
         decidedBy: selectedBy,
         decidedAt: new Date().toISOString(),
-        decisionEvidence: choice.evidence,
+        decisionEvidence: evidence,
     };
     const audit = makeExecutionDecisionAudit({
         task: options.auditTask,
@@ -192,15 +323,14 @@ export async function routeExecution(workers, requirements, options = {}) {
         },
         policy,
         routing,
-        decisionRequest,
-        decisionContract,
+        decisionStages,
     });
     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),
+        selection: workerSelection(selected.worker, selectedBy, evidence),
         model: selected.model,
         audit,
     };

package/dist/relayd.js

@@ -397,6 +397,7 @@ export async function runDaemon(argv) {
                 reasoning: result.candidate.routing.reasoning,
             },
             probabilities: result.candidate.routing.decisionEvidence?.probabilities ?? {},
+            proposedFields: result.candidate.routing.decisionEvidence?.proposedFields ?? {},
             fallback: result.candidate.routing.decisionEvidence?.fallback ?? false,
             current: {
                 chatgptRunning: runtime.workers.chatgpt,

package/dist/router-evals.js

@@ -12,12 +12,12 @@ export const ROUTER_EVAL_CASES = [
     { 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@medium';
-const CHATGPT_ROUTE = 'chatgpt/browser-worker::chatgpt/account-defaults';
+const CODEX_ROUTE = 'codex/openai/default';
+const CHATGPT_ROUTE = 'chatgpt/browser-worker/chatgpt/default';
 function workerForRoute(route) {
     if (route.startsWith('chatgpt/'))
         return 'chatgpt';
-    if (route.startsWith('codex::'))
+    if (route.startsWith('codex/'))
         return 'codex';
     return 'unknown';
 }
@@ -28,29 +28,31 @@ export async function runRouterEvals(engine, rulesPath) {
         const taskShape = executionTaskShape({ storySize: testCase.storySize });
         const available = testCase.chatgptAvailable;
         const choices = available ? [CODEX_ROUTE, CHATGPT_ROUTE] : [CODEX_ROUTE];
-        const eligibleRoutes = [
+        const workerCandidates = [
             {
-                id: CODEX_ROUTE,
-                worker: 'codex',
-                provider: 'openai',
-                model: 'gpt-5.6-sol',
-                profile: null,
-                reasoning: 'medium',
-                code_plan: { five_hour: null, weekly: null },
+                id: 'codex',
+                adapter: 'codex',
+                providers: {
+                    openai: {
+                        default: { model: 'gpt-5.6-sol', reasoning: 'medium' },
+                        code_plan: { five_hour: null, weekly: null },
+                    },
+                },
             },
             ...(available ? [{
-                    id: CHATGPT_ROUTE,
-                    worker: 'chatgpt',
-                    provider: 'chatgpt',
-                    model: 'account-defaults',
-                    profile: null,
-                    reasoning: null,
-                    code_plan: { five_hour: null, weekly: null },
+                    id: 'chatgpt/browser-worker',
+                    adapter: 'chatgpt',
+                    providers: {
+                        chatgpt: {
+                            default: { model: 'account-defaults', reasoning: null },
+                            code_plan: { five_hour: null, weekly: null },
+                        },
+                    },
                 }] : []),
         ];
-        const facts = {
+        const facts = JSON.parse(JSON.stringify({
             context: {
-                job: { id: 'router-eval', title: 'Router eval', objective: 'Evaluate worker and model route selection.' },
+                job: { id: 'router-eval', title: 'Router eval', objective: 'Evaluate worker and provider route selection.' },
                 task: { id: testCase.id, kind: 'work', storySize: testCase.storySize, input: testCase.task },
                 task_shape: {
                     story_size: taskShape.storySize,
@@ -62,13 +64,16 @@ export async function runRouterEvals(engine, rulesPath) {
             },
             user_input_rules: rules.text,
             runtime: { chatgpt_running: testCase.chatgptRunning ?? 0, preferred_chatgpt_concurrency: 10 },
-            eligible_routes: eligibleRoutes,
-        };
+            worker_candidates: workerCandidates,
+            routing_instruction: 'For each selected provider, use its default model and reasoning unless user_input_rules explicitly provides another model/reasoning option.',
+        }));
         const decision = await engine.decide({ facts }, {
             type: 'choice',
-            question: 'Choose one eligible complete execution route. Treat context.task_shape.preferred_worker as the default worker-fit signal; user_input_rules and concrete runtime or code-plan resource facts may override it. The choice identifies worker, provider, model, profile, and reasoning together.',
+            question: 'Choose one legal route. Each provider default is available. Additional model/reasoning routes exist only when explicitly provided by user_input_rules. Use context, code-plan quota, runtime load, and user_input_rules.',
             choices,
         });
+        if (decision.type !== 'choice')
+            throw new Error('Router eval expected a single-choice decision');
         const selectedWorker = workerForRoute(decision.choice);
         results.push({
             ...testCase,

package/package.json

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