agents-relay 1.0.177 → 2.0.1

package/dist/reconciler-review.js

@@ -4,47 +4,107 @@ import { implementationComplete, implementationTasks } from './runtime-status.js
 import { eventFor } from './events.js';
 import { workerCandidates } from './worker-routing.js';
 import { routeExecution } from './execution-routing.js';
-import { ReconcilerRuntimeBase } from './reconciler-runtime.js';
+import { ReconcilerRuntimeBase, withExecutionBoundary } from './reconciler-runtime.js';
+import { dispatchReviewLifecycle, reviewOutcome } from './workflow/review-v2.js';
+import { createTaskEntity } from './workflow/entity-creation.js';
+const taskRouteClaims = new Set();
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) { return await this.store.headSha?.() ?? job.headSha ?? job.review?.headSha ?? null; }
-    async invalidateStaleReview(job, headSha) {
-        if (!headSha || !job.review || job.review.headSha === headSha || job.review.outcome === 'stale')
-            return;
-        job.review = { ...job.review, outcome: 'stale', updatedAt: new Date().toISOString() };
-        const staleTask = job.review.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
-        if (staleTask && ['DRAFT', 'QUEUED', 'RUNNING'].includes(staleTask.state)) {
-            this.live.get(staleTask.id)?.execution.cancel();
-            await transitionTaskEvent(staleTask, 'cancel');
-            staleTask.error = 'Review evidence became stale after the PR head changed';
-            staleTask.leaseOwner = null;
-            staleTask.leaseExpiresAt = null;
-            await this.store.saveTask(staleTask);
-        }
-        await this.store.saveJob(job);
+    reviewFacts(job, prState, headSha) {
+        const reviewTasks = job.tasks.filter(task => task.agentName === 'reviewer' && task.reviewHeadSha === headSha);
+        const currentReviewTask = job.review?.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
+        return {
+            unscheduled: !job.schedule,
+            reviewEnabled: job.reviewEnabled !== false,
+            prOpen: prState === 'OPEN',
+            jobActive: job.state === 'ACTIVE',
+            implementationComplete: implementationComplete(job),
+            headAvailable: Boolean(headSha),
+            completionGateSatisfied: completionGateSatisfied(job),
+            noActiveReviewTask: !reviewTasks.some(task => ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)),
+            currentReviewCancelled: currentReviewTask?.reviewHeadSha === headSha && currentReviewTask.state === 'CANCELLED',
+            noApprovedCurrentReview: !reviewTasks.some(task => task.state === 'SUCCEEDED' && job.review?.headSha === headSha && job.review.outcome === 'approved'),
+        };
     }
-    async ensureFinalReview(job, prState, headSha) {
-        if (job.schedule || job.reviewEnabled === false || prState !== 'OPEN' || job.state !== 'ACTIVE' || !implementationComplete(job) || !headSha)
-            return;
-        if (job.executionMode === 'autonomous' && !completionGateSatisfied(job))
+    async cancelStaleReviewTask(job) {
+        const staleTask = job.review?.taskId ? job.tasks.find(task => task.id === job.review?.taskId) : undefined;
+        if (!staleTask || !['DRAFT', 'QUEUED', 'RUNNING'].includes(staleTask.state))
             return;
-        const review = job.review;
-        if (review?.headSha === headSha && ['started', 'approved', 'changes_required', 'blocked'].includes(review.outcome))
-            return;
-        const reviewTasks = job.tasks.filter(task => task.agentName === 'reviewer' && task.reviewHeadSha === headSha);
-        if (reviewTasks.some(task => ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)))
+        this.cancelExecutionGeneration(job.id, staleTask.id, staleTask.executionId ?? staleTask.executionHistory?.at(-1)?.id);
+        await transitionTaskEvent(staleTask, 'cancel');
+        staleTask.error = 'Review evidence became stale after the PR head changed';
+        staleTask.leaseOwner = null;
+        staleTask.leaseExpiresAt = null;
+        await this.store.saveTask(staleTask);
+    }
+    async invalidateStaleReview(job, headSha) {
+        if (!headSha || !job.review || job.review.headSha === headSha)
             return;
-        if (reviewTasks.some(task => task.state === 'SUCCEEDED' && review?.headSha === headSha && review.outcome === 'approved'))
+        const decision = await dispatchReviewLifecycle(job.review.outcome, 'head.changed', {}, async (actionId) => {
+            if (actionId === 'review.cancelStale') {
+                await this.cancelStaleReviewTask(job);
+                return {};
+            }
+            throw new Error('Unsupported stale review action ' + actionId);
+        });
+        if (!decision.accepted)
             return;
-        const id = `final-review-${headSha.slice(0, 12)}`;
+        const outcome = reviewOutcome(decision.target);
+        if (!outcome)
+            throw new Error('Review graph produced invalid stale target ' + decision.target);
+        job.review = { ...job.review, outcome, updatedAt: new Date().toISOString() };
+        await this.store.saveJob(job);
+    }
+    nextFinalReviewTaskId(job, headSha) {
+        const base = 'final-review-' + headSha.slice(0, 12);
+        const ids = new Set(job.tasks.filter(task => task.reviewHeadSha === headSha && task.agentName === 'reviewer').map(task => task.id));
+        if (!ids.has(base))
+            return base;
+        for (let round = 2; round < 1000; round += 1) {
+            const candidate = base + '-r' + round;
+            if (!ids.has(candidate))
+                return candidate;
+        }
+        throw new Error('Too many final review rounds for ' + headSha);
+    }
+    async createFinalReviewTask(job, headSha) {
+        const id = this.nextFinalReviewTaskId(job, headSha);
         const now = new Date().toISOString();
         const reviewGateTasks = implementationTasks(job);
         const reviewerRouting = await this.selectReviewer(reviewGateTasks);
-        const task = { 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.`, output: { kind: 'task_pr' }, routing: reviewerRouting.candidate.routing, continuation: null, continuationDeliveredAt: null, reviewHeadSha: headSha, state: 'QUEUED', attempt: 0, maxAttempts: this.options.reviewer?.maxAttempts ?? 2, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now };
+        const task = createTaskEntity(job, {
+            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.',
+            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,
+            error: null, timeoutMs: this.options.reviewer?.timeoutMs ?? storySizeTimeoutMs('M'), createdAt: now, updatedAt: now
+        });
         await this.store.appendTask(task);
-        job.review = { outcome: 'pending', headSha, taskId: id, evidence: null, updatedAt: now };
+        await this.emit(eventFor(job.id, id, null, 'review.created', 'queued', 'Final review task ' + id + ' created for ' + headSha + ' using ' + reviewerRouting.reason, 'orchestrator', { headSha, agentName: 'reviewer', reviewerRouting: { workerId: reviewerRouting.selection.workerId, reason: reviewerRouting.reason, selectedBy: reviewerRouting.selection.selectedBy } }));
+        return id;
+    }
+    async ensureFinalReview(job, prState, headSha) {
+        let reviewTaskId = null;
+        const decision = await dispatchReviewLifecycle(job.review?.outcome, 'reconcile', this.reviewFacts(job, prState, headSha), async (actionId) => {
+            if (actionId !== 'review.create')
+                throw new Error('Unsupported review reconcile action ' + actionId);
+            if (!headSha)
+                throw new Error('Review graph requested creation without a durable head SHA');
+            reviewTaskId = await this.createFinalReviewTask(job, headSha);
+            return {};
+        });
+        if (!decision.accepted || !reviewTaskId || !headSha)
+            return;
+        const outcome = reviewOutcome(decision.target);
+        if (!outcome)
+            throw new Error('Review graph produced invalid create target ' + decision.target);
+        const now = new Date().toISOString();
+        job.review = { outcome, headSha, taskId: reviewTaskId, evidence: null, updatedAt: now };
         job.updatedAt = now;
         await this.store.saveJob(job);
-        await this.emit(eventFor(job.id, id, null, 'review.created', 'queued', `Final review task ${id} created for ${headSha} using ${reviewerRouting.reason}`, 'orchestrator', { headSha, agentName: 'reviewer', reviewerRouting: { workerId: reviewerRouting.selection.workerId, reason: reviewerRouting.reason, selectedBy: reviewerRouting.selection.selectedBy } }));
         const ready = schedule(await this.store.load(job.id));
         await this.store.saveJob(ready);
     }
@@ -104,43 +164,58 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const registered = await this.store.listAgents();
         const candidates = workerCandidates(this.options.adapters, registered, usage);
         const runtimeSummary = this.options.runtimeSummaryProvider?.();
-        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
-            const requirements = task.workerRequirements ?? { capabilities: [] };
-            const taskFacts = {
-                id: task.id,
-                kind: task.kind ?? 'work',
-                storySize: task.storySize ?? 'M',
-                agentName: task.agentName ?? null,
-                input: task.input,
-                attachments: task.attachments ?? [],
-                output: task.output ?? null,
-            };
-            const routingConstraints = task.routing ? { provider: task.routing.provider, model: task.routing.model, profile: task.routing.profile, reasoning: task.routing.reasoning } : undefined;
-            const parent = task.agentName === 'troubleshooter' && task.parentTaskId ? job.tasks.find(item => item.id === task.parentTaskId) : undefined;
-            const parentRouteFailedBeforeStart = Boolean(parent?.routing && /exited before publishing task\.started|worker_exit_before_start|launch failed/i.test(parent.error ?? parent.failureReason ?? ''));
-            const excludedRoutes = parentRouteFailedBeforeStart && parent?.routing
-                ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
-                : [];
-            const routed = await routeExecution(candidates, requirements, {
-                decisionEngine: this.options.decisionEngine,
-                decisionMode: this.options.decisionMode,
-                taskFacts: { ...taskFacts, recovery_parent_failed_route: excludedRoutes[0] ?? null },
-                usage,
-                registered,
-                chatgptRunning: runtimeSummary?.chatgptRunning ?? 0,
-                routingConstraints,
-                excludedRoutes,
-                auditStore: this.options.decisionAuditStore,
-                auditTask: task,
-            });
-            task.workerSelection = routed.selection;
-            task.adapter = routed.candidate.adapter;
-            task.routing = routed.candidate.routing;
-            task.timeoutMs = task.timeoutMs || taskOverallTimeoutMs(task.storySize ?? 'M', task.routing.reasoning);
-            task.updatedAt = new Date().toISOString();
-            await this.store.saveTask(task);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'worker.selected', 'queued', `Worker ${routed.selection.workerId} selected for task ${task.id}`, 'user', { workerSelection: routed.selection, workerRequirements: requirements }, { agent: 'relay', component: 'agents-relay' }));
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', `Selected ${task.routing.model} · thinking ${task.routing.reasoning ?? 'unknown'}`, 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
+        for (const candidate of job.tasks.filter(item => item.kind !== 'planner' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
+            const claimKey = `${job.id}/${candidate.id}`;
+            if (taskRouteClaims.has(claimKey))
+                continue;
+            taskRouteClaims.add(claimKey);
+            try {
+                await withExecutionBoundary(job.id, candidate.id, async () => {
+                    const freshJob = await this.store.load(job.id);
+                    const task = freshJob.tasks.find(item => item.id === candidate.id);
+                    if (!task || !['QUEUED', 'BLOCKED'].includes(task.state) || task.workerSelection || !task.output)
+                        return;
+                    const requirements = task.workerRequirements ?? { capabilities: [] };
+                    const taskFacts = {
+                        id: task.id,
+                        kind: task.kind ?? 'work',
+                        storySize: task.storySize ?? 'M',
+                        agentName: task.agentName ?? null,
+                        input: task.input,
+                        attachments: task.attachments ?? [],
+                        output: task.output ?? null,
+                    };
+                    const routingConstraints = task.routing ? { provider: task.routing.provider, model: task.routing.model, profile: task.routing.profile, reasoning: task.routing.reasoning } : undefined;
+                    const parent = task.agentName === 'troubleshooter' && task.parentTaskId ? freshJob.tasks.find(item => item.id === task.parentTaskId) : undefined;
+                    const parentRouteFailedBeforeStart = Boolean(parent?.routing && /exited before publishing task\.started|worker_exit_before_start|launch failed/i.test(parent.error ?? parent.failureReason ?? ''));
+                    const excludedRoutes = parentRouteFailedBeforeStart && parent?.routing
+                        ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
+                        : [];
+                    const routed = await routeExecution(candidates, requirements, {
+                        decisionEngine: this.options.decisionEngine,
+                        decisionMode: this.options.decisionMode,
+                        taskFacts: { ...taskFacts, recovery_parent_failed_route: excludedRoutes[0] ?? null },
+                        usage,
+                        registered,
+                        chatgptRunning: runtimeSummary?.chatgptRunning ?? 0,
+                        routingConstraints,
+                        excludedRoutes,
+                        auditStore: this.options.decisionAuditStore,
+                        auditTask: task,
+                    });
+                    task.workerSelection = routed.selection;
+                    task.adapter = routed.candidate.adapter;
+                    task.routing = routed.candidate.routing;
+                    task.timeoutMs = task.timeoutMs || taskOverallTimeoutMs(task.storySize ?? 'M', task.routing.reasoning);
+                    task.updatedAt = new Date().toISOString();
+                    await this.store.saveTask(task);
+                    await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'worker.selected', 'queued', `Worker ${routed.selection.workerId} selected for task ${task.id}`, 'user', { workerSelection: routed.selection, workerRequirements: requirements }, { agent: 'relay', component: 'agents-relay' }));
+                    await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'model.selected', 'queued', `Selected ${task.routing.model} · thinking ${task.routing.reasoning ?? 'unknown'}`, 'user', { routing: task.routing }, { agent: 'relay', component: 'agents-relay' }));
+                });
+            }
+            finally {
+                taskRouteClaims.delete(claimKey);
+            }
         }
     }
     async applyReviewEvent(event) {
@@ -149,14 +224,13 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const reviewData = event.data?.review && typeof event.data.review === 'object' ? event.data.review : undefined;
         const headSha = typeof reviewData?.headSha === 'string' ? reviewData.headSha : typeof event.data?.headSha === 'string' ? event.data.headSha : task?.reviewHeadSha;
         if (!task || !headSha || task.reviewHeadSha !== headSha)
-            return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
-        const outcome = event.type === 'review.started' ? 'started' : event.type === 'review.approved' ? 'approved' : event.type === 'review.changes_required' ? 'changes_required' : 'blocked';
+            return { applied: false, reconcile: false, reason: event.type + '.ignored' };
         const currentHeadSha = await this.store.headSha?.();
         if ((currentHeadSha && currentHeadSha !== headSha) || (job.headSha && job.headSha !== headSha))
-            return { applied: false, reconcile: false, reason: `${event.type}.stale` };
+            return { applied: false, reconcile: false, reason: event.type + '.stale' };
         const taskDecision = tryTransitionTaskEvent(task, event.type);
         if (!taskDecision.accepted || !taskDecision.target)
-            return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
+            return { applied: false, reconcile: false, reason: event.type + '.ignored' };
         task.error = null;
         if (taskDecision.target !== 'RUNNING') {
             task.leaseOwner = null;
@@ -164,49 +238,50 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             task.executionId = null;
         }
         await this.store.saveTask(task);
-        const evidence = { summary: event.message || `Review ${outcome}`, data: { ...(event.data ?? {}), review: reviewData ?? { headSha }, headSha, outcome } };
-        job.review = { outcome, headSha, taskId: task.id, evidence, updatedAt: event.timestamp || new Date().toISOString() };
-        if (outcome === 'changes_required') {
-            const rawIssues = Array.isArray(reviewData?.issues) ? reviewData.issues : [];
-            const issues = rawIssues.map(item => {
-                if (typeof item === 'string')
-                    return item.trim();
-                if (item && typeof item === 'object') {
-                    const value = item;
-                    const summary = typeof value.summary === 'string' ? value.summary : typeof value.message === 'string' ? value.message : typeof value.title === 'string' ? value.title : '';
-                    return summary.trim();
+        let needsReconcile = false;
+        const reviewDecision = await dispatchReviewLifecycle(job.review?.outcome, event.type, { autoMerge: job.autoMerge !== false }, async (actionId) => {
+            if (actionId === 'review.createFix') {
+                needsReconcile = true;
+                const rawIssues = Array.isArray(reviewData?.issues) ? reviewData.issues : [];
+                const issues = rawIssues.map(item => {
+                    if (typeof item === 'string')
+                        return item.trim();
+                    if (item && typeof item === 'object') {
+                        const value = item;
+                        return (typeof value.summary === 'string' ? value.summary : typeof value.message === 'string' ? value.message : typeof value.title === 'string' ? value.title : '').trim();
+                    }
+                    return '';
+                }).filter(Boolean);
+                if (issues.length === 0)
+                    issues.push(event.message || 'Address the reviewer-requested changes');
+                const now = event.timestamp || new Date().toISOString();
+                const id = 'review-fix-' + headSha.slice(0, 8);
+                if (!job.tasks.some(item => item.id === id)) {
+                    const input = 'Address all reviewer findings for PR #' + job.prNumber + ' at ' + headSha + ':\n\n' + issues.map((issue, index) => (index + 1) + '. ' + issue).join('\n');
+                    const fixTask = createTaskEntity(job, { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'implementation', parentTaskId: task.id, dependencies: [task.id], capabilities: ['implementation'], workerRequirements: { capabilities: [] }, adapter: 'codex', input, output: { kind: 'task_pr' }, continuation: null, continuationDeliveredAt: null, attempt: 0, maxAttempts: 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null, error: null, timeoutMs: 0, createdAt: now, updatedAt: now });
+                    await this.store.appendTask(fixTask);
+                    await this.emit(eventFor(job.id, id, task.id, 'review.fix_task_created', 'queued', 'Created one fix task ' + id + ' for ' + issues.length + ' reviewer finding(s)', 'orchestrator', { headSha, issues }, { agent: 'relay', component: 'agents-relay' }));
                 }
-                return '';
-            }).filter(Boolean);
-            if (issues.length === 0)
-                issues.push(event.message || 'Address the reviewer-requested changes');
-            const now = event.timestamp || new Date().toISOString();
-            const id = `review-fix-${headSha.slice(0, 8)}`;
-            if (!job.tasks.some(item => item.id === id)) {
-                const input = `Address all reviewer findings for PR #${job.prNumber} at ${headSha}:\n\n${issues.map((issue, index) => `${index + 1}. ${issue}`).join('\n')}`;
-                const fixTask = {
-                    jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title,
-                    agentName: 'implementation', parentTaskId: task.id, dependencies: [task.id], capabilities: ['implementation'],
-                    workerRequirements: { capabilities: [] }, adapter: 'codex', input, output: { kind: 'task_pr' },
-                    continuation: null, continuationDeliveredAt: null, state: 'DRAFT', attempt: 0, maxAttempts: 3,
-                    leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null, result: null, plannerResult: null,
-                    error: null, timeoutMs: 0, createdAt: now, updatedAt: now
-                };
-                await this.store.appendTask(fixTask);
-                await this.emit(eventFor(job.id, id, task.id, 'review.fix_task_created', 'queued', `Created one fix task ${id} for ${issues.length} reviewer finding(s)`, 'orchestrator', { headSha, issues }, { agent: 'relay', component: 'agents-relay' }));
+                return {};
             }
-        }
+            if (actionId === 'review.requestMerge') {
+                await transitionJobEvent(job, 'review.approved', { autoMerge: true }, async (effectId) => {
+                    const outcomes = await this.workflowEffects.execute([effectId], { jobId: job.id, taskId: task.id, transitionKey: 'review.approved:' + headSha, data: { headSha } });
+                    await this.applyJobEffectOutcomes(job, outcomes);
+                }, async () => { await this.store.saveJob(job); });
+                return {};
+            }
+            throw new Error('Unsupported review event action ' + actionId);
+        });
+        if (!reviewDecision.accepted)
+            return { applied: false, reconcile: false, reason: event.type + '.ignored' };
+        const outcome = reviewOutcome(reviewDecision.target);
+        if (!outcome)
+            return { applied: false, reconcile: false, reason: event.type + '.ignored' };
+        const evidence = { summary: event.message || 'Review ' + outcome, data: { ...(event.data ?? {}), review: reviewData ?? { headSha }, headSha, outcome } };
+        job.review = { outcome, headSha, taskId: task.id, evidence, updatedAt: event.timestamp || new Date().toISOString() };
         job.updatedAt = job.review.updatedAt;
         await this.store.saveJob(job);
-        if (outcome === 'approved' && job.autoMerge !== false && this.store.mergePullRequest) {
-            const decision = await transitionJobEvent(job, 'review.approved', { autoMerge: true });
-            await this.store.saveJob(job);
-            const outcomes = await this.workflowEffects.execute(decision.effects, { jobId: job.id, taskId: task.id, transitionKey: `review.approved:${headSha}`, data: { headSha } });
-            await this.applyJobEffectOutcomes(job, outcomes);
-            if (outcomes.some(item => item.effect === 'effect.mergePullRequest' && item.status !== 'failed')) {
-                await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'review.merged', 'succeeded', 'Reviewer-approved PR #' + job.prNumber + ' merge requested', 'user', { headSha, autoMerge: true }, { agent: 'reviewer', component: 'agents-relay' }));
-            }
-        }
-        return { applied: true, reconcile: outcome === 'changes_required', reason: `review.${outcome}`, reconcileMode: outcome === 'changes_required' ? 'detached' : undefined };
+        return { applied: true, reconcile: needsReconcile, reason: 'review.' + outcome, reconcileMode: needsReconcile ? 'detached' : undefined };
     }
 }

package/dist/reconciler-runtime.js

@@ -8,8 +8,35 @@ import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { acceptedReportedTag, eventDataWithoutTag } from './task-tag.js';
 export function executionEventSource(jobId, taskId, executionId) { return `job/${jobId}/task/${taskId}/execution/${executionId}`; }
 function eventSourceId(event) { return typeof event.source?.id === 'string' ? event.source.id : undefined; }
+function executionIdFromSource(sourceId, jobId, taskId) {
+    const prefix = `job/${jobId}/task/${taskId}/execution/`;
+    return sourceId?.startsWith(prefix) ? sourceId.slice(prefix.length) || undefined : undefined;
+}
 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);
+    }
+}
 function claimTerminalExecution(sourceId) {
     terminalExecutionClaims.add(sourceId);
     const cleanup = setTimeout(() => terminalExecutionClaims.delete(sourceId), 60000);
@@ -185,6 +212,19 @@ export class ReconcilerRuntimeBase {
     registerExecutionOwner(jobId, taskId, executionId) {
         activeExecutionOwners.set(executionEventSource(jobId, taskId, executionId), this);
     }
+    cancelExecutionGeneration(jobId, taskId, executionId) {
+        if (!executionId)
+            return false;
+        const sourceId = executionEventSource(jobId, taskId, executionId);
+        const owner = activeExecutionOwners.get(sourceId);
+        const live = owner?.live.get(taskId);
+        if (!owner || !live || live.executionId !== executionId)
+            return false;
+        live.controller.abort();
+        live.execution.cancel();
+        owner.clearExecution(taskId, executionId);
+        return true;
+    }
     clearTerminalTimer(taskId, executionId) {
         const live = this.live.get(taskId);
         if (!live || live.executionId !== executionId)
@@ -281,7 +321,7 @@ export class ReconcilerRuntimeBase {
             live.processSettled = true;
         const job = await this.store.load(jobId);
         const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId)
+        if (!task || (task.executionId !== executionId && !terminalExecutionClaimed(jobId, taskId, executionId)))
             return;
         if (task.adapter !== 'chatgpt')
             this.clearTerminalTimer(taskId, executionId);
@@ -311,13 +351,23 @@ export class ReconcilerRuntimeBase {
         this.detach(this.emit(event), jobId, taskId, 'timeout failure event');
     }
     async applyTerminalEvent(event, trustedInternal = false) {
-        const transition = await this.taskTransitions.apply(event.job_id, event.task_id, event.type, {
+        const liveAtTerminal = this.live.get(event.task_id);
+        const terminalEventExecutionId = executionIdFromSource(eventSourceId(event), event.job_id, event.task_id);
+        const transition = await withExecutionBoundary(event.job_id, event.task_id, () => this.taskTransitions.apply(event.job_id, event.task_id, event.type, {
             eligible: (_job, task) => {
                 if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
                     return false;
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
-                if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
-                    return false;
+                if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event)) {
+                    const eventExecutionId = executionIdFromSource(eventSourceId(event), _job.id, task.id);
+                    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())
+                        return false;
+                }
                 const terminalWaiter = this.terminalWaiters.get(task.id);
                 return !terminalWaiter || Boolean(event.timestamp && new Date(event.timestamp).getTime() >= terminalWaiter.launchBarrier);
             },
@@ -331,11 +381,17 @@ export class ReconcilerRuntimeBase {
             mutate: (job, task) => {
                 const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
                 const acceptedExecutionId = task.executionId;
-                if (modelBacked && acceptedExecutionId)
-                    claimTerminalExecution(executionEventSource(job.id, task.id, acceptedExecutionId));
+                const eventExecutionId = executionIdFromSource(eventSourceId(event), job.id, task.id);
+                const terminalExecutionId = eventExecutionId ?? acceptedExecutionId;
+                if (modelBacked && terminalExecutionId)
+                    claimTerminalExecution(executionEventSource(job.id, task.id, terminalExecutionId));
+                if (eventExecutionId && acceptedExecutionId && eventExecutionId !== acceptedExecutionId) {
+                    this.cancelExecutionGeneration(job.id, task.id, eventExecutionId);
+                }
                 this.clearExecution(task.id, acceptedExecutionId);
                 task.leaseOwner = null;
                 task.leaseExpiresAt = null;
+                task.executionId = null;
                 task.updatedAt = event.timestamp || new Date().toISOString();
                 this.terminalWaiters.get(task.id)?.resolve();
                 this.terminalWaiters.delete(task.id);
@@ -368,9 +424,13 @@ export class ReconcilerRuntimeBase {
                     task.error = event.message || `Task ${task.id} cancelled`;
                 }
             },
-        });
+        }));
         if (!transition?.decision.accepted)
             return { applied: false, reconcile: false, reason: `${event.type}.ignored` };
+        if (transition.task.adapter === 'codex' && liveAtTerminal && !liveAtTerminal.processSettled && liveAtTerminal.jobId === event.job_id && (!terminalEventExecutionId || liveAtTerminal.executionId === terminalEventExecutionId)) {
+            liveAtTerminal.controller.abort();
+            liveAtTerminal.execution.cancel();
+        }
         if (event.type === 'task.completed')
             await this.deliverContinuation(transition.job, transition.task);
         const reviewWorker = transition.task.agentName === 'reviewer';