agents-relay 1.0.53 → 1.0.54

package/dist/cli.js

@@ -411,7 +411,7 @@ async function runTaskCommand(action, args) {
     if (action === 'retry' || action === 'cancel') {
         if (action === 'retry')
             task.maxAttempts = extendRetryBudget(task);
-        task.state = action === 'retry' ? 'READY' : 'CANCELLED';
+        task.state = action === 'retry' ? 'QUEUED' : 'CANCELLED';
         task.error = action === 'retry' ? null : 'Cancelled by user';
         task.updatedAt = new Date().toISOString();
         await store.saveTask(task);

package/dist/reconciler.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { storySizeTimeoutMs, taskOverallTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
-import { schedule, transitionTask } from './scheduler.js';
+import { dependencyReady, schedule, transitionTask } from './scheduler.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
@@ -160,7 +160,7 @@ export class Reconciler {
                 for (const task of scheduled.tasks.filter(item => item.state === 'SUCCEEDED' && (item.continuation || scheduled.continuation) && !item.continuationDeliveredAt))
                     this.detach(this.deliverContinuation(scheduled, task), scheduled.id, task.id, 'continuation');
                 const capacity = Math.max(0, (this.options.maxConcurrent ?? 4) - this.live.size - this.plannerLive.size);
-                for (const task of scheduled.tasks.filter(t => t.state === 'READY').sort((a, b) => compareTaskPriority(a, b, scheduled.priority ?? 'P2')).slice(0, capacity)) {
+                for (const task of scheduled.tasks.filter(t => t.state === 'QUEUED' && dependencyReady(t, new Map(scheduled.tasks.map(item => [item.id, item])))).sort((a, b) => compareTaskPriority(a, b, scheduled.priority ?? 'P2')).slice(0, capacity)) {
                     if (task.kind === 'planner')
                         await this.launchPlanner(scheduled, task);
                     else if (task.adapter === 'orchestrator') {
@@ -199,7 +199,7 @@ export class Reconciler {
             return;
         job.review = { ...job.review, outcome: 'stale', updatedAt: new Date().toISOString() };
         const staleTask = job.review.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
-        if (staleTask && ['QUEUED', 'READY', 'RUNNING', 'WAITING'].includes(staleTask.state)) {
+        if (staleTask && ['QUEUED', 'RUNNING', 'WAITING'].includes(staleTask.state)) {
             this.live.get(staleTask.id)?.execution.cancel();
             transitionTask(staleTask, 'CANCELLED');
             staleTask.error = 'Review evidence became stale after the PR head changed';
@@ -218,7 +218,7 @@ export class Reconciler {
         if (review?.headSha === headSha && ['started', 'approved', 'changes_required', 'blocked'].includes(review.outcome))
             return;
         const reviewTasks = job.tasks.filter(task => task.agentName === 'reviewer' && task.reviewHeadSha === headSha);
-        if (reviewTasks.some(task => ['QUEUED', 'READY', 'RUNNING', 'WAITING'].includes(task.state)))
+        if (reviewTasks.some(task => ['QUEUED', 'RUNNING', 'WAITING'].includes(task.state)))
             return;
         if (reviewTasks.some(task => task.state === 'SUCCEEDED' && review?.headSha === headSha && review.outcome === 'approved'))
             return;
@@ -235,7 +235,7 @@ export class Reconciler {
         await this.emit(eventFor(job.id, id, null, 'review.created', 'queued', `Final review task ${id} created for ${headSha} using ${reviewerRouting.reason}`, 'orchestrator', { headSha, agentName: 'reviewer', reviewerRouting: { workerId: reviewerRouting.selection.workerId, reason: reviewerRouting.reason, selectedBy: reviewerRouting.selection.selectedBy } }));
         const ready = schedule(await this.store.load(job.id));
         await this.store.saveJob(ready);
-        const reviewTask = ready.tasks.find(item => item.id === id && item.state === 'READY');
+        const reviewTask = ready.tasks.find(item => item.id === id && item.state === 'QUEUED');
         if (reviewTask && (this.options.maxConcurrent ?? 4) > this.live.size + this.plannerLive.size)
             await this.launch(ready, reviewTask);
     }
@@ -270,7 +270,7 @@ export class Reconciler {
     async routeExecutableTasks(job) {
         const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
         const candidates = workerCandidates(this.options.adapters, await this.store.listAgents(), usage);
-        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'READY', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
+        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
             const requirements = task.workerRequirements ?? { capabilities: task.capabilities.length > 0 ? task.capabilities : ['model'] };
             const routed = selectWorker(candidates, requirements);
             task.workerSelection = routed.selection;
@@ -365,7 +365,7 @@ export class Reconciler {
                 this.plannerLive.delete(task.id);
             }
             if (task.attempt < task.maxAttempts) {
-                transitionTask(task, 'READY');
+                transitionTask(task, 'QUEUED');
                 task.leaseOwner = null;
                 task.leaseExpiresAt = null;
                 await this.store.saveTask(task);
@@ -391,7 +391,7 @@ export class Reconciler {
         const slot = job.schedule?.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
         const scopedTasks = Number.isFinite(slot) ? job.tasks.filter(task => Date.parse(task.createdAt) >= slot) : job.tasks;
         const planners = scopedTasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-        if (planners.some(task => ['QUEUED', 'READY', 'RUNNING', 'WAITING'].includes(task.state)))
+        if (planners.some(task => ['QUEUED', 'RUNNING', 'WAITING'].includes(task.state)))
             return job;
         if (scopedTasks.some(task => task.state === 'FAILED' || task.state === 'BLOCKED'))
             return job;
@@ -598,7 +598,7 @@ export class Reconciler {
             task.error = error.message;
             task.leaseOwner = null;
             task.leaseExpiresAt = null;
-            transitionTask(task, task.attempt < task.maxAttempts ? 'READY' : 'FAILED');
+            transitionTask(task, task.attempt < task.maxAttempts ? 'QUEUED' : 'FAILED');
             await this.store.saveTask(task);
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, task.state === 'FAILED' ? 'planner.failed' : 'planner.retry', task.state === 'FAILED' ? 'failed' : 'queued', `Planner ${task.id}: ${error.message}`, 'user'));
             this.detach(this.reconcile(jobId), jobId, task.id, 'planner retry reconciliation');
@@ -636,7 +636,7 @@ export class Reconciler {
                 task.error = message;
                 task.leaseOwner = null;
                 task.leaseExpiresAt = null;
-                transitionTask(task, task.attempt < task.maxAttempts ? 'READY' : 'FAILED');
+                transitionTask(task, task.attempt < task.maxAttempts ? 'QUEUED' : 'FAILED');
                 await this.store.saveTask(task);
                 await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.failed', 'failed', `Planner ${task.id}: ${message}`, 'user'));
             }

package/dist/scheduler.js

@@ -33,11 +33,11 @@ export function schedule(job) {
     const map = new Map(job.tasks.map(t => [t.id, t]));
     for (const task of scopedTasks) {
         if (['QUEUED', 'WAITING'].includes(task.state) && dependencyReady(task, map))
-            transitionTask(task, 'READY');
+            transitionTask(task, 'QUEUED');
     }
-    const active = scopedTasks.some(t => ['READY', 'RUNNING'].includes(t.state));
+    const active = scopedTasks.some(t => ['QUEUED', 'RUNNING'].includes(t.state));
     const blocked = scopedTasks.some(t => t.state === 'BLOCKED');
-    const waiting = scopedTasks.some(t => ['QUEUED', 'WAITING'].includes(t.state));
+    const waiting = scopedTasks.some(t => t.state === 'WAITING');
     const failed = scopedTasks.some(t => t.state === 'FAILED');
     const cancelled = scopedTasks.every(t => t.state === 'CANCELLED');
     const next = active ? 'RUNNING' : failed ? 'FAILED' : blocked ? 'BLOCKED' : waiting ? 'WAITING' : cancelled ? 'CANCELLED' : completionGateSatisfied(job) ? 'COMPLETED' : 'WAITING';
@@ -65,7 +65,7 @@ export function extendRetryBudget(task, windowSize = 3) {
     const usedOrBudgeted = Math.max(task.maxAttempts, task.attempt);
     return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
 }
-export function transitionTask(task, state) { assertTaskTransition(task.state, state); task.state = state; if (['READY', 'RUNNING', 'SUCCEEDED'].includes(state))
+export function transitionTask(task, state) { assertTaskTransition(task.state, state); task.state = state; if (['QUEUED', 'RUNNING', 'SUCCEEDED'].includes(state))
     task.error = null; task.updatedAt = new Date().toISOString(); }
 export const SCHEDULE_RESOLUTION_MS = 600_000;
 export const RUN_BUCKET_LABEL_COUNT = 144;

package/dist/types.js

@@ -3,7 +3,7 @@ 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(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', 'COMPLETED', 'CANCELLED'], COMPLETED: ['RUNNING', 'CANCELLED'], FAILED: ['RUNNING', 'COMPLETED', 'CANCELLED'], CANCELLED: ['RUNNING', 'COMPLETED'] };
-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: [] };
+const taskTransitions = { QUEUED: ['RUNNING', 'BLOCKED', 'FAILED', 'CANCELLED'], RUNNING: ['WAITING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED', 'QUEUED'], WAITING: ['QUEUED', 'BLOCKED', 'CANCELLED'], BLOCKED: ['QUEUED', 'CANCELLED'], SUCCEEDED: [], FAILED: ['QUEUED', '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.53",
+  "version": "1.0.54",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {