agents-relay 1.0.1 → 1.0.3

package/README.md

@@ -78,24 +78,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

@@ -264,7 +264,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);

package/dist/dashboard.js

@@ -202,7 +202,7 @@ function syncFilters(){
 function renderJobList(){jobList.replaceChildren();const visible=filteredJobs();if(!jobs.length){jobList.append(element('li','empty',text('No durable jobs discovered.')));return;}if(!visible.length){jobList.append(element('li','empty',text('No jobs match the selected repo.')));return;}for(const job of visible){const button=document.createElement('button');button.type='button';button.className='job-button'+(isCompleteUnmerged(job)?' complete-unmerged':'');button.setAttribute('aria-current',String(job.id===selectedJob));button.title=job.title||job.id;button.addEventListener('click',()=>selectJob(job.id));const meta=element('span','job-meta');meta.append(element('span','badge '+value(job.state),text(job.state)),element('span','badge mode-'+value(job.executionMode||'fixed'),text(value(job.executionMode||'fixed').toUpperCase())),element('span',job.draft?'badge DRAFT':'',text(job.draft?'DRAFT':value(job.githubState||'UNKNOWN'))));if(isCompleteUnmerged(job))meta.append(element('span','badge MERGE_PENDING',text('MERGE PENDING')));meta.append(element('span','',text(job.repository||'unknown repo')),element('span','',text(relativeTime(job.updatedAt))));button.append(element('span','job-title',text('PR#'+value(job.prNumber)+': '+value(job.title||job.id))),meta,element('span','subtle',text(compactCounts(counts(job.tasks)))));jobList.append(element('li','',button));}}
 function taskNode(task,children,depth){const li=element('li');const row=document.createElement('button');row.type='button';row.className='task-row';row.setAttribute('aria-current',String(task.id===selectedTaskId));row.title=task.id;row.addEventListener('click',()=>{selectedTaskId=task.id;rememberSelection();renderAll();});const id=element('span','task-id',text(task.id));id.style.paddingLeft=Math.min(depth,4)*6+'px';row.append(id,element('span','badge '+value(task.state),text(task.state)));li.append(row);const nested=children.get(task.id)||[];if(nested.length){const ul=element('ul','tree');for(const child of nested)ul.append(taskNode(child,children,depth+1));li.append(ul);}return li;}
 function buildTree(tasks){taskTree.replaceChildren();if(!Array.isArray(tasks)||!tasks.length){taskTree.append(element('li','empty',text('No tasks in durable state.')));return;}const known=new Set(tasks.map(task=>task.id));const children=new Map();const roots=[];for(const task of tasks){if(!task.parentTaskId||!known.has(task.parentTaskId))roots.push(task);else{const siblings=children.get(task.parentTaskId)||[];siblings.push(task);children.set(task.parentTaskId,siblings);}}for(const task of roots)taskTree.append(taskNode(task,children,0));}
-function attemptBudget(task){const attempt=Number(task?.attempt)||0;const max=Number(task?.maxAttempts)||0;if(max>=3&&max%3===0)return attempt+' / 3×'+(max/3);return attempt+' / '+max;}
+function attemptBudget(task){const attempt=Number(task?.attempt)||0;const max=Number(task?.maxAttempts)||0;if(max>=3&&max%3===0){const effectiveMax=Math.max(max,Math.ceil(attempt/3)*3);return attempt+' / 3×'+(effectiveMax/3);}return attempt+' / '+max;}
 function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Task',task.id),field('Kind',task.kind||'work'),field('State',task.state),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),chatField(task));if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));taskDetailRoot.append(groups);}
 function renderSelectedJob(){jobDetail.replaceChildren();const job=selected();if(!job){selectedJobTitle.textContent='';jobDetail.append(element('div','empty',text('No durable jobs discovered.')));buildTree([]);renderTaskDetail(null);return;}selectedJobTitle.textContent='— '+value(job.title||job.id);if(job.id!==selectedJob){selectedJob=job.id;selectedTaskId=null;rememberSelection();}const summary=element('div','job-summary');summary.append(field('GitHub state',job.githubState||'UNKNOWN'),field('Durable state',job.state),field('Execution mode',job.executionMode||'fixed'),field('Objective',job.objective||job.description||job.title),prField(job),field('Repository',job.repository||'—'),field('Last activity',relativeTime(job.updatedAt)),field('Task states',compactCounts(counts(job.tasks))));jobDetail.append(summary);const selectedTask=(job.tasks||[]).find(task=>task.id===selectedTaskId)||null;if(selectedTaskId&&!selectedTask){selectedTaskId=null;rememberSelection();}buildTree(job.tasks||[]);renderTaskDetail(selectedTask);}
 function renderAll(){jobs.sort(compareJobs);syncFilters();renderJobList();renderSelectedJob();}

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.1",
+  "version": "1.0.3",
   "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,11 @@ 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.
+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.