agents-relay 2.0.43 → 2.0.45

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/troubleshooter.js

@@ -26,7 +26,7 @@ Retrieve this task's lifecycle event history before classifying the root cause o
 GET http://127.0.0.1:8787/api/events?job=${encodeURIComponent(job.id)}&task=${encodeURIComponent(task.id)}&limit=200
 Inspect event order, type/status, source, data/phase, duplicate events, missing expected lifecycle events, late events, and execution identifiers. If the event stream points to delivery/runtime failure, inspect the corresponding Relay/worker/tool logs too. Do not treat the final task.error string as the complete root cause.
 
-Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Only model/provider/runtime evidence may call the narrow model re-decision action; that action gathers fresh usage, reloads current policy, updates this exact Task's routing, and does not retry it. Troubleshooter must then reactivate/retry this exact original task and verify progress. Do not manually choose a provider/model or create a replacement task. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
+Follow the selected Troubleshooter agent contract. Diagnose root cause from durable task state + event history + relevant runtime logs before retry. The final task.error string alone is never sufficient. Classify the evidence as model/provider/runtime, worker/tool/infrastructure, semantic task failure, or timeout/unknown. Only model/provider/runtime evidence may call the narrow model re-decision action; that action gathers fresh usage, reloads current policy, updates this exact Task's routing, and does not retry it. Troubleshooter must then reactivate/retry this exact original task and verify progress. Do not manually choose a provider/model or create a replacement task. If the blocker is a shared worker/runtime/tool defect, create and directly complete a P0/self-job in the owning repository, including required release/deploy verification. If diagnosis suggests a genuine human/external blocker, do not publish task.blocked directly: first call the Neo CLI neo escalation with the original intent, blocker, and relevant context. Pass any caller-defined notification plan through --on-needs-user/--on-needs-user-file; do not hard-code a channel. Continue recovery on resolved; treat failed as technical recovery evidence; only needs_user justifies publishing task.blocked with the returned exact user action and notification evidence. Retry this exact original task only after the blocker is removed, reconcile the original job, and verify durable progress.`;
 }
 function belongsToCurrentRun(job, task) {
     const slot = job.schedule?.currentRunSlot;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.43",
+  "version": "2.0.45",
   "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.
 

package/skills/agents-relay/agents/troubleshooter.agent.md

@@ -29,7 +29,10 @@ Read and follow the shared Task / Job contract and orchestrator P0/self-job work
    - For a transient failure, verify the transient condition is gone.
    - For task-local failure, make the smallest durable repair in the original Job/PR when that is within scope.
    - For a shared platform/runtime defect, first create or reuse the owning blocker P0/self-job. If it can be completed inside this recovery execution, fix/verify it and retry the original Task. If it cannot be completed now, register the original Task with `agents-relay blocker add` on that blocker Job and finish this Troubleshooter task; do not stay running while waiting for another Job.
-   - For a genuine human/external blocker, do not fake progress. Publish task.blocked with the exact action required.
+   - For a suspected genuine human/external blocker, do not publish `task.blocked` yet. First invoke the Neo CLI `neo escalation` with the original intent, blocker, and relevant context. If the recovery context defines a preferred way to contact the user, pass that description through `--on-needs-user` or `--on-needs-user-file`; Relay must not hard-code a channel. Handle the structured result:
+     - `resolved`: the escalation agent solved the blocker; continue the normal retry/reconcile path and verify durable progress.
+     - `failed`: this remains a technical recovery outcome; preserve the evidence and do not relabel it as human-required.
+     - `needs_user`: only now publish `task.blocked`, using the returned `user_action` and notification evidence.
 6. For an immediate repair, only after the blocker is removed run `agents-relay task retry` for the original Task and reconcile its Job. For deferred repair, rely on the durable blocker relation: merge-mode blockers wake matching dependents after merge; release/deploy/runtime blockers use `--resolution verified` and `agents-relay blocker resolve` only after verification.
 7. Verify durable evidence that the original Task moved: at minimum QUEUED after retry, preferably a new execution / task.started / observable progress.
 8. Publish this Troubleshooter Task's terminal event only after the recovery outcome is durable.