agents-relay 1.0.177 → 2.0.0

package/dist/dashboard-html.js

@@ -395,7 +395,6 @@ function creditProvider(provider){const row=element('section','usage-provider');
 function shortReset(reset){if(!Number.isFinite(reset))return '';const at=new Date(reset*1000);const minutes=Math.max(0,Math.ceil((at.getTime()-Date.now())/60000));const relative=minutes<60?minutes+'m':minutes<1440?Math.floor(minutes/60)+'h '+minutes%60+'m':Math.floor(minutes/1440)+'d '+Math.floor((minutes%1440)/60)+'h';return 'Reset '+relative;}
 function githubBucket(label,bucket){const row=element('div','usage-row');const heading=element('div','usage-label');heading.append(element('span','',text(label)),element('span','',text(bucket.remaining+' / '+bucket.limit)));const percent=bucket.limit>0?Math.max(0,Math.min(100,100*bucket.remaining/bucket.limit)):0;const track=element('div','usage-track');track.setAttribute('role','progressbar');track.setAttribute('aria-label',label+' remaining');track.setAttribute('aria-valuemin','0');track.setAttribute('aria-valuemax','100');track.setAttribute('aria-valuenow',String(Math.round(percent)));const fill=element('div','usage-fill');fill.style.width=percent+'%';track.append(fill);row.append(heading,track);const reset=shortReset(bucket.reset);if(reset){const hint=element('div','subtle',text(reset));hint.title=new Date(bucket.reset*1000).toLocaleString();row.append(hint);}return row;}
 function githubCounterLine(label,values){const entries=Object.entries(values||{}).sort((a,b)=>Number(b[1])-Number(a[1])).slice(0,8);return entries.length?element('div','subtle',text(label+' · '+entries.map(([key,count])=>key+' '+count).join(' · '))):null;}
-function githubDiagnostics(status){const body=element('div','usage-details-body');if(status?.calls)body.append(element('div','subtle',text('Calls · GraphQL '+(status.calls.graphql||0)+' · REST '+(status.calls.rest||0)+' · quota '+(status.calls.rateLimit||0))));const operations=githubCounterLine('GraphQL operations',status?.graphql?.operations);if(operations)body.append(operations);const contexts=githubCounterLine('GraphQL contexts',status?.graphql?.contexts);if(contexts)body.append(contexts);if(status?.readPaths){body.append(element('div','subtle',text('Reads · scans '+(status.readPaths.workspaceScans||0)+' · PR '+(status.readPaths.prRefreshes||0)+' · coalesced '+(status.readPaths.prRefreshCoalesced||0))));const triggers=githubCounterLine('Refresh triggers',status.readPaths.prRefreshesByTrigger);if(triggers)body.append(triggers);const coalesced=githubCounterLine('Coalesced',status.readPaths.prRefreshCoalescedByTrigger);if(coalesced)body.append(coalesced);}if(!body.children.length)return null;const details=element('details','usage-details');details.append(element('summary','',text('Diagnostics')),body);return details;}
 function githubObserved(label,observed){
   if(!observed)return null;
   const state=observed.throttled?'Throttled':observed.available===true?'Available':observed.available===false?'Unavailable':'Unknown';
@@ -409,6 +408,7 @@ function githubObserved(label,observed){
   if(observed.reason)row.title=observed.reason;
   return row;
 }
+function githubDiagnostics(status){const body=element('div','usage-details-body');if(status?.calls)body.append(element('div','subtle',text('Calls · GraphQL '+(status.calls.graphql||0)+' · REST '+(status.calls.rest||0)+' · quota '+(status.calls.rateLimit||0))));const operations=githubCounterLine('GraphQL operations',status?.graphql?.operations);if(operations)body.append(operations);const contexts=githubCounterLine('GraphQL contexts',status?.graphql?.contexts);if(contexts)body.append(contexts);if(status?.readPaths){body.append(element('div','subtle',text('Reads · scans '+(status.readPaths.workspaceScans||0)+' · PR '+(status.readPaths.prRefreshes||0)+' · coalesced '+(status.readPaths.prRefreshCoalesced||0))));const triggers=githubCounterLine('Refresh triggers',status.readPaths.prRefreshesByTrigger);if(triggers)body.append(triggers);const coalesced=githubCounterLine('Coalesced',status.readPaths.prRefreshCoalescedByTrigger);if(coalesced)body.append(coalesced);}if(!body.children.length)return null;const details=element('details','usage-details');details.append(element('summary','',text('Diagnostics')),body);return details;}
 function githubUsageCard(snapshot,status){
   const card=element('section','usage-provider');
   card.append(element('h3','',text('GitHub API')));

package/dist/dashboard.js

@@ -243,6 +243,45 @@ export function serveDashboard(store, port = 8787, bus, refreshMs = 300000, jobI
             }
             return;
         }
+        if (new URL(req.url ?? '/', 'http://127.0.0.1').pathname === '/api/task-command') {
+            if (req.method !== 'POST') {
+                res.writeHead(404);
+                res.end('Task command unavailable');
+                return;
+            }
+            try {
+                const chunks = [];
+                for await (const chunk of req)
+                    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+                const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                const requestedJobId = typeof body.jobId === 'string' ? body.jobId : '';
+                const requestedTaskId = typeof body.taskId === 'string' ? body.taskId : '';
+                if (!/^[A-Za-z0-9_-]+$/.test(requestedJobId))
+                    throw new Error('Invalid job id');
+                let result;
+                if (body.action === 'create' && body.task && resolvedActions?.taskCreate)
+                    result = await resolvedActions.taskCreate(requestedJobId, body.task);
+                else if (body.action === 'retry' && /^[A-Za-z0-9_-]+$/.test(requestedTaskId) && resolvedActions?.taskRetry)
+                    result = await resolvedActions.taskRetry(requestedJobId, requestedTaskId);
+                else if (body.action === 'cancel' && /^[A-Za-z0-9_-]+$/.test(requestedTaskId) && resolvedActions?.taskCancel)
+                    result = await resolvedActions.taskCancel(requestedJobId, requestedTaskId);
+                else if (body.action === 'complete' && /^[A-Za-z0-9_-]+$/.test(requestedTaskId) && typeof body.summary === 'string' && body.summary.trim() && resolvedActions?.taskComplete)
+                    result = await resolvedActions.taskComplete(requestedJobId, requestedTaskId, body.summary);
+                else
+                    throw new Error('Task command unavailable');
+                if (!res.headersSent)
+                    res.writeHead(200, { 'content-type': 'application/json' });
+                if (!res.writableEnded)
+                    res.end(JSON.stringify(result));
+            }
+            catch (error) {
+                if (!res.headersSent)
+                    res.writeHead(409);
+                if (!res.writableEnded)
+                    res.end(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         if (new URL(req.url ?? '/', 'http://127.0.0.1').pathname === '/api/task-action') {
             const url = new URL(req.url ?? '/', 'http://127.0.0.1');
             const requestedJobId = url.searchParams.get('id') ?? '';

package/dist/execution-recovery.js

@@ -0,0 +1,37 @@
+import { transitionTaskEvent } from './scheduler.js';
+async function currentGeneration(store, job, stale) {
+    const task = (await store.load(job.id)).tasks.find(item => item.id === stale.id);
+    if (!task)
+        return null;
+    const sameGeneration = task.executionId === stale.executionId && task.leaseOwner === stale.leaseOwner && task.leaseExpiresAt === stale.leaseExpiresAt;
+    return sameGeneration ? task : null;
+}
+async function recoverTask(task, event, reason, ports) {
+    ports.cancelGeneration(task);
+    ports.cancelPlanner(task.id);
+    const decision = await transitionTaskEvent(task, event, { retryAvailable: task.attempt < task.maxAttempts });
+    await ports.store.saveTask(task);
+    if (decision.target === 'FAILED')
+        await ports.emitFailed(task, reason);
+}
+export async function recoverExpiredExecutions(job, now, ports) {
+    const candidates = job.tasks.filter(item => item.kind !== 'planner' && (item.state === 'RUNNING' || (item.state === 'QUEUED' && item.executionId !== null)));
+    for (const stale of candidates) {
+        if (stale.leaseExpiresAt === null || new Date(stale.leaseExpiresAt).getTime() > now)
+            continue;
+        const task = await currentGeneration(ports.store, job, stale);
+        const recoverable = task && (task.state === 'RUNNING' || (task.state === 'QUEUED' && task.executionId !== null));
+        if (!recoverable || task.leaseExpiresAt === null || new Date(task.leaseExpiresAt).getTime() > now)
+            continue;
+        await recoverTask(task, 'lease.expired', 'lease_expired', ports);
+    }
+}
+export async function recoverStartupOrphans(job, ports) {
+    const candidates = job.tasks.filter(task => task.kind !== 'planner' && task.state === 'RUNNING' && task.executionId && task.leaseOwner && task.leaseOwner !== ports.owner && task.adapter !== 'chatgpt');
+    for (const stale of candidates) {
+        const task = await currentGeneration(ports.store, job, stale);
+        if (!task || task.state !== 'RUNNING' || task.adapter === 'chatgpt' || !task.executionId || !task.leaseOwner || task.leaseOwner === ports.owner)
+            continue;
+        await recoverTask(task, 'execution.orphaned', 'startup_orphaned', ports);
+    }
+}

package/dist/graph-runtime.js

@@ -0,0 +1 @@
+export * from './workflow/graph-v2.js';

package/dist/job-actions.js

@@ -0,0 +1,53 @@
+import { transitionJobEvent } from './scheduler.js';
+import { tryApplyTaskCancelAction } from './task-actions.js';
+export const JOB_ACTIVATE_ACTION = 'job.activate';
+export const JOB_CANCEL_ACTION = 'job.cancel';
+async function transitionJobAction(job, event, action) {
+    try {
+        await transitionJobEvent(job, event);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
+            throw new Error(`Job ${job.id} is not ${action} (${job.state})`);
+        }
+        throw error;
+    }
+}
+export async function applyJobActivateAction(job) {
+    await transitionJobAction(job, 'activate', 'startable');
+    return job;
+}
+async function cancelActiveWork(store, job, reason) {
+    for (const plan of (job.plans ?? []).filter(item => item.status === 'PLANNING')) {
+        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) {
+        if (!tryApplyTaskCancelAction(task, reason))
+            continue;
+        await store.saveTask(task);
+    }
+}
+export async function applyJobCancelAction(store, job, reason = 'Job cancelled') {
+    const from = job.state;
+    try {
+        await transitionJobEvent(job, 'cancel', {}, async (actionId) => {
+            if (actionId !== 'effect.cancelActiveTasks')
+                throw new Error(`Unsupported job.cancel effect ${actionId}`);
+            await cancelActiveWork(store, job, reason);
+        }, async () => { await store.saveJob(job); });
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
+            throw new Error(`Job ${job.id} is not cancellable (${from})`);
+        }
+        throw error;
+    }
+    return job;
+}

package/dist/manual-plan.js

@@ -1,37 +1,35 @@
-import { createPlannerRoundTask, pendingPlanForPlannerTask, recoverPendingPlannerTask } from './planner.js';
-import { transitionJobEvent } from './scheduler.js';
+import { createPlanRound, pendingPlan } from './planner.js';
+import { applyJobActivateAction } from './job-actions.js';
 export async function executeManualPlan(store, jobId, guidance, timeoutMs, launchPlanner) {
     let job = await store.load(jobId);
     if (['COMPLETED', 'CANCELLED'].includes(job.state))
         throw new Error(`Cannot plan terminal job ${job.id} (${job.state})`);
-    const active = job.tasks.find(task => task.kind === 'planner' && ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state));
-    if (active)
-        throw new Error(`Planning round ${active.id} is already ${active.state}`);
-    const recovered = recoverPendingPlannerTask(job, timeoutMs);
-    const round = recovered ?? createPlannerRoundTask(job, { guidance, manual: true, timeoutMs });
-    if (!recovered)
-        await store.appendPlan(pendingPlanForPlannerTask(job, round));
-    await store.appendTask(round);
+    const active = pendingPlan(job);
+    if (active && active.executionId)
+        throw new Error(`Planning round ${active.id} is already PLANNING`);
+    const round = active ?? createPlanRound(job, { guidance, manual: true, timeoutMs });
+    if (!active)
+        await store.appendPlan(round);
     job = await store.load(jobId);
     if (job.state === 'DRAFT') {
-        await transitionJobEvent(job, 'activate');
+        await applyJobActivateAction(job);
         await store.saveJob(job);
         job = await store.load(jobId);
     }
-    const durableRound = job.tasks.find(task => task.id === round.id);
+    const durableRound = (job.plans ?? []).find(plan => plan.id === round.id);
     if (!durableRound)
         throw new Error(`Planning round ${round.id} was not persisted`);
     await launchPlanner(job, durableRound);
     let completed = await store.load(jobId);
-    let completedRound = completed.tasks.find(task => task.id === round.id);
-    while (completedRound && ['QUEUED', 'RUNNING'].includes(completedRound.state)) {
+    let completedRound = (completed.plans ?? []).find(plan => plan.id === round.id);
+    while (completedRound?.status === 'PLANNING') {
         await new Promise(resolve => setTimeout(resolve, 25));
         completed = await store.load(jobId);
-        completedRound = completed.tasks.find(task => task.id === round.id);
+        completedRound = (completed.plans ?? []).find(plan => plan.id === round.id);
     }
     if (!completedRound)
         throw new Error(`Planning round ${round.id} disappeared`);
-    if (completedRound.state !== 'SUCCEEDED')
-        throw new Error(completedRound.error ?? `Planning round ${round.id} ended ${completedRound.state}`);
+    if (completedRound.status !== 'SUCCEEDED')
+        throw new Error(completedRound.error ?? `Planning round ${round.id} ended ${completedRound.status}`);
     return { job: completed, round: completedRound };
 }

package/dist/planner-runtime.js

@@ -0,0 +1,135 @@
+import { randomUUID } from 'node:crypto';
+import { eventFor } from './events.js';
+import { materializePlannerChild, parsePlannerResult, validatePlannerHierarchy } from './planner.js';
+import { samePlannerChildDefinition } from './planner-child.js';
+import { withExecutionBoundary } from './reconciler-runtime.js';
+import { storySizeTimeoutMs } from './types.js';
+async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
+    const live = ports.live.get(planId);
+    if (live?.executionId === executionId)
+        clearTimeout(live.timer);
+    const releaseLive = () => { if (ports.live.get(planId)?.executionId === executionId)
+        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)) {
+        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'));
+        if (retry && !plan.manualPlanning)
+            ports.detach(ports.reconcile(jobId), jobId, plan.id, 'planner retry reconciliation');
+    };
+    if (error) {
+        await failOrRetry(error.message);
+        releaseLive();
+        return;
+    }
+    try {
+        const result = parsePlannerResult(raw);
+        const executionContext = await ports.plannerContext(job, plan);
+        validatePlannerHierarchy(job.tasks, result.next_tasks);
+        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);
+            if (existing && !samePlannerChildDefinition(existing, child))
+                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.headSha = plan.trigger.currentHeadSha ?? await ports.store.headSha?.() ?? job.headSha;
+        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);
+        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 }));
+    }
+    catch (caught) {
+        await failOrRetry(caught instanceof Error ? caught.message : String(caught));
+        releaseLive();
+        return;
+    }
+    releaseLive();
+    if (!plan.manualPlanning)
+        ports.detach(ports.reconcile(jobId), jobId, plan.id, 'planner follow-up reconciliation');
+}
+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'));
+        return;
+    }
+    const claimed = await withExecutionBoundary(job.id, plan.id, async () => {
+        const freshJob = await ports.store.load(job.id);
+        const fresh = (freshJob.plans ?? []).find(item => item.id === plan.id);
+        if (!fresh || fresh.status !== 'PLANNING')
+            return null;
+        const live = ports.live.get(fresh.id);
+        if (fresh.executionId && fresh.leaseOwner === ports.options.owner && live?.executionId === fresh.executionId)
+            return null;
+        const startedAt = (ports.options.now ?? new Date()).getTime();
+        fresh.attempt = (fresh.attempt ?? 0) + 1;
+        fresh.maxAttempts ??= fresh.manualPlanning ? 1 : 3;
+        fresh.timeoutMs ??= ports.options.plannerTimeoutMs ?? storySizeTimeoutMs('M');
+        fresh.leaseOwner = ports.options.owner;
+        fresh.leaseExpiresAt = new Date(startedAt + Math.max(ports.options.leaseMs ?? 300000, fresh.timeoutMs)).toISOString();
+        fresh.executionId = randomUUID();
+        fresh.updatedAt = new Date(startedAt).toISOString();
+        await ports.store.savePlan(fresh);
+        return fresh;
+    });
+    if (!claimed)
+        return;
+    plan = claimed;
+    await ports.emit(eventFor(job.id, plan.id, null, 'planner.started', 'running', `Plan ${plan.id} started`, 'orchestrator'));
+    const controller = new AbortController();
+    const executionId = plan.executionId;
+    const timeoutMs = plan.timeoutMs ?? ports.options.plannerTimeoutMs ?? storySizeTimeoutMs('M');
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    ports.live.set(plan.id, { executionId, controller, timer });
+    let promise;
+    try {
+        const executionContext = await ports.plannerContext(job, plan);
+        const context = { job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: plan.previousPlanId, trigger: plan.trigger, executionContext, retryFeedback: plan.retryFeedback, guidance: plan.guidance };
+        promise = planner.plan(context, controller.signal);
+    }
+    catch (error) {
+        await finishPlanner(ports, job.id, plan.id, executionId, error instanceof Error ? error : new Error(String(error)));
+        return;
+    }
+    ports.detach(promise.then(result => finishPlanner(ports, job.id, plan.id, executionId, null, result), error => finishPlanner(ports, job.id, plan.id, executionId, error instanceof Error ? error : new Error(String(error)))), job.id, plan.id, 'planner completion');
+}

package/dist/planner.js

@@ -4,8 +4,9 @@ import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
 import { storySizeTimeoutMs, taskOverallTimeoutMs } from './types.js';
 import { executionContextPrompt } from './execution-context.js';
-import { parseAgentGraph } from './agent-graph.js';
-/** Business-task ownership only; planner rounds remain provenance records. */
+import { parseAgentGraph, validateAgentSelection } from './agent-graph.js';
+import { dispatchPlannerTrigger } from './workflow/planner-trigger-v2.js';
+import { createTaskEntity } from './workflow/entity-creation.js';
 export function semanticTaskTree(tasks) {
     const work = tasks.filter(task => task.kind !== 'planner');
     const ids = new Set(work.map(task => task.id));
@@ -15,27 +16,43 @@ export function semanticTaskTree(tasks) {
     };
 }
 function plannerTrigger(job, manual = false) {
-    if (manual)
-        return { source: 'manual' };
     const consumed = new Set((job.plans ?? []).flatMap(plan => plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
     const unblocked = job.tasks.filter(task => task.state === 'UNBLOCKED' && task.unblock && !consumed.has(task.id));
-    if (unblocked.length > 0) {
-        const records = unblocked.map(task => task.unblock);
-        const blockedHeadShas = [...new Set(records.map(record => record.baseline.headSha).filter((value) => Boolean(value)))];
-        return {
-            source: 'unblock', taskIds: unblocked.map(task => task.id),
-            reason: [...new Set(records.map(record => record.reason))].join('; '),
-            blockedHeadShas,
-            currentHeadSha: records.map(record => record.currentHeadSha).find((value) => Boolean(value)),
-            unblockSource: records[0].source,
-            facts: [...new Set(records.flatMap(record => record.facts ?? [`unblock: ${record.reason}`]))],
-        };
+    const hasUnblock = unblocked.length > 0 || Boolean(job.changeCycle && !job.changeCycle.consumedByPlannerTaskId);
+    const decision = dispatchPlannerTrigger({
+        manualPlan: manual,
+        hasUnblock,
+        scheduledRun: Boolean(job.schedule?.currentRunSlot),
+        initialPlan: (job.plans?.length ?? 0) === 0 && !job.tasks.some(task => task.kind === 'planner'),
+    });
+    if (!decision.accepted)
+        throw new Error('Planner trigger graph rejected plan.requested');
+    const source = decision.target;
+    if (source === 'manual')
+        return { source: 'manual' };
+    if (source === 'unblock') {
+        if (unblocked.length > 0) {
+            const records = unblocked.map(task => task.unblock);
+            const blockedHeadShas = [...new Set(records.map(record => record.baseline.headSha).filter((value) => Boolean(value)))];
+            return {
+                source: 'unblock', taskIds: unblocked.map(task => task.id),
+                reason: [...new Set(records.map(record => record.reason))].join('; '),
+                blockedHeadShas,
+                currentHeadSha: records.map(record => record.currentHeadSha).find((value) => Boolean(value)),
+                unblockSource: records[0].source,
+                facts: [...new Set(records.flatMap(record => record.facts ?? ['unblock: ' + record.reason]))],
+            };
+        }
+        const cycle = job.changeCycle;
+        if (!cycle || cycle.consumedByPlannerTaskId)
+            throw new Error('Planner trigger graph selected unblock without unblock facts');
+        return { source: 'unblock', taskIds: cycle.taskIds, reason: cycle.reason, facts: cycle.facts, blockedHeadShas: cycle.baselineHeadShas, currentHeadSha: cycle.currentHeadSha, unblockSource: cycle.source };
     }
-    if (job.changeCycle && !job.changeCycle.consumedByPlannerTaskId)
-        return { source: 'unblock', taskIds: job.changeCycle.taskIds, reason: job.changeCycle.reason, facts: job.changeCycle.facts, blockedHeadShas: job.changeCycle.baselineHeadShas, currentHeadSha: job.changeCycle.currentHeadSha, unblockSource: job.changeCycle.source };
-    if (job.schedule?.currentRunSlot)
+    if (source === 'schedule')
         return { source: 'schedule' };
-    return (job.plans?.length ?? 0) === 0 && !job.tasks.some(task => task.kind === 'planner') ? { source: 'initial' } : { source: 'continuation' };
+    if (source === 'initial')
+        return { source: 'initial' };
+    return { source: 'continuation' };
 }
 export function plannerRoundNumber(task) {
     if (task.kind !== 'planner')
@@ -45,57 +62,44 @@ export function plannerRoundNumber(task) {
     const match = /^(?:plan|planner)-(\d+)$/.exec(task.id);
     return match ? Number(match[1]) : null;
 }
-export function createPlannerRoundTask(job, options = {}) {
-    const planners = job.tasks.filter(task => task.kind === 'planner')
-        .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id));
-    const used = new Set(job.tasks.map(task => task.id));
-    let round = Math.max(0, ...planners.map(task => plannerRoundNumber(task) ?? 0)) + 1;
+function latestLegacyPlanner(job) {
+    return job.tasks.filter(task => task.kind === 'planner')
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)).at(-1);
+}
+export function createPlanRound(job, options = {}) {
+    const plans = [...(job.plans ?? [])].sort((a, b) => a.round - b.round || a.createdAt.localeCompare(b.createdAt));
+    const legacy = job.tasks.filter(task => task.kind === 'planner');
+    const used = new Set([...job.tasks.map(task => task.id), ...plans.map(plan => plan.id)]);
+    let round = Math.max(0, ...plans.map(plan => plan.round), ...legacy.map(task => plannerRoundNumber(task) ?? 0)) + 1;
     let id = `plan-${round}`;
     while (used.has(id)) {
         round += 1;
         id = `plan-${round}`;
     }
-    const previousPlanner = planners.at(-1);
+    const previousPlan = plans.at(-1);
+    const previousLegacy = previousPlan ? undefined : latestLegacyPlanner(job);
+    const previousPlanId = previousPlan?.id ?? previousLegacy?.id ?? null;
     const now = options.now ?? new Date().toISOString();
-    const context = {
-        job,
-        tasks: job.tasks,
-        objective: job.objective ?? job.description ?? job.title,
-        previousPlannerTaskId: previousPlanner?.id ?? null,
-        trigger: plannerTrigger(job, options.manual === true),
-        guidance: options.guidance,
-    };
+    const trigger = plannerTrigger(job, options.manual === true);
     return {
-        jobId: job.id, id, kind: 'planner', storySize: 'M', agentName: 'planner',
-        parentTaskId: null, dependencies: [], capabilities: ['planner'], adapter: 'orchestrator',
-        input: plannerInput(context), continuation: null, continuationDeliveredAt: null, state: 'QUEUED', attempt: 0,
-        maxAttempts: options.manual ? 1 : 3, leaseOwner: null, leaseExpiresAt: null, executionId: null, threadId: null,
-        result: null, plannerResult: null, error: null, timeoutMs: options.timeoutMs ?? storySizeTimeoutMs('M'),
-        createdAt: now, updatedAt: now, planningDecisionId: id, planningSource: 'model-planner', planningRound: round, previousPlannerTaskId: previousPlanner?.id ?? null,
-        plannerGuidance: options.guidance, manualPlanning: options.manual === true, planTrigger: context.trigger,
+        jobId: job.id, id, round, source: 'model-planner', previousPlanId, trigger,
+        status: 'PLANNING', guidance: options.guidance, assessment: 'Planning in progress.', generatedTaskIds: [],
+        headSha: trigger.currentHeadSha ?? job.headSha,
+        attempt: 0, maxAttempts: options.manual ? 1 : 3, leaseOwner: null, leaseExpiresAt: null, executionId: null,
+        timeoutMs: options.timeoutMs ?? storySizeTimeoutMs('M'), manualPlanning: options.manual === true,
+        createdAt: now, updatedAt: now,
     };
 }
-export function pendingPlanForPlannerTask(job, task) {
-    return {
-        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: 'PLANNING', guidance: task.plannerGuidance, assessment: 'Planning in progress.', generatedTaskIds: [],
-        headSha: task.planTrigger?.currentHeadSha ?? job.headSha, createdAt: task.createdAt, updatedAt: task.updatedAt,
-    };
+export function pendingPlan(job) {
+    return [...(job.plans ?? [])].filter(plan => plan.status === 'PLANNING').sort((a, b) => a.round - b.round)[0] ?? null;
 }
-export function recoverPendingPlannerTask(job, timeoutMs) {
-    const pending = (job.plans ?? []).filter(plan => plan.status === 'PLANNING' && !job.tasks.some(task => task.kind === 'planner' && task.id === plan.id)).sort((a, b) => a.round - b.round)[0];
-    if (!pending)
-        return null;
-    const task = createPlannerRoundTask(job, { guidance: pending.guidance, manual: pending.trigger.source === 'manual', timeoutMs, now: pending.createdAt });
-    if (task.id !== pending.id || task.planningRound !== pending.round)
-        throw new Error(`Pending Plan ${pending.id} cannot be recovered as planner round ${task.id}`);
-    task.previousPlannerTaskId = pending.previousPlanId;
-    task.planTrigger = pending.trigger;
-    task.planningSource = pending.source;
-    task.planningDecisionId = pending.id;
-    task.input = plannerInput({ job, tasks: job.tasks, objective: job.objective ?? job.description ?? job.title, previousPlannerTaskId: pending.previousPlanId, trigger: pending.trigger, guidance: pending.guidance });
-    return task;
+export function materializePlannerChild(job, planner, spec, executionContext) {
+    validateAgentSelection(executionContext, spec.agentName, spec.agentGraph);
+    const now = new Date().toISOString();
+    const decisionId = 'round' in planner ? planner.id : planner.id;
+    const source = 'round' in planner ? planner.source : planner.planningSource ?? 'model-planner';
+    const round = 'round' in planner ? planner.round : planner.planningRound ?? 1;
+    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 });
 }
 export function planningSpec(task) {
     if (!task.output && task.adapter !== 'orchestrator')
@@ -339,6 +343,18 @@ export function plannerInput(context) {
         plan_trigger: context.trigger,
         legacy_change_cycle: context.job.changeCycle,
         semantic_task_tree: semanticTaskTree(context.tasks),
+        plans: (context.job.plans ?? []).map(plan => ({
+            id: plan.id,
+            round: plan.round,
+            status: plan.status,
+            source: plan.source,
+            previous_plan_id: plan.previousPlanId,
+            trigger: plan.trigger,
+            objective_status: plan.objectiveStatus,
+            assessment: boundedText(plan.assessment),
+            generated_task_ids: plan.generatedTaskIds,
+            error: boundedText(plan.error, 2000),
+        })),
         project: project ? { name: project.name, path: project.path } : undefined,
         visible_agents: visibleAgents ?? [],
         tasks: context.tasks.map(task => ({