agents-relay 2.0.68 → 2.0.69

package/dist/planner-runtime.js

@@ -1,10 +1,53 @@
 import { randomUUID } from 'node:crypto';
 import { jobHasActiveExecution } from './job-execution-slot.js';
 import { eventFor } from './events.js';
-import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy } from './planner.js';
+import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy, validatePlannerLifecycleOwnership, validatePlannerProgress } from './planner.js';
 import { samePlannerChildDefinition } from './planner-child.js';
 import { withExecutionBoundary } from './reconciler-runtime.js';
 import { storySizeTimeoutMs } from './types.js';
+export async function drainPlannerUnblocks(ports, jobId, planId) {
+    const job = await ports.store.load(jobId);
+    const plan = (job.plans ?? []).find(item => item.id === planId);
+    if (!ports.store.registerBlockerDependent)
+        throw new Error("Blocker registration unavailable");
+    const pending = [...(plan?.pendingUnblocks ?? [])];
+    // Persist only acknowledgments observed by this invocation. Subtract from
+    // the latest transactional snapshot, never replace another drain's intents.
+    const acknowledged = new Set();
+    const key = (item) => JSON.stringify(item);
+    for (const unblock of pending) {
+        try {
+            await ports.store.registerBlockerDependent(jobId, unblock);
+            acknowledged.add(key(unblock));
+        }
+        catch { /* Pending intent is retained for the next reconcile. */ }
+    }
+    if (acknowledged.size > 0) {
+        if (!ports.store.mutateJob)
+            throw new Error('Atomic SQLite mutation is required to acknowledge planner unblocks');
+        await ports.store.mutateJob(jobId, current => {
+            const fresh = (current.plans ?? []).find(item => item.id === planId);
+            if (fresh?.pendingUnblocks?.length) {
+                const outstanding = fresh.pendingUnblocks.filter(item => !acknowledged.has(key(item)));
+                if (outstanding.length)
+                    fresh.pendingUnblocks = outstanding;
+                else
+                    delete fresh.pendingUnblocks;
+                fresh.updatedAt = new Date().toISOString();
+            }
+            return current;
+        });
+    }
+    const refreshed = await ports.store.load(jobId);
+    const remaining = (refreshed.plans ?? []).find(item => item.id === planId)?.pendingUnblocks ?? [];
+    return remaining.map(item => `${item.repository}#${item.prNumber}:${item.jobId}:${item.taskId}`);
+}
+export async function retryPendingPlannerUnblocks(ports, jobId) {
+    const job = await ports.store.load(jobId);
+    for (const plan of (job.plans ?? []).filter(item => item.status === 'SUCCEEDED' && (item.pendingUnblocks?.length ?? 0) > 0)) {
+        await drainPlannerUnblocks(ports, jobId, plan.id);
+    }
+}
 async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
     const live = ports.live.get(planId);
     if (live?.executionId === executionId)
@@ -13,40 +56,65 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
         ports.live.delete(planId); };
     const job = await ports.store.load(jobId);
     const plan = (job.plans ?? []).find(item => item.id === planId);
-    if (!plan || (executionId !== null && plan.executionId !== executionId)) {
+    if (!plan || plan.status !== "PLANNING" || plan.executionId !== executionId) {
         releaseLive();
         return;
     }
     const failOrRetry = async (message) => {
-        const attempt = plan.attempt ?? 0;
-        const maxAttempts = plan.maxAttempts ?? (plan.manualPlanning ? 1 : 3);
-        const retry = attempt < maxAttempts;
-        plan.status = retry ? 'PLANNING' : 'FAILED';
-        plan.retryFeedback = message;
-        plan.error = message;
-        plan.assessment = retry ? `Planning retry: ${message}` : `Planning failed: ${message}`;
-        plan.leaseOwner = null;
-        plan.leaseExpiresAt = null;
-        plan.executionId = null;
-        plan.updatedAt = new Date().toISOString();
-        await ports.store.savePlan(plan);
-        await ports.emit(eventFor(job.id, plan.id, null, retry ? 'planner.retry' : 'planner.failed', retry ? 'queued' : 'failed', `Planner ${plan.id}: ${message}`, 'user'));
+        let retry = false;
+        let applied = false;
+        const update = (fresh) => {
+            if (fresh.status !== 'PLANNING' || fresh.executionId !== executionId)
+                return;
+            const attempt = fresh.attempt ?? 0;
+            const maxAttempts = fresh.maxAttempts ?? (fresh.manualPlanning ? 1 : 3);
+            retry = attempt < maxAttempts;
+            fresh.status = retry ? 'PLANNING' : 'FAILED';
+            fresh.retryFeedback = message;
+            fresh.error = message;
+            fresh.assessment = retry ? `Planning retry: ${message}` : `Planning failed: ${message}`;
+            fresh.leaseOwner = null;
+            fresh.leaseExpiresAt = null;
+            fresh.executionId = null;
+            fresh.updatedAt = new Date().toISOString();
+            applied = true;
+        };
+        if (ports.store.mutateJob) {
+            await ports.store.mutateJob(jobId, current => {
+                const fresh = (current.plans ?? []).find(item => item.id === planId);
+                if (fresh)
+                    update(fresh);
+                return current;
+            });
+        }
+        else {
+            const fresh = (await ports.store.load(jobId)).plans?.find(item => item.id === planId);
+            if (fresh) {
+                update(fresh);
+                if (applied)
+                    await ports.store.savePlan(fresh);
+            }
+        }
+        if (!applied)
+            return;
+        await ports.emit(eventFor(jobId, planId, null, retry ? 'planner.retry' : 'planner.failed', retry ? 'queued' : 'failed', `Planner ${planId}: ${message}`, 'user'));
         if (retry && !plan.manualPlanning)
-            ports.detach(ports.reconcile(jobId), jobId, plan.id, 'planner retry reconciliation');
+            ports.detach(ports.reconcile(jobId), jobId, planId, 'planner retry reconciliation');
     };
     if (error) {
         await failOrRetry(error.message);
         releaseLive();
         return;
     }
+    let planCommitted = false;
     try {
         const result = parsePlannerResult(raw);
         const executionContext = await ports.plannerContext(job, plan);
         validatePlannerHierarchy(job.tasks, result.next_tasks);
+        validatePlannerLifecycleOwnership(job, result.next_tasks);
+        validatePlannerProgress(job, result);
         if (result.unblocks.length > 0 && !ports.store.registerBlockerDependent)
             throw new Error('Durable store does not support Planner cross-Job unblock registration');
-        for (const unblock of result.unblocks)
-            await ports.store.registerBlockerDependent?.(job.id, unblock);
         const children = result.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
         for (const child of children) {
             const existing = job.tasks.find(item => item.id === child.id);
@@ -54,29 +122,79 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                 throw new Error(`Planner child ${child.id} already exists with a different definition`);
         }
         const now = new Date().toISOString();
-        plan.status = 'SUCCEEDED';
-        plan.objectiveStatus = result.objective_status;
-        plan.plannerResult = result;
-        plan.assessment = result.assessment;
-        plan.generatedTaskIds = result.next_tasks.map(item => item.id);
-        plan.error = undefined;
-        plan.retryFeedback = undefined;
-        plan.leaseOwner = null;
-        plan.leaseExpiresAt = null;
-        plan.executionId = null;
-        plan.updatedAt = now;
-        await ports.store.savePlan(plan);
-        if (job.changeCycle && !job.changeCycle.consumedByPlannerTaskId && plan.trigger.source === 'unblock') {
-            job.changeCycle.consumedByPlannerTaskId = plan.id;
-            job.updatedAt = now;
-            await ports.store.saveJob(job);
+        if (ports.store.mutateJob) {
+            let committedPlan = false;
+            const committed = await ports.store.mutateJob(job.id, current => {
+                const durablePlan = (current.plans ?? []).find(item => item.id === plan.id);
+                if (!durablePlan || durablePlan.status !== 'PLANNING' || durablePlan.executionId !== executionId)
+                    return current;
+                durablePlan.status = 'SUCCEEDED';
+                durablePlan.objectiveStatus = result.objective_status;
+                durablePlan.plannerResult = result;
+                durablePlan.assessment = result.assessment;
+                durablePlan.generatedTaskIds = result.next_tasks.map(item => item.id);
+                durablePlan.pendingUnblocks = result.unblocks.length > 0 ? structuredClone(result.unblocks) : undefined;
+                durablePlan.error = undefined;
+                durablePlan.retryFeedback = undefined;
+                durablePlan.leaseOwner = null;
+                durablePlan.leaseExpiresAt = null;
+                durablePlan.executionId = null;
+                durablePlan.updatedAt = now;
+                if (current.changeCycle && !current.changeCycle.consumedByPlannerTaskId && durablePlan.trigger.source === 'unblock') {
+                    current.changeCycle.consumedByPlannerTaskId = durablePlan.id;
+                }
+                for (const child of children) {
+                    const existing = current.tasks.find(item => item.id === child.id);
+                    if (!existing)
+                        current.tasks.push(structuredClone(child));
+                    else if (!samePlannerChildDefinition(existing, child))
+                        throw new Error(`Planner child ${child.id} already exists with a different definition`);
+                }
+                current.updatedAt = now;
+                committedPlan = true;
+                return current;
+            });
+            Object.assign(job, structuredClone(committed));
+            if (!committedPlan) {
+                releaseLive();
+                return;
+            }
+        }
+        else {
+            plan.status = 'SUCCEEDED';
+            plan.objectiveStatus = result.objective_status;
+            plan.plannerResult = result;
+            plan.assessment = result.assessment;
+            plan.generatedTaskIds = result.next_tasks.map(item => item.id);
+            plan.pendingUnblocks = result.unblocks.length > 0 ? structuredClone(result.unblocks) : undefined;
+            plan.error = undefined;
+            plan.retryFeedback = undefined;
+            plan.leaseOwner = null;
+            plan.leaseExpiresAt = null;
+            plan.executionId = null;
+            plan.updatedAt = now;
+            await ports.store.savePlan(plan);
+            if (job.changeCycle && !job.changeCycle.consumedByPlannerTaskId && plan.trigger.source === 'unblock') {
+                job.changeCycle.consumedByPlannerTaskId = plan.id;
+                job.updatedAt = now;
+                await ports.store.saveJob(job);
+            }
+            for (const child of children)
+                if (!job.tasks.some(item => item.id === child.id))
+                    await ports.store.appendTask(child);
         }
-        for (const child of children)
-            if (!job.tasks.some(item => item.id === child.id))
-                await ports.store.appendTask(child);
-        await ports.emit(eventFor(job.id, plan.id, null, 'planner.completed', 'succeeded', `Plan ${plan.id} completed: ${result.objective_status}`, 'orchestrator', { objective_status: result.objective_status }));
+        planCommitted = true;
+        // Cross-Job registrations cannot join this Job's SQLite transaction. The
+        // committed Plan keeps replay intent until each external registration is
+        // confirmed, so a crash or partial failure is recoverable by reconcile.
+        const pendingUnblocks = await drainPlannerUnblocks(ports, job.id, plan.id);
+        await ports.emit(eventFor(job.id, plan.id, null, 'planner.completed', 'succeeded', `Plan ${plan.id} completed: ${result.objective_status}`, 'orchestrator', { objective_status: result.objective_status, pendingUnblocks }));
     }
     catch (caught) {
+        if (planCommitted) {
+            releaseLive();
+            throw caught;
+        }
         await failOrRetry(caught instanceof Error ? caught.message : String(caught));
         releaseLive();
         return;
@@ -88,9 +206,32 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
 export async function launchPlanExecution(ports, job, plan) {
     const planner = ports.options.planner;
     if (!planner) {
-        const failed = { ...plan, status: 'FAILED', error: 'Planner unavailable', assessment: 'Planning failed: Planner unavailable', leaseOwner: null, leaseExpiresAt: null, executionId: null, updatedAt: new Date().toISOString() };
-        await ports.store.savePlan(failed);
-        await ports.emit(eventFor(job.id, plan.id, null, 'planner.failed', 'failed', `Planner ${plan.id}: Planner unavailable`, 'user'));
+        let failed = false;
+        if (ports.store.mutateJob) {
+            await ports.store.mutateJob(job.id, current => {
+                const fresh = current.plans?.find(item => item.id === plan.id);
+                if (fresh?.status === 'PLANNING' && fresh.executionId === plan.executionId) {
+                    fresh.status = 'FAILED';
+                    fresh.error = 'Planner unavailable';
+                    fresh.assessment = 'Planning failed: Planner unavailable';
+                    fresh.leaseOwner = null;
+                    fresh.leaseExpiresAt = null;
+                    fresh.executionId = null;
+                    fresh.updatedAt = new Date().toISOString();
+                    failed = true;
+                }
+                return current;
+            });
+        }
+        else {
+            const fresh = (await ports.store.load(job.id)).plans?.find(item => item.id === plan.id);
+            if (fresh?.status === 'PLANNING' && fresh.executionId === plan.executionId) {
+                await ports.store.savePlan({ ...fresh, status: 'FAILED', error: 'Planner unavailable', assessment: 'Planning failed: Planner unavailable', leaseOwner: null, leaseExpiresAt: null, executionId: null, updatedAt: new Date().toISOString() });
+                failed = true;
+            }
+        }
+        if (failed)
+            await ports.emit(eventFor(job.id, plan.id, null, 'planner.failed', 'failed', `Planner ${plan.id}: Planner unavailable`, 'user'));
         return;
     }
     const claimed = await withExecutionBoundary(job.id, '__job_execution_slot__', async () => {

package/dist/planner.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises';
+import { parseTestInjection } from './e2e-injection.js';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
@@ -101,14 +102,14 @@ export function materializePlannerChild(job, planner, spec, executionContext) {
     const round = 'round' in planner ? planner.round : planner.planningRound ?? 1;
     const plannerHeadSha = 'round' in planner ? planner.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 });
+    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, testInjection: spec.testInjection, 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) {
     if (!task.output && task.adapter !== 'orchestrator')
         throw new Error(`Initial task ${task.id} requires an output contract`);
     if (!['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
         throw new Error(`Initial task ${task.id} requires a supported adapter`);
-    return { id: task.id, parentTaskId: task.parentTaskId, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, agentGraph: task.agentGraph, review: task.review, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs };
+    return { id: task.id, parentTaskId: task.parentTaskId, input: task.input, priority: task.priority, storySize: task.storySize, projectName: task.projectName, agentName: task.agentName, agentGraph: task.agentGraph, review: task.review, dependencies: task.dependencies, capabilities: task.capabilities, workerRequirements: task.workerRequirements, testInjection: task.testInjection, adapter: task.adapter, output: task.output ?? { kind: 'task_pr' }, routing: task.routing, continuation: task.continuation, maxAttempts: task.maxAttempts, timeoutMs: task.timeoutMs };
 }
 function record(value, field = 'result') {
     if (!value || typeof value !== 'object' || Array.isArray(value))
@@ -286,12 +287,44 @@ export function parsePlannerResult(value) {
             id, parentTaskId, input: task.input, priority, storySize,
             projectName: optionalString(task.projectName, 'projectName'), agentName: optionalString(task.agentName, 'agentName'), agentGraph, review,
             dependencies: stringArray(task.dependencies, 'dependencies'), capabilities: stringArray(task.capabilities, 'capabilities'), workerRequirements: requirements,
+            testInjection: parseTestInjection(task.testInjection ?? task['--test-injection']) ?? optionalString(task.testInjection ?? task['--test-injection'], `next_tasks[${index}].--test-injection`),
             adapter: adapter, output: output, routing: route,
             continuation: task.continuation, maxAttempts, timeoutMs
         };
     });
     return { objective_status: status, assessment: root.assessment, next_tasks, unblocks };
 }
+export function validatePlannerProgress(job, result) {
+    if (result.objective_status !== 'in_progress' || result.next_tasks.length > 0 || result.unblocks.length > 0)
+        return;
+    const previousReviewFinished = job.tasks.some(task => task.agentName === 'reviewer' && task.state === 'SUCCEEDED');
+    if (previousReviewFinished)
+        return;
+    const liveWork = job.tasks.some(task => task.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(task.state));
+    if (liveWork)
+        return;
+    throw new Error('Planner returned in_progress with no executable tasks or unblocks while no live work remains; return satisfied when only Relay-owned review/merge/completion effects remain');
+}
+export function validatePlannerLifecycleOwnership(job, specs) {
+    if (job.prNumber !== 0 || !job.localMerge)
+        return;
+    for (const spec of specs) {
+        // Restrict ownership detection to an individual imperative clause. A long
+        // implementation brief may describe Relay-owned completion as context.
+        const clauses = spec.input.toLowerCase().split(/[.!?\n]+/);
+        for (const clause of clauses) {
+            if (/\b(?:relay|graph|orchestrator)\s+(?:must|will|should|owns?)\b/.test(clause))
+                continue;
+            const localMerge = /\blocal[ -]merge\b|\blocal merge\b/.test(clause);
+            const jobCompletion = /\bjob\b.{0,80}\bcompleted\b|\bcompleted\b.{0,80}\bjob\b/.test(clause);
+            const externalMerge = /\b(?:external|github|projected)\b.{0,80}\bpr\b.{0,80}\bmerged\b|\bpr\b.{0,80}\bmerged\b/.test(clause);
+            const ownsLifecycle = /^\s*(?:perform|execute|complete|trigger|drive|merge|transition|finish|finalize)\b/.test(clause);
+            if (ownsLifecycle && [localMerge, jobCompletion, externalMerge].filter(Boolean).length >= 2) {
+                throw new Error(`Planner next task ${spec.id} attempts to own Graph lifecycle delivery; local merge, Job COMPLETED, and projected PR merge are Relay-owned effects and must not be worker Tasks`);
+            }
+        }
+    }
+}
 export function validatePlannerHierarchy(existing, specs) {
     const existingById = new Map(existing.map(task => [task.id, task]));
     const specsById = new Map(specs.map(spec => [spec.id, spec]));

package/dist/pool.js

@@ -4,6 +4,7 @@ import { runScheduledBucketFromStore } from './scheduled-jobs.js';
 import { scheduleBucket } from './scheduler.js';
 import { ReconcileCoordinator } from './reconcile-coordinator.js';
 import { errorMessage, observability, withObservabilityCorrelation } from './observability.js';
+import { jobHasActiveExecution } from './job-execution-slot.js';
 const RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareJobPriority(a, b) { return RANK[a.priority ?? 'P2'] - RANK[b.priority ?? 'P2'] || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export function runnableManagedJobs(items) { return items.filter(item => item.job.state === 'ACTIVE').map(item => item.job).sort(compareJobPriority); }
@@ -31,6 +32,7 @@ export class RepositoryWorkerPool {
     reconcileLocks = new Map();
     coordinator;
     scheduleSignalCoordinator;
+    dispatchTail = Promise.resolve();
     watchedBus;
     constructor(concurrency, makeReconciler, localInventory, resolveLocalJob) {
         this.concurrency = concurrency;
@@ -57,6 +59,18 @@ export class RepositoryWorkerPool {
             throw new Error('Authoritative SQLite Job is not registered: ' + jobId);
         return resolved.store;
     }
+    async withDispatchGate(work) {
+        const previous = this.dispatchTail;
+        let release;
+        this.dispatchTail = new Promise(resolve => { release = resolve; });
+        await previous;
+        try {
+            await work();
+        }
+        finally {
+            release();
+        }
+    }
     async reconcileExclusive(jobId, work) {
         while (this.reconcileLocks.has(jobId))
             await this.reconcileLocks.get(jobId);
@@ -98,9 +112,11 @@ export class RepositoryWorkerPool {
         const target = await this.localTarget(jobId);
         if (!target)
             throw new Error('Local job not found: ' + jobId);
-        const reconciler = this.makeReconciler(target.store, Math.max(1, this.concurrency));
-        await this.reconcileExclusive(jobId, async () => {
-            await withObservabilityCorrelation({ jobId, repository: target.job.repository }, () => reconciler.reconcile(jobId));
+        await this.withDispatchGate(async () => {
+            await this.reconcileExclusive(jobId, async () => {
+                await withObservabilityCorrelation({ jobId, repository: target.job.repository }, () => this.makeReconciler(target.store, 0).reconcile(jobId));
+            });
+            await this.reconcileDiscovered(await this.localInventory());
         });
         void reason;
     }
@@ -125,7 +141,7 @@ export class RepositoryWorkerPool {
     }
     async reconcileDiscovered(discovered) {
         const jobs = runnableManagedJobs(discovered);
-        let capacity = Math.max(1, this.concurrency);
+        let capacity = Math.max(0, this.concurrency - jobs.filter(job => jobHasActiveExecution(job)).length);
         for (const job of jobs) {
             if (capacity <= 0)
                 break;
@@ -170,7 +186,7 @@ export class RepositoryWorkerPool {
         try {
             do {
                 this.pending = false;
-                await this.reconcileDiscovered(await this.localInventory());
+                await this.withDispatchGate(async () => this.reconcileDiscovered(await this.localInventory()));
             } while (this.pending);
         }
         finally {
@@ -200,7 +216,7 @@ export class RepositoryWorkerPool {
             // GitHub transport is observational. It must never wake lifecycle execution.
             if (event.type === 'github.webhook')
                 return;
-            const wake = event.type === 'job.wake' || event.type === 'review.created';
+            const wake = event.type === 'job.wake' || event.type === 'review.created' || event.type === 'planner.completed';
             if (!lifecycle && !wake)
                 return;
             await this.coordinator.acceptTransport({

package/dist/reconciler-cancellation.js

@@ -0,0 +1,21 @@
+import { applyTaskCancelAction } from './task-actions.js';
+export async function cancelActiveTasks(store, jobId, reason, cancelPlanner, cancelExecutionGeneration) {
+    const job = await store.load(jobId);
+    for (const plan of (job.plans ?? []).filter(item => item.status === 'PLANNING')) {
+        cancelPlanner(plan.id);
+        plan.status = 'FAILED';
+        plan.error = reason;
+        plan.assessment = `Planning failed: ${reason}`;
+        plan.leaseOwner = null;
+        plan.leaseExpiresAt = null;
+        plan.executionId = null;
+        plan.updatedAt = new Date().toISOString();
+        await store.savePlan(plan);
+    }
+    for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
+        cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
+        cancelPlanner(task.id);
+        await applyTaskCancelAction(task, reason);
+        await store.saveTask(task);
+    }
+}

package/dist/reconciler-review.js

@@ -6,9 +6,11 @@ import { workerCandidates } from './worker-routing.js';
 import { routeExecution } from './execution-routing.js';
 import { ReconcilerRuntimeBase } from './reconciler-runtime.js';
 import { dispatchReviewLifecycle, reviewOutcome } from './workflow/review-v2.js';
+import { dispatchTaskLifecycleSync } from './workflow/lifecycle.js';
 import { createTaskEntity } from './workflow/entity-creation.js';
 import { localSourceHead, localWorkingHead } from './local-git-merge.js';
 import { chatgptThreadRequirements, resolveReviewerThreadDestination } from './reviewer-thread.js';
+import { reviewGenerationMatches } from './review-generation-fence.js';
 export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
     async currentHeadSha(job) {
         // GitHub PR head facts are audit-only. Source identity is local Git.
@@ -118,8 +120,12 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         }
         throw new Error('Too many final review rounds for ' + headSha);
     }
+    externalReviewPrNumber(job) {
+        return job.externalPrNumber && job.externalPrNumber > 0 ? job.externalPrNumber : job.prNumber;
+    }
     async createFinalReviewTask(job, headSha) {
         const id = this.nextFinalReviewTaskId(job, headSha);
+        const reviewPrNumber = this.externalReviewPrNumber(job);
         const now = new Date().toISOString();
         const reviewGateTasks = implementationTasks(job);
         const reviewThread = resolveReviewerThreadDestination(job, this.options.reviewer?.threadId);
@@ -130,13 +136,13 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             threadSource: reviewThread.source,
             requestId: `${job.id}:${id}:${headSha}`,
             jobId: job.id,
-            prNumber: job.prNumber,
+            prNumber: reviewPrNumber,
             reviewHeadSha: headSha,
             projectId: reviewerRouting.candidate.routing.projectId ?? null,
         } : undefined;
         const input = [
             `Job ID: ${job.id}`,
-            `Review PR #${job.prNumber} at exactly head SHA ${headSha}.`,
+            `Review PR #${reviewPrNumber} at exactly head SHA ${headSha}.`,
             `Review head SHA: ${headSha}`,
             'Job objective: ' + (job.objective ?? job.description ?? job.title),
             'Use the selected reviewer agent contract as the authoritative review protocol.',
@@ -247,7 +253,7 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 id: job.id, title: job.title, objective: job.objective ?? null,
                 description: job.description ?? null, priority: job.priority ?? null,
                 executionMode: job.executionMode, repository: job.repository,
-                prNumber: job.prNumber, state: job.state,
+                prNumber: this.externalReviewPrNumber(job), state: job.state,
             },
             task: {
                 id: task.id, kind: task.kind ?? 'work', storySize: task.storySize ?? 'M',
@@ -264,9 +270,11 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
             ? 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
+        const parentExcludedRoutes = parentRouteFailedBeforeStart && parent?.routing
             ? [{ provider: parent.routing.provider, model: parent.routing.model, profile: parent.routing.profile }]
             : [];
+        const taskExcludedRoutes = (task.routingExclusions ?? []).map(item => ({ provider: item.provider, model: item.model, profile: item.profile }));
+        const excludedRoutes = [...taskExcludedRoutes, ...parentExcludedRoutes];
         const routed = await routeExecution(candidates, requirements, {
             decisionEngine: this.options.decisionEngine,
             decisionMode: this.options.decisionMode,
@@ -307,19 +315,23 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         // 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);
+        const taskDecision = this.store.mutateJob
+            ? dispatchTaskLifecycleSync(structuredClone(task), event.type)
+            : tryTransitionTaskEvent(task, event.type);
         if (!taskDecision.accepted || !taskDecision.target)
             return { applied: false, reconcile: false, reason: event.type + '.ignored' };
-        task.error = null;
-        if (taskDecision.target !== 'RUNNING') {
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
+        if (!this.store.mutateJob && taskDecision.target !== 'RUNNING' && !this.finalizeReviewExecution(job.id, task, event)) {
+            return { applied: false, reconcile: false, reason: event.type + '.stale-execution' };
+        }
+        if (!this.store.mutateJob) {
+            task.error = null;
+            if (taskDecision.target !== 'RUNNING')
+                task.result = { summary: event.message || `Review ${event.type}`, data: event.data ?? {} };
+            await this.store.saveTask(task);
         }
-        await this.store.saveTask(task);
         let needsReconcile = false;
+        let pendingFixTask = null;
         const reviewDecision = await dispatchReviewLifecycle(job.review?.outcome, event.type, { autoMerge: job.autoMerge !== false }, async (actionId) => {
             if (actionId === 'review.createFix') {
                 needsReconcile = true;
@@ -329,10 +341,9 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
                 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 input = 'Address all reviewer findings for PR #' + this.externalReviewPrNumber(job) + ' 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' }));
+                    pendingFixTask = fixTask;
                 }
                 return {};
             }
@@ -352,9 +363,54 @@ export class ReconcilerReviewBase extends ReconcilerRuntimeBase {
         const evidence = { summary: event.message || 'Review ' + outcome, data: {
                 ...(event.data ?? {}), review: { ...(reviewData ?? {}), headSha }, headSha, outcome, source: event.source,
             } };
-        job.review = { outcome, headSha, taskId: task.id, evidence, updatedAt: event.timestamp || new Date().toISOString() };
-        job.updatedAt = job.review.updatedAt;
-        await this.store.saveJob(job);
+        const reviewUpdatedAt = event.timestamp || new Date().toISOString();
+        if (this.store.mutateJob) {
+            let committed = false;
+            let terminalExecutionId = null;
+            const updated = await this.store.mutateJob(job.id, current => {
+                const freshTask = current.tasks.find(item => item.id === task.id);
+                if (!freshTask || !reviewGenerationMatches(current, job, task, headSha))
+                    return current;
+                const freshDecision = tryTransitionTaskEvent(freshTask, event.type);
+                if (!freshDecision.accepted || !freshDecision.target)
+                    return current;
+                if (freshDecision.target !== 'RUNNING') {
+                    if (!this.finalizeReviewExecution(job.id, freshTask, event, false))
+                        return current;
+                    terminalExecutionId = freshTask.executionId;
+                }
+                freshTask.error = null;
+                if (freshDecision.target !== 'RUNNING')
+                    freshTask.result = { summary: event.message || `Review ${event.type}`, data: event.data ?? {} };
+                if (pendingFixTask && !current.tasks.some(item => item.id === pendingFixTask.id))
+                    current.tasks.push(structuredClone(pendingFixTask));
+                current.review = { outcome, headSha, taskId: freshTask.id, evidence, updatedAt: reviewUpdatedAt };
+                current.updatedAt = reviewUpdatedAt;
+                committed = true;
+                return current;
+            });
+            if (!committed)
+                return { applied: false, reconcile: false, reason: event.type + '.stale-execution' };
+            Object.assign(job, structuredClone(updated));
+            // Live waiter cleanup/terminal claims are irreversible; run after commit.
+            if (terminalExecutionId) {
+                this.finalizeReviewExecution(job.id, { ...task, executionId: terminalExecutionId }, event);
+            }
+            const committedFixTask = pendingFixTask;
+            if (committedFixTask)
+                await this.emit(eventFor(job.id, committedFixTask.id, task.id, 'review.fix_task_created', 'queued', 'Created one fix task ' + committedFixTask.id + ' for reviewer findings', 'orchestrator', { headSha }, { agent: 'relay', component: 'agents-relay' }));
+        }
+        else {
+            const legacyFixTask = pendingFixTask;
+            if (legacyFixTask) {
+                await this.store.appendTask(legacyFixTask);
+                await this.emit(eventFor(job.id, legacyFixTask.id, task.id, 'review.fix_task_created', 'queued', 'Created one fix task ' + legacyFixTask.id + ' for reviewer findings', 'orchestrator', { headSha }, { agent: 'relay', component: 'agents-relay' }));
+            }
+            job.review = { outcome, headSha, taskId: task.id, evidence, updatedAt: reviewUpdatedAt };
+            job.updatedAt = reviewUpdatedAt;
+            await this.store.saveTask(task);
+            await this.store.saveJob(job);
+        }
         // Review approval records evidence only. The subsequent Graph reconcile
         // drives durable local Git merge delivery and terminalization.
         if (outcome === 'approved')