agents-relay 1.0.4 → 1.0.6

package/README.md

@@ -1,6 +1,6 @@
 # Agents Relay
 
-Agents Relay is a generic TypeScript runtime for durable asynchronous agent jobs coordinated through GitHub pull requests. GitHub PR comments are the source of truth; events only wake the reconciler and update the dashboard.
+Agents Relay is a generic TypeScript runtime for durable asynchronous agent jobs coordinated through GitHub pull requests. GitHub PR comments store durable workflow state; correlated terminal events are authoritative for model-backed task lifecycle transitions.
 
 ## Quick start
 
@@ -11,7 +11,8 @@ npx agents-relay job create --repo OWNER/REPO --head feat/example --base main \
   --id job-1 --title "Objective" --body "PR description" --mode fixed
 
 npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 \
-  --task-id child --input "echo hello" --adapter shell
+  --task-id child --adapter codex --provider openai --model MODEL --output task-pr \
+  --input "Implement the described child task and publish a terminal event."
 
 npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1
 npx agents-relay status --repo OWNER/REPO --pr 12 --id job-1
@@ -67,14 +68,14 @@ For explicit local demo/test mode:
 npm install
 npm run build
 node dist/cli.js init --file .agents-relay.json --title "Dogfood" --id demo
-node dist/cli.js submit --file .agents-relay.json --task-id hello --input "echo hello" --adapter shell
+node dist/cli.js submit --file .agents-relay.json --task-id hello --adapter codex --provider openai --model MODEL --output task-pr --input "Complete the described task"
 node dist/cli.js reconcile --file .agents-relay.json
 npx agents-relay serve --file .agents-relay.json
 ~~~
 
 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 and can use --events nats --subject-prefix PREFIX for optional wakeups. See [docs/service.md](docs/service.md). --file PATH is explicit local demo/test mode only.
+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.
 
 `agents-relayd` without `--pr`/`--id` runs in workspace mode by default: it discovers nested Git repositories under `~/Workspace`, keeps only GitHub `origin` remotes, and aggregates their managed PR jobs into one dashboard and worker pool. Pass `--workspace PATH` to use another root. `--repo OWNER/REPO` remains the single-repository pool mode.
 
@@ -86,25 +87,25 @@ Codex/model-backed tasks require --provider and --model (or equivalent routing m
 
 The minimal agent-network surface is machine-driven registration and discovery. `agent-register` persists an agent identity, responsibility boundary, claimed capabilities, endpoint/runtime, availability, and routing metadata in a trusted PR marker; `agent-discover` applies hard filters and returns evidence-backed candidates. Adapters remain runtimes, not agent identities. See [docs/architecture.md](docs/architecture.md) for the constrained future remote submission contract.
 
-### ChatGPT workers through the browser-worker agent
+### Agent worker lifecycle
 
-Use the chatgpt adapter to launch the installed `chatgpt-browser-worker` agent through a local model harness. The observed ChatGPT `thread_id` is stored as the task `threadId`, so lineage is durable and a retry continues the same conversation.
+Managed tasks are descriptive work for agents, not shell commands. Use `codex` or `chatgpt` for worker tasks. Commands such as tests, build tools, Markad Vision, ffmpeg, and other CLIs are invoked by the orchestrator or by an executing agent; they are not worker adapters.
 
-Managed Codex and ChatGPT worker prompts automatically receive the durable PR URL plus job/task/parent/project context before the original task input. The stored task input is not rewritten.
+Every model-backed task declares a durable output with `--output task-pr` or `--output file --output-path PATH`. Agents Relay enriches the prompt with the PR URL, job/task identity, output contract, and mandatory terminal-event contract.
 
-Each ChatGPT task owns its own conversation. Retries reuse that task's conversation; sibling tasks never share a conversation merely because they use the same adapter. When the job reaches COMPLETED, or GitHub reports the PR merged, Agents Relay asks the browser-worker agent to delete every ChatGPT task conversation. The durable threadId remains in the task marker with threadDeletedAt for audit history. Failed deletion records threadCleanupError and is retried on later reconciliation without reopening the terminal job.
+For Codex and ChatGPT, **events are authoritative task state**. A process exit or browser submission receipt does not complete a task. The executing agent must publish exactly one correlated `task.completed`, `task.failed`, or `task.blocked` event. Relay persists the matching durable state only from that terminal event. Model-backed tasks require an event bus and time out explicitly if no terminal event arrives.
+
+The ChatGPT adapter uses the packaged `chatgpt-browser-worker` as a one-shot submitter. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, closes the owned tab, and returns. It does not poll for the assistant response, resume/reopen a thread, or use conversation text as the result channel. Any observed ChatGPT thread ID is diagnostic only.
 
 ~~~sh
 npx agents-relay submit --repo OWNER/REPO --pr 5 --id job-1 \
   --task-id research-ui --adapter chatgpt \
   --capabilities model,chatgpt,browser-harness \
-  --provider openai --model gpt-5-6-sol --reasoning high \
-  --chatgpt-project g-p-EXACT_PROJECT_ID \
-  --input "Research the dashboard UX and return implementation guidance."
+  --provider openai --model MODEL \
+  --output file --output-path runs/research-ui.md \
+  --input "Research the dashboard UX and write the final report to the declared output file."
 ~~~
 
-The adapter discovers `chatgpt-browser-worker/agents/browser-worker.agent.md` from `AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT` first, then `AGENTS_RELAY_SKILL_ROOTS`, `~/.codex/skills`, `~/.agents/skills`, and the local `skills` directory. It runs the definition and one typed JSON request through the configured local harness (`AGENTS_RELAY_AGENT_HARNESS`, default `codex`). Normal consumers do not need a Neo source checkout.
-
 GitHub PR state is authoritative for terminal lifecycle: a merged PR reconciles its managed job to `COMPLETED`; a closed, unmerged PR reconciles to `CANCELLED` and cannot launch queued work. The dashboard exposes `/api/jobs` and shows repository-wide managed PR state beside each durable Agents Relay job state so stale markers are visible instead of being mistaken for current truth.
 
 For work that was completed outside the relay but must be represented truthfully in durable history, use `npx agents-relay record --task-id <id> --summary <summary> --commit <sha>`. Recorded tasks use the `orchestrator` adapter and terminal `SUCCEEDED` state; they do not pretend a shell/model worker executed the work. This is a repair/backfill mechanism—normal work should be submitted before execution. Managed jobs also retain the GitHub PR body as the job description for dashboard display.

package/dist/adapters.js

@@ -1,9 +1,9 @@
 import { spawn } from 'node:child_process';
-import { access, readFile, readdir } from 'node:fs/promises';
+import { access, readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { randomUUID } from 'node:crypto';
-function commandExecution(child, output, signal, id) { const promise = new Promise((resolve, reject) => { child.on('error', reject); child.on('close', code => code === 0 ? resolve({ summary: output().trim() || 'Command completed' }) : reject(new Error(output().trim() || `Command exited ${code}`))); signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true }); }); return { id, promise, cancel: () => { child.kill('SIGTERM'); } }; }
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
     if (route.profile)
@@ -19,277 +19,189 @@ export function buildCodexArgs(route, input) {
     args.push('--', input);
     return args;
 }
-function parseThreadStarted(line) { try {
-    const value = JSON.parse(line);
-    return value.type === 'thread.started' && typeof value.thread_id === 'string' ? value.thread_id : undefined;
-}
-catch {
-    return undefined;
-} }
-function parseCodexAssistantMessage(line) {
+function parseThreadStarted(line) {
     try {
         const value = JSON.parse(line);
-        const payload = value.payload;
-        if (value.type === 'event_msg' && payload?.type === 'task_complete' && typeof payload.last_agent_message === 'string')
-            return payload.last_agent_message.trim() || undefined;
-        const item = value.item;
-        if (value.type === 'item.completed' && item?.type === 'agent_message' && typeof item.text === 'string')
-            return item.text.trim() || undefined;
+        return value.type === 'thread.started' && typeof value.thread_id === 'string' ? value.thread_id : undefined;
+    }
+    catch {
+        return undefined;
     }
-    catch { /* non-JSON diagnostic output is ignored on successful Codex runs */ }
-    return undefined;
 }
 function appendTail(current, chunk, maxBytes = 16384) {
     const combined = current + chunk;
-    return Buffer.byteLength(combined) <= maxBytes ? combined : Buffer.from(combined).subarray(-maxBytes).toString('utf8');
-}
-export class ShellAdapter {
-    shell;
-    name = 'shell';
-    id = 'shell';
-    capabilities = ['shell', 'command'];
-    constructor(shell = false) {
-        this.shell = shell;
-    }
-    launch(task, signal) { const parts = task.input.split(' ').filter(Boolean); const child = this.shell ? spawn(task.input, { shell: true }) : spawn(parts[0] ?? 'true', parts.slice(1)); let output = ''; child.stdout?.on('data', (x) => { output += x.toString(); }); child.stderr?.on('data', (x) => { output += x.toString(); }); return commandExecution(child, () => output, signal, randomUUID()); }
+    return Buffer.byteLength(combined) <= maxBytes
+        ? combined
+        : Buffer.from(combined).subarray(-maxBytes).toString('utf8');
 }
 export class CodexAdapter {
     command;
-    sessionsRoot;
     name = 'codex';
     id = 'codex';
     capabilities = ['model', 'codex'];
-    constructor(command = 'codex', sessionsRoot = join(homedir(), '.codex', 'sessions')) {
+    constructor(command = 'codex') {
         this.command = command;
-        this.sessionsRoot = sessionsRoot;
     }
     launch(task, signal) {
         if (!task.routing)
             throw new Error(`Task ${task.id} requires routing metadata before Codex launch`);
-        const route = task.routing;
-        const args = buildCodexArgs(route, task.input);
-        const child = spawn(this.command, args, { shell: false, cwd: route.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+        const child = spawn(this.command, buildCodexArgs(task.routing, task.input), {
+            shell: false,
+            cwd: task.routing.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
         let stdoutBuffer = '';
-        let finalAssistantMessage = '';
         let stderrTail = '';
         let bufferedThreadId;
         let execution;
         const consumeLine = (line) => {
             const threadId = parseThreadStarted(line);
-            if (threadId) {
-                bufferedThreadId = threadId;
-                if (execution) {
-                    execution.threadId = threadId;
-                    execution.onThreadStarted?.(threadId);
-                }
+            if (!threadId)
+                return;
+            bufferedThreadId = threadId;
+            if (execution) {
+                execution.threadId = threadId;
+                execution.onThreadStarted?.(threadId);
             }
-            const assistantMessage = parseCodexAssistantMessage(line);
-            if (assistantMessage)
-                finalAssistantMessage = assistantMessage;
         };
-        child.stdout?.on('data', (x) => {
-            stdoutBuffer += x.toString();
+        child.stdout?.on('data', (chunk) => {
+            stdoutBuffer += chunk.toString();
             const lines = stdoutBuffer.split(/\r?\n/);
             stdoutBuffer = lines.pop() ?? '';
             for (const line of lines)
                 consumeLine(line);
         });
-        child.stderr?.on('data', (x) => { stderrTail = appendTail(stderrTail, x.toString()); });
-        const id = randomUUID();
+        child.stderr?.on('data', (chunk) => {
+            stderrTail = appendTail(stderrTail, chunk.toString());
+        });
         const promise = new Promise((resolve, reject) => {
             child.on('error', reject);
             child.on('close', code => {
                 if (stdoutBuffer)
                     consumeLine(stdoutBuffer);
-                if (code === 0)
-                    resolve({ summary: finalAssistantMessage || 'Codex task completed' });
-                else
+                if (code === 0) {
+                    resolve({ summary: 'Codex runtime exited after task execution; terminal task state is event-owned' });
+                }
+                else {
                     reject(new Error(stderrTail.trim() || `Codex exited ${code}`));
+                }
             });
             signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
         });
-        execution = { id, promise, cancel: () => { child.kill('SIGTERM'); } };
+        execution = { id: randomUUID(), promise, cancel: () => child.kill('SIGTERM') };
         execution.threadId = bufferedThreadId;
         return execution;
     }
-    async recover(task) {
-        if (!task.threadId)
-            return null;
-        let entries;
-        try {
-            entries = await readdir(this.sessionsRoot, { recursive: true, encoding: 'utf8' });
-        }
-        catch {
-            return null;
-        }
-        const filename = entries.find(entry => entry.endsWith(`${task.threadId}.jsonl`));
-        if (!filename)
-            return null;
-        let lines;
-        try {
-            lines = (await readFile(join(this.sessionsRoot, filename), 'utf8')).split(/\r?\n/);
-        }
-        catch {
-            return null;
-        }
-        for (let index = lines.length - 1; index >= 0; index -= 1) {
-            const line = lines[index];
-            if (!line)
-                continue;
-            try {
-                const value = JSON.parse(line);
-                if (value.type !== 'event_msg')
-                    continue;
-                const payload = value.payload;
-                if (payload?.type !== 'task_complete')
-                    continue;
-                const summary = typeof payload.last_agent_message === 'string' ? payload.last_agent_message.trim() : '';
-                return { summary: summary || 'Codex task completed', data: { recoveredFromThread: task.threadId } };
-            }
-            catch { /* ignore malformed session rows */ }
-        }
-        return null;
-    }
+}
+export class LaunchFailure extends Error {
 }
 function browserWorkerCandidates(explicit) {
     const roots = (process.env.AGENTS_RELAY_SKILL_ROOTS ?? '').split(':').filter(Boolean);
-    return [explicit, ...roots, join(homedir(), '.codex', 'skills'), join(homedir(), '.agents', 'skills'), join(process.cwd(), 'skills')]
+    const packageSkills = join(dirname(fileURLToPath(import.meta.url)), '..', 'skills');
+    return [
+        explicit,
+        ...roots,
+        packageSkills,
+        join(homedir(), '.codex', 'skills'),
+        join(homedir(), '.agents', 'skills'),
+        join(process.cwd(), 'skills'),
+    ]
         .filter((value) => Boolean(value))
-        .map(value => value.endsWith('browser-worker.agent.md') ? value : join(value, 'chatgpt-browser-worker', 'agents', 'browser-worker.agent.md'));
+        .map(value => value.endsWith('browser-worker.agent.md')
+        ? value
+        : join(value, 'chatgpt-browser-worker', 'agents', 'browser-worker.agent.md'));
 }
-async function loadBrowserWorkerDefinition(explicit) {
+async function loadBrowserWorkerRuntime(explicit) {
     for (const candidate of browserWorkerCandidates(explicit)) {
         try {
             await access(candidate);
-            return readFile(candidate, 'utf8');
+            return { definition: await readFile(candidate, 'utf8'), root: dirname(dirname(candidate)) };
+        }
+        catch {
+            // Try the next installed skill root.
         }
-        catch { /* try the next installed skill root */ }
     }
     throw new Error('chatgpt-browser-worker agent definition not found; set AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT');
 }
-function thinkingLevel(reasoning) {
-    if (reasoning === 'low' || reasoning === 'medium' || reasoning === 'high')
-        return reasoning;
-    if (reasoning === 'minimal')
-        return 'low';
-    return 'default';
-}
-function parseBrowserWorkerResponse(output) {
-    const text = output.trim().replace(/^```(?:json)?\s*|\s*```$/g, '').trim();
-    let value;
-    try {
-        value = JSON.parse(text);
-    }
-    catch {
-        throw new Error('browser-worker returned non-JSON output');
+function parseDriverJson(output) {
+    const lines = output.trim().split(/\r?\n/).filter(Boolean);
+    for (let index = lines.length - 1; index >= 0; index -= 1) {
+        try {
+            const value = JSON.parse(lines[index]);
+            if (value.operation !== 'submit' || value.status !== 'submitted')
+                continue;
+            return value;
+        }
+        catch {
+            // Browser-harness diagnostics may precede the final JSON observation.
+        }
     }
-    if (!value || typeof value !== 'object')
-        throw new Error('browser-worker returned an invalid JSON response');
-    const response = value;
-    if (!response.operation || !response.status)
-        throw new Error('browser-worker response omitted operation or status');
-    return response;
+    throw new Error('browser-worker driver returned no submitted receipt');
 }
-function agentPrompt(definition, request) {
-    return `${definition}\n\nReturn only the machine-readable JSON response required by the agent contract.\nREQUEST_JSON:\n${JSON.stringify(request)}`;
-}
-function defaultChatGptAgentRunner(harness) {
-    return (definition, request, route, signal) => {
-        const child = spawn(harness, buildCodexArgs(route, agentPrompt(definition, request)), { shell: false, cwd: route.cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+function directBrowserWorkerRunner(root) {
+    return (_definition, request, _route, signal) => {
+        const args = [join(root, 'scripts', 'temporary_bh.py'), '--prompt', request.prompt];
+        for (const file of request.files ?? [])
+            args.push('--file', file);
+        const child = spawn('python3', args, { shell: false, stdio: ['ignore', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
-        child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
-        child.stderr?.on('data', (chunk) => { stderr = appendTail(stderr, chunk.toString()); });
+        child.stdout?.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr = appendTail(stderr, chunk.toString());
+        });
         const promise = new Promise((resolve, reject) => {
             child.on('error', reject);
-            child.on('close', code => code === 0 ? resolve(parseCodexAgentMessage(stdout) ?? stdout.trim()) : reject(new Error(stderr.trim() || `browser-worker harness exited ${code}`)));
+            child.on('close', code => {
+                if (code !== 0) {
+                    reject(new Error(stderr.trim() || stdout.trim() || `browser-worker driver exited ${code}`));
+                    return;
+                }
+                try {
+                    resolve(JSON.stringify(parseDriverJson(stdout)));
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
             if (signal.aborted)
                 child.kill('SIGTERM');
             else
                 signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
         });
-        return { promise, cancel: () => { child.kill('SIGTERM'); } };
+        return { promise, cancel: () => child.kill('SIGTERM') };
     };
 }
-function parseCodexAgentMessage(output) {
-    let final;
-    for (const line of output.split(/\r?\n/)) {
-        try {
-            const value = JSON.parse(line);
-            const payload = value.payload;
-            const item = value.item;
-            if (value.type === 'event_msg' && payload?.type === 'task_complete' && typeof payload.last_agent_message === 'string')
-                final = payload.last_agent_message;
-            if (value.type === 'item.completed' && item?.type === 'agent_message' && typeof item.text === 'string')
-                final = item.text;
-        }
-        catch { /* harness diagnostics are not the agent response */ }
+function parseBrowserWorkerResponse(output) {
+    const text = output.trim().replace(/^\`\`\`(?:json)?\s*|\s*\`\`\`$/g, '').trim();
+    let value;
+    try {
+        value = JSON.parse(text);
     }
-    return final;
-}
-function browserWorkerError(response) {
-    const detail = response.error?.message || `browser-worker ${response.status}`;
-    return new Error(response.error?.code ? `${response.error.code}: ${detail}` : detail);
+    catch {
+        throw new Error('browser-worker returned non-JSON output');
+    }
+    if (!value || typeof value !== 'object')
+        throw new Error('browser-worker returned an invalid JSON response');
+    const response = value;
+    if (response.operation !== 'submit' || response.status !== 'submitted') {
+        throw new Error('browser-worker did not return a submitted receipt');
+    }
+    if (response.verified !== true)
+        throw new Error('browser-worker submission was not verified');
+    return response;
 }
 export class ChatGptAdapter {
     name = 'chatgpt';
     id = 'chatgpt/browser-worker';
     capabilities = ['model', 'chatgpt', 'browser-harness'];
     agentPath;
-    harness;
     runner;
-    deleted = new Set();
-    routes = new Map();
-    constructor(options = {}) { this.agentPath = options.agentPath ?? process.env.AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT; this.harness = options.harness ?? process.env.AGENTS_RELAY_AGENT_HARNESS ?? 'codex'; this.runner = options.agentRunner; }
-    async run(request, route, signal) {
-        const definition = await loadBrowserWorkerDefinition(this.agentPath);
-        if (signal.aborted)
-            throw new Error('browser-worker execution aborted');
-        const run = (this.runner ?? defaultChatGptAgentRunner(this.harness))(definition, request, route, signal);
-        const output = await new Promise((resolve, reject) => {
-            const abort = () => { run.cancel(); reject(new Error('browser-worker execution aborted')); };
-            if (signal.aborted) {
-                abort();
-                return;
-            }
-            signal.addEventListener('abort', abort, { once: true });
-            run.promise.then(value => { signal.removeEventListener('abort', abort); resolve(value); }, error => { signal.removeEventListener('abort', abort); reject(error); });
-        });
-        return parseBrowserWorkerResponse(output);
-    }
-    project(task, route) {
-        return { name: task?.projectName ?? route.projectId ?? 'default', id: route.projectId };
-    }
-    exposeThread(execution, expected, response) {
-        const threadId = typeof response.thread_id === 'string' && response.thread_id.trim() ? response.thread_id : undefined;
-        if (!threadId)
-            throw new Error('browser-worker response omitted thread_id');
-        if (expected && threadId !== expected)
-            throw new Error('browser-worker returned a different thread_id');
-        execution.threadId = threadId;
-        execution.onThreadStarted?.(threadId);
-        return threadId;
-    }
-    validateOperation(response, operation) {
-        if (response.operation !== operation)
-            throw new Error(`browser-worker response operation mismatch: expected ${operation}, got ${response.operation}`);
-        if (response.status === 'blocked' || response.status === 'failed')
-            throw browserWorkerError(response);
-    }
-    async deleteThread(threadId, task) {
-        if (this.deleted.has(threadId))
-            return;
-        const route = task?.routing ?? this.routes.get(threadId);
-        if (!route)
-            throw new Error(`Task routing metadata is required to delete browser-worker thread ${threadId}`);
-        const response = await this.run({ operation: 'delete', thread_id: threadId, project: this.project(task, route), state: null }, route, new AbortController().signal);
-        if (response.operation !== 'delete')
-            throw new Error(`browser-worker response operation mismatch: expected delete, got ${response.operation}`);
-        if (response.thread_id && response.thread_id !== threadId)
-            throw new Error('browser-worker returned a different thread_id');
-        if (response.status !== 'deleted' && response.status !== 'not_found')
-            throw browserWorkerError(response);
-        this.deleted.add(threadId);
+    constructor(options = {}) {
+        this.agentPath = options.agentPath ?? process.env.AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT;
+        this.runner = options.agentRunner;
     }
     launch(task, signal) {
         if (!task.routing)
@@ -301,45 +213,32 @@ export class ChatGptAdapter {
             abort();
         else
             signal.addEventListener('abort', abort, { once: true });
-        const execution = { id: randomUUID(), promise: Promise.resolve({ summary: '' }), cancel: abort };
-        const timeout = setTimeout(abort, Math.max(1, task.timeoutMs));
+        const execution = {
+            id: randomUUID(),
+            promise: Promise.resolve({ summary: '' }),
+            cancel: abort,
+        };
         execution.promise = (async () => {
+            const runtime = await loadBrowserWorkerRuntime(this.agentPath);
+            if (controller.signal.aborted)
+                throw new Error('browser-worker execution aborted');
+            const run = (this.runner ?? directBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input }, route, controller.signal);
             try {
-                const expectedThreadId = task.threadId;
-                const hasPrompt = Boolean(task.input.trim());
-                const operation = expectedThreadId ? (hasPrompt ? 'continue' : 'resume') : 'create';
-                const request = {
-                    operation, thread_id: expectedThreadId, project: this.project(task, route), prompt: hasPrompt ? task.input : undefined,
-                    thinking_level: thinkingLevel(route.reasoning), state: null,
+                const output = await run.promise;
+                const response = parseBrowserWorkerResponse(output);
+                return {
+                    summary: 'ChatGPT task submitted; terminal task state is event-owned',
+                    data: {
+                        submitted: true,
+                        diagnosticThreadId: response.diagnostic_thread_id ?? null,
+                        userMessageId: response.user_message_id ?? null,
+                    },
                 };
-                const response = await this.run(request, route, controller.signal);
-                const threadId = this.exposeThread(execution, expectedThreadId, response);
-                this.routes.set(threadId, route);
-                this.validateOperation(response, operation);
-                let status = response.status;
-                while (status !== 'awaiting_result' && status !== 'completed') {
-                    if (controller.signal.aborted)
-                        throw new Error('browser-worker execution aborted');
-                    await new Promise((resolve, reject) => {
-                        const timer = setTimeout(resolve, 25);
-                        controller.signal.addEventListener('abort', () => { clearTimeout(timer); reject(new Error('browser-worker execution aborted')); }, { once: true });
-                    });
-                    const statusResponse = await this.run({ operation: 'status', thread_id: threadId, project: this.project(task, route), state: null }, route, controller.signal);
-                    if (statusResponse.thread_id && statusResponse.thread_id !== threadId)
-                        throw new Error('browser-worker returned a different thread_id');
-                    this.validateOperation(statusResponse, 'status');
-                    status = statusResponse.status;
-                }
-                const resultResponse = await this.run({ operation: 'result', thread_id: threadId, project: this.project(task, route), state: null }, route, controller.signal);
-                if (resultResponse.thread_id && resultResponse.thread_id !== threadId)
-                    throw new Error('browser-worker returned a different thread_id');
-                this.validateOperation(resultResponse, 'result');
-                if (resultResponse.status !== 'completed' || resultResponse.result?.verified !== true || !resultResponse.result.message_id || !resultResponse.result.text?.trim())
-                    throw browserWorkerError(resultResponse);
-                return { summary: resultResponse.result.text.trim(), data: { threadId, messageId: resultResponse.result.message_id, verified: true, provider: route.provider, model: route.model } };
             }
-            finally {
-                clearTimeout(timeout);
+            catch (error) {
+                if (controller.signal.aborted)
+                    throw error;
+                throw new LaunchFailure(error instanceof Error ? error.message : String(error));
             }
         })();
         return execution;

package/dist/cli.js

@@ -7,7 +7,7 @@ import { randomUUID } from 'node:crypto';
 import { dashboardManagedJobs, InMemoryStore, GitHubStore, resolvePullRequest, listManagedGitHubJobs } from './store.js';
 import { githubAuthContext } from './github-auth.js';
 import { Reconciler } from './reconciler.js';
-import { ShellAdapter, CodexAdapter, ChatGptAdapter } from './adapters.js';
+import { CodexAdapter, ChatGptAdapter } from './adapters.js';
 import { CodexThreadContinuation, CommandContinuation, WebhookContinuation } from './continuation.js';
 import { NatsEventBus, eventFor } from './events.js';
 import { serveDashboard } from './dashboard.js';
@@ -95,10 +95,10 @@ Example:
     submit: `Queue a task for a managed job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, --id JOB_ID, and --input TEXT.
-Common: --task-id ID, --adapter shell|codex|chatgpt, --priority P0|P1|P2|P3, --max-attempts N.
+Required for worker tasks: --adapter codex|chatgpt, --model MODEL, and --output task-pr|file. File output also requires --output-path PATH.\nCommon: --task-id ID, --priority P0|P1|P2|P3, --max-attempts N. Model-backed execution requires --events nats in the running reconciler/daemon.
 
 Example:
-  npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 --task-id build --input "npm test"`,
+  npx agents-relay submit --repo OWNER/REPO --pr 12 --id job-1 --task-id build --adapter codex --provider openai --model gpt-5-6 --output task-pr --input "Run the required tests and report the result through events."`,
     record: `Backfill work completed outside the relay into durable history.
 
 Required: --file PATH or --repo/--pr/--id, plus --summary TEXT.
@@ -269,8 +269,8 @@ async function runTaskCommand(action, args) {
         throw new Error(`Task ${id} is ${task.state}; durable execution fields are immutable in this state`);
     if (hasArg(args, '--adapter')) {
         const adapter = arg(args, '--adapter');
-        if (!['shell', 'codex', 'chatgpt', 'orchestrator'].includes(adapter))
-            throw new Error('--adapter must be shell, codex, chatgpt, or orchestrator');
+        if (!['codex', 'chatgpt', 'orchestrator'].includes(adapter))
+            throw new Error('--adapter must be codex, chatgpt, or orchestrator');
         task.adapter = adapter;
     }
     if (hasArg(args, '--priority'))
@@ -346,7 +346,7 @@ 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 }, 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 runtime(store, args, bus) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); 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 ShellAdapter(), new CodexAdapter(modelRuntime), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, eventBus: bus, emit }); }
+export function runtime(store, args, bus) { const emit = (event) => { process.stderr.write(`${JSON.stringify(event)}\n`); }; const modelRuntime = arg(args, '--codex', 'codex'); 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()], continuations: [new CodexThreadContinuation(modelRuntime), new CommandContinuation(), new WebhookContinuation()], planner, eventBus: bus, emit }); }
 export async function createService(args) {
     const loaded = await storeFor(args);
     const upstream = eventBus(args);
@@ -490,8 +490,19 @@ async function main() {
     if (command === 'submit') {
         const now = new Date().toISOString();
         const model = arg(args, '--model');
+        const adapter = arg(args, '--adapter', 'codex');
+        const outputKind = arg(args, '--output');
+        const outputPath = arg(args, '--output-path');
+        if (!['codex', 'chatgpt'].includes(adapter))
+            throw new Error('submit adapter must be codex or chatgpt');
+        if (!model)
+            throw new Error('submit requires --model for codex/chatgpt tasks');
+        if (outputKind !== 'task-pr' && outputKind !== 'file')
+            throw new Error('submit requires --output task-pr|file');
+        if (outputKind === 'file' && !outputPath)
+            throw new Error('--output file requires --output-path');
         const routing = model ? { provider: arg(args, '--provider', 'openai'), model, profile: arg(args, '--profile') || undefined, reasoning: arg(args, '--reasoning') || undefined, cwd: arg(args, '--cwd') || undefined, projectId: arg(args, '--chatgpt-project') || undefined, decidedBy: 'cli', decidedAt: now } : undefined;
-        const task = { jobId: job.id, id: arg(args, '--task-id', randomUUID()), priority: priority(args, job.priority ?? 'P2'), projectName: arg(args, '--project') || undefined, agentName: arg(args, '--agent') || undefined, parentTaskId: arg(args, '--parent') || null, dependencies: arg(args, '--deps').split(',').filter(Boolean), capabilities: arg(args, '--capabilities').split(',').filter(Boolean), adapter: arg(args, '--adapter', 'shell'), input: arg(args, '--input', 'true'), routing, continuation: continuation(args), continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: Number(arg(args, '--max-attempts', '3')), leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, error: null, timeoutMs: Number(arg(args, '--timeout', '300000')), createdAt: now, updatedAt: now };
+        const task = { jobId: job.id, id: arg(args, '--task-id', randomUUID()), priority: priority(args, job.priority ?? 'P2'), projectName: arg(args, '--project') || undefined, agentName: arg(args, '--agent') || undefined, parentTaskId: arg(args, '--parent') || null, dependencies: arg(args, '--deps').split(',').filter(Boolean), capabilities: arg(args, '--capabilities').split(',').filter(Boolean), adapter, input: arg(args, '--input', 'true'), output: outputKind === 'file' ? { kind: 'file', path: outputPath } : { kind: 'task_pr' }, routing, continuation: continuation(args), continuationDeliveredAt: null, state: 'QUEUED', attempt: 0, maxAttempts: Number(arg(args, '--max-attempts', '3')), leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, error: null, timeoutMs: Number(arg(args, '--timeout', '300000')), createdAt: now, updatedAt: now };
         await store.appendTask(task);
         job.tasks.push(task);
         if (job.state === 'COMPLETED') {