agents-relay 1.0.177 → 2.0.1

package/README.md

@@ -2,6 +2,8 @@
 
 Agents Relay is a generic TypeScript runtime for durable asynchronous agent jobs coordinated through GitHub pull requests. The PR body stores the durable Job marker plus human-readable Job objective, while PR comments store durable Task and other append-friendly records; correlated terminal events are authoritative for model-backed task lifecycle transitions.
 
+V2 separates **operational execution state** from that collaboration record. A local RelayStore may use SQLite/WAL for runtime snapshots, event idempotency and a durable GitHub projection outbox. ProjectedDurableStore bootstraps from the existing GitHub representation, commits Job/Plan/Task runtime changes locally, and lets GitHubProjectionWriter project them asynchronously. GitHub therefore remains the human-readable durable Job/Plan/Task/Review surface without being required for every high-frequency runtime transition.
+
 ## Quick start
 
 For GitHub-backed work, create or adopt the PR through Agents Relay itself. This guarantees the durable job marker exists before any managed task is submitted.
@@ -48,9 +50,9 @@ npx agents-relay task update --repo OWNER/REPO --pr 12 --id job-1 --task-id chil
 
 Jobs separate durable lifecycle from derived runtime status. Durable lifecycle is `DRAFT | ACTIVE | COMPLETED | CANCELLED`: a newly created unscheduled Job is DRAFT, creating executable work activates it, and scheduled Jobs are ACTIVE because the scheduler is allowed to advance them. Runtime status (`IDLE`, `WAITING`, `QUEUED`, `RUNNING`, `BLOCKED`, `FAILED`, `REVIEWING`, `MERGE_PENDING`, `MERGED`, or `CANCELLED`) is computed from Tasks, Review, PR, and schedule facts and is never persisted as lifecycle truth.
 
-Lifecycle transition authority lives in the directly renderable canonical sources [`workflow/job-lifecycle.mmd`](workflow/job-lifecycle.mmd) and [`workflow/task-lifecycle.mmd`](workflow/task-lifecycle.mmd); see [`docs/workflow-engine.md`](docs/workflow-engine.md) for the executable Mermaid profile and runtime boundary.
+Lifecycle transition authority lives in the directly renderable v2 flowchart sources [`workflow/job-lifecycle-v2.mmd`](workflow/job-lifecycle-v2.mmd) and [`workflow/task-lifecycle-v2.mmd`](workflow/task-lifecycle-v2.mmd). The legacy `stateDiagram-v2` files remain compatibility fixtures only; see [`docs/workflow-engine.md`](docs/workflow-engine.md) for the executable Mermaid profile and runtime boundary.
 
-The canonical Mermaid Graph Engine is the single authoritative Job/Task lifecycle decision path. Lifecycle events, guards, deterministic mutations, and declarative effects are defined by the workflow graphs and executed through the shared graph runtime.
+The canonical Mermaid Graph Engine is the authoritative durable workflow decision path. Job/Task lifecycle transitions plus Review, Planner, Blocker/Unblock, Schedule, and Troubleshooter orchestration branches are defined by the v2 workflow graphs and executed through the shared graph runtime. TypeScript supplies facts and primitive action/effect implementations; it must not duplicate those workflow branches as a second procedural state machine.
 
 Job objectives and Task inputs are Markdown. Prefer `--objective-file` / `--input-file` (use `-` for stdin) for durable long-form context; inline `--objective` / `--input` remain for short/simple text and are mutually exclusive with the file variants. When a diagram materially clarifies the work, put Mermaid first and then Markdown detail. A newly created Job must capture enough context to finish independently of the originating chat. Its PR body contains exactly one hidden `agents-relay:job:v1` metadata marker followed by the objective Markdown; there is no separate Job comment duplicating the objective. Objective and Job metadata updates rewrite that same PR body. Legacy Job-comment markers remain readable and are migrated into the PR body on the next Job save.
 

package/dist/adapters.js

@@ -26,6 +26,29 @@ function parseThreadStarted(line) {
         return undefined;
     }
 }
+function signalChildTree(child, signal) {
+    if (child.pid && process.platform !== 'win32') {
+        try {
+            process.kill(-child.pid, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'ESRCH')
+                throw error;
+        }
+    }
+    child.kill(signal);
+}
+function terminateChild(child, graceMs = 750) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return;
+    signalChildTree(child, 'SIGTERM');
+    const force = setTimeout(() => {
+        if (child.exitCode === null && child.signalCode === null)
+            signalChildTree(child, 'SIGKILL');
+    }, graceMs);
+    force.unref();
+}
 function appendTail(current, chunk, maxBytes = 16384) {
     const combined = current + chunk;
     return Buffer.byteLength(combined) <= maxBytes
@@ -47,6 +70,7 @@ export class CodexAdapter {
             shell: false,
             cwd: task.routing.cwd,
             stdio: ['ignore', 'pipe', 'pipe'],
+            detached: process.platform !== 'win32',
         });
         let stdoutBuffer = '';
         let stderrTail = '';
@@ -89,9 +113,9 @@ export class CodexAdapter {
                     reject(new Error(stderrTail.trim() || `Codex exited ${code}`));
                 }
             });
-            signal.addEventListener('abort', () => child.kill('SIGTERM'), { once: true });
+            signal.addEventListener('abort', () => terminateChild(child), { once: true });
         });
-        execution = { id: randomUUID(), promise, launched, cancel: () => child.kill('SIGTERM') };
+        execution = { id: randomUUID(), promise, launched, cancel: () => terminateChild(child) };
         execution.threadId = bufferedThreadId;
         return execution;
     }

package/dist/blockers.js

@@ -1,5 +1,6 @@
-import { extendRetryBudget, transitionTaskEvent } from './scheduler.js';
+import { applyTaskReleaseAction, applyTaskUnblockRetryAction, dispatchTaskAction } from './task-actions.js';
 import { isEffectivelyBlocked, unblockAutonomousTasks, unblockTask } from './unblock.js';
+import { dispatchBlockerResolution } from './workflow/blocker-resolution-v2.js';
 function dependentKey(value) {
     return `${value.repository}#${value.prNumber}:${value.jobId}:${value.taskId}:a${value.blockedAttempt}`;
 }
@@ -58,10 +59,6 @@ function obsoleteReason(task, relation) {
 export async function resolveBlockerDependencies(options) {
     const blocker = await options.blockerStore.load(options.blockerJobId);
     const mode = blocker.blockerResolutionMode ?? 'merge';
-    if (mode === 'verified' && options.resolution !== 'verified') {
-        const waiting = (blocker.unblocks ?? []).filter(item => item.state === 'waiting').length;
-        return { resumed: 0, obsolete: 0, waiting, unblocked: [] };
-    }
     const now = options.now ?? new Date().toISOString();
     const relations = blocker.unblocks ?? [];
     let resumed = 0;
@@ -71,80 +68,78 @@ export async function resolveBlockerDependencies(options) {
         if (relation.state !== 'waiting')
             continue;
         const store = options.dependentStore(relation.repository, relation.prNumber);
-        let targetJob;
+        let targetJob = null;
+        let task;
+        let loadError = null;
         try {
             targetJob = await store.load(relation.jobId);
+            task = targetJob.tasks.find(item => item.id === relation.taskId);
         }
         catch (error) {
-            relation.state = 'obsolete';
-            relation.resolvedAt = now;
-            relation.resolution = options.resolution;
-            relation.note = error instanceof Error ? error.message : String(error);
-            obsolete += 1;
-            continue;
+            loadError = error instanceof Error ? error.message : String(error);
         }
-        const task = targetJob.tasks.find(item => item.id === relation.taskId);
-        const matches = !!task && ['DRAFT', 'FAILED', 'BLOCKED', 'UNBLOCKED'].includes(task.state) && task.attempt === relation.blockedAttempt;
-        if (!matches) {
+        const targetMatches = !!task && ['DRAFT', 'FAILED', 'BLOCKED', 'UNBLOCKED'].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),
+            isDraft: task?.state === 'DRAFT', isBlocked: task?.state === 'BLOCKED',
+            isFailed: task?.state === 'FAILED', isUnblocked: task?.state === 'UNBLOCKED',
+        }, async (actionId) => {
+            if (!targetJob || !task)
+                throw new Error('Blocker graph requested action without a matching dependent task');
+            if (actionId === 'blocker.autonomousUnblock') {
+                await unblockAutonomousTasks({ store, job: targetJob, tasks: [task], trigger: { source: 'blocker_job', reason: 'Blocker Job ' + blocker.id + ' resolved (' + options.resolution + ')', blockerJobId: blocker.id, resolution: options.resolution }, now });
+                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
+                note = 'dependent task unblocked for replanning';
+            }
+            else if (actionId === 'blocker.acceptExistingUnblock')
+                note = 'dependent Job already unblocked for replanning';
+            else if (actionId === 'blocker.releaseDraft') {
+                await applyTaskReleaseAction(task);
+                task.error = null;
+                task.updatedAt = now;
+                delete task.blockedBy;
+                await store.saveTask(task);
+            }
+            else if (actionId === 'blocker.unblockTask') {
+                await unblockTask({ store, job: targetJob, task, trigger: { source: 'blocker_job', reason: 'Blocker Job ' + blocker.id + ' resolved (' + options.resolution + ')', blockerJobId: blocker.id, resolution: options.resolution }, now });
+                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
+            }
+            else if (actionId === 'blocker.retryFailed') {
+                const result = await dispatchTaskAction(store, { id: 'task.retry', jobId: targetJob.id, taskId: task.id });
+                delete result.task.blockedBy;
+                result.task.updatedAt = now;
+                await store.saveTask(result.task);
+            }
+            else if (actionId === 'blocker.retryUnblocked') {
+                await applyTaskUnblockRetryAction(task);
+                task.updatedAt = now;
+                await store.saveTask(task);
+            }
+            else
+                throw new Error('Unsupported blocker graph action ' + actionId);
+            return {};
+        });
+        if (!decision.accepted || decision.target === 'wait')
+            continue;
+        if (decision.target === 'obsolete') {
             relation.state = 'obsolete';
             relation.resolvedAt = now;
             relation.resolution = options.resolution;
-            relation.note = obsoleteReason(task, relation);
+            relation.note = loadError ?? obsoleteReason(task, relation);
             obsolete += 1;
             continue;
         }
-        if (targetJob.executionMode === 'autonomous') {
-            if (isEffectivelyBlocked(task)) {
-                await unblockAutonomousTasks({
-                    store,
-                    job: targetJob,
-                    tasks: [task],
-                    trigger: { source: 'blocker_job', reason: `Blocker Job ${blocker.id} resolved (${options.resolution})`, blockerJobId: blocker.id, resolution: options.resolution },
-                    now,
-                });
-                unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
-                relation.state = 'resumed';
-                relation.resolvedAt = now;
-                relation.resolution = options.resolution;
-                relation.note = 'dependent task unblocked for replanning';
-                resumed += 1;
-                continue;
-            }
-            if (task.state === 'UNBLOCKED' && task.unblock) {
-                relation.state = 'resumed';
-                relation.resolvedAt = now;
-                relation.resolution = options.resolution;
-                relation.note = 'dependent Job already unblocked for replanning';
-                resumed += 1;
-                continue;
-            }
-        }
-        if (task.state === 'DRAFT') {
-            await transitionTaskEvent(task, 'release');
-            task.error = null;
-            task.updatedAt = now;
-            delete task.blockedBy;
-            await store.saveTask(task);
-        }
-        else if (task.state === 'BLOCKED') {
-            await unblockTask({ store, job: targetJob, task, trigger: { source: 'blocker_job', reason: `Blocker Job ${blocker.id} resolved (${options.resolution})`, blockerJobId: blocker.id, resolution: options.resolution }, now });
-            unblocked.push({ repository: relation.repository, prNumber: relation.prNumber, jobId: relation.jobId, taskId: relation.taskId });
-        }
-        else {
-            task.maxAttempts = extendRetryBudget(task);
-            await transitionTaskEvent(task, 'retry');
-            task.error = null;
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
-            delete task.blockedBy;
-            task.updatedAt = now;
-            await store.saveTask(task);
-        }
+        if (decision.target !== 'resumed')
+            throw new Error('Blocker graph produced unsupported target ' + decision.target);
         relation.state = 'resumed';
         relation.resolvedAt = now;
         relation.resolution = options.resolution;
-        relation.note = 'dependent task requeued';
+        relation.note = note;
         resumed += 1;
     }
     const remaining = relations.filter(relation => relation.state === 'waiting');

package/dist/cli-support.js

@@ -4,7 +4,7 @@ import { githubAuthContext } from './github-auth.js';
 import { NatsEventBus, eventFor } from './events.js';
 import { parseJobSchedule } from './scheduler.js';
 import { parseJobTagJson } from './task-tag.js';
-export const SERVICE_DEFAULTS = { port: 8787, watchdogMs: 300000, webhookWatchdogMs: 300000, dashboardRefreshMs: 300000 };
+export const SERVICE_DEFAULTS = { port: 8787, watchdogMs: 300000, webhookWatchdogMs: 300000, dashboardRefreshMs: 300000, projectionFlushMs: 1000 };
 export class ServiceEventBus {
     upstream;
     unsubscribers = new Set();
@@ -66,6 +66,38 @@ export async function storeFor(args) { const repo = arg(args, '--repo'); const p
     throw new Error('Local mode is demo/test only; pass --file explicitly'); const loaded = await localStore(file); return { store: loaded.store, job: loaded.job, localFile: file }; }
 export async function saveLocal(file, job) { if (file)
     await writeFile(file, JSON.stringify(job, null, 2)); }
+export async function relayControlJob(args, jobId) {
+    const host = arg(args, '--host', '127.0.0.1');
+    const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        throw new Error('--port must be an integer between 1 and 65535');
+    let response;
+    try {
+        response = await fetch(`http://${host}:${port}/api/job?id=${encodeURIComponent(jobId)}`);
+    }
+    catch (error) {
+        throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`Agents Relay job request failed: ${await response.text() || `HTTP ${response.status}`}`);
+    return await response.json();
+}
+export async function relayTaskCommand(args, body) {
+    const host = arg(args, '--host', '127.0.0.1');
+    const port = Number(arg(args, '--port', String(SERVICE_DEFAULTS.port)));
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        throw new Error('--port must be an integer between 1 and 65535');
+    let response;
+    try {
+        response = await fetch(`http://${host}:${port}/api/task-command`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) });
+    }
+    catch (error) {
+        throw new Error(`Agents Relay service unavailable at ${host}:${port}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!response.ok)
+        throw new Error(`Agents Relay task command failed: ${await response.text() || `HTTP ${response.status}`}`);
+    return await response.json();
+}
 export function eventBus(args) { if (arg(args, '--events') !== 'nats')
     return undefined; return new NatsEventBus(arg(args, '--nats-url', 'nats://127.0.0.1:4222'), arg(args, '--subject-prefix', 'neo.events.job')); }
 export async function publishWake(bus, job, taskId, message) { if (!bus)

package/dist/cli.js

@@ -17,15 +17,18 @@ import { codexAndZaiUsageRegistry } from './usage.js';
 import { decisionMode, LayaCliDecisionEngine } from './decision.js';
 import { discoverAgents } from './registry.js';
 import { AgentObjectivePlanner, CommandObjectivePlanner } from './planner.js';
-import { extendRetryBudget, transitionJobEvent, transitionTaskEvent } from './scheduler.js';
+import { transitionJobEvent } from './scheduler.js';
+import { applyOrchestratorCompleteAction, applyTaskHoldAction, dispatchTaskAction } from './task-actions.js';
+import { applyJobActivateAction, applyJobCancelAction } from './job-actions.js';
 import { resolveExecutionContext } from './execution-context.js';
 import { defaultWorkspaceRoot, resolveManagedProjectPath, resolveRepositoryProjectPath } from './workspace.js';
 import { runBlockerCommand } from './cli-blocker.js';
 import { helpText, usage } from './cli-help.js';
 import { parseAgentGraph } from './agent-graph.js';
 import { runJobUnblockCommand, runTaskUnblockCommand } from './cli-unblock.js';
+import { createJobEntity, createTaskEntity } from './workflow/entity-creation.js';
 export { helpText } from './cli-help.js';
-import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, } from './cli-support.js';
+import { SERVICE_DEFAULTS, ServiceEventBus, arg, hasArg, textOption, integerArg, repository, storeFor, saveLocal, githubStore, eventBus, publishWake, publishDependentUnblocked, priority, storySize, executionMode, chatGptTabClosePolicy, requestedExecutionMode, continuation, scheduleFromArgs, jobTagFromArgs, requestManagedReconciliation, relayControlJob, relayTaskCommand, } from './cli-support.js';
 export { SERVICE_DEFAULTS, eventBus, executionMode, chatGptTabClosePolicy } from './cli-support.js';
 export async function ensureManagedGitHubJob(client, repositoryName, trustedAuthors, options) {
     if (!options.id)
@@ -41,7 +44,7 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
             throw error;
     }
     const now = new Date().toISOString();
-    const job = {
+    const job = createJobEntity({
         id: options.id,
         title: options.title || pr.title || 'Agents Relay job',
         objective: options.objective || pr.body || undefined,
@@ -54,14 +57,12 @@ export async function ensureManagedGitHubJob(client, repositoryName, trustedAuth
         reviewEnabled: options.reviewEnabled ?? true,
         prNumber: pr.number,
         repository: repositoryName,
-        state: options.schedule ? 'ACTIVE' : 'DRAFT',
         continuation: options.continuation ?? null,
         createdAt: now,
         updatedAt: now,
-        tasks: []
-    };
-    if (options.schedule)
-        job.schedule = options.schedule;
+        tasks: [],
+        ...(options.schedule ? { schedule: options.schedule } : {}),
+    }, { activate: Boolean(options.schedule) });
     await store.saveJob(job);
     return { job: await store.load(options.id), pr };
 }
@@ -91,7 +92,7 @@ async function workerTaskFromArgs(job, args, now) {
     const size = storySize(args);
     const dependencies = arg(args, '--deps').split(',').filter(Boolean);
     const timeoutMs = adapter === 'orchestrator' ? 0 : hasArg(args, '--timeout') ? integerArg(args, '--timeout', taskOverallTimeoutMs(size, routing?.reasoning)) : routing ? taskOverallTimeoutMs(size, routing.reasoning) : 0;
-    return {
+    return createTaskEntity(job, {
         jobId: job.id,
         id: arg(args, '--task-id', 'initial'),
         priority: priority(args, job.priority ?? 'P2'),
@@ -111,7 +112,6 @@ async function workerTaskFromArgs(job, args, now) {
         routing,
         continuation: continuation(args),
         continuationDeliveredAt: null,
-        state: hasArg(args, '--draft') || dependencies.length > 0 ? 'DRAFT' : 'QUEUED',
         attempt: 0,
         maxAttempts: Number(arg(args, '--max-attempts', '3')),
         leaseOwner: null,
@@ -123,11 +123,45 @@ async function workerTaskFromArgs(job, args, now) {
         timeoutMs,
         createdAt: now,
         updatedAt: now
-    };
+    }, { defer: hasArg(args, '--draft') });
+}
+async function runManagedTaskCommand(action, args) {
+    const jobId = arg(args, '--id');
+    if (!jobId)
+        throw new Error('--id is required for managed task commands');
+    const id = arg(args, '--task-id', action === 'create' ? randomUUID() : '');
+    if (!id)
+        throw new Error(`task ${action} requires --task-id`);
+    let result;
+    if (action === 'create') {
+        const job = await relayControlJob(args, jobId);
+        if (['COMPLETED', 'CANCELLED'].includes(job.state))
+            throw new Error(`Cannot create task on terminal job ${job.id} (${job.state})`);
+        const task = await workerTaskFromArgs(job, args, new Date().toISOString());
+        task.id = id;
+        result = await relayTaskCommand(args, { jobId, action, task });
+    }
+    else if (action === 'complete') {
+        const summary = arg(args, '--summary');
+        if (!summary)
+            throw new Error('task complete requires --summary');
+        result = await relayTaskCommand(args, { jobId, taskId: id, action, summary });
+    }
+    else
+        result = await relayTaskCommand(args, { jobId, taskId: id, action });
+    const task = result.tasks.find(item => item.id === id);
+    if (!task)
+        throw new Error(`Task ${id} missing after ${action}`);
+    console.log(JSON.stringify(task, null, 2));
 }
 async function runTaskCommand(action, args) {
     if (!['create', 'update', 'show', 'list', 'complete', 'retry', 'unblock', 'cancel'].includes(action))
         throw new Error(usage);
+    const managed = Boolean(arg(args, '--repo') && arg(args, '--pr') && !arg(args, '--file'));
+    if (managed && ['create', 'complete', 'retry', 'cancel'].includes(action)) {
+        await runManagedTaskCommand(action, args);
+        return;
+    }
     const { store, job, localFile } = await storeFor(args);
     if (action === 'list') {
         console.log(JSON.stringify(job.tasks, null, 2));
@@ -145,7 +179,7 @@ async function runTaskCommand(action, args) {
         await store.appendTask(task);
         const refreshed = await store.load(job.id);
         if (refreshed.state === 'DRAFT') {
-            await transitionJobEvent(refreshed, 'activate');
+            await applyJobActivateAction(refreshed);
             await store.saveJob(refreshed);
         }
         const durableTask = (await store.load(job.id)).tasks.find(item => item.id === task.id) ?? task;
@@ -166,52 +200,35 @@ async function runTaskCommand(action, args) {
         return;
     }
     if (action === 'complete') {
-        if (task.adapter !== 'orchestrator')
-            throw new Error('task complete is only valid for adapter=orchestrator self-tasks');
-        if (!['QUEUED', 'RUNNING'].includes(task.state))
-            throw new Error(`Task ${id} is ${task.state}; only QUEUED or RUNNING orchestrator tasks can be completed`);
         const summary = arg(args, '--summary');
         if (!summary)
             throw new Error('task complete requires --summary');
-        if (task.state === 'QUEUED')
-            await transitionTaskEvent(task, 'task.started');
-        task.attempt = Math.max(task.attempt, 1);
-        task.result = { summary };
-        task.error = null;
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.executionId = null;
-        await transitionTaskEvent(task, 'task.completed');
+        await applyOrchestratorCompleteAction(task, summary);
         await store.saveTask(task);
         await saveLocal(localFile, await store.load(job.id));
         console.log(JSON.stringify(task, null, 2));
         return;
     }
     if (action === 'retry' || action === 'cancel') {
+        let outputJob = job;
+        let outputTask = task;
         if (action === 'retry') {
-            if (task.state === 'BLOCKED')
-                throw new Error(`Task ${id} is BLOCKED; use task unblock --reason instead of retry`);
-            if (task.state === 'UNBLOCKED')
-                throw new Error(`Task ${id} is historical UNBLOCKED work; only fixed-job authoritative unblock may requeue it`);
-            task.maxAttempts = extendRetryBudget(task);
-            if (task.kind === 'planner' && task.error)
-                task.plannerRetryFeedback = task.error;
+            const result = await dispatchTaskAction(store, { id: 'task.retry', jobId: job.id, taskId: id });
+            if (result.job.state === 'DRAFT') {
+                await applyJobActivateAction(result.job);
+                await store.saveJob(result.job);
+            }
+            outputJob = await store.load(job.id);
+            outputTask = outputJob.tasks.find(item => item.id === id) ?? result.task;
         }
-        if (action === 'cancel' && task.state === 'UNBLOCKED')
-            throw new Error(`Task ${id} is historical UNBLOCKED work and is immutable`);
-        await transitionTaskEvent(task, action === 'retry' ? 'retry' : task.state === 'RUNNING' ? 'task.cancelled' : 'cancel');
-        task.error = action === 'retry' ? null : 'Cancelled by user';
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.executionId = null;
-        await store.saveTask(task);
-        if (action === 'retry' && job.state === 'DRAFT') {
-            await transitionJobEvent(job, 'activate');
-            await store.saveJob(job);
+        else {
+            const result = await dispatchTaskAction(store, { id: 'task.cancel', jobId: job.id, taskId: id });
+            outputJob = await store.load(job.id);
+            outputTask = outputJob.tasks.find(item => item.id === id) ?? result.task;
         }
-        await saveLocal(localFile, job);
-        await publishWake(eventBus(args), job, task.id, `${task.id} ${action} requested`);
-        console.log(JSON.stringify(task, null, 2));
+        await saveLocal(localFile, outputJob);
+        await publishWake(eventBus(args), outputJob, outputTask.id, `${outputTask.id} ${action} requested`);
+        console.log(JSON.stringify(outputTask, null, 2));
         return;
     }
     if (['RUNNING', 'UNBLOCKED', 'SUCCEEDED', 'CANCELLED'].includes(task.state))
@@ -254,19 +271,11 @@ async function runTaskCommand(action, args) {
     if (hasArg(args, '--draft') && hasArg(args, '--queue'))
         throw new Error('--draft and --queue are mutually exclusive');
     if (hasArg(args, '--draft') && task.state === 'QUEUED')
-        await transitionTaskEvent(task, 'hold');
+        await applyTaskHoldAction(task);
     if (hasArg(args, '--queue')) {
-        const taskMap = new Map(job.tasks.map(item => [item.id, item]));
-        if (!task.dependencies.every(dep => taskMap.get(dep)?.state === 'SUCCEEDED'))
-            throw new Error('Task dependencies must succeed before queueing');
-        if (task.state === 'DRAFT')
-            await transitionTaskEvent(task, 'release');
-        else if (task.state === 'FAILED')
-            await transitionTaskEvent(task, 'retry');
-        else if (task.state === 'BLOCKED')
-            throw new Error(`Task ${id} is BLOCKED; use task unblock --reason instead of --queue`);
-        else if (task.state === 'UNBLOCKED')
-            throw new Error(`Task ${id} is historical UNBLOCKED work and cannot be queued`);
+        await store.saveTask(task);
+        const result = await dispatchTaskAction(store, { id: 'task.queue', jobId: job.id, taskId: id });
+        Object.assign(task, result.task);
     }
     if (hasArg(args, '--max-attempts') && task.maxAttempts < task.attempt)
         throw new Error('--max-attempts cannot be less than the current attempt count');
@@ -391,19 +400,8 @@ async function runJobCommand(action, args) {
         return;
     }
     if (action === 'cancel') {
-        if (job.state === 'COMPLETED')
-            throw new Error(`Cannot cancel completed job ${job.id}`);
-        for (const task of job.tasks.filter(item => !['SUCCEEDED', 'UNBLOCKED', 'CANCELLED'].includes(item.state))) {
-            await transitionTaskEvent(task, 'cancel');
-            task.error = 'Job cancelled';
-            task.leaseOwner = null;
-            task.leaseExpiresAt = null;
-            task.executionId = null;
-            await store.saveTask(task);
-        }
+        await applyJobCancelAction(store, job);
         await store.closePullRequest();
-        await transitionJobEvent(job, 'cancel');
-        await store.saveJob(job);
         console.log(JSON.stringify(await store.load(id), null, 2));
         return;
     }
@@ -454,25 +452,12 @@ export function dashboardJobAction(store, reconciler, action) {
     return async (jobId) => {
         const job = await store.load(jobId);
         if (action === 'start') {
-            if (job.state !== 'DRAFT')
-                throw new Error(`Job ${job.id} is not startable (${job.state})`);
-            await transitionJobEvent(job, 'activate');
+            await applyJobActivateAction(job);
             await store.saveJob(job);
         }
         else if (action === 'cancel') {
-            if (job.state === 'COMPLETED' || job.state === 'CANCELLED')
-                throw new Error(`Job ${job.id} is not cancellable (${job.state})`);
-            for (const task of job.tasks.filter(item => !['SUCCEEDED', 'CANCELLED'].includes(item.state))) {
-                await transitionTaskEvent(task, 'cancel');
-                task.error = 'Job cancelled';
-                task.leaseOwner = null;
-                task.leaseExpiresAt = null;
-                task.executionId = null;
-                await store.saveTask(task);
-            }
+            await applyJobCancelAction(store, job);
             await store.closePullRequest?.();
-            await transitionJobEvent(job, 'cancel');
-            await store.saveJob(job);
             return await store.load(job.id);
         }
         return await reconciler.wake(job.id);
@@ -588,7 +573,8 @@ async function main() {
     }
     if (command === 'init') {
         const now = new Date().toISOString();
-        const job = { id: arg(args, '--id', randomUUID()), title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), schedule: scheduleFromArgs(args), autoMerge: !hasArg(args, '--no-auto-merge'), reviewEnabled: !hasArg(args, '--no-review'), prNumber: Number(arg(args, '--pr', '0')), repository: arg(args, '--repo'), state: scheduleFromArgs(args) ? 'ACTIVE' : 'DRAFT', continuation: continuation(args), createdAt: now, updatedAt: now, tasks: [] };
+        const initialSchedule = scheduleFromArgs(args);
+        const job = createJobEntity({ id: arg(args, '--id', randomUUID()), title: arg(args, '--title', 'Agents Relay job'), objective: arg(args, '--objective') || undefined, priority: priority(args), executionMode: executionMode(args), schedule: initialSchedule, autoMerge: !hasArg(args, '--no-auto-merge'), reviewEnabled: !hasArg(args, '--no-review'), prNumber: Number(arg(args, '--pr', '0')), repository: arg(args, '--repo'), continuation: continuation(args), createdAt: now, updatedAt: now, tasks: [] }, { activate: Boolean(initialSchedule) });
         let store;
         let file = null;
         if (arg(args, '--repo') && arg(args, '--pr'))

package/dist/dashboard-actions.js

@@ -1,5 +1,7 @@
-import { extendRetryBudget, transitionTaskEvent } from './scheduler.js';
-import { applyJobWorkflowDecision, applyTaskWorkflowDecision } from './workflow/runtime.js';
+import { applyJobGraphTarget, applyTaskGraphTarget } from './workflow/runtime.js';
+import { jobLifecycleV2, taskLifecycleV2 } from './workflow/definitions-v2.js';
+import { dispatchWorkflowTargetOverride } from './workflow/dispatcher.js';
+import { dispatchTaskAction } from './task-actions.js';
 export function dashboardTaskAction(store, reconciler, action) {
     return async (jobId, taskId) => {
         const job = await store.load(jobId);
@@ -7,24 +9,11 @@ export function dashboardTaskAction(store, reconciler, action) {
         if (!task)
             throw new Error(`Task ${taskId} not found`);
         if (action === 'retry') {
-            if (task.state === 'BLOCKED')
-                throw new Error(`Task ${task.id} is BLOCKED; use the unblock CLI with a reason`);
-            if (task.state !== 'FAILED')
-                throw new Error(`Task ${task.id} is not restartable (${task.state})`);
-            task.maxAttempts = extendRetryBudget(task);
-            await transitionTaskEvent(task, 'retry');
-            task.error = null;
+            await dispatchTaskAction(store, { id: 'task.retry', jobId, taskId });
         }
         else {
-            if (!['DRAFT', 'QUEUED', 'RUNNING', 'BLOCKED', 'FAILED'].includes(task.state))
-                throw new Error(`Task ${task.id} is not cancellable (${task.state})`);
-            await transitionTaskEvent(task, task.state === 'RUNNING' ? 'task.cancelled' : 'cancel');
-            task.error = 'Cancelled by user';
+            await dispatchTaskAction(store, { id: 'task.cancel', jobId, taskId });
         }
-        task.leaseOwner = null;
-        task.leaseExpiresAt = null;
-        task.executionId = null;
-        await store.saveTask(task);
         return await reconciler.wake(job.id);
     };
 }
@@ -33,16 +22,10 @@ export function dashboardJobSetState(store) {
         const job = await store.load(jobId);
         if (job.state === state)
             return job;
-        applyJobWorkflowDecision(job, {
-            accepted: true,
-            target: state,
-            guard: null,
-            actions: [],
-            mutations: [],
-            effects: [],
-            reason: 'accepted',
+        await dispatchWorkflowTargetOverride(jobLifecycleV2, {
+            currentState: job.state, targetState: state, kind: 'job',
+            persistTransition: async (_from, target) => { applyJobGraphTarget(job, target); await store.saveJob(job); },
         });
-        await store.saveJob(job);
         return await store.load(job.id);
     };
 }
@@ -62,15 +45,10 @@ export function dashboardTaskSetState(store) {
             throw new Error(`Task ${task.id} is historical UNBLOCKED work and cannot be changed by dashboard state override`);
         const now = new Date().toISOString();
         const from = task.state;
-        applyTaskWorkflowDecision(task, {
-            accepted: true,
-            target: state,
-            guard: null,
-            actions: [],
-            mutations: [],
-            effects: [],
-            reason: 'accepted',
-        }, now);
+        await dispatchWorkflowTargetOverride(taskLifecycleV2, {
+            currentState: from, targetState: state, kind: 'task',
+            persistTransition: (_source, target) => { applyTaskGraphTarget(task, target, now); },
+        });
         task.manualStateOverrides = [
             ...(task.manualStateOverrides ?? []),
             { from, to: state, at: now, actor: 'dashboard-user' },