agents-relay 1.0.127 → 1.0.128

package/dist/reconciler-review.js

@@ -2,7 +2,6 @@ import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
 import { schedule, transitionTaskEvent, transitionJobEvent } from './scheduler.js';
 import { implementationComplete, implementationTasks } from './runtime-status.js';
 import { eventFor } from './events.js';
-import { selectReviewer } from './reviewer-routing.js';
 import { routeWorker, workerCandidates } from './worker-routing.js';
 import { discoverModelCandidates, routeModel } from './model-routing.js';
 import { ReconcilerRuntimeBase } from './reconciler-runtime.js';
@@ -51,56 +50,57 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const configured = this.options.reviewer;
         const registered = await this.store.listAgents();
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
-        const workers = workerCandidates(this.options.adapters, registered, usage).filter(candidate => {
+        let workers = workerCandidates(this.options.adapters, registered, usage).filter(candidate => {
             if (configured?.workerId && configured.workerId !== candidate.workerId)
                 return false;
             if (configured?.adapter && configured.adapter !== candidate.adapter)
                 return false;
             return true;
         });
-        // Explicit reviewer routing is a caller-owned hard constraint and remains
-        // readable in isolated/test runtimes that do not instantiate that adapter.
+        // Explicit reviewer runtime/routing is a caller-owned hard constraint and remains
+        // usable in isolated/test runtimes that do not instantiate that adapter. It still
+        // flows through the same Worker Router path as every other executable task.
         if (workers.length === 0 && configured?.adapter && configured.routing) {
-            const candidate = {
-                workerId: configured.workerId ?? configured.adapter,
-                adapter: configured.adapter,
-                capabilities: ['model'],
-                runtime: configured.adapter,
-                routing: configured.routing,
-            };
-            return {
-                candidate,
-                selection: { workerId: candidate.workerId, adapter: candidate.adapter, capabilities: [...candidate.capabilities], selectedBy: 'worker-router:reviewer-diversity:eligible-fallback', selectedAt: new Date().toISOString() },
-                reason: 'eligible-fallback',
-            };
-        }
-        const previews = new Map();
-        for (const worker of workers) {
-            try {
-                const models = await discoverModelCandidates(worker, registered, usage);
-                const preview = await routeModel(worker, models, { decisionMode: 'off', constraints: configured?.routing });
-                previews.set(worker.workerId, { ...worker, routing: preview.routing });
-            }
-            catch {
-                continue;
-            }
-        }
-        const result = selectReviewer([...previews.values()], implementationTasks, configured?.requirements ?? { capabilities: ['model'] });
-        const selectedWorker = workers.find(worker => worker.workerId === result.selection.workerId);
-        if (selectedWorker) {
-            result.selection.resourceHealthy = selectedWorker.resourceHealthy;
-            result.selection.resourceProvider = selectedWorker.resourceProvider;
-            result.selection.resourceUsedPercent = selectedWorker.resourceUsedPercent;
-            const models = await discoverModelCandidates(selectedWorker, registered, usage);
-            const routedModel = await routeModel(selectedWorker, models, {
-                decisionEngine: this.options.decisionEngine,
-                decisionMode: this.options.decisionMode,
-                constraints: configured?.routing,
-                taskFacts: { role: 'reviewer', implementationWorkers: implementationTasks.map(task => task.workerSelection?.workerId ?? task.adapter) },
-            });
-            result.candidate.routing = routedModel.routing;
+            workers = [{
+                    workerId: configured.workerId ?? configured.adapter,
+                    adapter: configured.adapter,
+                    capabilities: ['model'],
+                    runtime: configured.adapter,
+                }];
         }
-        return result;
+        const implementationWorkers = implementationTasks.map(task => task.workerSelection?.workerId ?? task.adapter);
+        const implementationRoutes = implementationTasks.filter(task => task.routing).map(task => ({
+            provider: task.routing.provider,
+            model: task.routing.model,
+        }));
+        const taskFacts = {
+            role: 'reviewer',
+            reviewer_diversity: {
+                preference: 'Prefer a worker/provider-model identity different from implementation when otherwise suitable; this is a soft preference below user environment rules.',
+                implementation_workers: implementationWorkers,
+                implementation_routes: implementationRoutes,
+            },
+        };
+        const runtimeSummary = this.options.runtimeSummaryProvider?.();
+        const routedWorker = await routeWorker(workers, configured?.requirements ?? { capabilities: ['model'] }, {
+            decisionEngine: this.options.decisionEngine,
+            decisionMode: this.options.decisionMode,
+            taskFacts,
+            usage,
+            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,
+        });
+        return {
+            candidate: { ...routedWorker.candidate, routing: routedModel.routing },
+            selection: routedWorker.selection,
+            reason: 'worker-router',
+        };
     }
     async routeExecutableTasks(job) {
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;

package/dist/worker-routing.js

@@ -2,6 +2,7 @@ import { chooseWithDecision } from './decision.js';
 import { loadWorkerRouterRules } 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.',
     '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.',
@@ -86,12 +87,8 @@ export function satisfiesWorker(candidate, requirements) {
 export function eligibleWorkerCandidates(candidates, requirements) {
     return candidates.filter(candidate => satisfiesWorker(candidate, requirements));
 }
-function deterministicWorker(eligible, chatgptRunning = 0, preferredChatgptConcurrency = DEFAULT_CHATGPT_PREFERRED_CONCURRENCY) {
-    const chatgptAtPreferenceLimit = chatgptRunning >= preferredChatgptConcurrency;
-    return [...eligible].map((candidate, index) => ({ candidate, index })).sort((left, right) => {
-        const preference = (item) => chatgptAtPreferenceLimit ? (item.adapter === 'codex' ? 0 : 1) : (item.adapter === 'chatgpt' ? 0 : 1);
-        return preference(left.candidate) - preference(right.candidate) || left.index - right.index;
-    })[0].candidate;
+function deterministicWorker(eligible) {
+    return eligible.find(candidate => candidate.adapter === 'codex') ?? eligible[0];
 }
 function selection(selected, selectedBy, decisionEvidence) {
     return {
@@ -125,7 +122,7 @@ export async function routeWorker(candidates, requirements, options = {}) {
         throw new Error('No eligible worker satisfies the authoritative worker constraints');
     const preferredChatgptConcurrency = options.preferredChatgptConcurrency ?? DEFAULT_CHATGPT_PREFERRED_CONCURRENCY;
     const chatgptRunning = options.chatgptRunning ?? 0;
-    const deterministic = deterministicWorker(eligible, chatgptRunning, preferredChatgptConcurrency);
+    const deterministic = deterministicWorker(eligible);
     if (eligible.length === 1) {
         const evidence = { mode: options.decisionMode ?? 'off', fallback: true };
         return { candidate: deterministic, selection: selection(deterministic, 'worker-router:constraint', evidence) };
@@ -134,8 +131,9 @@ export async function routeWorker(candidates, requirements, options = {}) {
     const facts = JSON.parse(JSON.stringify({
         task: options.taskFacts ?? {},
         explicit_constraints: { runtime: requirements.runtime ?? null },
-        routing_principles: DEFAULT_WORKER_ROUTER_PRINCIPLES,
+        decision_precedence: ['authoritative_hard_constraints', 'environment_rules', 'routing_principles', 'resource_and_runtime_preferences'],
         environment_rules: rules.text,
+        routing_principles: DEFAULT_WORKER_ROUTER_PRINCIPLES,
         usage_snapshot: options.usage ?? null,
         runtime_load: {
             chatgpt_running: chatgptRunning,
@@ -158,7 +156,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. Use the task description, current usage, routing principles, and environment rules. Prefer ChatGPT when both can do the work; choose Codex when native/local execution is necessary. 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-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.',
         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": "1.0.127",
+  "version": "1.0.128",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {

package/dist/reviewer-routing.js

@@ -1,50 +0,0 @@
-function satisfies(candidate, requirements) {
-    if (candidate.availability === 'offline')
-        return false;
-    if (requirements?.runtime && candidate.runtime !== requirements.runtime)
-        return false;
-    return true;
-}
-function producedWorkerIds(tasks) {
-    return new Set(tasks
-        .filter(task => task.agentName !== 'reviewer')
-        .map(task => task.workerSelection?.workerId ?? task.adapter));
-}
-function producedRoutes(tasks) {
-    return new Set(tasks
-        .filter(task => task.agentName !== 'reviewer' && task.routing)
-        .map(task => `${task.routing?.provider}\0${task.routing?.model}`));
-}
-/** Select a reviewer after authoritative worker constraints, then prefer execution diversity. */
-export function selectReviewer(candidates, implementationTasks, requirements) {
-    const eligible = candidates.filter(candidate => satisfies(candidate, requirements));
-    if (eligible.length === 0)
-        throw new Error('No eligible reviewer worker satisfies the declared requirements');
-    const usedWorkers = producedWorkerIds(implementationTasks);
-    const usedRoutes = producedRoutes(implementationTasks);
-    const ranked = eligible.map((candidate, index) => ({
-        candidate,
-        index,
-        differentWorker: !usedWorkers.has(candidate.workerId),
-        differentRoute: !usedRoutes.has(`${candidate.routing.provider}\0${candidate.routing.model}`),
-    })).sort((left, right) => {
-        if (left.differentWorker !== right.differentWorker)
-            return left.differentWorker ? -1 : 1;
-        if (left.differentRoute !== right.differentRoute)
-            return left.differentRoute ? -1 : 1;
-        return left.index - right.index;
-    });
-    const selected = ranked[0];
-    const reason = selected.differentWorker ? 'worker-diversity' : selected.differentRoute ? 'provider-model-diversity' : 'eligible-fallback';
-    return {
-        candidate: selected.candidate,
-        selection: {
-            workerId: selected.candidate.workerId,
-            adapter: selected.candidate.adapter,
-            capabilities: [...selected.candidate.capabilities],
-            selectedBy: `worker-router:reviewer-diversity:${reason}`,
-            selectedAt: new Date().toISOString(),
-        },
-        reason,
-    };
-}