agents-relay 2.0.56 → 2.0.58

package/README.md

@@ -230,9 +230,9 @@ Managed tasks are descriptive work for agents, not shell commands. Use `codex` o
 
 Every model-backed task declares a durable output with `--output task-pr` or `--output file --output-path PATH`. Agents Relay bootstraps workers with the managed PR URL, durable task-comment URL, job/task identity, project, output contract, and mandatory terminal-event contract; workers retrieve the task intent from GitHub rather than receiving a duplicate copy of the stored task prompt.
 
-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.
+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 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.
+The ChatGPT adapter uses Relay's `agents/chatgpt-worker.agent.md` lifecycle contract and invokes Browser Workspace exactly as a one-shot platform action: `browser-workspace 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.
 
 ~~~sh
 npx agents-relay task create --repo OWNER/REPO --pr 5 --id job-1 \
@@ -247,6 +247,8 @@ GitHub PR state is authoritative for terminal lifecycle: a merged PR reconciles
 
 `adapter: orchestrator` is reserved for synchronous self-work by the exact orchestrator turn that creates the Task. Relay deliberately does not auto-start these Tasks during reconciliation. The creator must perform the work before ending the turn and terminalize the same Task with `npx agents-relay task complete --task-id <id> --summary <summary> ...`. If work should continue asynchronously or in a later turn, use a real worker adapter instead.
 
+As a narrow recovery exception, reconciliation converts a `QUEUED` work Task that still has `adapter: orchestrator`, no execution identity, and is at least 30 minutes past `createdAt` into a normal ChatGPT-routable Task. This preserves the Task identity, intent, dependencies, output, lineage, priority, and story size while clearing stale routing state. `RUNNING` and terminal Tasks are never converted; the 30-minute rescue does not weaken the synchronous self-task contract for newly created work.
+
 For work that was completed outside the relay but must be represented truthfully in durable history, use `npx agents-relay record --task-id <id> --summary <summary> --commit <sha>`. Recorded tasks use the `orchestrator` adapter and terminal `SUCCEEDED` state; they do not pretend a shell/model worker executed the work. This is a repair/backfill mechanism—normal work should be created as a durable Task before execution. For managed jobs, the GitHub PR body is the canonical Job surface: hidden Job metadata marker plus the visible Markdown objective.
 
 ### Automatic task troubleshooting
@@ -281,4 +283,4 @@ For autonomous Jobs, `UNBLOCKED` is historical: Relay does not retry that old Ta
 
 ### Browser Workspace product boundary
 
-Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary worker/session activity remains on the public Browser Workspace CLI (`session start/exec/stop` and platform commands). Relay does not create or delete workspaces through CLI lifecycle commands.
+Agents Relay owns the persistent `Relay` browser workspace as product infrastructure. At daemon startup it runs `browser-workspace status`, dynamically imports the returned absolute `admin_helper`, and calls `ensureWorkspace("Relay", 6)`. This bootstrap is best-effort: Browser Workspace discovery/helper failures are logged and skipped so they do not prevent `agents-relayd` from starting; ChatGPT browser work may remain unavailable until Browser Workspace recovers. Ordinary ChatGPT worker activity uses the public Browser Workspace one-shot `platform run ... --auto-session` command; orchestrator-owned self-healing flows may still use explicit session commands. Relay does not create or delete workspaces through CLI lifecycle commands.

package/agents/chatgpt-worker.agent.md

@@ -11,14 +11,12 @@ You execute one complete Relay task by submitting it to a fresh worker-owned Cha
 ## Contract
 
 - Browser Workspace `platforms/chatgpt` is the sole owner of ChatGPT selectors, readiness checks, attachments, Temporary Chat mechanics, and submit verification.
-- Relay owns worker lifecycle, task/event barriers, routing, cancellation, and tab/session close policy.
-- Execute only a one-shot submission. Do not expose a create/resume/status/result conversation lifecycle.
-- Always use a fresh worker-owned Browser Workspace session/tab. Never submit through a pre-existing user tab.
+- 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.
 - 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.
-- `after-start` releases the Browser Workspace session after the exact worker `task.started` barrier.
-- `after-terminal` releases it after the exact task terminal barrier.
-- `never` leaves the owned session open for test/debug.
+- 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.
 - 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

@@ -151,20 +151,28 @@ function parseDriverJson(output) {
 function browserWorkspaceCli(override = process.env.AGENTS_RELAY_BROWSER_WORKSPACE_COMMAND) {
     return override ? { command: override, prefix: [] } : { command: 'npx', prefix: ['browser-workspace'] };
 }
-function browserWorkspaceCommand(cli, args, stdin) {
+function browserWorkspaceCommand(cli, args, stdin, signal) {
     return new Promise((resolve, reject) => {
         const child = spawn(cli.command, [...cli.prefix, ...args], { shell: false, stdio: [stdin === undefined ? 'ignore' : 'pipe', 'pipe', 'pipe'] });
         let stdout = '';
         let stderr = '';
+        const abort = () => terminateChild(child);
         child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
         child.stderr?.on('data', (chunk) => { stderr = appendTail(stderr, chunk.toString()); });
         child.on('error', reject);
         child.on('close', code => {
+            signal?.removeEventListener('abort', abort);
             if (code === 0)
                 resolve(stdout.trim());
+            else if (signal?.aborted)
+                reject(new Error('browser-worker execution aborted'));
             else
                 reject(new Error(stderr.trim() || stdout.trim() || `browser-workspace exited ${code}`));
         });
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener('abort', abort, { once: true });
         if (stdin !== undefined) {
             child.stdin?.end(stdin);
         }
@@ -191,86 +199,26 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-function sessionBrowserWorkerRunner() {
+function autoSessionBrowserWorkerRunner() {
     const cli = browserWorkspaceCli();
     return (_definition, request, _route, signal) => {
-        const policy = request.tabClosePolicy ?? 'after-start';
-        let activeSessionId;
-        let released = false;
-        let releaseResolve;
-        const releaseBarrier = new Promise(resolve => { releaseResolve = resolve; });
-        const release = () => {
-            if (released)
-                return;
-            released = true;
-            releaseResolve();
-        };
-        let submittedResolve;
-        let submittedReject;
-        const submitted = new Promise((resolve, reject) => {
-            submittedResolve = resolve;
-            submittedReject = reject;
-        });
         const promise = (async () => {
             const configFile = join(process.env.TMPDIR ?? '/tmp', `agents-relay-chatgpt-${randomUUID()}.json`);
             try {
                 await writeFile(configFile, JSON.stringify({
                     prompt: request.prompt,
                     file: request.files ?? [],
-                    close_policy: 'never',
                 }));
-                const startOutput = await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE]);
-                const started = parseWorkspaceJson(startOutput);
-                if (typeof started.session_id !== 'string') {
-                    throw new Error('browser-workspace session start returned no session_id');
-                }
-                activeSessionId = started.session_id;
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                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) {
-                    throw new Error(typeof wrapper.error === 'string' ? wrapper.error : 'browser-workspace session exec failed');
-                }
-                const receipt = parseDriverJson(typeof wrapper.stdout === 'string' ? wrapper.stdout : '');
-                const result = JSON.stringify(receipt);
-                submittedResolve(result);
-                if (policy === 'never') {
-                    await unlink(configFile).catch(() => { });
-                    activeSessionId = undefined;
-                    return result;
-                }
-                await releaseBarrier;
-                if (activeSessionId) {
-                    await browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]);
-                    activeSessionId = undefined;
-                }
-                return result;
+                const output = await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', 'temporary-submit', '--auto-session', '--config', configFile], undefined, signal);
+                return JSON.stringify(parseDriverJson(output));
             }
-            catch (failure) {
-                if (activeSessionId) {
-                    await browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]).catch(() => { });
-                    activeSessionId = undefined;
-                }
+            finally {
                 await unlink(configFile).catch(() => { });
-                const error = failure instanceof Error ? failure : new Error(String(failure));
-                submittedReject(error);
-                throw error;
             }
         })();
-        const cancel = () => {
-            release();
-            if (activeSessionId) {
-                void browserWorkspaceCommand(cli, ['session', 'stop', activeSessionId]);
-                activeSessionId = undefined;
-            }
-        };
-        if (signal.aborted)
-            cancel();
-        else
-            signal.addEventListener('abort', cancel, { once: true });
-        return { promise, submitted, release, cancel };
+        return { promise, submitted: promise, cancel: () => { } };
     };
 }
 function parseBrowserWorkerResponse(output) {
@@ -326,7 +274,7 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? sessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? autoSessionBrowserWorkerRunner())(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);
@@ -335,7 +283,7 @@ export class ChatGptAdapter {
                     await context.waitForWorkerStart;
                 else if (policy === 'after-terminal') {
                     if (!context.waitForTerminal)
-                        throw new Error('ChatGPT after-terminal tab close policy requires a terminal event barrier');
+                        throw new Error('ChatGPT after-terminal compatibility policy requires a terminal event barrier');
                     await context.waitForTerminal;
                 }
                 if (policy !== 'never')

package/dist/reconciler.js

@@ -19,6 +19,7 @@ import { createReviewChairExecutionPlan } from './review-chair.js';
 import { taskTagWorkerPrompt } from './task-tag.js';
 import { recoverExpiredExecutions, recoverStartupOrphans as recoverStartupExecutionOrphans } from './execution-recovery.js';
 import { dispatchJobReconcile } from './workflow/job-reconcile-v2.js';
+import { applyOrchestratorRescue } from './workflow/orchestrator-rescue.js';
 import { launchPlanExecution } from './planner-runtime.js';
 import { classifyFailure, errorMessage, observability, withObservabilityCorrelation } from './observability.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
@@ -154,6 +155,13 @@ export class Reconciler extends ReconcilerReviewBase {
             if (job.state !== 'ACTIVE')
                 return job;
             await recoverExpiredExecutions(job, now, this.executionRecoveryPorts(job));
+            for (const task of (await this.store.load(jobId)).tasks) {
+                const rescue = applyOrchestratorRescue(task, now);
+                if (!rescue.rescued)
+                    continue;
+                await this.store.saveTask(task);
+                await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.orchestrator_rescued', 'queued', `Stale orchestrator task ${task.id} converted to ChatGPT execution`, 'orchestrator', { ageMs: rescue.ageMs, adapter: 'chatgpt' }, { agent: 'relay', component: 'agents-relay' }));
+            }
             await this.recoverPlannerChildren(job);
             for (const recovery of pendingTroubleshooterTasks(await this.store.load(jobId))) {
                 await this.store.appendTask(recovery);

package/dist/workflow/orchestrator-rescue.js

@@ -0,0 +1,38 @@
+import { readFileSync } from 'node:fs';
+import { dispatchWorkflowGraphSync } from './dispatcher.js';
+import { GraphRuntime } from './graph-v2.js';
+export const STALE_ORCHESTRATOR_TASK_MS = 30 * 60 * 1000;
+const source = readFileSync(new URL('../../workflow/orchestrator-rescue.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const orchestratorRescueV2 = new GraphRuntime(source, {
+    states: new Set(['idle', 'check', 'skip', 'rescued']),
+    guards: { rescuable: boolGuard('rescuable') },
+    actions: { 'task.rescueOrchestrator': { id: 'task.rescueOrchestrator' } },
+    events: { 'orchestrator.rescue.reconcile': { id: 'orchestrator.rescue.reconcile' } },
+});
+export function orchestratorRescueFacts(task, now) {
+    const createdAt = Date.parse(task.createdAt);
+    const oldEnough = Number.isFinite(createdAt) && now - createdAt >= STALE_ORCHESTRATOR_TASK_MS;
+    return { rescuable: task.kind !== 'planner' && task.adapter === 'orchestrator' && task.state === 'QUEUED' && task.executionId === null && oldEnough };
+}
+export function decideOrchestratorRescue(task, now) {
+    return dispatchWorkflowGraphSync(orchestratorRescueV2, {
+        initialState: 'idle', input: { transport: 'event', id: 'orchestrator.rescue.reconcile', payload: {} },
+        durableFacts: orchestratorRescueFacts(task, now), graphName: 'orchestrator-rescue',
+        isTransientState: state => state === 'check', maxSteps: 2,
+    });
+}
+export function applyOrchestratorRescue(task, now) {
+    const decision = decideOrchestratorRescue(task, now);
+    const rescued = decision.accepted && decision.actions.some(action => action.id === 'task.rescueOrchestrator');
+    const ageMs = now - Date.parse(task.createdAt);
+    if (!rescued)
+        return { rescued: false, ageMs };
+    task.adapter = 'chatgpt';
+    task.workerRequirements = { capabilities: [...task.capabilities], runtime: 'chatgpt' };
+    task.workerSelection = undefined;
+    task.routing = undefined;
+    task.timeoutMs = 0;
+    task.updatedAt = new Date(now).toISOString();
+    return { rescued: true, ageMs };
+}

package/package.json

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

package/skills/agents-relay/contracts/orchestrator-workflows.md

@@ -36,6 +36,8 @@ A **P0 job** (alias: **self job**) is executed directly by the current active or
 5. P0/self jobs do not require the normal reviewer gate unless the user explicitly asks for review.
 6. After implementation and local verification, the orchestrator merges the job itself and completes normal post-merge reconciliation.
 
+Recovery exception: reconciliation may rescue only a `QUEUED` work Task with `adapter: orchestrator` that has no execution identity and is at least 30 minutes past `createdAt`. It converts that Task in place to a normal ChatGPT-routable Task, preserving its durable intent and Task identity while clearing stale routing state. `RUNNING` and terminal Tasks are not rescued. This is a stale-task safety net, not an asynchronous handoff mechanism for newly created self-work.
+
 `job create` still only creates durable job state; the P0 workflow requires the orchestrator to follow it immediately with task creation and execution.
 
 ## Merge completion vs deployment evidence

package/workflow/orchestrator-rescue.mmd

@@ -0,0 +1,13 @@
+flowchart LR
+%% relay: initial idle
+idle["state: idle"]
+check["state: check"]
+skip["state: skip"]
+rescued["state: rescued"]
+rescuable["guard: rescuable"]
+rescue["action: task.rescueOrchestrator"]
+idle -->|on: orchestrator.rescue.reconcile| check
+check -->|on: orchestrator.rescue.reconcile| rescuable
+rescuable -->|false| skip
+rescuable -->|true| rescue
+rescue -->|to: rescued| rescued