agents-relay 1.0.177 → 2.0.1

package/dist/reconciler.js

@@ -1,24 +1,26 @@
 import { randomUUID } from 'node:crypto';
-import { storySizeTimeoutMs, taskOverallTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
+import { storySizeTimeoutMs, chatGptStartAckTimeoutMs } from './types.js';
 import { dependencyReady, schedule, transitionJobEvent, transitionTaskEvent } from './scheduler.js';
-import { implementationComplete } from './runtime-status.js';
+import { applyTaskCancelAction } from './task-actions.js';
 import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
-import { createPlannerRoundTask, pendingPlanForPlannerTask, recoverPendingPlannerTask, parsePlannerResult, plannerInput, validatePlannerHierarchy } from './planner.js';
+import { createPlanRound, materializePlannerChild, pendingPlan } from './planner.js';
+import { dispatchPlannerOrchestration, plannerOrchestrationFacts } from './workflow/planner-orchestration-v2.js';
 import { agentContractPrompt, executionContextPrompt, resolveExecutionContext } from './execution-context.js';
-import { agentGraphPrompt, validateAgentSelection } from './agent-graph.js';
+import { agentGraphPrompt } from './agent-graph.js';
 import { ReconcilerReviewBase } from './reconciler-review.js';
 import { executeManualPlan } from './manual-plan.js';
-import { executionEventSource } from './reconciler-runtime.js';
+import { executionEventSource, withExecutionBoundary } from './reconciler-runtime.js';
 export { executionEventSource } from './reconciler-runtime.js';
 import { CallbackWorkflowEffectHandler } from './workflow/effects.js';
 import { applyHistoricalJobCompatibilityRepair } from './workflow/runtime.js';
 import { pendingTroubleshooterTasks } from './troubleshooter.js';
 import { prepareManagedExecutionWorktree } from './workspace.js';
 import { createReviewChairExecutionPlan } from './review-chair.js';
-import { samePlannerChildDefinition } from './planner-child.js';
-import { isEffectivelyBlocked } from './unblock.js';
 import { taskTagWorkerPrompt } from './task-tag.js';
+import { recoverExpiredExecutions, recoverStartupOrphans as recoverStartupExecutionOrphans } from './execution-recovery.js';
+import { dispatchJobReconcile } from './workflow/job-reconcile-v2.js';
+import { launchPlanExecution } from './planner-runtime.js';
 const PRIORITY_RANK = { P0: 0, P1: 1, P2: 2, P3: 3 };
 export function compareTaskPriority(a, b, jobPriority = 'P2') { const ar = PRIORITY_RANK[a.priority ?? jobPriority]; const br = PRIORITY_RANK[b.priority ?? jobPriority]; return ar - br || a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id); }
 export async function managedWorkerInput(job, task, context) {
@@ -78,7 +80,6 @@ The ChatGPT/Codex conversation or process exit is never the task result.
 Before your final return, verify that a terminal event for this exact Job/Task was published.
 If no terminal event has been published, publish task.failed before exiting.`;
 }
-const taskLaunchClaims = new Set();
 export class Reconciler extends ReconcilerReviewBase {
     constructor(store, options) {
         super(store, options);
@@ -87,9 +88,7 @@ export class Reconciler extends ReconcilerReviewBase {
             const task = context.taskId ? job.tasks.find(item => item.id === context.taskId) : undefined;
             if (!task || task.state !== 'QUEUED' || task.executionId !== null)
                 return;
-            if (task.kind === 'planner')
-                await this.launchPlanner(job, task);
-            else if (task.adapter !== 'orchestrator')
+            if (task.kind !== 'planner' && task.adapter !== 'orchestrator')
                 await this.launch(job, task);
         }, context => `effect.launchTask:${context.jobId}:${context.taskId ?? 'task'}:${String(context.data?.attempt ?? 0)}`));
         this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.cancelActiveTasks', async (context) => this.cancelActiveTasks(context.jobId, String(context.data?.reason ?? 'Job terminated'))));
@@ -111,6 +110,7 @@ export class Reconciler extends ReconcilerReviewBase {
             const headSha = prState === 'OPEN' ? await this.currentHeadSha(job) : null;
             if (headSha && job.headSha !== headSha) {
                 job.headSha = headSha;
+                job.updatedAt = new Date().toISOString();
                 await this.store.saveJob(job);
             }
             await this.invalidateStaleReview(job, headSha);
@@ -127,10 +127,10 @@ export class Reconciler extends ReconcilerReviewBase {
                         await this.applyJobEffectOutcomes(job, outcomes);
                     }
                     else {
-                        const decision = await transitionJobEvent(job, prState === 'MERGED' ? 'pr.merged' : 'pr.closed', prState === 'CLOSED' ? { notMerged: true } : {});
-                        await this.store.saveJob(job);
-                        const outcomes = await this.workflowEffects.execute(decision.effects, { jobId: job.id, transitionKey: `${decision.target}:${prState}`, data: { reason } });
-                        await this.applyJobEffectOutcomes(job, outcomes);
+                        await transitionJobEvent(job, prState === 'MERGED' ? 'pr.merged' : 'pr.closed', prState === 'CLOSED' ? { notMerged: true } : {}, async (actionId) => {
+                            const outcomes = await this.workflowEffects.execute([actionId], { jobId: job.id, transitionKey: `terminal:${prState}`, data: { reason } });
+                            await this.applyJobEffectOutcomes(job, outcomes);
+                        }, async () => { await this.store.saveJob(job); });
                     }
                 }
                 if (prState === 'MERGED' && this.store.resolveBlockerDependents) {
@@ -142,7 +142,7 @@ export class Reconciler extends ReconcilerReviewBase {
             }
             if (job.state !== 'ACTIVE')
                 return job;
-            await this.recoverLostExecutions(job, now);
+            await recoverExpiredExecutions(job, now, this.executionRecoveryPorts(job));
             await this.recoverPlannerChildren(job);
             for (const recovery of pendingTroubleshooterTasks(await this.store.load(jobId))) {
                 await this.store.appendTask(recovery);
@@ -150,7 +150,7 @@ export class Reconciler extends ReconcilerReviewBase {
             }
             for (const task of job.tasks)
                 if (task.state === 'CANCELLED') {
-                    this.live.get(task.id)?.execution.cancel();
+                    this.cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
                     this.plannerLive.get(task.id)?.controller.abort();
                 }
             const beforeSchedule = await this.store.load(jobId);
@@ -181,171 +181,141 @@ export class Reconciler extends ReconcilerReviewBase {
                 const dispatchable = scheduled.tasks
                     .filter(task => task.state === 'QUEUED'
                     && task.executionId === null
-                    && (task.kind === 'planner' || task.adapter !== 'orchestrator')
+                    && task.kind !== 'planner'
+                    && task.adapter !== 'orchestrator'
                     && dependencyReady(task, new Map(scheduled.tasks.map(item => [item.id, item]))))
                     .sort((a, b) => compareTaskPriority(a, b, scheduled.priority ?? 'P2'))
                     .slice(0, capacity);
                 for (const task of dispatchable) {
-                    const decision = await transitionTaskEvent(task, 'dispatch', { dispatchable: true });
-                    await this.store.saveTask(task);
-                    const outcomes = await this.workflowEffects.execute(decision.effects, {
-                        jobId: scheduled.id,
-                        taskId: task.id,
-                        transitionKey: `dispatch:${task.attempt}`,
-                        data: { attempt: task.attempt },
-                    });
-                    await this.applyTaskEffectOutcomes(scheduled, task, outcomes);
+                    await transitionTaskEvent(task, 'dispatch', { dispatchable: true }, async (actionId) => {
+                        const outcomes = await this.workflowEffects.execute([actionId], { jobId: scheduled.id, taskId: task.id, transitionKey: `dispatch:${task.attempt}`, data: { attempt: task.attempt } });
+                        await this.applyTaskEffectOutcomes(scheduled, task, outcomes);
+                    }, async () => { await this.store.saveTask(task); });
                 }
             }
             const finalState = schedule(await this.store.load(jobId));
             if (finalState.updatedAt !== scheduled.updatedAt)
                 await this.store.saveJob(finalState);
             await this.ensureFinalReview(finalState, prState, headSha);
-            if (prState === 'OPEN' && finalState.reviewEnabled === false && implementationComplete(finalState) && finalState.autoMerge !== false && this.store.mergePullRequest && headSha) {
-                const decision = await transitionJobEvent(finalState, 'implementation.completed', { autoMerge: true });
-                await this.store.saveJob(finalState);
-                const outcomes = await this.workflowEffects.execute(decision.effects, { jobId: finalState.id, transitionKey: `implementation.completed:${headSha}`, data: { headSha } });
+            await dispatchJobReconcile(finalState, { prState, headSha, mergeCapable: Boolean(this.store.mergePullRequest) }, async (actionId) => {
+                const outcomes = await this.workflowEffects.execute([actionId], { jobId: finalState.id, transitionKey: `reconcile:${headSha ?? 'no-head'}`, data: { headSha } });
                 await this.applyJobEffectOutcomes(finalState, outcomes);
-                if (outcomes.some(item => item.effect === 'effect.mergePullRequest' && item.status !== 'failed')) {
-                    await this.emit(eventFor(finalState.id, 'job', null, 'job.merged', 'succeeded', 'Completed work requested merge for PR #' + finalState.prNumber, 'user', { headSha, autoMerge: true }, { agent: 'relay', component: 'agents-relay' }));
-                }
-            }
+            }, async () => { await this.store.saveJob(finalState); });
             return this.store.load(jobId);
         }
         finally {
             this.reconciling = false;
         }
     }
-    async recoverStartupOrphans(jobId) { const job = await this.store.load(jobId); if (job.state === 'ACTIVE' && (await this.store.pullRequestState?.() ?? 'OPEN') === 'OPEN')
-        await this.recoverOrphanedLocalExecutions(job); return this.store.load(jobId); }
     async cancelActiveTasks(jobId, reason) {
         const job = await this.store.load(jobId);
-        for (const task of job.tasks.filter(item => !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(item.state))) {
-            this.live.get(task.id)?.execution.cancel();
+        for (const plan of (job.plans ?? []).filter(item => item.status === 'PLANNING')) {
+            const live = this.plannerLive.get(plan.id);
+            if (live) {
+                clearTimeout(live.timer);
+                live.controller.abort();
+                this.plannerLive.delete(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 this.store.savePlan(plan);
+        }
+        for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
+            this.cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
             this.plannerLive.get(task.id)?.controller.abort();
-            await transitionTaskEvent(task, task.state === 'RUNNING' ? 'task.cancelled' : 'cancel');
-            task.error = reason;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
+            await applyTaskCancelAction(task, reason);
             await this.store.saveTask(task);
         }
     }
-    async recoverLostExecutions(job, now) {
-        const candidates = job.tasks.filter(item => item.state === 'RUNNING' || (item.state === 'QUEUED' && item.executionId !== null));
-        for (const staleTask of candidates) {
-            if (staleTask.leaseExpiresAt === null || new Date(staleTask.leaseExpiresAt).getTime() > now)
-                continue;
-            // Re-read durable state before applying lease recovery: another reconciler may have accepted a terminal event or launched a newer execution.
-            const task = (await this.store.load(job.id)).tasks.find(item => item.id === staleTask.id);
-            if (!task)
-                continue;
-            const sameGeneration = task.executionId === staleTask.executionId && task.leaseOwner === staleTask.leaseOwner && task.leaseExpiresAt === staleTask.leaseExpiresAt;
-            const recoverable = task.state === 'RUNNING' || (task.state === 'QUEUED' && task.executionId !== null);
-            if (!sameGeneration || !recoverable || task.leaseExpiresAt === null || new Date(task.leaseExpiresAt).getTime() > now)
-                continue;
-            this.live.get(task.id)?.execution.cancel();
-            const planner = this.plannerLive.get(task.id);
-            if (planner) {
+    executionRecoveryPorts(job) {
+        return {
+            store: this.store,
+            owner: this.options.owner,
+            cancelGeneration: task => { this.cancelExecutionGeneration(job.id, task.id, task.executionId); },
+            cancelPlanner: taskId => { const planner = this.plannerLive.get(taskId); if (planner) {
                 clearTimeout(planner.timer);
                 planner.controller.abort();
-                this.plannerLive.delete(task.id);
-            }
-            await transitionTaskEvent(task, task.state === 'RUNNING' ? 'task.failed' : 'fail');
-            task.error = 'Lease expired';
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
-            if (task.attempt < task.maxAttempts) {
-                await transitionTaskEvent(task, 'retry');
-                await this.store.saveTask(task);
-                continue;
-            }
-            task.error += ' after maximum attempts';
-            await this.store.saveTask(task);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.failed', 'failed', task.error, 'user', { reason: 'lease_expired' }));
-        }
+                this.plannerLive.delete(taskId);
+            } },
+            emitFailed: async (task, reason) => { await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.failed', 'failed', task.error ?? reason, 'user', { reason })); },
+        };
     }
-    async recoverOrphanedLocalExecutions(job) {
-        for (const stale of job.tasks.filter(t => t.state === 'RUNNING' && t.executionId && t.leaseOwner && t.leaseOwner !== this.options.owner && t.adapter !== 'chatgpt')) {
-            const task = (await this.store.load(job.id)).tasks.find(t => t.id === stale.id);
-            if (!task || task.state !== 'RUNNING' || task.executionId !== stale.executionId || task.leaseOwner !== stale.leaseOwner || task.leaseExpiresAt !== stale.leaseExpiresAt || task.adapter === 'chatgpt' || task.leaseOwner === this.options.owner)
-                continue;
-            await transitionTaskEvent(task, 'task.failed');
-            task.error = 'Orphaned after relayd restart';
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
-            if (task.attempt < task.maxAttempts) {
-                await transitionTaskEvent(task, 'retry');
-                await this.store.saveTask(task);
-                continue;
-            }
-            task.error += ' after maximum attempts';
-            await this.store.saveTask(task);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'task.failed', 'failed', task.error, 'user', { reason: 'startup_orphaned' }));
+    async recoverLostExecutions(job, now) { await recoverExpiredExecutions(job, now, this.executionRecoveryPorts(job)); }
+    async recoverStartupOrphans(jobId) {
+        const job = await this.store.load(jobId);
+        if (job.state === 'ACTIVE' && (await this.store.pullRequestState?.() ?? 'OPEN') === 'OPEN') {
+            await recoverStartupExecutionOrphans(job, this.executionRecoveryPorts(job));
         }
+        return this.store.load(jobId);
     }
     async planJob(jobId, guidance) {
-        return executeManualPlan(this.store, jobId, guidance, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), (job, task) => this.launchPlanner(job, task));
+        return executeManualPlan(this.store, jobId, guidance, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'), (job, plan) => this.launchPlanner(job, plan));
     }
     async maybeCreatePlanner(job) {
-        if (job.executionMode !== 'autonomous')
-            return job;
-        if (job.initialPlanning?.status === 'pending')
-            return job;
-        const recovered = recoverPendingPlannerTask(job, this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M'));
-        if (recovered) {
-            await this.store.appendTask(recovered);
-            await this.emit(eventFor(job.id, recovered.id, null, 'planner.created', 'queued', `Recovered pending Plan ${recovered.id}`, 'orchestrator'));
-            return this.store.load(job.id);
-        }
-        const allPlanners = job.tasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-        if (allPlanners.length === 0 && job.tasks.length === 0)
-            return job;
-        const slot = job.schedule?.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
-        const scopedTasks = Number.isFinite(slot) ? job.tasks.filter(task => Date.parse(task.createdAt) >= slot) : job.tasks;
-        const planners = scopedTasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-        if (planners.some(task => ['DRAFT', 'QUEUED', 'RUNNING', 'FAILED'].includes(task.state)))
-            return job;
-        if (scopedTasks.some(isEffectivelyBlocked))
-            return job;
-        if (scopedTasks.some(task => task.kind !== 'planner' && ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)))
-            return job;
-        if (planners.length > 0 && planners.at(-1)?.plannerResult?.objective_status === 'in_progress' && !job.tasks.some(task => task.planningDecisionId === planners.at(-1)?.id))
-            return job;
-        const latest = planners.at(-1);
-        if (latest?.plannerResult?.objective_status === 'satisfied')
+        const pending = pendingPlan(job);
+        const recoverable = pending && !this.plannerLive.has(pending.id)
+            && (!pending.executionId || pending.leaseOwner !== this.options.owner || !pending.leaseExpiresAt || Date.parse(pending.leaseExpiresAt) <= (this.options.now ?? new Date()).getTime())
+            ? pending : null;
+        let changed = false;
+        const decision = await dispatchPlannerOrchestration(plannerOrchestrationFacts(job, Boolean(recoverable)), async (actionId) => {
+            if (actionId === 'planner.recoverPending') {
+                if (!recoverable)
+                    throw new Error('Planner graph requested pending recovery without a recoverable Plan');
+                await this.launchPlanner(job, recoverable);
+                changed = true;
+                return {};
+            }
+            if (actionId === 'planner.createRound') {
+                const plan = createPlanRound(job, { timeoutMs: this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M') });
+                await this.store.appendPlan(plan);
+                await this.emit(eventFor(job.id, plan.id, null, 'planner.created', 'queued', 'Plan ' + plan.id + ' created', 'orchestrator'));
+                await this.launchPlanner(await this.store.load(job.id), plan);
+                changed = true;
+                return {};
+            }
+            throw new Error('Unsupported planner orchestration action ' + actionId);
+        });
+        if (!decision.accepted || !changed)
             return job;
-        const task = createPlannerRoundTask(job, { timeoutMs: this.options.plannerTimeoutMs ?? storySizeTimeoutMs('M') });
-        await this.store.appendPlan(pendingPlanForPlannerTask(job, task));
-        await this.store.appendTask(task);
-        await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.created', 'queued', `Planner task ${task.id} created`, 'orchestrator'));
         return this.store.load(job.id);
     }
     async recoverPlannerChildren(job) {
+        for (const plan of (job.plans ?? []).filter(item => item.status === 'SUCCEEDED' && item.plannerResult)) {
+            const executionContext = await this.plannerContext(job, plan);
+            const children = plan.plannerResult.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
+            for (const child of children) {
+                const existing = job.tasks.find(item => item.id === child.id);
+                if (existing)
+                    continue;
+                await this.store.appendTask(child);
+                job.tasks.push(child);
+            }
+        }
+        // Legacy read compatibility: migrate historical successful planner Tasks into first-class Plans.
         const contextTask = job.tasks.find(task => task.kind === 'planner') ?? job.tasks[0];
         if (!contextTask)
             return;
         const executionContext = await this.plannerContext(job, contextTask);
         for (const planner of job.tasks.filter(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult)) {
             const result = planner.plannerResult;
-            const plan = { jobId: job.id, id: planner.id, round: planner.planningRound ?? 1, source: planner.planningSource ?? 'model-planner', previousPlanId: planner.previousPlannerTaskId ?? null, trigger: planner.planTrigger ?? { source: 'continuation' }, status: 'SUCCEEDED', guidance: planner.plannerGuidance, objectiveStatus: result.objective_status, assessment: result.assessment, generatedTaskIds: result.next_tasks.map(item => item.id), headSha: planner.planTrigger?.currentHeadSha ?? job.headSha, createdAt: planner.createdAt, updatedAt: planner.updatedAt };
+            const plan = { jobId: job.id, id: planner.id, round: planner.planningRound ?? 1, source: planner.planningSource ?? 'model-planner', previousPlanId: planner.previousPlannerTaskId ?? null, trigger: planner.planTrigger ?? { source: 'continuation' }, status: 'SUCCEEDED', guidance: planner.plannerGuidance, objectiveStatus: result.objective_status, plannerResult: result, assessment: result.assessment, generatedTaskIds: result.next_tasks.map(item => item.id), headSha: planner.planTrigger?.currentHeadSha ?? job.headSha, attempt: planner.attempt, maxAttempts: planner.maxAttempts, leaseOwner: null, leaseExpiresAt: null, executionId: null, timeoutMs: planner.timeoutMs, manualPlanning: planner.manualPlanning, createdAt: planner.createdAt, updatedAt: planner.updatedAt };
             if (!(job.plans ?? []).some(item => item.id === plan.id)) {
                 await this.store.appendPlan(plan);
                 (job.plans ??= []).push(plan);
             }
             else
-                await this.store.savePlan(plan);
-            const children = result.next_tasks.map(spec => this.plannerChild(job, planner, spec, executionContext));
-            for (const child of children) {
-                const existing = job.tasks.find(item => item.id === child.id);
-                if (existing) {
-                    continue;
+                continue;
+            const children = result.next_tasks.map(spec => materializePlannerChild(job, plan, spec, executionContext));
+            for (const child of children)
+                if (!job.tasks.some(item => item.id === child.id)) {
+                    await this.store.appendTask(child);
+                    job.tasks.push(child);
                 }
-                await this.store.appendTask(child);
-                job.tasks.push(child);
-            }
         }
     }
     async resolvedContext(job, task, role, projectPathOverride) {
@@ -356,16 +326,21 @@ export class Reconciler extends ReconcilerReviewBase {
             runtimes: this.options.adapters.map(adapter => ({ name: adapter.name, id: adapter.id, capabilities: [...adapter.capabilities] })),
         });
     }
-    async plannerContext(job, task) {
-        let projectPath = this.options.projectPathForJob ? await this.options.projectPathForJob(job) : task.routing?.cwd ?? process.cwd();
+    async plannerContext(job, planning) {
+        const routingCwd = 'routing' in planning ? planning.routing?.cwd : undefined;
+        let projectPath = this.options.projectPathForJob ? await this.options.projectPathForJob(job) : routingCwd ?? process.cwd();
         if (this.store.pullRequestHead) {
             const head = await this.store.pullRequestHead();
             if (!head)
                 throw new Error(`PR #${job.prNumber} has no resolvable head ref`);
-            const key = `planner-${task.id}-${head.sha.slice(0, 12)}`;
+            const key = `planner-${planning.id}-${head.sha.slice(0, 12)}`;
             projectPath = await prepareManagedExecutionWorktree(projectPath, job.repository, job.prNumber, head, key);
         }
-        return this.resolvedContext(job, task, 'planner', projectPath);
+        return resolveExecutionContext(projectPath, 'planner', {
+            ...(this.options.executionContextRoots ?? {}),
+            registeredAgents: await this.store.listAgents(),
+            runtimes: this.options.adapters.map(adapter => ({ name: adapter.name, id: adapter.id, capabilities: [...adapter.capabilities] })),
+        });
     }
     async launch(job, task) {
         const adapter = this.options.adapters.find(x => x.name === task.adapter);
@@ -381,30 +356,27 @@ export class Reconciler extends ReconcilerReviewBase {
             await this.store.saveTask(task);
             return;
         }
-        const claimKey = `${job.repository}#${job.prNumber}:${task.id}`;
-        if (taskLaunchClaims.has(claimKey))
-            return;
-        taskLaunchClaims.add(claimKey);
-        let claimedTask = null;
-        try {
+        const claimedTask = await withExecutionBoundary(job.id, task.id, async () => {
             const freshJob = await this.store.load(job.id);
             const freshTask = freshJob.tasks.find(item => item.id === task.id);
             if (!freshTask || freshTask.state !== 'QUEUED' || !dependencyReady(freshTask, new Map(freshJob.tasks.map(item => [item.id, item]))))
                 return;
-            const leaseMs = Math.max(this.options.leaseMs ?? 300000, freshTask.timeoutMs);
-            const startedAt = (this.options.now ?? new Date()).getTime();
             if (freshTask.executionId !== null)
                 return;
+            const leaseMs = Math.max(this.options.leaseMs ?? 300000, freshTask.timeoutMs);
+            const startedAt = (this.options.now ?? new Date()).getTime();
             freshTask.attempt += 1;
             freshTask.leaseOwner = this.options.owner;
             freshTask.leaseExpiresAt = new Date(startedAt + leaseMs).toISOString();
             freshTask.executionId = randomUUID();
+            freshTask.executionHistory = [...(freshTask.executionHistory ?? []), {
+                    id: freshTask.executionId,
+                    attempt: freshTask.attempt,
+                    startedAt: new Date(startedAt).toISOString(),
+                }].slice(-8);
             await this.store.saveTask(freshTask);
-            claimedTask = freshTask;
-        }
-        finally {
-            taskLaunchClaims.delete(claimKey);
-        }
+            return freshTask;
+        }) ?? null;
         if (!claimedTask)
             return;
         task = claimedTask;
@@ -474,135 +446,15 @@ export class Reconciler extends ReconcilerReviewBase {
                 ? this.failLaunch(job.id, task.id, durableExecutionId, error.message, 'delivery')
                 : this.runtimeSettled(job.id, task.id, durableExecutionId, null, error instanceof Error ? error.message : String(error))), job.id, task.id, 'worker runtime completion');
     }
-    async launchPlanner(job, task) {
-        const planner = this.options.planner;
-        if (!planner) {
-            task.attempt = task.maxAttempts;
-            task.error = 'No objective planner configured';
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.failed', 'failed', `Planner ${task.id}: ${task.error}`, 'user'));
-            return;
-        }
-        const startedAt = (this.options.now ?? new Date()).getTime();
-        await transitionTaskEvent(task, 'task.started');
-        task.attempt += 1;
-        task.leaseOwner = this.options.owner;
-        task.leaseExpiresAt = new Date(startedAt + Math.max(this.options.leaseMs ?? 300000, task.timeoutMs)).toISOString();
-        task.executionId = randomUUID();
-        await this.store.saveTask(task);
-        await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.started', 'running', `Planner task ${task.id} started`, 'orchestrator'));
-        const controller = new AbortController();
-        const executionId = task.executionId;
-        const timer = setTimeout(() => controller.abort(), task.timeoutMs);
-        this.plannerLive.set(task.id, { executionId: executionId, controller, timer });
-        let promise;
-        try {
-            const executionContext = await this.plannerContext(job, task);
-            const context = { job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: task.previousPlannerTaskId ?? null, trigger: task.planTrigger, executionContext, retryFeedback: task.plannerRetryFeedback, guidance: task.plannerGuidance };
-            task.input = plannerInput(context);
-            await this.store.saveTask(task);
-            promise = planner.plan(context, controller.signal);
-        }
-        catch (error) {
-            await this.finishPlanner(job.id, task.id, executionId, error instanceof Error ? error : new Error(String(error)));
-            return;
-        }
-        this.detach(promise.then(result => this.finishPlanner(job.id, task.id, executionId, null, result), error => this.finishPlanner(job.id, task.id, executionId, error instanceof Error ? error : new Error(String(error)))), job.id, task.id, 'planner completion');
-    }
-    async finishPlanner(jobId, taskId, executionId, error, raw) {
-        const live = this.plannerLive.get(taskId);
-        if (live?.executionId === executionId) {
-            clearTimeout(live.timer);
-            this.plannerLive.delete(taskId);
-        }
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || (executionId !== null && task.executionId !== executionId))
-            return;
-        if (task.state === 'CANCELLED')
-            return;
-        if (error) {
-            task.plannerRetryFeedback = error.message;
-            task.error = error.message;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
-            await transitionTaskEvent(task, 'task.failed');
-            if (task.attempt < task.maxAttempts)
-                await transitionTaskEvent(task, 'retry');
-            await this.store.saveTask(task);
-            const pending = (job.plans ?? []).find(plan => plan.id === task.id) ?? pendingPlanForPlannerTask(job, task);
-            await this.store.savePlan({ ...pending, status: task.state === 'FAILED' ? 'FAILED' : 'PLANNING', error: error.message, assessment: task.state === 'FAILED' ? `Planning failed: ${error.message}` : `Planning retry: ${error.message}`, updatedAt: new Date().toISOString() });
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, task.state === 'FAILED' ? 'planner.failed' : 'planner.retry', task.state === 'FAILED' ? 'failed' : 'queued', `Planner ${task.id}: ${error.message}`, 'user'));
-            this.detach(this.reconcile(jobId), jobId, task.id, 'planner retry reconciliation');
-            return;
-        }
-        try {
-            const result = parsePlannerResult(raw);
-            const executionContext = await this.plannerContext(job, task);
-            validatePlannerHierarchy(job.tasks, result.next_tasks);
-            if (result.unblocks.length > 0 && !this.store.registerBlockerDependent)
-                throw new Error('Durable store does not support Planner cross-Job unblock registration');
-            for (const unblock of result.unblocks)
-                await this.store.registerBlockerDependent?.(job.id, unblock);
-            const children = result.next_tasks.map(spec => this.plannerChild(job, task, spec, executionContext));
-            for (const child of children) {
-                const existing = job.tasks.find(item => item.id === child.id);
-                if (existing && !samePlannerChildDefinition(existing, child))
-                    throw new Error(`Planner child ${child.id} already exists with a different definition`);
-            }
-            // Persist the first-class Plan decision before exposing executable child Task comments.
-            const now = new Date().toISOString();
-            const plan = { jobId: job.id, id: task.id, round: task.planningRound ?? 1, source: task.planningSource ?? 'model-planner', previousPlanId: task.previousPlannerTaskId ?? null, trigger: task.planTrigger ?? { source: task.manualPlanning ? 'manual' : 'continuation' }, status: 'SUCCEEDED', guidance: task.plannerGuidance, objectiveStatus: result.objective_status, assessment: result.assessment, generatedTaskIds: result.next_tasks.map(item => item.id), headSha: task.planTrigger?.currentHeadSha ?? await this.store.headSha?.() ?? job.headSha, createdAt: task.createdAt, updatedAt: now };
-            await this.store.savePlan(plan);
-            if (job.changeCycle && !job.changeCycle.consumedByPlannerTaskId && plan.trigger.source === 'unblock') {
-                job.changeCycle.consumedByPlannerTaskId = task.id;
-                job.updatedAt = now;
-                await this.store.saveJob(job);
-            }
-            task.plannerResult = result;
-            task.result = { summary: result.assessment, data: { objective_status: result.objective_status, next_tasks: result.next_tasks, unblocks: result.unblocks } };
-            task.error = null;
-            task.plannerRetryFeedback = undefined;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
-            await transitionTaskEvent(task, 'task.completed');
-            await this.store.saveTask(task);
-            for (const child of children)
-                if (!job.tasks.some(item => item.id === child.id))
-                    await this.store.appendTask(child);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.completed', 'succeeded', `Planner ${task.id} completed: ${result.objective_status}`, 'orchestrator', { objective_status: result.objective_status }));
-        }
-        catch (caught) {
-            const message = caught instanceof Error ? caught.message : String(caught);
-            if (task.state === 'SUCCEEDED') {
-                task.error = `Child materialization failed: ${message}`;
-                await this.store.saveTask(task);
-                await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'planner.children_failed', 'failed', `Planner ${task.id} child materialization failed: ${message}`, 'user'));
-            }
-            else {
-                task.plannerRetryFeedback = message;
-                task.error = message;
-                task.leaseOwner = null;
-                task.leaseExpiresAt = null;
-                task.executionId = null;
-                await transitionTaskEvent(task, 'task.failed');
-                if (task.attempt < task.maxAttempts)
-                    await transitionTaskEvent(task, 'retry');
-                await this.store.saveTask(task);
-                await this.emit(eventFor(job.id, task.id, task.parentTaskId, task.state === 'FAILED' ? 'planner.failed' : 'planner.retry', task.state === 'FAILED' ? 'failed' : 'queued', `Planner ${task.id}: ${message}`, 'user'));
-            }
-            const pending = (await this.store.load(job.id)).plans?.find(plan => plan.id === task.id) ?? pendingPlanForPlannerTask(job, task);
-            await this.store.savePlan({ ...pending, status: task.state === 'QUEUED' ? 'PLANNING' : 'FAILED', error: message, assessment: task.state === 'QUEUED' ? `Planning retry: ${message}` : `Planning failed: ${message}`, updatedAt: new Date().toISOString() });
-        }
-        if (!task.manualPlanning)
-            this.detach(this.reconcile(jobId), jobId, task.id, 'planner follow-up reconciliation');
-    }
-    plannerChild(job, planner, spec, executionContext) {
-        validateAgentSelection(executionContext, spec.agentName, spec.agentGraph);
-        const now = new Date().toISOString();
-        return { 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, state: (spec.dependencies?.length ?? 0) > 0 ? 'DRAFT' : 'QUEUED', 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: planner.id, planningSource: planner.planningSource ?? 'model-planner', planningRound: planner.planningRound ?? 1 };
+    async launchPlanner(job, plan) {
+        return launchPlanExecution({
+            store: this.store,
+            options: this.options,
+            live: this.plannerLive,
+            plannerContext: (currentJob, currentPlan) => this.plannerContext(currentJob, currentPlan),
+            emit: event => this.emit(event),
+            detach: (promise, jobId, planId, context) => this.detach(promise, jobId, planId, context),
+            reconcile: jobId => this.reconcile(jobId),
+        }, job, plan);
     }
 }