agents-relay 2.0.94 → 2.0.95

package/dist/projected-store.js

@@ -111,8 +111,7 @@ export class GitHubProjectionWriter {
                         observedAt: new Date().toISOString(),
                     });
                 }
-                await this.relay.completeProjection(item.id);
-                await this.relay.recordProjectionReceipt?.(item.operationKey, 'succeeded', item.attempts, { operation: item.operation });
+                await this.relay.completeProjectionWithReceipt(item.id, item.operationKey, 'succeeded', item.attempts, { operation: item.operation });
                 projected += 1;
                 observability().record({
                     stage: 'projection', event: 'projection.completed', outcome: 'succeeded',
@@ -137,8 +136,7 @@ export class GitHubProjectionWriter {
                 }
                 else {
                     const retryAt = githubProjectionRetryAt(error, item.attempts, now);
-                    await this.relay.retryProjection(item.id, message, retryAt);
-                    await this.relay.recordProjectionReceipt?.(item.operationKey, 'failed', item.attempts + 1, { operation: item.operation, error: message });
+                    await this.relay.retryProjectionWithReceipt(item.id, item.operationKey, message, retryAt, item.attempts + 1, { operation: item.operation, error: message });
                     deferred += 1;
                     observability().record({
                         stage: 'projection', event: 'projection.retry_scheduled', level: 'warn', outcome: 'failed',

package/dist/projection-outbox.js

@@ -215,6 +215,32 @@ export class ProjectionOutbox {
     complete(id) {
         this.db.prepare('DELETE FROM projection_outbox WHERE id=?').run(id);
     }
+    completeWithReceipt(id, operationKey, status, attempts, detail, now) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.recordReceipt(operationKey, status, attempts, detail, now);
+            this.db.prepare('DELETE FROM projection_outbox WHERE id=?').run(id);
+            this.db.exec('COMMIT');
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    retryWithReceipt(id, operationKey, error, nextAttemptAt, attempts, detail, now) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            this.db.prepare(`UPDATE projection_outbox
+        SET status='pending', attempts=?, next_attempt_at=?, last_error=?, updated_at=? WHERE id=?`)
+                .run(attempts, nextAttemptAt.toISOString(), error, now, id);
+            this.recordReceipt(operationKey, 'failed', attempts, detail, now);
+            this.db.exec('COMMIT');
+        }
+        catch (caught) {
+            this.db.exec('ROLLBACK');
+            throw caught;
+        }
+    }
     retry(id, error, nextAttemptAt) {
         this.db.prepare(`
       UPDATE projection_outbox

package/dist/relay-store.js

@@ -372,7 +372,13 @@ export class SQLiteRelayStore {
         return this.outbox.claimDue(limit, now);
     }
     async completeProjection(id) { this.outbox.complete(id); }
+    async completeProjectionWithReceipt(id, operationKey, status, attempts, detail) {
+        this.outbox.completeWithReceipt(id, operationKey, status, attempts, detail, new Date().toISOString());
+    }
     async retryProjection(id, error, nextAttemptAt) { this.outbox.retry(id, error, nextAttemptAt); }
+    async retryProjectionWithReceipt(id, operationKey, error, nextAttemptAt, attempts, detail) {
+        this.outbox.retryWithReceipt(id, operationKey, error, nextAttemptAt, attempts, detail, new Date().toISOString());
+    }
     async deadLetterProjection(id, error) { this.outbox.deadLetter(id, error); }
     async recordProjectionConflict(id, diagnostic) { this.outbox.recordConflict(id, diagnostic); }
     async listProjectionConflicts() { return this.outbox.listConflicts(); }

package/dist/relayd.js

@@ -222,12 +222,9 @@ export async function runDaemon(argv) {
             const snapshot = { path: candidate.snapshotPath };
             const discovered = candidate.job;
             try {
-                if (discovered.state === 'CANCELLED')
-                    continue;
                 if (!repositoryPaths.has(discovered.repository) || !discovered.localMerge?.sourceRef || !discovered.localMerge?.targetRef)
                     continue;
-                const sourceRef = discovered.localMerge.sourceRef;
-                const targetRef = discovered.localMerge.targetRef;
+                const sourceRef = discovered.localMerge.sourceRef, targetRef = discovered.localMerge.targetRef;
                 if (!sourceRef.startsWith('refs/heads/') || !targetRef.startsWith('refs/heads/'))
                     continue;
                 if (targetRef !== 'refs/heads/main')
@@ -250,13 +247,33 @@ export async function runDaemon(argv) {
                         await bus?.publish(eventFor(discovered.id, 'projection', null, 'projection.delivered', 'succeeded', `GitHub main synchronization ${published.status}`, 'orchestrator', { operation: 'github.syncMain', deliveryStatus: published.status, mergedCommitSha: published.localMergedCommitSha }, { agent: 'relay', component: 'github-projection' }));
                     continue;
                 }
-                const existingPrNumber = discovered.prNumber > 0 ? discovered.prNumber : 0;
                 const terminal = ['COMPLETED', 'CANCELLED'].includes(discovered.state);
                 const sourceSha = await gitText(canonical, ['rev-parse', '--verify', sourceRef]).catch(() => '');
                 if (!sourceSha)
                     continue;
                 let job = (await relay.loadJob(discovered.id)) ?? discovered;
                 let prNumber = job.prNumber > 0 ? job.prNumber : 0;
+                // The callback is part of the durable create intent, not daemon memory.
+                // Rebuild it on every scan so a reclaimed row remains executable after a
+                // crash, including when the binding mutation committed first.
+                const effect = async (item) => {
+                    const payload = item.payload;
+                    await gitText(canonical, ['fetch', '--no-tags', 'origin', `+refs/heads/${payload.base}:refs/remotes/origin/${payload.base}`]);
+                    const remoteRef = `refs/remotes/origin/${payload.head}`;
+                    const remoteHeadSha = await gitText(canonical, ['rev-parse', '--verify', remoteRef]).catch(() => '');
+                    const remoteTreeMatchesBase = remoteHeadSha ? await gitText(canonical, ['diff', '--quiet', `refs/remotes/origin/${payload.base}`, remoteRef]).then(() => true, () => false) : false;
+                    await gitText(canonical, authoritativeBranchPushArgs({ sourceRef: payload.sourceRef, branch: payload.head, remoteHeadSha: remoteHeadSha || null, remoteTreeMatchesBase }));
+                    // Lookup by head/base first: a crash after GitHub created the PR must
+                    // bind the existing collaboration projection rather than create one.
+                    const pr = await resolvePullRequest(client, payload.repository, { head: payload.head, base: payload.base, title: payload.title, body: payload.body });
+                    if (!relay.mutateJob)
+                        throw new Error('Atomic SQLite mutation is required for GitHub PR binding');
+                    await relay.mutateJob(job.id, current => ({ ...current, prNumber: pr.number, githubProjection: { status: 'pr_bound', sourceSha, observedAt: new Date().toISOString() }, updatedAt: new Date().toISOString() }));
+                    observability().record({ stage: 'projection', event: 'github.pr_bound', outcome: 'succeeded', message: `Bound local Job ${job.id} to GitHub PR #${pr.number}`, correlation: { repository: job.repository, prNumber: pr.number, jobId: job.id }, data: { head: branch, base } });
+                };
+                projectionWriters.set(`job:${job.id}`, new GitHubProjectionWriter(relay, prNumber > 0 ? new GitHubStore(client, job.repository, prNumber, trusted) : new InMemoryStore(job), undefined, true, effect));
+                if (job.state === 'CANCELLED')
+                    continue; // Drain committed effects only; never push.
                 if (prNumber === 0) {
                     // Do not bootstrap an empty remote-only PR commit: it would diverge from
                     // the real local Job branch before its first Worker commit. Publish the
@@ -277,21 +294,9 @@ export async function runDaemon(argv) {
                             await relay.mutateJob(job.id, current => ({ ...current, githubProjection: { status: 'merged_without_pr', sourceSha, observedAt: new Date().toISOString() } }));
                         continue;
                     }
-                    const effect = async (item) => {
-                        const payload = item.payload;
-                        await gitText(canonical, ['fetch', '--no-tags', 'origin', `+refs/heads/${payload.base}:refs/remotes/origin/${payload.base}`]);
-                        const remoteRef = `refs/remotes/origin/${payload.head}`;
-                        const remoteHeadSha = await gitText(canonical, ['rev-parse', '--verify', remoteRef]).catch(() => '');
-                        const remoteTreeMatchesBase = remoteHeadSha ? await gitText(canonical, ['diff', '--quiet', `refs/remotes/origin/${payload.base}`, remoteRef]).then(() => true, () => false) : false;
-                        await gitText(canonical, authoritativeBranchPushArgs({ sourceRef: payload.sourceRef, branch: payload.head, remoteHeadSha: remoteHeadSha || null, remoteTreeMatchesBase }));
-                        const pr = await resolvePullRequest(client, payload.repository, { head: payload.head, base: payload.base, title: payload.title, body: payload.body });
-                        if (!relay.mutateJob)
-                            throw new Error('Atomic SQLite mutation is required for GitHub PR binding');
-                        await relay.mutateJob(job.id, current => ({ ...current, prNumber: pr.number, githubProjection: { status: 'pr_bound', sourceSha, observedAt: new Date().toISOString() }, updatedAt: new Date().toISOString() }));
-                        observability().record({ stage: 'projection', event: 'github.pr_bound', outcome: 'succeeded', message: `Bound local Job ${job.id} to GitHub PR #${pr.number}`, correlation: { repository: job.repository, prNumber: pr.number, jobId: job.id }, data: { head: branch, base } });
-                    };
-                    projectionWriters.set(`job:${job.id}`, new GitHubProjectionWriter(relay, new InMemoryStore(job), undefined, true, effect));
-                    if (relay.enqueueExternalActionOnce)
+                    // A terminal Job may drain an already-committed intent, but terminal
+                    // state is never permission to create a new external PR intent.
+                    if (!terminal && relay.enqueueExternalActionOnce)
                         await relay.enqueueExternalActionOnce({ idempotencyKey: `create_pull_request:${job.id}:${sourceSha}`, operation: 'create_pull_request', payload: { operation: 'create_pull_request', repository: job.repository, head: branch, base, title: job.title, body: job.objective ?? job.description ?? '', sourceRef, targetRef }, priority: 100 });
                     if (terminal)
                         continue;
@@ -312,7 +317,7 @@ export async function runDaemon(argv) {
                     await relay.savePullRequestFacts({ state: latestFacts?.state === 'CLOSED' ? 'CLOSED' : 'OPEN', head: { ref: branch, sha: sourceSha }, observedAt: new Date().toISOString() });
                 }
                 const github = new GitHubStore(client, job.repository, prNumber, trusted);
-                projectionWriters.set(`job:${job.id}`, new GitHubProjectionWriter(relay, github, undefined, true));
+                projectionWriters.set(`job:${job.id}`, new GitHubProjectionWriter(relay, github, undefined, true, effect));
                 if (job.state === 'COMPLETED' && job.localMerge?.status === 'succeeded' && job.localMerge.projectionStrategy === 'target_ref_push') {
                     const injection = await consumeMethodInjection(relay, job.repository, job.id, 'github.projectLocalMerge');
                     const projectedMerge = await withTestInjection('github.projectLocalMerge', injection, () => projectAuthoritativeLocalMerge(canonical, job));

package/package.json

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