agents-relay 1.0.177 → 2.0.0

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

@@ -0,0 +1,24 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/planner-trigger-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const plannerTriggerV2 = new GraphRuntime(source, {
+    states: new Set(['idle', 'check_unblock', 'check_schedule', 'check_initial', 'manual', 'unblock', 'schedule', 'initial', 'continuation']),
+    guards: {
+        manualPlan: boolGuard('manualPlan'),
+        hasUnblock: boolGuard('hasUnblock'),
+        scheduledRun: boolGuard('scheduledRun'),
+        initialPlan: boolGuard('initialPlan'),
+    },
+    actions: {},
+    events: { 'plan.requested': { id: 'plan.requested' } },
+});
+export function dispatchPlannerTrigger(facts) {
+    return dispatchWorkflowGraphSync(plannerTriggerV2, {
+        initialState: 'idle', input: { transport: 'event', id: 'plan.requested', payload: {} }, durableFacts: facts,
+        isTransientState: state => state.startsWith('check_'), maxSteps: 4,
+    });
+}
+/** Compatibility/testing alias. Production callers use dispatchPlannerTrigger. */
+export const decidePlannerTrigger = dispatchPlannerTrigger;

package/dist/workflow/review-v2.js

@@ -0,0 +1,42 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/review-lifecycle-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const reviewLifecycleV2 = new GraphRuntime(source, {
+    states: new Set(['NONE', 'PENDING', 'STARTED', 'APPROVED', 'CHANGES_REQUIRED', 'BLOCKED', 'STALE']),
+    guards: {
+        unscheduled: boolGuard('unscheduled'),
+        reviewEnabled: boolGuard('reviewEnabled'),
+        prOpen: boolGuard('prOpen'),
+        jobActive: boolGuard('jobActive'),
+        implementationComplete: boolGuard('implementationComplete'),
+        headAvailable: boolGuard('headAvailable'),
+        completionGateSatisfied: boolGuard('completionGateSatisfied'),
+        noActiveReviewTask: boolGuard('noActiveReviewTask'),
+        currentReviewCancelled: boolGuard('currentReviewCancelled'),
+        noApprovedCurrentReview: boolGuard('noApprovedCurrentReview'),
+        autoMerge: boolGuard('autoMerge'),
+    },
+    actions: Object.fromEntries(['review.create', 'review.cancelStale', 'review.createFix', 'review.requestMerge'].map(id => [id, { id }])),
+    events: Object.fromEntries(['reconcile', 'review.started', 'review.approved', 'review.changes_required', 'review.blocked', 'head.changed'].map(id => [id, { id }])),
+});
+export function reviewGraphState(outcome) {
+    if (!outcome)
+        return 'NONE';
+    return outcome.toUpperCase();
+}
+export function reviewOutcome(state) {
+    if (state === 'NONE')
+        return undefined;
+    if (!['PENDING', 'STARTED', 'APPROVED', 'CHANGES_REQUIRED', 'BLOCKED', 'STALE'].includes(state)) {
+        throw new Error('Unknown review graph state ' + state);
+    }
+    return state.toLowerCase();
+}
+export async function dispatchReviewLifecycle(outcome, event, facts = {}, executeAction) {
+    return dispatchWorkflowGraph(reviewLifecycleV2, { initialState: reviewGraphState(outcome), input: { transport: 'event', id: event, payload: {} }, durableFacts: facts, executeAction });
+}
+export function decideReviewLifecycle(outcome, event, facts = {}) {
+    return dispatchWorkflowGraphSync(reviewLifecycleV2, { initialState: reviewGraphState(outcome), input: { transport: 'event', id: event, payload: {} }, durableFacts: facts });
+}

package/dist/workflow/runtime.js

@@ -17,12 +17,26 @@ export function graphWorkflowDecision(engine, from, event, facts = {}) {
         reason: 'accepted',
     };
 }
-function applyTaskMutation(task, mutation) {
+export function applyTaskMutation(task, mutation) {
     if (mutation === 'mutation.clearError')
         task.error = null;
     if (mutation === 'mutation.clearFailureReason')
         task.failureReason = undefined;
+    if (mutation === 'mutation.clearLease') {
+        task.leaseOwner = null;
+        task.leaseExpiresAt = null;
+    }
+    if (mutation === 'mutation.clearExecution')
+        task.executionId = null;
+    if (mutation === 'mutation.markLeaseExpired')
+        task.error = 'Lease expired after maximum attempts';
+    if (mutation === 'mutation.markStartupOrphanedExhausted')
+        task.error = 'Orphaned after relayd restart after maximum attempts';
+    if (mutation === 'mutation.markPlannerUnavailable')
+        task.error = 'No objective planner configured';
 }
+export function applyTaskGraphTarget(task, target, timestamp = new Date().toISOString()) { task.state = target; task.updatedAt = timestamp; }
+export function applyJobGraphTarget(job, target, timestamp = new Date().toISOString()) { job.state = target; job.updatedAt = timestamp; }
 export function applyTaskWorkflowDecision(task, decision, timestamp = new Date().toISOString()) {
     if (!decision.accepted || !decision.target)
         throw new Error(`Cannot apply rejected workflow decision to task ${task.id}`);

package/dist/workflow/schedule-cycle-v2.js

@@ -0,0 +1,25 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/schedule-cycle-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const scheduleCycleV2 = new GraphRuntime(source, {
+    states: new Set(['idle', 'check_satisfied', 'waiting', 'finished']),
+    guards: {
+        hasCurrentSlot: boolGuard('hasCurrentSlot'),
+        plannerSatisfied: boolGuard('plannerSatisfied'),
+    },
+    actions: { 'schedule.finishSlot': { id: 'schedule.finishSlot' } },
+    events: { 'schedule.reconcile': { id: 'schedule.reconcile' } },
+});
+export function dispatchScheduleCycle(facts, onFinish) {
+    return dispatchWorkflowGraphSync(scheduleCycleV2, {
+        initialState: 'idle', input: { transport: 'event', id: 'schedule.reconcile', payload: {} }, durableFacts: facts,
+        isTransientState: state => state.startsWith('check_'), maxSteps: 2,
+        executeAction: actionId => { if (actionId === 'schedule.finishSlot')
+            onFinish();
+        else
+            throw new Error('Unsupported schedule cycle action ' + actionId); return {}; },
+    });
+}
+export function decideScheduleCycle(facts) { return dispatchScheduleCycle(facts, () => { }); }

package/dist/workflow/scheduled-run-v2.js

@@ -0,0 +1,30 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/scheduled-run-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const scheduledRunV2 = new GraphRuntime(source, {
+    states: new Set([
+        'idle', 'check_unclaimed', 'check_job', 'check_active', 'check_concurrency',
+        'check_queue', 'check_missed', 'skip_idempotent', 'skip_active', 'claimed',
+    ]),
+    guards: {
+        slotDue: boolGuard('slotDue'),
+        slotUnclaimed: boolGuard('slotUnclaimed'),
+        jobActive: boolGuard('jobActive'),
+        hasActiveTasks: boolGuard('hasActiveTasks'),
+        concurrencySkip: boolGuard('concurrencySkip'),
+        concurrencyQueue: boolGuard('concurrencyQueue'),
+        runMissed: boolGuard('runMissed'),
+    },
+    actions: Object.fromEntries([
+        'schedule.skipActiveAdvance', 'schedule.claimFromSlot', 'schedule.claimFromNow',
+    ].map(id => [id, { id }])),
+    events: { 'schedule.tick': { id: 'schedule.tick' } },
+});
+export async function dispatchScheduledRun(facts, executeAction) {
+    return dispatchWorkflowGraph(scheduledRunV2, { initialState: 'idle', input: { transport: 'event', id: 'schedule.tick', payload: {} }, durableFacts: facts, isTransientState: state => state.startsWith('check_'), maxSteps: 8, executeAction });
+}
+export function decideScheduledRun(facts) {
+    return dispatchWorkflowGraphSync(scheduledRunV2, { initialState: 'idle', input: { transport: 'event', id: 'schedule.tick', payload: {} }, durableFacts: facts, isTransientState: state => state.startsWith('check_'), maxSteps: 8 });
+}

package/dist/workflow/task-action-policy.js

@@ -0,0 +1,19 @@
+import { decideRelatedTaskAction } from './task-related-action-v2.js';
+/**
+ * Graph-driven related-task scope for explicit task actions.
+ *
+ * TypeScript provides relationship/lifecycle facts; the executable workflow
+ * decides whether each candidate receives a related mutation.
+ */
+export function selectRelatedTaskMutations(job, task, actionId) {
+    return job.tasks.flatMap(candidate => {
+        const decision = decideRelatedTaskAction(task, candidate, actionId);
+        if (!decision.accepted || decision.target !== 'selected')
+            return [];
+        return [{
+                taskId: candidate.id,
+                mutation: 'cancel',
+                reason: `Superseded by manual retry of ${task.id}`,
+            }];
+    });
+}

package/dist/workflow/task-reconcile.js

@@ -1,5 +1,4 @@
-import { decideTaskLifecycle } from './lifecycle.js';
-import { applyTaskWorkflowDecision } from './runtime.js';
+import { dispatchTaskLifecycleSync } from './lifecycle.js';
 export function dependencyReady(task, tasks) {
     return task.dependencies.every(id => tasks.get(id)?.state === 'SUCCEEDED');
 }
@@ -32,17 +31,18 @@ export function reconcileTaskDependencies(job) {
     const scopedTasks = scheduledCycleTasks(job);
     const tasks = new Map(job.tasks.map(task => [task.id, task]));
     for (const task of scopedTasks) {
+        if (task.kind === 'planner')
+            continue;
         const ready = dependencyReady(task, tasks);
         const facts = {
             dependenciesSatisfied: task.dependencies.length > 0 && ready,
             dependenciesUnsatisfied: task.dependencies.length > 0 && !ready,
             runnable: ready,
         };
-        const decision = decideTaskLifecycle(task, 'reconcile', facts);
+        const from = task.state;
+        const decision = dispatchTaskLifecycleSync(task, 'reconcile', facts);
         if (decision.reason === 'ambiguous')
-            throw new Error(`Ambiguous automatic task transition from ${task.state}`);
-        if (decision.accepted && decision.target)
-            applyTaskWorkflowDecision(task, decision);
+            throw new Error(`Ambiguous automatic task transition from ${from}`);
     }
     return job;
 }

package/dist/workflow/task-related-action-v2.js

@@ -0,0 +1,42 @@
+import { readFileSync } from 'node:fs';
+import { decideTaskLifecycle } from './lifecycle.js';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/task-related-action-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const taskRelatedActionV2 = new GraphRuntime(source, {
+    states: new Set(['evaluate', 'check_other', 'check_recovery', 'skip', 'selected']),
+    guards: {
+        otherTask: boolGuard('otherTask'),
+        recoveryForTask: boolGuard('recoveryForTask'),
+        candidateCancellable: boolGuard('candidateCancellable'),
+    },
+    actions: {
+        'task.retry': { id: 'task.retry' },
+        'task.cancel': { id: 'task.cancel' },
+        'task.unblock.retry': { id: 'task.unblock.retry' },
+        'task.queue': { id: 'task.queue' },
+        'task.release': { id: 'task.release' },
+        'task.hold': { id: 'task.hold' },
+        'related.cancel': { id: 'related.cancel' },
+    },
+    events: {},
+});
+export function relatedTaskActionFacts(task, candidate) {
+    return {
+        otherTask: candidate.id !== task.id,
+        recoveryForTask: candidate.agentName === 'troubleshooter'
+            && (candidate.parentTaskId === task.id
+                || (!candidate.parentTaskId && candidate.id.startsWith(`troubleshoot-${task.id}-a`))),
+        candidateCancellable: decideTaskLifecycle(candidate, 'cancel').accepted,
+    };
+}
+export function decideRelatedTaskAction(task, candidate, actionId) {
+    return dispatchWorkflowGraphSync(taskRelatedActionV2, {
+        initialState: 'evaluate',
+        input: { transport: 'action', id: actionId, payload: {} },
+        durableFacts: relatedTaskActionFacts(task, candidate),
+        isTransientState: state => state === 'check_other' || state === 'check_recovery',
+        maxSteps: 3,
+    });
+}

package/dist/workflow/troubleshooter-v2.js

@@ -0,0 +1,29 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraphSync } from './dispatcher.js';
+const source = readFileSync(new URL('../../workflow/troubleshooter-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const troubleshooterV2 = new GraphRuntime(source, {
+    states: new Set(['idle', 'check_ordinary', 'check_run', 'check_needs', 'check_id', 'check_barrier', 'skip', 'create']),
+    guards: {
+        failedOrBlocked: boolGuard('failedOrBlocked'),
+        ordinaryWork: boolGuard('ordinaryWork'),
+        currentRun: boolGuard('currentRun'),
+        needsRecovery: boolGuard('needsRecovery'),
+        idUnused: boolGuard('idUnused'),
+        noRecoveryBarrier: boolGuard('noRecoveryBarrier'),
+    },
+    actions: { 'troubleshooter.create': { id: 'troubleshooter.create' } },
+    events: { 'troubleshooter.reconcile': { id: 'troubleshooter.reconcile' } },
+});
+export function dispatchTroubleshooter(facts, onCreate) {
+    return dispatchWorkflowGraphSync(troubleshooterV2, {
+        initialState: 'idle', input: { transport: 'event', id: 'troubleshooter.reconcile', payload: {} }, durableFacts: facts,
+        isTransientState: state => state.startsWith('check_'), maxSteps: 6,
+        executeAction: actionId => { if (actionId === 'troubleshooter.create')
+            onCreate();
+        else
+            throw new Error('Unsupported troubleshooter graph action ' + actionId); return {}; },
+    });
+}
+export function decideTroubleshooter(facts) { return dispatchTroubleshooter(facts, () => { }); }

package/dist/workspace.js

@@ -1,5 +1,5 @@
 import { mkdir, readdir, stat } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { homedir } from 'node:os';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
@@ -81,6 +81,11 @@ export function resolveRepositoryProjectPath(repositoryRoot, projectPath) {
         return root;
     if (isAbsolute(projectPath))
         throw new Error('Job projectPath must be repository-relative');
+    // Legacy Jobs sometimes stored the repository folder name itself (for example
+    // projectPath='agents-relay' for the agents-relay repository). Interpret that
+    // historical form as the repository root instead of appending it twice.
+    if (projectPath === basename(root))
+        return root;
     const target = resolve(root, projectPath);
     const rel = relative(root, target);
     if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel))

package/package.json

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

package/skills/agents-relay/agents/planner.agent.md

@@ -36,14 +36,15 @@ The graph is the explanation for the decomposition: every emitted Task should ma
 
 ### Semantic ownership vs execution flow
 
-The planning graph and the durable Task tree are two different views:
+The planning graph and the durable Task tree are different views:
 
 - The graph and `dependencies` express execution flow and prerequisites.
 - `parentTaskId` expresses semantic ownership of an artifact or milestone.
-- A later planning round must inspect the existing Task tree and attach work to the existing artifact it changes. Do not turn a later round into a new root merely because its work follows an earlier Task.
-- `plan-N` records are planning provenance, not business milestones, and must never be used as `parentTaskId`.
+- Later planning rounds attach revision, re-review, specialist review, and recovery work to the existing artifact subtree instead of creating new roots merely because the work occurs later.
+- `plan-N` records are planning provenance, never business milestones, and must never be used as `parentTaskId`.
+- A terminal parent remains valid historical ownership. Dependencies may cross semantic subtrees.
 
-For example, produce `architecture-v2` as a root milestone, then place `architecture-review`, `architecture-revision-1`, and `architecture-rereview-1` under it. The revision may depend on the review, and the re-review may depend on the revision; those dependencies do not determine their semantic parent. An independent `graph-runtime-v2` milestone remains a root sibling. A troubleshooter belongs under the failed Task (or its artifact subtree), and specialist review work stays under its review/artifact context.
+Example: keep `architecture-v2` as the root milestone and place review, revision, and re-review beneath it; their dependencies express order without changing their semantic parent. An independent `graph-runtime-v2` milestone remains a root sibling.
 
 ### Examples
 
@@ -80,7 +81,6 @@ Do not create separate Tasks merely for "analyze", "format", "call tool", "check
 - When a Task depends on mutable repository or product state, distinguish a frozen evidence target from the current execution head. A SHA may freeze that Task's own review/source evidence, but do not copy an upstream SHA into a dependent release, deploy, publication, or other follow-on Task unless the objective explicitly requires that same frozen target. After dependencies complete, downstream Tasks must resolve and verify the current durable Job/PR head before acting.
 - When fresh UI, browser, store, runtime, or visual evidence is material to the Task outcome, say so explicitly in the Task input and require evidence from the real current state. Existing screenshots, prepared assets, or prior observations are not substitutes for fresh evidence unless the objective explicitly allows reuse.
 - When a Job needs multi-perspective review, use the visible `review-chair` agent or an Agent Graph to select specialist roles dynamically. Keep specialist Tasks as independent siblings against the same immutable target/version, and leave worker/model/provider routing to Relay.
-- Treat `parentTaskId` as semantic ownership, not execution order. Select an existing non-planner Task as the parent when a later-round revision, re-review, specialist review, or troubleshooting Task belongs to that artifact/milestone; a terminal parent remains valid historical ownership. Use `dependencies` independently for prerequisites, including cross-parent dependencies. Never use a `plan-N` Task as a parent, and never invent a synthetic parent merely to group a planning round.
 - A Task describes what an agent must accomplish; never emit a shell command as a worker Task.
 - Use dependencies only for Task IDs inside the current Job, and only when execution order actually matters. Never encode cross-Job or cross-repository dependencies in `dependencies`.
 - When the current Job is a prerequisite for another durable Job/Task, emit that dependent in top-level `unblocks`. The current blocker Job owns this authoritative reverse relation. Dependent-side `blockedBy` is optional observability metadata and is not the source of truth. Use `resolutionMode: "merge"` when blocker PR merge is sufficient; use `"verified"` when publication, deployment, runtime health, human approval, or another post-merge fact must be verified.

package/skills/agents-relay/contracts/task-job-contract.md

@@ -24,31 +24,9 @@ Task producers choose semantic task properties such as objective, dependencies,
 
 ### Planning graph and semantic Task tree
 
-The planning graph expresses execution flow. The Task tree expresses semantic
-ownership. `dependencies` answer which durable outcomes must succeed before a
-Task can run; `parentTaskId` answers which durable artifact, milestone, or
-parent outcome the Task belongs to. These are independent relationships and
-must not be inferred from one another.
-
-For a multi-round artifact workflow, keep the business tree compact and
-milestone-oriented:
-
-```text
-Job
-├── Architecture v2
-│   ├── Review
-│   ├── Revision 1
-│   └── Re-review 1
-└── Graph Runtime v2
-```
+The planning graph expresses execution flow. The Task tree expresses semantic ownership. `dependencies` answer which durable outcomes must succeed before a Task can run; `parentTaskId` answers which durable artifact or milestone owns the Task. These are independent relationships.
 
-The revision may depend on Review and Re-review may depend on Revision 1, but
-both remain semantically owned by Architecture v2. A later Planner round must
-inspect existing Tasks and attach review, change, validation-rerun, release
-correction, or recovery work to the existing artifact subtree. An independent
-milestone is a root sibling. `plan-N` records are planning provenance/history,
-never semantic parents. Existing terminal Tasks are historical evidence and
-must not be rewritten merely to improve the tree.
+A later Planner round must inspect the existing semantic tree and attach review, revision, re-review, validation rerun, release correction, or recovery work to the existing artifact subtree. Independent milestones remain roots. `plan-N` records are provenance/history and must never be semantic parents. Existing terminal Tasks remain immutable historical evidence and may continue to own later work.
 
 ### Task input vs result
 
@@ -126,33 +104,6 @@ For the ChatGPT Browser Worker guardian, for example, the Job defines `pass ->
 
 ### Optional Review Chair Tasks
 
-### Semantic Task tree and planning provenance
-
-The planning graph, semantic Task tree, and dependency graph are separate:
-
-```text
-plan-2 (planning provenance only)
-  ├─ revision (parentTaskId: milestone, dependencies: [review])
-  └─ re-review (parentTaskId: milestone, dependencies: [revision])
-independent-milestone (parentTaskId: null, dependencies: [revision])
-```
-
-`parentTaskId` answers which durable artifact or milestone owns this work. It
-may point to an existing terminal work Task when a later planning round
-continues that artifact, or to another work Task in the same batch. It must
-never point to a `plan-N`/historical `planner-N` record and must not be used
-just to group a round. `dependencies` answer what must finish first and may
-cross semantic subtrees. Reviews, changes-required revisions, re-reviews,
-specialist reviews, and troubleshooter recovery belong under the relevant
-artifact/milestone; independent milestones remain roots. Planning provenance
-is retained separately in `planningDecisionId` and `planningRound`, and
-historical terminal Tasks are immutable.
-
-Incorrect: make every generated Task a child of the current `plan-N`, or use
-`parentTaskId` as a substitute for a dependency. Correct: attach a re-review
-to the original milestone, set its dependency to the revision Task, and leave
-the original milestone's terminal record unchanged.
-
 Projects may use the shared `review-chair` agent as a normal Task or Agent
 Graph node. The chair discovers specialist agent roles from the resolved
 visible-agent catalog, records selection reasons, and creates sibling durable

package/workflow/authoritative-unblock-v2.mmd

@@ -0,0 +1,15 @@
+flowchart LR
+%% relay: initial blocked
+blocked["state: blocked"]
+autonomous["state: autonomous_replan"]
+fixed["state: fixed_retry"]
+
+autonomousJob["guard: autonomousJob"]
+replan["action: unblock.replan"]
+retry["action: unblock.retry"]
+
+blocked -->|on: task.authoritative_unblock| autonomousJob
+autonomousJob -->|true| replan
+replan --> autonomous
+autonomousJob -->|false| retry
+retry --> fixed

package/workflow/blocker-resolution-v2.mmd

@@ -0,0 +1,73 @@
+flowchart LR
+%% relay: initial waiting
+waiting["state: waiting"]
+checkTarget["state: check_target"]
+checkAutonomous["state: check_autonomous"]
+checkEffective["state: check_effective"]
+checkAlreadyUnblocked["state: check_already_unblocked"]
+checkDraft["state: check_draft"]
+checkBlocked["state: check_blocked"]
+checkFailed["state: check_failed"]
+checkUnblocked["state: check_unblocked"]
+wait["state: wait"]
+obsolete["state: obsolete"]
+resumed["state: resumed"]
+
+resolutionAllowed["guard: resolutionAllowed"]
+targetMatches["guard: targetMatches"]
+autonomousJob["guard: autonomousJob"]
+effectivelyBlocked["guard: effectivelyBlocked"]
+alreadyUnblocked["guard: alreadyUnblocked"]
+isDraft["guard: isDraft"]
+isBlocked["guard: isBlocked"]
+isFailed["guard: isFailed"]
+isUnblocked["guard: isUnblocked"]
+
+autonomousUnblock["action: blocker.autonomousUnblock"]
+acceptExisting["action: blocker.acceptExistingUnblock"]
+releaseDraft["action: blocker.releaseDraft"]
+unblockTask["action: blocker.unblockTask"]
+retryFailed["action: blocker.retryFailed"]
+retryUnblocked["action: blocker.retryUnblocked"]
+
+waiting -->|on: blocker.resolved| resolutionAllowed
+resolutionAllowed -->|false| wait
+resolutionAllowed -->|true| checkTarget
+
+checkTarget -->|on: blocker.resolved| targetMatches
+targetMatches -->|false| obsolete
+targetMatches -->|true| checkAutonomous
+
+checkAutonomous -->|on: blocker.resolved| autonomousJob
+autonomousJob -->|true| checkEffective
+autonomousJob -->|false| checkDraft
+
+checkEffective -->|on: blocker.resolved| effectivelyBlocked
+effectivelyBlocked -->|true| autonomousUnblock
+autonomousUnblock --> resumed
+effectivelyBlocked -->|false| checkAlreadyUnblocked
+
+checkAlreadyUnblocked -->|on: blocker.resolved| alreadyUnblocked
+alreadyUnblocked -->|true| acceptExisting
+acceptExisting --> resumed
+alreadyUnblocked -->|false| checkDraft
+
+checkDraft -->|on: blocker.resolved| isDraft
+isDraft -->|true| releaseDraft
+releaseDraft --> resumed
+isDraft -->|false| checkBlocked
+
+checkBlocked -->|on: blocker.resolved| isBlocked
+isBlocked -->|true| unblockTask
+unblockTask --> resumed
+isBlocked -->|false| checkFailed
+
+checkFailed -->|on: blocker.resolved| isFailed
+isFailed -->|true| retryFailed
+retryFailed --> resumed
+isFailed -->|false| checkUnblocked
+
+checkUnblocked -->|on: blocker.resolved| isUnblocked
+isUnblocked -->|true| retryUnblocked
+retryUnblocked --> resumed
+isUnblocked -->|false| obsolete

package/workflow/job-lifecycle-v2.mmd

@@ -0,0 +1,70 @@
+flowchart LR
+%% relay: initial draft
+draft["state: DRAFT"]
+active["state: ACTIVE"]
+completed["state: COMPLETED"]
+cancelled["state: CANCELLED"]
+notMergedDraft["guard: notMerged"]
+notMergedActive["guard: notMerged"]
+autoMergeReview["guard: autoMerge"]
+autoMergeImplementation["guard: autoMerge"]
+prOpenReconcile["guard: prOpen"]
+reviewDisabledReconcile["guard: reviewDisabled"]
+implementationCompleteReconcile["guard: implementationComplete"]
+autoMergeReconcile["guard: autoMerge"]
+headAvailableReconcile["guard: headAvailable"]
+mergeCapableReconcile["guard: mergeCapable"]
+mergeReconcile["action: effect.mergePullRequest"]
+cancelDraftMerge["action: effect.cancelActiveTasks"]
+cancelDraftClose["action: effect.cancelActiveTasks"]
+mergeReview["action: effect.mergePullRequest"]
+mergeImplementation["action: effect.mergePullRequest"]
+cancelActiveMerge["action: effect.cancelActiveTasks"]
+cancelActiveClose["action: effect.cancelActiveTasks"]
+cancelCancelledMerge["action: effect.cancelActiveTasks"]
+
+draft -->|on: activate| active
+draft -->|on: pr.merged| cancelDraftMerge
+cancelDraftMerge --> completed
+draft -->|on: cancel| cancelDraft
+cancelDraft["action: effect.cancelActiveTasks"]
+cancelDraft --> cancelled
+draft -->|on: pr.closed| notMergedDraft
+notMergedDraft -->|true| cancelDraftClose
+cancelDraftClose --> cancelled
+
+active -->|on: reconcile| prOpenReconcile
+prOpenReconcile -->|true| reviewDisabledReconcile
+prOpenReconcile -->|false| active
+reviewDisabledReconcile -->|true| implementationCompleteReconcile
+reviewDisabledReconcile -->|false| active
+implementationCompleteReconcile -->|true| autoMergeReconcile
+implementationCompleteReconcile -->|false| active
+autoMergeReconcile -->|true| headAvailableReconcile
+autoMergeReconcile -->|false| active
+headAvailableReconcile -->|true| mergeCapableReconcile
+headAvailableReconcile -->|false| active
+mergeCapableReconcile -->|true| mergeReconcile
+mergeCapableReconcile -->|false| active
+mergeReconcile --> active
+
+active -->|on: review.approved| autoMergeReview
+autoMergeReview -->|true| mergeReview
+mergeReview --> active
+active -->|on: implementation.completed| autoMergeImplementation
+autoMergeImplementation -->|true| mergeImplementation
+mergeImplementation --> active
+active -->|on: effect.mergePullRequest.failed| active
+active -->|on: pr.merged| cancelActiveMerge
+cancelActiveMerge --> completed
+active -->|on: cancel| cancelActive
+cancelActive["action: effect.cancelActiveTasks"]
+cancelActive --> cancelled
+active -->|on: pr.closed| notMergedActive
+notMergedActive -->|true| cancelActiveClose
+cancelActiveClose --> cancelled
+
+cancelled -->|on: pr.merged| cancelCancelledMerge
+cancelCancelledMerge --> completed
+cancelled -->|on: effect.cancelActiveTasks.failed| cancelled
+completed -->|on: effect.cancelActiveTasks.failed| completed

package/workflow/job-lifecycle.mmd

@@ -3,14 +3,14 @@ stateDiagram-v2
 
     DRAFT --> ACTIVE: activate
     DRAFT --> COMPLETED: pr.merged / effect.cancelActiveTasks
-    DRAFT --> CANCELLED: cancel
+    DRAFT --> CANCELLED: cancel / effect.cancelActiveTasks
     DRAFT --> CANCELLED: pr.closed [notMerged] / effect.cancelActiveTasks
 
     ACTIVE --> ACTIVE: review.approved [autoMerge] / effect.mergePullRequest
     ACTIVE --> ACTIVE: implementation.completed [autoMerge] / effect.mergePullRequest
     ACTIVE --> ACTIVE: effect.mergePullRequest.failed
     ACTIVE --> COMPLETED: pr.merged / effect.cancelActiveTasks
-    ACTIVE --> CANCELLED: cancel
+    ACTIVE --> CANCELLED: cancel / effect.cancelActiveTasks
     ACTIVE --> CANCELLED: pr.closed [notMerged] / effect.cancelActiveTasks
 
     CANCELLED --> COMPLETED: pr.merged / effect.cancelActiveTasks