agents-relay 1.0.142 → 1.0.144

package/dist/blockers.js

@@ -62,9 +62,10 @@ export async function resolveBlockerDependencies(options) {
         return { resumed: 0, obsolete: 0, waiting };
     }
     const now = options.now ?? new Date().toISOString();
+    const relations = blocker.unblocks ?? [];
     let resumed = 0;
     let obsolete = 0;
-    for (const relation of blocker.unblocks ?? []) {
+    for (const relation of relations) {
         if (relation.state !== 'waiting')
             continue;
         const store = options.dependentStore(relation.repository, relation.prNumber);
@@ -110,8 +111,16 @@ export async function resolveBlockerDependencies(options) {
         relation.note = 'dependent task requeued';
         resumed += 1;
     }
+    const remaining = relations.filter(relation => relation.state === 'waiting');
+    const consumed = remaining.length !== relations.length;
+    if (!consumed)
+        return { resumed, obsolete, waiting: remaining.length };
+    if (remaining.length > 0)
+        blocker.unblocks = remaining;
+    else
+        delete blocker.unblocks;
     blocker.blockerResolvedAt = now;
     blocker.updatedAt = now;
     await options.blockerStore.saveJob(blocker);
-    return { resumed, obsolete, waiting: (blocker.unblocks ?? []).filter(item => item.state === 'waiting').length };
+    return { resumed, obsolete, waiting: remaining.length };
 }

package/dist/dashboard.js

@@ -184,9 +184,12 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             res.writeHead(202);
             res.end('Accepted');
             queueMicrotask(() => {
-                void (webhook.refresh ? webhook.refresh(event) : Promise.resolve([]))
-                    .then(jobIds => broadcastSnapshots(jobIds))
-                    .catch(error => process.stderr.write(`warning: webhook dashboard snapshot unavailable: ${error instanceof Error ? error.message : String(error)}\n`))
+                const refreshDashboard = webhook.refresh
+                    ? webhook.refresh(event)
+                        .then(jobIds => broadcastSnapshots(jobIds))
+                        .catch(error => process.stderr.write(`warning: webhook dashboard snapshot unavailable: ${error instanceof Error ? error.message : String(error)}\n`))
+                    : Promise.resolve();
+                void refreshDashboard
                     .then(() => webhook.wake(event))
                     .catch(error => process.stderr.write(`warning: webhook wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`));
             });

package/dist/pool.js

@@ -1,5 +1,6 @@
 import { GitHubStore, listManagedGitHubJobs, withGitHubRequestContext } from './store.js';
 import { eventFor } from './events.js';
+import { ReconcileCoordinator } from './reconcile-coordinator.js';
 const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export function runnableManagedJobs(items) { return items.filter(item => item.githubState === 'OPEN' && item.job.state === 'ACTIVE').map(item => item.job).sort(compareJobPriority); }
@@ -23,19 +24,28 @@ export class RepositoryWorkerPool {
     concurrency;
     makeReconciler;
     isRateLimited;
+    refreshWebhookSnapshot;
     running = false;
     pending = false;
     reconcileLocks = new Map();
-    targetedReconcileFlights = new Map();
+    coordinator;
+    githubSignalCoordinator;
+    watchedBus;
     jobTargets = new Map();
     targetSeeds = new Map();
-    constructor(client, repository, trustedAuthors, concurrency, makeReconciler, isRateLimited = () => false) {
+    constructor(client, repository, trustedAuthors, concurrency, makeReconciler, isRateLimited = () => false, refreshWebhookSnapshot) {
         this.client = client;
         this.trustedAuthors = trustedAuthors;
         this.concurrency = concurrency;
         this.makeReconciler = makeReconciler;
         this.isRateLimited = isRateLimited;
+        this.refreshWebhookSnapshot = refreshWebhookSnapshot;
         this.repositories = [...new Set(typeof repository === 'string' ? [repository] : repository)];
+        const reportCoordinatorError = (error, signal) => {
+            process.stderr.write(`warning: reconcile coordinator failed for ${signal.jobId} (${signal.reason}): ${error instanceof Error ? error.message : String(error)}\n`);
+        };
+        this.coordinator = new ReconcileCoordinator((jobId, signals) => this.consumeSignals(jobId, signals), reportCoordinatorError);
+        this.githubSignalCoordinator = new ReconcileCoordinator((_key, signals) => this.consumeGitHubSignals(signals), reportCoordinatorError);
     }
     repositories;
     async reconcileExclusive(jobId, work) {
@@ -53,6 +63,91 @@ export class RepositoryWorkerPool {
             release();
         }
     }
+    signalReason(event) {
+        if (event.type === 'github.webhook') {
+            const webhookEvent = typeof event.data?.event === 'string' ? event.data.event : 'unknown';
+            const action = typeof event.data?.action === 'string' && event.data.action ? `:${event.data.action}` : '';
+            return `github.webhook:${webhookEvent}${action}`;
+        }
+        return `event.${event.type}`;
+    }
+    async consumeGitHubSignals(signals) {
+        if (this.isRateLimited() || signals.length === 0)
+            return;
+        const repository = signals.find(signal => signal.repository)?.repository;
+        const prNumber = signals.find(signal => signal.prNumber)?.prNumber;
+        if (!repository || !prNumber || !this.repositories.includes(repository))
+            return;
+        if (!this.refreshWebhookSnapshot) {
+            process.stderr.write(`warning: GitHub webhook signal refresh unavailable for ${repository}#${prNumber}\n`);
+            return;
+        }
+        const reasons = [...new Set(signals.map(signal => signal.reason))];
+        const trigger = reasons.join('+') || 'github.webhook';
+        const snapshot = await this.refreshWebhookSnapshot(repository, prNumber, trigger);
+        const sourceEvents = signals.map(signal => signal.event).filter((event) => Boolean(event));
+        for (const item of snapshot.overviews) {
+            this.jobTargets.set(item.job.id, { repository, prNumber });
+            this.seedTargetSnapshot(repository, prNumber, item.job.id, snapshot.seed);
+            if (this.watchedBus) {
+                for (const event of sourceEvents) {
+                    const publication = event.data?.publication;
+                    if (publication && typeof publication === 'object') {
+                        const value = publication;
+                        await this.watchedBus.publish(eventFor(item.job.id, 'release', null, 'package.published', 'succeeded', `Published ${String(value.package ?? 'package')}@${String(value.version ?? 'unknown')}`, 'orchestrator', {
+                            deliveryId: event.data?.deliveryId,
+                            repository,
+                            prNumber,
+                            package: value.package,
+                            version: value.version,
+                            registry: value.registry,
+                            sha: value.sha,
+                        }, event.source));
+                    }
+                    await this.watchedBus.publish(eventFor(item.job.id, 'github', null, 'github.webhook', 'queued', event.message, 'orchestrator', { ...(event.data ?? {}), coordinatorIngress: false, coordinatorRouted: true }, event.source));
+                }
+            }
+            await this.coordinator.accept({ jobId: item.job.id, reason: trigger, repository, prNumber });
+        }
+    }
+    async consumeSignals(jobId, signals) {
+        if (this.isRateLimited())
+            return;
+        for (const signal of signals) {
+            if (signal.repository && signal.prNumber && this.repositories.includes(signal.repository)) {
+                this.jobTargets.set(jobId, { repository: signal.repository, prNumber: signal.prNumber });
+            }
+        }
+        const target = this.jobTargets.get(jobId);
+        if (!target || !this.repositories.includes(target.repository)) {
+            process.stderr.write(`warning: reconcile signal target unknown for job ${jobId}\n`);
+            return;
+        }
+        const seedKey = `${target.repository}#${target.prNumber}:${jobId}`;
+        const mayConsumeSeed = signals.some(signal => signal.reason === 'target.request' || signal.reason.startsWith('github.webhook:'));
+        const seed = mayConsumeSeed ? this.targetSeeds.get(seedKey) ?? null : null;
+        if (mayConsumeSeed)
+            this.targetSeeds.delete(seedKey);
+        const store = new GitHubStore(this.client, target.repository, target.prNumber, this.trustedAuthors, seed);
+        const reconciler = this.makeReconciler(store, Math.max(1, this.concurrency));
+        let shouldReconcile = false;
+        const reasons = [];
+        for (const signal of signals) {
+            reasons.push(signal.reason);
+            if (!signal.event) {
+                shouldReconcile = true;
+                continue;
+            }
+            const result = await withGitHubRequestContext(this.client, `pool.coordinator-apply:${signal.reason}`, () => reconciler.applyEvent(signal.event));
+            shouldReconcile ||= result.reconcile;
+        }
+        if (!shouldReconcile)
+            return;
+        const reason = [...new Set(reasons)].join('+') || 'unknown';
+        await this.reconcileExclusive(jobId, async () => {
+            await withGitHubRequestContext(this.client, `pool.coordinator-reconcile:${reason}`, () => reconciler.reconcile(jobId));
+        });
+    }
     async reconcileDiscovered(discovered) {
         for (const item of discovered)
             this.jobTargets.set(item.job.id, { repository: item.job.repository, prNumber: item.job.prNumber });
@@ -105,60 +200,75 @@ export class RepositoryWorkerPool {
             return;
         this.targetSeeds.set(`${repository}#${prNumber}:${jobId}`, seed);
     }
-    async reconcileTarget(repository, prNumber, jobId) {
+    async reconcileTarget(repository, prNumber, jobId, reason = 'target.request') {
         if (this.isRateLimited() || !this.repositories.includes(repository))
             return;
         this.jobTargets.set(jobId, { repository, prNumber });
-        const key = `${repository}#${prNumber}:${jobId}`;
-        const existing = this.targetedReconcileFlights.get(key);
-        if (existing)
-            return existing;
-        const flight = this.reconcileExclusive(jobId, async () => {
-            const seedKey = `${repository}#${prNumber}:${jobId}`;
-            const seed = this.targetSeeds.get(seedKey) ?? null;
-            this.targetSeeds.delete(seedKey);
-            const store = new GitHubStore(this.client, repository, prNumber, this.trustedAuthors, seed);
-            await withGitHubRequestContext(this.client, seed ? 'pool.targeted-reconcile.seeded' : 'pool.targeted-reconcile', () => this.makeReconciler(store, Math.max(1, this.concurrency)).reconcile(jobId));
+        await this.coordinator.accept({ jobId, reason, repository, prNumber });
+    }
+    async watch(bus) {
+        this.watchedBus = bus;
+        const unsubscribe = await bus.subscribeAll(async (event) => {
+            const repository = typeof event.data?.repository === 'string' ? event.data.repository : undefined;
+            const prValue = Number(event.data?.prNumber);
+            const prNumber = Number.isInteger(prValue) && prValue > 0 ? prValue : undefined;
+            const routedWebhook = event.type === 'github.webhook' && event.data?.coordinatorRouted === true;
+            const ingressWebhook = event.type === 'github.webhook' && event.data?.coordinatorIngress === true && !routedWebhook;
+            if (ingressWebhook && repository && prNumber) {
+                await this.githubSignalCoordinator.acceptTransport({
+                    jobId: `${repository}#${prNumber}`,
+                    reason: this.signalReason(event),
+                    event,
+                    repository,
+                    prNumber,
+                });
+                return;
+            }
+            if (routedWebhook)
+                return;
+            const lifecycle = ['task.started', 'task.completed', 'task.failed', 'task.blocked', 'task.cancelled', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type);
+            const wake = event.type === 'job.wake' || event.type === 'github.webhook';
+            if (!lifecycle && !wake)
+                return;
+            if (repository && prNumber)
+                this.jobTargets.set(event.job_id, { repository, prNumber });
+            await this.coordinator.acceptTransport({
+                jobId: event.job_id,
+                reason: this.signalReason(event),
+                event: lifecycle ? event : undefined,
+                repository,
+                prNumber,
+            });
         });
-        this.targetedReconcileFlights.set(key, flight);
-        try {
-            await flight;
-        }
-        finally {
-            if (this.targetedReconcileFlights.get(key) === flight)
-                this.targetedReconcileFlights.delete(key);
-        }
+        return async () => {
+            await unsubscribe();
+            if (this.watchedBus === bus)
+                this.watchedBus = undefined;
+        };
     }
-    async handleLifecycleEvent(event) {
-        if (this.isRateLimited())
+    async webhookSignal(bus, wake) {
+        if (!wake.repository || !wake.pullRequest)
             return;
-        const target = this.jobTargets.get(event.job_id);
-        if (!target || !this.repositories.includes(target.repository)) {
-            process.stderr.write(`warning: terminal event target unknown for job ${event.job_id}\n`);
+        const source = { id: `github/${wake.repository}/delivery/${wake.deliveryId}`, component: 'github-webhook' };
+        const event = eventFor('github-webhook', 'github', null, 'github.webhook', 'queued', `GitHub webhook ${wake.event}${wake.action ? ':' + wake.action : ''}`, 'orchestrator', {
+            deliveryId: wake.deliveryId,
+            event: wake.event,
+            action: wake.action,
+            repository: wake.repository,
+            prNumber: wake.pullRequest,
+            publication: wake.publication ?? null,
+            coordinatorIngress: true,
+        }, source);
+        if (bus) {
+            await bus.publish(event);
             return;
         }
-        const store = new GitHubStore(this.client, target.repository, target.prNumber, this.trustedAuthors);
-        const reconciler = this.makeReconciler(store, Math.max(1, this.concurrency));
-        await withGitHubRequestContext(this.client, `pool.event.${event.type}`, () => reconciler.handleEvent(event));
-        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type))
-            await withGitHubRequestContext(this.client, `pool.event-reconcile.${event.type}`, () => reconciler.reconcile(event.job_id));
-    }
-    async watch(bus) {
-        return bus.subscribeAll(async (event) => {
-            if (['task.started', 'task.completed', 'task.failed', 'task.blocked', 'task.cancelled', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type)) {
-                await this.handleLifecycleEvent(event);
-                return;
-            }
-            if (event.type === 'job.wake' || event.type === 'github.webhook') {
-                const repository = typeof event.data?.repository === 'string' ? event.data.repository : '';
-                const prNumber = Number(event.data?.prNumber);
-                if (repository && Number.isInteger(prNumber) && prNumber > 0) {
-                    await this.reconcileTarget(repository, prNumber, event.job_id);
-                    return;
-                }
-            }
-            if (event.type === 'job.wake' || event.type === 'github.webhook')
-                await this.reconcile();
+        await this.githubSignalCoordinator.accept({
+            jobId: `${wake.repository}#${wake.pullRequest}`,
+            reason: this.signalReason(event),
+            event,
+            repository: wake.repository,
+            prNumber: wake.pullRequest,
         });
     }
     async webhookWake(bus, job, wake) {
@@ -178,6 +288,6 @@ export class RepositoryWorkerPool {
             await bus.publish(eventFor(job.id, 'github', null, 'github.webhook', 'queued', `GitHub webhook ${wake.event}${wake.action ? ':' + wake.action : ''}`, 'orchestrator', { deliveryId: wake.deliveryId, event: wake.event, action: wake.action, repository: job.repository, prNumber: job.prNumber }, source));
             return;
         }
-        await this.reconcileTarget(job.repository, job.prNumber, job.id);
+        await this.reconcileTarget(job.repository, job.prNumber, job.id, `github.webhook:${wake.event}${wake.action ? ':' + wake.action : ''}`);
     }
 }

package/dist/reconcile-coordinator.js

@@ -0,0 +1,90 @@
+export class ReconcileCoordinator {
+    consumeBatch;
+    reportError;
+    mailboxes = new Map();
+    idleWaiters = [];
+    constructor(consumeBatch, reportError) {
+        this.consumeBatch = consumeBatch;
+        this.reportError = reportError;
+    }
+    accept(signal) {
+        return this.enqueue(signal, true);
+    }
+    acceptTransport(signal) {
+        return this.enqueue(signal, false);
+    }
+    acceptObserved(signal) {
+        const running = this.mailboxes.get(signal.jobId)?.running === true;
+        return this.enqueue(signal, !running);
+    }
+    isIdle() {
+        return [...this.mailboxes.values()].every(mailbox => !mailbox.running && !mailbox.scheduled && mailbox.pending.length === 0);
+    }
+    settle() {
+        if (this.isIdle())
+            return Promise.resolve();
+        return new Promise(resolve => this.idleWaiters.push(resolve));
+    }
+    notifyIdle() {
+        if (!this.isIdle())
+            return;
+        for (const resolve of this.idleWaiters.splice(0))
+            resolve();
+    }
+    enqueue(signal, waitForProcessing) {
+        const mailbox = this.mailboxes.get(signal.jobId) ?? { pending: [], running: false, scheduled: false };
+        this.mailboxes.set(signal.jobId, mailbox);
+        let accepted;
+        if (waitForProcessing) {
+            accepted = new Promise((resolve, reject) => {
+                mailbox.pending.push({ signal, resolve, reject });
+            });
+        }
+        else {
+            mailbox.pending.push({
+                signal,
+                resolve: () => { },
+                reject: error => this.reportError?.(error, signal),
+            });
+            accepted = Promise.resolve();
+        }
+        if (!mailbox.running && !mailbox.scheduled) {
+            mailbox.scheduled = true;
+            queueMicrotask(() => { void this.drain(signal.jobId); });
+        }
+        return accepted;
+    }
+    async drain(jobId) {
+        const mailbox = this.mailboxes.get(jobId);
+        if (!mailbox || mailbox.running)
+            return;
+        mailbox.running = true;
+        mailbox.scheduled = false;
+        try {
+            while (mailbox.pending.length > 0) {
+                const batch = mailbox.pending.splice(0);
+                try {
+                    await this.consumeBatch(jobId, batch.map(item => item.signal));
+                    for (const item of batch)
+                        item.resolve();
+                }
+                catch (error) {
+                    for (const item of batch)
+                        item.reject(error);
+                }
+                await Promise.resolve();
+            }
+        }
+        finally {
+            mailbox.running = false;
+            if (mailbox.pending.length > 0 && !mailbox.scheduled) {
+                mailbox.scheduled = true;
+                queueMicrotask(() => { void this.drain(jobId); });
+            }
+            else if (mailbox.pending.length === 0) {
+                this.mailboxes.delete(jobId);
+            }
+            this.notifyIdle();
+        }
+    }
+}

package/dist/reconciler-review.js

@@ -149,14 +149,14 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const reviewData = event.data?.review && typeof event.data.review === 'object' ? event.data.review : undefined;
         const headSha = typeof reviewData?.headSha === 'string' ? reviewData.headSha : typeof event.data?.headSha === 'string' ? event.data.headSha : task?.reviewHeadSha;
         if (!task || !headSha || task.reviewHeadSha !== headSha)
-            return;
+            return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
         const outcome = event.type === 'review.started' ? 'started' : event.type === 'review.approved' ? 'approved' : event.type === 'review.changes_required' ? 'changes_required' : 'blocked';
         const currentHeadSha = await this.store.headSha?.();
         if ((currentHeadSha && currentHeadSha !== headSha) || (job.headSha && job.headSha !== headSha))
-            return;
+            return { applied: false, reconcile: false, reason: `${event.type}.stale` };
         const taskDecision = tryTransitionTaskEvent(task, event.type);
         if (!taskDecision.accepted || !taskDecision.target)
-            return;
+            return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
         task.error = null;
         if (taskDecision.target !== 'RUNNING') {
             task.leaseOwner = null;
@@ -199,8 +199,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         }
         job.updatedAt = job.review.updatedAt;
         await this.store.saveJob(job);
-        if (outcome === 'changes_required')
-            this.detach(this.reconcile(job.id), job.id, task.id, 'review-fix reconciliation');
         if (outcome === 'approved' && job.autoMerge !== false && this.store.mergePullRequest) {
             const decision = await transitionJobEvent(job, 'review.approved', { autoMerge: true });
             await this.store.saveJob(job);
@@ -210,5 +208,6 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'review.merged', 'succeeded', 'Reviewer-approved PR #' + job.prNumber + ' merge requested', 'user', { headSha, autoMerge: true }, { agent: 'reviewer', component: 'agents-relay' }));
             }
         }
+        return { applied: true, reconcile: outcome === 'changes_required', reason: `review.${outcome}`, reconcileMode: outcome === 'changes_required' ? 'detached' : undefined };
     }
 }

package/dist/reconciler-runtime.js

@@ -4,6 +4,7 @@ import { StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { WorkflowEffectExecutor } from './workflow/effects.js';
 import { workflowEffectFailureEvent } from './workflow/contracts.js';
+import { ReconcileCoordinator } from './reconcile-coordinator.js';
 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; }
 const terminalExecutionClaims = new Set();
@@ -26,12 +27,43 @@ export class ReconcilerRuntimeBase {
     launchFailureClaims = new Set();
     terminalWaiters = new Map();
     taskTransitions;
+    eventCoordinator;
+    detachedReconciles = new Set();
     workflowEffects = new WorkflowEffectExecutor();
     reconciling = false;
     constructor(store, options) {
         this.store = store;
         this.options = options;
         this.taskTransitions = new DurableTaskTransitionRuntime(store);
+        this.eventCoordinator = new ReconcileCoordinator(async (jobId, signals) => {
+            let shouldReconcile = false;
+            let detached = false;
+            let taskId = 'job';
+            const reasons = [];
+            for (const signal of signals) {
+                reasons.push(signal.reason);
+                if (!signal.event) {
+                    shouldReconcile = true;
+                    continue;
+                }
+                taskId = signal.event.task_id || taskId;
+                const result = await this.applyEvent(signal.event);
+                shouldReconcile ||= result.reconcile;
+                detached ||= result.reconcile && result.reconcileMode === 'detached';
+            }
+            if (!shouldReconcile)
+                return;
+            const reconciliation = this.reconcile(jobId);
+            if (detached) {
+                let tracked;
+                tracked = reconciliation.finally(() => this.detachedReconciles.delete(tracked));
+                this.detachedReconciles.add(tracked);
+                this.detach(tracked, jobId, taskId, `coordinator reconciliation: ${[...new Set(reasons)].join('+')}`);
+            }
+            else {
+                await reconciliation;
+            }
+        });
     }
     async applyJobEffectOutcomes(job, outcomes) {
         for (const outcome of outcomes.filter(item => item.status === 'failed')) {
@@ -60,42 +92,41 @@ export class ReconcilerRuntimeBase {
             await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'workflow.effect.failed', 'failed', `${outcome.effect} failed: ${outcome.error ?? 'unknown error'}`, 'orchestrator', { effect: outcome.effect, idempotencyKey: outcome.key, workflowEvent: eventName }, { agent: 'relay', component: 'agents-relay' }));
         }
     }
-    async handleEvent(event) {
+    async applyEvent(event) {
         const sourceId = eventSourceId(event);
         const activeOwner = sourceId ? activeExecutionOwners.get(sourceId) : undefined;
-        if (activeOwner && activeOwner !== this) {
-            await activeOwner.handleEvent(event);
-            return;
-        }
-        if (event.type === 'task.started') {
-            await this.markWorkerStarted(event);
-            return;
-        }
-        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
-            await this.applyTerminalEvent(event);
-            return;
-        }
-        if (['review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type)) {
-            await this.applyReviewEvent(event);
-            return;
-        }
+        if (activeOwner && activeOwner !== this)
+            return activeOwner.applyEvent(event);
+        if (event.type === 'task.started')
+            return this.markWorkerStarted(event);
+        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type))
+            return this.applyTerminalEvent(event);
+        if (['review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type))
+            return this.applyReviewEvent(event);
         if (event.type === 'job.wake' || event.type === 'github.webhook')
-            await this.reconcile(event.job_id);
+            return { applied: true, reconcile: true, reason: event.type };
+        return { applied: false, reconcile: false, reason: event.type };
+    }
+    async handleEvent(event) {
+        await this.eventCoordinator.accept({ jobId: event.job_id, reason: `event.${event.type}`, event });
     }
     async watch(jobId) {
         if (!this.options.eventBus)
             return async () => { };
         try {
-            return await this.options.eventBus.subscribe(jobId, event => this.handleEvent(event));
+            return await this.options.eventBus.subscribe(jobId, event => this.eventCoordinator.acceptObserved({ jobId: event.job_id, reason: `event.${event.type}`, event }));
         }
         catch (error) {
             await this.reportTransportFailure(error);
             return async () => { };
         }
     }
-    async idle() { while ([...this.live.values()].some(item => !item.processSettled) || this.plannerLive.size > 0 || this.continuationLive.size > 0 || this.reconciling)
+    async idle() { while ([...this.live.values()].some(item => !item.processSettled) || this.plannerLive.size > 0 || this.continuationLive.size > 0 || this.reconciling || !this.eventCoordinator.isIdle())
         await new Promise(resolve => setTimeout(resolve, 25)); }
     async close() {
+        await this.eventCoordinator.settle();
+        if (this.detachedReconciles.size > 0)
+            await Promise.allSettled([...this.detachedReconciles]);
         for (const live of this.live.values()) {
             const sourceId = executionEventSource(live.jobId, live.taskId, live.executionId);
             if (activeExecutionOwners.get(sourceId) === this)
@@ -180,7 +211,7 @@ export class ReconcilerRuntimeBase {
     async markWorkerStarted(event) {
         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;
+            return { applied: false, reconcile: false, reason: 'task.started.stale' };
         const transition = await this.taskTransitions.apply(event.job_id, event.task_id, 'task.started', {
             eligible: (job, task) => {
                 if (!task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
@@ -198,11 +229,10 @@ export class ReconcilerRuntimeBase {
             },
         });
         if (!transition?.decision.accepted)
-            return;
+            return { applied: false, reconcile: false, reason: 'task.started.ignored' };
         if (live?.executionId === transition.task.executionId)
             live.workerStarted = true;
-        if (transition.from === 'FAILED')
-            this.detach(this.reconcile(event.job_id), event.job_id, event.task_id, 'late worker-start reconciliation');
+        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 ?? ''))
@@ -326,10 +356,11 @@ export class ReconcilerRuntimeBase {
             },
         });
         if (!transition?.decision.accepted)
-            return;
+            return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
         if (event.type === 'task.completed')
             await this.deliverContinuation(transition.job, transition.task);
-        this.detach(this.reconcile(transition.job.id), transition.job.id, transition.task.id, 'terminal-event reconciliation');
+        const reviewWorker = transition.task.agentName === 'reviewer';
+        return { applied: true, reconcile: !reviewWorker, reason: reviewWorker ? `${event.type}.review-worker` : event.type, reconcileMode: reviewWorker ? undefined : 'detached' };
     }
     terminalWait(taskId, executionId, launchBarrier) {
         let resolve;

package/dist/relayd.js

@@ -106,7 +106,6 @@ export async function runDaemon(argv) {
     const makeReconciler = (store, maxConcurrent) => new Reconciler(store, { owner: `relayd-${process.pid}`, maxConcurrent, leaseMs: Number(value(argv, '--lease-ms', '300000')), adapters: [new CodexAdapter(value(argv, '--codex', 'codex')), new ChatGptAdapter()], continuations: [new CodexThreadContinuation(value(argv, '--codex', 'codex')), new CommandContinuation(), new WebhookContinuation()], planner: runtimePlanner(argv), usageSnapshotProvider: () => usageRegistry.snapshot(), runtimeSummaryProvider: () => ({ chatgptRunning: summarizeRuntime(cachedOverviews.map(item => item.job)).workers.chatgpt }), decisionEngine: new LayaCliDecisionEngine(), decisionMode: decisionMode(), decisionAuditStore, eventBus: bus, reviewer: runtimeReviewer(), projectPathForJob: async (job) => resolveRepositoryProjectPath(repositoryPaths.get(job.repository) ?? await resolveManagedProjectPath(job.repository, explicitProjectPath, workspaceRoot), job.projectPath) });
     if (repositories.length === 0)
         throw new Error(`No Git repositories with GitHub origins found under ${normalized.workspaceRoot ?? defaultWorkspaceRoot()}`);
-    const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler, () => client.rateLimitStatus().limited);
     const cacheDirectory = join(homedir(), '.agents-relay');
     const cacheFile = join(cacheDirectory, 'dashboard-jobs.json');
     try {
@@ -186,6 +185,7 @@ export async function runDaemon(argv) {
         }
     };
     const refreshPullRequest = async (repository, prNumber, trigger, options) => (await refreshPullRequestSnapshot(repository, prNumber, trigger, options)).overviews;
+    const pool = new RepositoryWorkerPool(client, repositories, trusted, concurrency, makeReconciler, () => client.rateLimitStatus().limited, (repository, prNumber, trigger) => refreshPullRequestSnapshot(repository, prNumber, trigger));
     const initial = cachedOverviews;
     const fallback = initial[0]?.job;
     const dashboardStore = fallback ? new GitHubStore(client, fallback.repository, fallback.prNumber, trusted) : new InMemoryStore();
@@ -221,21 +221,11 @@ export async function runDaemon(argv) {
     const webhook = secret ? {
         secret,
         repositories: new Set(repositories),
-        refresh: async (event) => {
-            if (!event.repository || !event.pullRequest)
-                return [];
-            const snapshot = await refreshPullRequestSnapshot(event.repository, event.pullRequest, `github.webhook:${event.event}${event.action ? ':' + event.action : ''}`);
-            for (const item of snapshot.overviews)
-                pool.seedTargetSnapshot(event.repository, event.pullRequest, item.job.id, snapshot.seed);
-            return snapshot.overviews.map(item => item.job.id);
-        },
         wake: async (event) => {
             if (!event.repository || !event.pullRequest)
                 return;
             try {
-                const refreshed = cachedOverviews.filter(item => item.job.repository === event.repository && item.job.prNumber === event.pullRequest);
-                for (const item of refreshed)
-                    await pool.webhookWake(bus, item.job, event);
+                await pool.webhookSignal(bus, event);
             }
             catch (error) {
                 process.stderr.write(`warning: webhook wake unavailable: ${error instanceof Error ? error.message : String(error)}\n`);
@@ -260,6 +250,7 @@ export async function runDaemon(argv) {
             return cachedJob();
         }
     };
+    const stopWatch = bus ? await pool.watch(bus) : async () => { };
     const server = serveDashboard(dashboardStore, Number(value(argv, '--port', String(SERVICE_DEFAULTS.port))), bus, Number(value(argv, '--refresh-ms', String(SERVICE_DEFAULTS.dashboardRefreshMs))), fallback?.id, usageRegistry, overviews, webhook, () => ({ ...client.rateLimitStatus(), readPaths: { ...githubReadPaths } }), () => client.rateLimitSnapshot(), exactJob, {
         start: workspaceJobAction('start'),
         reconcile: workspaceJobAction('reconcile'),
@@ -282,7 +273,6 @@ export async function runDaemon(argv) {
     const watchdogDefault = webhook ? SERVICE_DEFAULTS.webhookWatchdogMs : SERVICE_DEFAULTS.watchdogMs;
     const interval = setInterval(() => void reconcileSafely(), Number(value(argv, '--interval', String(watchdogDefault))));
     interval.unref();
-    const stopWatch = bus ? await pool.watch(bus) : async () => { };
     const stop = () => { clearInterval(interval); void stopWatch().finally(() => server.close(() => process.exit(0))); };
     process.once('SIGINT', stop);
     process.once('SIGTERM', stop);

package/dist/store-github.js

@@ -275,10 +275,13 @@ export class GitHubStore {
         const conflicts = jobComments.filter(comment => parseJob(comment.body)?.id !== job.id);
         if (conflicts.length > 0)
             throw new Error(`PR #${this.prNumber} already has a different ${JOB_MARKER} marker`);
-        await this.updatePullRequestBody(renderJobBody(job));
-        const persisted = parseJob(await this.pullRequestBody());
-        if (!persisted || persisted.id !== job.id)
-            throw new Error(`Failed to persist ${JOB_MARKER} marker in PR #${this.prNumber} body for job ${job.id}`);
+        const nextBody = renderJobBody(job);
+        if (currentBody !== nextBody) {
+            await this.updatePullRequestBody(nextBody);
+            const persisted = parseJob(await this.pullRequestBody());
+            if (!persisted || persisted.id !== job.id)
+                throw new Error(`Failed to persist ${JOB_MARKER} marker in PR #${this.prNumber} body for job ${job.id}`);
+        }
         for (const legacy of jobComments.filter(comment => parseJob(comment.body)?.id === job.id))
             await this.deleteComment(legacy);
     }

package/package.json

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