agents-relay 2.0.94 → 2.0.96

package/dist/adapters.js

@@ -228,63 +228,12 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-/**
- * The upstream new-turn action accepts idempotency_key but does not enforce it.
- * Inspect the current thread before resubmitting after an ambiguous exit.
- * If the transcript is not observable, fail closed rather than duplicate.
- */
-async function findExistingReviewTurn(cli, sessionId, delivery, signal) {
-    const pathname = delivery.projectId
-        ? `/g/${encodeURIComponent(delivery.projectId)}/c/${encodeURIComponent(delivery.threadId)}`
-        : `/c/${encodeURIComponent(delivery.threadId)}`;
-    const marker = `Relay delivery ID: ${delivery.requestId}`;
-    const inspectJs = `(() => {
-    const legacy = [...document.querySelectorAll('[data-message-author-role="user"]')]
-      .map(e => ({text: (e.innerText || '').trim(), id: e.getAttribute('data-message-id') || ''})).filter(x => x.text);
-    if (legacy.length) return legacy;
-    return [...document.querySelectorAll('h4')].filter(e => (e.innerText || '').trim() === 'You said:')
-      .map((e,i) => ({text: (e.parentElement?.innerText || '').trim(), id: 'dom-user-' + i})).filter(x => x.text);
-  })()`;
-    const script = [
-        'import json, time',
-        'from urllib.parse import urlsplit',
-        `url = ${JSON.stringify(`https://chatgpt.com${pathname}`)}`,
-        `marker = ${JSON.stringify(marker)}`,
-        'goto_url(url)',
-        'wait_for_load()',
-        'if urlsplit(page_info().get("url", "")).path.rstrip("/") != urlsplit(url).path.rstrip("/"): raise RuntimeError("review thread redirect mismatch")',
-        'turns = []',
-        'for attempt in range(30):',
-        `    turns = js(${JSON.stringify(inspectJs)}) or []`,
-        '    if turns: break',
-        '    time.sleep(0.5)',
-        'if not turns: raise RuntimeError("review thread transcript unavailable; refusing ambiguous resubmission")',
-        'matches = [turn for turn in turns if marker in turn.get("text", "")]',
-        'if len(matches) > 1: raise RuntimeError("duplicate review delivery detected; manual reconciliation required")',
-        'print(json.dumps({"found": bool(matches), "user_message_id": matches[0].get("id") if matches else None}), flush=True)',
-    ].join('\n');
-    const envelope = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'exec', sessionId], script, signal));
-    if (envelope.ok !== true || typeof envelope.stdout !== 'string')
-        throw new Error('review thread inspection returned no executable result');
-    const observation = parseWorkspaceJson(envelope.stdout);
-    if (typeof observation.found !== 'boolean')
-        throw new Error('review thread inspection returned no authoritative result');
-    if (!observation.found)
-        return null;
-    return { status: 'submitted', mode: 'new-turn', thread_id: delivery.threadId, project_id: delivery.projectId,
-        verified_by: 'existing-user-turn', user_message_id: typeof observation.user_message_id === 'string' ? observation.user_message_id : null };
-}
-async function runBrowserWorker(cli, configFile, signal, action = 'temporary-submit', delivery) {
+async function runBrowserWorker(cli, configFile, signal, action = 'temporary-submit') {
     const session = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'start', '--workspace', CHATGPT_BROWSER_WORKSPACE], undefined, signal));
     const sessionId = session.session_id;
     if (typeof sessionId !== 'string' || !sessionId)
         throw new Error('browser-workspace session start returned no session_id');
     try {
-        if (delivery) {
-            const existing = await findExistingReviewTurn(cli, sessionId, delivery, signal);
-            if (existing)
-                return JSON.stringify(existing);
-        }
         return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', action, '--session-id', sessionId, '--config', configFile], undefined, signal);
     }
     finally {
@@ -310,7 +259,7 @@ function browserWorkerRunner() {
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
                 const action = delivery ? 'new-turn' : 'temporary-submit';
-                const output = await runBrowserWorker(cli, configFile, signal, action, delivery);
+                const output = await runBrowserWorker(cli, configFile, signal, action);
                 return JSON.stringify(parseDriverJson(output));
             }
             finally {

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.96",
   "description": "Durable async agent jobs coordinated through GitHub pull requests",
   "type": "module",
   "bin": {