agents-relay 1.0.29 → 1.0.30

package/README.md

@@ -38,7 +38,7 @@ autonomous runtime uses the bundled `skills/agents-relay/agents/planner.agent.md
 snapshot as JSON on stdin and must return `{ "objective_status": "in_progress"|"satisfied", "assessment": "...", "next_tasks": [...] }`.
 Planner-created tasks use stable IDs and the existing parent/subtask tree, so
 retries and daemon restarts do not create duplicate work.
-Task producers must follow `skills/agents-relay/contracts/task-job-contract.md`; that shared skill contract defines story size, timeout derivation, lifecycle events, review, and auto-merge semantics.
+Task producers must follow `skills/agents-relay/contracts/task-job-contract.md`; that shared skill contract defines story size, lifecycle events, review, and auto-merge semantics.
 All task producers use the same story-size contract: `S`≈5 minutes, `M`≈15 minutes, and `L`≈45 minutes of normal-reasoning execution, with `M` as the default. `high` reasoning doubles that overall window. ChatGPT Browser Worker start-ack timeout is derived as one third of the effective overall timeout, clamped between 1 and 5 minutes. Orchestrators and planners should choose `storySize`, not raw timeout milliseconds; `--timeout` remains only as an explicit compatibility/debug override.
 
 job create first resolves an existing open PR with the same head/base, then creates it only when needed. Re-running it is idempotent: it reuses the PR and maintains exactly one trusted agents-relay:job:v1 marker.

package/dist/reconciler.js

@@ -71,7 +71,7 @@ export class Reconciler {
     }
     async handleEvent(event) {
         if (event.type === 'task.started') {
-            this.markWorkerStarted(event);
+            await this.markWorkerStarted(event);
             return;
         }
         if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
@@ -512,17 +512,44 @@ export class Reconciler {
             clearTimeout(graceTimer);
         this.terminalExitGraceTimers.delete(taskId);
     }
-    markWorkerStarted(event) {
-        const live = this.live.get(event.task_id);
-        if (!live || event.job_id !== live.jobId)
-            return;
+    async markWorkerStarted(event) {
         const sourceAgent = typeof event.source?.agent === 'string' ? event.source.agent : '';
         const sourceComponent = typeof event.source?.component === 'string' ? event.source.component : '';
         if (sourceAgent === 'relay' || sourceComponent === 'agents-relay')
             return;
-        if (event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
+        const live = this.live.get(event.task_id);
+        if (live && event.job_id === live.jobId) {
+            if (event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
+                return;
+            live.workerStarted = true;
+            return;
+        }
+        const job = await this.store.load(event.job_id);
+        const task = job.tasks.find(item => item.id === event.task_id);
+        if (!task || task.state !== 'FAILED' || !this.isRecoverableWatchdogFailure(task))
             return;
-        live.workerStarted = true;
+        if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
+            return;
+        transitionTask(task, 'RUNNING');
+        task.failureReason = undefined;
+        task.error = null;
+        task.updatedAt = event.timestamp || new Date().toISOString();
+        await this.store.saveTask(task);
+        this.detach(this.reconcile(job.id), job.id, task.id, 'late worker-start reconciliation');
+    }
+    isRecoverableWatchdogFailure(task) {
+        if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event'].includes(task.failureReason ?? ''))
+            return true;
+        const error = task.error ?? '';
+        return error.includes('worker_start_timeout')
+            || error.includes('timed out waiting for the mandatory terminal worker event')
+            || error.includes('exited before publishing task.started')
+            || error.includes('exited after task.started without publishing a terminal task event');
+    }
+    isWorkerOwnedEvent(event) {
+        const sourceAgent = typeof event.source?.agent === 'string' ? event.source.agent : '';
+        const sourceComponent = typeof event.source?.component === 'string' ? event.source.component : '';
+        return sourceAgent !== 'relay' && sourceComponent !== 'agents-relay';
     }
     async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
         const claim = executionId ?? `${jobId}:${taskId}`;
@@ -592,7 +619,16 @@ export class Reconciler {
     async applyTerminalEvent(event) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !['codex', 'chatgpt'].includes(task.adapter) || task.state !== 'RUNNING')
+        if (!task || !['codex', 'chatgpt'].includes(task.adapter))
+            return;
+        if (task.state === 'FAILED' && this.isRecoverableWatchdogFailure(task) && this.isWorkerOwnedEvent(event)) {
+            if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
+                return;
+            transitionTask(task, 'RUNNING');
+            task.failureReason = undefined;
+            task.error = null;
+        }
+        if (task.state !== 'RUNNING')
             return;
         const terminalWaiter = this.terminalWaiters.get(task.id);
         if (terminalWaiter && (!event.timestamp || new Date(event.timestamp).getTime() < terminalWaiter.launchBarrier))
@@ -606,12 +642,14 @@ export class Reconciler {
         if (event.type === 'task.completed') {
             task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
             task.error = null;
+            task.failureReason = undefined;
             transitionTask(task, 'SUCCEEDED');
             await this.store.saveTask(task);
             await this.deliverContinuation(job, task);
         }
         else if (event.type === 'task.failed') {
             task.error = event.message || `Task ${task.id} failed`;
+            task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
             transitionTask(task, 'FAILED');
             await this.store.saveTask(task);
         }

package/dist/types.js

@@ -1,9 +1,9 @@
 export const STORY_SIZE_TIMEOUT_MS = { S: 300000, M: 900000, L: 2700000 };
 export function storySizeTimeoutMs(size) { return STORY_SIZE_TIMEOUT_MS[size]; }
 export function taskOverallTimeoutMs(size, reasoning) { return storySizeTimeoutMs(size) * (reasoning?.toLowerCase() === 'high' ? 2 : 1); }
-export function chatGptStartAckTimeoutMs(overallTimeoutMs) { return Math.min(300000, Math.max(60000, Math.floor(overallTimeoutMs / 3))); }
+export function chatGptStartAckTimeoutMs(overallTimeoutMs) { return Math.min(600000, Math.max(120000, Math.floor(overallTimeoutMs / 3))); }
 const jobTransitions = { OPEN: ['RUNNING', 'WAITING', 'BLOCKED', 'COMPLETED', 'CANCELLED'], RUNNING: ['OPEN', 'WAITING', 'BLOCKED', 'COMPLETED', 'FAILED', 'CANCELLED'], WAITING: ['RUNNING', 'BLOCKED', 'COMPLETED', 'CANCELLED'], BLOCKED: ['RUNNING', 'CANCELLED'], COMPLETED: ['RUNNING', 'CANCELLED'], FAILED: ['RUNNING', 'CANCELLED'], CANCELLED: ['RUNNING'] };
-const taskTransitions = { QUEUED: ['READY', 'BLOCKED', 'CANCELLED'], READY: ['RUNNING', 'BLOCKED', 'FAILED', 'CANCELLED'], RUNNING: ['WAITING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED', 'READY'], WAITING: ['READY', 'BLOCKED', 'CANCELLED'], BLOCKED: ['READY', 'CANCELLED'], SUCCEEDED: [], FAILED: ['READY', 'CANCELLED'], CANCELLED: [] };
+const taskTransitions = { QUEUED: ['READY', 'BLOCKED', 'CANCELLED'], READY: ['RUNNING', 'BLOCKED', 'FAILED', 'CANCELLED'], RUNNING: ['WAITING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED', 'READY'], WAITING: ['READY', 'BLOCKED', 'CANCELLED'], BLOCKED: ['READY', 'CANCELLED'], SUCCEEDED: [], FAILED: ['READY', 'RUNNING', 'CANCELLED'], CANCELLED: [] };
 export function assertJobTransition(from, to) { if (from !== to && !jobTransitions[from].includes(to))
     throw new Error(`Invalid job transition ${from} -> ${to}`); }
 export function assertTaskTransition(from, to) { if (from !== to && !taskTransitions[from].includes(to))

package/package.json

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

package/skills/agents-relay/contracts/task-job-contract.md

@@ -17,11 +17,7 @@ Every worker task has one of three story sizes:
 
 Relay derives the overall execution timeout from `storySize`. If `routing.reasoning` is `high`, Relay doubles the overall execution timeout. Other reasoning levels do not change it.
 
-For ChatGPT Browser Worker tasks, Relay derives start-ack timeout from the effective overall timeout:
-
-`startAckTimeout = clamp(overallTimeout / 3, 1 minute, 5 minutes)`
-
-This applies equally to normal ChatGPT tasks and reviewer tasks. Raw `timeoutMs` is a compatibility/debug/hotfix override, not the normal task-production interface.
+Raw `timeoutMs` is a compatibility/debug/hotfix override, not the normal task-production interface.
 
 ## Worker lifecycle