agents-relay 2.0.25 → 2.0.27

package/dist/cli-support.js

@@ -146,6 +146,22 @@ export async function publishTaskUnblocked(bus, job, taskId, reason) { if (!bus)
 catch (error) {
     process.stderr.write(`warning: unblock event unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
 } }
+export async function publishOrchestratorTaskCompletion(bus, job, task, summary) {
+    if (!bus)
+        return;
+    const events = [
+        eventFor(job.id, task.id, task.parentTaskId, 'task.started', 'running', `Task ${task.id} started by orchestrator`, 'orchestrator', { adapter: 'orchestrator' }, { agent: 'relay', component: 'agents-relay' }),
+        eventFor(job.id, task.id, task.parentTaskId, 'task.completed', 'succeeded', `Task ${task.id} completed by orchestrator`, 'orchestrator', { adapter: 'orchestrator', summary }, { agent: 'relay', component: 'agents-relay' }),
+    ];
+    for (const event of events) {
+        try {
+            await bus.publish(event);
+        }
+        catch (error) {
+            process.stderr.write(`warning: orchestrator task event unavailable for ${job.id}/${task.id}: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+}
 export async function publishDependentUnblocked(bus, targets, reason) { if (!bus)
     return; for (const target of targets) {
     try {

package/dist/decision-audit.js

@@ -1,6 +1,7 @@
 import { appendFile, mkdir, readFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
+import { modelChoiceId } from './model-routing.js';
 export const DECISION_AUDIT_SCHEMA_VERSION = 5;
 export class JsonlDecisionAuditStore {
     path;
@@ -35,8 +36,8 @@ export function taskAuditFacts(task) {
     return { job_id: task.jobId, task_id: task.id, attempt: task.attempt, execution_id: task.executionId, capabilities: [...task.capabilities], input_class: task.input.slice(0, 80).replace(/\s+/g, ' ') };
 }
 export function makeDecisionAudit(input) {
-    const candidate = (item) => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null });
-    const eligibleIds = new Set(input.eligibleCandidates.map(item => item.id));
+    const candidate = (item) => ({ id: modelChoiceId(item), provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null });
+    const eligibleIds = new Set(input.eligibleCandidates.map(modelChoiceId));
     const gate_results = input.candidates.map(item => {
         const reasons = [];
         if (item.resourceHealthy === false)
@@ -55,7 +56,7 @@ export function makeDecisionAudit(input) {
             reasons.push('policy_disabled_provider');
         if (item.profile && input.policy.policy.disabledProfiles?.includes(item.profile))
             reasons.push('policy_disabled_profile');
-        return { candidate_id: item.id, eligible: eligibleIds.has(item.id), rejection_reasons: reasons };
+        return { candidate_id: modelChoiceId(item), eligible: eligibleIds.has(modelChoiceId(item)), rejection_reasons: reasons };
     });
     return { record_type: 'decision', schema_version: DECISION_AUDIT_SCHEMA_VERSION, decision_id: decisionAuditId(), prior_decision_id: input.priorDecisionId, timestamp: input.routing.decidedAt, correlation: { job_id: input.task?.jobId, task_id: input.task?.id, execution_id: input.task?.executionId, attempt: input.task?.attempt }, task: taskAuditFacts(input.task), worker: input.worker, contract: input.contract, policy: { path: input.policy.path, hash: input.policy.hash, snapshot: input.policy.snapshot, rules: input.policy.rules }, candidates: input.candidates.map(candidate), gate_results, eligible_candidates: input.eligibleCandidates.map(candidate), selected: candidate(input.selected), engine: input.routing.decidedBy, fallback: { used: input.routing.decisionEvidence?.fallback ?? false, reason: input.routing.decisionEvidence?.error }, decision_evidence: input.routing.decisionEvidence, prior_failure: input.priorFailure };
 }

package/dist/execution-routing.js

@@ -61,7 +61,7 @@ function modelGateReasons(candidate, constraints, excludedRoutes, policy) {
     return reasons;
 }
 function routeId(worker, model) {
-    return `${worker.workerId}::${model.id}`;
+    return worker.workerId + '::' + model.id + (model.reasoning ? '@' + model.reasoning : '');
 }
 function fallbackRoute(routes) {
     const codex = routes.filter(route => route.worker.adapter === 'codex');
@@ -111,59 +111,56 @@ export async function routeExecution(workers, requirements, options = {}) {
         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 userInputRules = rules.text;
     const preferredChatgptConcurrency = options.preferredChatgptConcurrency ?? DEFAULT_CHATGPT_PREFERRED_CONCURRENCY;
     const chatgptRunning = options.chatgptRunning ?? 0;
     const taskFacts = options.taskFacts ?? {};
     const taskShape = executionTaskShape(taskFacts);
     const facts = JSON.parse(JSON.stringify({
-        job: taskFacts.job ?? null,
-        task: taskFacts.task ?? taskFacts,
-        task_shape: {
-            story_size: taskShape.storySize,
-            sustained_work: taskShape.sustainedWork,
-            preferred_worker: taskShape.preferredWorker,
-            reason: taskShape.reason,
+        context: {
+            job: taskFacts.job ?? null,
+            task: taskFacts.task ?? taskFacts,
+            task_shape: {
+                story_size: taskShape.storySize,
+                sustained_work: taskShape.sustainedWork,
+                preferred_worker: taskShape.preferredWorker,
+                reason: taskShape.reason,
+            },
+            reviewer: taskFacts.reviewer_diversity ? {
+                role: taskFacts.role ?? null,
+                reviewer_diversity: taskFacts.reviewer_diversity,
+            } : null,
         },
-        environment_rules: environmentRules,
-        reviewer_context: taskFacts.reviewer_diversity ? {
-            role: taskFacts.role ?? null,
-            reviewer_diversity: taskFacts.reviewer_diversity,
-        } : null,
-        runtime_load: {
+        user_input_rules: userInputRules,
+        runtime: {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
         },
-        candidates: routes.map(route => ({
+        eligible_routes: routes.map(route => ({
             id: route.id,
-            worker: {
-                adapter: route.worker.adapter,
-            },
-            model: {
-                provider: route.model.provider,
-                model: route.model.model,
-                profile: route.model.profile ?? null,
-                reasoning: route.model.reasoning ?? null,
-                resourceHealthy: route.model.resourceHealthy ?? 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: 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,
             },
         })),
     }));
     const decisionRequest = { facts };
     const decisionContract = {
         type: 'choice',
-        question: 'Choose the best complete execution route from the eligible choices. Use task shape, environment rules, runtime load, and code-plan quota windows as decision facts. Choose worker+model together in one decision.',
+        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);

package/dist/model-routing.js

@@ -4,7 +4,39 @@ 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 { loadExecutionRouterRules, loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
+import { loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
+export function modelChoiceId(candidate) {
+    return candidate.id + (candidate.reasoning ? '@' + candidate.reasoning : '');
+}
+async function readCodexModelCatalog(codexHome) {
+    try {
+        const parsed = JSON.parse(await readFile(join(codexHome, 'models_cache.json'), 'utf8'));
+        return Array.isArray(parsed.models)
+            ? parsed.models.filter(item => typeof item.slug === 'string' && item.visibility === 'list' && item.supported_in_api !== false)
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function catalogCandidates(models, usage) {
+    const result = [];
+    for (const item of [...models].sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999))) {
+        if (!item.slug)
+            continue;
+        const efforts = (item.supported_reasoning_levels ?? []).map(level => level.effort).filter((value) => Boolean(value));
+        const reasoningLevels = efforts.length ? efforts : item.default_reasoning_level ? [item.default_reasoning_level] : [undefined];
+        for (const reasoning of reasoningLevels) {
+            result.push(withResource({
+                id: 'catalog:openai/' + item.slug,
+                provider: 'openai',
+                model: item.slug,
+                reasoning,
+            }, usage));
+        }
+    }
+    return result;
+}
 function topLevelCodexConfig(text) {
     const result = {};
     let inSection = false;
@@ -38,36 +70,15 @@ async function readConfig(path) {
         return null;
     }
 }
-function compact(value) {
-    return value.toLowerCase().replace(/[^a-z0-9]+/g, '');
-}
-function modelAliases(model) {
-    const aliases = new Set([compact(model)]);
-    const firstDigit = model.search(/\d/);
-    if (firstDigit >= 0)
-        aliases.add(compact(model.slice(firstDigit)));
-    return [...aliases].filter(Boolean);
-}
-export function nonOpenAiModelAuthorized(provider, model, rulesText) {
-    if (provider === 'openai')
-        return true;
-    const rules = compact(rulesText);
-    if (!rules.includes(compact(provider)))
-        return false;
-    return modelAliases(model).some(alias => alias.length >= 3 && rules.includes(alias));
-}
 function withResource(candidate, usage) {
     const resource = usageForProvider(usage, candidate.provider);
     return { ...candidate, resourceHealthy: resource.healthy, resourceUsedPercent: resource.usedPercent, resourceRemainingPercent: resource.remainingPercent, resourceResetAt: resource.resetAt, resourceResetInMinutes: resource.resetInMinutes, resourceWindows: resource.windows };
 }
-export async function discoverModelCandidates(worker, registered, usage, codexHome = process.env.CODEX_HOME ?? join(homedir(), '.codex'), rulesPath) {
+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 loadExecutionRouterRules(rulesPath);
-        if (!nonOpenAiModelAuthorized(registration.runtime.provider, registration.runtime.model, rules.text))
-            return [];
         return [withResource({
-                id: `${registration.runtime.provider}/${registration.runtime.model}`,
+                id: registration.runtime.provider + '/' + registration.runtime.model,
                 provider: registration.runtime.provider,
                 model: registration.runtime.model,
             }, usage)];
@@ -76,12 +87,22 @@ 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 loadExecutionRouterRules(rulesPath);
     const candidates = [];
     if (base.model) {
         const provider = base.provider ?? 'openai';
-        if (nonOpenAiModelAuthorized(provider, base.model, rules.text))
-            candidates.push(withResource({ id: `default:${provider}/${base.model}`, provider, model: base.model, reasoning: base.reasoning }, usage));
+        candidates.push(withResource({
+            id: 'default:' + provider + '/' + base.model,
+            provider,
+            model: base.model,
+            reasoning: base.reasoning,
+        }, usage));
+    }
+    if ((base.provider ?? 'openai') === 'openai') {
+        for (const item of catalogCandidates(await readCodexModelCatalog(codexHome), usage)) {
+            if (item.model === base.model && item.reasoning === base.reasoning)
+                continue;
+            candidates.push(item);
+        }
     }
     let files = [];
     try {
@@ -94,13 +115,18 @@ export async function discoverModelCandidates(worker, registered, usage, codexHo
             continue;
         const profile = basename(file, '.config.toml');
         const provider = config.provider ?? base.provider ?? 'openai';
-        if (!nonOpenAiModelAuthorized(provider, config.model, rules.text))
-            continue;
-        candidates.push(withResource({ id: `${profile}:${provider}/${config.model}`, provider, model: config.model, profile, reasoning: config.reasoning ?? base.reasoning }, usage));
+        candidates.push(withResource({
+            id: profile + ':' + provider + '/' + config.model,
+            provider,
+            model: config.model,
+            profile,
+            reasoning: config.reasoning ?? base.reasoning,
+        }, usage));
     }
-    if (candidates.length === 0)
+    if (candidates.length === 0) {
         candidates.push(withResource({ id: 'default:openai/gpt-5.6-luna', provider: 'openai', model: 'gpt-5.6-luna' }, usage));
-    return candidates.filter((candidate, index, all) => all.findIndex(item => item.id === candidate.id) === index);
+    }
+    return candidates.filter((candidate, index, all) => all.findIndex(item => item.id === candidate.id && item.reasoning === candidate.reasoning) === index);
 }
 function sameRoute(candidate, route) {
     return (!route.provider || candidate.provider === route.provider)
@@ -144,14 +170,15 @@ export async function routeModel(worker, candidates, options = {}) {
         : await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', {
             facts: JSON.parse(JSON.stringify({
                 task: options.taskFacts ?? {},
-                environment_policy: { structured_policy: policy.snapshot, rules: policy.rules.text },
+                user_input_rules: policy.rules.text,
+                structured_policy: policy.snapshot,
                 prior_decision_id: options.priorDecisionId ?? null,
                 prior_failure: options.priorFailure ?? null,
                 worker: { id: worker.workerId, adapter: worker.adapter, capabilities: [...worker.capabilities] },
                 candidates: eligible.map(item => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null })),
             })),
-        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task? Apply hard gates first, then explicit task constraints, then current environment policy; consider every quota window and never violate task fit or continuity.', choices: eligible.map(item => item.id) }, () => deterministic.id);
-    const selected = eligible.find(item => item.id === choice.choice) ?? deterministic;
+        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task? Apply hard gates first, then explicit task constraints, then current user input rules and structured policy; consider every quota window and never violate task fit or continuity.', choices: eligible.map(modelChoiceId) }, () => modelChoiceId(deterministic));
+    const selected = eligible.find(item => modelChoiceId(item) === choice.choice) ?? deterministic;
     const routing = {
         provider: selected.provider,
         model: selected.model,

package/dist/relayd.js

@@ -13,7 +13,7 @@ import { ProjectedDurableStore } from './projected-store.js';
 import { discoverLocalRelayStoreSnapshots, SQLiteRelayStore } from './relay-store.js';
 import { githubAuthContext } from './github-auth.js';
 import { dashboardJobAction, isEntrypoint, runtimePlanner, runtimeReviewer, startService, SERVICE_DEFAULTS } from './cli.js';
-import { eventBusResolutionMessage, resolveEventBus } from './cli-support.js';
+import { eventBusResolutionMessage, publishOrchestratorTaskCompletion, resolveEventBus } from './cli-support.js';
 import { applyJobActivateAction } from './job-actions.js';
 import { applyOrchestratorCompleteAction } from './task-actions.js';
 import { dashboardJobSetState, dashboardTaskAction, dashboardTaskSetState } from './dashboard-actions.js';
@@ -280,6 +280,7 @@ export async function runDaemon(argv) {
             throw new Error(`Task ${taskId} not found`);
         await applyOrchestratorCompleteAction(task, summary);
         await store.saveTask(task);
+        await publishOrchestratorTaskCompletion(bus, job, task, summary);
         await pool.reconcileTarget(overview.job.repository, overview.job.prNumber, jobId, 'control.task.complete');
         return await store.load(jobId);
     };

package/dist/router-evals.js

@@ -12,7 +12,7 @@ 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';
+const CODEX_ROUTE = 'codex::default:openai/gpt-5.6-sol@medium';
 const CHATGPT_ROUTE = 'chatgpt/browser-worker::chatgpt/account-defaults';
 function workerForRoute(route) {
     if (route.startsWith('chatgpt/'))
@@ -27,34 +27,46 @@ export async function runRouterEvals(engine, rulesPath) {
     for (const testCase of ROUTER_EVAL_CASES) {
         const taskShape = executionTaskShape({ storySize: testCase.storySize });
         const available = testCase.chatgptAvailable;
-        const slots = testCase.chatgptSlots ?? (available ? 5 : 0);
         const choices = available ? [CODEX_ROUTE, CHATGPT_ROUTE] : [CODEX_ROUTE];
-        const facts = {
-            task_shape: {
-                story_size: taskShape.storySize,
-                sustained_work: taskShape.sustainedWork,
-                preferred_worker: taskShape.preferredWorker,
-                reason: taskShape.reason,
+        const eligibleRoutes = [
+            {
+                id: CODEX_ROUTE,
+                worker: 'codex',
+                provider: 'openai',
+                model: 'gpt-5.6-sol',
+                profile: null,
+                reasoning: 'medium',
+                code_plan: { five_hour: null, weekly: null },
             },
-            environment_rules: rules.text,
-            runtime_load: { chatgpt_running: testCase.chatgptRunning ?? 0, preferred_chatgpt_concurrency: 10 },
-            preferred_routes: choices.filter(route => taskShape.preferredWorker === 'chatgpt' ? route.startsWith('chatgpt/') : route.startsWith('codex::')),
-            candidates: [
-                {
-                    id: CODEX_ROUTE,
-                    worker: { adapter: 'codex' },
-                    model: { provider: 'openai', model: 'gpt-5.6-sol', profile: 'default', resourceHealthy: true },
+            ...(available ? [{
+                    id: CHATGPT_ROUTE,
+                    worker: 'chatgpt',
+                    provider: 'chatgpt',
+                    model: 'account-defaults',
+                    profile: null,
+                    reasoning: null,
+                    code_plan: { five_hour: null, weekly: null },
+                }] : []),
+        ];
+        const facts = {
+            context: {
+                job: { id: 'router-eval', title: 'Router eval', objective: 'Evaluate worker and model route selection.' },
+                task: { id: testCase.id, kind: 'work', storySize: testCase.storySize, input: testCase.task },
+                task_shape: {
+                    story_size: taskShape.storySize,
+                    sustained_work: taskShape.sustainedWork,
+                    preferred_worker: taskShape.preferredWorker,
+                    reason: taskShape.reason,
                 },
-                ...(available ? [{
-                        id: CHATGPT_ROUTE,
-                        worker: { adapter: 'chatgpt' },
-                        model: { provider: 'chatgpt', model: 'account-defaults', profile: 'account-defaults', resourceHealthy: true },
-                    }] : []),
-            ],
+                reviewer: null,
+            },
+            user_input_rules: rules.text,
+            runtime: { chatgpt_running: testCase.chatgptRunning ?? 0, preferred_chatgpt_concurrency: 10 },
+            eligible_routes: eligibleRoutes,
         };
         const decision = await engine.decide({ facts }, {
             type: 'choice',
-            question: 'Choose the best complete execution route. If preferred_routes is non-empty, choose from preferred_routes unless environment_rules explicitly override it or a preferred route is unhealthy/unavailable.',
+            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,
         });
         const selectedWorker = workerForRoute(decision.choice);

package/dist/worker-routing.js

@@ -2,7 +2,7 @@ import { chooseWithDecision } from './decision.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.',
+    'User-provided user_input_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.',
     'Worker Router chooses only the execution worker. Model Router chooses provider/model/profile after worker selection.',
     'Prefer ChatGPT when both workers can execute the task because it does not consume Codex coding-plan tokens and normally has access to a stronger ChatGPT Sol model.',
     'Prefer Codex when the task requires native/local execution or computer-use abilities that are unavailable through ChatGPT plus MacBridge.',
@@ -141,8 +141,8 @@ export async function routeWorker(candidates, requirements, options = {}) {
     const facts = JSON.parse(JSON.stringify({
         task: options.taskFacts ?? {},
         explicit_constraints: { runtime: requirements.runtime ?? null },
-        decision_precedence: ['authoritative_hard_constraints', 'environment_rules', 'routing_principles', 'resource_and_runtime_preferences'],
-        environment_rules: rules.text,
+        decision_precedence: ['authoritative_hard_constraints', 'user_input_rules', 'routing_principles', 'resource_and_runtime_preferences'],
+        user_input_rules: rules.text,
         routing_principles: DEFAULT_WORKER_ROUTER_PRINCIPLES,
         usage_snapshot: options.usage ?? null,
         runtime_load: {
@@ -167,7 +167,7 @@ export async function routeWorker(candidates, requirements, options = {}) {
     }));
     const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, {
         type: 'choice',
-        question: 'Choose the best execution worker for this task. Authoritative hard constraints come first. Then follow user-provided environment rules ahead of built-in routing principles when they conflict. Use task facts, reviewer-diversity context when present, current usage, and runtime load as supporting evidence. Do not choose a provider or model here.',
+        question: 'Choose the best execution worker for this task. Authoritative hard constraints come first. Then follow user_input_rules ahead of built-in routing principles when they conflict. Use task facts, reviewer-diversity context when present, current usage, and runtime load as supporting evidence. Do not choose a provider or model here.',
         choices: eligible.map(item => item.workerId),
     }, () => deterministic.workerId);
     const selected = eligible.find(item => item.workerId === choice.choice) ?? deterministic;

package/package.json

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