agents-relay 2.0.167 → 2.0.169

package/README.md

@@ -255,7 +255,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 one-shot submission runtime exits; neither substitutes for `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. 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 Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and invokes Browser Workspace exactly as a one-shot platform action: `webhelm platform run chatgpt temporary-submit --auto-session --config <file>`. Browser Workspace owns creation/release of the fresh Temporary Chat session, selectors, attachments, and submit verification; Relay does not self-heal browser failures and instead lets delivery failures enter its normal retry/recovery lifecycle. Legacy `--chatgpt-tab-close-policy` values remain accepted for compatibility around Relay's event barriers, but they do not control the Browser Workspace auto-session lifetime. The adapter never uses a pre-existing user tab, polls for the assistant response, resumes/reopens a thread, or treats 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. A new worker uses `webhelm platform run chatgpt new-thread --session-id SESSION_ID --config <file>` in a caller-owned Session. This is a regular persistent ChatGPT thread, which supports the connected Neo MCP in the verified account. Relay closes the Session after submission, but the ChatGPT thread remains in history. Existing-thread review and handoff continue through `new-turn`. File paths are included in the worker message for Neo MCP reading; they are not uploaded as browser attachments. Submission receipts retain `status: submitted`; the event bus owns task completion.
 
 ~~~sh
 npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \

package/agents/chatgpt-worker.agent.md

@@ -6,17 +6,17 @@ type: worker
 
 # ChatGPT Worker Agent
 
-You execute one complete Relay task by submitting it to a fresh worker-owned ChatGPT Temporary Chat through Browser Workspace.
+You execute one complete Relay task by submitting it to a fresh, regular ChatGPT Thread through Browser Workspace.
 
 ## Contract
 
-- Browser Workspace `platforms/chatgpt` is the sole owner of ChatGPT selectors, readiness checks, attachments, Temporary Chat mechanics, and submit verification.
+- Browser Workspace `platforms/chatgpt` is the sole owner of ChatGPT selectors, readiness checks, new-thread mechanics and submit verification.
 - Relay owns worker lifecycle, task/event barriers, routing, and cancellation; Browser Workspace owns the one-shot auto-session lifecycle.
-- Execute only a one-shot submission with `platform run chatgpt temporary-submit --auto-session`. Do not expose a create/resume/status/result conversation lifecycle.
-- Let Browser Workspace create and release the fresh Temporary Chat session/tab for the action. Never submit through a pre-existing user tab.
+- Execute one new worker submission with `platform run chatgpt new-thread --session-id SESSION_ID`. Existing-thread delivery uses `new-turn`. Never use Temporary Chat for workers that need Neo MCP.
+- Relay creates and stops a caller-owned WebHelm Session for each delivery. New worker conversations persist in ChatGPT history; do not reuse a pre-existing user tab.
 - Preserve the account's current default model/thinking settings.
 - A submission is accepted only after Browser Workspace returns a verified submit receipt.
-- Treat observed conversation/thread identity as diagnostic only, never as a resumable handle.
-- Legacy ChatGPT tab-close policy values remain accepted by Relay for compatibility, but they do not control Browser Workspace's auto-session lifetime or add self-heal.
+- Require the real new-thread receipt to include a durable thread ID and URL. The thread identifies delivery, not task completion.
+- Legacy ChatGPT tab-close policy values remain accepted by Relay for compatibility, but they do not control the caller-owned Session lifetime or add self-heal.
 - Do not wait for the assistant response. Durable task success/failure is event-owned by Relay and the executing task.
 - Stop on authentication, MFA, consent, or ambiguous browser state rather than bypassing it.

package/dist/adapters.js

@@ -148,7 +148,7 @@ function findSubmittedReceipt(value) {
     if (!value || typeof value !== 'object')
         return undefined;
     const record = value;
-    if ((record.operation === 'submit' || record.operation === 'new-turn' || record.mode === 'new-turn') && record.status === 'submitted')
+    if ((record.operation === 'submit' || record.operation === 'new-turn' || record.mode === 'new-turn' || record.mode === 'new-thread') && record.status === 'submitted')
         return record;
     for (const key of ['result', 'output', 'data', 'stdout']) {
         const nested = findSubmittedReceipt(record[key]);
@@ -285,13 +285,13 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-async function runBrowserWorker(cli, configFile, signal, action = 'temporary-submit') {
+async function runBrowserWorker(cli, configFile, signal, action = 'new-thread') {
     const session = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE], undefined, signal));
     const sessionId = session.session_id;
     if (typeof sessionId !== 'string' || !sessionId)
         throw new Error('webhelm session start returned no session_id');
     try {
-        return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', action, '--session-id', sessionId, '--config', configFile], undefined, signal);
+        return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', action, ...(action === 'new-turn' ? ['--mode', 'async'] : []), '--session-id', sessionId, '--config', configFile], undefined, signal);
     }
     finally {
         await browserWorkspaceCommand(cli, ['session', 'stop', sessionId]).catch(() => { });
@@ -304,18 +304,23 @@ function browserWorkerRunner() {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
                 const delivery = request.thread;
+                // Temporary Chat lacks Neo MCP tools on this verified account.
+                // File paths remain accessible to normal workers through Neo MCP.
+                const message = request.files?.length
+                    ? `${request.prompt}\n\nTask file paths (read with Neo MCP; files are not browser-uploaded):\n${request.files.map(file => `- ${JSON.stringify(file)}`).join('\n')}`
+                    : request.prompt;
                 await writeFile(configFile, JSON.stringify(delivery ? {
                     project_id: delivery.projectId ?? _route.projectId ?? null,
                     thread_id: delivery.threadId,
                     message: `${request.prompt}\n\nRelay delivery ID: ${delivery.requestId}`,
                     idempotency_key: delivery.requestId,
                 } : {
-                    prompt: request.prompt,
-                    file: request.files ?? [],
+                    message,
+                    temporary: false,
                 }));
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const action = delivery ? 'new-turn' : 'temporary-submit';
+                const action = delivery ? 'new-turn' : 'new-thread';
                 const output = await runBrowserWorker(cli, configFile, signal, action);
                 return JSON.stringify(parseDriverJson(output));
             }
@@ -338,6 +343,10 @@ function parseBrowserWorkerResponse(output) {
     if (!value || typeof value !== 'object')
         throw new Error('browser-worker returned an invalid JSON response');
     const response = value;
+    if (response.mode === 'new-thread' && (response.temporary !== false ||
+        typeof response.thread_id !== 'string' || !/^[A-Za-z0-9_-]{8,160}$/.test(response.thread_id) ||
+        typeof response.thread_url !== 'string' || !/^https:\/\/chatgpt\.com\/c\//.test(response.thread_url)))
+        throw new Error('browser-worker did not return a durable ChatGPT thread');
     const verified = response.verified === true || response.verified_by !== undefined;
     if (response.status !== 'submitted' || !verified) {
         throw new Error('browser-worker did not return a submitted receipt');
@@ -432,7 +441,7 @@ export class ChatGptAdapter {
                     summary: 'ChatGPT task submitted; terminal task state is event-owned',
                     data: {
                         submitted: true,
-                        mode: response.mode ?? 'temporary-submit',
+                        mode: response.mode ?? 'new-thread',
                         threadId: response.thread_id ?? response.diagnostic_thread_id ?? null,
                         diagnosticThreadId: response.diagnostic_thread_id ?? null,
                         userMessageId: response.user_message_id ?? null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.167",
+  "version": "2.0.169",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",

package/skills/agents-relay/SKILL.md

@@ -100,7 +100,7 @@ Leaf workers consume the resolved instruction/skill/agent paths, not the full to
 
 ## ChatGPT worker
 
-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.
+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 regular ChatGPT thread so the worker can use Neo MCP, submits the task with the account defaults, verifies the durable thread ID and submission receipt, and closes its caller-owned WebHelm Session after submission. File inputs are passed as explicit local paths for Neo MCP reading, not browser uploads.
 
 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.