agents-relay 2.0.80 → 2.0.81

package/dist/reconciler-review.js

@@ -325,7 +325,10 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             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.
-        const initialReviewOutcome = !job.review && task.planningDecisionId ? 'pending' : job.review?.outcome;
+        const freshAfterStale = job.review?.outcome === 'stale'
+            && job.review.headSha !== headSha && Boolean(task.planningDecisionId);
+        const initialReviewOutcome = (!job.review || freshAfterStale) && task.planningDecisionId
+            ? 'pending' : job.review?.outcome;
         const taskDecision = this.store.mutateJob
             ? dispatchTaskLifecycleSync(structuredClone(task), event.type)
             : tryTransitionTaskEvent(task, event.type);
@@ -395,7 +398,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 Object.assign(freshTask, candidate);
                 // Bind the first Planner review only after the generation fence has
                 // checked the unmodified outer snapshot and authoritative SQLite state.
-                if (!current.review && freshTask.planningDecisionId) {
+                if ((!current.review || (current.review.outcome === 'stale' && current.review.headSha !== headSha)) && freshTask.planningDecisionId) {
                     current.review = { outcome: 'pending', headSha, taskId: freshTask.id, evidence: null, updatedAt: reviewUpdatedAt };
                 }
                 freshTask.error = null;

package/dist/reconciler-runtime.js

@@ -1,3 +1,4 @@
+import { normalizeReviewerTerminalEvent } from './review-terminal-normalization.js';
 import { applyJobEffectOutcomes, applyTaskEffectOutcomes } from './workflow-effect-failures.js';
 import { classifyWorkerRejection, reroutableWorkerRejections } from './worker-rejection.js';
 import { applyTaskRetryAction } from './task-actions.js';
@@ -89,6 +90,12 @@ export class ReconcilerRuntimeBase {
             return activeOwner.applyEvent(event);
         if (event.type === 'task.started')
             return this.markWorkerStarted(event);
+        if (event.type === 'task.completed') {
+            const task = (await this.store.load(event.job_id)).tasks.find(item => item.id === event.task_id);
+            const normalized = task?.agentName === 'reviewer' ? normalizeReviewerTerminalEvent(event) : null;
+            if (normalized)
+                return this.applyReviewEvent(normalized);
+        }
         if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
             const result = await this.applyTerminalEvent(event);
             if (event.type !== 'task.failed' || event.source?.watchdog !== true || event.data?.workflowEvent !== 'watchdog.failed' || result.reconcile)

package/dist/review-generation-fence.js

@@ -5,6 +5,14 @@ export function reviewGenerationMatches(current, original, task, headSha) {
         || (current.headSha && current.headSha !== headSha)
         || fresh.executionId !== task.executionId)
         return false;
+    // A fresh Planner reviewer for a new head replaces the old STALE review
+    // generation. Reject competing reviewers of that same head deterministically.
+    if (current.review?.outcome === 'stale' && original.review?.outcome === 'stale'
+        && current.review.headSha !== headSha && task.planningDecisionId) {
+        const currentHeadReviewers = current.tasks.filter(item => item.agentName === 'reviewer'
+            && item.reviewHeadSha === headSha && item.state !== 'CANCELLED');
+        return currentHeadReviewers.at(-1)?.id === task.id;
+    }
     if (current.review)
         return current.review.taskId === task.id && current.review.headSha === headSha
             && current.review.outcome === (original.review?.outcome ?? 'pending');

package/dist/review-terminal-normalization.js

@@ -0,0 +1,27 @@
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+/** Translate an authenticated reviewer terminal verdict without losing canonical review evidence. */
+export function normalizeReviewerTerminalEvent(event) {
+    if (event.type !== 'task.completed')
+        return null;
+    const data = record(event.data);
+    const raw = data.verdict;
+    const type = raw === 'approved' || raw === 'pass' ? 'review.approved'
+        : raw === 'changes-required' || raw === 'changes_required' ? 'review.changes_required'
+            : raw === 'blocked' ? 'review.blocked' : null;
+    if (!type)
+        return null;
+    const outcome = record(data.outcome);
+    const review = record(data.review);
+    // Match canonical review head resolution: outcome > review > top-level data.
+    const head = [outcome.head_sha, outcome.headSha, review.head_sha, review.headSha,
+        data.head_sha, data.headSha]
+        .find(value => typeof value === 'string' && value.length > 0);
+    const existingFindings = outcome.blocking_findings ?? outcome.blockingFindings;
+    const findings = existingFindings ?? (Array.isArray(data.findings) ? data.findings : undefined);
+    return { ...event, type, data: { ...data, outcome: {
+                ...outcome, ...(head ? { head_sha: head } : {}),
+                ...(findings !== undefined && existingFindings === undefined ? { blocking_findings: findings } : {}),
+            } } };
+}

package/package.json

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