agents-relay 2.0.67 → 2.0.69

package/dist/pool.js

@@ -1,12 +1,13 @@
-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';
+import { jobHasActiveExecution } from './job-execution-slot.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 +16,29 @@ 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;
+    dispatchTail = Promise.resolve();
     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 +48,29 @@ 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 withDispatchGate(work) {
+        const previous = this.dispatchTail;
+        let release;
+        this.dispatchTail = new Promise(resolve => { release = resolve; });
+        await previous;
+        try {
+            await work();
+        }
+        finally {
+            release();
+        }
+    }
     async reconcileExclusive(jobId, work) {
         while (this.reconcileLocks.has(jobId))
             await this.reconcileLocks.get(jobId);
@@ -84,107 +95,57 @@ 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);
+        await this.withDispatchGate(async () => {
+            await this.reconcileExclusive(jobId, async () => {
+                await withObservabilityCorrelation({ jobId, repository: target.job.repository }, () => this.makeReconciler(target.store, 0).reconcile(jobId));
+            });
+            await this.reconcileDiscovered(await this.localInventory());
+        });
+        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);
+        let capacity = Math.max(0, this.concurrency - jobs.filter(job => jobHasActiveExecution(job)).length);
         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 +153,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 +161,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 +186,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.withDispatchGate(async () => this.reconcileDiscovered(await this.localInventory()));
             } while (this.pending);
         }
         finally {
             this.running = false;
         }
     }
-    seedTargetSnapshot(repository, prNumber, jobId, seed) {
-        if (!this.repositories.includes(repository))
-            return;
-        this.targetSeeds.set(`${repository}#${prNumber}:${jobId}`, seed);
-    }
-    async reconcileTarget(repository, prNumber, jobId, reason = 'target.request') {
-        if (this.isRateLimited() || !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.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 +213,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' || event.type === 'planner.completed';
             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 +234,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 +250,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 +258,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) }));
+}

package/dist/reconciler-cancellation.js

@@ -0,0 +1,21 @@
+import { applyTaskCancelAction } from './task-actions.js';
+export async function cancelActiveTasks(store, jobId, reason, cancelPlanner, cancelExecutionGeneration) {
+    const job = await store.load(jobId);
+    for (const plan of (job.plans ?? []).filter(item => item.status === 'PLANNING')) {
+        cancelPlanner(plan.id);
+        plan.status = 'FAILED';
+        plan.error = reason;
+        plan.assessment = `Planning failed: ${reason}`;
+        plan.leaseOwner = null;
+        plan.leaseExpiresAt = null;
+        plan.executionId = null;
+        plan.updatedAt = new Date().toISOString();
+        await store.savePlan(plan);
+    }
+    for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
+        cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
+        cancelPlanner(task.id);
+        await applyTaskCancelAction(task, reason);
+        await store.saveTask(task);
+    }
+}