agents-relay 1.0.176 → 2.0.0

package/dist/runtime-status.js

@@ -2,7 +2,8 @@ function isSuperseded(task) {
     return task.state === 'CANCELLED' && typeof task.error === 'string' && task.error.startsWith('Superseded ');
 }
 export function implementationTasks(job) {
-    return job.tasks.filter(task => task.agentName !== 'reviewer'
+    return job.tasks.filter(task => task.kind !== 'planner'
+        && task.agentName !== 'reviewer'
         && task.agentName !== 'troubleshooter'
         && !isSuperseded(task)
         && task.state !== 'UNBLOCKED');

package/dist/scheduled-jobs.js

@@ -1,49 +1,58 @@
 import { GitHubStore } from './store.js';
 import { nextScheduleRun, scheduleBucket } from './scheduler.js';
-async function refresh(client, repository, trustedAuthors, ref) {
-    const store = new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
+import { dispatchScheduledRun } from './workflow/scheduled-run-v2.js';
+async function refresh(client, repository, trustedAuthors, ref, storeFactory) {
+    const store = storeFactory ? storeFactory() : new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
     return await store.load(ref.jobId);
 }
-export async function runScheduledBucket(client, repository, trustedAuthors, ref, engine, now = new Date()) {
-    let job = await refresh(client, repository, trustedAuthors, ref);
+export async function runScheduledBucket(client, repository, trustedAuthors, ref, engine, now = new Date(), storeFactory) {
+    let job = await refresh(client, repository, trustedAuthors, ref, storeFactory);
     const schedule = job.schedule;
     if (!schedule)
-        throw new Error(`Scheduled job ${job.id} has no schedule metadata`);
+        throw new Error('Scheduled job ' + job.id + ' has no schedule metadata');
     const slot = new Date(schedule.nextRunAt);
-    if (scheduleBucket(slot) !== ref.bucket || slot.getTime() > now.getTime()) {
-        return { job, status: 'skipped-idempotent' };
-    }
-    if (schedule.lastScheduledSlot && new Date(schedule.lastScheduledSlot).getTime() >= slot.getTime()) {
-        return { job, status: 'skipped-idempotent' };
-    }
-    if (job.state !== 'ACTIVE')
-        return { job, status: 'skipped-idempotent' };
     const active = job.tasks.some(task => ['QUEUED', 'RUNNING'].includes(task.state));
-    if (active && schedule.concurrencyPolicy === 'skip') {
-        schedule.lastScheduledSlot = slot.toISOString();
-        schedule.nextRunAt = nextScheduleRun(schedule, now).toISOString();
-        job.updatedAt = now.toISOString();
-        await new GitHubStore(client, repository, ref.prNumber, trustedAuthors).saveJob(job);
-        return { job, status: 'skipped-active' };
-    }
-    if (active && schedule.concurrencyPolicy === 'queue') {
+    const schedulerStore = storeFactory ? storeFactory() : new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
+    let actionStatus = null;
+    const decision = await dispatchScheduledRun({
+        slotDue: scheduleBucket(slot) === ref.bucket && slot.getTime() <= now.getTime(),
+        slotUnclaimed: !schedule.lastScheduledSlot || new Date(schedule.lastScheduledSlot).getTime() < slot.getTime(),
+        jobActive: job.state === 'ACTIVE', hasActiveTasks: active,
+        concurrencySkip: schedule.concurrencyPolicy === 'skip', concurrencyQueue: schedule.concurrencyPolicy === 'queue',
+        runMissed: schedule.missedRunPolicy === 'run',
+    }, async (actionId) => {
+        if (actionId === 'schedule.skipActiveAdvance') {
+            schedule.lastScheduledSlot = slot.toISOString();
+            schedule.nextRunAt = nextScheduleRun(schedule, now).toISOString();
+            job.updatedAt = now.toISOString();
+            await schedulerStore.saveJob(job);
+            actionStatus = 'skipped-active';
+            return {};
+        }
+        if (actionId === 'schedule.claimFromSlot' || actionId === 'schedule.claimFromNow') {
+            schedule.lastScheduledSlot = slot.toISOString();
+            schedule.currentRunSlot = slot.toISOString();
+            schedule.nextRunAt = nextScheduleRun(schedule, actionId === 'schedule.claimFromSlot' ? slot : now).toISOString();
+            job.updatedAt = now.toISOString();
+            await schedulerStore.saveJob(job);
+            job = await schedulerStore.load(job.id);
+            return {};
+        }
+        throw new Error('Unsupported schedule graph action ' + actionId);
+    });
+    if (!decision.accepted || decision.target === 'skip_idempotent')
+        return { job, status: 'skipped-idempotent' };
+    if (actionStatus === 'skipped-active' || decision.target === 'skip_active')
         return { job, status: 'skipped-active' };
-    }
-    const missedRunPolicy = schedule.missedRunPolicy;
-    schedule.lastScheduledSlot = slot.toISOString();
-    schedule.currentRunSlot = slot.toISOString();
-    schedule.nextRunAt = nextScheduleRun(schedule, missedRunPolicy === 'run' ? slot : now).toISOString();
-    job.updatedAt = now.toISOString();
-    const schedulerStore = new GitHubStore(client, repository, ref.prNumber, trustedAuthors);
-    await schedulerStore.saveJob(job);
-    job = await schedulerStore.load(job.id);
+    if (decision.target !== 'claimed')
+        return { job, status: 'skipped-idempotent' };
     if (!engine)
         throw new Error('Scheduled jobs require the local relayd scheduler engine');
     await engine.reconcile(job.id);
     await engine.idle();
     const finished = await schedulerStore.load(job.id);
     if (!finished.schedule)
-        throw new Error(`Scheduled job ${job.id} lost its schedule metadata`);
+        throw new Error('Scheduled job ' + job.id + ' lost its schedule metadata');
     finished.schedule.lastRunAt = now.toISOString();
     finished.updatedAt = now.toISOString();
     await schedulerStore.saveJob(finished);

package/dist/scheduler.js

@@ -1,16 +1,16 @@
 import { implementationTasks } from './runtime-status.js';
-import { decideJobLifecycle, decideTaskLifecycle } from './workflow/lifecycle.js';
+import { dispatchJobLifecycle, dispatchTaskLifecycle, dispatchTaskLifecycleSync } from './workflow/lifecycle.js';
 import { reconcileTaskDependencies } from './workflow/task-reconcile.js';
 export { dependencyReady, detectCycles } from './workflow/task-reconcile.js';
-import { applyJobWorkflowDecision, applyTaskWorkflowDecision } from './workflow/runtime.js';
+import { dispatchScheduleCycle } from './workflow/schedule-cycle-v2.js';
 export function completionGateSatisfied(job) {
     if (job.schedule)
         return false;
     if (job.executionMode !== 'autonomous')
         return true;
-    const planners = job.tasks.filter(task => task.kind === 'planner');
-    return planners.some(task => task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied')
-        && implementationTasks(job).every(task => task.state === 'SUCCEEDED');
+    const planSatisfied = (job.plans ?? []).some(plan => plan.status === 'SUCCEEDED' && plan.objectiveStatus === 'satisfied');
+    const legacySatisfied = (job.plans?.length ?? 0) === 0 && job.tasks.some(task => task.kind === 'planner' && task.state === 'SUCCEEDED' && task.plannerResult?.objective_status === 'satisfied');
+    return (planSatisfied || legacySatisfied) && implementationTasks(job).every(task => task.state === 'SUCCEEDED');
 }
 export function schedule(job) {
     reconcileTaskDependencies(job);
@@ -18,16 +18,21 @@ export function schedule(job) {
         ? job.tasks.filter(task => Date.parse(task.createdAt) >= Date.parse(job.schedule?.currentRunSlot ?? ''))
         : job.tasks;
     if (job.schedule) {
-        const planners = scopedTasks.filter(task => task.kind === 'planner');
-        const latest = planners.sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)).at(-1);
-        if (latest?.state === 'SUCCEEDED' && latest.plannerResult?.objective_status === 'satisfied') {
+        const slot = Date.parse(job.schedule.currentRunSlot ?? '');
+        const scopedPlans = (job.plans ?? []).filter(plan => !Number.isFinite(slot) || Date.parse(plan.createdAt) >= slot).sort((a, b) => a.round - b.round || a.createdAt.localeCompare(b.createdAt));
+        const latestPlan = scopedPlans.at(-1);
+        const legacyLatest = scopedPlans.length === 0 ? scopedTasks.filter(task => task.kind === 'planner').sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)).at(-1) : undefined;
+        dispatchScheduleCycle({
+            hasCurrentSlot: Boolean(job.schedule.currentRunSlot),
+            plannerSatisfied: latestPlan ? latestPlan.status === 'SUCCEEDED' && latestPlan.objectiveStatus === 'satisfied' : legacyLatest?.state === 'SUCCEEDED' && legacyLatest.plannerResult?.objective_status === 'satisfied',
+        }, () => {
             const slot = job.schedule.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
             const lastRun = job.schedule.lastRunAt ? Date.parse(job.schedule.lastRunAt) : Number.NaN;
             if (Number.isFinite(slot) && (!Number.isFinite(lastRun) || lastRun < slot))
                 job.schedule.lastRunAt = new Date().toISOString();
             job.schedule.currentRunSlot = null;
             job.updatedAt = new Date().toISOString();
-        }
+        });
     }
     return job;
 }
@@ -38,27 +43,23 @@ export function extendRetryBudget(task, windowSize = 3) {
     return Math.max(windowSize, (Math.floor(usedOrBudgeted / windowSize) + 1) * windowSize);
 }
 export function tryTransitionTaskEvent(task, event, context = {}) {
-    const decision = decideTaskLifecycle(task, event, context);
-    if (decision.accepted && decision.target)
-        applyTaskWorkflowDecision(task, decision);
-    return decision;
+    return dispatchTaskLifecycleSync(task, event, context);
 }
-export async function transitionTaskEvent(task, event, context = {}) {
+export async function transitionTaskEvent(task, event, context = {}, executeEffect, persist) {
     const from = task.state;
-    const decision = tryTransitionTaskEvent(task, event, context);
+    const decision = await dispatchTaskLifecycle(task, event, context, executeEffect, persist);
     if (!decision.accepted || !decision.target)
         throw new Error(decision.reason === 'ambiguous'
             ? `Ambiguous workflow transition from ${from} on ${event}`
             : `No enabled workflow transition from ${from} on ${event}`);
     return decision;
 }
-export async function transitionJobEvent(job, event, context = {}) {
-    const decision = decideJobLifecycle(job, event, context);
+export async function transitionJobEvent(job, event, context = {}, executeEffect, persist) {
+    const decision = await dispatchJobLifecycle(job, event, context, executeEffect, persist);
     if (!decision.accepted || !decision.target)
         throw new Error(decision.reason === 'ambiguous'
             ? `Ambiguous workflow transition from ${job.state} on ${event}`
             : `No enabled workflow transition from ${job.state} on ${event}`);
-    applyJobWorkflowDecision(job, decision);
     return decision;
 }
 export const SCHEDULE_RESOLUTION_MS = 600_000;

package/dist/store.js

@@ -126,7 +126,6 @@ export class InMemoryStore {
     }
 }
 export async function withGitHubRequestContext(client, context, work) { return client.withRequestContext ? client.withRequestContext(context, work) : work(); }
-export { createGitHubAppJwt, GhApiClient } from './github-client.js';
 async function githubGraphql(client, query, variables) {
     if (!client.graphql)
         throw new Error('GitHub GraphQL client is required');
@@ -257,6 +256,7 @@ export async function resolvePullRequest(client, repository, options) {
         throw error;
     }
 }
+export { GhApiClient, createGitHubAppJwt } from './github-client.js';
 export { GitHubStore } from './store-github.js';
 export async function listManagedGitHubJobs(client, repository, trustedAuthors) {
     if (!client.graphql)

package/dist/task-actions.js

@@ -0,0 +1,139 @@
+import { extendRetryBudget, transitionTaskEvent, tryTransitionTaskEvent } from './scheduler.js';
+import { selectRelatedTaskMutations } from './workflow/task-action-policy.js';
+export const TASK_RETRY_ACTION = 'task.retry';
+export const TASK_UNBLOCK_RETRY_ACTION = 'task.unblock.retry';
+export const TASK_CANCEL_ACTION = 'task.cancel';
+export const TASK_RELEASE_ACTION = 'task.release';
+export const TASK_HOLD_ACTION = 'task.hold';
+export const TASK_COMPLETE_ACTION = 'task.complete';
+export const TASK_QUEUE_ACTION = 'task.queue';
+function lifecycleRejection(task, action) {
+    return new Error(`Task ${task.id} is not ${action} (${task.state})`);
+}
+async function transitionTaskAction(task, event, action, facts = {}) {
+    try {
+        await transitionTaskEvent(task, event, facts);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
+            throw lifecycleRejection(task, action);
+        }
+        throw error;
+    }
+}
+function clearExecution(task) {
+    task.error = null;
+    task.leaseOwner = null;
+    task.leaseExpiresAt = null;
+    task.executionId = null;
+}
+/** Shared task.retry mutation. The canonical lifecycle graph is the sole legality authority. */
+export async function applyTaskRetryAction(task, policy = {}) {
+    if (task.kind === 'planner')
+        throw new Error(`Legacy planner Task ${task.id} is read-only; retry the Plan instead`);
+    await transitionTaskAction(task, 'retry', 'restartable');
+    if (policy.extendBudget)
+        task.maxAttempts = extendRetryBudget(task);
+    clearExecution(task);
+    return task;
+}
+/** 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);
+    clearExecution(task);
+    delete task.blockedBy;
+    return task;
+}
+export function tryApplyTaskCancelAction(task, reason) {
+    if (task.kind === 'planner')
+        return false;
+    const decision = tryTransitionTaskEvent(task, 'cancel');
+    if (!decision.accepted)
+        return false;
+    task.error = reason;
+    task.leaseOwner = null;
+    task.leaseExpiresAt = null;
+    task.executionId = null;
+    return true;
+}
+export async function applyTaskCancelAction(task, reason) {
+    if (task.kind === 'planner')
+        throw new Error(`Legacy planner Task ${task.id} is read-only`);
+    if (!tryApplyTaskCancelAction(task, reason))
+        throw lifecycleRejection(task, 'cancellable');
+    return task;
+}
+export async function applyTaskReleaseAction(task) {
+    await transitionTaskAction(task, 'release', 'releasable');
+    return task;
+}
+export async function applyTaskHoldAction(task) {
+    await transitionTaskAction(task, 'hold', 'holdable');
+    return task;
+}
+export async function applyTaskQueueAction(job, task) {
+    const taskMap = new Map(job.tasks.map(item => [item.id, item]));
+    const dependenciesSatisfied = task.dependencies.every(id => taskMap.get(id)?.state === 'SUCCEEDED');
+    await transitionTaskAction(task, 'queue', 'queueable', { dependenciesSatisfied });
+    clearExecution(task);
+    return task;
+}
+export async function applyOrchestratorCompleteAction(task, summary) {
+    if (task.adapter !== 'orchestrator')
+        throw new Error('task complete is only valid for adapter=orchestrator self-tasks');
+    const originalState = task.state;
+    tryTransitionTaskEvent(task, 'task.started');
+    task.attempt = Math.max(task.attempt, 1);
+    task.result = { summary };
+    clearExecution(task);
+    try {
+        await transitionTaskEvent(task, 'task.completed');
+    }
+    catch (error) {
+        if (error instanceof Error && error.message.startsWith('No enabled workflow transition')) {
+            throw new Error(`Task ${task.id} is ${originalState}; only QUEUED or RUNNING orchestrator tasks can be completed`);
+        }
+        throw error;
+    }
+    return task;
+}
+async function applySelectedRelatedTaskMutations(job, mutations) {
+    const changed = [];
+    for (const mutation of mutations) {
+        const related = job.tasks.find(item => item.id === mutation.taskId);
+        if (!related)
+            throw new Error(`Related task ${mutation.taskId} not found`);
+        if (mutation.mutation === 'cancel')
+            await applyTaskCancelAction(related, mutation.reason);
+        changed.push(related);
+    }
+    return changed;
+}
+/** Compatibility bridge: domain mutation only; adapters own wake/reconcile/output behavior. */
+export async function dispatchTaskAction(store, request) {
+    const job = await store.load(request.jobId);
+    const task = job.tasks.find(item => item.id === request.taskId);
+    if (!task)
+        throw new Error(`Task ${request.taskId} not found`);
+    const relatedMutations = selectRelatedTaskMutations(job, task, request.id);
+    if (request.id === TASK_RETRY_ACTION)
+        await applyTaskRetryAction(task, { extendBudget: true });
+    else if (request.id === TASK_UNBLOCK_RETRY_ACTION)
+        await applyTaskUnblockRetryAction(task);
+    else if (request.id === TASK_CANCEL_ACTION)
+        await applyTaskCancelAction(task, 'Cancelled by user');
+    else if (request.id === TASK_RELEASE_ACTION)
+        await applyTaskReleaseAction(task);
+    else if (request.id === TASK_HOLD_ACTION)
+        await applyTaskHoldAction(task);
+    else if (request.id === TASK_QUEUE_ACTION)
+        await applyTaskQueueAction(job, task);
+    else
+        throw new Error(`Unsupported task action ${request.id}`);
+    const changedRelated = await applySelectedRelatedTaskMutations(job, relatedMutations);
+    await store.saveTask(task);
+    for (const related of changedRelated)
+        await store.saveTask(related);
+    return { job, task };
+}

package/dist/troubleshooter.js

@@ -1,4 +1,6 @@
 import { taskOverallTimeoutMs } from './types.js';
+import { dispatchTroubleshooter } from './workflow/troubleshooter-v2.js';
+import { createTaskEntity } from './workflow/entity-creation.js';
 function slug(value) {
     return value.replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 72) || 'task';
 }
@@ -46,15 +48,20 @@ export function pendingTroubleshooterTasks(job) {
     const existing = new Set(job.tasks.filter(task => task.agentName === 'troubleshooter').map(task => task.id));
     const recoveries = [];
     for (const task of job.tasks) {
-        if (!['FAILED', 'BLOCKED'].includes(task.state) || task.kind === 'planner' || task.agentName === 'troubleshooter' || !belongsToCurrentRun(job, task))
-            continue;
-        if (task.state === 'BLOCKED' && task.unblock)
-            continue;
         const id = troubleshooterTaskId(task);
-        if (existing.has(id) || hasRecoveryBarrier(job, task))
+        let create = false;
+        const decision = dispatchTroubleshooter({
+            failedOrBlocked: ['FAILED', 'BLOCKED'].includes(task.state),
+            ordinaryWork: task.kind !== 'planner' && task.agentName !== 'troubleshooter',
+            currentRun: belongsToCurrentRun(job, task),
+            needsRecovery: !(task.state === 'BLOCKED' && Boolean(task.unblock)),
+            idUnused: !existing.has(id),
+            noRecoveryBarrier: !hasRecoveryBarrier(job, task),
+        }, () => { create = true; });
+        if (!decision.accepted || !create)
             continue;
         const now = new Date().toISOString();
-        recoveries.push({
+        recoveries.push(createTaskEntity(job, {
             jobId: job.id,
             id,
             kind: 'work',
@@ -71,7 +78,6 @@ export function pendingTroubleshooterTasks(job) {
             output: { kind: 'task_pr' },
             continuation: null,
             continuationDeliveredAt: null,
-            state: 'QUEUED',
             attempt: 0,
             maxAttempts: 1,
             leaseOwner: null,
@@ -84,7 +90,7 @@ export function pendingTroubleshooterTasks(job) {
             timeoutMs: taskOverallTimeoutMs('M'),
             createdAt: now,
             updatedAt: now,
-        });
+        }));
     }
     return recoveries;
 }

package/dist/types.js

@@ -1,7 +1,7 @@
-import { jobLifecycleWorkflow, taskLifecycleWorkflow } from './workflow/definitions.js';
+import { assertV2StateTransition, jobLifecycleV2, taskLifecycleV2 } from './workflow/definitions-v2.js';
 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))); }
-export function assertJobLifecycleTransition(from, to) { jobLifecycleWorkflow.assertStateTransition(from, to, 'job'); }
-export function assertTaskTransition(from, to) { taskLifecycleWorkflow.assertStateTransition(from, to, '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

@@ -1,4 +1,6 @@
-import { extendRetryBudget, transitionTaskEvent } from './scheduler.js';
+import { transitionTaskEvent } from './scheduler.js';
+import { applyTaskUnblockRetryAction } from './task-actions.js';
+import { dispatchAuthoritativeUnblock } from './workflow/authoritative-unblock-v2.js';
 export function isEffectivelyBlocked(task) { return task.kind !== 'planner' && task.state === 'BLOCKED'; }
 function baselineFor(task) {
     return task.blockedBaseline ?? { blockedAt: task.updatedAt, reason: task.error ?? undefined };
@@ -69,24 +71,32 @@ export async function unblockAutonomousTasks(options) {
 export async function unblockTask(options) {
     if (!isEffectivelyBlocked(options.task))
         throw new Error(`Task ${options.task.id} is not an effective BLOCKED work task`);
-    if (options.job.executionMode === 'autonomous')
-        return { replanning: true, planTrigger: await unblockAutonomousTasks({ store: options.store, job: options.job, tasks: [options.task], trigger: options.trigger, now: options.now }) };
-    const now = options.now ?? new Date().toISOString();
-    const currentHeadSha = await options.store.headSha?.() ?? options.job.headSha ?? null;
-    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 };
-    await transitionTaskEvent(options.task, 'task.unblocked');
-    await options.store.saveTask(options.task);
-    options.task.maxAttempts = extendRetryBudget(options.task);
-    await transitionTaskEvent(options.task, 'retry');
-    options.task.error = null;
-    options.task.leaseOwner = null;
-    options.task.leaseExpiresAt = null;
-    options.task.executionId = null;
-    options.task.updatedAt = now;
-    delete options.task.blockedBy;
-    await options.store.saveTask(options.task);
-    return { replanning: false };
+    let result;
+    const decision = await dispatchAuthoritativeUnblock(options.job.executionMode === 'autonomous', async (actionId) => {
+        if (actionId === 'unblock.replan') {
+            result = { replanning: true, planTrigger: await unblockAutonomousTasks({ store: options.store, job: options.job, tasks: [options.task], trigger: options.trigger, now: options.now }) };
+            return {};
+        }
+        if (actionId === 'unblock.retry') {
+            const now = options.now ?? new Date().toISOString();
+            const currentHeadSha = await options.store.headSha?.() ?? options.job.headSha ?? null;
+            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 };
+            await transitionTaskEvent(options.task, 'task.unblocked');
+            await options.store.saveTask(options.task);
+            await applyTaskUnblockRetryAction(options.task);
+            options.task.updatedAt = now;
+            await options.store.saveTask(options.task);
+            result = { replanning: false };
+            return {};
+        }
+        throw new Error('Unsupported authoritative unblock action ' + actionId);
+    });
+    if (!decision.accepted)
+        throw new Error('Authoritative unblock graph rejected task.authoritative_unblock');
+    if (!result)
+        throw new Error('Authoritative unblock graph completed without an action result');
+    return result;
 }

package/dist/workflow/authoritative-unblock-v2.js

@@ -0,0 +1,20 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/authoritative-unblock-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const authoritativeUnblockV2 = new GraphRuntime(source, {
+    states: new Set(['blocked', 'autonomous_replan', 'fixed_retry']),
+    guards: { autonomousJob: boolGuard('autonomousJob') },
+    actions: {
+        'unblock.replan': { id: 'unblock.replan' },
+        'unblock.retry': { id: 'unblock.retry' },
+    },
+    events: { 'task.authoritative_unblock': { id: 'task.authoritative_unblock' } },
+});
+export async function dispatchAuthoritativeUnblock(autonomousJob, executeAction) {
+    return dispatchWorkflowGraph(authoritativeUnblockV2, { initialState: 'blocked', input: { transport: 'event', id: 'task.authoritative_unblock', payload: {} }, durableFacts: { autonomousJob }, executeAction });
+}
+export function decideAuthoritativeUnblock(autonomousJob) {
+    return dispatchWorkflowGraphSync(authoritativeUnblockV2, { initialState: 'blocked', input: { transport: 'event', id: 'task.authoritative_unblock', payload: {} }, durableFacts: { autonomousJob } });
+}

package/dist/workflow/blocker-resolution-v2.js

@@ -0,0 +1,33 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/blocker-resolution-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const blockerResolutionV2 = new GraphRuntime(source, {
+    states: new Set([
+        'waiting', 'check_target', 'check_autonomous', 'check_effective', 'check_already_unblocked',
+        'check_draft', 'check_blocked', 'check_failed', 'check_unblocked', 'wait', 'obsolete', 'resumed',
+    ]),
+    guards: {
+        resolutionAllowed: boolGuard('resolutionAllowed'),
+        targetMatches: boolGuard('targetMatches'),
+        autonomousJob: boolGuard('autonomousJob'),
+        effectivelyBlocked: boolGuard('effectivelyBlocked'),
+        alreadyUnblocked: boolGuard('alreadyUnblocked'),
+        isDraft: boolGuard('isDraft'),
+        isBlocked: boolGuard('isBlocked'),
+        isFailed: boolGuard('isFailed'),
+        isUnblocked: boolGuard('isUnblocked'),
+    },
+    actions: Object.fromEntries([
+        'blocker.autonomousUnblock', 'blocker.acceptExistingUnblock', 'blocker.releaseDraft',
+        'blocker.unblockTask', 'blocker.retryFailed', 'blocker.retryUnblocked',
+    ].map(id => [id, { id }])),
+    events: { 'blocker.resolved': { id: 'blocker.resolved' } },
+});
+export async function dispatchBlockerResolution(facts, executeAction) {
+    return dispatchWorkflowGraph(blockerResolutionV2, { initialState: 'waiting', input: { transport: 'event', id: 'blocker.resolved', payload: {} }, durableFacts: facts, isTransientState: state => state.startsWith('check_'), maxSteps: 10, executeAction });
+}
+export function decideBlockerResolution(facts) {
+    return dispatchWorkflowGraphSync(blockerResolutionV2, { initialState: 'waiting', input: { transport: 'event', id: 'blocker.resolved', payload: {} }, durableFacts: facts, isTransientState: state => state.startsWith('check_'), maxSteps: 10 });
+}

package/dist/workflow/contracts.js

@@ -6,11 +6,17 @@ export const WORKFLOW_EVENT_NAMES = [
     'effect.cancelActiveTasks.failed',
     'effect.launchTask.failed',
     'effect.mergePullRequest.failed',
+    'execution.orphaned',
     'fail',
     'hold',
+    'lease.expired',
     'implementation.completed',
     'pr.closed',
     'pr.merged',
+    'queue',
+    'plan.requested',
+    'planner.failed',
+    'planner.unavailable',
     'reconcile',
     'release',
     'retry',
@@ -36,10 +42,25 @@ export const WORKFLOW_FACT_NAMES = [
     'notMerged',
     'autoMerge',
     'recoverableExecution',
+    'retryAvailable',
+    'initialPlan',
+    'scheduledRun',
+    'hasUnblock',
+    'manualPlan',
+    'prOpen',
+    'reviewDisabled',
+    'implementationComplete',
+    'headAvailable',
+    'mergeCapable',
 ];
 export const WORKFLOW_MUTATION_NAMES = [
     'mutation.clearError',
     'mutation.clearFailureReason',
+    'mutation.clearLease',
+    'mutation.clearExecution',
+    'mutation.markLeaseExpired',
+    'mutation.markStartupOrphanedExhausted',
+    'mutation.markPlannerUnavailable',
 ];
 export const WORKFLOW_EFFECT_NAMES = [
     'effect.launchTask',

package/dist/workflow/definitions-v2.js

@@ -0,0 +1,75 @@
+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 JOB_STATES = ['DRAFT', 'ACTIVE', 'COMPLETED', 'CANCELLED'];
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+function eventRegistry() {
+    return Object.fromEntries(WORKFLOW_EVENT_NAMES.map(id => [id, { id }]));
+}
+function actionRegistry() {
+    return Object.fromEntries([...WORKFLOW_MUTATION_NAMES, ...WORKFLOW_EFFECT_NAMES].map(id => [id, { id }]));
+}
+function load(name, states, guards) {
+    const url = new URL(`../../workflow/${name}-v2.mmd`, import.meta.url);
+    return new GraphRuntime(readFileSync(url, 'utf8'), {
+        states: new Set(states),
+        guards,
+        actions: actionRegistry(),
+        events: eventRegistry(),
+    });
+}
+export const taskLifecycleV2 = load('task-lifecycle', TASK_STATES, {
+    dependenciesSatisfied: boolGuard('dependenciesSatisfied'),
+    dependenciesUnsatisfied: boolGuard('dependenciesUnsatisfied'),
+    runnable: boolGuard('runnable'),
+    dispatchable: boolGuard('dispatchable'),
+    recoverableExecution: boolGuard('recoverableExecution'),
+    retryAvailable: boolGuard('retryAvailable'),
+});
+export const jobLifecycleV2 = load('job-lifecycle', JOB_STATES, {
+    notMerged: boolGuard('notMerged'),
+    autoMerge: boolGuard('autoMerge'),
+    prOpen: boolGuard('prOpen'),
+    reviewDisabled: boolGuard('reviewDisabled'),
+    implementationComplete: boolGuard('implementationComplete'),
+    headAvailable: boolGuard('headAvailable'),
+    mergeCapable: boolGuard('mergeCapable'),
+});
+function topologyTargets(graph, from) {
+    const source = [...graph.nodes.values()].find(node => node.kind === 'state' && node.semanticId === from);
+    if (!source)
+        throw new Error(`Unknown workflow state ${from}`);
+    const targets = new Set();
+    const visit = (nodeId, seen) => {
+        if (seen.has(nodeId))
+            return;
+        seen.add(nodeId);
+        const node = graph.nodes.get(nodeId);
+        if (!node)
+            return;
+        if (node.kind === 'state') {
+            targets.add(node.semanticId);
+            return;
+        }
+        for (const edge of graph.edges) {
+            if (edge.from === nodeId && edge.kind !== 'emit')
+                visit(edge.to, new Set(seen));
+        }
+    };
+    for (const edge of graph.edges) {
+        if (edge.from === source.id && (edge.kind === 'on' || edge.kind === 'request')) {
+            visit(edge.to, new Set([source.id]));
+        }
+    }
+    return targets;
+}
+export function assertV2StateTransition(graph, from, to, kind) {
+    if (from === to)
+        return;
+    const states = new Set([...graph.nodes.values()].filter(node => node.kind === 'state').map(node => node.semanticId));
+    if (!states.has(from) || !states.has(to))
+        throw new Error(`Unknown ${kind} state ${!states.has(from) ? from : to}`);
+    if (!topologyTargets(graph, from).has(to))
+        throw new Error(`Invalid ${kind} transition ${from} -> ${to}`);
+}