agents-relay 2.0.151 → 2.0.153

package/README.md

@@ -138,7 +138,7 @@ 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, lifecycle events, review, and auto-merge semantics.
 
 Execution routing is code-driven: Relay builds complete executable worker+model routes from authoritative runtime/model/resource facts, merges profile defaults with the user's explicit `[choices]`, deduplicates them, removes only impossible routes via hard gates, then calls the generic typed `decide(request, contract)` boundary exactly once with one merged choice list and the `[routing-instruction]` text forwarded verbatim. Task/resource/capability signals and the routing instruction are soft decision facts; decision failure falls back deterministically to a usable Codex default route. See [Execution Router and typed decisions](docs/worker-model-routers.md).
-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.
+All task producers use the same story-size contract: `S`≈5 minutes, `M`≈15 minutes, and `L`≈45 minutes of inactivity, with `M` as the default. `high` reasoning doubles that inactivity window. Accepted `task.started` and newer `task.progress` events from the exact current execution reset it. ChatGPT Browser Worker start-ack timeout is derived as one third of the effective inactivity 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.
 
 Autonomous jobs can also be scheduled. The Job marker stores a five-field cron expression, IANA timezone, next run, and missed-run/concurrency policy. The daemon evaluates the SQLite-backed managed Job view and validates durable schedule facts before claiming a due slot. A repository heartbeat invokes `tick` at 10-minute resolution. See
 [Scheduled autonomous jobs](docs/scheduled-autonomous-jobs.md) for the exact

package/dist/cli-help.js

@@ -135,7 +135,8 @@ Example:
     'task update': `Update mutable durable Task fields in place.
 
 Required: --task-id ID and the normal Job storage options.
-Mutable while not RUNNING/SUCCEEDED/CANCELLED: --title, --adapter, --priority, --story-size, --input-file PATH|- or --input MARKDOWN, --project, --agent, --agent-graph-file PATH|-, --parent, --deps, --capabilities, --timeout, --max-attempts, --provider, --model, --profile, --reasoning, --cwd, --chatgpt-project, --chatgpt-tab-close-policy, --draft, --queue.
+Mutable while not RUNNING/SUCCEEDED/CANCELLED: --title, --adapter, --priority, --story-size, --input-file PATH|- or --input MARKDOWN, --project, --agent, --agent-graph-file PATH|-, --parent, --deps, --capabilities, --timeout (inactivity window), --max-attempts, --provider, --model, --profile, --reasoning, --cwd, --chatgpt-project, --chatgpt-tab-close-policy, --draft, --queue.
+Accepted task.started and newer current-execution task.progress events reset --timeout.
 Use --clear-routing to remove routing metadata.
 
 Example:

package/dist/managed-worker-input.js

@@ -70,7 +70,7 @@ As your FIRST execution action, before reading files, editing code, running comm
 you MUST publish exactly one canonical task.started event for this exact Job/Task.
 Immediately after task.started, BEFORE reading task context or doing any implementation/review/recovery work, read the full authoritative Relay event contract at absolute path /Users/chengli/Workspace/agents-relay/skills/agents-relay/contracts/event-contract.md. If it cannot be read, publish task.failed with the blocker and stop. Do not rely only on this prompt summary or a relative path.
 
-${task.adapter === 'chatgpt' ? `Because ChatGPT execution continues asynchronously after the submit process exits, you MUST keep reporting liveness while the task is active. Publish meaningful progress/milestone events when there is real progress to report. If no meaningful milestone has been published for 30 seconds during active work, publish a non-terminal task.heartbeat event with status running, visibility orchestrator, this exact source.id, and a concise description of the current operation. Continue heartbeats after each further 30 seconds of active silence until a terminal task event is published. Do not invent percentage progress.` : `You MAY publish progress events while working. For long silent active work, follow the events-bus heartbeat policy.`}
+Publish task.progress only for meaningful work milestones. It is nonterminal; do not fabricate progress. Relay's Task.timeoutMs is an inactivity timeout reset only by accepted task.started or newer task.progress events for this exact execution.
 Before returning or allowing the worker process to exit, you MUST publish exactly one canonical terminal event:
 - task.completed only after the declared output is durable;
 - task.failed for implementation, tool, command, test, patch, commit, push, runtime, or other execution failure that prevents completion;

package/dist/pool.js

@@ -232,7 +232,7 @@ export class RepositoryWorkerPool {
                 return;
             if (routedWebhook)
                 return;
-            const lifecycle = ['task.started', 'task.completed', 'task.failed', 'task.blocked', 'task.unblocked', 'task.cancelled', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type);
+            const lifecycle = ['task.started', 'task.progress', 'task.completed', 'task.failed', 'task.blocked', 'task.unblocked', 'task.cancelled', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type);
             // GitHub transport is observational. It must never wake lifecycle execution.
             if (event.type === 'github.webhook')
                 return;

package/dist/reconciler-runtime.js

@@ -9,12 +9,12 @@ import { eventFor } from './events.js';
 import { WorkflowEffectExecutor } from './workflow/effects.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { acceptedReportedTag, eventDataWithoutTag } from './task-tag.js';
-import { rearmTerminalEventDeadline } from './terminal-event-watchdog.js';
 import { createWorkerStartAck } from './worker-start-ack.js';
 import { monitorExecutionProcess } from './execution-process-tracker.js';
 import { HostInteractiveInvocationCoordinator, hostInvocationPorts } from './interactive-invocation.js';
 import { resumeInteractiveTask } from './interactive-resume.js';
 import { codexFallbackCompatible, persistChatGptPlatformFailure } from './chatgpt-platform-fallback.js';
+import { acceptTaskProgress, armInactivityWatchdog, inactivityDeadline, isCorrelatedWorkerEvent, isRecoverableWatchdogFailure } from './task-inactivity-watchdog.js';
 const activeExecutionOwners = new Map();
 import { withExecutionBoundary } from './execution-boundary.js';
 export { withExecutionBoundary } from './execution-boundary.js';
@@ -84,6 +84,8 @@ export class ReconcilerRuntimeBase {
             return activeOwner.applyEvent(event);
         if (event.type === 'task.started')
             return this.markWorkerStarted(event);
+        if (event.type === 'task.progress')
+            return this.markWorkerProgress(event);
         if (event.type === 'task.completed') {
             const task = (await this.store.load(event.job_id)).tasks.find(item => item.id === event.task_id);
             const normalized = task?.agentName === 'reviewer' ? normalizeReviewerTerminalEvent(event) : null;
@@ -176,14 +178,8 @@ export class ReconcilerRuntimeBase {
         owner.clearExecution(taskId, executionId);
         return true;
     }
-    clearTerminalTimer(taskId, executionId) {
-        const live = this.live.get(taskId);
-        if (!live || live.executionId !== executionId)
-            return;
-        const timer = this.terminalTimers.get(taskId);
-        if (timer)
-            clearTimeout(timer);
-        this.terminalTimers.delete(taskId);
+    armInactivityWatchdog(task, executionId) {
+        armInactivityWatchdog(task, executionId, this.terminalTimers, this.options.postExitTerminalGraceMs ?? 15_000, () => this.detach(this.timeoutTask(task.jobId, task.id, executionId), task.jobId, task.id, 'worker inactivity timeout'));
     }
     clearExecution(taskId, executionId) {
         const live = this.live.get(taskId);
@@ -206,16 +202,19 @@ export class ReconcilerRuntimeBase {
             eligible: (job, task) => {
                 if (!task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
                     return false;
+                if (!Number.isFinite(Date.parse(event.timestamp)) || Date.parse(event.timestamp) > Date.now())
+                    return false;
                 const claimedExecution = task.executionId !== null && task.leaseOwner !== null;
                 const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
-                return Boolean(exactLiveExecution || claimedExecution || this.isRecoverableWatchdogFailure(task));
+                return Boolean(exactLiveExecution || claimedExecution || isRecoverableWatchdogFailure(task));
             },
             facts: (_job, task) => ({
-                recoverableExecution: this.isRecoverableWatchdogFailure(task)
+                recoverableExecution: isRecoverableWatchdogFailure(task)
                     && Boolean(task.executionId && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId)),
             }),
             mutate: (_job, task) => {
-                task.updatedAt = new Date().toISOString();
+                task.updatedAt = task.lastProgressAt = new Date().toISOString();
+                task.lastProgressEventAt = event.timestamp;
             },
         });
         if (!transition?.decision.accepted)
@@ -227,21 +226,11 @@ export class ReconcilerRuntimeBase {
         }
         if (live?.executionId === transition.task.executionId)
             live.workerStarted = true;
+        this.armInactivityWatchdog(transition.task, transition.task.executionId);
         return { applied: true, reconcile: transition.from === 'FAILED', reason: transition.from === 'FAILED' ? 'task.started.recovery' : 'task.started', reconcileMode: transition.from === 'FAILED' ? 'detached' : undefined };
     }
-    isRecoverableWatchdogFailure(task) {
-        if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event', 'worker_delivery_after_start'].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')
-            || error.includes('Worker delivery failed after task.started');
-    }
-    isCorrelatedWorkerEvent(task, event) {
-        return task.executionId !== null && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId);
-    }
+    async markWorkerProgress(event) { const task = await acceptTaskProgress(this.taskTransitions, event); if (!task?.executionId)
+        return { applied: false, reconcile: false, reason: 'task.progress.ignored' }; this.armInactivityWatchdog(task, task.executionId); return { applied: true, reconcile: false, reason: 'task.progress' }; }
     finalizeReviewExecution(jobId, task, event, afterCommit = true) {
         if (!task.executionId)
             return true;
@@ -331,29 +320,38 @@ export class ReconcilerRuntimeBase {
         const task = job.tasks.find(item => item.id === taskId);
         if (!task)
             return;
+        if (task.adapter !== 'chatgpt') {
+            const exited = await this.taskTransitions.updateFact(jobId, taskId, current => current.executionId === executionId && ['RUNNING', 'QUEUED'].includes(current.state), current => { current.processExitedAt = new Date().toISOString(); });
+            if (exited)
+                this.armInactivityWatchdog(exited, executionId);
+        }
         const correlated = task.executionId === executionId || task.executionHistory?.some(item => item.id === executionId);
         if (!correlated)
             return;
         if (task.adapter !== 'chatgpt' && (task.executionId !== executionId || terminalExecutionClaimed(jobId, taskId, executionId)))
             return;
-        if (task.adapter !== 'chatgpt' && task.executionId === executionId && live?.executionId === executionId)
-            rearmTerminalEventDeadline(this.terminalTimers, taskId, task.timeoutMs - (Date.now() - live.launchBarrier), this.options.postExitTerminalGraceMs ?? 15_000, () => this.detach(this.timeoutTask(jobId, taskId, executionId), jobId, taskId, 'post-exit terminal event timeout'));
         await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (live?.execution.processExit?.terminationReason === 'parent-shutdown' ? 'Worker interrupted by daemon shutdown' : error ? `Worker exited: ${error}${live?.execution.processExit ? ` (exit=${live.execution.processExit.exitCode ?? 'null'}${live.execution.processExit.signal ? ` signal=${live.execution.processExit.signal}` : ''})` : ''}` : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
             signal: live?.execution.processExit?.signal ?? null, terminationReason: live?.execution.processExit?.terminationReason ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error, executionId, pid: live?.execution.pid ?? null }, { id: executionEventSource(jobId, taskId, executionId), agent: 'relay', component: 'agents-relay' }));
     }
     async timeoutTask(jobId, taskId, executionId) {
-        const live = this.live.get(taskId);
-        if (live?.executionId === executionId) {
-            live.controller.abort();
-            live.execution.cancel();
+        const current = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
+        if (!current || current.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(current.state))
+            return;
+        const deadline = inactivityDeadline(current, executionId, this.options.postExitTerminalGraceMs ?? 15_000);
+        if (deadline > Date.now()) {
+            this.armInactivityWatchdog(current, executionId);
+            return;
         }
+        const live = this.live.get(taskId);
+        // Do not cancel before the serialized watchdog transition rechecks the
+        // deadline: a concurrent accepted progress event may have extended it.
         const exit = live?.executionId === executionId && live.processSettled ? live.execution.processExit : undefined;
         const rawError = live?.executionId === executionId && live.processSettled ? (live.processError || exit?.stderr || '').trim() : '';
         const failedExit = Boolean(exit && (exit.exitCode !== 0 || exit.signal));
         const failureReason = failedExit ? classifyWorkerRejection(rawError) : 'terminal_event_timeout';
-        const failureMessage = failedExit ? (rawError || `Worker exited with code ${exit?.exitCode ?? 'null'}${exit?.signal ? `, signal ${exit.signal}` : ''}`) : `Task ${taskId} timed out waiting for the mandatory terminal worker event`;
+        const failureMessage = failedExit ? (rawError || `Worker exited with code ${exit?.exitCode ?? 'null'}${exit?.signal ? `, signal ${exit.signal}` : ''}`) : `Task ${taskId} exceeded its inactivity timeout without a terminal event`;
         const transition = await this.taskTransitions.apply(jobId, taskId, 'watchdog.failed', {
-            eligible: (_job, task) => task.executionId === executionId,
+            eligible: (_job, task) => task.executionId === executionId && inactivityDeadline(task, executionId, this.options.postExitTerminalGraceMs ?? 15_000) <= Date.now(),
             mutate: (_job, task) => {
                 this.clearExecution(task.id, executionId);
                 task.error = failureMessage;
@@ -363,9 +361,15 @@ export class ReconcilerRuntimeBase {
             },
         });
         if (!transition?.decision.accepted) {
-            this.clearExecution(taskId, executionId);
+            const latest = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
+            if (latest?.executionId === executionId && ['QUEUED', 'RUNNING'].includes(latest.state))
+                this.armInactivityWatchdog(latest, executionId);
             return;
         }
+        if (live?.executionId === executionId) {
+            live.controller.abort();
+            live.execution.cancel();
+        }
         let reroutedTask = null;
         if (reroutableWorkerRejections.has(failureReason) && transition.task.attempt < transition.task.maxAttempts) {
             const current = (await this.store.load(jobId)).tasks.find(task => task.id === taskId);
@@ -410,19 +414,19 @@ export class ReconcilerRuntimeBase {
                 if (event.type === 'task.completed' && task.interactiveInvocation?.status !== undefined && task.interactiveInvocation.status !== 'approved')
                     return false; // current interactive revision requires durable approval
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
-                if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event)) {
+                if (!trustedInternal && modelBacked && !isCorrelatedWorkerEvent(task, event)) {
                     const eventExecutionId = executionIdFromSource(eventSourceId(event), _job.id, task.id);
                     const prior = eventExecutionId ? task.executionHistory?.find(item => item.id === eventExecutionId) : undefined;
                     if (!prior || prior.attempt !== task.attempt)
                         return false;
                 }
                 const terminalWaiter = this.terminalWaiters.get(task.id);
-                return !terminalWaiter || Boolean(task.executionId && terminalWaiter.executionId === task.executionId && this.isCorrelatedWorkerEvent(task, event));
+                return !terminalWaiter || Boolean(task.executionId && terminalWaiter.executionId === task.executionId && isCorrelatedWorkerEvent(task, event));
             },
             facts: (_job, task) => {
                 const processExitedAfterPublishedTerminal = task.failureReason === 'worker_exit_without_terminal_event';
-                const freshEnough = processExitedAfterPublishedTerminal || this.isCorrelatedWorkerEvent(task, event);
-                return { recoverableExecution: this.isRecoverableWatchdogFailure(task) && freshEnough };
+                const freshEnough = processExitedAfterPublishedTerminal || isCorrelatedWorkerEvent(task, event);
+                return { recoverableExecution: isRecoverableWatchdogFailure(task) && freshEnough };
             },
             mutate: (job, task) => {
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';

package/dist/reconciler.js

@@ -180,6 +180,9 @@ export class Reconciler extends ReconcilerReviewBase {
             const taskStatesBeforeSchedule = new Map(beforeSchedule.tasks.map(task => [task.id, task.state]));
             const scheduleBefore = JSON.stringify(beforeSchedule.schedule ?? null);
             let scheduled = schedule(beforeSchedule);
+            for (const task of scheduled.tasks)
+                if (task.executionId && ['QUEUED', 'RUNNING'].includes(task.state))
+                    this.armInactivityWatchdog(task, task.executionId);
             for (const task of scheduled.tasks) {
                 if (taskStatesBeforeSchedule.get(task.id) !== task.state)
                     await this.store.saveTask(task);
@@ -366,6 +369,9 @@ export class Reconciler extends ReconcilerReviewBase {
             freshTask.leaseOwner = this.options.owner;
             freshTask.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
             freshTask.executionId = randomUUID();
+            delete freshTask.lastProgressAt;
+            delete freshTask.lastProgressEventAt;
+            delete freshTask.processExitedAt;
             freshTask.executionHistory = [...(freshTask.executionHistory ?? []), {
                     id: freshTask.executionId,
                     attempt: freshTask.attempt,
@@ -396,6 +402,9 @@ export class Reconciler extends ReconcilerReviewBase {
                     durable.leaseOwner = this.options.owner;
                     durable.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
                     durable.executionId = randomUUID();
+                    delete durable.lastProgressAt;
+                    delete durable.lastProgressEventAt;
+                    delete durable.processExitedAt;
                     durable.executionHistory = [...(durable.executionHistory ?? []), {
                             id: durable.executionId, attempt: durable.attempt, startedAt: new Date(startedAt).toISOString(),
                         }].slice(-8);
@@ -514,10 +523,7 @@ export class Reconciler extends ReconcilerReviewBase {
             transition: { graph: 'task-lifecycle', from: 'QUEUED', to: 'QUEUED', actions: ['effect.launchTask'] },
             data: { adapter: adapter.id, attempt: task.attempt, model: task.routing?.model ?? null },
         });
-        const terminalTimer = setTimeout(() => {
-            this.detach(this.timeoutTask(job.id, task.id, durableExecutionId), job.id, task.id, 'worker terminal-event timeout');
-        }, Math.max(1, task.timeoutMs));
-        this.terminalTimers.set(task.id, terminalTimer);
+        this.armInactivityWatchdog(task, durableExecutionId);
         this.detach(execution.promise.then(result => this.runtimeSettled(job.id, task.id, durableExecutionId, result, null), error => error instanceof StartAckTimeout
             ? this.failLaunch(job.id, task.id, durableExecutionId, error, 'start-ack')
             : error instanceof LaunchFailure || error instanceof PreSubmissionRejection

package/dist/task-context.js

@@ -45,5 +45,5 @@ THEN read the entire authoritative event contract from /Users/chengli/Workspace/
 THEN retrieve the authoritative Task Context:
   agents-relay task context --repo ${repository} --id ${jobId} --task-id ${taskId} --execution-id ${executionId}
 Verify the execution ID. Read Task input, dependencies, Plan, project context, and output requirements from that response. Never guess or create a new Job. Continue in this thread; Relay owns completion and review.
-Follow the file's lifecycle contract, including progress/heartbeat and exactly one task.completed or task.failed before exiting. If context is unavailable publish task.failed with the blocker.`;
+Follow the file's lifecycle contract, including optional meaningful progress and exactly one task.completed or task.failed before exiting. Accepted current-execution task.started and newer task.progress events reset Task.timeoutMs; duplicate, stale, or out-of-order progress does not. If context is unavailable publish task.failed with the blocker.`;
 }

package/dist/task-inactivity-watchdog.js

@@ -0,0 +1,45 @@
+import { executionEventSource, eventSourceId } from './execution-event-identity.js';
+export function isRecoverableWatchdogFailure(task) {
+    if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event', 'worker_delivery_after_start'].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('exceeded its inactivity timeout')
+        || error.includes('exited before publishing task.started') || error.includes('exited after task.started without publishing a terminal task event')
+        || error.includes('Worker delivery failed after task.started');
+}
+export function isCorrelatedWorkerEvent(task, event) {
+    return task.executionId !== null && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId);
+}
+export function inactivityDeadline(task, executionId, postExitGraceMs) {
+    const progressAt = Date.parse(task.lastProgressAt ?? task.executionHistory?.find(item => item.id === executionId)?.startedAt ?? task.updatedAt);
+    const timeoutAt = (Number.isFinite(progressAt) ? progressAt : Date.now()) + Math.max(1, task.timeoutMs);
+    const exitAt = task.adapter !== 'chatgpt' && task.processExitedAt ? Date.parse(task.processExitedAt) : NaN;
+    return Number.isFinite(exitAt) ? Math.min(timeoutAt, exitAt + postExitGraceMs) : timeoutAt;
+}
+export function armInactivityWatchdog(task, executionId, timers, postExitGraceMs, expire) {
+    const existing = timers.get(task.id);
+    if (existing)
+        clearTimeout(existing);
+    timers.delete(task.id);
+    if (!task.jobId || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state))
+        return;
+    const timer = setTimeout(expire, Math.max(1, inactivityDeadline(task, executionId, postExitGraceMs) - Date.now()));
+    timer.unref();
+    timers.set(task.id, timer);
+}
+export async function acceptTaskProgress(transitions, event) {
+    const parsedAt = Date.parse(event.timestamp);
+    const receivedAt = Date.now();
+    const transition = await transitions.apply(event.job_id, event.task_id, 'task.progress', {
+        eligible: (job, task) => task.state === 'RUNNING'
+            && Boolean(task.executionId && eventSourceId(event) === executionEventSource(job.id, task.id, task.executionId))
+            && Number.isFinite(parsedAt) && parsedAt <= receivedAt
+            && (!task.lastProgressEventAt || parsedAt > Date.parse(task.lastProgressEventAt)),
+        mutate: (_job, task) => {
+            task.lastProgressAt = new Date(receivedAt).toISOString();
+            task.lastProgressEventAt = event.timestamp;
+            task.updatedAt = task.lastProgressAt;
+        },
+    });
+    return transition?.decision.accepted ? transition.task : null;
+}

package/dist/workflow/contracts.js

@@ -35,6 +35,7 @@ export const WORKFLOW_EVENT_NAMES = [
     'task.cancelled',
     'task.completed',
     'task.failed',
+    'task.progress',
     'task.started',
     'task.unblocked',
     'watchdog.failed',

package/dist/workflow/durable-transition.js

@@ -52,6 +52,32 @@ export class DurableTaskTransitionRuntime {
             return { job, task, from, decision };
         });
     }
+    /** Persist a non-lifecycle fact without racing the serialized terminal transitions. */
+    async updateFact(jobId, taskId, eligible, mutate) {
+        return this.withLock(`${jobId}/${taskId}`, async () => {
+            let accepted = false;
+            const apply = (job) => {
+                const task = job.tasks.find(item => item.id === taskId);
+                if (!task || !eligible(task))
+                    return job;
+                const previous = Date.parse(task.updatedAt);
+                mutate(task);
+                task.updatedAt = new Date(Math.max(Date.now(), Number.isFinite(previous) ? previous + 1 : 0)).toISOString();
+                accepted = true;
+                return job;
+            };
+            if (this.store.mutateJob) {
+                const updated = await this.store.mutateJob(jobId, apply);
+                return accepted ? updated.tasks.find(item => item.id === taskId) ?? null : null;
+            }
+            const job = apply(await this.store.load(jobId));
+            if (!accepted)
+                return null;
+            const task = job.tasks.find(item => item.id === taskId);
+            await this.store.saveTask(task);
+            return task;
+        });
+    }
     async withLock(key, work) {
         const previous = this.locks.get(key);
         let release;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-relay",
-  "version": "2.0.151",
+  "version": "2.0.153",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "repository": {
     "type": "git",
@@ -27,6 +27,7 @@
     "test:verification:matrix": "node test/verification/recovery-report.mjs /tmp/agents-relay-job481-evidence",
     "test:verification:l2": "npm run build && node --test test/verification/l2/*.test.mjs",
     "test:verification:l2:live": "node test/verification/l2/live-provider.mjs",
+    "test:verification:l2:live-codex": "npm run build && node test/verification/l2/live-codex-agents.mjs",
     "test:l2:agents": "npm run build && node test/l2-agent-prompts/evaluate.mjs"
   },
   "devDependencies": {

package/skills/agents-relay/SKILL.md

@@ -56,9 +56,9 @@ Agents Relay maps those terminal events to durable state:
 - `task.failed` → `FAILED`
 Relay may authoritatively move a Task to `BLOCKED` for an external condition and may resume it only through an authorized unblock operation. A human response is an append-only Task Comment and resumes the blocked Troubleshooter, not the failed original Task. Task input remains stable; recovery agents receive current authoritative state and relevant comments as execution context.
 
-A model-backed task must not launch without an event bus. If no terminal event arrives before the task timeout, Relay records an explicit timeout failure. A Codex process exit or ChatGPT submission receipt alone never changes the task to a terminal state.
+A model-backed task must not launch without an event bus. If no accepted `task.started` or newer current-execution `task.progress` arrives within `Task.timeoutMs`, Relay records an inactivity timeout failure. A Codex process exit or ChatGPT submission receipt alone never changes the task to a terminal state.
 
-Worker process exit is observational only. Relay does not perform an exit-time terminal check or synthesize task failure from process exit; semantic terminal state comes from the worker event contract or the normal task timeout.
+Worker process exit is observational only. Relay does not perform an exit-time terminal check or synthesize task failure from process exit; for synchronous workers it caps the remaining inactivity wait at the shorter post-exit terminal grace.
 
 ## Managed GitHub jobs
 

package/skills/agents-relay/contracts/event-contract.md

@@ -4,7 +4,9 @@
 
 ## Producer contract
 
-Every Implementation, Reviewer, and Troubleshooter execution publishes `task.started`, optional `task.progress` or `task.heartbeat`, then **exactly one** agent terminal event:
+Every Implementation, Reviewer, and Troubleshooter execution publishes `task.started`, optional `task.progress`, then **exactly one** agent terminal event:
+
+`task.started` and `task.progress` reset the Task inactivity timeout only when Relay accepts the event for the exact current execution. Progress is nonterminal, must be newer than the last accepted progress event, and cannot extend a terminal or stale execution.
 
 - `task.completed`: assigned responsibility finished and its role-specific output is durable, regardless of whether a reviewed artifact passed.
 - `task.failed`: assigned responsibility could not be fulfilled; include failure phase, reason, and evidence in `data`.

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

@@ -22,6 +22,8 @@ Ordinary `job create` requires standalone objective Markdown. An external displa
 Any task producer — orchestrator, planner, or nested task-producing agent — must follow this contract.
 Task producers choose semantic task properties such as objective, dependencies, worker requirements, priority, and `storySize`. They do not normally choose an adapter, provider/model, or raw timeout milliseconds.
 
+`Task.timeoutMs` is the inactivity window. Only an accepted `task.started` or newer `task.progress` event for the exact current execution resets it; duplicate, stale, and out-of-order progress does not.
+
 ### Planning graph and semantic Task tree
 
 The planning graph expresses execution flow. The Task tree expresses semantic ownership. `dependencies` answer which durable outcomes must succeed before a Task can run; `parentTaskId` answers which durable artifact or milestone owns the Task. These are independent relationships.

package/workflow/task-lifecycle.mmd

@@ -151,6 +151,7 @@ leaseFailQueuedClearExecution --> failed
 queued -->|on: cancel| cancelled
 
 running -->|on: task.blocked| blocked
+running -->|on: task.progress| running
 running -->|on: review.approved| reviewApproveRunningClearError
 reviewApproveRunningClearError --> reviewApproveRunningClearReason
 reviewApproveRunningClearReason --> succeeded

package/dist/terminal-event-watchdog.js

@@ -1,11 +0,0 @@
-/**
- * Replace the overall worker deadline with a shorter post-exit deadline.
- * Execution outcomes remain owned by the authoritative task lifecycle graph.
- * Never extend the original overall timeout.
- */
-export function rearmTerminalEventDeadline(timers, taskId, overallRemainingMs, graceMs, expire) {
-    const existing = timers.get(taskId);
-    if (existing)
-        clearTimeout(existing);
-    timers.set(taskId, setTimeout(expire, Math.max(1, Math.min(overallRemainingMs, graceMs))));
-}