agents-relay 1.0.92 → 1.0.93

package/README.md

@@ -69,6 +69,8 @@ snapshot as JSON on stdin and must return `{ "objective_status": "in_progress"|"
 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 deterministic fallback and `off|shadow|active` rollout. See [Worker Router, Model 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.js

@@ -12,6 +12,7 @@ import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } fro
 import { eventFor } from './events.js';
 import { serveDashboard } from './dashboard.js';
 import { codexAndZaiUsageRegistry } from './usage.js';
+import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { extendRetryBudget, transitionJobEvent, transitionTaskEvent } from './scheduler.js';
@@ -411,7 +412,7 @@ async function runJobCommand(action, args) {
 }
 export function runtimePlanner(args) { const plannerCommand = arg([...args], '--planner-command'); const modelRuntime = arg([...args], '--codex', 'codex'); return plannerCommand ? new CommandObjectivePlanner(plannerCommand) : new AgentObjectivePlanner(modelRuntime); }
 export function runtimeReviewer() { return { requirements: { capabilities: ['model'] } }; }
-export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: job => resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()) }); }
+export function runtime(store, args, bus, usageRegistry = codexAndZaiUsageRegistry()) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); const policy = chatGptTabClosePolicy(args); const planner = runtimePlanner(args); return new Reconciler(store, { owner: arg(args, '--owner', `cli-${process.pid}`), maxConcurrent: Number(arg(args, '--concurrency', '4')), leaseMs: Number(arg(args, '--lease-ms', '300000')), adapters: [new CodexAdapter(modelRuntime), new ChatGptAdapter({ tabClosePolicy: policy })], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: job => resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()) }); }
 export function dashboardTaskAction(store, reconciler, action) {
     return async (jobId, taskId) => {
         const job = await store.load(jobId);

package/dist/decision.js

@@ -0,0 +1,190 @@
+import { spawn } from 'node:child_process';
+function validateContract(contract) {
+    if (contract.type !== 'choice')
+        throw new Error(`Unsupported decision contract ${contract.type}`);
+    if (!contract.question.trim())
+        throw new Error('Decision choice question is required');
+    if (contract.choices.length === 0)
+        throw new Error('Decision choice contract requires at least one choice');
+    if (new Set(contract.choices).size !== contract.choices.length)
+        throw new Error('Decision choice contract contains duplicate choices');
+    if (contract.choices.some(choice => !choice.trim()))
+        throw new Error('Decision choice contract contains an empty choice');
+}
+function assertJson(value, path = 'facts') {
+    if (value === null || typeof value === 'boolean' || typeof value === 'string')
+        return;
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value))
+            throw new Error(`${path} contains a non-finite number`);
+        return;
+    }
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertJson(item, `${path}[${index}]`));
+        return;
+    }
+    if (typeof value === 'object') {
+        for (const [key, item] of Object.entries(value)) {
+            if (item === undefined)
+                throw new Error(`${path}.${key} is undefined`);
+            assertJson(item, `${path}.${key}`);
+        }
+        return;
+    }
+    throw new Error(`${path} is not JSON-safe`);
+}
+export function validateDecisionRequest(request, contract) {
+    validateContract(contract);
+    assertJson(request.facts);
+}
+function probabilities(value, choices) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const source = value;
+    const result = {};
+    for (const choice of choices) {
+        const score = source[choice];
+        if (typeof score !== 'number' || !Number.isFinite(score) || score < 0 || score > 1)
+            return undefined;
+        result[choice] = score;
+    }
+    return Object.keys(result).length === choices.length ? result : undefined;
+}
+export function parseChoiceDecision(raw, contract) {
+    validateContract(contract);
+    if (!raw || typeof raw !== 'object')
+        throw new Error('Decision output must be a JSON object');
+    const envelope = raw;
+    const nested = envelope.answers && typeof envelope.answers === 'object' && !Array.isArray(envelope.answers)
+        ? envelope.answers.decision
+        : undefined;
+    const answer = nested && typeof nested === 'object' && !Array.isArray(nested) ? nested : envelope;
+    const choice = typeof answer.choice === 'string' ? answer.choice : '';
+    if (!contract.choices.includes(choice))
+        throw new Error(`Decision choice ${choice || '<missing>'} is outside the contract`);
+    const result = { type: 'choice', choice };
+    const parsedProbabilities = probabilities(answer.probabilities, contract.choices);
+    if (parsedProbabilities)
+        result.probabilities = parsedProbabilities;
+    return result;
+}
+/**
+ * Stateless Laya invocation. The command receives one JSON request on stdin and
+ * must emit one JSON decision on stdout. It is intentionally a subprocess per
+ * decision: no daemon, resident model, socket, or PM2 lifecycle is introduced.
+ */
+export class LayaCliDecisionEngine {
+    name = 'laya-cli';
+    command;
+    args;
+    timeoutMs;
+    env;
+    constructor(options = {}) {
+        this.command = options.command ?? process.env.AGENTS_RELAY_LAYA_COMMAND ?? 'npx';
+        this.args = options.args ?? layaArgsFromEnv();
+        this.timeoutMs = options.timeoutMs ?? Number(process.env.AGENTS_RELAY_LAYA_TIMEOUT_MS ?? 30_000);
+        this.env = options.env;
+    }
+    async decide(request, contract) {
+        validateDecisionRequest(request, contract);
+        const payload = {
+            state: request.facts,
+            questions: {
+                decision: {
+                    type: contract.type,
+                    instructions: contract.question,
+                    criteria: [...contract.choices],
+                },
+            },
+        };
+        const stdout = await this.run(JSON.stringify(payload));
+        let parsed;
+        try {
+            parsed = JSON.parse(stdout);
+        }
+        catch {
+            throw new Error('Laya CLI returned invalid JSON');
+        }
+        return parseChoiceDecision(parsed, contract);
+    }
+    async run(stdin) {
+        return await new Promise((resolve, reject) => {
+            const child = spawn(this.command, [...this.args], { stdio: ['pipe', 'pipe', 'pipe'], env: this.env ?? process.env });
+            const stdout = [];
+            const stderr = [];
+            let settled = false;
+            const finish = (error, output) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                if (error)
+                    reject(error);
+                else
+                    resolve(output ?? '');
+            };
+            const timer = setTimeout(() => {
+                child.kill('SIGKILL');
+                finish(new Error(`Laya CLI timed out after ${this.timeoutMs}ms`));
+            }, this.timeoutMs);
+            child.stdout.on('data', chunk => stdout.push(Buffer.from(chunk)));
+            child.stderr.on('data', chunk => stderr.push(Buffer.from(chunk)));
+            child.once('error', error => finish(error));
+            child.once('close', code => {
+                if (code !== 0) {
+                    const detail = Buffer.concat(stderr).toString('utf8').trim();
+                    finish(new Error(`Laya CLI exited ${code}${detail ? `: ${detail}` : ''}`));
+                    return;
+                }
+                finish(undefined, Buffer.concat(stdout).toString('utf8').trim());
+            });
+            child.stdin.end(`${stdin}\n`);
+        });
+    }
+}
+function layaArgsFromEnv() {
+    const configured = process.env.AGENTS_RELAY_LAYA_ARGS;
+    if (!configured)
+        return ['-y', 'laya', 'decide', '--json'];
+    try {
+        const parsed = JSON.parse(configured);
+        if (!Array.isArray(parsed) || parsed.some(item => typeof item !== 'string'))
+            throw new Error('not a string array');
+        return parsed;
+    }
+    catch {
+        throw new Error('AGENTS_RELAY_LAYA_ARGS must be a JSON string array');
+    }
+}
+export function decisionMode(value = process.env.AGENTS_RELAY_DECISION_MODE) {
+    return value === 'shadow' || value === 'active' ? value : 'off';
+}
+export async function chooseWithDecision(engine, mode, request, contract, fallback) {
+    validateDecisionRequest(request, contract);
+    const deterministic = fallback();
+    if (!contract.choices.includes(deterministic))
+        throw new Error('Deterministic fallback is outside the decision contract');
+    if (mode === 'off' || !engine)
+        return { choice: deterministic, evidence: { mode, fallback: true } };
+    try {
+        const result = await engine.decide(request, contract);
+        if (result.type !== 'choice')
+            throw new Error(`Unexpected decision result ${result.type}`);
+        if (mode === 'shadow') {
+            return {
+                choice: deterministic,
+                evidence: { mode, engine: engine.name, proposed: result.choice, probabilities: result.probabilities, fallback: true },
+            };
+        }
+        return {
+            choice: result.choice,
+            evidence: { mode, engine: engine.name, proposed: result.choice, probabilities: result.probabilities, fallback: false },
+        };
+    }
+    catch (error) {
+        return {
+            choice: deterministic,
+            evidence: { mode, engine: engine.name, fallback: true, error: error instanceof Error ? error.message : String(error) },
+        };
+    }
+}

package/dist/model-routing.js

@@ -0,0 +1,124 @@
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { readdir, readFile } from 'node:fs/promises';
+import { chooseWithDecision } from './decision.js';
+import { usageForProvider } from './worker-routing.js';
+function topLevelCodexConfig(text) {
+    const result = {};
+    let inSection = false;
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        if (line.startsWith('[')) {
+            inSection = true;
+            continue;
+        }
+        if (inSection)
+            continue;
+        const match = line.match(/^(model|model_provider|model_reasoning_effort)\s*=\s*"([^"]+)"/);
+        if (!match)
+            continue;
+        if (match[1] === 'model')
+            result.model = match[2];
+        else if (match[1] === 'model_provider')
+            result.provider = match[2];
+        else
+            result.reasoning = match[2];
+    }
+    return result;
+}
+async function readConfig(path) {
+    try {
+        return topLevelCodexConfig(await readFile(path, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function withResource(candidate, usage) {
+    const resource = usageForProvider(usage, candidate.provider);
+    return { ...candidate, resourceHealthy: resource.healthy, resourceUsedPercent: resource.usedPercent };
+}
+export async function discoverModelCandidates(worker, registered, usage, codexHome = process.env.CODEX_HOME ?? join(homedir(), '.codex')) {
+    const registration = registered.find(item => item.id === worker.workerId);
+    if (registration?.runtime.provider && registration.runtime.model) {
+        return [withResource({
+                id: `${registration.runtime.provider}/${registration.runtime.model}`,
+                provider: registration.runtime.provider,
+                model: registration.runtime.model,
+            }, usage)];
+    }
+    if (worker.adapter === 'chatgpt') {
+        return [withResource({ id: 'chatgpt/account-defaults', provider: 'chatgpt', model: 'account-defaults' }, usage)];
+    }
+    const base = await readConfig(join(codexHome, 'config.toml')) ?? {};
+    const candidates = [];
+    if (base.model)
+        candidates.push(withResource({ id: `default:${base.provider ?? 'openai'}/${base.model}`, provider: base.provider ?? 'openai', model: base.model, reasoning: base.reasoning }, usage));
+    let files = [];
+    try {
+        files = (await readdir(codexHome)).filter(name => name.endsWith('.config.toml')).sort();
+    }
+    catch { /* no profiles */ }
+    for (const file of files) {
+        const config = await readConfig(join(codexHome, file));
+        if (!config?.model)
+            continue;
+        const profile = basename(file, '.config.toml');
+        const provider = config.provider ?? base.provider ?? 'openai';
+        candidates.push(withResource({ id: `${profile}:${provider}/${config.model}`, provider, model: config.model, profile, reasoning: config.reasoning ?? base.reasoning }, usage));
+    }
+    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);
+}
+function eligibleModels(candidates, constraints) {
+    return candidates.filter(candidate => {
+        if (candidate.resourceHealthy === false)
+            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 deterministicModel(candidates) {
+    return [...candidates].map((candidate, index) => ({ candidate, index })).sort((left, right) => {
+        const pressure = (item) => item.resourceUsedPercent === undefined ? 1 : item.resourceUsedPercent >= 90 ? 2 : 0;
+        return pressure(left.candidate) - pressure(right.candidate) || left.index - right.index;
+    })[0].candidate;
+}
+export async function routeModel(worker, candidates, options = {}) {
+    const eligible = eligibleModels(candidates, options.constraints);
+    if (eligible.length === 0)
+        throw new Error(`No eligible model profile is usable by worker ${worker.workerId}`);
+    const deterministic = deterministicModel(eligible);
+    const choice = eligible.length === 1
+        ? { choice: deterministic.id, evidence: { mode: options.decisionMode ?? 'off', fallback: true } }
+        : await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', {
+            facts: JSON.parse(JSON.stringify({
+                task: options.taskFacts ?? {},
+                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 })),
+            })),
+        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task?', choices: eligible.map(item => item.id) }, () => deterministic.id);
+    const selected = eligible.find(item => item.id === choice.choice) ?? deterministic;
+    return {
+        candidate: selected,
+        routing: {
+            provider: selected.provider,
+            model: selected.model,
+            profile: selected.profile,
+            reasoning: options.constraints?.reasoning ?? selected.reasoning,
+            decidedBy: choice.evidence.engine && !choice.evidence.fallback ? 'model-router:laya' : 'model-router',
+            decidedAt: new Date().toISOString(),
+            decisionEvidence: choice.evidence,
+        },
+    };
+}

package/dist/reconciler-review.js

@@ -3,7 +3,8 @@ import { schedule, transitionTaskEvent, transitionJobEvent } from './scheduler.j
 import { implementationComplete } from './runtime-status.js';
 import { eventFor } from './events.js';
 import { selectReviewer } from './reviewer-routing.js';
-import { selectWorker, usageForProvider, workerCandidates } from './worker-routing.js';
+import { routeWorker, workerCandidates } from './worker-routing.js';
+import { discoverModelCandidates, routeModel } from './model-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; }
@@ -52,43 +53,76 @@ 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 candidates = workerCandidates(this.options.adapters, registered, usage);
-        let constrained = candidates.filter(candidate => {
+        const 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;
-            if (configured?.routing?.provider && configured.routing.provider !== candidate.routing.provider)
-                return false;
-            if (configured?.routing?.model && configured.routing.model !== candidate.routing.model)
-                return false;
             return true;
-        }).map(candidate => ({ ...candidate, routing: configured?.routing ? { ...candidate.routing, ...configured.routing } : candidate.routing }));
+        });
         // Explicit reviewer routing is a caller-owned hard constraint and remains
         // readable in isolated/test runtimes that do not instantiate that adapter.
-        if (constrained.length === 0 && configured?.adapter && configured.routing) {
-            constrained = [{ workerId: configured.workerId ?? configured.adapter, adapter: configured.adapter, capabilities: ['model'], runtime: configured.adapter, routing: configured.routing }];
+        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;
         }
-        const result = selectReviewer(constrained, implementationTasks, configured?.requirements ?? { capabilities: ['model'] });
-        const resource = usageForProvider(usage, result.candidate.routing.provider);
-        result.selection.resourceHealthy = resource.healthy;
-        result.selection.resourceProvider = resource.healthy === undefined ? undefined : result.candidate.routing.provider;
-        result.selection.resourceUsedPercent = resource.usedPercent;
         return result;
     }
     async routeExecutableTasks(job) {
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
-        const candidates = workerCandidates(this.options.adapters, await this.store.listAgents(), usage);
+        const registered = await this.store.listAgents();
+        const candidates = workerCandidates(this.options.adapters, registered, usage);
         for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
             const requirements = task.workerRequirements ?? { capabilities: task.capabilities.length > 0 ? task.capabilities : ['model'] };
-            const routed = selectWorker(candidates, requirements);
-            task.workerSelection = routed.selection;
-            task.adapter = routed.candidate.adapter;
-            task.routing = routed.candidate.routing;
+            const taskFacts = { id: task.id, kind: task.kind ?? 'work', storySize: task.storySize ?? 'M', capabilities: task.capabilities };
+            const routedWorker = await routeWorker(candidates, requirements, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts });
+            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 routedModel = await routeModel(routedWorker.candidate, models, { decisionEngine: this.options.decisionEngine, decisionMode: this.options.decisionMode, taskFacts, constraints: routingConstraints });
+            task.workerSelection = routedWorker.selection;
+            task.adapter = routedWorker.candidate.adapter;
+            task.routing = routedModel.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 ${routed.selection.workerId} selected for task ${task.id}`, 'orchestrator', { workerSelection: routed.selection, workerRequirements: requirements }, { agent: 'relay', component: 'agents-relay' }));
+            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, 'model.selected', 'queued', `Selected ${task.routing.model} · thinking ${task.routing.reasoning ?? 'unknown'}`, 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
         }
     }
     isSupersededTask(task) {

package/dist/relayd.js

@@ -15,6 +15,7 @@ import { dashboardJobAction, dashboardTaskAction, isEntrypoint, runtimePlanner,
 import { codexAndZaiUsageRegistry } from './usage.js';
 import { defaultWorkspaceRoot, discoverWorkspaceRepositories, resolveManagedProjectPath } from './workspace.js';
 import { deriveJobRuntimeStatus } from './runtime-status.js';
+import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 export const daemonHelp = `Agents Relay daemon runs the dashboard and worker pool.
 
 Usage:
@@ -71,7 +72,7 @@ export async function runDaemon(argv) {
     const repositoryPaths = new Map(discoveredRepositories.map(item => [item.repository, item.path]));
     const explicitProjectPath = value(argv, '--project-path');
     const usageRegistry = codexAndZaiUsageRegistry();
-    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
+    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
     const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler);

package/dist/worker-routing.js

@@ -1,16 +1,23 @@
+import { chooseWithDecision } from './decision.js';
 export function usageForProvider(snapshot, provider) {
     const usage = snapshot?.providers.find(item => item.id === provider)?.usage;
-    if (!usage || !usage.available)
-        return {};
-    const usedPercent = Math.max(usage.fiveHour?.usedPercent ?? 0, usage.weekly?.usedPercent ?? 0);
-    return { healthy: usedPercent < 100, usedPercent };
+    if (usage?.available) {
+        const usedPercent = Math.max(usage.fiveHour?.usedPercent ?? 0, usage.weekly?.usedPercent ?? 0);
+        return { healthy: usedPercent < 100, usedPercent };
+    }
+    const credits = snapshot?.credits.find(item => item.id === provider)?.credits;
+    if (credits?.available) {
+        const knownRemaining = credits.balances.map(item => item.remaining).filter((value) => typeof value === 'number' && Number.isFinite(value));
+        if (knownRemaining.length > 0)
+            return { healthy: knownRemaining.some(value => value > 0) };
+    }
+    return {};
 }
 export function workerCandidates(adapters, registered, snapshot) {
     return adapters.filter(adapter => adapter.name !== 'orchestrator').flatMap(adapter => {
-        const defaults = adapter.name === 'chatgpt' ? { provider: 'chatgpt', model: 'account-defaults' } : { provider: 'openai', model: 'gpt-5.6-luna' };
         const workers = registered.filter(worker => worker.runtime.adapter === adapter.name);
         return (workers.length > 0 ? workers : [undefined]).map(worker => {
-            const provider = worker?.runtime.provider ?? defaults.provider;
+            const provider = worker?.runtime.provider ?? (adapter.name === 'chatgpt' ? 'chatgpt' : 'openai');
             const resource = usageForProvider(snapshot, provider);
             return {
                 workerId: worker?.id ?? adapter.id,
@@ -27,12 +34,11 @@ export function workerCandidates(adapters, registered, snapshot) {
                 resourceHealthy: resource.healthy,
                 resourceProvider: provider,
                 resourceUsedPercent: resource.usedPercent,
-                routing: { provider, model: worker?.runtime.model ?? defaults.model, decidedBy: 'model-router', decidedAt: new Date().toISOString() },
             };
         });
     });
 }
-function satisfies(candidate, requirements) {
+export function satisfiesWorker(candidate, requirements) {
     if (candidate.availability && candidate.availability !== 'available')
         return false;
     if (candidate.resourceHealthy === false)
@@ -51,26 +57,61 @@ function satisfies(candidate, requirements) {
         return false;
     return true;
 }
-export function selectWorker(candidates, requirements) {
-    const eligible = candidates.filter(candidate => satisfies(candidate, requirements));
-    if (eligible.length === 0)
-        throw new Error('No eligible worker satisfies the declared requirements');
-    const ranked = eligible.map((candidate, index) => ({ candidate, index })).sort((a, b) => {
+export function eligibleWorkerCandidates(candidates, requirements) {
+    return candidates.filter(candidate => satisfiesWorker(candidate, requirements));
+}
+function deterministicWorker(eligible) {
+    return [...eligible].map((candidate, index) => ({ candidate, index })).sort((left, right) => {
         const pressure = (item) => item.resourceUsedPercent === undefined ? 1 : item.resourceUsedPercent >= 90 ? 2 : 0;
-        return pressure(a.candidate) - pressure(b.candidate) || a.index - b.index;
-    });
-    const selected = ranked[0].candidate;
+        return pressure(left.candidate) - pressure(right.candidate) || left.index - right.index;
+    })[0].candidate;
+}
+function selection(selected, selectedBy, decisionEvidence) {
     return {
-        candidate: selected,
-        selection: {
-            workerId: selected.workerId,
-            adapter: selected.adapter,
-            capabilities: [...selected.capabilities],
-            selectedBy: 'worker-router:requirements',
-            selectedAt: new Date().toISOString(),
-            resourceHealthy: selected.resourceHealthy,
-            resourceProvider: selected.resourceProvider,
-            resourceUsedPercent: selected.resourceUsedPercent,
-        },
+        workerId: selected.workerId,
+        adapter: selected.adapter,
+        capabilities: [...selected.capabilities],
+        selectedBy,
+        selectedAt: new Date().toISOString(),
+        resourceHealthy: selected.resourceHealthy,
+        resourceProvider: selected.resourceProvider,
+        resourceUsedPercent: selected.resourceUsedPercent,
+        decisionEvidence,
     };
 }
+/** Deterministic fallback and backwards-compatible direct selector. */
+export function selectWorker(candidates, requirements) {
+    const eligible = eligibleWorkerCandidates(candidates, requirements);
+    if (eligible.length === 0)
+        throw new Error('No eligible worker satisfies the declared requirements');
+    const selected = deterministicWorker(eligible);
+    return { candidate: selected, selection: selection(selected, 'worker-router:requirements') };
+}
+/** Gathered facts and hard gates stay in code; Laya only judges among legal choices. */
+export async function routeWorker(candidates, requirements, options = {}) {
+    const eligible = eligibleWorkerCandidates(candidates, requirements);
+    if (eligible.length === 0)
+        throw new Error('No eligible worker satisfies the declared requirements');
+    const deterministic = deterministicWorker(eligible);
+    if (eligible.length === 1) {
+        const evidence = { mode: options.decisionMode ?? 'off', fallback: true };
+        return { candidate: deterministic, selection: selection(deterministic, 'worker-router:requirements', evidence) };
+    }
+    const facts = JSON.parse(JSON.stringify({
+        task: options.taskFacts ?? {},
+        requirements,
+        candidates: eligible.map(item => ({
+            id: item.workerId,
+            adapter: item.adapter,
+            capabilities: [...item.capabilities],
+            runtime: item.runtime ?? null,
+            resourceHealthy: item.resourceHealthy ?? null,
+            resourceProvider: item.resourceProvider ?? null,
+            resourceUsedPercent: item.resourceUsedPercent ?? null,
+        })),
+    }));
+    const choice = await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', { facts }, { type: 'choice', question: 'Which eligible worker is best suited to execute this task?', choices: eligible.map(item => item.workerId) }, () => deterministic.workerId);
+    const selected = eligible.find(item => item.workerId === choice.choice) ?? deterministic;
+    const selectedBy = choice.evidence.engine && !choice.evidence.fallback ? 'worker-router:laya' : 'worker-router:requirements';
+    return { candidate: selected, selection: selection(selected, selectedBy, choice.evidence) };
+}

package/package.json

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

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

@@ -55,9 +55,10 @@ Keep these concepts distinct: observation is not root cause; hypothesis is not r
 Every new model-backed executable task follows this order:
 
 1. The planner declares `workerRequirements` (capabilities and optional runtime, task-kind, trust-domain, region, and label constraints).
-2. `worker-router` resolves those requirements against available workers and a fresh on-demand usage snapshot from the shared usage registry. It applies capability/availability hard gates before considering resource evidence.
-3. `model-router` chooses provider/model/reasoning details for the selected worker.
-4. Relay persists the selected worker and model routing on the durable task before launch.
+2. `worker-router` is code-driven: it gathers authoritative worker/resource facts, applies capability/availability and other hard gates, then may call the generic typed `decide(request, contract)` primitive only among eligible workers.
+3. `model-router` runs after worker selection, discovers model/profile facts usable by that worker, applies model hard gates, then may use the same typed `decide()` primitive among eligible profiles. Router judgment is not a free-form agent invocation.
+4. `decide()` owns no routing facts or legality policy. Its optional Laya implementation is a transient CLI subprocess per decision; unavailable/invalid decisions fall back to deterministic routing. `src/usage.ts` remains the shared resource-fact source.
+5. Relay persists the selected worker and model routing on the durable task before launch.
 
 Planner output must not hard-code `codex`/`chatgpt`, provider preference, or usage probes. The worker-router and model-router are separate responsibilities; usage readers remain owned by `src/usage.ts` and are not duplicated in either router. Legacy task records that already contain adapter/routing metadata remain readable, but newly produced planner tasks must carry worker requirements.