agents-relay 1.0.40 → 1.0.42

package/README.md

@@ -88,6 +88,20 @@ node dist/cli.js reconcile --file .agents-relay.json
 npx agents-relay serve --file .agents-relay.json
 ~~~
 
+### Opt-in Temporary Chat quality checks
+
+The normal `npm test` suite does not open a browser or send ChatGPT messages.
+For an explicit live check of the one-shot Temporary Chat path, use an
+authenticated browser session and run:
+
+~~~sh
+npm run test:chatgpt-temp-quality
+~~~
+
+This small live suite covers two Temporary Chat submission gates: a normal text
+prompt and a prompt with an attachment. It does not exercise worker lifecycle
+events, durable-thread reuse, resume, or retry behavior.
+
 Open the dashboard on localhost port 8787. The marker format is intentionally public and append-friendly; the CLI uses GitHubStore with the authenticated gh client in operational mode.
 
 reconcile leases and launches ready tasks without waiting inside the runtime scheduler; the CLI waits only long enough for its launched workers to persist results. agents-relayd (or the equivalent npx agents-relay serve) is the watchdog/dashboard mode. Model-backed workers require --events nats; the event transport carries authoritative terminal worker events as well as wake/progress traffic. See [docs/service.md](docs/service.md). --file PATH is explicit local demo/test mode only.

package/dist/adapters.js

@@ -252,7 +252,7 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? directBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? directBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);

package/dist/cli.js

@@ -356,6 +356,7 @@ function workerTaskFromArgs(job, args, now, requireInput = false) {
         adapter,
         chatgptTabClosePolicy: closePolicy,
         input: input || 'true',
+        attachments: arg(args, '--attachments').split(',').filter(Boolean),
         output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' },
         routing,
         continuation: continuation(args),
@@ -507,16 +508,16 @@ async function runJobCommand(action, args) {
     console.log(JSON.stringify({ repository: repo, pr: result.pr.number, job: result.job.id, executionMode: result.job.executionMode, state: result.job.state, task: start ? arg(args, '--task-id', 'initial') : undefined }, null, 2));
 }
 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 { adapter: 'chatgpt', routing: { provider: 'chatgpt', model: 'account-defaults', decidedBy: 'fixed-chatgpt-reviewer', decidedAt: new Date().toISOString() } }; }
-export function runtime(store, args, bus) { 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, reviewer: runtimeReviewer(), eventBus: bus, emit, chatgptTabClosePolicy: policy, projectPathForJob: job => resolveManagedProjectPath(job.repository, arg(args, '--project-path'), arg(args, '--workspace-root') || defaultWorkspaceRoot()) }); }
+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 async function createService(args) {
     const loaded = await storeFor(args);
     const upstream = eventBus(args);
     const bus = upstream ? new ServiceEventBus(upstream) : undefined;
-    const reconciler = runtime(loaded.store, args, bus);
     const requestedUsageDays = Number(arg(args, '--usage-window-days', '1'));
     const usageWindowDays = Number.isInteger(requestedUsageDays) && requestedUsageDays > 0 ? requestedUsageDays : 1;
     const usageRegistry = codexAndZaiUsageRegistry(undefined, usageWindowDays);
+    const reconciler = runtime(loaded.store, args, bus, usageRegistry);
     const repo = arg(args, '--repo');
     let overviewProvider;
     if (repo) {

package/dist/dashboard.js

@@ -2,6 +2,7 @@ import { createServer } from 'node:http';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { readUsageSnapshot } from './usage.js';
 import { DeliveryDeduper, parseGitHubWebhook, verifyGitHubWebhook } from './github-webhook.js';
 const GITHUB_REPOSITORY_PATTERN = /^([A-Za-z0-9](?:[A-Za-z0-9-]{0,36}[A-Za-z0-9])?)\/([A-Za-z0-9._-]{1,100})$/;
 const SSE_HEARTBEAT_MS = 15000;
@@ -363,7 +364,7 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
     const usage = async () => {
         if (!usageRegistry)
             throw new Error('Account usage telemetry is unavailable');
-        return JSON.stringify(await usageRegistry.snapshot());
+        return JSON.stringify(await readUsageSnapshot(usageRegistry));
     };
     const server = createServer(async (req, res) => {
         if (req.url === '/') {

package/dist/planner.js

@@ -9,7 +9,7 @@ export function planningSpec(task) {
         throw new Error(`Initial task ${task.id} requires an output contract`);
     if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
         throw new Error(`Initial task ${task.id} requires a supported adapter`);
-    return { id: task.id, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, dependencies: task.dependencies, capabilities: task.capabilities, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs };
+    return { id: task.id, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs };
 }
 export function orchestratorPlanningDecision(job, tasks, id, parentTaskId, round, source = 'orchestrator') {
     const now = new Date().toISOString();
@@ -34,6 +34,26 @@ function stringArray(value, field, fallback = []) {
         throw new Error(`Planner ${field} must be an array of non-empty strings`);
     return [...value];
 }
+function workerRequirements(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    const root = record(value);
+    const capabilities = stringArray(root.capabilities, `${field}.capabilities`);
+    const optional = (name) => optionalString(root[name], `${field}.${name}`);
+    const labelsValue = root.labels;
+    let labels;
+    if (labelsValue !== undefined) {
+        if (!labelsValue || typeof labelsValue !== 'object' || Array.isArray(labelsValue))
+            throw new Error(`Planner ${field}.labels must be an object`);
+        labels = {};
+        for (const [key, item] of Object.entries(labelsValue)) {
+            if (typeof item !== 'string' || item.length === 0)
+                throw new Error(`Planner ${field}.labels values must be non-empty strings`);
+            labels[key] = item;
+        }
+    }
+    return { capabilities, runtime: optional('runtime'), taskKind: optional('taskKind'), trustDomain: optional('trustDomain'), region: optional('region'), labels };
+}
 function rawValue(value) {
     if (typeof value === 'string')
         return JSON.stringify(value);
@@ -88,8 +108,8 @@ export function parsePlannerResult(value) {
         if (typeof task.input !== 'string' || task.input.length === 0)
             throw new Error(`Planner next_tasks[${index}].input is required`);
         const adapter = task.adapter;
-        if (adapter === undefined || !['codex', 'chatgpt'].includes(String(adapter)))
-            throw new Error(`Planner next_tasks[${index}].adapter must be codex or chatgpt`);
+        if (adapter !== undefined && !['codex', 'chatgpt'].includes(String(adapter)))
+            throw new Error(`Planner next_tasks[${index}].adapter must be codex or chatgpt when provided`);
         const output = task.output === undefined ? undefined : record(task.output);
         if (!output || (output.kind !== 'task_pr' && output.kind !== 'file'))
             throw new Error(`Planner next_tasks[${index}].output is required`);
@@ -102,6 +122,7 @@ export function parsePlannerResult(value) {
         const storySize = sizeValue;
         const maxAttempts = task.maxAttempts === undefined ? 3 : task.maxAttempts;
         const route = routing(task.routing, 'next_tasks[' + index + '].routing');
+        const requirements = workerRequirements(task.workerRequirements ?? task.requirements, 'next_tasks[' + index + '].workerRequirements');
         const timeoutMs = task.timeoutMs === undefined ? taskOverallTimeoutMs(storySize, route?.reasoning) : task.timeoutMs;
         if (typeof maxAttempts !== 'number' || !Number.isInteger(maxAttempts) || maxAttempts < 1)
             throw new Error(`Planner next_tasks[${index}].maxAttempts is invalid`);
@@ -110,7 +131,7 @@ export function parsePlannerResult(value) {
         return {
             id, input: task.input, priority, storySize,
             projectName: optionalString(task.projectName, 'projectName'), agentName: optionalString(task.agentName, 'agentName'),
-            dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'),
+            dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'), workerRequirements: requirements,
             adapter: adapter, output: output, routing: route,
             continuation: task.continuation, maxAttempts, timeoutMs
         };

package/dist/reconciler.js

@@ -5,6 +5,8 @@ import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
 import { executionContextPrompt, resolveExecutionContext } from './execution-context.js';
+import { selectReviewer } from './reviewer-routing.js';
+import { selectWorker, usageForProvider, workerCandidates } from './worker-routing.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareTaskPriority(a, b, jobPriority = 'P2') { const ar = PRIORITY_RANK[a.priority ?? jobPriority]; const br = PRIORITY_RANK[b.priority ?? jobPriority]; return ar - br || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export function managedWorkerInput(job, task, context) {
@@ -130,6 +132,7 @@ export class Reconciler {
             }
             await this.recoverLostExecutions(job, now);
             await this.recoverPlannerChildren(job);
+            await this.routeExecutableTasks(await this.store.load(jobId));
             for (const task of job.tasks)
                 if (task.state === 'CANCELLED') {
                     this.live.get(task.id)?.execution.cancel();
@@ -221,19 +224,64 @@ export class Reconciler {
             return;
         const id = `final-review-${headSha.slice(0, 12)}`;
         const now = new Date().toISOString();
-        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: job.tasks.filter(item => item.agentName !== 'reviewer' && !this.isSupersededTask(item)).map(item => item.id), capabilities: ['review'], adapter: this.options.reviewer?.adapter ?? 'codex', input: `Review PR #${job.prNumber} at head SHA ${headSha}. Objective: ${job.objective ?? job.description ?? job.title}. First publish task.started as the worker start acknowledgement with data.worker_owned=true, then verify the deterministic pre-review gates have passed and inspect the completed work. Emit review.started, then exactly one of review.approved, review.changes_required, or review.blocked with data.review.headSha set to ${headSha}. For review.changes_required, include every actionable finding in data.review.issues as an array of concise issue strings; Relay will create one durable fix task containing all findings. Do not modify code. When auto-merge is enabled, Relay will merge this exact reviewed head after review.approved.`, output: { kind: 'task_pr' }, routing: this.options.reviewer?.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
+        const implementationTasks = job.tasks.filter(item => item.agentName !== 'reviewer' && !this.isSupersededTask(item));
+        const reviewerRouting = await this.selectReviewer(implementationTasks);
+        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: implementationTasks.map(item => item.id), capabilities: ['review'], workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter, input: `Review PR #${job.prNumber} at head SHA ${headSha}. Objective: ${job.objective ?? job.description ?? job.title}. First publish task.started as the worker start acknowledgement with data.worker_owned=true, then verify the deterministic pre-review gates have passed and inspect the completed work. Emit review.started, then exactly one of review.approved, review.changes_required, or review.blocked with data.review.headSha set to ${headSha}. For review.changes_required, include every actionable finding in data.review.issues as an array of concise issue strings; Relay will create one durable fix task containing all findings. Do not modify code. When auto-merge is enabled, Relay will merge this exact reviewed head after review.approved.`, output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
         await this.store.appendTask(task);
         job.review = { outcome: 'pending', headSha, taskId: id, evidence: null, updatedAt: now };
         job.state = 'RUNNING';
         job.updatedAt = now;
         await this.store.saveJob(job);
-        await this.emit(eventFor(job.id, id, null, 'review.created', 'queued', `Final review task ${id} created for ${headSha}`, 'orchestrator', { headSha, agentName: 'reviewer' }));
+        await this.emit(eventFor(job.id, id, null, 'review.created', 'queued', `Final review task ${id} created for ${headSha} using ${reviewerRouting.reason}`, 'orchestrator', { headSha, agentName: 'reviewer', reviewerRouting: { workerId: reviewerRouting.selection.workerId, reason: reviewerRouting.reason, selectedBy: reviewerRouting.selection.selectedBy } }));
         const ready = schedule(await this.store.load(job.id));
         await this.store.saveJob(ready);
         const reviewTask = ready.tasks.find(item => item.id === id && item.state === 'READY');
         if (reviewTask && (this.options.maxConcurrent ?? 4) > this.live.size + this.plannerLive.size)
             await this.launch(ready, reviewTask);
     }
+    async selectReviewer(implementationTasks) {
+        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 => {
+            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 }];
+        }
+        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);
+        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'READY', '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;
+            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' }));
+        }
+    }
     isSupersededTask(task) {
         return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
     }
@@ -591,7 +639,7 @@ export class Reconciler {
     }
     plannerChild(job, planner, spec) {
         const now = new Date().toISOString();
-        return { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, parentTaskId: planner.id, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], adapter: spec.adapter, input: spec.input, output: spec.output, routing: spec.routing, continuation: spec.continuation ?? null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M', spec.routing?.reasoning), createdAt: now, updatedAt: now, planningDecisionId: planner.id, planningSource: planner.planningSource ?? 'model-planner', planningRound: planner.planningRound ?? 1 };
+        return { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, parentTaskId: planner.id, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, adapter: 'codex', input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: planner.id, planningSource: planner.planningSource ?? 'model-planner', planningRound: planner.planningRound ?? 1 };
     }
     clearExecution(taskId, executionId) {
         const live = this.live.get(taskId);

package/dist/relayd.js

@@ -69,7 +69,8 @@ export async function runDaemon(argv) {
     const repositories = normalized.repository ? [normalized.repository] : discoveredRepositories.map(item => item.repository);
     const repositoryPaths = new Map(discoveredRepositories.map(item => [item.repository, item.path]));
     const explicitProjectPath = value(argv, '--project-path');
-    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), eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: job => repositoryPaths.get(job.repository) ?? resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot) });
+    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) });
     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);
@@ -157,7 +158,6 @@ export async function runDaemon(argv) {
             return null;
         }
     };
-    const usageRegistry = codexAndZaiUsageRegistry();
     const server = serveDashboard(dashboardStore, Number(value(argv, '--port', String(SERVICE_DEFAULTS.port))), bus, Number(value(argv, '--refresh-ms', String(SERVICE_DEFAULTS.dashboardRefreshMs))), fallback?.id, usageRegistry, overviews, webhook, () => client.rateLimitStatus(), exactJob);
     await once(server, 'listening');
     const reconcileSafely = async () => {

package/dist/reviewer-routing.js

@@ -0,0 +1,64 @@
+function satisfies(candidate, requirements) {
+    if (candidate.availability && candidate.availability !== 'available')
+        return false;
+    if (candidate.resourceHealthy === false)
+        return false;
+    if (!requirements)
+        return true;
+    if (!requirements.capabilities.every(capability => candidate.capabilities.includes(capability)))
+        return false;
+    if (requirements.runtime && candidate.runtime !== requirements.runtime)
+        return false;
+    if (requirements.taskKind && candidate.taskKind !== requirements.taskKind)
+        return false;
+    if (requirements.trustDomain && !candidate.trustDomains?.includes(requirements.trustDomain))
+        return false;
+    if (requirements.region && candidate.region !== requirements.region)
+        return false;
+    if (requirements.labels && Object.entries(requirements.labels).some(([key, value]) => candidate.labels?.[key] !== value))
+        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 review worker only after hard gates, 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,
+    };
+}

package/dist/store.js

@@ -82,8 +82,8 @@ function immutableTaskDefinition(task) {
     } : undefined;
     return {
         jobId: task.jobId, id: task.id, priority: task.priority, storySize: task.storySize ?? 'M', projectName: task.projectName, agentName: task.agentName,
-        kind: task.kind ?? 'work', planningDecisionId: task.planningDecisionId, planningSource: task.planningSource, planningRound: task.planningRound, parentTaskId: task.parentTaskId, dependencies: task.dependencies, capabilities: task.capabilities, adapter: task.adapter,
-        input: task.input, output: task.output, routing, chatgptTabClosePolicy: task.chatgptTabClosePolicy ?? 'after-start', continuation: task.continuation ?? null, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs
+        kind: task.kind ?? 'work', planningDecisionId: task.planningDecisionId, planningSource: task.planningSource, planningRound: task.planningRound, parentTaskId: task.parentTaskId, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, workerSelection: task.workerSelection, adapter: task.adapter,
+        input: task.input, attachments: task.attachments, output: task.output, routing, chatgptTabClosePolicy: task.chatgptTabClosePolicy ?? 'after-start', continuation: task.continuation ?? null, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs
     };
 }
 function sameTaskDefinition(left, right) {

package/dist/usage.js

@@ -348,6 +348,10 @@ export class UsageRegistry {
         };
     }
 }
+/** Read one fresh, on-demand snapshot from the shared usage source. */
+export function readUsageSnapshot(source) {
+    return source.snapshot();
+}
 export class UnavailableUsageReader {
     reason;
     now;

package/dist/worker-routing.js

@@ -0,0 +1,76 @@
+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 };
+}
+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 resource = usageForProvider(snapshot, provider);
+            return {
+                workerId: worker?.id ?? adapter.id,
+                adapter: adapter.name,
+                capabilities: worker?.capabilities ?? [
+                    ...adapter.capabilities,
+                    ...(adapter.name === 'codex' ? ['local_repo', 'iterative_tools', 'long_running'] : ['web_session', 'attachments', 'interactive_ui', 'one_shot']),
+                ],
+                runtime: worker?.runtime.adapter ?? adapter.name,
+                trustDomains: worker?.routing.trustDomains,
+                region: worker?.routing.regions?.[0],
+                labels: worker?.routing.labels,
+                availability: worker?.availability,
+                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) {
+    if (candidate.availability && candidate.availability !== 'available')
+        return false;
+    if (candidate.resourceHealthy === false)
+        return false;
+    if (!requirements.capabilities.every(capability => candidate.capabilities.includes(capability)))
+        return false;
+    if (requirements.runtime && candidate.runtime !== requirements.runtime)
+        return false;
+    if (requirements.taskKind && candidate.taskKind !== requirements.taskKind)
+        return false;
+    if (requirements.trustDomain && !candidate.trustDomains?.includes(requirements.trustDomain))
+        return false;
+    if (requirements.region && candidate.region !== requirements.region)
+        return false;
+    if (requirements.labels && Object.entries(requirements.labels).some(([key, value]) => candidate.labels?.[key] !== value))
+        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) => {
+        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 {
+        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,
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "1.0.40",
+  "version": "1.0.42",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {
@@ -10,6 +10,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli.js dist/relayd.js",
     "test": "npm run build && node --test test/*.test.js",
+    "test:chatgpt-temp-quality": "AGENTS_RELAY_RUN_CHATGPT_TEMP_QUALITY=1 AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT=/Users/chengli/Workspace/neo/skills/chatgpt-browser-worker/agents/browser-worker.agent.md sh -c \"npm run build && node test/quality/run-temporary-chat.mjs\"",
     "dev": "tsx src/cli.ts"
   },
   "devDependencies": {

package/skills/agents-relay/agents/planner.agent.md

@@ -13,12 +13,13 @@ Inspect the durable objective and task tree, then decide whether the objective i
 - Prefer small independently verifiable tasks.
 - Preserve parent/subtask causality and stable IDs.
 - A child task describes what an agent must accomplish. Never emit a shell command as a worker task.
-- Every child task must use adapter `codex` or `chatgpt`.
+- Every child task must declare `workerRequirements` (capabilities plus any runtime, task-kind, trust-domain, region, or label constraints). The worker-router resolves those requirements against the fresh usage snapshot and available workers before model-router chooses provider/model details.
+- Do not choose `codex`/`chatgpt` or provider/model heuristically. When a selected worker is supplied by the caller, consume that selection; otherwise leave worker selection to the worker-router.
 - Every child task must declare exactly one output: `task_pr` or `file`.
-- Include routing metadata for every model-backed child task.
+- Do not emit provider/model routing metadata; worker-router and model-router add it after planning.
 - Every child task must include `storySize` according to the shared Task / Job Contract. Use `M` when uncertain.
 - Return no prose outside the JSON result.
 
 ## Output
 
-Return exactly one JSON object with `objective_status`, `assessment`, and `next_tasks`. Each next task contains id, input, adapter, output, routing, storySize, and may also contain priority, projectName, agentName, dependencies, capabilities, maxAttempts, and timeoutMs. When the objective is satisfied, next_tasks must be empty.
+Return exactly one JSON object with `objective_status`, `assessment`, and `next_tasks`. Each next task contains id, input, `workerRequirements`, output, and storySize. Adapter/routing fields are selected by the runtime after worker-router runs; do not invent them. Each task may also contain priority, projectName, agentName, dependencies, capabilities, maxAttempts, and timeoutMs. When the objective is satisfied, next_tasks must be empty.

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

@@ -5,7 +5,18 @@ This contract is the shared protocol for every component that creates, schedules
 ## Task producers
 
 Any task producer — orchestrator, planner, or nested task-producing agent — must follow this contract.
-Task producers choose semantic task properties such as objective, dependencies, adapter/routing, priority, and `storySize`. They do not normally choose raw timeout milliseconds.
+Task producers choose semantic task properties such as objective, dependencies, worker requirements, priority, and `storySize`. They do not normally choose an adapter, provider/model, or raw timeout milliseconds.
+
+## Worker routing order
+
+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.
+
+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.
 
 ## Story size
 
@@ -27,6 +38,8 @@ Relay owns process lifecycle. Workers own semantic task lifecycle. A worker must
 
 A normal task never merges a PR. After all non-superseded work gates pass, Relay creates a SHA-bound final review task. The reviewer emits exactly one of `review.approved`, `review.changes_required`, or `review.blocked`. When `autoMerge` is enabled (default), Relay merges only after `review.approved`, pinned to the exact reviewed head SHA. A new task or new PR head makes earlier final-review evidence stale and requires a fresh review.
 
+Final-review routing follows the same worker-selection boundary as executable work. Capability, availability, explicit reviewer constraints, and resource health are hard gates. Among eligible workers, Relay prefers a reviewer with a different worker identity from the implementation tasks; when that is unavailable it prefers a different provider/model, then falls back to the first eligible worker. The selected worker, `selectedBy` reason, and `reviewerRouting` event data are durable evidence. No provider is a universal reviewer default.
+
 ## Fixed and autonomous jobs
 
 `fixed` jobs execute the orchestrator-provided task set and then proceed to final review. `autonomous` jobs may ask the planner for additional task batches. Planner-produced tasks must obey this same contract, including explicit `storySize`.