agents-relay 1.0.90 → 1.0.91

package/dist/reconciler.js

@@ -6,13 +6,13 @@ import { LaunchFailure, StartAckTimeout } from './adapters.js';
 import { eventFor } from './events.js';
 import { parsePlannerResult, plannerInput } from './planner.js';
 import { agentContractPrompt, executionContextPrompt, resolveExecutionContext } from './execution-context.js';
-import { selectReviewer } from './reviewer-routing.js';
 import { agentGraphPrompt } from './agent-graph.js';
-import { selectWorker, usageForProvider, workerCandidates } from './worker-routing.js';
+import { ReconcilerReviewBase } from './reconciler-review.js';
+import { executionEventSource } from './reconciler-runtime.js';
+export { executionEventSource } from './reconciler-runtime.js';
+import { CallbackWorkflowEffectHandler } from './workflow/effects.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 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; }
 export async function managedWorkerInput(job, task, context) {
     if (!['codex', 'chatgpt'].includes(task.adapter) || !job.repository || job.prNumber <= 0)
         return task.input;
@@ -72,60 +72,27 @@ Before your final return, verify that a terminal event for this exact Job/Task w
 If no terminal event has been published, publish task.failed before exiting.`;
 }
 const taskLaunchClaims = new Set();
-const terminalExecutionClaims = new Set();
-function claimTerminalExecution(sourceId) {
-    terminalExecutionClaims.add(sourceId);
-    const cleanup = setTimeout(() => terminalExecutionClaims.delete(sourceId), 60000);
-    cleanup.unref();
-}
-function terminalExecutionClaimed(jobId, taskId, executionId) {
-    return terminalExecutionClaims.has(executionEventSource(jobId, taskId, executionId));
-}
-export class Reconciler {
-    store;
-    options;
-    live = new Map();
-    plannerLive = new Map();
-    terminalTimers = new Map();
-    terminalExitGraceTimers = new Map();
-    continuationLive = new Set();
-    launchFailureClaims = new Set();
-    terminalWaiters = new Map();
-    reconciling = false;
+export class Reconciler extends ReconcilerReviewBase {
     constructor(store, options) {
-        this.store = store;
-        this.options = options;
-    }
-    async handleEvent(event) {
-        if (event.type === 'task.started') {
-            await this.markWorkerStarted(event);
-            return;
-        }
-        if (['task.completed', 'task.failed', 'task.blocked', 'task.cancelled'].includes(event.type)) {
-            await this.applyTerminalEvent(event);
-            return;
-        }
-        if (['review.started', 'review.approved', 'review.changes_required', 'review.blocked'].includes(event.type)) {
-            await this.applyReviewEvent(event);
-            return;
-        }
-        if (event.type === 'job.wake' || event.type === 'github.webhook')
-            await this.reconcile(event.job_id);
-    }
-    async watch(jobId) {
-        if (!this.options.eventBus)
-            return async () => { };
-        try {
-            return await this.options.eventBus.subscribe(jobId, event => this.handleEvent(event));
-        }
-        catch (error) {
-            await this.reportTransportFailure(error);
-            return async () => { };
-        }
+        super(store, options);
+        this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.launchTask', async (context) => {
+            const job = await this.store.load(context.jobId);
+            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')
+                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'))));
+        this.workflowEffects.register(new CallbackWorkflowEffectHandler('effect.mergePullRequest', async (context) => {
+            const headSha = typeof context.data?.headSha === 'string' ? context.data.headSha : null;
+            if (!headSha || !this.store.mergePullRequest)
+                throw new Error('Pull request merge effect requires a head SHA and merge-capable store');
+            await this.store.mergePullRequest(headSha);
+        }, context => `effect.mergePullRequest:${context.jobId}:${String(context.data?.headSha ?? 'missing')}`));
     }
-    async idle() { while (this.live.size > 0 || this.plannerLive.size > 0 || this.continuationLive.size > 0 || this.reconciling)
-        await new Promise(resolve => setTimeout(resolve, 25)); }
-    async wake(jobId) { return this.reconcile(jobId); }
     async reconcile(jobId) {
         if (this.reconciling)
             return this.store.load(jobId);
@@ -141,27 +108,22 @@ export class Reconciler {
             const now = (this.options.now ?? new Date()).getTime();
             if (prState !== 'OPEN') {
                 const reason = prState === 'MERGED' ? 'Pull request merged' : 'Pull request closed';
-                for (const task of job.tasks.filter(item => !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(item.state))) {
-                    this.live.get(task.id)?.execution.cancel();
-                    this.plannerLive.get(task.id)?.controller.abort();
-                    await transitionTaskEvent(task, 'cancel');
-                    task.error = reason;
-                    task.leaseOwner = null;
-                    task.leaseExpiresAt = null;
-                    task.executionId = null;
-                    await this.store.saveTask(task);
-                }
                 const terminalState = prState === 'MERGED' ? 'COMPLETED' : 'CANCELLED';
                 if (job.state !== terminalState) {
                     if (!['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'].includes(job.state)) {
-                        // Compatibility repair for legacy records that persisted derived runtime status as lifecycle.
+                        // Compatibility repair boundary for historical records that persisted runtime status as lifecycle.
                         job.state = terminalState;
                         job.updatedAt = new Date().toISOString();
+                        await this.store.saveJob(job);
+                        const outcomes = await this.workflowEffects.execute(['effect.cancelActiveTasks'], { jobId: job.id, transitionKey: `compatibility:${prState}`, data: { reason } });
+                        await this.applyJobEffectOutcomes(job, outcomes);
                     }
                     else {
-                        await transitionJobEvent(job, prState === 'MERGED' ? 'pr.merged' : 'pr.closed', prState === 'CLOSED' ? { notMerged: true } : {});
+                        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 this.store.saveJob(job);
                 }
                 return this.store.load(jobId);
             }
@@ -193,11 +155,23 @@ export class Reconciler {
                 for (const task of scheduled.tasks.filter(item => item.state === 'SUCCEEDED' && (item.continuation || scheduled.continuation) && !item.continuationDeliveredAt))
                     this.detach(this.deliverContinuation(scheduled, task), scheduled.id, task.id, 'continuation');
                 const capacity = Math.max(0, (this.options.maxConcurrent ?? 4) - this.live.size - this.plannerLive.size);
-                for (const task of scheduled.tasks.filter(t => t.state === 'QUEUED' && t.executionId === null && dependencyReady(t, new Map(scheduled.tasks.map(item => [item.id, item])))).sort((a, b) => compareTaskPriority(a, b, scheduled.priority ?? 'P2')).slice(0, capacity)) {
-                    if (task.kind === 'planner')
-                        await this.launchPlanner(scheduled, task);
-                    else if (task.adapter !== 'orchestrator')
-                        await this.launch(scheduled, task);
+                const dispatchable = scheduled.tasks
+                    .filter(task => task.state === 'QUEUED'
+                    && task.executionId === null
+                    && (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);
                 }
             }
             const finalState = schedule(await this.store.load(jobId));
@@ -205,8 +179,13 @@ export class Reconciler {
                 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) {
-                await this.store.mergePullRequest(headSha);
-                await this.emit(eventFor(finalState.id, 'job', null, 'job.merged', 'succeeded', 'Completed work merged PR #' + finalState.prNumber, 'user', { headSha, autoMerge: true }, { agent: 'relay', component: 'agents-relay' }));
+                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 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' }));
+                }
             }
             return this.store.load(jobId);
         }
@@ -214,151 +193,17 @@ export class Reconciler {
             this.reconciling = false;
         }
     }
-    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);
-    }
-    async ensureFinalReview(job, prState, headSha) {
-        if (job.schedule || job.reviewEnabled === false || prState !== 'OPEN' || job.state !== 'ACTIVE' || !implementationComplete(job) || !headSha)
-            return;
-        if (!this.preReviewGatesPass(job))
-            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)))
-            return;
-        if (reviewTasks.some(task => task.state === 'SUCCEEDED' && review?.headSha === headSha && review.outcome === 'approved'))
-            return;
-        const id = `final-review-${headSha.slice(0, 12)}`;
-        const now = new Date().toISOString();
-        const implementationTasks = job.tasks.filter(item => item.agentName !== 'reviewer' && !this.isSupersededTask(item));
-        const reviewerRouting = await this.selectReviewer(implementationTasks);
-        const task = { jobId: job.id, id, kind: 'work', priority: job.priority, storySize: 'M', projectName: job.title, agentName: 'reviewer', parentTaskId: null, dependencies: implementationTasks.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 };
-        await this.store.appendTask(task);
-        job.review = { outcome: 'pending', headSha, taskId: id, 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);
-        const reviewTask = ready.tasks.find(item => item.id === id && item.state === 'QUEUED');
-        if (reviewTask && (this.options.maxConcurrent ?? 4) > this.live.size + this.plannerLive.size)
-            await this.launch(ready, reviewTask);
-    }
-    async selectReviewer(implementationTasks) {
-        const configured = this.options.reviewer;
-        const registered = await this.store.listAgents();
-        const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
-        const candidates = workerCandidates(this.options.adapters, registered, usage);
-        let constrained = candidates.filter(candidate => {
-            if (configured?.workerId && configured.workerId !== candidate.workerId)
-                return false;
-            if (configured?.adapter && configured.adapter !== candidate.adapter)
-                return false;
-            if (configured?.routing?.provider && configured.routing.provider !== candidate.routing.provider)
-                return false;
-            if (configured?.routing?.model && configured.routing.model !== candidate.routing.model)
-                return false;
-            return true;
-        }).map(candidate => ({ ...candidate, routing: configured?.routing ? { ...candidate.routing, ...configured.routing } : candidate.routing }));
-        // Explicit reviewer routing is a caller-owned hard constraint and remains
-        // readable in isolated/test runtimes that do not instantiate that adapter.
-        if (constrained.length === 0 && configured?.adapter && configured.routing) {
-            constrained = [{ workerId: configured.workerId ?? configured.adapter, adapter: configured.adapter, capabilities: ['model'], runtime: configured.adapter, routing: configured.routing }];
-        }
-        const result = selectReviewer(constrained, implementationTasks, configured?.requirements ?? { capabilities: ['model'] });
-        const resource = usageForProvider(usage, result.candidate.routing.provider);
-        result.selection.resourceHealthy = resource.healthy;
-        result.selection.resourceProvider = resource.healthy === undefined ? undefined : result.candidate.routing.provider;
-        result.selection.resourceUsedPercent = resource.usedPercent;
-        return result;
-    }
-    async routeExecutableTasks(job) {
-        const usage = this.options.usageSnapshotProvider ? await this.options.usageSnapshotProvider() : undefined;
-        const candidates = workerCandidates(this.options.adapters, await this.store.listAgents(), usage);
-        for (const task of job.tasks.filter(item => item.kind !== 'planner' && item.agentName !== 'reviewer' && item.adapter !== 'orchestrator' && ['QUEUED', 'BLOCKED'].includes(item.state) && item.output && !item.workerSelection && (item.workerRequirements || item.planningSource === 'model-planner'))) {
-            const requirements = task.workerRequirements ?? { capabilities: task.capabilities.length > 0 ? task.capabilities : ['model'] };
-            const routed = selectWorker(candidates, requirements);
-            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();
+    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();
+            this.plannerLive.get(task.id)?.controller.abort();
+            await transitionTaskEvent(task, 'cancel');
+            task.error = reason;
+            task.leaseOwner = null;
+            task.leaseExpiresAt = null;
+            task.executionId = null;
             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}`, 'orchestrator', { workerSelection: routed.selection, workerRequirements: requirements }, { agent: 'relay', component: 'agents-relay' }));
-        }
-    }
-    isSupersededTask(task) {
-        return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
-    }
-    preReviewGatesPass(job) {
-        return job.tasks.filter(task => task.agentName !== 'reviewer' && !this.isSupersededTask(task)).every(task => task.state === 'SUCCEEDED');
-    }
-    async applyReviewEvent(event) {
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id && item.agentName === 'reviewer');
-        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;
-        const outcome = event.type === 'review.started' ? 'started' : event.type === 'review.approved' ? 'approved' : event.type === 'review.changes_required' ? 'changes_required' : 'blocked';
-        const currentHeadSha = await this.store.headSha?.();
-        if ((currentHeadSha && currentHeadSha !== headSha) || (job.headSha && job.headSha !== headSha))
-            return;
-        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();
-                }
-                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: 'review-fix', parentTaskId: task.id, dependencies: [task.id], capabilities: ['implementation'],
-                    adapter: 'codex', input, output: { kind: 'task_pr' },
-                    routing: { provider: 'openai', model: 'gpt-5.6-luna', reasoning: 'medium', decidedBy: 'review-fix', decidedAt: now },
-                    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: storySizeTimeoutMs('M'), 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' }));
-            }
-        }
-        job.updatedAt = job.review.updatedAt;
-        await this.store.saveJob(job);
-        if (outcome === 'changes_required')
-            this.detach(this.reconcile(job.id), job.id, task.id, 'review-fix reconciliation');
-        if (outcome === 'approved' && job.autoMerge !== false && this.store.mergePullRequest) {
-            await this.store.mergePullRequest(headSha);
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'review.merged', 'succeeded', 'Reviewer-approved PR #' + job.prNumber + ' merged', 'user', { headSha, autoMerge: true }, { agent: 'reviewer', component: 'agents-relay' }));
         }
     }
     async recoverLostExecutions(job, now) {
@@ -544,39 +389,6 @@ export class Reconciler {
                 ? 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 startAck(jobId, taskId, sourceId, launchBarrier, timeoutMs = this.options.startAckTimeoutMs ?? 60000) {
-        if (!this.options.eventBus)
-            throw new Error('Worker start acknowledgement requires an event bus');
-        let resolveAck;
-        let rejectAck;
-        let settled = false;
-        let timer;
-        const ack = new Promise((resolve, reject) => { resolveAck = resolve; rejectAck = reject; });
-        const unsubscribe = await this.options.eventBus.subscribe(jobId, async (event) => {
-            if (settled || event.type !== 'task.started' || event.job_id !== jobId || event.task_id !== taskId)
-                return;
-            if (eventSourceId(event) !== sourceId)
-                return;
-            if (!event.timestamp || new Date(event.timestamp).getTime() < launchBarrier)
-                return;
-            settled = true;
-            if (timer)
-                clearTimeout(timer);
-            resolveAck();
-        });
-        timer = setTimeout(() => {
-            if (settled)
-                return;
-            settled = true;
-            void unsubscribe();
-            rejectAck(new StartAckTimeout(`Task ${taskId} worker_start_timeout: no worker task.started start-ack`));
-        }, timeoutMs);
-        let stopped = false;
-        const stop = async () => { if (stopped)
-            return; stopped = true; if (timer)
-            clearTimeout(timer); await unsubscribe(); };
-        return { ack, stop };
-    }
     async launchPlanner(job, task) {
         const planner = this.options.planner;
         if (!planner) {
@@ -682,287 +494,6 @@ export class Reconciler {
         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, parentTaskId: planner.id, 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 };
     }
-    clearExecution(taskId, executionId) {
-        const live = this.live.get(taskId);
-        if (!executionId || live?.executionId === executionId)
-            this.live.delete(taskId);
-        const timer = this.terminalTimers.get(taskId);
-        if (timer)
-            clearTimeout(timer);
-        this.terminalTimers.delete(taskId);
-        const graceTimer = this.terminalExitGraceTimers.get(taskId);
-        if (graceTimer)
-            clearTimeout(graceTimer);
-        this.terminalExitGraceTimers.delete(taskId);
-    }
-    async markWorkerStarted(event) {
-        const live = this.live.get(event.task_id);
-        if (live && event.job_id === live.jobId && event.timestamp && new Date(event.timestamp).getTime() < live.launchBarrier)
-            return;
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !task.executionId || eventSourceId(event) !== executionEventSource(job.id, task.id, task.executionId))
-            return;
-        const claimedExecution = task.state === 'QUEUED' && task.executionId !== null && task.leaseOwner !== null;
-        const exactLiveExecution = live && event.job_id === live.jobId && task.executionId === live.executionId;
-        if ((exactLiveExecution || claimedExecution) && task.state === 'QUEUED') {
-            await transitionTaskEvent(task, 'task.started');
-            task.failureReason = undefined;
-            task.error = null;
-            task.updatedAt = event.timestamp || new Date().toISOString();
-            await this.store.saveTask(task);
-            if (live)
-                live.workerStarted = true;
-            return;
-        }
-        if (task.state !== 'FAILED' || !this.isRecoverableWatchdogFailure(task))
-            return;
-        if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
-            return;
-        await transitionTaskEvent(task, 'reconcile.started');
-        task.failureReason = undefined;
-        task.error = null;
-        task.updatedAt = event.timestamp || new Date().toISOString();
-        await this.store.saveTask(task);
-        this.detach(this.reconcile(job.id), job.id, task.id, 'late worker-start reconciliation');
-    }
-    isRecoverableWatchdogFailure(task) {
-        if (['worker_start_timeout', 'terminal_event_timeout', 'worker_exit_before_start', 'worker_exit_without_terminal_event'].includes(task.failureReason ?? ''))
-            return true;
-        const error = task.error ?? '';
-        return error.includes('worker_start_timeout')
-            || error.includes('timed out waiting for the mandatory terminal worker event')
-            || error.includes('exited before publishing task.started')
-            || error.includes('exited after task.started without publishing a terminal task event');
-    }
-    isCorrelatedWorkerEvent(task, event) {
-        return task.executionId !== null && eventSourceId(event) === executionEventSource(event.job_id, task.id, task.executionId);
-    }
-    async failLaunch(jobId, taskId, executionId, message, phase = 'launch') {
-        const claim = executionId ?? `${jobId}:${taskId}`;
-        if (this.launchFailureClaims.has(claim))
-            return;
-        this.launchFailureClaims.add(claim);
-        const cleanup = setTimeout(() => this.launchFailureClaims.delete(claim), 60000);
-        cleanup.unref();
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state))
-            return;
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Worker ${phase} failed: ${message}`, 'user', { phase, reason: phase === 'start-ack' ? 'worker_start_timeout' : undefined }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        if (task.state === 'QUEUED') {
-            this.clearExecution(task.id, executionId);
-            task.error = event.message;
-            task.failureReason = phase === 'start-ack' ? 'worker_start_timeout' : undefined;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
-    }
-    async runtimeSettled(jobId, taskId, executionId, result, error) {
-        const live = this.live.get(taskId);
-        const liveWorkerStarted = live?.executionId === executionId && live.workerStarted;
-        if (live?.executionId === executionId)
-            this.live.delete(taskId);
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        const workerStarted = liveWorkerStarted || task?.state === 'RUNNING';
-        if (!task || task.executionId !== executionId)
-            return;
-        await this.emit(eventFor(jobId, taskId, task.parentTaskId, task.adapter === 'chatgpt' ? 'task.process.async_exited' : 'task.process.exited', error ? 'failed' : 'succeeded', error ?? result?.summary ?? 'Worker runtime exited', 'orchestrator', { authoritative: false, waitingForTerminalEvent: true, processError: error }, { agent: 'relay', component: 'agents-relay' }));
-        if (['QUEUED', 'RUNNING'].includes(task.state) && task.adapter === 'codex' && !terminalExecutionClaimed(jobId, taskId, executionId))
-            this.scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted === true);
-    }
-    scheduleUnexpectedExit(jobId, taskId, executionId, workerStarted) {
-        const graceMs = Math.max(1, this.options.terminalExitGraceMs ?? 1000);
-        const timer = setTimeout(() => {
-            this.terminalExitGraceTimers.delete(taskId);
-            this.detach(this.failUnexpectedExit(jobId, taskId, executionId, workerStarted), jobId, taskId, 'unexpected worker process exit');
-        }, graceMs);
-        this.terminalExitGraceTimers.set(taskId, timer);
-    }
-    async failUnexpectedExit(jobId, taskId, executionId, workerStarted) {
-        if (terminalExecutionClaimed(jobId, taskId, executionId))
-            return;
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state) || terminalExecutionClaimed(jobId, taskId, executionId))
-            return;
-        const reason = workerStarted ? 'worker_exit_without_terminal_event' : 'worker_exit_before_start';
-        const message = workerStarted
-            ? `Worker ${taskId} exited after task.started without publishing a terminal task event`
-            : `Worker ${taskId} exited before publishing task.started`;
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', message, 'user', { reason, terminalGraceMs: this.options.terminalExitGraceMs ?? 1000 }, { agent: 'relay', component: 'agents-relay', watchdog: true });
-        if (task.state === 'QUEUED') {
-            this.clearExecution(task.id, executionId);
-            task.error = message;
-            task.failureReason = reason;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
-    }
-    async timeoutTask(jobId, taskId, executionId) {
-        const live = this.live.get(taskId);
-        if (live?.executionId === executionId) {
-            live.controller.abort();
-            live.execution.cancel();
-        }
-        const job = await this.store.load(jobId);
-        const task = job.tasks.find(item => item.id === taskId);
-        if (!task || task.executionId !== executionId || !['QUEUED', 'RUNNING'].includes(task.state)) {
-            this.clearExecution(taskId, executionId);
-            return;
-        }
-        const event = eventFor(jobId, taskId, task.parentTaskId, 'task.failed', 'failed', `Task ${taskId} timed out waiting for the mandatory terminal worker event`, 'user', { reason: 'terminal_event_timeout', timeoutMs: task.timeoutMs });
-        if (task.state === 'QUEUED') {
-            task.error = event.message;
-            task.failureReason = 'terminal_event_timeout';
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            await transitionTaskEvent(task, 'fail');
-            await this.store.saveTask(task);
-            this.clearExecution(task.id, executionId);
-        }
-        else {
-            await this.applyTerminalEvent(event, true);
-        }
-        await this.emit(event);
-    }
-    async applyTerminalEvent(event, trustedInternal = false) {
-        const job = await this.store.load(event.job_id);
-        const task = job.tasks.find(item => item.id === event.task_id);
-        if (!task || !['codex', 'chatgpt', 'orchestrator'].includes(task.adapter))
-            return;
-        const modelBacked = task.adapter === 'codex' || task.adapter === 'chatgpt';
-        if (!trustedInternal && modelBacked && !this.isCorrelatedWorkerEvent(task, event))
-            return;
-        if (task.state === 'FAILED' && this.isRecoverableWatchdogFailure(task) && (trustedInternal || !modelBacked || this.isCorrelatedWorkerEvent(task, event))) {
-            if (event.timestamp && new Date(event.timestamp).getTime() < new Date(task.updatedAt).getTime())
-                return;
-            await transitionTaskEvent(task, 'reconcile.started');
-            task.failureReason = undefined;
-            task.error = null;
-        }
-        if (task.state !== 'RUNNING')
-            return;
-        const terminalWaiter = this.terminalWaiters.get(task.id);
-        if (terminalWaiter && (!event.timestamp || new Date(event.timestamp).getTime() < terminalWaiter.launchBarrier))
-            return;
-        const acceptedExecutionId = task.executionId;
-        if (modelBacked && acceptedExecutionId)
-            claimTerminalExecution(executionEventSource(job.id, task.id, acceptedExecutionId));
-        this.clearExecution(task.id, acceptedExecutionId);
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.updatedAt = event.timestamp || new Date().toISOString();
-        this.terminalWaiters.get(task.id)?.resolve();
-        this.terminalWaiters.delete(task.id);
-        if (event.type === 'task.completed') {
-            task.result = { summary: event.message || `Task ${task.id} completed`, data: event.data };
-            task.error = null;
-            task.failureReason = undefined;
-            await transitionTaskEvent(task, 'task.completed');
-            await this.store.saveTask(task);
-            await this.deliverContinuation(job, task);
-        }
-        else if (event.type === 'task.failed') {
-            task.error = event.message || `Task ${task.id} failed`;
-            task.failureReason = typeof event.data?.reason === 'string' ? event.data.reason : undefined;
-            await transitionTaskEvent(task, 'task.failed');
-            await this.store.saveTask(task);
-        }
-        else if (event.type === 'task.blocked') {
-            task.error = event.message || `Task ${task.id} blocked`;
-            await transitionTaskEvent(task, 'task.blocked');
-            await this.store.saveTask(task);
-        }
-        else if (event.type === 'task.cancelled') {
-            task.error = event.message || `Task ${task.id} cancelled`;
-            await transitionTaskEvent(task, 'task.cancelled');
-            await this.store.saveTask(task);
-        }
-        this.detach(this.reconcile(job.id), job.id, task.id, 'terminal-event reconciliation');
-    }
-    terminalWait(taskId, executionId, launchBarrier) {
-        let resolve;
-        const promise = new Promise(resolver => { resolve = resolver; });
-        this.terminalWaiters.set(taskId, { executionId, launchBarrier, resolve });
-        return {
-            promise,
-            cancel: () => {
-                const current = this.terminalWaiters.get(taskId);
-                if (current?.executionId === executionId)
-                    this.terminalWaiters.delete(taskId);
-            },
-        };
-    }
-    async deliverContinuation(job, task) {
-        const continuation = task.continuation ?? job.continuation;
-        if (!continuation || task.continuationDeliveredAt || this.continuationLive.has(task.id))
-            return;
-        const adapter = this.options.continuations?.find(candidate => candidate.kind === continuation.kind);
-        if (!adapter) {
-            task.error = `No continuation adapter for ${continuation.kind}`;
-            await this.store.saveTask(task);
-            return;
-        }
-        this.continuationLive.add(task.id);
-        try {
-            await adapter.continue(task.result?.summary ?? '', continuation);
-            const fresh = await this.store.load(job.id);
-            const durable = fresh.tasks.find(item => item.id === task.id);
-            if (durable?.state === 'SUCCEEDED' && !durable.continuationDeliveredAt) {
-                durable.continuationDeliveredAt = new Date().toISOString();
-                await this.store.saveTask(durable);
-            }
-        }
-        catch (error) {
-            await this.emit(eventFor(job.id, task.id, task.parentTaskId, 'continuation.failed', 'failed', `Continuation failed: ${error instanceof Error ? error.message : String(error)}`, 'user'));
-        }
-        finally {
-            this.continuationLive.delete(task.id);
-        }
-    }
-    async emit(event) { try {
-        if (this.options.emit)
-            await this.options.emit(event);
-    }
-    catch { /* observability cannot block durable execution */ } try {
-        if (this.options.eventBus)
-            await this.options.eventBus.publish(event);
-    }
-    catch (error) {
-        await this.reportTransportFailure(error);
-    } }
-    detach(promise, jobId, taskId, context) {
-        void promise.catch(error => this.reportDetachedFailure(jobId, taskId, context, error));
-    }
-    async reportDetachedFailure(jobId, taskId, context, error) {
-        if (!this.options.emit)
-            return;
-        const message = error instanceof Error ? error.message : String(error);
-        try {
-            await this.options.emit(eventFor(jobId, taskId, null, 'runtime.persistence.failed', 'failed', `${context} failed: ${message}`, 'orchestrator'));
-        }
-        catch { /* detached failure reporting must never crash the daemon */ }
-    }
-    async reportTransportFailure(error) { if (this.options.emit) {
-        try {
-            await this.options.emit(eventFor('system', 'event-bus', null, 'event.transport.failed', 'failed', `Event transport unavailable: ${error instanceof Error ? error.message : String(error)}`, 'orchestrator'));
-        }
-        catch { /* reporting is best effort */ }
-    } }
 }
 function samePlannerChildDefinition(left, right) {
     return JSON.stringify({ id: left.id, input: left.input, output: left.output, priority: left.priority, storySize: left.storySize ?? 'M', projectName: left.projectName, agentName: left.agentName, agentGraph: left.agentGraph, dependencies: left.dependencies, capabilities: left.capabilities, adapter: left.adapter, routing: left.routing, continuation: left.continuation ?? null, maxAttempts: left.maxAttempts, timeoutMs: left.timeoutMs }) === JSON.stringify({ id: right.id, input: right.input, output: right.output, priority: right.priority, storySize: right.storySize ?? 'M', projectName: right.projectName, agentName: right.agentName, agentGraph: right.agentGraph, dependencies: right.dependencies, capabilities: right.capabilities, adapter: right.adapter, routing: right.routing, continuation: right.continuation ?? null, maxAttempts: right.maxAttempts, timeoutMs: right.timeoutMs });