agents-relay 2.0.42 → 2.0.44

package/README.md

@@ -227,7 +227,7 @@ Every model-backed task declares a durable output with `--output task-pr` or `--
 
 For Codex and ChatGPT, **correlated worker events are authoritative lifecycle inputs**, not a separate durable store. Event publication uses the canonical Neo `events-bus` surface (`events__publish` for sandboxed/hosted workers, or `NEO_EVENTS_EMIT` for direct local workers); Agents Relay subscribes, validates correlation, applies graph transitions, persists results in RelayStore, and projects them to GitHub. Relay publishes `task.process.launched` only after successful adapter launch; `task.started` is worker-owned and must be a new, correlated start acknowledgement. Codex publishes `task.process.exited` when its synchronous runtime exits, while ChatGPT publishes `task.process.async_exited` after its submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. The ChatGPT worker-owned tab follows the configured close policy: `after-start` waits for the correlated start acknowledgement, `never` keeps it open for debug, and `after-terminal` waits for a new exact-task terminal event; start-ack failure closes only the owned tab after 60 seconds. The executing agent must publish exactly one correlated terminal 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 `chatgpt-browser-worker` path selected by the shared execution-context resolver; Relay does not bundle its own copy. The resolver applies project-local > Neo shared > global `~/.agents` precedence at execution time, so durable tasks store names/intent rather than stale absolute skill paths. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and 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.
+The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and Browser Workspace `platforms/chatgpt` for all ChatGPT browser mechanics. It opens a fresh Temporary Chat tab, uses the account defaults, submits the prompt, verifies acceptance, and applies `--chatgpt-tab-close-policy` (or `AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY`): `after-start` by default, `never` for test/debug, or `after-terminal` after a new exact-task terminal event. It never closes a user tab and 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 task create --repo OWNER/REPO --pr 5 --id job-1 \

package/dist/adapters.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { access, readFile, writeFile, unlink } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { readFile, writeFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
@@ -132,24 +132,6 @@ export class LaunchFailure extends Error {
 }
 export class StartAckTimeout extends LaunchFailure {
 }
-async function loadBrowserWorkerRuntime(context, explicit) {
-    const resolvedSkill = context?.skills.find(skill => skill.name === 'chatgpt-browser-worker');
-    // Once a worker receives a resolved execution context, that context owns
-    // skill discovery. The explicit path remains the fallback for direct
-    // adapter use, where no shared context has been resolved yet.
-    const candidate = resolvedSkill
-        ? join(dirname(resolvedSkill.path), 'agents', 'browser-worker.agent.md')
-        : explicit;
-    if (!candidate)
-        throw new Error('chatgpt-browser-worker is not visible in the resolved execution context');
-    try {
-        await access(candidate);
-        return { definition: await readFile(candidate, 'utf8'), root: dirname(dirname(candidate)) };
-    }
-    catch {
-        throw new Error(`chatgpt-browser-worker agent definition not found at resolved path: ${candidate}`);
-    }
-}
 function parseDriverJson(output) {
     const lines = output.trim().split(/\r?\n/).filter(Boolean);
     for (let index = lines.length - 1; index >= 0; index -= 1) {
@@ -200,7 +182,7 @@ function parseWorkspaceJson(output) {
 export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
     await browserWorkspaceCommand(browserWorkspaceCli(command), ['create', CHATGPT_BROWSER_WORKSPACE, String(CHATGPT_BROWSER_WORKSPACE_POOL_SIZE)]);
 }
-function sessionBrowserWorkerRunner(root) {
+function sessionBrowserWorkerRunner() {
     const cli = browserWorkspaceCli();
     return (_definition, request, _route, signal) => {
         const policy = request.tabClosePolicy ?? 'after-start';
@@ -223,16 +205,10 @@ function sessionBrowserWorkerRunner(root) {
         const promise = (async () => {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
-                const [readiness, submitSource, temporarySource] = await Promise.all([
-                    readFile(join(root, 'scripts', '_submit_readiness.py'), 'utf8'),
-                    readFile(join(root, 'scripts', '_submit_bh.py'), 'utf8'),
-                    readFile(join(root, 'scripts', '_temporary_bh.py'), 'utf8'),
-                ]);
                 await writeFile(configFile, JSON.stringify({
                     prompt: request.prompt,
                     file: request.files ?? [],
-                    close_policy: policy,
-                    release_file: '',
+                    close_policy: 'never',
                 }));
                 const startOutput = await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
                 const started = parseWorkspaceJson(startOutput);
@@ -242,12 +218,7 @@ function sessionBrowserWorkerRunner(root) {
                 activeSessionId = started.session_id;
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const escapedConfig = configFile.replaceAll('\\', '\\\\').replaceAll('"', '\\"');
-                const source = [
-                    readiness,
-                    submitSource.replace(/^from browser_harness import \*\s*$/m, ''),
-                    temporarySource.replace(/^_wait_for_release\(\)\s*$/m, ''),
-                ].join('\n\n').replaceAll('__CFG_PATH__', escapedConfig);
+                const source = await browserWorkspaceCommand(cli, ['platform', 'source', 'chatgpt', 'temporary-submit', '--config', configFile]);
                 const execOutput = await browserWorkspaceCommand(cli, ['session', 'exec', activeSessionId], source);
                 const wrapper = parseWorkspaceJson(execOutput);
                 if (wrapper.ok !== true) {
@@ -316,11 +287,9 @@ export class ChatGptAdapter {
     name = 'chatgpt';
     id = 'chatgpt/browser-worker';
     capabilities = ['model', 'chatgpt', 'browser-workspace'];
-    agentPath;
     runner;
     tabClosePolicy;
     constructor(options = {}) {
-        this.agentPath = options.agentPath ?? process.env.AGENTS_RELAY_CHATGPT_BROWSER_WORKER_AGENT;
         this.runner = options.agentRunner;
         this.tabClosePolicy = chatGptTabClosePolicy(options.tabClosePolicy ?? process.env.AGENTS_RELAY_CHATGPT_TAB_CLOSE_POLICY);
     }
@@ -344,11 +313,11 @@ export class ChatGptAdapter {
         execution.launched = new Promise((resolve, reject) => { launchResolve = resolve; launchReject = reject; });
         execution.launched.catch(() => { });
         execution.promise = (async () => {
-            const runtime = await loadBrowserWorkerRuntime(context.executionContext, this.agentPath);
+            const definition = await readFile(new URL('../agents/chatgpt-worker.agent.md', import.meta.url), 'utf8');
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? sessionBrowserWorkerRunner(runtime.root))(runtime.definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? sessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);

package/dist/cli-blocker.js

@@ -1,7 +1,7 @@
 import { GitHubStore } from './store.js';
 import { githubAuthContext } from './github-auth.js';
 import { registerBlockerDependency } from './blockers.js';
-import { arg, eventBus, publishDependentUnblocked, repository } from './cli-support.js';
+import { arg, publishDependentUnblocked, repository, withEventBus } from './cli-support.js';
 import { usage } from './cli-help.js';
 export async function runBlockerCommand(action, args) {
     if (!['add', 'resolve', 'show'].includes(action))
@@ -19,7 +19,7 @@ export async function runBlockerCommand(action, args) {
     }
     if (action === 'resolve') {
         const summary = await blockerStore.resolveBlockerDependents(id, 'verified');
-        await publishDependentUnblocked(await eventBus(args), summary.unblocked, `Blocker Job ${id} resolved (verified)`);
+        await withEventBus(args, bus => publishDependentUnblocked(bus, summary.unblocked, `Blocker Job ${id} resolved (verified)`));
         console.log(JSON.stringify({ blocker: id, resolution: 'verified', ...summary }, null, 2));
         return;
     }

package/dist/cli-support.js

@@ -139,6 +139,15 @@ export async function eventBus(args) {
     process.stderr.write(`${eventBusResolutionMessage(resolution)}\n`);
     return resolution.bus;
 }
+export async function withEventBus(args, work, resolve = eventBus) {
+    const bus = await resolve(args);
+    try {
+        return await work(bus);
+    }
+    finally {
+        await bus?.close?.();
+    }
+}
 export async function publishWake(bus, job, taskId, message) { if (!bus)
     return; try {
     await bus.publish(eventFor(job.id, taskId, null, 'job.wake', 'queued', message, 'orchestrator', { repository: job.repository, prNumber: job.prNumber }));

package/dist/cli-unblock.js

@@ -1,4 +1,4 @@
-import { arg, eventBus, publishTaskUnblocked, publishWake, saveLocal } from './cli-support.js';
+import { arg, publishTaskUnblocked, publishWake, saveLocal, withEventBus } from './cli-support.js';
 import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
 export async function runTaskUnblockCommand(args, store, job, task, localFile) {
     const reason = arg(args, '--reason');
@@ -7,9 +7,10 @@ export async function runTaskUnblockCommand(args, store, job, task, localFile) {
     const result = await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
     const refreshed = await store.load(job.id);
     await saveLocal(localFile, refreshed);
-    const bus = await eventBus(args);
-    await publishTaskUnblocked(bus, refreshed, task.id, reason);
-    await publishWake(bus, refreshed, task.id, `Task ${task.id} unblocked${result.replanning ? ' for replanning' : ''}`);
+    await withEventBus(args, async (bus) => {
+        await publishTaskUnblocked(bus, refreshed, task.id, reason);
+        await publishWake(bus, refreshed, task.id, `Task ${task.id} unblocked${result.replanning ? ' for replanning' : ''}`);
+    });
     console.log(JSON.stringify({ taskId: task.id, ...result, task: refreshed.tasks.find(item => item.id === task.id) }, null, 2));
 }
 export async function runJobUnblockCommand(args, store, job) {
@@ -22,19 +23,21 @@ export async function runJobUnblockCommand(args, store, job) {
     if (job.executionMode === 'autonomous') {
         const planTrigger = await unblockAutonomousTasks({ store, job, tasks: blocked, trigger: { source: 'cli', reason } });
         const refreshed = await store.load(job.id);
-        const bus = await eventBus(args);
-        for (const task of blocked)
-            await publishTaskUnblocked(bus, refreshed, task.id, reason);
-        await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked for replanning`);
+        await withEventBus(args, async (bus) => {
+            for (const task of blocked)
+                await publishTaskUnblocked(bus, refreshed, task.id, reason);
+            await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked for replanning`);
+        });
         console.log(JSON.stringify({ jobId: job.id, replanning: true, planTrigger }, null, 2));
         return;
     }
     for (const task of blocked)
         await unblockTask({ store, job, task, trigger: { source: 'cli', reason } });
     const refreshed = await store.load(job.id);
-    const bus = await eventBus(args);
-    for (const task of blocked)
-        await publishTaskUnblocked(bus, refreshed, task.id, reason);
-    await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked`);
+    await withEventBus(args, async (bus) => {
+        for (const task of blocked)
+            await publishTaskUnblocked(bus, refreshed, task.id, reason);
+        await publishWake(bus, refreshed, 'job', `Job ${job.id} unblocked`);
+    });
     console.log(JSON.stringify({ jobId: job.id, replanning: false, resumedTasks: blocked.map(task => task.id) }, null, 2));
 }

package/dist/cli.js

@@ -29,7 +29,7 @@ import { parseAgentGraph } from './agent-graph.js';
 import { runJobUnblockCommand, runTaskUnblockCommand } from './cli-unblock.js';
 import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js';
 export { helpText } from './cli-help.js';
-import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, } from './cli-support.js';
+import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, withEventBus, } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
 export async function ensureManagedGitHubJob(client, repositoryName, trustedAuthors, options) {
     if (!options.id)
@@ -185,7 +185,7 @@ async function runTaskCommand(action, args) {
         }
         const durableTask = (await store.load(job.id)).tasks.find(item => item.id === task.id) ?? task;
         await saveLocal(localFile, await store.load(job.id));
-        await publishWake(await eventBus(args), refreshed, task.id, `Task ${task.id} created`);
+        await withEventBus(args, bus => publishWake(bus, refreshed, task.id, `Task ${task.id} created`));
         console.log(JSON.stringify(durableTask, null, 2));
         return;
     }
@@ -228,7 +228,7 @@ async function runTaskCommand(action, args) {
             outputTask = outputJob.tasks.find(item => item.id === id) ?? result.task;
         }
         await saveLocal(localFile, outputJob);
-        await publishWake(await eventBus(args), outputJob, outputTask.id, `${outputTask.id} ${action} requested`);
+        await withEventBus(args, bus => publishWake(bus, outputJob, outputTask.id, `${outputTask.id} ${action} requested`));
         console.log(JSON.stringify(outputTask, null, 2));
         return;
     }
@@ -397,7 +397,7 @@ async function runJobCommand(action, args) {
         await transitionJobEvent(job, 'pr.merged');
         await store.saveJob(job);
         const resolved = await store.resolveBlockerDependents(id, 'merge');
-        await publishDependentUnblocked(await eventBus(args), resolved.unblocked, `Blocker Job ${id} resolved (merge)`);
+        await withEventBus(args, bus => publishDependentUnblocked(bus, resolved.unblocked, `Blocker Job ${id} resolved (merge)`));
         console.log(JSON.stringify(await store.load(id), null, 2));
         return;
     }
@@ -597,7 +597,6 @@ async function main() {
         console.log(`Initialized ${job.id}`);
         return;
     }
-    const bus = await eventBus(args);
     if (command === 'status') {
         const host = arg(args, '--host', '127.0.0.1');
         const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
@@ -619,15 +618,12 @@ async function main() {
     const { store, job, localFile } = loaded;
     if (command === 'plan') {
         const guidance = hasArg(args, '--prompt') || hasArg(args, '--prompt-file') ? await textOption(args, '--prompt', '--prompt-file') : undefined;
-        try {
+        await withEventBus(args, async (bus) => {
             const result = await runtime(store, args, bus).planJob(job.id, guidance?.trim() || undefined);
             await saveLocal(localFile, result.job);
             await publishWake(bus, result.job, result.round.id, `Planning round ${result.round.id} completed`);
             console.log(JSON.stringify(result.round, null, 2));
-        }
-        finally {
-            await bus?.close?.();
-        }
+        });
         return;
     }
     if (command === 'agent-register') {
@@ -659,27 +655,24 @@ async function main() {
         console.log(`Recorded ${id}`);
         return;
     }
-    if (command === 'reconcile' && !localFile) {
-        try {
-            await requestManagedReconciliation(bus, job);
-            console.log(JSON.stringify(await store.load(job.id), null, 2));
-        }
-        finally {
-            await bus?.close?.();
-        }
+    if (command === 'serve') {
+        await startService(args);
         return;
     }
-    const reconciler = runtime(store, args, bus);
     if (command === 'reconcile') {
-        await reconciler.reconcile(job.id);
-        await reconciler.idle();
-        const finalState = await store.load(job.id);
-        await saveLocal(localFile, finalState);
-        console.log(JSON.stringify(finalState, null, 2));
-        return;
-    }
-    if (command === 'serve') {
-        await startService(args);
+        await withEventBus(args, async (bus) => {
+            if (!localFile) {
+                await requestManagedReconciliation(bus, job);
+                console.log(JSON.stringify(await store.load(job.id), null, 2));
+                return;
+            }
+            const reconciler = runtime(store, args, bus);
+            await reconciler.reconcile(job.id);
+            await reconciler.idle();
+            const finalState = await store.load(job.id);
+            await saveLocal(localFile, finalState);
+            console.log(JSON.stringify(finalState, null, 2));
+        });
         return;
     }
     throw new Error(usage);

package/package.json

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

package/skills/agents-relay/SKILL.md

@@ -91,7 +91,7 @@ Leaf workers consume the resolved instruction/skill/agent paths, not the full to
 
 ## ChatGPT worker
 
-The ChatGPT adapter uses the `chatgpt-browser-worker` path from the shared execution context; Relay does not bundle or independently rediscover that skill. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
+The ChatGPT adapter uses Relay's `chatgpt-worker` agent contract and Browser Workspace ChatGPT platform; it does not depend on a Neo worker skill. It opens a fresh Temporary Chat tab, submits the complete task with the account defaults, verifies acceptance, applies the configured `after-start` (default), `never`, or `after-terminal` owned-tab close policy, and returns a submission receipt.
 
 ChatGPT thread identity is diagnostic only. It is not persisted as a resumable task handle, and Relay does not poll, resume, retrieve a result from, or delete a ChatGPT conversation as part of task lifecycle.