agents-relay 1.0.123 → 1.0.125

package/dist/reconciler-review.js

@@ -1,6 +1,6 @@
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
 import { schedule, transitionTaskEvent, transitionJobEvent } from './scheduler.js';
-import { implementationComplete } from './runtime-status.js';
+import { implementationComplete, implementationTasks } from './runtime-status.js';
 import { eventFor } from './events.js';
 import { selectReviewer } from './reviewer-routing.js';
 import { routeWorker, workerCandidates } from './worker-routing.js';
@@ -26,8 +26,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async ensureFinalReview(job, prState, headSha) {
         if (job.schedule || job.reviewEnabled === false || prState !== 'OPEN' || job.state !== 'ACTIVE' || !implementationComplete(job) || !headSha)
             return;
-        if (!this.preReviewGatesPass(job))
-            return;
         const review = job.review;
         if (review?.headSha === headSha && ['started', 'approved', 'changes_required', 'blocked'].includes(review.outcome))
             return;
@@ -38,9 +36,9 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             return;
         const id = `final-review-${headSha.slice(0, 12)}`;
         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 existing PR #${job.prNumber} at exactly head SHA ${headSha}. Job objective: ${job.objective ?? job.description ?? job.title}. Use the selected reviewer agent contract as the authoritative review protocol.`, 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 reviewGateTasks = implementationTasks(job);
+        const reviewerRouting = await this.selectReviewer(reviewGateTasks);
+        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: reviewGateTasks.map(item => item.id), capabilities: ['review'], workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter, input: `Review existing PR #${job.prNumber} at exactly head SHA ${headSha}. Job objective: ${job.objective ?? job.description ?? job.title}. Use the selected reviewer agent contract as the authoritative review protocol.`, 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;
@@ -145,12 +143,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', `Selected ${task.routing.model} · thinking ${task.routing.reasoning ?? 'unknown'}`, 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
         }
     }
-    isSupersededTask(task) {
-        return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
-    }
-    preReviewGatesPass(job) {
-        return job.tasks.filter(task => task.agentName !== 'reviewer' && !this.isSupersededTask(task)).every(task => task.state === 'SUCCEEDED');
-    }
     async applyReviewEvent(event) {
         const job = await this.store.load(event.job_id);
         const task = job.tasks.find(item => item.id === event.task_id && item.agentName === 'reviewer');

package/dist/reconciler.js

@@ -56,7 +56,7 @@ For a direct non-sandbox local worker, use NEO_EVENTS_EMIT when the caller provi
 As your FIRST execution action, before reading files, editing code, running commands, or doing other work,
 you MUST publish exactly one canonical task.started event for this exact Job/Task.
 
-You MAY publish progress events while working.
+${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.`}
 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/runtime-status.js

@@ -2,7 +2,7 @@ function isSuperseded(task) {
     return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
 }
 export function implementationTasks(job) {
-    return job.tasks.filter(task => task.agentName !== 'reviewer' && !isSuperseded(task));
+    return job.tasks.filter(task => task.agentName !== 'reviewer' && task.agentName !== 'troubleshooter' && !isSuperseded(task));
 }
 export function implementationComplete(job) {
     const tasks = implementationTasks(job);

package/package.json

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

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

@@ -107,7 +107,7 @@ Blocker resolution is generation-safe and idempotent: Relay retries a dependent
 
 ## Worker lifecycle
 
-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 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. Because the ChatGPT worker continues asynchronously after its submit process exits, its managed execution prompt must also require the shared events-bus liveness rule: publish meaningful progress when available, and publish non-terminal `task.heartbeat` after each 30 seconds of otherwise silent active work until a terminal task event is emitted.
 
 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.