agents-relay 1.0.69 → 1.0.70

package/dist/reconciler.js

@@ -10,11 +10,16 @@ import { selectReviewer } from './reviewer-routing.js';
 import { selectWorker, usageForProvider, workerCandidates } from './worker-routing.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareTaskPriority(a, b, jobPriority = 'P2') { const ar = PRIORITY_RANK[a.priority ?? jobPriority]; const br = PRIORITY_RANK[b.priority ?? jobPriority]; return ar - br || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
+export function executionEventSource(jobId, taskId, executionId) { return `job/${jobId}/task/${taskId}/execution/${executionId}`; }
+function eventSourceId(event) { return typeof event.source?.id === 'string' ? event.source.id : undefined; }
 export function managedWorkerInput(job, task, context) {
     if (!['codex', 'chatgpt'].includes(task.adapter) || !job.repository || job.prNumber <= 0)
         return task.input;
     if (!task.output)
         throw new Error(`Task ${task.id} requires an explicit output contract`);
+    if (!task.executionId)
+        throw new Error(`Task ${task.id} requires an executionId before worker input is built`);
+    const sourceId = executionEventSource(job.id, task.id, task.executionId);
     const prUrl = `https://github.com/${job.repository}/pull/${job.prNumber}`;
     const taskUrl = task.taskUrl ?? `${prUrl}#issuecomment-${task.id}`;
     const output = task.output.kind === 'file'
@@ -36,6 +41,8 @@ ${output}
 
 [Execution event contract — mandatory]
 Use the canonical Neo events-bus with exactly Job ${job.id} and Task ${task.id}.
+Your exact event source identity is: ${sourceId}
+Every lifecycle event for this execution MUST set source.id to that exact string. Do not derive, rename, or replace it.
 Follow the events-bus skill/protocol. For sandboxed Codex or hosted ChatGPT,
 publish through the federated MCP tool events__publish; do not open NATS directly.
 For a direct non-sandbox local worker, use NEO_EVENTS_EMIT when the caller provides it.
@@ -236,7 +243,7 @@ export class Reconciler {
         const now = new Date().toISOString();
         const implementationTasks = job.tasks.filter(item => item.agentName !== 'reviewer' && !this.isSupersededTask(item));
         const reviewerRouting = await this.selectReviewer(implementationTasks);
-        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: implementationTasks.map(item => item.id), capabilities: ['review'], workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter, input: `Review PR #${job.prNumber} at head SHA ${headSha}. Objective: ${job.objective ?? job.description ?? job.title}. First publish task.started as the worker start acknowledgement with data.worker_owned=true, then verify the deterministic pre-review gates have passed and inspect the completed work. Emit review.started, then exactly one of review.approved, review.changes_required, or review.blocked with data.review.headSha set to ${headSha}. For review.changes_required, include every actionable finding in data.review.issues as an array of concise issue strings; Relay will create one durable fix task containing all findings. Do not modify code. When auto-merge is enabled, Relay will merge this exact reviewed head after review.approved.`, output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
+        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: implementationTasks.map(item => item.id), capabilities: ['review'], workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter, input: `Review PR #${job.prNumber} at head SHA ${headSha}. Objective: ${job.objective ?? job.description ?? job.title}. First publish task.started using the caller-provided execution source identity, then verify the deterministic pre-review gates have passed and inspect the completed work. Emit review.started, then exactly one of review.approved, review.changes_required, or review.blocked with data.review.headSha set to ${headSha}. For review.changes_required, include every actionable finding in data.review.issues as an array of concise issue strings; Relay will create one durable fix task containing all findings. Do not modify code. When auto-merge is enabled, Relay will merge this exact reviewed head after review.approved.`, output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
         await this.store.appendTask(task);
         job.review = { outcome: 'pending', headSha, taskId: id, evidence: null, updatedAt: now };
         job.updatedAt = now;
@@ -455,12 +462,10 @@ export class Reconciler {
             await this.store.saveTask(task);
             return;
         }
-        let workerInput;
         let executionContext;
         try {
             const role = task.agentName === 'reviewer' ? 'reviewer' : task.parentTaskId ? 'nested-worker' : 'worker';
             executionContext = await this.resolvedContext(job, task, role);
-            workerInput = managedWorkerInput(job, task, executionContext);
         }
         catch (error) {
             await transitionTaskEvent(task, 'block');
@@ -499,8 +504,10 @@ export class Reconciler {
         const durableExecutionId = task.executionId;
         const controller = new AbortController();
         let execution;
+        const sourceId = executionEventSource(job.id, task.id, durableExecutionId);
+        const workerInput = managedWorkerInput(job, task, executionContext);
         const workerTask = { ...task, input: workerInput, routing: task.routing ? { ...task.routing, cwd: task.routing.cwd ?? executionContext.project.path } : task.routing };
-        const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, Date.now(), this.options.startAckTimeoutMs ?? chatGptStartAckTimeoutMs(task.timeoutMs)) : null;
+        const startAckSetup = task.adapter === 'chatgpt' ? await this.startAck(job.id, task.id, sourceId, Date.now(), this.options.startAckTimeoutMs ?? chatGptStartAckTimeoutMs(task.timeoutMs)) : null;
         const closePolicy = task.chatgptTabClosePolicy ?? this.options.chatgptTabClosePolicy ?? adapter.tabClosePolicy ?? 'after-start';
         const terminalWait = task.adapter === 'chatgpt' && closePolicy === 'after-terminal'
             ? this.terminalWait(task.id, durableExecutionId, startedAt - 1)
@@ -533,7 +540,7 @@ export class Reconciler {
                 ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'delivery')
                 : this.runtimeSettled(job.id, task.id, durableExecutionId, null, error instanceof Error ? error.message : String(error))), job.id, task.id, 'worker runtime completion');
     }
-    async startAck(jobId, taskId, launchBarrier, timeoutMs = this.options.startAckTimeoutMs ?? 60000) {
+    async startAck(jobId, taskId, sourceId, launchBarrier, timeoutMs = this.options.startAckTimeoutMs ?? 60000) {
         if (!this.options.eventBus)
             throw new Error('Worker start acknowledgement requires an event bus');
         let resolveAck;
@@ -544,10 +551,7 @@ export class Reconciler {
         const unsubscribe = await this.options.eventBus.subscribe(jobId, async (event) => {
             if (settled || event.type !== 'task.started' || event.job_id !== jobId || event.task_id !== taskId)
                 return;
-            const sourceAgent = typeof event.source?.agent === 'string' ? event.source.agent : '';
-            const sourceComponent = typeof event.source?.component === 'string' ? event.source.component : '';
-            const workerOwned = event.data?.worker_owned === true || ['codex', 'chatgpt'].includes(sourceAgent);
-            if (!workerOwned || sourceAgent === 'relay' || sourceComponent === 'agents-relay')
+            if (eventSourceId(event) !== sourceId)
                 return;
             if (!event.timestamp || new Date(event.timestamp).getTime() < launchBarrier)
                 return;
@@ -688,16 +692,12 @@ export class Reconciler {
         this.terminalExitGraceTimers.delete(taskId);
     }
     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;
         const live = this.live.get(event.task_id);
         if (live && event.job_id === live.jobId && event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
             return;
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task)
+        if (!task || !task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
             return;
         const claimedExecution = task.state === 'QUEUED' && task.executionId !== null && task.leaseOwner !== null;
         const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
@@ -731,10 +731,8 @@ export class Reconciler {
             || 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';
+    isCorrelatedWorkerEvent(task, event) {
+        return task.executionId !== null && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId);
     }
     async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
         const claim = executionId ?? `${jobId}:${taskId}`;
@@ -758,7 +756,7 @@ export class Reconciler {
             await this.store.saveTask(task);
         }
         else {
-            await this.applyTerminalEvent(event);
+            await this.applyTerminalEvent(event, true);
         }
         await this.emit(event);
     }
@@ -804,7 +802,7 @@ export class Reconciler {
             await this.store.saveTask(task);
         }
         else {
-            await this.applyTerminalEvent(event);
+            await this.applyTerminalEvent(event, true);
         }
         await this.emit(event);
     }
@@ -831,16 +829,19 @@ export class Reconciler {
             this.clearExecution(task.id, executionId);
         }
         else {
-            await this.applyTerminalEvent(event);
+            await this.applyTerminalEvent(event, true);
         }
         await this.emit(event);
     }
-    async applyTerminalEvent(event) {
+    async applyTerminalEvent(event, trustedInternal = false) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id);
         if (!task || !['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
             return;
-        if (task.state === 'FAILED' && this.isRecoverableWatchdogFailure(task) && this.isWorkerOwnedEvent(event)) {
+        const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
+        if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
+            return;
+        if (task.state === 'FAILED' && this.isRecoverableWatchdogFailure(task) && (trustedInternal || !modelBacked || this.isCorrelatedWorkerEvent(task, event))) {
             if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
                 return;
             await transitionTaskEvent(task, 'reconcile.started');

package/package.json

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

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

@@ -63,6 +63,8 @@ Do not use `WAITING` as a Task state or durable Job lifecycle state. `WAITING` i
 
 Relay owns process lifecycle. Workers own semantic task lifecycle. A worker must publish canonical `task.started` as its first execution action, then exactly one of `task.completed`, `task.failed`, `task.blocked`, or `task.cancelled`. Process launch/exit events do not substitute for worker semantic events.
 
+Relay allocates the durable `executionId` before launching model-backed work and gives that worker one exact event source identity: `job/<job-id>/task/<task-id>/execution/<execution-id>`. Every semantic lifecycle event from that execution must copy the identity verbatim in `source.id`. Relay correlates model-worker lifecycle only by this execution identity; `source.agent`, `source.component`, provider/adapter names, and `data.worker_owned` are diagnostic/legacy metadata and MUST NOT authorize or correlate lifecycle state. A retry receives a new execution identity, so events from an older execution are ignored.
+
 ## Job lifecycle and runtime status
 
 The canonical durable lifecycle transition graphs are `workflow/job-lifecycle.mmd` and `workflow/task-lifecycle.mmd`. They use Relay's minimal executable Mermaid `stateDiagram-v2` profile and are the single source of truth for transition legality; do not maintain a parallel JSON/YAML transition table. Runtime status is not part of those lifecycle graphs.