agents-relay 2.0.63 → 2.0.64

package/dist/adapters.js

@@ -2,7 +2,7 @@ import { readFile, writeFile, unlink } from 'node:fs/promises';
 import { join } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { randomUUID } from 'node:crypto';
-import { spawnOwnedProcess, terminateOwnedProcess } from './owned-process.js';
+import { spawnOwnedProcess, terminateOwnedProcess, ownedProcessTerminationReason } from './owned-process.js';
 export function buildCodexArgs(route, input) {
     const args = ['exec', '--json'];
     if (route.profile)
@@ -82,7 +82,7 @@ export class CodexAdapter {
             child.on('error', error => { launchedReject(error); reject(error); });
             child.once('spawn', launchedResolve);
             child.on('close', (code, signal) => {
-                execution.processExit = { exitCode: code, signal, stderr: stderrTail };
+                execution.processExit = { exitCode: code, signal, stderr: stderrTail, terminationReason: ownedProcessTerminationReason(child) };
                 if (stdoutBuffer)
                     consumeLine(stdoutBuffer);
                 if (code === 0) {
@@ -110,14 +110,34 @@ export class LaunchFailure extends Error {
 }
 export class StartAckTimeout extends LaunchFailure {
 }
-function parseDriverJson(output) {
+function findSubmittedReceipt(value) {
+    if (typeof value === 'string') {
+        try {
+            return findSubmittedReceipt(JSON.parse(value));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    if (record.operation === 'submit' && record.status === 'submitted')
+        return record;
+    for (const key of ['result', 'output', 'data', 'stdout']) {
+        const nested = findSubmittedReceipt(record[key]);
+        if (nested)
+            return nested;
+    }
+    return undefined;
+}
+export function parseDriverJson(output) {
     const lines = output.trim().split(/\r?\n/).filter(Boolean);
     for (let index = lines.length - 1; index >= 0; index -= 1) {
         try {
-            const value = JSON.parse(lines[index]);
-            if (value.operation !== 'submit' || value.status !== 'submitted')
-                continue;
-            return value;
+            const receipt = findSubmittedReceipt(JSON.parse(lines[index]));
+            if (receipt)
+                return receipt;
         }
         catch {
             // Browser-harness diagnostics may precede the final JSON observation.
@@ -180,7 +200,19 @@ export async function ensureChatGptBrowserWorkspace(command = process.env.AGENTS
     }
     await admin.ensureWorkspace(CHATGPT_BROWSER_WORKSPACE, CHATGPT_BROWSER_WORKSPACE_POOL_SIZE);
 }
-function autoSessionBrowserWorkerRunner() {
+async function runBrowserWorker(cli, configFile, signal) {
+    const session = parseWorkspaceJson(await browserWorkspaceCommand(cli, ['session', 'start'], undefined, signal));
+    const sessionId = session.session_id;
+    if (typeof sessionId !== 'string' || !sessionId)
+        throw new Error('browser-workspace session start returned no session_id');
+    try {
+        return await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', 'temporary-submit', '--session-id', sessionId, '--config', configFile], undefined, signal);
+    }
+    finally {
+        await browserWorkspaceCommand(cli, ['session', 'stop', sessionId]).catch(() => { });
+    }
+}
+function browserWorkerRunner() {
     const cli = browserWorkspaceCli();
     return (_definition, request, _route, signal) => {
         const promise = (async () => {
@@ -192,7 +224,7 @@ function autoSessionBrowserWorkerRunner() {
                 }));
                 if (signal.aborted)
                     throw new Error('browser-worker execution aborted');
-                const output = await browserWorkspaceCommand(cli, ['platform', 'run', 'chatgpt', 'temporary-submit', '--auto-session', '--config', configFile], undefined, signal);
+                const output = await runBrowserWorker(cli, configFile, signal);
                 return JSON.stringify(parseDriverJson(output));
             }
             finally {
@@ -255,7 +287,7 @@ export class ChatGptAdapter {
             if (controller.signal.aborted)
                 throw new Error('browser-worker execution aborted');
             const policy = chatGptTabClosePolicy(task.chatgptTabClosePolicy, this.tabClosePolicy);
-            const run = (this.runner ?? autoSessionBrowserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
+            const run = (this.runner ?? browserWorkerRunner())(definition, { prompt: task.input, ...(task.attachments?.length ? { files: task.attachments } : {}), tabClosePolicy: policy }, route, controller.signal);
             try {
                 const output = await (run.submitted ?? run.promise);
                 const response = parseBrowserWorkerResponse(output);

package/dist/dashboard-html.js

@@ -486,9 +486,8 @@ const stream=new EventSource('/events');
 stream.onopen=()=>{connection.textContent='';connection.setAttribute('aria-label','Event stream connected');connection.className='status-pill ok';};
 stream.onerror=()=>{connection.textContent='';connection.setAttribute('aria-label','Event stream reconnecting');connection.className='status-pill warn';};
 stream.onmessage=message=>{const payload=parseMessage(message);if(payload?.job){const index=jobs.findIndex(job=>jobSelectionKey(job)===jobSelectionKey(payload.job));if(index>=0)jobs[index]=payload.job;else jobs.push(payload.job);renderAll();void drawRuntimeSummary();}};
-stream.addEventListener('relay',message=>{const payload=parseMessage(message);if(payload?.statePatch)applyStatePatch(payload.statePatch);if(payload?.event)addEvent(payload.event);renderAll();void drawRuntimeSummary();});
+stream.addEventListener('relay',message=>{const payload=parseMessage(message);if(payload?.job){const index=jobs.findIndex(job=>jobSelectionKey(job)===jobSelectionKey(payload.job));if(index>=0)jobs[index]=payload.job;else jobs.push(payload.job);}else if(payload?.statePatch)applyStatePatch(payload.statePatch);if(payload?.event)addEvent(payload.event);renderAll();void drawRuntimeSummary();});
 if(location.hash==='#/usage')showView('usage');else if(location.hash==='#/graphs')showView('graphs');else if(location.hash==='#/execution-router-rules')showView('rules');else if(location.hash==='#/shortcuts')showView('shortcuts');else showView('jobs');
-setInterval(()=>{if(location.hash!=='#/usage'&&location.hash!=='#/graphs'&&location.hash!=='#/execution-router-rules'&&location.hash!=='#/shortcuts')void refresh();},300000);
 setInterval(()=>{if(location.hash==='#/usage')void drawUsage();},30000);
 setInterval(()=>void refreshVersion(),30000);
 async function refreshSelected(){const job=selected();if(!job){await refresh();return;}selectedJobRefresh.disabled=true;selectedJobRefresh.textContent='Refreshing…';try{const params=new URLSearchParams({id:job.id,repo:job.repository,pr:String(job.prNumber)});const updated=await loadJSON('/api/job?'+params.toString());const index=jobs.findIndex(candidate=>jobSelectionKey(candidate)===jobSelectionKey(job));if(index>=0)jobs[index]=updated;else jobs.push(updated);selectedJob=jobSelectionKey(updated);rememberSelection();renderAll();connection.textContent='';connection.setAttribute('aria-label','Live durable state connected');connection.className='status-pill ok';}catch(error){connection.textContent='';connection.setAttribute('aria-label','Durable state unavailable');connection.className='status-pill bad';}finally{selectedJobRefresh.disabled=false;selectedJobRefresh.textContent='Refresh';}}

package/dist/dashboard.js

@@ -1,4 +1,5 @@
 import { createServer } from 'node:http';
+import { subscribeLocalCommits } from './local-commit-events.js';
 import { readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -99,17 +100,7 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             subscribedJobs.add(job.id);
             try {
                 await bus.subscribe(job.id, async (event) => {
-                    const durable = await store.load(job.id).catch(() => null);
-                    const task = durable?.tasks.find(candidate => candidate.id === event.task_id) ?? null;
-                    const statePatch = durable ? {
-                        jobId: durable.id,
-                        jobState: durable.state,
-                        jobUpdatedAt: durable.updatedAt,
-                        taskId: task?.id ?? null,
-                        taskState: task?.state ?? null,
-                        taskUpdatedAt: task?.updatedAt ?? null,
-                    } : null;
-                    const payload = JSON.stringify({ event, statePatch });
+                    const payload = JSON.stringify({ event });
                     for (const client of clients)
                         client.write(`event: relay\ndata: ${payload}\n\n`);
                 });
@@ -119,6 +110,16 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             }
         }
     };
+    const unsubscribeLocalCommits = subscribeLocalCommits(durable => {
+        const known = lastKnownJobs?.find(job => job.id === durable.id && job.repository === durable.repository && job.prNumber === durable.prNumber);
+        const githubState = known?.githubState;
+        const current = { ...durable, githubState, runtimeStatus: deriveJobRuntimeStatus(durable, githubState) };
+        if (lastKnownJobs && known)
+            Object.assign(known, current);
+        const payload = JSON.stringify({ job: current });
+        for (const client of clients)
+            client.write(`data: ${payload}\n\n`);
+    });
     const snapshot = async (requestedJobId = jobId, forceRefresh = false, target) => {
         await subscribeDiscovered();
         if (overviewProvider) {
@@ -563,15 +564,6 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
         res.writeHead(404);
         res.end('Not found');
     });
-    const interval = setInterval(() => {
-        if (clients.size === 0)
-            return;
-        void snapshot().then(value => {
-            for (const client of clients)
-                client.write(`data: ${value.json}\n\n`);
-        }).catch(() => undefined);
-    }, Math.max(10000, refreshMs));
-    interval.unref();
     const heartbeat = setInterval(() => {
         if (clients.size === 0)
             return;
@@ -579,7 +571,7 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             client.write(': heartbeat\n\n');
     }, SSE_HEARTBEAT_MS);
     heartbeat.unref();
-    server.on('close', () => { clearInterval(interval); clearInterval(heartbeat); clients.clear(); });
+    server.on('close', () => { unsubscribeLocalCommits(); clearInterval(heartbeat); clients.clear(); });
     server.listen(port, '127.0.0.1');
     return server;
 }

package/dist/execution-boundary.js

@@ -0,0 +1,23 @@
+const executionBoundaryLocks = new Map();
+/**
+ * Serialize the durable execution-generation boundary across reconciler
+ * instances in one relay process. Launch, routing, and terminal persistence
+ * must not observe and write the same queued generation concurrently.
+ */
+export async function withExecutionBoundary(jobId, taskId, work) {
+    const key = `${jobId}/${taskId}`;
+    const previous = executionBoundaryLocks.get(key);
+    let release;
+    const current = new Promise(resolve => { release = resolve; });
+    executionBoundaryLocks.set(key, current);
+    if (previous)
+        await previous;
+    try {
+        return await work();
+    }
+    finally {
+        release();
+        if (executionBoundaryLocks.get(key) === current)
+            executionBoundaryLocks.delete(key);
+    }
+}

package/dist/github-client.js

@@ -142,27 +142,33 @@ export class GhApiClient {
         if (rateLimited)
             this.assertAvailable();
         const commandArgs = includeHeaders ? [args[0] ?? '', '--include', ...args.slice(1)] : args;
-        return await new Promise((resolve) => {
-            const child = spawnOwnedProcess('gh', commandArgs, { invocation: 'github.api', spawn: { env } });
-            let stdout = '';
-            let stderr = '';
-            child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
-            child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
-            child.on('error', error => resolve({ status: null, headers: {}, body: '', stderr: error.message }));
-            if (input !== undefined)
-                child.stdin?.write(input);
-            child.stdin?.end();
-            child.on('close', code => {
-                const response = parseGitHubCliHeaders(stdout, includeHeaders);
-                const failed = code !== 0;
-                const message = failed ? stderr.trim() || response.body.trim() || `gh exited ${code}` : '';
-                if (failed && rateLimited)
-                    this.noteFailure(message);
-                if (!failed && rateLimited)
-                    this.noteSuccess();
-                resolve({ ...response, stderr: failed ? message : undefined });
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const result = await new Promise((resolve) => {
+                const child = spawnOwnedProcess('gh', commandArgs, { invocation: 'github.api', spawn: { env } });
+                let stdout = '';
+                let stderr = '';
+                child.stdout?.on('data', (chunk) => { stdout += chunk.toString(); });
+                child.stderr?.on('data', (chunk) => { stderr += chunk.toString(); });
+                child.on('error', error => resolve({ status: null, headers: {}, body: '', stderr: error.message }));
+                if (input !== undefined)
+                    child.stdin?.write(input);
+                child.stdin?.end();
+                child.on('close', (code, signal) => {
+                    const response = parseGitHubCliHeaders(stdout, includeHeaders);
+                    const failed = code !== 0;
+                    const message = failed ? stderr.trim() || response.body.trim() || `gh exited ${code}; signal=${signal ?? "none"}` : '';
+                    resolve({ ...response, stderr: failed ? message : undefined, signal });
+                });
             });
-        });
+            if (result.signal && attempt === 0)
+                continue;
+            if (result.stderr && rateLimited)
+                this.noteFailure(result.stderr);
+            if (!result.stderr && rateLimited)
+                this.noteSuccess();
+            return result;
+        }
+        throw new Error('GitHub CLI retry exhausted');
     }
     async spawnGh(args, input, env = process.env, rateLimited = true) {
         return (await this.runGh(args, input, env, rateLimited, false)).body;

package/dist/local-commit-events.js

@@ -0,0 +1,10 @@
+const listeners = new Set();
+/** Notify dashboard listeners only after authoritative SQLite state is committed. */
+export function publishLocalCommit(job) {
+    for (const listener of listeners)
+        listener(structuredClone(job));
+}
+export function subscribeLocalCommits(listener) {
+    listeners.add(listener);
+    return () => { listeners.delete(listener); };
+}

package/dist/owned-process.js

@@ -4,6 +4,9 @@ import { basename } from 'node:path';
 import { observability } from './observability.js';
 const owned = new Map();
 const byChild = new WeakMap();
+export function ownedProcessTerminationReason(child) {
+    return byChild.get(child)?.terminationReason ?? null;
+}
 let exitHookInstalled = false;
 function audit(record, event, outcome, data) {
     observability().record({
@@ -113,7 +116,7 @@ export function spawnOwnedProcess(command, args, options) {
         record.timeoutTimer.unref();
     }
     child.once('exit', (code, signal) => {
-        audit(record, 'process.exited', code === 0 ? 'succeeded' : 'failed', { exitStatus: code, signal });
+        audit(record, 'process.exited', code === 0 ? 'succeeded' : 'failed', { exitStatus: code, signal, terminationReason: record.terminationReason ?? null });
         // `close` waits for inherited stdio. End any descendants left behind by a
         // wrapper before they can keep the caller alive indefinitely.
         if (!record.terminating)
@@ -143,6 +146,7 @@ export async function terminateOwnedProcess(child, reason, graceMs) {
         return;
     if (!record.terminating) {
         record.terminating = true;
+        record.terminationReason = reason;
         const outcome = signalOwned(record, 'SIGTERM');
         audit(record, 'process.signal', outcome === 'error' ? 'failed' : 'succeeded', { reason, signal: 'SIGTERM', delivered: outcome === 'sent', alreadyGone: outcome === 'gone' });
         record.forceTimer = setTimeout(() => forceOwned(record, reason), graceMs ?? record.graceMs);

package/dist/planned-review-head.js

@@ -0,0 +1,17 @@
+/** 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;
+    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.',
+        '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:',
+        'those events must follow approval and are verified by the independent E2E runner.',
+    ].join(' ');
+    if (!task.input.includes(rule))
+        task.input += '\n\n' + rule;
+    await store.saveTask(task);
+}

package/dist/planner.js

@@ -100,7 +100,7 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
     const source = 'round' in planner ? planner.source : planner.planningSource ?? 'model-planner';
     const round = 'round' in planner ? planner.round : planner.planningRound ?? 1;
     const plannerHeadSha = 'round' in planner ? planner.headSha : undefined;
-    const reviewHeadSha = spec.agentName === 'reviewer' ? plannerHeadSha ?? job.headSha : undefined;
+    const reviewHeadSha = spec.agentName === 'reviewer' && !(spec.dependencies?.length) ? plannerHeadSha ?? job.headSha : undefined;
     return createTaskEntity(job, { jobId: job.id, id: spec.id, kind: 'work', priority: spec.priority ?? job.priority, storySize: spec.storySize ?? 'M', projectName: spec.projectName, agentName: spec.agentName, agentGraph: spec.agentGraph, review: spec.review, parentTaskId: spec.parentTaskId ?? null, dependencies: spec.dependencies ?? [], capabilities: spec.capabilities ?? [], workerRequirements: spec.workerRequirements, adapter: 'codex', input: spec.input, output: spec.output, continuation: spec.continuation ?? null, continuationDeliveredAt: null, attempt: 0, maxAttempts: spec.maxAttempts ?? 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: spec.timeoutMs ?? taskOverallTimeoutMs(spec.storySize ?? 'M'), createdAt: now, updatedAt: now, planningDecisionId: decisionId, planningSource: source, planningRound: round, reviewHeadSha });
 }
 export function planningSpec(task) {

package/dist/pool.js

@@ -263,7 +263,7 @@ 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';
+            const wake = event.type === 'job.wake' || event.type === 'github.webhook' || event.type === 'review.created';
             if (!lifecycle && !wake)
                 return;
             if (repository && prNumber)

package/dist/projected-store.js

@@ -1,3 +1,4 @@
+import { publishLocalCommit } from './local-commit-events.js';
 import { registerBlockerDependency, resolveBlockerDependencies } from './blockers.js';
 import { DurableDefinitionConflictError, isDurableDefinitionConflict, sameTaskDefinition } from './store-task-definition.js';
 import { decideProjectionFailure } from './workflow/projection-conflict-v2.js';
@@ -221,6 +222,7 @@ export class ProjectedDurableStore {
             payload: { operation: 'save_job', value },
             priority: ['COMPLETED', 'CANCELLED'].includes(job.state) ? 100 : 20,
         });
+        publishLocalCommit(job);
         observability().record({
             stage: 'store', event: 'store.commit', outcome: 'succeeded',
             message: `Job ${job.id} committed`,
@@ -243,6 +245,7 @@ export class ProjectedDurableStore {
             payload: { operation: 'append_plan', value: plan },
             priority: 30,
         });
+        publishLocalCommit(job);
     }
     async savePlan(plan) {
         const job = await this.load(plan.jobId);
@@ -260,6 +263,7 @@ export class ProjectedDurableStore {
             payload: { operation: 'save_plan', value: plan },
             priority: 30,
         });
+        publishLocalCommit(job);
     }
     async appendTask(task) {
         if (!task.jobId)
@@ -278,6 +282,7 @@ export class ProjectedDurableStore {
             payload: { operation: 'append_task', value: task },
             priority: 40,
         });
+        publishLocalCommit(job);
         observability().record({
             stage: 'store', event: 'store.commit', outcome: 'succeeded',
             message: `Task ${task.id} appended`,
@@ -305,6 +310,7 @@ export class ProjectedDurableStore {
             payload: { operation: 'save_task', value },
             priority: terminal ? 100 : 50,
         });
+        publishLocalCommit(job);
         observability().record({
             stage: 'store', event: 'store.commit', outcome: 'succeeded',
             message: `Task ${task.id} committed (${task.state})`,

package/dist/reconciler-review.js

@@ -113,7 +113,11 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer',
             parentTaskId: null, dependencies: reviewGateTasks.map(item => item.id), capabilities: ['review'],
             workerSelection: reviewerRouting.selection, adapter: reviewerRouting.candidate.adapter,
-            input: 'Review existing PR #' + job.prNumber + ' at exactly head SHA ' + headSha + '. Job objective: ' + (job.objective ?? job.description ?? job.title) + '. Use the selected reviewer agent contract as the authoritative review protocol.',
+            input: 'Review existing PR #' + job.prNumber + ' at exactly head SHA ' + headSha + '. Job objective: ' + (job.objective ?? job.description ?? job.title) + '. Use the selected reviewer agent contract as the authoritative review protocol. ' +
+                'This is a PRE-MERGE artifact approval gate: inspect the exact PR head, requested changes, applicable source/test requirements, and genuine blocking defects in the proposed changes. ' +
+                'Do not block approval because automatic merge, Job COMPLETED, or post-merge E2E evidence has not occurred yet; those are downstream effects of review approval and independently verified later. ' +
+                'Do not treat historical failed attempts or launch anomalies as current artifact defects if the latest implementation and tests succeeded; report historical lifecycle observations separately. ' +
+                'Compare implementation changes with the PR head that existed before the implementation, not only against main: preserved seed or baseline files are not automatically unrelated additions.',
             output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null,
             reviewHeadSha: headSha, attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2,
             leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null,
@@ -267,6 +271,12 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const currentHeadSha = await this.store.headSha?.();
         if ((currentHeadSha && currentHeadSha !== headSha) || (job.headSha && job.headSha !== headSha))
             return { applied: false, reconcile: false, reason: event.type + '.stale' };
+        // Planner-created reviewer tasks predate the final-review Job gate. Bind
+        // their first trustworthy review event to PENDING before dispatching it.
+        if (!job.review && task.planningDecisionId) {
+            job.review = { outcome: 'pending', headSha, taskId: task.id, evidence: null, updatedAt: event.timestamp || new Date().toISOString() };
+            await this.store.saveJob(job);
+        }
         const taskDecision = tryTransitionTaskEvent(task, event.type);
         if (!taskDecision.accepted || !taskDecision.target)
             return { applied: false, reconcile: false, reason: event.type + '.ignored' };

package/dist/reconciler-runtime.js

@@ -17,29 +17,8 @@ function executionIdFromSource(sourceId, jobId, taskId) {
 }
 const terminalExecutionClaims = new Set();
 const activeExecutionOwners = new Map();
-const executionBoundaryLocks = new Map();
-/**
- * Serialize the durable execution-generation boundary across reconciler
- * instances in one relay process. Launch, routing, and terminal persistence
- * must not observe and write the same queued generation concurrently.
- */
-export async function withExecutionBoundary(jobId, taskId, work) {
-    const key = `${jobId}/${taskId}`;
-    const previous = executionBoundaryLocks.get(key);
-    let release;
-    const current = new Promise(resolve => { release = resolve; });
-    executionBoundaryLocks.set(key, current);
-    if (previous)
-        await previous;
-    try {
-        return await work();
-    }
-    finally {
-        release();
-        if (executionBoundaryLocks.get(key) === current)
-            executionBoundaryLocks.delete(key);
-    }
-}
+import { withExecutionBoundary } from './execution-boundary.js';
+export { withExecutionBoundary } from './execution-boundary.js';
 function claimTerminalExecution(sourceId) {
     terminalExecutionClaims.add(sourceId);
     const cleanup = setTimeout(() => terminalExecutionClaims.delete(sourceId), 60000);
@@ -302,12 +281,12 @@ export class ReconcilerRuntimeBase {
         }
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
-        if (!task || (task.executionId !== executionId && !terminalExecutionClaimed(jobId, taskId, executionId)))
+        if (terminalExecutionClaimed(jobId, taskId, executionId) || !task || task.executionId !== executionId)
             return;
         if (task.adapter !== 'chatgpt' && task.executionId === executionId && live?.executionId === executionId)
             rearmTerminalEventDeadline(this.terminalTimers, taskId, task.timeoutMs - (Date.now() - live.launchBarrier), this.options.postExitTerminalGraceMs ?? 15_000, () => this.detach(this.timeoutTask(jobId, taskId, executionId), jobId, taskId, 'post-exit terminal event timeout'));
-        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (error ? 'Worker runtime exited with error' : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
-            signal: live?.execution.processExit?.signal ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error, executionId, pid: live?.execution.pid ?? null }, { id: executionEventSource(jobId, taskId, executionId), agent: 'relay', component: 'agents-relay' }));
+        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', live?.execution.processExit ? (live.execution.processExit.exitCode === 0 ? 'succeeded' : 'failed') : (error ? 'failed' : 'succeeded'), result?.summary ?? (live?.execution.processExit?.terminationReason === 'parent-shutdown' ? 'Worker interrupted by daemon shutdown' : error ? 'Worker runtime exited with error' : 'Worker runtime exited'), 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, exitCode: live?.execution.processExit?.exitCode ?? null,
+            signal: live?.execution.processExit?.signal ?? null, terminationReason: live?.execution.processExit?.terminationReason ?? null, stderr: live?.execution.processExit?.stderr ?? '', processError: error, executionId, pid: live?.execution.pid ?? null }, { id: executionEventSource(jobId, taskId, executionId), agent: 'relay', component: 'agents-relay' }));
     }
     async timeoutTask(jobId, taskId, executionId) {
         const live = this.live.get(taskId);
@@ -363,9 +342,8 @@ export class ReconcilerRuntimeBase {
                     const prior = eventExecutionId ? task.executionHistory?.find(item => item.id === eventExecutionId) : undefined;
                     // A duplicate launch can leave one worker orphaned after another worker
                     // has already produced the terminal fact. Accept only a known execution
-                    // from the same durable attempt and only when its fact is newer than its
-                    // launch. A prior retry attempt cannot complete a newer generation.
-                    if (!prior || prior.attempt !== task.attempt || !event.timestamp || new Date(event.timestamp).getTime() < new Date(prior.startedAt).getTime())
+                    // from the same durable attempt. A prior retry attempt cannot complete a newer generation.
+                    if (!prior || prior.attempt !== task.attempt)
                         return false;
                 }
                 const terminalWaiter = this.terminalWaiters.get(task.id);
@@ -373,9 +351,7 @@ export class ReconcilerRuntimeBase {
             },
             facts: (_job, task) => {
                 const processExitedAfterPublishedTerminal = task.failureReason === 'worker_exit_without_terminal_event';
-                const freshEnough = processExitedAfterPublishedTerminal
-                    || !event.timestamp
-                    || new Date(event.timestamp).getTime() >= new Date(task.updatedAt).getTime();
+                const freshEnough = processExitedAfterPublishedTerminal || this.isCorrelatedWorkerEvent(task, event);
                 return { recoverableExecution: this.isRecoverableWatchdogFailure(task) && freshEnough };
             },
             mutate: (job, task) => {

package/dist/reconciler.js

@@ -1,3 +1,4 @@
+import { bindPlannedReviewHead } from './planned-review-head.js';
 import { randomUUID } from 'node:crypto';
 import { storySizeTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
 import { dependencyReady, schedule, transitionTaskEvent } from './scheduler.js';
@@ -387,6 +388,8 @@ export class Reconciler extends ReconcilerReviewBase {
                 return;
             if (freshTask.executionId !== null)
                 return;
+            if (freshTask.agentName === 'reviewer' && freshTask.planningDecisionId && freshTask.dependencies.length)
+                await bindPlannedReviewHead(this.store, freshTask);
             if (!freshTask.routing && freshTask.adapter !== 'orchestrator') {
                 freshTask = (await this.routeTaskForExecution(freshJob, freshTask)).task;
             }

package/dist/runtime-status.js

@@ -32,13 +32,16 @@ export function deriveJobRuntimeStatus(job, prState = 'OPEN') {
             return 'WAITING';
         return 'WAITING';
     }
-    const reviewTasks = job.tasks.filter(task => task.agentName === 'reviewer');
-    const reviewActive = reviewTasks.some(task => ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state))
-        || job.review?.outcome === 'pending'
-        || job.review?.outcome === 'started';
+    // Draft or queued reviewers must not mask implementation that is still active.
+    const implementation = implementationTasks(job);
+    if (implementation.some(task => task.state === 'RUNNING'))
+        return 'RUNNING';
+    if (implementation.some(task => task.state === 'QUEUED'))
+        return 'QUEUED';
+    const reviewRunning = job.tasks.some(task => task.agentName === 'reviewer' && task.state === 'RUNNING');
     if (job.review?.outcome === 'approved' && prState === 'OPEN')
         return 'MERGE_PENDING';
-    if (reviewActive || (job.reviewEnabled !== false && implementationComplete(job) && job.review?.outcome !== 'approved'))
+    if (reviewRunning)
         return 'REVIEWING';
     if (job.tasks.some(task => task.state === 'RUNNING'))
         return 'RUNNING';

package/dist/scheduler.js

@@ -9,7 +9,10 @@ export function completionGateSatisfied(job) {
         return false;
     if (job.executionMode !== 'autonomous')
         return true;
-    const planSatisfied = (job.plans ?? []).some(plan => plan.status === 'SUCCEEDED' && plan.objectiveStatus === 'satisfied');
+    const latest = [...(job.plans ?? [])].sort((a, b) => a.round - b.round).at(-1);
+    const previousReviewFinished = job.tasks.some(task => task.agentName === 'reviewer' && task.state === 'SUCCEEDED');
+    const planSatisfied = latest?.status === 'SUCCEEDED' && (latest.objectiveStatus === 'satisfied'
+        || (latest.objectiveStatus === 'in_progress' && latest.plannerResult?.next_tasks?.length === 0 && previousReviewFinished));
     const legacySatisfied = (job.plans?.length ?? 0) === 0 && job.tasks.some(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied');
     return (planSatisfied || legacySatisfied) && implementationTasks(job).every(task => task.state === 'SUCCEEDED');
 }

package/package.json

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