agents-relay 1.0.58 → 1.0.59

package/dist/pool.js

@@ -25,7 +25,6 @@ export class RepositoryWorkerPool {
     running = false;
     pending = false;
     jobTargets = new Map();
-    jobQueues = new Map();
     constructor(client, repository, trustedAuthors, concurrency, makeReconciler) {
         this.client = client;
         this.trustedAuthors = trustedAuthors;
@@ -34,44 +33,27 @@ export class RepositoryWorkerPool {
         this.repositories = [...new Set(typeof repository === 'string' ? [repository] : repository)];
     }
     repositories;
-    async withJobQueue(jobId, work) {
-        const previous = this.jobQueues.get(jobId) ?? Promise.resolve();
-        const run = previous.catch(() => undefined).then(work);
-        const settled = run.then(() => undefined, () => undefined);
-        this.jobQueues.set(jobId, settled);
-        try {
-            return await run;
-        }
-        finally {
-            if (this.jobQueues.get(jobId) === settled)
-                this.jobQueues.delete(jobId);
-        }
-    }
     async reconcileDiscovered(discovered) {
         for (const item of discovered)
             this.jobTargets.set(item.job.id, { repository: item.job.repository, prNumber: item.job.prNumber });
         // Terminal PRs must be reconciled before OPEN-job scheduling. Otherwise the
         // OPEN-only runnable filter can strand durable jobs after GitHub merges/closes them.
         for (const job of terminalManagedJobs(discovered)) {
-            await this.withJobQueue(job.id, async () => {
-                const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
-                await this.makeReconciler(store, 0).reconcile(job.id);
-            });
+            const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
+            await this.makeReconciler(store, 0).reconcile(job.id);
         }
         const jobs = runnableManagedJobs(discovered);
         let capacity = Math.max(1, this.concurrency);
         for (const job of jobs) {
             if (capacity <= 0)
                 break;
+            const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
             const ready = job.tasks.filter(task => task.state === 'QUEUED' || (task.state === 'DRAFT' && task.dependencies.length > 0)).length;
             const expiredRunning = job.tasks.some(task => task.state === 'RUNNING' && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= Date.now());
             if (!needsLifecycleReconciliation(job))
                 continue;
             const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
-            await this.withJobQueue(job.id, async () => {
-                const store = new GitHubStore(this.client, job.repository, job.prNumber, this.trustedAuthors);
-                await this.makeReconciler(store, allowance).reconcile(job.id);
-            });
+            await this.makeReconciler(store, allowance).reconcile(job.id);
             capacity -= allowance;
         }
     }
@@ -96,10 +78,8 @@ export class RepositoryWorkerPool {
         if (!this.repositories.includes(repository))
             return;
         this.jobTargets.set(jobId, { repository, prNumber });
-        await this.withJobQueue(jobId, async () => {
-            const store = new GitHubStore(this.client, repository, prNumber, this.trustedAuthors);
-            await this.makeReconciler(store, Math.max(1, this.concurrency)).reconcile(jobId);
-        });
+        const store = new GitHubStore(this.client, repository, prNumber, this.trustedAuthors);
+        await this.makeReconciler(store, Math.max(1, this.concurrency)).reconcile(jobId);
     }
     async handleTerminalEvent(event) {
         const target = this.jobTargets.get(event.job_id);
@@ -107,10 +87,8 @@ export class RepositoryWorkerPool {
             process.stderr.write(`warning: terminal event target unknown for job ${event.job_id}\n`);
             return;
         }
-        await this.withJobQueue(event.job_id, async () => {
-            const store = new GitHubStore(this.client, target.repository, target.prNumber, this.trustedAuthors);
-            await this.makeReconciler(store, Math.max(1, this.concurrency)).handleEvent(event);
-        });
+        const store = new GitHubStore(this.client, target.repository, target.prNumber, this.trustedAuthors);
+        await this.makeReconciler(store, Math.max(1, this.concurrency)).handleEvent(event);
     }
     async watch(bus) {
         return bus.subscribeAll(async (event) => {

package/dist/reconciler.js

@@ -61,6 +61,7 @@ The ChatGPT/Codex conversation or process exit is never the task result.
 Before your final return, verify that a terminal event for this exact Job/Task was published.
 If no terminal event has been published, publish task.failed before exiting.`;
 }
+const taskLaunchClaims = new Set();
 export class Reconciler {
     store;
     options;
@@ -468,15 +469,34 @@ export class Reconciler {
             await this.store.saveTask(task);
             return;
         }
-        const leaseMs = Math.max(this.options.leaseMs ?? 300000, task.timeoutMs);
-        const startedAt = (this.options.now ?? new Date()).getTime();
-        transitionTask(task, 'RUNNING');
-        task.attempt += 1;
-        task.leaseOwner = this.options.owner;
-        task.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
-        task.executionId = randomUUID();
+        const claimKey = `${job.repository}#${job.prNumber}:${task.id}`;
+        if (taskLaunchClaims.has(claimKey))
+            return;
+        taskLaunchClaims.add(claimKey);
+        let claimedTask = null;
+        try {
+            const freshJob = await this.store.load(job.id);
+            const freshTask = freshJob.tasks.find(item => item.id === task.id);
+            if (!freshTask || freshTask.state !== 'QUEUED' || !dependencyReady(freshTask, new Map(freshJob.tasks.map(item => [item.id, item]))))
+                return;
+            const leaseMs = Math.max(this.options.leaseMs ?? 300000, freshTask.timeoutMs);
+            const startedAt = (this.options.now ?? new Date()).getTime();
+            transitionTask(freshTask, 'RUNNING');
+            freshTask.attempt += 1;
+            freshTask.leaseOwner = this.options.owner;
+            freshTask.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
+            freshTask.executionId = randomUUID();
+            await this.store.saveTask(freshTask);
+            claimedTask = freshTask;
+        }
+        finally {
+            taskLaunchClaims.delete(claimKey);
+        }
+        if (!claimedTask)
+            return;
+        task = claimedTask;
+        const startedAt = Date.now();
         const durableExecutionId = task.executionId;
-        await this.store.saveTask(task);
         const controller = new AbortController();
         let execution;
         const workerTask = { ...task, input: workerInput, routing: task.routing ? { ...task.routing, cwd: task.routing.cwd ?? executionContext.project.path } : task.routing };

package/package.json

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