agents-relay 1.0.2 → 1.0.4

package/README.md

@@ -17,6 +17,14 @@ npx agents-relay reconcile --repo OWNER/REPO --pr 12 --id job-1
 npx agents-relay status --repo OWNER/REPO --pr 12 --id job-1
 ~~~
 
+Mutable queued/retryable task fields can be changed in place without replacing the durable task identity. `task update` rejects `RUNNING`, `SUCCEEDED`, and `CANCELLED` tasks so active execution and terminal history cannot be rewritten. For example:
+
+~~~sh
+npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id child \
+  --adapter chatgpt --provider chatgpt --model gpt-5.6-sol --reasoning high \
+  --capabilities model,chatgpt,browser-harness
+~~~
+
 Jobs default to `fixed`, preserving the original submit-and-run behavior. Use
 `--mode autonomous` with `init` or `job create` to make reconciliation own
 planner progress. The durable status JSON and dashboard show the mode. An
@@ -78,24 +86,24 @@ 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 MacBridge
+### ChatGPT workers through the browser-worker agent
 
-Use the chatgpt adapter to make a relay task create a real ChatGPT web conversation through the local MacBridge runtime. The returned ChatGPT conversation_id is stored as the task threadId, so lineage is durable and a retry continues the same conversation.
+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 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.
 
-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 deletes every ChatGPT task conversation through MacBridge. 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.
+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.
 
 ~~~sh
 npx agents-relay submit --repo OWNER/REPO --pr 5 --id job-1 \
   --task-id research-ui --adapter chatgpt \
-  --capabilities model,chatgpt,macbridge \
+  --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."
 ~~~
 
-The adapter calls MacBridge's loopback-only /experimental/chatgpt/conversation endpoint. Configure it with --macbridge-url and --macbridge-token-file, or AGENTS_RELAY_MACBRIDGE_URL / AGENTS_RELAY_MACBRIDGE_TOKEN_FILE. By default it uses loopback port MAC_DEV_BRIDGE_HTTP_PORT (or 8788) and the MacBridge menu app token file under ~/Library/Application Support/MacDeveloperBridge/http-token. Secrets are read locally and are never stored in PR markers.
+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.
 

package/dist/adapters.js

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { readFile, readdir } from 'node:fs/promises';
+import { access, readFile, readdir } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
@@ -151,100 +151,145 @@ export class CodexAdapter {
         return null;
     }
 }
-function chatGptThinkingEffort(reasoning) {
-    if (reasoning === 'minimal' || reasoning === 'low' || reasoning === 'standard' || reasoning === 'high' || reasoning === 'max')
-        return reasoning;
-    if (reasoning === 'medium')
-        return 'standard';
-    if (reasoning === 'xhigh' || reasoning === 'extra-high')
-        return 'max';
-    return 'standard';
+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')]
+        .filter((value) => Boolean(value))
+        .map(value => value.endsWith('browser-worker.agent.md') ? value : join(value, 'chatgpt-browser-worker', 'agents', 'browser-worker.agent.md'));
 }
-function chatGptEndpoint(base) {
-    const configured = (base ?? process.env.AGENTS_RELAY_MACBRIDGE_URL ?? `http://127.0.0.1:${process.env.MAC_DEV_BRIDGE_HTTP_PORT ?? '8788'}`).replace(/\/+$/, '');
-    const url = new URL(configured);
-    if (url.pathname === '/experimental/chatgpt/conversation')
-        return url.toString().replace(/\/$/, '');
-    // --macbridge-url is a service origin. Do not inherit an unrelated API path
-    // such as /v1/responses from a model-router endpoint.
-    url.pathname = '/experimental/chatgpt/conversation';
-    url.search = '';
-    url.hash = '';
-    return url.toString();
+async function loadBrowserWorkerDefinition(explicit) {
+    for (const candidate of browserWorkerCandidates(explicit)) {
+        try {
+            await access(candidate);
+            return readFile(candidate, 'utf8');
+        }
+        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 chatGptTokenFile(file) {
-    return file ?? process.env.AGENTS_RELAY_MACBRIDGE_TOKEN_FILE ?? process.env.MAC_DEV_BRIDGE_HTTP_TOKEN_FILE ?? join(homedir(), 'Library', 'Application Support', 'MacDeveloperBridge', 'http-token');
+function thinkingLevel(reasoning) {
+    if (reasoning === 'low' || reasoning === 'medium' || reasoning === 'high')
+        return reasoning;
+    if (reasoning === 'minimal')
+        return 'low';
+    return 'default';
 }
-function chatGptConversationId(text) {
-    const match = /\"conversation_id\"\s*:\s*\"((?:\\.|[^\"\\])*)\"/.exec(text);
-    if (!match)
-        return undefined;
+function parseBrowserWorkerResponse(output) {
+    const text = output.trim().replace(/^```(?:json)?\s*|\s*```$/g, '').trim();
+    let value;
     try {
-        const value = JSON.parse(`\"${match[1]}\"`);
-        return typeof value === 'string' ? value : undefined;
+        value = JSON.parse(text);
     }
     catch {
-        return undefined;
+        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 || !response.status)
+        throw new Error('browser-worker response omitted operation or status');
+    return response;
 }
-async function readChatGptResponse(response, onConversationId) {
-    if (!response.body) {
-        const text = await response.text();
-        const conversationId = chatGptConversationId(text);
-        if (conversationId)
-            onConversationId(conversationId);
-        return text;
-    }
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let text = '';
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        text += decoder.decode(value, { stream: true });
-        const conversationId = chatGptConversationId(text);
-        if (conversationId)
-            onConversationId(conversationId);
+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'] });
+        let stdout = '';
+        let stderr = '';
+        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}`)));
+            if (signal.aborted)
+                child.kill('SIGTERM');
+            else
+                signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+        });
+        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 */ }
     }
-    text += decoder.decode();
-    const conversationId = chatGptConversationId(text);
-    if (conversationId)
-        onConversationId(conversationId);
-    return 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);
 }
 export class ChatGptAdapter {
     name = 'chatgpt';
-    id = 'chatgpt/macbridge';
-    capabilities = ['model', 'chatgpt', 'macbridge'];
-    endpoint;
-    tokenFile;
-    fetchImpl;
-    constructor(options = {}) {
-        this.endpoint = chatGptEndpoint(options.endpoint);
-        this.tokenFile = chatGptTokenFile(options.tokenFile);
-        this.fetchImpl = options.fetch ?? fetch;
-    }
-    async deleteThread(threadId) {
-        const token = (await readFile(this.tokenFile, 'utf8')).trim();
-        if (!token)
-            throw new Error(`MacBridge token file is empty: ${this.tokenFile}`);
-        const response = await this.fetchImpl(this.endpoint, {
-            method: 'DELETE',
-            headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
-            body: JSON.stringify({ conversation_id: threadId }),
+    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); });
         });
-        if (response.status === 404)
+        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;
-        if (!response.ok) {
-            let detail = '';
-            try {
-                const payload = await response.json();
-                detail = typeof payload.error === 'string' ? payload.error : '';
-            }
-            catch { }
-            throw new Error(detail || `MacBridge ChatGPT conversation delete failed (${response.status})`);
-        }
+        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);
     }
     launch(task, signal) {
         if (!task.routing)
@@ -257,54 +302,45 @@ export class ChatGptAdapter {
         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));
         execution.promise = (async () => {
-            const token = (await readFile(this.tokenFile, 'utf8')).trim();
-            if (!token)
-                throw new Error(`MacBridge token file is empty: ${this.tokenFile}`);
-            const body = {
-                prompt: task.input,
-                model: route.model,
-                thinking_effort: chatGptThinkingEffort(route.reasoning),
-                max_runtime_seconds: Math.max(30, Math.min(3600, Math.ceil(task.timeoutMs / 1000))),
-            };
-            if (route.projectId)
-                body.project_id = route.projectId;
-            if (task.threadId)
-                body.conversation_id = task.threadId;
-            const response = await this.fetchImpl(this.endpoint, {
-                method: 'POST',
-                headers: { authorization: `Bearer ${token}`, 'content-type': 'application/json' },
-                body: JSON.stringify(body),
-                signal: controller.signal,
-            });
-            let exposedConversationId;
-            const exposeConversationId = (conversationId) => {
-                if (exposedConversationId === conversationId)
-                    return;
-                exposedConversationId = conversationId;
-                execution.threadId = conversationId;
-                execution.onThreadStarted?.(conversationId);
-            };
-            const text = await readChatGptResponse(response, exposeConversationId);
-            let payload;
             try {
-                payload = JSON.parse(text);
+                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 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 } };
             }
-            catch {
-                throw new Error(`MacBridge returned unreadable ChatGPT response (${response.status})`);
+            finally {
+                clearTimeout(timeout);
             }
-            const conversationId = typeof payload.conversation_id === 'string' ? payload.conversation_id : exposedConversationId;
-            if (conversationId)
-                exposeConversationId(conversationId);
-            if (!response.ok)
-                throw new Error(typeof payload.error === 'string' ? payload.error : `MacBridge ChatGPT request failed (${response.status})`);
-            if (payload.complete !== true)
-                throw new Error('MacBridge ChatGPT conversation did not complete');
-            const assistantText = typeof payload.assistant_text === 'string' ? payload.assistant_text.trim() : '';
-            return {
-                summary: assistantText || 'ChatGPT conversation completed',
-                data: { conversationId, provider: route.provider, model: route.model },
-            };
         })();
         return execution;
     }

package/dist/cli.js

@@ -15,7 +15,7 @@ import { codexAndZaiUsageRegistry } from './usage.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
 import { extendRetryBudget } from './scheduler.js';
-const usage = 'agents-relay <job|init|submit|record|agent-register|agent-discover|status|reconcile|retry|cancel|serve> [options]';
+const usage = 'agents-relay <job|task|init|submit|record|agent-register|agent-discover|status|reconcile|retry|cancel|serve> [options]';
 const help = {
     root: `Agents Relay coordinates durable asynchronous agent jobs through GitHub pull requests.
 
@@ -24,6 +24,7 @@ Usage:
 
 Commands:
   job create|adopt|repair  Create or repair a durable GitHub-backed job
+  task update              Update mutable durable task fields in place
   init                     Create a local demo job or initialize a GitHub job
   submit                   Queue a task for a managed job
   record                   Backfill a completed task into durable history
@@ -76,6 +77,21 @@ Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID.
 
 Example:
   npx agents-relay job repair --repo OWNER/REPO --pr 12 --id job-12`,
+    task: `Manage a durable task.
+
+Usage:
+  npx agents-relay task update [options]
+
+Actions:
+  update  Update mutable task fields without changing task identity/history`,
+    'task update': `Update mutable durable task fields in place.
+
+Required: --task-id ID and the normal job storage options.
+Mutable while not RUNNING/SUCCEEDED/CANCELLED: --adapter, --priority, --input, --project, --agent, --parent, --deps, --capabilities, --timeout, --max-attempts, --provider, --model, --profile, --reasoning, --cwd, --chatgpt-project.
+Use --clear-routing to remove routing metadata. A model update requires --model; provider defaults to the existing provider or openai.
+
+Example:
+  npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id build --adapter chatgpt --provider chatgpt --model gpt-5.6-sol --reasoning high`,
     submit: `Queue a task for a managed job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, --id JOB_ID, and --input TEXT.
@@ -145,6 +161,8 @@ Example:
 export function helpText(command, action) {
     if (command === 'job')
         return action ? help[`job ${action}`] ?? help.job : help.job;
+    if (command === 'task')
+        return action ? help[`task ${action}`] ?? help.task : help.task;
     return command ? help[command] ?? help.root : help.root;
 }
 export const SERVICE_DEFAULTS = { port: 8787, watchdogMs: 300000, webhookWatchdogMs: 1800000, dashboardRefreshMs: 300000 };
@@ -172,6 +190,10 @@ class ServiceEventBus {
     }
 }
 function arg(args, name, fallback = '') { const index = args.indexOf(name); return index >= 0 ? args[index + 1] ?? fallback : fallback; }
+function hasArg(args, name) { return args.includes(name); }
+function integerArg(args, name, fallback) { if (!hasArg(args, name))
+    return fallback; const value = Number(arg(args, name)); if (!Number.isInteger(value) || value < 0)
+    throw new Error(`${name} must be a non-negative integer`); return value; }
 function repository(args) { const value = arg(args, '--repo'); if (!value)
     throw new Error('--repo is required for GitHub-backed operation'); return value; }
 function pullRequest(args) { const value = Number(arg(args, '--pr')); if (!Number.isInteger(value) || value <= 0)
@@ -233,6 +255,66 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
     await store.saveJob(job);
     return { job: await store.load(options.id), pr };
 }
+async function runTaskCommand(action, args) {
+    if (action !== 'update')
+        throw new Error(usage);
+    const { store, job, localFile } = await storeFor(args);
+    const id = arg(args, '--task-id');
+    if (!id)
+        throw new Error('task update requires --task-id');
+    const task = job.tasks.find(item => item.id === id);
+    if (!task)
+        throw new Error(`Task ${id} not found`);
+    if (['RUNNING', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
+        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');
+        task.adapter = adapter;
+    }
+    if (hasArg(args, '--priority'))
+        task.priority = priority(args, task.priority ?? job.priority ?? 'P2');
+    if (hasArg(args, '--input'))
+        task.input = arg(args, '--input');
+    if (hasArg(args, '--project'))
+        task.projectName = arg(args, '--project') || undefined;
+    if (hasArg(args, '--agent'))
+        task.agentName = arg(args, '--agent') || undefined;
+    if (hasArg(args, '--parent'))
+        task.parentTaskId = arg(args, '--parent') || null;
+    if (hasArg(args, '--deps'))
+        task.dependencies = arg(args, '--deps').split(',').filter(Boolean);
+    if (hasArg(args, '--capabilities'))
+        task.capabilities = arg(args, '--capabilities').split(',').filter(Boolean);
+    task.timeoutMs = integerArg(args, '--timeout', task.timeoutMs);
+    task.maxAttempts = integerArg(args, '--max-attempts', task.maxAttempts);
+    if (hasArg(args, '--max-attempts') && task.maxAttempts < task.attempt)
+        throw new Error('--max-attempts cannot be less than the current attempt count');
+    const routingFlags = ['--provider', '--model', '--profile', '--reasoning', '--cwd', '--chatgpt-project'];
+    if (args.includes('--clear-routing'))
+        task.routing = undefined;
+    else if (routingFlags.some(flag => hasArg(args, flag))) {
+        const current = task.routing;
+        const model = hasArg(args, '--model') ? arg(args, '--model') : current?.model;
+        if (!model)
+            throw new Error('task routing update requires --model when no existing routing is present');
+        task.routing = {
+            provider: hasArg(args, '--provider') ? arg(args, '--provider') : current?.provider ?? 'openai',
+            model,
+            profile: hasArg(args, '--profile') ? arg(args, '--profile') || undefined : current?.profile,
+            reasoning: hasArg(args, '--reasoning') ? arg(args, '--reasoning') || undefined : current?.reasoning,
+            cwd: hasArg(args, '--cwd') ? arg(args, '--cwd') || undefined : current?.cwd,
+            projectId: hasArg(args, '--chatgpt-project') ? arg(args, '--chatgpt-project') || undefined : current?.projectId,
+            decidedBy: 'cli:update',
+            decidedAt: new Date().toISOString()
+        };
+    }
+    task.updatedAt = new Date().toISOString();
+    await store.saveTask(task);
+    await saveLocal(localFile, job);
+    console.log(JSON.stringify(task, null, 2));
+}
 async function runJobCommand(action, args) {
     if (!['create', 'adopt', 'repair'].includes(action))
         throw new Error(usage);
@@ -264,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({ endpoint: arg(args, '--macbridge-url') || undefined, tokenFile: arg(args, '--macbridge-token-file') || undefined })], 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 ShellAdapter(), 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);
@@ -342,7 +424,7 @@ async function main() {
         return;
     }
     if (args.includes('--help') || args.includes('-h')) {
-        console.log(helpText(command, command === 'job' ? args[0] : undefined));
+        console.log(helpText(command, command === 'job' || command === 'task' ? args[0] : undefined));
         return;
     }
     if (command === 'job') {
@@ -350,6 +432,11 @@ async function main() {
         await runJobCommand(action ?? '', jobArgs);
         return;
     }
+    if (command === 'task') {
+        const [action, ...taskArgs] = args;
+        await runTaskCommand(action ?? '', taskArgs);
+        return;
+    }
     if (command === 'init') {
         const now = new Date().toISOString();
         const job = { id: arg(args, '--id', randomUUID()), title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), prNumber: Number(arg(args, '--pr', '0')), repository: arg(args, '--repo'), state: 'OPEN', continuation: continuation(args), createdAt: now, updatedAt: now, tasks: [] };

package/dist/reconciler.js

@@ -359,7 +359,7 @@ export class Reconciler {
             return;
         for (const task of job.tasks.filter(item => item.adapter === 'chatgpt' && item.threadId && !item.threadDeletedAt)) {
             try {
-                await adapter.deleteThread(task.threadId);
+                await adapter.deleteThread(task.threadId, task);
                 task.threadDeletedAt = new Date().toISOString();
                 task.threadCleanupError = null;
                 await this.store.saveTask(task);

package/dist/relayd.js

@@ -64,7 +64,7 @@ export async function runDaemon(argv) {
     const trusted = auth.trustedAuthors;
     const concurrency = Number(value(argv, '--concurrency', '4'));
     const bus = value(argv, '--events') === 'nats' ? new NatsEventBus(value(argv, '--nats-url', 'nats://127.0.0.1:4222'), value(argv, '--subject-prefix', 'agents-relay.events.job')) : undefined;
-    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new ShellAdapter(), new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter({ endpoint: value(argv, '--macbridge-url') || undefined, tokenFile: value(argv, '--macbridge-token-file') || undefined })], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), eventBus: bus });
+    const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new ShellAdapter(), new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), eventBus: bus });
     const repositories = normalized.repository
         ? [normalized.repository]
         : (await discoverWorkspaceRepositories(normalized.workspaceRoot ?? defaultWorkspaceRoot())).map(item => item.repository);

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -10,7 +10,7 @@ description: Create and operate durable asynchronous agent jobs through GitHub P
 This skill is the installable instruction/agent bundle. Do not require a local source checkout to execute Agents Relay. Use `npx agents-relay ...` for the executable CLI/runtime. Supporting agent definitions live under this skill directory and ship with the npm package; the default autonomous planner uses `agents/planner.agent.md`.
 
 
-Use Agents Relay for asynchronous work that must survive the current agent process. Create one durable top-level job per objective and submit child tasks with unique IDs, explicit parentTaskId, dependencies, capabilities, adapter, timeout, and retry policy. A model-backed task must carry a recorded routing decision (provider, model, optional profile/reasoning/cwd/projectId) before it can launch. Use adapter codex for local Codex-compatible workers and adapter chatgpt for a ChatGPT web worker created through MacBridge.
+Use Agents Relay for asynchronous work that must survive the current agent process. Create one durable top-level job per objective and submit child tasks with unique parentTaskId, dependencies, capabilities, adapter, timeout, and retry policy. A model-backed task must carry a recorded routing decision (provider, model, optional profile/reasoning/cwd/projectId) before it can launch. Use adapter codex for local Codex-compatible workers and adapter chatgpt for the installed `chatgpt-browser-worker` agent through a local model harness.
 
 GitHub PR comments are durable truth in operational mode. Reload the PR after every event or wake-up and reconcile desired durable state into worker executions; events and NATS are only low-latency notifications and must never be treated as completion.
 
@@ -62,11 +62,13 @@ Use --file PATH only for explicit local demo/test mode. Optional --events nats e
 
 Use task-level continuation when the sender needs to resume, otherwise the job continuation. Continuation delivery is deduplicated by the durable delivery timestamp. Treat BLOCKED as an approval/manual-release state until an explicit retry/release changes it. Cancellation, timeout, and lease expiry are durable state transitions; do not claim success from a worker process exit alone.
 
-For a ChatGPT worker, use the chatgpt adapter with capabilities model,chatgpt,macbridge. The runtime calls MacBridge's loopback-only ChatGPT conversation endpoint, stores the returned conversation_id as the durable task threadId, and reuses that ID on retry. Pass --chatgpt-project when the worker must run inside one exact ChatGPT Project. MacBridge URL/token overrides are --macbridge-url and --macbridge-token-file; never place the bearer token in job/task markers.
+Use `npx agents-relay task update` to change safe durable fields of a `QUEUED`, `READY`, `WAITING`, `BLOCKED`, or `FAILED` task without changing its task ID or prior attempt/error history. This is the preferred way to reroute future execution to a different adapter/provider/model. The CLI rejects `RUNNING`, `SUCCEEDED`, and `CANCELLED` task updates so active execution semantics and terminal audit history are not rewritten.
+
+For a ChatGPT worker, use the chatgpt adapter with capabilities model,chatgpt,browser-harness. The runtime launches the installed `chatgpt-browser-worker` agent, stores its observed `thread_id` as the durable task threadId, and reuses that ID on retry. Pass --chatgpt-project when the worker must run inside one exact ChatGPT Project. Set `AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT` to an explicit agent definition path when needed; otherwise standard skill roots are searched. Never place credentials or private prompts in job/task markers.
 
 Managed Codex and ChatGPT worker prompts are enriched at launch with the PR URL and durable job/task/parent/project identity; do not duplicate that context manually in task input. Keep one ChatGPT conversation per logical task. Retries reuse the same task conversation, but sibling tasks use separate conversations even when their adapter is the same.
 
-When a job becomes COMPLETED or its GitHub PR is merged, delete all ChatGPT task conversations. Preserve threadId in durable markers, record threadDeletedAt on success, and record/retry threadCleanupError on deletion failure without reopening the job.
+When a job becomes COMPLETED or its GitHub PR is merged, ask the browser-worker agent to delete all ChatGPT task conversations. Preserve threadId in durable markers, record threadDeletedAt on success, and record/retry threadCleanupError on deletion failure without reopening the job.
 
 V1 runs with one active runner per job; do not start multiple reconcilers without adding an atomic distributed lease. Keep secrets, credentials, private prompts, and large private payloads out of PR markers—store summaries and artifact references only. Event transport failures are degraded observability, not durable task failures.