agents-relay 2.0.33 → 2.0.35

package/README.md

@@ -128,7 +128,7 @@ Autonomous jobs can also be scheduled. The Job marker stores a five-field cron e
 [Scheduled autonomous jobs](docs/scheduled-autonomous-jobs.md) for the exact
 operational contract.
 
-job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker. Job creation is always create-only. Task execution options belong to `task create`, and the orchestrator may create zero, one, or multiple initial Tasks according to user intent.
+job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker. Job creation is always create-only and always enables auto-merge; `--no-auto-merge` is not a `job create` option. Existing Jobs can still change that setting with `job update`. Task execution options belong to `task create`, and the orchestrator may create zero, one, or multiple initial Tasks according to user intent.
 
 To create a Job on an existing unmanaged PR, use the same `job create` action with `--pr` instead of `--head`:
 

package/dist/adapters.js

@@ -120,6 +120,8 @@ export class CodexAdapter {
         return execution;
     }
 }
+export const CHATGPT_BROWSER_WORKSPACE = 'agents-replay';
+export const CHATGPT_BROWSER_WORKSPACE_POOL_SIZE = 6;
 export function chatGptTabClosePolicy(value, fallback = 'after-start') {
     const policy = value || fallback;
     if (!['after-start', 'never', 'after-terminal'].includes(policy))
@@ -163,62 +165,129 @@ function parseDriverJson(output) {
     }
     throw new Error('browser-worker driver returned no submitted receipt');
 }
-function directBrowserWorkerRunner(root) {
-    return (_definition, request, _route, signal) => {
-        const releaseFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-release-${randomUUID()}`);
-        const args = [join(root, 'scripts', 'temporary_bh.py'), '--prompt', request.prompt, '--release-file', releaseFile, '--close-policy', request.tabClosePolicy ?? 'after-start'];
-        for (const file of request.files ?? [])
-            args.push('--file', file);
-        const child = spawn('python3', args, { shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
+function browserWorkspaceCommand(command, args, stdin) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, [...args], { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
-        let submitted = false;
+        child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+        child.stderr?.on('data', (chunk) => { stderr = appendTail(stderr, chunk.toString()); });
+        child.on('error', reject);
+        child.on('close', code => {
+            if (code === 0)
+                resolve(stdout.trim());
+            else
+                reject(new Error(stderr.trim() || stdout.trim() || `browser-workspace exited ${code}`));
+        });
+        if (stdin !== undefined) {
+            child.stdin?.end(stdin);
+        }
+    });
+}
+function parseWorkspaceJson(output) {
+    const lines = output.trim().split(/\r?\n/).filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+            return JSON.parse(lines[index]);
+        }
+        catch { /* diagnostics may precede JSON */ }
+    }
+    throw new Error('browser-workspace returned no JSON result');
+}
+export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND ?? 'browser-workspace') {
+    await browserWorkspaceCommand(command, ['create', CHATGPT_BROWSER_WORKSPACE, String(CHATGPT_BROWSER_WORKSPACE_POOL_SIZE)]);
+}
+function sessionBrowserWorkerRunner(root) {
+    const command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND ?? 'browser-workspace';
+    return (_definition, request, _route, signal) => {
+        const policy = request.tabClosePolicy ?? 'after-start';
+        let activeSessionId;
+        let released = false;
+        let releaseResolve;
+        const releaseBarrier = new Promise(resolve => { releaseResolve = resolve; });
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            releaseResolve();
+        };
         let submittedResolve;
         let submittedReject;
-        const submittedPromise = new Promise((resolve, reject) => { submittedResolve = resolve; submittedReject = reject; });
-        child.stdout?.on('data', (chunk) => {
-            stdout += chunk.toString();
-            if (!submitted) {
-                try {
-                    const response = parseDriverJson(stdout);
-                    submitted = true;
-                    submittedResolve?.(JSON.stringify(response));
-                }
-                catch { /* receipt may be split across chunks */ }
-            }
+        const submitted = new Promise((resolve, reject) => {
+            submittedResolve = resolve;
+            submittedReject = reject;
         });
-        child.stderr?.on('data', (chunk) => {
-            stderr = appendTail(stderr, chunk.toString());
-        });
-        const promise = new Promise((resolve, reject) => {
-            child.on('error', reject);
-            child.on('close', code => {
-                if (code !== 0) {
-                    const error = new Error(stderr.trim() || stdout.trim() || `browser-worker driver exited ${code}`);
-                    submittedReject?.(error);
-                    reject(error);
-                    return;
+        const promise = (async () => {
+            const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
+            try {
+                const [readiness, submitSource, temporarySource] = await Promise.all([
+                    readFile(join(root, 'scripts', '_submit_readiness.py'), 'utf8'),
+                    readFile(join(root, 'scripts', '_submit_bh.py'), 'utf8'),
+                    readFile(join(root, 'scripts', '_temporary_bh.py'), 'utf8'),
+                ]);
+                await writeFile(configFile, JSON.stringify({
+                    prompt: request.prompt,
+                    file: request.files ?? [],
+                    close_policy: policy,
+                    release_file: '',
+                }));
+                const startOutput = await browserWorkspaceCommand(command, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
+                const started = parseWorkspaceJson(startOutput);
+                if (typeof started.session_id !== 'string') {
+                    throw new Error('browser-workspace session start returned no session_id');
                 }
-                try {
-                    const result = JSON.stringify(parseDriverJson(stdout));
-                    if (!submitted) {
-                        submitted = true;
-                        submittedResolve?.(result);
-                    }
-                    resolve(result);
+                activeSessionId = started.session_id;
+                if (signal.aborted)
+                    throw new Error('browser-worker execution aborted');
+                const escapedConfig = configFile.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
+                const source = [
+                    readiness,
+                    submitSource.replace(/^from browser_harness import \*\s*$/m, ''),
+                    temporarySource.replace(/^_wait_for_release\(\)\s*$/m, ''),
+                ].join('\n\n').replaceAll('__CFG_PATH__', escapedConfig);
+                const execOutput = await browserWorkspaceCommand(command, ['session', 'exec', activeSessionId], source);
+                const wrapper = parseWorkspaceJson(execOutput);
+                if (wrapper.ok !== true) {
+                    throw new Error(typeof wrapper.error === 'string' ? wrapper.error : 'browser-workspace session exec failed');
                 }
-                catch (error) {
-                    reject(error);
+                const receipt = parseDriverJson(typeof wrapper.stdout === 'string' ? wrapper.stdout : '');
+                const result = JSON.stringify(receipt);
+                submittedResolve(result);
+                if (policy === 'never') {
+                    await unlink(configFile).catch(() => { });
+                    activeSessionId = undefined;
+                    return result;
                 }
-            });
-            if (signal.aborted)
-                child.kill('SIGTERM');
-            else
-                signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
-        });
-        const release = () => { void writeFile(releaseFile, 'release').catch(() => { }); };
-        promise.finally(() => { void unlink(releaseFile).catch(() => { }); }).catch(() => { });
-        return { promise, submitted: submittedPromise, release, cancel: () => { release(); child.kill('SIGTERM'); } };
+                await releaseBarrier;
+                if (activeSessionId) {
+                    await browserWorkspaceCommand(command, ['session', 'stop', activeSessionId]);
+                    activeSessionId = undefined;
+                }
+                return result;
+            }
+            catch (failure) {
+                if (activeSessionId) {
+                    await browserWorkspaceCommand(command, ['session', 'stop', activeSessionId]).catch(() => { });
+                    activeSessionId = undefined;
+                }
+                await unlink(configFile).catch(() => { });
+                const error = failure instanceof Error ? failure : new Error(String(failure));
+                submittedReject(error);
+                throw error;
+            }
+        })();
+        const cancel = () => {
+            release();
+            if (activeSessionId) {
+                void browserWorkspaceCommand(command, ['session', 'stop', activeSessionId]);
+                activeSessionId = undefined;
+            }
+        };
+        if (signal.aborted)
+            cancel();
+        else
+            signal.addEventListener('abort', cancel, { once: true });
+        return { promise, submitted, release, cancel };
     };
 }
 function parseBrowserWorkerResponse(output) {
@@ -243,7 +312,7 @@ function parseBrowserWorkerResponse(output) {
 export class ChatGptAdapter {
     name = 'chatgpt';
     id = 'chatgpt/browser-worker';
-    capabilities = ['model', 'chatgpt', 'browser-harness'];
+    capabilities = ['model', 'chatgpt', 'browser-workspace'];
     agentPath;
     runner;
     tabClosePolicy;
@@ -276,7 +345,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, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? sessionBrowserWorkerRunner(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-help.js

@@ -47,8 +47,8 @@ Example:
 
 Required: --repo OWNER/REPO, --id JOB_ID, and either --head BRANCH or --pr NUMBER.
 With --head, reuse/create the PR for that head. With --pr, bind an existing unmanaged PR.
-Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --no-auto-merge, --no-review, --tag JSON. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
-Job creation never creates executable tasks. The orchestrator decides the initial task batch separately. Re-running create against an already healthy Job is idempotent and does not mutate its metadata.
+Common: --base BRANCH (default: main), --title TEXT, --objective-file PATH|- (preferred), --objective MARKDOWN (short/simple only), --project-path RELATIVE_PATH, --priority P0|P1|P2|P3, --mode fixed|autonomous, --no-review, --tag JSON. --objective and --objective-file are mutually exclusive. For a new --head Job, one is required and must contain enough standalone context to complete the Job without the originating chat/thread. Objective Markdown is also the default PR body; --body is an explicit override.
+Job creation always enables auto-merge and never creates executable tasks. The orchestrator decides the initial task batch separately. Re-running create against an already healthy Job is idempotent and does not mutate its metadata.
 
 Example:
   npx agents-relay job create --repo OWNER/REPO --head feat/example --base main --id job-1 --title "Objective" --objective-file job.md`,

package/dist/cli.js

@@ -54,7 +54,7 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
         priority: options.priority ?? 'P2',
         executionMode: options.executionMode ?? 'fixed',
         tag: options.tag,
-        autoMerge: options.autoMerge ?? true,
+        autoMerge: true,
         reviewEnabled: options.reviewEnabled ?? true,
         prNumber: pr.number,
         repository: repositoryName,
@@ -331,6 +331,8 @@ async function runJobCommand(action, args) {
     const repo = repository(args);
     let createObjective;
     if (action === 'create') {
+        if (hasArg(args, '--no-auto-merge'))
+            throw new Error('job create does not accept --no-auto-merge; new Jobs always enable auto-merge');
         const taskOnlyFlags = ['--start', '--task-id', '--input', '--input-file', '--adapter', '--provider', '--model', '--profile', '--reasoning', '--story-size', '--project', '--agent', '--parent', '--deps', '--capabilities', '--attachments', '--max-attempts', '--timeout', '--cwd', '--chatgpt-project', '--chatgpt-tab-close-policy', '--output', '--output-path', '--draft', '--queue'];
         const invalid = taskOnlyFlags.find(flag => hasArg(args, flag));
         if (invalid)
@@ -364,7 +366,6 @@ async function runJobCommand(action, args) {
             executionMode: requestedExecutionMode(args),
             schedule: scheduleFromArgs(args),
             tag: jobTagFromArgs(args),
-            autoMerge: !hasArg(args, '--no-auto-merge'),
             reviewEnabled: !hasArg(args, '--no-review'),
             continuation: continuation(args),
             prNumber,

package/dist/execution-routing.js

@@ -2,6 +2,7 @@ import { makeExecutionDecisionAudit } from './decision-audit.js';
 import { discoverModelCandidates } from './model-routing.js';
 import { loadExecutionRouterRules, loadRoutingPolicy, policyAllows } from './routing-policy.js';
 import { DEFAULT_CHATGPT_PREFERRED_CONCURRENCY } from './worker-routing.js';
+import { appendRoutingInstruction } from './router-rules.js';
 export function executionTaskShape(taskFacts = {}) {
     const nestedTask = taskFacts.task && typeof taskFacts.task === 'object' ? taskFacts.task : undefined;
     const raw = taskFacts.storySize ?? nestedTask?.storySize;
@@ -228,7 +229,8 @@ export async function discoverExecutionRoutes(workers, requirements, options = {
         const workerReasons = workerGateEvaluations.find(item => item.workerId === worker.workerId)?.rejectionReasons ?? [];
         const discovered = await discoverModelCandidates(worker, registered, options.usage, undefined, options.rulesPath);
         const defaults = profileDefaults(discovered);
-        const explicit = resolveExplicitChoices(rules.parsed.choices, discovered);
+        const workerChoices = rules.parsed.choices.filter(choice => !choice.worker || choice.worker === worker.workerId || choice.worker === worker.adapter);
+        const explicit = resolveExplicitChoices(workerChoices, discovered);
         const merged = mergeCandidates(defaults, explicit);
         for (const model of merged) {
             const rejectionReasons = [...workerReasons, ...modelGateReasons(model, options.routingConstraints, options.excludedRoutes, policy)];
@@ -244,7 +246,6 @@ export async function routeExecution(workers, requirements, options = {}) {
     if (routes.length === 0)
         throw new Error('No executable worker+model route satisfies authoritative constraints');
     const fallback = fallbackRoute(routes);
-    const rules = await loadExecutionRouterRules(options.rulesPath);
     const preferredChatgptConcurrency = options.preferredChatgptConcurrency ?? DEFAULT_CHATGPT_PREFERRED_CONCURRENCY;
     const chatgptRunning = options.chatgptRunning ?? 0;
     const taskFacts = options.taskFacts ?? {};
@@ -279,8 +280,6 @@ export async function routeExecution(workers, requirements, options = {}) {
                 reviewer_diversity: taskFacts.reviewer_diversity,
             } : null,
         },
-        user_input_rules: rules.text,
-        routing_instruction: routingInstruction,
         runtime: {
             chatgpt_running: chatgptRunning,
             preferred_chatgpt_concurrency: preferredChatgptConcurrency,
@@ -288,7 +287,7 @@ export async function routeExecution(workers, requirements, options = {}) {
         worker_candidates: workerProviderFacts(routes),
         effective_choices: effectiveChoices,
     }));
-    const question = 'Choose one complete route from the merged choice list. Relay has already merged profile defaults with the user\'s explicit [choices] and applied every authoritative hard gate, so only these routes are legal. Follow [routing_instruction] verbatim; do not invent, add, or substitute routes that are not listed.';
+    const question = appendRoutingInstruction('Choose one complete route from the merged choice list. Relay has already merged profile defaults with the user\'s explicit [choices] and applied every authoritative hard gate, so only these routes are legal. Do not invent, add, or substitute routes that are not listed.', routingInstruction);
     let selected = fallback;
     let evidence = { mode: options.decisionMode ?? 'off', fallback: true };
     const decisionStages = [];

package/dist/model-routing.js

@@ -5,6 +5,7 @@ import { chooseWithDecision } from './decision.js';
 import { usageForProvider } from './worker-routing.js';
 import { makeDecisionAudit } from './decision-audit.js';
 import { loadRoutingPolicy, policyAllows, policyRank } from './routing-policy.js';
+import { appendRoutingInstruction } from './router-rules.js';
 export function modelChoiceId(candidate) {
     return candidate.id + (candidate.reasoning ? '@' + candidate.reasoning : '');
 }
@@ -170,14 +171,13 @@ export async function routeModel(worker, candidates, options = {}) {
         : await chooseWithDecision(options.decisionEngine, options.decisionMode ?? 'off', {
             facts: JSON.parse(JSON.stringify({
                 task: options.taskFacts ?? {},
-                user_input_rules: policy.rules.text,
                 structured_policy: policy.snapshot,
                 prior_decision_id: options.priorDecisionId ?? null,
                 prior_failure: options.priorFailure ?? null,
                 worker: { id: worker.workerId, adapter: worker.adapter, capabilities: [...worker.capabilities] },
                 candidates: eligible.map(item => ({ id: item.id, provider: item.provider, model: item.model, profile: item.profile ?? null, reasoning: item.reasoning ?? null, resourceHealthy: item.resourceHealthy ?? null, resourceUsedPercent: item.resourceUsedPercent ?? null, resourceRemainingPercent: item.resourceRemainingPercent ?? null, resourceResetAt: item.resourceResetAt ?? null, resourceResetInMinutes: item.resourceResetInMinutes ?? null, resourceWindows: item.resourceWindows ?? null })),
             })),
-        }, { type: 'choice', question: 'Which eligible model profile is best suited to execute this task? Apply hard gates first, then explicit task constraints, then current user input rules and structured policy; consider every quota window and never violate task fit or continuity.', choices: eligible.map(modelChoiceId) }, () => modelChoiceId(deterministic));
+        }, { type: 'choice', question: appendRoutingInstruction('Which eligible model profile is best suited to execute this task? Apply hard gates first, then explicit task constraints, then structured policy; consider every quota window and never violate task fit or continuity.', policy.rules.parsed.routingInstruction), choices: eligible.map(modelChoiceId) }, () => modelChoiceId(deterministic));
     const selected = eligible.find(item => modelChoiceId(item) === choice.choice) ?? deterministic;
     const routing = {
         provider: selected.provider,

package/dist/relayd.js

@@ -3,7 +3,7 @@ import { once } from 'node:events';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { ChatGptAdapter, CodexAdapter } from './adapters.js';
+import { ChatGptAdapter, CodexAdapter, ensureChatGptBrowserWorkspace } from './adapters.js';
 import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
 import { serveDashboard } from './dashboard.js';
 import { RepositoryWorkerPool, aggregateManagedGitHubJobs } from './pool.js';
@@ -35,6 +35,15 @@ export async function overlayOperationalOverviews(overviews, storeFor) {
         return { ...item, job };
     }));
 }
+function managedOverviewKey(item) {
+    return item.job.repository + '#' + item.job.prNumber + ':' + item.job.id;
+}
+export function mergeOperationalInventory(current, discovered) {
+    const merged = new Map(current.map(item => [managedOverviewKey(item), item]));
+    for (const item of discovered)
+        merged.set(managedOverviewKey(item), item);
+    return [...merged.values()];
+}
 const PR_REFRESH_COALESCE_MS = 1000;
 export const SCHEDULE_HEARTBEAT_MS = 600_000;
 export function dueScheduledOverviews(overviews, now = new Date()) {
@@ -120,6 +129,7 @@ export async function runDaemon(argv) {
         return;
     }
     configureExecutionRouterRulesPath(argv);
+    await ensureChatGptBrowserWorkspace();
     const normalized = normalizeDaemonArguments(argv);
     if (normalized.pullRequest && normalized.jobId) {
         await startService([...argv]);
@@ -183,9 +193,8 @@ export async function runDaemon(argv) {
         try {
             githubReadPaths.workspaceScans += 1;
             const refreshed = await withGitHubRequestContext(client, 'relayd.workspace-refresh', () => aggregateManagedGitHubJobs(client, scanRepositories, trusted));
-            const scanned = new Set(scanRepositories);
-            const merged = dashboardManagedJobs([...cachedOverviews.filter(item => !scanned.has(item.job.repository)), ...refreshed]);
-            cachedOverviews = await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber));
+            const merged = mergeOperationalInventory(cachedOverviews, refreshed);
+            cachedOverviews = dashboardManagedJobs(await overlayOperationalOverviews(merged, (repository, prNumber) => runtimeStore(repository, prNumber)));
             return cachedOverviews;
         }
         catch (error) {
@@ -382,7 +391,7 @@ export async function runDaemon(argv) {
         const runtime = summarizeRuntime(cachedOverviews.map(item => item.job));
         const workers = workerCandidates([
             { name: 'codex', id: 'codex', capabilities: ['model', 'codex'] },
-            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-harness'] },
+            { name: 'chatgpt', id: 'chatgpt/browser-worker', capabilities: ['model', 'chatgpt', 'browser-workspace'] },
         ], [], usage);
         const result = await routeExecution(workers, task.workerRequirements ?? { capabilities: task.capabilities ?? [] }, {
             decisionEngine: new LayaCliDecisionEngine(),

package/dist/router-evals.js

@@ -1,5 +1,6 @@
 import { executionTaskShape } from './execution-routing.js';
 import { loadExecutionRouterRules } from './routing-policy.js';
+import { appendRoutingInstruction } from './router-rules.js';
 export const ROUTER_EVAL_CASES = [
     { id: 'small-review', storySize: 'S', task: 'Review a focused PR and explain any correctness issue.', chatgptAvailable: true, expectedWorker: 'chatgpt' },
     { id: 'medium-investigation', storySize: 'M', task: 'Investigate why a Relay job is blocked and propose a focused fix.', chatgptAvailable: true, expectedWorker: 'chatgpt' },
@@ -62,14 +63,12 @@ export async function runRouterEvals(engine, rulesPath) {
                 },
                 reviewer: null,
             },
-            user_input_rules: rules.text,
             runtime: { chatgpt_running: testCase.chatgptRunning ?? 0, preferred_chatgpt_concurrency: 10 },
             worker_candidates: workerCandidates,
-            routing_instruction: 'Choose one route from the merged choice list. Profile defaults and explicit [choices] have already been merged and hard-gated; do not invent additional routes.',
         }));
         const decision = await engine.decide({ facts }, {
             type: 'choice',
-            question: 'Choose one legal route from the merged choice list. Each provider default is available; extra model/reasoning routes appear only when explicitly listed in [choices]. Use context, code-plan quota, runtime load, and routing_instruction.',
+            question: appendRoutingInstruction('Choose one legal route from the merged choice list. Each provider default is available; extra model/reasoning routes appear only when explicitly listed in [choices]. Use context, code-plan quota, and runtime load.', rules.parsed.routingInstruction),
             choices,
         });
         if (decision.type !== 'choice')

package/dist/router-rules.js

@@ -27,7 +27,7 @@ function sectionOf(line) {
     return match ? match[1].toLowerCase() : null;
 }
 function choiceKey(choice) {
-    return [choice.provider, choice.model, choice.reasoning ?? ''].join('\u0000');
+    return [choice.worker ?? '', choice.provider, choice.model, choice.reasoning ?? ''].join('\u0000');
 }
 /**
  * Return the raw body of the first section named `name`, exactly as authored.
@@ -61,6 +61,11 @@ function rawSectionBody(text, name) {
  * `[choices]` entries are deduplicated deterministically (first occurrence
  * wins). The `[routing-instruction]` body is captured verbatim.
  */
+export function appendRoutingInstruction(question, instruction) {
+    if (!instruction)
+        return question;
+    return question + '\n\n' + instruction;
+}
 export function parseRouterRules(text) {
     const choices = [];
     const seen = new Set();
@@ -77,6 +82,21 @@ export function parseRouterRules(text) {
             continue;
         if (!rawLine.trim() || rawLine.trim().startsWith('#'))
             continue;
+        const route = rawLine.trim().match(/^([A-Za-z0-9._/-]+)::([A-Za-z0-9._-]+):([A-Za-z0-9._/-]+)(?:@([A-Za-z0-9._-]+))?$/);
+        if (route) {
+            const choice = {
+                worker: route[1],
+                provider: route[2],
+                model: route[3],
+                ...(route[4] ? { reasoning: route[4].toLowerCase() } : {}),
+            };
+            const key = choiceKey(choice);
+            if (!seen.has(key)) {
+                seen.add(key);
+                choices.push(choice);
+            }
+            continue;
+        }
         const match = rawLine.match(/^\s*([A-Za-z0-9._-]+)\s*:\s*(.+)$/);
         if (!match)
             continue;

package/dist/store.js

@@ -70,7 +70,7 @@ export async function loadManagedGitHubJobGraphql(client, repository, prNumber,
     return (await loadManagedGitHubPullRequestGraphql(client, repository, prNumber, trustedAuthors)).find(item => item.job.id === jobId) ?? null;
 }
 const COMPLETED_JOB_HISTORY_LIMIT = 10;
-function isCompletedManagedJob(item) { return ['COMPLETED', 'CANCELLED'].includes(item.job.state) || item.githubState !== 'OPEN'; }
+function isCompletedManagedJob(item) { return ['COMPLETED', 'CANCELLED'].includes(item.job.state); }
 function completedAt(item) {
     return [item.job.updatedAt, item.mergedAt, item.closedAt].filter((value) => typeof value === 'string' && value.length > 0).sort().at(-1) ?? '';
 }

package/dist/worker-routing.js

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

package/package.json

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