agents-relay 2.0.101 → 2.0.103

package/dist/blockers.js

@@ -98,16 +98,16 @@ export async function resolveBlockerDependencies(options) {
         catch (error) {
             loadError = error instanceof Error ? error.message : String(error);
         }
-        const targetMatches = !!task && ['DRAFT', 'FAILED', 'BLOCKED', 'UNBLOCKED'].includes(task.state) && task.attempt === relation.blockedAttempt;
+        const targetMatches = !!task && ['DRAFT', 'FAILED', 'BLOCKED', 'QUEUED'].includes(task.state) && task.attempt === relation.blockedAttempt;
         let note = 'dependent task requeued';
         const decision = await dispatchBlockerResolution({
             resolutionAllowed: !(mode === 'verified' && options.resolution !== 'verified'),
             targetMatches,
             autonomousJob: targetJob?.executionMode === 'autonomous',
             effectivelyBlocked: !!task && isEffectivelyBlocked(task),
-            alreadyUnblocked: task?.state === 'UNBLOCKED' && Boolean(task.unblock),
+            alreadyUnblocked: Boolean(task?.unblock && ['DRAFT', 'QUEUED'].includes(task.state)),
             isDraft: task?.state === 'DRAFT', isBlocked: task?.state === 'BLOCKED',
-            isFailed: task?.state === 'FAILED', isUnblocked: task?.state === 'UNBLOCKED',
+            isFailed: task?.state === 'FAILED', isUnblocked: Boolean(task?.unblock && ['DRAFT', 'QUEUED'].includes(task.state)),
         }, async (actionId) => {
             if (!targetJob || !task)
                 throw new Error('Blocker graph requested action without a matching dependent task');

package/dist/cli-help.js

@@ -90,7 +90,7 @@ Example:
     'job merge': `Request an idempotent external pull-request merge; return QUEUED until confirmed, when the Graph Engine completes the Job.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. The current PR head SHA is pinned into the merge request.`,
-    'job unblock': `Authoritatively unblock the effective BLOCKED work Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Autonomous Jobs transition blocked work to historical UNBLOCKED state and wake Planner with unblock facts as Plan trigger/context; fixed Jobs record UNBLOCKED first and then resume according to fixed-job retry semantics.`,
+    'job unblock': `Authoritatively unblock the effective BLOCKED work Tasks in one Job.\n\nRequired: --repo OWNER/REPO --pr NUMBER --id JOB_ID --reason TEXT. Autonomous Jobs move blocked work to planner-waiting DRAFT with durable unblock facts; fixed Jobs resume directly as QUEUED with a reset retry budget.`,
     'job cancel': `Cancel the durable Job and close its backing pull request.
 
 Required: --repo OWNER/REPO, --pr NUMBER, and --id JOB_ID. Nonterminal Tasks are cancelled before the PR is closed.`,

package/dist/cli.js

@@ -153,7 +153,7 @@ async function runTaskCommand(action, args) {
             if (!task)
                 throw new Error(`Task ${taskId} not found`);
             const expectedUpdatedAt = task.updatedAt;
-            if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
+            if (['RUNNING', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
                 throw new Error(`Task ${taskId} is ${task.state}; durable execution fields are immutable in this state`);
             if (hasArg(args, '--title'))
                 task.title = arg(args, '--title');
@@ -260,7 +260,7 @@ async function runTaskCommand(action, args) {
         return;
     }
     const expectedUpdatedAt = task.updatedAt;
-    if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
+    if (['RUNNING', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
         throw new Error(`Task ${id} is ${task.state}; durable execution fields are immutable in this state`);
     if (hasArg(args, '--adapter')) {
         const adapter = arg(args, '--adapter');

package/dist/dashboard-actions.js

@@ -46,11 +46,7 @@ export function dashboardTaskSetState(store) {
         if (task.state === state)
             return job;
         if (task.state === 'BLOCKED' && state !== 'CANCELLED')
-            throw new Error(`Task ${task.id} is BLOCKED; only authoritative unblock may transition it to UNBLOCKED`);
-        if (state === 'UNBLOCKED')
-            throw new Error(`Task ${task.id} may enter UNBLOCKED only through authoritative unblock`);
-        if (task.state === 'UNBLOCKED')
-            throw new Error(`Task ${task.id} is historical UNBLOCKED work and cannot be changed by dashboard state override`);
+            throw new Error(`Task ${task.id} is BLOCKED; only authoritative unblock may resume it`);
         const now = new Date().toISOString();
         const from = task.state;
         await dispatchWorkflowTargetOverride(taskLifecycleV2, {

package/dist/dashboard-html.js

@@ -61,7 +61,7 @@ export const dashboardHtml = `<!doctype html>
     .status-pill.ok,.badge.ACTIVE,.badge.RUNNING,.badge.SUCCEEDED,.badge.COMPLETED,.badge.MERGED { background:#e5f3e9; color:var(--ok); }
     .status-pill.warn,.badge.BLOCKED,.badge.DRAFT,.badge.QUEUED,.badge.WAITING,.badge.OPEN { background:#fff1d2; color:var(--warn); }
     .status-pill.bad,.badge.FAILED { background:#ffe8e8; color:var(--bad); }
-    .status-pill.neutral,.badge.IDLE,.badge.UNBLOCKED,.badge.CANCELLED { background:#edf0f4; color:var(--muted); }
+    .status-pill.neutral,.badge.IDLE,.badge.CANCELLED { background:#edf0f4; color:var(--muted); }
     .badge.DRAFT { background:#eef2ff; color:#3f51b5; }
     .badge.MERGE_PENDING { background:#ffe3a3; color:#7a4a00; }
     .job-summary,.detail-groups { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:.55rem; }
@@ -339,7 +339,7 @@ function shortManagedId(id,repository,kind){const parts=String(repository||'').s
 function jobForSelection(selection){return jobs.find(job=>jobSelectionKey(job)===selection)||jobs.find(job=>job.id===selection)||null;}
 function selected(){return jobForSelection(selectedJob)||jobs[0]||null;}
 function counts(tasks){const out={};for(const task of Array.isArray(tasks)?tasks:[])out[task.state]=(out[task.state]||0)+1;return out;}
-function compactCounts(input){const order=['RUNNING','BLOCKED','UNBLOCKED','FAILED','QUEUED','DRAFT','SUCCEEDED','CANCELLED'];return order.filter(state=>input[state]).map(state=>input[state]+' '+state).join(', ')||'No tasks';}
+function compactCounts(input){const order=['RUNNING','BLOCKED','FAILED','QUEUED','DRAFT','SUCCEEDED','CANCELLED'];return order.filter(state=>input[state]).map(state=>input[state]+' '+state).join(', ')||'No tasks';}
 function relativeTime(timestamp){if(!timestamp)return '—';const parsed=Date.parse(timestamp);if(!Number.isFinite(parsed))return value(timestamp);const seconds=Math.max(0,Math.round((Date.now()-parsed)/1000));if(seconds<60)return 'just now';if(seconds<3600)return Math.floor(seconds/60)+'m ago';if(seconds<86400)return Math.floor(seconds/3600)+'h ago';return Math.floor(seconds/86400)+'d ago';}
 function cadence(job){const schedule=job?.schedule;if(!schedule?.cron)return '—';const cron=String(schedule.cron).trim();const timezone=value(schedule.timezone||'UTC');const fields=cron.split(/\\s+/);let label=cron;if(fields.length===5){const [minute,hour,day,month,weekday]=fields;if(day==='*'&&month==='*'&&weekday==='*'){const everyMinute=minute.match(/^\\*\\/(\\d+)$/);if(everyMinute&&hour==='*')label='Every '+everyMinute[1]+' min';else if(minute==='0'&&hour==='*')label='Hourly';else if(/^\\d+$/.test(minute)&&/^\\d+$/.test(hour)){const hh=String(Number(hour)).padStart(2,'0');const mm=String(Number(minute)).padStart(2,'0');label='Daily '+hh+':'+mm;}}}return label+' · '+cron+' · '+timezone;}
 function safePrUrl(repository,prNumber){if(typeof repository!=='string'||!Number.isInteger(prNumber)||prNumber<=0)return null;const parts=repository.split('/');if(parts.length!==2)return null;const [owner,repo]=parts;if(!owner||!repo||owner==='.'||owner==='..'||repo==='.'||repo==='..')return null;if(!/^[A-Za-z0-9-]+$/.test(owner)||!/^[A-Za-z0-9._-]+$/.test(repo))return null;return 'https://github.com/'+owner+'/'+repo+'/pull/'+prNumber;}
@@ -397,9 +397,9 @@ function attemptBudget(task){const attempt=Number(task?.attempt)||0;const max=Nu
 const JOB_STATES=['DRAFT','ACTIVE','COMPLETED','CANCELLED'];
 async function setJobState(job,state,select){if(!job||state===job.state)return;select.disabled=true;try{const params=new URLSearchParams({id:job.id,state,repo:job.repository,pr:String(job.prNumber)});const response=await fetch('/api/job-state?'+params.toString(),{method:'POST'});if(!response.ok)throw new Error(response.status+' '+response.statusText);const updated=await response.json();const index=jobs.findIndex(candidate=>jobSelectionKey(candidate)===jobSelectionKey(job));if(index>=0)jobs[index]=updated;else jobs.push(updated);renderAll();void loadEventHistory();}catch(error){select.title='Set job lifecycle state: '+error.message;select.value=job.state;}finally{select.disabled=false;}}
 function jobStateField(job){const box=element('div','detail-group');box.append(element('p','detail-label',text('Lifecycle state')));const select=document.createElement('select');select.className='job-filter job-state-select';select.setAttribute('aria-label','Job lifecycle state');for(const state of JOB_STATES)select.append(new Option(state,state));select.value=job.state;select.addEventListener('change',()=>void setJobState(job,select.value,select));box.append(select);return box;}
-const TASK_STATES=['DRAFT','QUEUED','RUNNING','BLOCKED','UNBLOCKED','SUCCEEDED','FAILED','CANCELLED'];
+const TASK_STATES=['DRAFT','QUEUED','RUNNING','BLOCKED','SUCCEEDED','FAILED','CANCELLED'];
 async function setTaskState(task,state,select){const job=selected();if(!job||state===task.state)return;select.disabled=true;try{const params=new URLSearchParams({id:job.id,task:task.id,state,repo:job.repository,pr:String(job.prNumber)});const response=await fetch('/api/task-state?'+params.toString(),{method:'POST'});if(!response.ok)throw new Error(response.status+' '+response.statusText);const updated=await response.json();const index=jobs.findIndex(candidate=>jobSelectionKey(candidate)===jobSelectionKey(job));if(index>=0)jobs[index]=updated;else jobs.push(updated);renderAll();void loadEventHistory();}catch(error){select.title='Set task state: '+error.message;select.value=task.state;}finally{select.disabled=false;}}
-function taskStateField(task){const box=element('div','detail-group');box.append(element('p','detail-label',text('State')));const select=document.createElement('select');select.className='job-filter task-state-select';select.setAttribute('aria-label','Task state');for(const state of TASK_STATES){const option=new Option(state,state);if(state==='UNBLOCKED'&&task.state!=='UNBLOCKED')option.disabled=true;select.append(option);}select.value=task.state;select.addEventListener('change',()=>void setTaskState(task,select.value,select));box.append(select);return box;}
+function taskStateField(task){const box=element('div','detail-group');box.append(element('p','detail-label',text('State')));const select=document.createElement('select');select.className='job-filter task-state-select';select.setAttribute('aria-label','Task state');for(const state of TASK_STATES)select.append(new Option(state,state));select.value=task.state;select.addEventListener('change',()=>void setTaskState(task,select.value,select));box.append(select);return box;}
 function manualOverrideField(task){const rows=Array.isArray(task.manualStateOverrides)?task.manualStateOverrides:[];const last=rows.at(-1);return field('Manual override',last?last.from+' → '+last.to+' · '+relativeTime(last.at):'—');}
 function renderTaskDetail(task){taskDetailRoot.replaceChildren();if(!task){taskDetailRoot.append(element('p','empty',text('Select a task to inspect execution details.')));return;}const routing=task.routing||{};const groups=element('div','detail-groups');groups.append(field('Title',task.title||'—'),field('Task ID',task.id),field('Kind',task.kind||'work'),taskStateField(task),manualOverrideField(task),field('Planning decision',task.planningDecisionId||'—'),field('Planning source',task.planningSource||'—'),field('Planning round',task.planningRound===undefined?'—':String(task.planningRound)),field('Project / agent',value(task.projectName)+' / '+value(task.agentName)),field('Parent task',task.parentTaskId||'root'),field('Adapter',task.adapter),field('Provider / model',value(routing.provider)+' / '+value(routing.model)),field('Reasoning / profile',value(routing.reasoning||routing.profile)),field('Attempt',attemptBudget(task)),field('Dependencies',Array.isArray(task.dependencies)&&task.dependencies.length?task.dependencies.join(', '):'none'),taskCommentField(task),chatField(task));const job=selected();if(task.reviewHeadSha&&job)groups.append(commitField('HEAD commit',job,task.reviewHeadSha));const graph=agentGraphField(task);if(graph)groups.append(graph);if(task.plannerResult)groups.append(field('Objective status',task.plannerResult.objective_status),markdownField('Assessment',task.plannerResult.assessment));if(task.error)groups.append(field('Error',task.error));taskDetailRoot.append(groups);}
 function reviewStatus(job){const review=job?.review;if(!review)return 'Not started';if(review.outcome==='approved'&&review.headSha===job.headSha)return 'MERGE READY · approved';const stale=Array.isArray(job?.tasks)&&job.tasks.some(task=>task.agentName==='reviewer'&&task.reviewHeadSha&&job.headSha&&task.reviewHeadSha!==job.headSha);if(stale)return 'STALE · awaiting review';return String(review.outcome||'pending').replace('_',' ').toUpperCase();}

package/dist/interactive-resume.js

@@ -13,7 +13,7 @@ export async function resumeInteractiveTask(store, jobId, taskId, invocationId,
             invocation.status !== decision || !invocation.decidedAt)
             return job;
         // Both state transitions and retry eligibility are owned by task-lifecycle.mmd.
-        if (!tryTransitionTaskEvent(task, 'task.unblocked').accepted) {
+        if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted) {
             throw new Error('Interactive Task unblock rejected by canonical lifecycle Graph');
         }
         applyTaskUnblockRetrySnapshot(task);

package/dist/local-authority-store.js

@@ -14,7 +14,7 @@ import { nextScheduleRun, scheduleBucket } from './scheduler.js';
  * not lifecycle storage. An explicit one-time import must use RelayStore directly.
  */
 const TASK_STATE_ORDER = {
-    DRAFT: 0, QUEUED: 1, UNBLOCKED: 2, RUNNING: 3, BLOCKED: 4,
+    DRAFT: 0, QUEUED: 1, RUNNING: 2, BLOCKED: 3,
     SUCCEEDED: 5, FAILED: 5, CANCELLED: 5,
 };
 export class LocalAuthorityDurableStore {

package/dist/planner-runtime.js

@@ -8,6 +8,7 @@ import { samePlannerChildDefinition } from './planner-child.js';
 import { dispatchJobLifecycleSync } from './workflow/lifecycle.js';
 import { withExecutionBoundary } from './reconciler-runtime.js';
 import { storySizeTimeoutMs } from './types.js';
+import { tryTransitionTaskEvent } from './scheduler.js';
 /** Activate queued planner work inside the same authoritative SQLite mutation. */
 export function activateCommittedPlannerWork(job) {
     if (job.state !== 'DRAFT' || !job.tasks.some(item => item.state === 'QUEUED'))
@@ -80,7 +81,7 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                 return;
             const attempt = fresh.attempt ?? 0;
             const maxAttempts = fresh.maxAttempts ?? (fresh.manualPlanning ? 1 : 3);
-            retry = attempt < maxAttempts;
+            retry = attempt < maxAttempts && !message.startsWith('Planner JSON correction failed after one retry:');
             fresh.status = retry ? 'PLANNING' : 'FAILED';
             fresh.retryFeedback = message;
             fresh.error = message;
@@ -167,6 +168,17 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                     else if (!samePlannerChildDefinition(existing, child))
                         throw new Error(`Planner child ${child.id} already exists with a different definition`);
                 }
+                const consumedUnblocks = new Set(durablePlan.trigger.source === 'unblock' ? durablePlan.trigger.taskIds ?? [] : []);
+                for (const task of current.tasks) {
+                    if (!consumedUnblocks.has(task.id) || !task.unblock || task.state === 'CANCELLED' || durablePlan.generatedTaskIds.includes(task.id))
+                        continue;
+                    if (tryTransitionTaskEvent(task, 'cancel').accepted) {
+                        task.error = `Superseded by successful unblock plan ${durablePlan.id}`;
+                        task.leaseOwner = null;
+                        task.leaseExpiresAt = null;
+                        task.executionId = null;
+                    }
+                }
                 // Planner children are committed atomically with Job activation.
                 // Otherwise the DRAFT Job is invisible to the ACTIVE-only dispatcher.
                 activateCommittedPlannerWork(current);
@@ -199,6 +211,15 @@ async function finishPlanner(ports, jobId, planId, executionId, error, raw) {
                 job.updatedAt = now;
                 await ports.store.saveJob(job);
             }
+            const consumedUnblocks = new Set(plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []);
+            for (const task of job.tasks) {
+                if (!consumedUnblocks.has(task.id) || !task.unblock || task.state === 'CANCELLED' || plan.generatedTaskIds.includes(task.id))
+                    continue;
+                if (tryTransitionTaskEvent(task, 'cancel').accepted) {
+                    task.error = `Superseded by successful unblock plan ${plan.id}`;
+                    await ports.store.saveTask(task);
+                }
+            }
             for (const child of children)
                 if (!job.tasks.some(item => item.id === child.id)) {
                     const spec = result.next_tasks.find(item => item.id === child.id);

package/dist/planner.js

@@ -21,8 +21,8 @@ export function semanticTaskTree(tasks) {
     };
 }
 function plannerTrigger(job, manual = false) {
-    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));
+    const consumed = new Set((job.plans ?? []).filter(plan => plan.status === 'SUCCEEDED').flatMap(plan => plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
+    const unblocked = job.tasks.filter(task => ['DRAFT', 'QUEUED', 'UNBLOCKED'].includes(task.state) && task.unblock && !consumed.has(task.id));
     const hasUnblock = unblocked.length > 0 || Boolean(job.changeCycle && !job.changeCycle.consumedByPlannerTaskId);
     const decision = dispatchPlannerTrigger({
         manualPlan: manual,
@@ -502,17 +502,14 @@ export class AgentObjectivePlanner {
         this.agentFile = agentFile;
     }
     async plan(context, signal) {
-        const resolvedPlanner = context.executionContext?.agents.find(agent => agent.name === 'planner')?.path;
         const effectivePlanner = context.executionContext ? await resolveAgentMarkdown('planner', BUNDLED_AGENTS_ROOT, context.executionContext.project.path) : undefined;
         const instructions = effectivePlanner?.content ?? await readFile(this.agentFile, 'utf8');
         const contract = await readFile(DEFAULT_TASK_JOB_CONTRACT, 'utf8');
         const resolvedContext = context.executionContext ? executionContextPrompt(context.executionContext) + '\n\n' : '';
         const prompt = (effectivePlanner ? `[Effective planner contract SHA-256: ${effectivePlanner.hash}]\n\n` : '') + instructions.trim() + '\n\n## Shared Task / Job Contract\n\n' + contract.trim() + '\n\n' + resolvedContext + '## Durable planner input\n\n' + plannerInput(context);
-        return await new Promise((resolve, reject) => {
-            const child = spawnOwnedProcess(this.command, ['exec', '--json', '--', prompt], { invocation: 'planner.agent', signal, correlation: { jobId: context.job.id }, spawn: { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] } });
-            let stdoutBuffer = '';
-            let finalMessage = '';
-            let stderrTail = '';
+        const runAgent = (input) => new Promise((resolve, reject) => {
+            const child = spawnOwnedProcess(this.command, ['exec', '--json', '--', input], { invocation: 'planner.agent', signal, correlation: { jobId: context.job.id }, spawn: { cwd: context.executionContext?.project.path, stdio: ['ignore', 'pipe', 'pipe'] } });
+            let stdoutBuffer = '', finalMessage = '', stderrTail = '';
             const consume = (line) => {
                 const message = parsePlannerAgentMessage(line);
                 if (message)
@@ -538,13 +535,23 @@ export class AgentObjectivePlanner {
                     reject(new Error('Planner agent returned no final message'));
                     return;
                 }
-                try {
-                    resolve(parsePlannerOutput(finalMessage));
-                }
-                catch (error) {
-                    reject(error);
-                }
+                resolve(finalMessage);
             });
         });
+        const first = await runAgent(prompt);
+        try {
+            return parsePlannerOutput(first);
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            const correction = `${prompt}\n\n## Format correction (one retry only)\nYour previous final response was not valid Planner JSON. Error: ${error instanceof Error ? error.message : String(error)}\nPrevious response (possibly truncated):\n${first.slice(0, 12000)}\nReturn exactly one valid JSON object conforming to the Planner contract. No prose, no second JSON object.`;
+            try {
+                return parsePlannerOutput(await runAgent(correction));
+            }
+            catch (retryError) {
+                throw new Error(`Planner JSON correction failed after one retry: ${retryError instanceof Error ? retryError.message : String(retryError)}`);
+            }
+        }
     }
 }

package/dist/projected-store.js

@@ -344,7 +344,7 @@ export class ProjectedDurableStore {
             tasks.push(structuredClone(task));
         job.tasks = tasks;
         const value = structuredClone(task);
-        const terminal = ['SUCCEEDED', 'FAILED', 'BLOCKED', 'UNBLOCKED', 'CANCELLED'].includes(task.state);
+        const terminal = ['SUCCEEDED', 'FAILED', 'BLOCKED', 'CANCELLED'].includes(task.state);
         await this.relay.saveJobWithProjection(job, {
             idempotencyKey: `save_task:${task.jobId}:${task.id}`,
             coalesceKey: taskKey(task),

package/dist/reconciler-cancellation.js

@@ -12,7 +12,7 @@ export async function cancelActiveTasks(store, jobId, reason, cancelPlanner, can
         plan.updatedAt = new Date().toISOString();
         await store.savePlan(plan);
     }
-    for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
+    for (const task of job.tasks.filter(item => item.kind !== 'planner' && !['SUCCEEDED', 'FAILED', 'CANCELLED'].includes(item.state))) {
         cancelExecutionGeneration(job.id, task.id, task.executionId ?? task.executionHistory?.at(-1)?.id);
         cancelPlanner(task.id);
         await applyTaskCancelAction(task, reason);

package/dist/relay-store.js

@@ -2,6 +2,7 @@ import { preserveTaskComments } from './task-comments.js';
 import { DatabaseSync } from 'node:sqlite';
 import { dirname } from 'node:path';
 import { mkdirSync } from 'node:fs';
+import { normalizeLegacyTaskLifecycle } from './types.js';
 import { recordPublicationInDatabase, loadPublicationFromDatabase, listPublicationEventsFromDatabase } from './publication-store.js';
 import { observability } from './observability.js';
 import { createJobIfAbsent } from './relay-create.js';
@@ -140,11 +141,15 @@ export class SQLiteRelayStore {
     async loadJob(jobId) {
         this.assertScope(jobId);
         const row = this.db.prepare('SELECT json FROM job_snapshot WHERE job_id=?').get(jobId);
-        return row?.json ? normalizeLegacyJobPrNumber(JSON.parse(row.json)) : null;
+        if (!row?.json)
+            return null;
+        const job = normalizeLegacyJobPrNumber(JSON.parse(row.json));
+        job.tasks = job.tasks.map(task => normalizeLegacyTaskLifecycle(task, job.executionMode));
+        return job;
     }
     async listJobs() {
         const rows = this.db.prepare(this.scopeJobId ? 'SELECT json FROM job_snapshot WHERE job_id=? ORDER BY job_id' : 'SELECT json FROM job_snapshot ORDER BY job_id').all(...(this.scopeJobId ? [this.scopeJobId] : []));
-        return rows.map(row => normalizeLegacyJobPrNumber(JSON.parse(row.json)));
+        return rows.map(row => { const job = normalizeLegacyJobPrNumber(JSON.parse(row.json)); job.tasks = job.tasks.map(task => normalizeLegacyTaskLifecycle(task, job.executionMode)); return job; });
     }
     async saveJob(job) {
         if (!this.scopeJobId) {
@@ -176,6 +181,7 @@ export class SQLiteRelayStore {
             if (!row?.json)
                 throw new Error(`Local authoritative Job ${jobId} not found`);
             const current = normalizeLegacyJobPrNumber(JSON.parse(row.json));
+            current.tasks = current.tasks.map(task => normalizeLegacyTaskLifecycle(task, current.executionMode));
             const before = JSON.stringify(current);
             const next = mutation(current);
             if (next.id !== jobId)

package/dist/runtime-status.js

@@ -7,7 +7,7 @@ export function implementationTasks(job) {
         && task.agentName !== 'reviewer'
         && task.agentName !== 'troubleshooter'
         && !isSuperseded(task)
-        && task.state !== 'UNBLOCKED');
+        && task.state !== 'DRAFT');
 }
 export function implementationComplete(job) {
     const tasks = implementationTasks(job);

package/dist/store.js

@@ -1,3 +1,4 @@
+import { normalizeLegacyTaskLifecycle } from './types.js';
 import { parseAgent, parseJob, parsePlan, parseTask, renderAgentComment, renderJobComment, renderPlanComment, renderTaskComment, AGENT_MARKER, JOB_MARKER, PLAN_MARKER, TASK_MARKER } from './markers.js';
 import { DurableDefinitionConflictError, isTaskForJob, planDefinitionDivergence, samePlanDefinition, sameTaskDefinition, taskDefinitionDivergence } from './store-task-definition.js';
 import { parsePackagePublicationMarker } from './github-webhook.js';
@@ -91,7 +92,7 @@ export class InMemoryStore {
         }
     }
     async load(jobId) { const job = await this.findJob(jobId); if (!job)
-        throw new Error(`Job ${jobId} not found`); job.plans = this.plansForJob(jobId); job.tasks = this.tasksForJob(jobId); return job; }
+        throw new Error(`Job ${jobId} not found`); job.plans = this.plansForJob(jobId); job.tasks = this.tasksForJob(jobId).map(task => normalizeLegacyTaskLifecycle(task, job.executionMode)); return job; }
     async saveJob(job) { this.values.set(`${JOB_MARKER}:${job.id}`, renderJobComment(job)); }
     async appendPlan(plan) { const key = `${PLAN_MARKER}:${plan.jobId}:${plan.id}`; const existing = this.values.get(key); if (existing) {
         const current = parsePlan(existing);

package/dist/task-actions.js

@@ -40,9 +40,12 @@ function applyTaskRetrySnapshot(task, policy = {}) {
 }
 /** Fixed-job authoritative unblock continuation, applied inside one Job snapshot mutation. */
 export function applyTaskUnblockRetrySnapshot(task) {
-    if (!tryTransitionTaskEvent(task, 'retry').accepted)
+    if (task.state === 'BLOCKED' && !tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted)
         throw lifecycleRejection(task, 'retryable after unblock');
-    task.maxAttempts = extendRetryBudget(task);
+    if (!['QUEUED', 'DRAFT'].includes(task.state))
+        throw lifecycleRejection(task, 'retryable after unblock');
+    task.attempt = 0;
+    task.maxAttempts = Math.max(3, task.maxAttempts);
     clearExecution(task);
     delete task.blockedBy;
 }
@@ -58,8 +61,12 @@ export async function applyTaskRetryAction(task, policy = {}) {
 }
 /** Fixed-job authoritative unblock continuation: legality is owned by the lifecycle graph. */
 export async function applyTaskUnblockRetryAction(task) {
-    await transitionTaskAction(task, 'retry', 'retryable after unblock');
-    task.maxAttempts = extendRetryBudget(task);
+    if (task.state === 'BLOCKED')
+        await transitionTaskAction(task, 'task.unblocked', 'retryable after unblock', { autonomousJob: false });
+    if (!['QUEUED', 'DRAFT'].includes(task.state))
+        throw lifecycleRejection(task, 'retryable after unblock');
+    task.attempt = 0;
+    task.maxAttempts = Math.max(3, task.maxAttempts);
     clearExecution(task);
     delete task.blockedBy;
     return task;

package/dist/task-update.js

@@ -13,7 +13,7 @@ export async function applyManagedTaskUpdate(store, jobId, taskId, proposed, exp
         throw new Error('Task update identity mismatch');
     if (current.updatedAt !== expectedUpdatedAt)
         throw new Error('Task changed since update preflight; refresh and retry');
-    if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(current.state) || current.executionId || current.leaseOwner)
+    if (['RUNNING', 'SUCCEEDED', 'CANCELLED'].includes(current.state) || current.executionId || current.leaseOwner)
         throw new Error('Task is not mutable while active or terminal');
     if (current.attempt > 0 && current.adapter !== proposed.adapter)
         throw new Error('Cannot replace adapter after an execution attempt');

package/dist/troubleshooter.js

@@ -32,7 +32,7 @@ function belongsToCurrentRun(job, task) {
     const slot = job.schedule?.currentRunSlot;
     return !slot || task.createdAt >= slot;
 }
-const ACTIVE_RECOVERY_STATES = new Set(['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'UNBLOCKED']);
+const ACTIVE_RECOVERY_STATES = new Set(['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED']);
 function recoveryTargetsTask(recovery, original) {
     if (recovery.agentName !== 'troubleshooter')
         return false;

package/dist/types.js

@@ -3,5 +3,16 @@ export const STORY_SIZE_TIMEOUT_MS = { S: 300000, M: 900000, L: 2700000 };
 export function storySizeTimeoutMs(size) { return STORY_SIZE_TIMEOUT_MS[size]; }
 export function taskOverallTimeoutMs(size, reasoning) { return storySizeTimeoutMs(size) * (reasoning?.toLowerCase() === 'high' ? 2 : 1); }
 export function chatGptStartAckTimeoutMs(overallTimeoutMs) { return Math.min(600000, Math.max(120000, Math.floor(overallTimeoutMs / 3))); }
+/** Normalize snapshots written before UNBLOCKED was removed from the lifecycle graph. */
+export function normalizeLegacyTaskLifecycle(task, executionMode) {
+    const legacy = task;
+    if (legacy.state !== 'UNBLOCKED')
+        return task;
+    legacy.state = executionMode === 'autonomous' ? 'DRAFT' : 'QUEUED';
+    // Preserve the historical execution count when upgrading old snapshots.
+    task.maxAttempts = Math.max(3, task.maxAttempts ?? 0, task.attempt + 1);
+    task.unblock = task.unblock ? { ...task.unblock, event: 'task.unblocked' } : undefined;
+    return task;
+}
 export function assertJobLifecycleTransition(from, to) { assertV2StateTransition(jobLifecycleV2.graph, from, to, 'job'); }
 export function assertTaskTransition(from, to) { assertV2StateTransition(taskLifecycleV2.graph, from, to, 'task'); }

package/dist/unblock.js

@@ -26,8 +26,8 @@ function unblockFacts(job, tasks, currentHeadSha, reason) {
     return [...new Set(facts)];
 }
 export function unconsumedUnblockTrigger(job) {
-    const consumed = new Set((job.plans ?? []).flatMap(plan => plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
-    const tasks = job.tasks.filter(task => task.state === 'UNBLOCKED' && task.unblock && !consumed.has(task.id));
+    const consumed = new Set((job.plans ?? []).filter(plan => plan.status === 'SUCCEEDED').flatMap(plan => plan.trigger.source === 'unblock' ? plan.trigger.taskIds ?? [] : []));
+    const tasks = job.tasks.filter(task => task.unblock && !consumed.has(task.id) && ['DRAFT', 'QUEUED', 'UNBLOCKED'].includes(task.state));
     if (tasks.length === 0) {
         const legacy = job.changeCycle;
         if (!legacy || legacy.consumedByPlannerTaskId)
@@ -59,10 +59,10 @@ export async function unblockAutonomousTasks(options) {
             if (!task || !isEffectivelyBlocked(task))
                 throw new Error(`Task ${requested.id} changed before authoritative unblock`);
             const baseline = baselineFor(task);
-            if (!tryTransitionTaskEvent(task, 'task.unblocked').accepted)
+            if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: true }).accepted)
                 throw new Error(`Task ${task.id} cannot be authoritatively unblocked`);
             task.blockedBaseline = baseline;
-            task.unblock = { at: now, source: trigger.source, reason: trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: trigger.blockerJobId, resolution: trigger.resolution };
+            task.unblock = { event: 'task.unblocked', at: now, source: trigger.source, reason: trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: trigger.blockerJobId, resolution: trigger.resolution };
             task.updatedAt = now;
             delete task.blockedBy;
         }
@@ -98,16 +98,16 @@ export async function unblockTask(options) {
             const baseline = baselineFor(options.task);
             options.task.blockedBaseline = baseline;
             const facts = unblockFacts(options.job, [options.task], currentHeadSha, options.trigger.reason);
-            options.task.unblock = { at: now, source: options.trigger.source, reason: options.trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: options.trigger.blockerJobId, resolution: options.trigger.resolution };
+            options.task.unblock = { event: 'task.unblocked', at: now, source: options.trigger.source, reason: options.trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: options.trigger.blockerJobId, resolution: options.trigger.resolution };
             const apply = (current) => {
                 const task = current.tasks.find(item => item.id === options.task.id);
                 if (!task || !isEffectivelyBlocked(task))
                     throw new Error(`Task ${options.task.id} changed before authoritative unblock`);
-                if (!tryTransitionTaskEvent(task, 'task.unblocked').accepted)
+                if (!tryTransitionTaskEvent(task, 'task.unblocked', { autonomousJob: false }).accepted)
                     throw new Error(`Task ${task.id} cannot be authoritatively unblocked`);
                 const baseline = baselineFor(task);
                 task.blockedBaseline = baseline;
-                task.unblock = { at: now, source: options.trigger.source, reason: options.trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: options.trigger.blockerJobId, resolution: options.trigger.resolution };
+                task.unblock = { event: 'task.unblocked', at: now, source: options.trigger.source, reason: options.trigger.reason, baseline, currentHeadSha: currentHeadSha ?? undefined, facts, blockerJobId: options.trigger.blockerJobId, resolution: options.trigger.resolution };
                 applyTaskUnblockRetrySnapshot(task);
                 task.updatedAt = now;
                 delete task.blockedBy;

package/dist/workflow/definitions-v2.js

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { GraphRuntime } from './graph-v2.js';
 import { WORKFLOW_EFFECT_NAMES, WORKFLOW_EVENT_NAMES, WORKFLOW_MUTATION_NAMES, } from './contracts.js';
-const TASK_STATES = ['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'UNBLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'];
+const TASK_STATES = ['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'SUCCEEDED', 'FAILED', 'CANCELLED'];
 const JOB_STATES = ['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'];
 const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
 function eventRegistry() {
@@ -27,6 +27,7 @@ export const taskLifecycleV2 = load('task-lifecycle', TASK_STATES, {
     recoverableExecution: boolGuard('recoverableExecution'),
     troubleshooterRecovery: boolGuard('troubleshooterRecovery'),
     retryAvailable: boolGuard('retryAvailable'),
+    autonomousJob: boolGuard('autonomousJob'),
 });
 export const jobLifecycleV2 = load('job-lifecycle', JOB_STATES, {
     notMerged: boolGuard('notMerged'),

package/dist/workflow/planner-orchestration-v2.js

@@ -52,9 +52,9 @@ export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
         hasSeedWork: !((job.plans?.length ?? 0) === 0 && job.tasks.filter(task => task.kind !== 'planner').length === 0),
         noActivePlanner: !scopedPlans.some(plan => plan.status === 'PLANNING'),
         noBlockedWork: Boolean(unconsumedUnblockTrigger(job)) || !scopedTasks.some(task => task.kind !== 'planner' && isEffectivelyBlocked(task)),
-        noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)),
+        noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && (['QUEUED', 'RUNNING'].includes(task.state) || (task.state === 'DRAFT' && !task.unblock))),
         resolutionOwnedByTroubleshooter: scopedTasks.some(task => task.kind !== 'planner' && task.resolution?.owner === 'troubleshooter' && ['active', 'waiting'].includes(task.resolution.state)),
-        continuationMaterialized: !(latestObjective === 'in_progress' && latestId && !job.tasks.some(task => task.kind !== 'planner' && task.planningDecisionId === latestId)),
+        continuationMaterialized: Boolean(unconsumedUnblockTrigger(job)) || !(latestObjective === 'in_progress' && latestId && !job.tasks.some(task => task.kind !== 'planner' && task.planningDecisionId === latestId)),
         objectiveUnsatisfied: latestObjective !== 'satisfied',
     };
 }

package/dist/workflow/task-reconcile.js

@@ -33,6 +33,8 @@ export function reconcileTaskDependencies(job) {
     for (const task of scopedTasks) {
         if (task.kind === 'planner')
             continue;
+        if (task.state === 'DRAFT' && task.unblock)
+            continue;
         const ready = dependencyReady(task, tasks);
         const facts = {
             dependenciesSatisfied: task.dependencies.length > 0 && ready,

package/package.json

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

package/workflow/task-lifecycle.mmd

@@ -4,7 +4,6 @@ draft["state: DRAFT"]
 queued["state: QUEUED"]
 running["state: RUNNING"]
 blocked["state: BLOCKED"]
-unblocked["state: UNBLOCKED"]
 succeeded["state: SUCCEEDED"]
 failed["state: FAILED"]
 cancelled["state: CANCELLED"]
@@ -76,6 +75,8 @@ completeClearError["action: mutation.clearError"]
 completeClearReason["action: mutation.clearFailureReason"]
 unblockRetryClearError["action: mutation.clearError"]
 unblockRetryClearReason["action: mutation.clearFailureReason"]
+unblockDraftClearError["action: mutation.clearError"]
+unblockDraftClearReason["action: mutation.clearFailureReason"]
 failedRetryClearError["action: mutation.clearError"]
 failedRetryClearReason["action: mutation.clearFailureReason"]
 recoverStartClearError["action: mutation.clearError"]
@@ -179,12 +180,15 @@ leaseFailRunningClearExecution --> failed
 running -->|on: task.cancelled| cancelled
 running -->|on: cancel| cancelled
 
-blocked -->|on: task.unblocked| unblocked
-blocked -->|on: cancel| cancelled
-
-unblocked -->|on: retry| unblockRetryClearError
+autonomousJob["guard: autonomousJob"]
+blocked -->|on: task.unblocked| autonomousJob
+autonomousJob -->|true| unblockDraftClearError
+unblockDraftClearError --> unblockDraftClearReason
+unblockDraftClearReason --> draft
+autonomousJob -->|false| unblockRetryClearError
 unblockRetryClearError --> unblockRetryClearReason
 unblockRetryClearReason --> queued
+blocked -->|on: cancel| cancelled
 
 failed -->|on: queue| depSat
 failed -->|on: retry| failedRetryClearError