agents-relay 2.0.66 → 2.0.68

package/dist/local-merge-lock.js

@@ -0,0 +1,103 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync, statSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+import { hostname } from 'node:os';
+const sleep = (ms) => {
+    // Synchronous delivery API; Atomics.wait only blocks this worker's thread.
+    const wait = new Int32Array(new SharedArrayBuffer(4));
+    Atomics.wait(wait, 0, 0, ms);
+};
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+/** Cross-process atomic directory lock in the shared Git common directory. */
+export function withLocalMergeLock(commonDir, targetRef, action, timeoutMs = 15000) {
+    const digest = createHash('sha256').update(targetRef).digest('hex').slice(0, 24);
+    const path = join(commonDir, 'agents-relay-merge-' + digest + '.lockdir');
+    const ownerPath = join(path, 'owner.json');
+    const recoveryGuard = path + '.recovery';
+    const guardOwnerPath = join(recoveryGuard, 'owner.json');
+    const incompleteGraceMs = 3000;
+    const deadline = Date.now() + timeoutMs;
+    const owner = { pid: process.pid, host: hostname(), startedAt: new Date().toISOString(), targetRef };
+    while (true) {
+        try {
+            mkdirSync(path);
+            writeFileSync(ownerPath, JSON.stringify(owner), { flag: 'wx', mode: 0o600 });
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            // Reap a crashed recovery owner, or a crash between mkdir and owner write.
+            // Renaming the orphan into a private quarantine keeps cleanup out of the
+            // active path. A grace period protects slow owner-file initialization.
+            const orphaned = (directory, metadata) => {
+                try {
+                    const age = Date.now() - statSync(directory).mtimeMs;
+                    if (age < incompleteGraceMs)
+                        return false;
+                    try {
+                        const previous = JSON.parse(readFileSync(metadata, 'utf8'));
+                        return previous.host === hostname() && Number.isInteger(previous.pid)
+                            && !processAlive(previous.pid);
+                    }
+                    catch {
+                        return true;
+                    }
+                }
+                catch {
+                    return false;
+                }
+            };
+            if (orphaned(recoveryGuard, guardOwnerPath)) {
+                const quarantine = recoveryGuard + '.orphan-' + process.pid + '-' + createHash('sha256').update(owner.startedAt).digest('hex').slice(0, 10);
+                try {
+                    renameSync(recoveryGuard, quarantine);
+                    rmSync(quarantine, { recursive: true, force: true });
+                }
+                catch { /* another recovery contender may already have moved it */ }
+            }
+            let guarded = false;
+            try {
+                mkdirSync(recoveryGuard);
+                guarded = true;
+                writeFileSync(guardOwnerPath, JSON.stringify(owner), { flag: 'wx', mode: 0o600 });
+                if (orphaned(path, ownerPath))
+                    rmSync(path, { recursive: true, force: true });
+            }
+            catch { /* A live lock or incomplete initialization must be preserved. */ }
+            finally {
+                if (guarded) {
+                    try {
+                        const current = JSON.parse(readFileSync(guardOwnerPath, 'utf8'));
+                        if (current.pid === owner.pid && current.startedAt === owner.startedAt && current.host === owner.host)
+                            rmSync(recoveryGuard, { recursive: true, force: true });
+                    }
+                    catch { /* keep unknown guard */ }
+                }
+            }
+            if (Date.now() >= deadline)
+                throw new Error('Local merge target locked: ' + targetRef);
+            sleep(50);
+        }
+    }
+    try {
+        return action();
+    }
+    finally {
+        // Never release a lock now owned by a different process.
+        try {
+            const current = JSON.parse(readFileSync(ownerPath, 'utf8'));
+            if (current.pid === owner.pid && current.host === owner.host && current.startedAt === owner.startedAt)
+                rmSync(path, { recursive: true, force: true });
+        }
+        catch { /* preserve any unknown lock */ }
+    }
+}

package/dist/no-github.js

@@ -0,0 +1,11 @@
+import { GhApiClient } from './github-client.js';
+/** No GitHub transport can escape the disabled adapter. */
+export class DisabledGitHubClient extends GhApiClient {
+    async request() { throw new Error('GitHub disabled by --no-github'); }
+    async graphql() { throw new Error('GitHub disabled by --no-github'); }
+    async rateLimitSnapshot() { throw new Error('GitHub disabled by --no-github'); }
+    async currentLogin() { throw new Error('GitHub disabled by --no-github'); }
+}
+export function noGitHubMode(args = process.argv.slice(2)) {
+    return args.includes('--no-github') || process.argv.includes('--no-github') || process.env.AGENTS_RELAY_NO_GITHUB === '1';
+}

package/dist/planned-review-head.js

@@ -1,14 +1,13 @@
 /** A planner-created dependent review must freeze its head only after implementation completes. */
-export async function bindPlannedReviewHead(store, task) {
-    const current = await store.pullRequestHead?.();
-    if (!current?.sha)
-        throw new Error(`Review ${task.id} requires current PR head SHA`);
-    task.reviewHeadSha = current.sha;
+export async function bindPlannedReviewHead(store, task, localHeadSha) {
+    if (!localHeadSha)
+        throw new Error(`Review ${task.id} requires current local Git head SHA`);
+    task.reviewHeadSha = localHeadSha;
     const rule = [
-        'Review the current immutable PR head as a PRE-MERGE approval gate.',
-        'Distinguish code added by this implementation from pre-existing PR baseline/seed files present before the Task started.',
+        'Review the current immutable local source head as a PRE-MERGE approval gate.',
+        'Distinguish code added by this implementation from pre-existing local baseline/seed files present before the Task started.',
         'Preserved baseline files are not automatically extra changes merely because they differ from main; still review them for real risks.',
-        'Do not require PR MERGED, Job COMPLETED, or post-merge E2E evidence before review approval:',
+        'Do not require a remote PR MERGED, Job COMPLETED, or post-merge E2E evidence before review approval:',
         'those events must follow approval and are verified by the independent E2E runner.',
     ].join(' ');
     if (!task.input.includes(rule))

package/dist/pool.js

@@ -1,12 +1,12 @@
-import { GitHubStore, listManagedGitHubJobs, withGitHubRequestContext } from './store.js';
+import { listManagedGitHubJobs } from './store.js';
 import { eventFor } from './events.js';
-import { runScheduledBucket } from './scheduled-jobs.js';
+import { runScheduledBucketFromStore } from './scheduled-jobs.js';
 import { scheduleBucket } from './scheduler.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { errorMessage, observability, withObservabilityCorrelation } from './observability.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); }
+export function runnableManagedJobs(items) { return items.filter(item => item.job.state === 'ACTIVE').map(item => item.job).sort(compareJobPriority); }
 export function needsLifecycleReconciliation(job, now = Date.now()) {
     // DRAFT create-only Jobs stay dormant until a caller explicitly creates work.
     if (job.tasks.length === 0)
@@ -15,38 +15,28 @@ export function needsLifecycleReconciliation(job, now = Date.now()) {
         return true;
     return job.tasks.some(task => ['RUNNING', 'QUEUED'].includes(task.state) && task.executionId !== null && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= now);
 }
-export function terminalManagedJobs(items) { return items.filter(item => item.githubState !== 'OPEN' && ((item.githubState === 'MERGED' && item.job.state !== 'COMPLETED') || (item.githubState === 'CLOSED' && item.job.state !== 'CANCELLED'))).map(item => item.job).sort(compareJobPriority); }
+export function terminalManagedJobs(_items) { return []; }
 export async function aggregateManagedGitHubJobs(client, repositories, trustedAuthors) {
     const uniqueRepositories = [...new Set(repositories)];
     const groups = await Promise.all(uniqueRepositories.map(repository => listManagedGitHubJobs(client, repository, trustedAuthors)));
     return groups.flat().sort((a, b) => b.job.updatedAt.localeCompare(a.job.updatedAt) || b.job.prNumber - a.job.prNumber);
 }
 export class RepositoryWorkerPool {
-    client;
-    trustedAuthors;
     concurrency;
     makeReconciler;
-    isRateLimited;
-    refreshWebhookSnapshot;
-    makeStore;
+    localInventory;
+    resolveLocalJob;
     running = false;
     pending = false;
     reconcileLocks = new Map();
     coordinator;
-    githubSignalCoordinator;
     scheduleSignalCoordinator;
     watchedBus;
-    jobTargets = new Map();
-    targetSeeds = new Map();
-    constructor(client, repository, trustedAuthors, concurrency, makeReconciler, isRateLimited = () => false, refreshWebhookSnapshot, makeStore = (repository, prNumber, seed) => new GitHubStore(this.client, repository, prNumber, this.trustedAuthors, seed)) {
-        this.client = client;
-        this.trustedAuthors = trustedAuthors;
+    constructor(concurrency, makeReconciler, localInventory, resolveLocalJob) {
         this.concurrency = concurrency;
         this.makeReconciler = makeReconciler;
-        this.isRateLimited = isRateLimited;
-        this.refreshWebhookSnapshot = refreshWebhookSnapshot;
-        this.makeStore = makeStore;
-        this.repositories = [...new Set(typeof repository === 'string' ? [repository] : repository)];
+        this.localInventory = localInventory;
+        this.resolveLocalJob = resolveLocalJob;
         const reportCoordinatorError = (error, signal) => {
             observability().record({
                 stage: 'reconcile', event: 'reconcile.coordinator_failed', level: 'error', outcome: 'failed',
@@ -56,10 +46,17 @@ export class RepositoryWorkerPool {
             });
         };
         this.coordinator = new ReconcileCoordinator((jobId, signals) => this.consumeSignals(jobId, signals), reportCoordinatorError);
-        this.githubSignalCoordinator = new ReconcileCoordinator((_key, signals) => this.consumeGitHubSignals(signals), reportCoordinatorError);
         this.scheduleSignalCoordinator = new ReconcileCoordinator((jobId, signals) => this.consumeScheduleSignals(jobId, signals), reportCoordinatorError);
     }
-    repositories;
+    async localTarget(jobId) {
+        return this.resolveLocalJob(jobId);
+    }
+    async requireLocalStore(jobId) {
+        const resolved = await this.localTarget(jobId);
+        if (!resolved)
+            throw new Error('Authoritative SQLite Job is not registered: ' + jobId);
+        return resolved.store;
+    }
     async reconcileExclusive(jobId, work) {
         while (this.reconcileLocks.has(jobId))
             await this.reconcileLocks.get(jobId);
@@ -84,107 +81,55 @@ export class RepositoryWorkerPool {
         return `event.${event.type}`;
     }
     async consumeScheduleSignals(jobId, signals) {
-        if (this.isRateLimited() || signals.length === 0)
+        const event = [...signals].reverse().find(item => item.event?.type === 'schedule.tick')?.event;
+        const bucket = typeof event?.data?.bucket === 'string' ? event.data.bucket : null;
+        const tickAt = new Date(typeof event?.data?.tickAt === 'string' ? event.data.tickAt : event?.timestamp ?? Date.now());
+        if (!bucket || Number.isNaN(tickAt.getTime()))
             return;
-        const signal = [...signals].reverse().find(item => item.event?.type === 'schedule.tick');
-        const event = signal?.event;
-        const repository = signal?.repository ?? (typeof event?.data?.repository === 'string' ? event.data.repository : undefined);
-        const prValue = signal?.prNumber ?? Number(event?.data?.prNumber);
-        const prNumber = Number.isInteger(prValue) && Number(prValue) > 0 ? Number(prValue) : undefined;
-        const bucket = typeof event?.data?.bucket === 'string' ? event.data.bucket : undefined;
-        const tickAt = typeof event?.data?.tickAt === 'string' ? new Date(event.data.tickAt) : new Date(event?.timestamp ?? Date.now());
-        if (!repository || !prNumber || !bucket || !this.repositories.includes(repository) || Number.isNaN(tickAt.getTime()))
+        const target = await this.localTarget(jobId);
+        if (!target)
             return;
-        this.jobTargets.set(jobId, { repository, prNumber });
-        await runScheduledBucket(this.client, repository, this.trustedAuthors, { prNumber, jobId, bucket }, { reconcile: async () => { await this.reconcileTarget(repository, prNumber, jobId, 'schedule.tick'); }, idle: async () => { } }, tickAt, () => this.makeStore(repository, prNumber));
+        await runScheduledBucketFromStore(target.store, { jobId, bucket }, {
+            reconcile: async () => this.reconcileLocalJob(jobId, 'schedule.tick'),
+            idle: async () => { },
+        }, tickAt);
     }
-    async consumeGitHubSignals(_signals) {
-        // GitHub webhooks are fact-only inputs. They must never trigger a GitHub reread.
+    async reconcileLocalJob(jobId, reason = 'local.request') {
+        const target = await this.localTarget(jobId);
+        if (!target)
+            throw new Error('Local job not found: ' + jobId);
+        const reconciler = this.makeReconciler(target.store, Math.max(1, this.concurrency));
+        await this.reconcileExclusive(jobId, async () => {
+            await withObservabilityCorrelation({ jobId, repository: target.job.repository }, () => reconciler.reconcile(jobId));
+        });
+        void reason;
     }
     async consumeSignals(jobId, signals) {
-        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)) {
-            observability().record({
-                stage: 'reconcile', event: 'reconcile.signal_unrouted', level: 'warn', outcome: 'skipped',
-                message: `Reconcile signal target unknown for job ${jobId}`,
-                correlation: { jobId },
-                data: { reasons: signals.map(signal => signal.reason) },
-            });
+        const target = await this.localTarget(jobId);
+        if (!target)
             return;
-        }
-        const seedKey = `${target.repository}#${target.prNumber}:${jobId}`;
-        const mayConsumeSeed = signals.some(signal => signal.reason === 'target.request' || signal.reason.startsWith('github.webhook:'));
-        let seed = mayConsumeSeed ? this.targetSeeds.get(seedKey) ?? null : null;
-        if (mayConsumeSeed)
-            this.targetSeeds.delete(seedKey);
-        const needsFreshPullRequestFacts = signals.some(signal => !signal.event || signal.event.type === 'task.completed');
-        if (!seed && needsFreshPullRequestFacts && this.refreshWebhookSnapshot && !this.isRateLimited()) {
-            const trigger = `coordinator.${signals.map(signal => signal.reason).join('+') || 'reconcile'}`;
-            seed = (await this.refreshWebhookSnapshot(target.repository, target.prNumber, trigger)).seed;
-        }
-        const store = this.makeStore(target.repository, target.prNumber, seed);
-        const reconciler = this.makeReconciler(store, Math.max(1, this.concurrency));
+        const reconciler = this.makeReconciler(target.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));
-            if (!result.applied)
-                observability().record({
-                    stage: 'transition', event: 'lifecycle.event_rejected', level: 'warn', outcome: 'skipped',
-                    message: `Lifecycle event ${signal.event.type} not applied: ${result.reason}`,
-                    correlation: { repository: target.repository, prNumber: target.prNumber, jobId, taskId: signal.event.task_id },
-                    data: { eventId: signal.event.event_id, sourceId: signal.event.source?.id, reason: result.reason, eventTimestamp: signal.event.timestamp },
-                });
-            shouldReconcile ||= result.reconcile;
-        }
-        if (!shouldReconcile) {
-            observability().record({
-                stage: 'wake', event: 'wake.signal', level: 'debug', outcome: 'noop',
-                message: `Wake for ${target.repository}#${target.prNumber} produced no reconcile work`,
-                correlation: { repository: target.repository, prNumber: target.prNumber, jobId },
-                data: { reasons: [...new Set(reasons)] },
-            });
-            return;
+            if (signal.event.type === 'github.webhook')
+                continue;
+            const outcome = await reconciler.applyEvent(signal.event);
+            shouldReconcile ||= outcome.reconcile;
         }
-        const reason = [...new Set(reasons)].join('+') || 'unknown';
-        observability().record({
-            stage: 'wake', event: 'wake.signal', outcome: 'started',
-            message: `Wake for ${target.repository}#${target.prNumber}: ${reason}`,
-            correlation: { repository: target.repository, prNumber: target.prNumber, jobId },
-            data: { reasons: [...new Set(reasons)] },
-        });
-        await this.reconcileExclusive(jobId, async () => {
-            await withObservabilityCorrelation({ repository: target.repository, prNumber: target.prNumber, jobId }, () => withGitHubRequestContext(this.client, `pool.coordinator-reconcile:${reason}`, () => reconciler.reconcile(jobId)));
-        });
+        if (shouldReconcile)
+            await this.reconcileLocalJob(jobId, 'local.signal');
     }
     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.reconcileExclusive(job.id, async () => {
-                const store = this.makeStore(job.repository, job.prNumber);
-                await store.hydrate?.(job);
-                await withGitHubRequestContext(this.client, 'pool.terminal-reconcile', () => 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 = this.makeStore(job.repository, job.prNumber);
+            const store = await this.requireLocalStore(job.id);
             await store.hydrate?.(job);
             const ready = job.tasks.filter(task => (task.state === 'QUEUED' && task.executionId === null) || (task.state === 'DRAFT' && task.dependencies.length > 0)).length;
             const expiredRunning = job.tasks.some(task => ['RUNNING', 'QUEUED'].includes(task.state) && task.executionId !== null && task.leaseExpiresAt !== null && new Date(task.leaseExpiresAt).getTime() <= Date.now());
@@ -192,7 +137,7 @@ export class RepositoryWorkerPool {
                 continue;
             const allowance = Math.max(1, Math.min(capacity, ready || (expiredRunning ? 1 : 0) || 1));
             await this.reconcileExclusive(job.id, async () => {
-                await withGitHubRequestContext(this.client, 'pool.discovered-reconcile', () => this.makeReconciler(store, allowance).reconcile(job.id));
+                await this.makeReconciler(store, allowance).reconcile(job.id);
             });
             capacity -= allowance;
         }
@@ -200,26 +145,23 @@ export class RepositoryWorkerPool {
     async reconcileKnown(discovered) {
         const recovered = [];
         for (const item of discovered) {
-            if (item.githubState !== 'OPEN' || item.job.state !== 'ACTIVE') {
+            if (item.job.state !== 'ACTIVE') {
                 recovered.push(item);
                 continue;
             }
-            this.jobTargets.set(item.job.id, { repository: item.job.repository, prNumber: item.job.prNumber });
-            const store = this.makeStore(item.job.repository, item.job.prNumber);
+            const store = await this.requireLocalStore(item.job.id);
             await store.hydrate?.(item.job);
             const reconciler = this.makeReconciler(store, 0);
             let recoveredJob = item.job;
             if (typeof reconciler.recoverStartupOrphans === 'function')
                 await this.reconcileExclusive(item.job.id, async () => {
-                    recoveredJob = await withGitHubRequestContext(this.client, 'pool.startup-orphan-recovery', () => reconciler.recoverStartupOrphans(item.job.id));
+                    recoveredJob = await reconciler.recoverStartupOrphans(item.job.id);
                 });
             recovered.push({ ...item, job: recoveredJob });
         }
         await this.reconcileDiscovered(recovered);
     }
     async reconcile() {
-        if (this.isRateLimited())
-            return;
         if (this.running) {
             this.pending = true;
             return;
@@ -228,34 +170,26 @@ export class RepositoryWorkerPool {
         try {
             do {
                 this.pending = false;
-                await this.reconcileDiscovered(await withGitHubRequestContext(this.client, 'pool.workspace-scan', () => aggregateManagedGitHubJobs(this.client, this.repositories, this.trustedAuthors)));
+                await this.reconcileDiscovered(await this.localInventory());
             } while (this.pending);
         }
         finally {
             this.running = false;
         }
     }
-    seedTargetSnapshot(repository, prNumber, jobId, seed) {
-        if (!this.repositories.includes(repository))
+    async reconcileTarget(_repository, _prNumber, jobId, reason = 'target.request') {
+        // Transport metadata is never used for routing; reject observational wakeups.
+        if (reason.startsWith('github.webhook:'))
             return;
-        this.targetSeeds.set(`${repository}#${prNumber}:${jobId}`, seed);
-    }
-    async reconcileTarget(repository, prNumber, jobId, reason = 'target.request') {
-        if (this.isRateLimited() || !this.repositories.includes(repository))
-            return;
-        this.jobTargets.set(jobId, { repository, prNumber });
-        await this.coordinator.accept({ jobId, reason, repository, prNumber });
+        await this.coordinator.accept({ jobId, reason });
     }
     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 (event.type === 'schedule.tick' && repository && prNumber) {
-                await this.scheduleSignalCoordinator.acceptTransport({ jobId: event.job_id, reason: this.signalReason(event), event, repository, prNumber });
+            if (event.type === 'schedule.tick') {
+                await this.scheduleSignalCoordinator.acceptTransport({ jobId: event.job_id, reason: this.signalReason(event), event });
                 return;
             }
             if (ingressWebhook)
@@ -263,17 +197,16 @@ export class RepositoryWorkerPool {
             if (routedWebhook)
                 return;
             const lifecycle = ['task.started', 'task.completed', 'task.failed', 'task.blocked', 'task.unblocked', 'task.cancelled', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type);
-            const wake = event.type === 'job.wake' || event.type === 'github.webhook' || event.type === 'review.created';
+            // GitHub transport is observational. It must never wake lifecycle execution.
+            if (event.type === 'github.webhook')
+                return;
+            const wake = event.type === 'job.wake' || event.type === 'review.created';
             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,
             });
         });
         return async () => {
@@ -285,13 +218,13 @@ export class RepositoryWorkerPool {
     async scheduleTickSignal(bus, job, now = new Date()) {
         if (!job.schedule)
             return;
-        const event = eventFor(job.id, 'scheduler', null, 'schedule.tick', 'queued', `Schedule tick for ${job.schedule.nextRunAt}`, 'orchestrator', { repository: job.repository, prNumber: job.prNumber, bucket: scheduleBucket(new Date(job.schedule.nextRunAt)), tickAt: now.toISOString() }, { agent: 'relay', component: 'scheduler-timer' });
+        const event = eventFor(job.id, 'scheduler', null, 'schedule.tick', 'queued', `Schedule tick for ${job.schedule.nextRunAt}`, 'orchestrator', { bucket: scheduleBucket(new Date(job.schedule.nextRunAt)), tickAt: now.toISOString() }, { agent: 'relay', component: 'scheduler-timer' });
         // Use the same coordinator-owned schedule path whether transport is available or not.
         if (bus) {
             await bus.publish(event);
             return;
         }
-        await this.scheduleSignalCoordinator.accept({ jobId: job.id, reason: this.signalReason(event), event, repository: job.repository, prNumber: job.prNumber });
+        await this.scheduleSignalCoordinator.accept({ jobId: job.id, reason: this.signalReason(event), event });
     }
     async webhookSignal(_bus, _wake) {
         // Uncorrelated webhook wakeups are intentionally ignored. A caller must first
@@ -301,7 +234,7 @@ export class RepositoryWorkerPool {
         if (bus) {
             const source = { id: `github/${job.repository}/delivery/${wake.deliveryId}`, component: 'github-webhook' };
             if (wake.publication) {
-                await bus.publish(eventFor(job.id, 'release', null, 'package.published', 'succeeded', `Published ${wake.publication.package}@${wake.publication.version}`, 'orchestrator', {
+                const publishEvent = eventFor(job.id, 'release', null, 'package.published', 'succeeded', `Published ${wake.publication.package}@${wake.publication.version}`, 'orchestrator', {
                     deliveryId: wake.deliveryId,
                     repository: job.repository,
                     prNumber: job.prNumber,
@@ -309,14 +242,18 @@ export class RepositoryWorkerPool {
                     version: wake.publication.version,
                     registry: wake.publication.registry,
                     sha: wake.publication.sha,
-                }, source));
+                }, source);
+                publishEvent.event_id = 'github:' + job.id + ':' + wake.deliveryId + ':package.published';
+                await bus.publish(publishEvent);
             }
             if (wake.publishFailure) {
-                await bus.publish(eventFor(job.id, 'release', null, 'package.publish_failed', 'failed', `Publish workflow ${wake.publishFailure.runId} failed: ${wake.publishFailure.stage}`, 'user', { ...wake.publishFailure, repository: job.repository, prNumber: job.prNumber, deliveryId: wake.deliveryId }, source));
+                const failedEvent = eventFor(job.id, 'release', null, 'package.publish_failed', 'failed', `Publish workflow ${wake.publishFailure.runId} failed: ${wake.publishFailure.stage}`, 'user', { ...wake.publishFailure, repository: job.repository, prNumber: job.prNumber, deliveryId: wake.deliveryId }, source);
+                failedEvent.event_id = 'github:' + job.id + ':' + wake.deliveryId + ':package.publish_failed';
+                await bus.publish(failedEvent);
             }
             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, `github.webhook:${wake.event}${wake.action ? ':' + wake.action : ''}`);
+        // Without EventBus the GitHub observation stays in SQLite; it does not wake execution.
     }
 }

package/dist/projected-store.js

@@ -80,10 +80,12 @@ export class GitHubProjectionWriter {
     relay;
     github;
     onConflict;
-    constructor(relay, github, onConflict) {
+    externalOnly;
+    constructor(relay, github, onConflict, externalOnly = false) {
         this.relay = relay;
         this.github = github;
         this.onConflict = onConflict;
+        this.externalOnly = externalOnly;
     }
     async flushOnce(limit = 50, now = new Date()) {
         const items = await this.relay.claimDueProjections(limit, now);
@@ -91,7 +93,22 @@ export class GitHubProjectionWriter {
         let deferred = 0;
         for (const item of items) {
             try {
+                if (this.externalOnly && !['merge_pull_request', 'close_pull_request', 'update_pr_body'].includes(item.operation)) {
+                    // Drop legacy lifecycle projections; GitHub may not override SQLite truth.
+                    await this.relay.completeProjection(item.id);
+                    continue;
+                }
                 await this.apply(item);
+                // Only a CONFIRMED external operation may create the corresponding
+                // fact; Graph Engine observes it and decides the local lifecycle.
+                if (item.operation === 'merge_pull_request' || item.operation === 'close_pull_request') {
+                    const previous = await this.relay.loadPullRequestFacts();
+                    await this.relay.savePullRequestFacts({
+                        state: item.operation === 'merge_pull_request' ? 'MERGED' : 'CLOSED',
+                        head: previous?.head ?? null,
+                        observedAt: new Date().toISOString(),
+                    });
+                }
                 await this.relay.completeProjection(item.id);
                 projected += 1;
                 observability().record({
@@ -184,11 +201,11 @@ export class ProjectedDurableStore {
     relatedStore;
     projection;
     seededFacts;
-    constructor(relay, github, seed = null, relatedStore, onConflict) {
+    constructor(relay, github, seed = null, relatedStore, onConflict, externalOnly = false) {
         this.relay = relay;
         this.github = github;
         this.relatedStore = relatedStore;
-        this.projection = new GitHubProjectionWriter(relay, github, onConflict);
+        this.projection = new GitHubProjectionWriter(relay, github, onConflict, externalOnly);
         this.seededFacts = pullRequestFactsFromSeed(seed);
         if (this.seededFacts)
             void this.relay.savePullRequestFacts(this.seededFacts).catch(() => { });

package/dist/projection-outbox.js

@@ -136,7 +136,8 @@ export class ProjectionOutbox {
         }
     }
     resetProcessing(now) {
-        this.db.prepare("UPDATE projection_outbox SET status='pending', updated_at=? WHERE status='processing'").run(now);
+        const cutoff = new Date(Date.parse(now) - 120_000).toISOString();
+        this.db.prepare("UPDATE projection_outbox SET status='pending', updated_at=? WHERE status='processing' AND updated_at<=?").run(now, cutoff);
     }
     enqueue(request, now) {
         const operationKey = logicalOperationKey(request.idempotencyKey);
@@ -179,6 +180,7 @@ export class ProjectionOutbox {
         const observedAt = now.toISOString();
         this.db.exec('BEGIN IMMEDIATE');
         try {
+            this.resetProcessing(observedAt); // Reclaim only stale claims; recover on each retry tick, not only on process restart.
             const rows = this.db.prepare(`
         SELECT ${OUTBOX_COLUMNS}
         FROM projection_outbox

package/dist/publication-store.js

@@ -0,0 +1,37 @@
+/** Persist a webhook publication acknowledgement and its delivery ID in one transaction. */
+export function recordPublicationInDatabase(db, jobId, deliveryId, publication, failure, observedAt = new Date().toISOString()) {
+    if (!publication && !failure)
+        return false;
+    db.exec('BEGIN IMMEDIATE');
+    try {
+        const inserted = db.prepare('INSERT OR IGNORE INTO publication_delivery(job_id,delivery_id,type,json,observed_at) VALUES(?,?,?,?,?)')
+            .run(jobId, deliveryId, publication ? 'package.published' : 'package.publish_failed', JSON.stringify(publication ?? failure), observedAt);
+        if (inserted.changes === 0) {
+            db.exec('COMMIT');
+            return false;
+        }
+        const previous = loadPublicationFromDatabase(db, jobId);
+        const isNewer = !previous || observedAt >= previous.updatedAt;
+        const next = isNewer ? {
+            latest: publication ?? previous?.latest ?? null,
+            failure: failure ?? (publication ? null : previous?.failure ?? null),
+            updatedAt: observedAt,
+        } : previous;
+        db.prepare('INSERT INTO publication_state(job_id,json) VALUES(?,?) ON CONFLICT(job_id) DO UPDATE SET json=excluded.json')
+            .run(jobId, JSON.stringify(next));
+        db.exec('COMMIT');
+        return true;
+    }
+    catch (error) {
+        db.exec('ROLLBACK');
+        throw error;
+    }
+}
+export function loadPublicationFromDatabase(db, jobId) {
+    const row = db.prepare('SELECT json FROM publication_state WHERE job_id=?').get(jobId);
+    return row ? JSON.parse(row.json) : null;
+}
+export function listPublicationEventsFromDatabase(db, jobId) {
+    const rows = db.prepare('SELECT delivery_id,type,json,observed_at FROM publication_delivery WHERE job_id=? ORDER BY observed_at,delivery_id').all(jobId);
+    return rows.map(row => ({ deliveryId: row.delivery_id, type: row.type, observedAt: row.observed_at, payload: JSON.parse(row.json) }));
+}