agents-relay 1.0.177 → 2.0.0

package/dist/workflow/dispatcher.js

@@ -0,0 +1,56 @@
+import { GraphDispatcher } from './graph-v2.js';
+/**
+ * The single production graph execution boundary.
+ * Ingress adapters normalize input/facts, while GraphDispatcher alone evaluates,
+ * persists graph transitions, executes graph-selected actions, and emits events.
+ */
+export async function dispatchWorkflowGraph(runtime, options) {
+    let current = options.initialState;
+    const maxSteps = options.maxSteps ?? 1;
+    for (let step = 0; step < maxSteps; step += 1) {
+        const dispatcher = new GraphDispatcher(runtime, {
+            persistTransition: async (transition) => { await options.persistTransition?.(transition.source, transition.target); },
+            executeAction: options.executeAction ? async (actionId) => await options.executeAction(actionId) : undefined,
+            publishEvent: async (event) => { await options.publishEvent?.(event.id, event.payload); },
+        });
+        const result = await dispatcher.dispatch({
+            currentState: current,
+            input: options.input,
+            durableFacts: options.durableFacts ?? {},
+        });
+        if (!result.decision.accepted)
+            return result.decision;
+        current = result.decision.target;
+        if (!options.isTransientState?.(current))
+            return result.decision;
+    }
+    return { accepted: false, source: current, reason: 'no_transition' };
+}
+export function dispatchWorkflowGraphSync(runtime, options) {
+    let current = options.initialState;
+    const maxSteps = options.maxSteps ?? 1;
+    for (let step = 0; step < maxSteps; step += 1) {
+        const dispatcher = new GraphDispatcher(runtime, {
+            persistTransition: transition => { const result = options.persistTransition?.(transition.source, transition.target); if (result instanceof Promise)
+                throw new Error('sync workflow persistTransition returned Promise'); },
+            executeAction: options.executeAction ? actionId => { const result = options.executeAction(actionId); if (result instanceof Promise)
+                throw new Error('sync workflow executeAction returned Promise'); return result; } : undefined,
+            publishEvent: event => { const result = options.publishEvent?.(event.id, event.payload); if (result instanceof Promise)
+                throw new Error('sync workflow publishEvent returned Promise'); },
+        });
+        const result = dispatcher.dispatchSync({ currentState: current, input: options.input, durableFacts: options.durableFacts ?? {} });
+        if (!result.decision.accepted)
+            return result.decision;
+        current = result.decision.target;
+        if (!options.isTransientState?.(current))
+            return result.decision;
+    }
+    return { accepted: false, source: current, reason: 'no_transition' };
+}
+export async function dispatchWorkflowTargetOverride(runtime, options) {
+    // Administrative correction still derives legality from the canonical Mermaid graph.
+    // It intentionally executes no workflow actions/effects: this is a state repair, not an event replay.
+    const { assertV2StateTransition } = await import('./definitions-v2.js');
+    assertV2StateTransition(runtime.graph, options.currentState, options.targetState, options.kind);
+    await options.persistTransition(options.currentState, options.targetState);
+}

package/dist/workflow/entity-creation.js

@@ -0,0 +1,32 @@
+import { dispatchJobLifecycleSync, dispatchTaskLifecycleSync } from './lifecycle.js';
+function dependenciesSatisfied(job, dependencies) {
+    if (dependencies.length === 0)
+        return true;
+    const byId = new Map(job.tasks.map(task => [task.id, task]));
+    return dependencies.every(id => byId.get(id)?.state === 'SUCCEEDED');
+}
+/**
+ * Canonical creation boundary for new Task entities.
+ * Constructors provide metadata/facts only; the Task lifecycle graph derives
+ * whether a fresh Task remains DRAFT or becomes QUEUED.
+ */
+export function createTaskEntity(job, value, options = {}) {
+    const task = { ...value, state: 'DRAFT' };
+    if (!options.defer) {
+        dispatchTaskLifecycleSync(task, 'reconcile', {
+            dependenciesSatisfied: dependenciesSatisfied(job, task.dependencies),
+        });
+    }
+    return task;
+}
+/**
+ * Canonical creation boundary for new Job entities.
+ * New Jobs begin at the graph initial state and scheduled creation is expressed
+ * as the normal activate lifecycle event.
+ */
+export function createJobEntity(value, options = {}) {
+    const job = { ...value, state: 'DRAFT' };
+    if (options.activate)
+        dispatchJobLifecycleSync(job, 'activate');
+    return job;
+}

package/dist/workflow/graph-v2.js

@@ -0,0 +1,391 @@
+/** Strict, executable Mermaid flowchart profile for the incremental v2 graph runtime. */
+const IDENTIFIER = '[A-Za-z_][A-Za-z0-9_.-]*';
+const NODE = new RegExp(`^(${IDENTIFIER})\\["(state|guard|action|emit):\\s*([^|\\]"]+?)(?:\\s*\\|[^\\]"]*)?"\\]$`);
+const EDGE = new RegExp(`^(${IDENTIFIER})\\s+-->\\s*(?:\\|\\s*([^|]+?)\\s*\\|\\s*)?(${IDENTIFIER})$`);
+const HEADER = /^flowchart (LR|RL|TD|TB)$/;
+const NAME = new RegExp(`^${IDENTIFIER}$`);
+function fail(line, message) { throw new Error(`line ${line}: ${message}`); }
+function lookup(value, id) {
+    return value instanceof Map ? value.get(id) : value?.[id];
+}
+function entries(value) {
+    return value instanceof Map ? value.entries() : Object.entries(value ?? {});
+}
+function parseLabel(raw, line) {
+    if (raw === undefined)
+        return { kind: 'unlabelled', semanticId: null };
+    const label = raw.trim();
+    if (label === 'true' || label === 'false')
+        return { kind: label, semanticId: null };
+    const match = label.match(/^(on|request|to|emit):\s*(.*)$/);
+    if (!match || !NAME.test(match[2]))
+        fail(line, `unsupported edge label '${label}'`);
+    return { kind: match[1], semanticId: match[2] };
+}
+export function parseGraphV2(source) {
+    const lines = source.split(/\r?\n/);
+    let direction = null;
+    let initial = null;
+    const nodes = new Map();
+    const edges = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        const lineNumber = index + 1;
+        const line = lines[index].trim();
+        if (!line)
+            continue;
+        if (line.startsWith('%%')) {
+            const directive = line.match(/^%%\s*relay:\s*initial\s+(.+)$/);
+            if (directive) {
+                if (initial)
+                    fail(lineNumber, 'duplicate initial declaration');
+                initial = directive[1].trim();
+                if (!NAME.test(initial))
+                    fail(lineNumber, `invalid initial state '${initial}'`);
+            }
+            continue;
+        }
+        if (!direction) {
+            const header = line.match(HEADER);
+            if (!header)
+                fail(lineNumber, 'expected flowchart LR, RL, TD, or TB');
+            direction = header[1];
+            continue;
+        }
+        const node = line.match(NODE);
+        if (node) {
+            if (nodes.has(node[1]))
+                fail(lineNumber, `duplicate node '${node[1]}'`);
+            const semanticId = node[3].trim();
+            if (!NAME.test(semanticId))
+                fail(lineNumber, `invalid ${node[2]} identifier '${semanticId}'`);
+            if (node[2] === 'state' && [...nodes.values()].some(candidate => candidate.kind === 'state' && candidate.semanticId === semanticId))
+                fail(lineNumber, `duplicate semantic declaration 'state: ${semanticId}'`);
+            nodes.set(node[1], { id: node[1], kind: node[2], semanticId, line: lineNumber });
+            continue;
+        }
+        const edge = line.match(EDGE);
+        if (edge) {
+            const label = parseLabel(edge[2], lineNumber);
+            edges.push({ from: edge[1], to: edge[3], ...label, line: lineNumber });
+            continue;
+        }
+        const unsupportedShape = line.match(/[({<]/)?.[0];
+        if (unsupportedShape) {
+            const shape = unsupportedShape === '{' ? '{...}' : `${unsupportedShape}...`;
+            fail(lineNumber, `unsupported node shape '${shape}'; expected '[\"...\"]'`);
+        }
+        fail(lineNumber, `unsupported syntax '${line}'`);
+    }
+    if (!direction)
+        throw new Error('line 1: executable graph is empty; expected flowchart header');
+    if (!initial)
+        throw new Error('graph requires exactly one %% relay: initial STATE declaration');
+    if (!nodes.has(initial) || nodes.get(initial)?.kind !== 'state')
+        throw new Error(`initial state '${initial}' is not a declared state node`);
+    if (![...nodes.values()].some(node => node.kind === 'state'))
+        throw new Error('graph requires at least one state node');
+    if (!edges.length)
+        throw new Error('graph requires at least one executable edge');
+    for (const edge of edges) {
+        if (!nodes.has(edge.from))
+            fail(edge.line, `edge source '${edge.from}' is not declared`);
+        if (!nodes.has(edge.to))
+            fail(edge.line, `edge target '${edge.to}' is not declared`);
+    }
+    validateTopology(nodes, edges, initial);
+    return { source, direction, nodes, edges, initial };
+}
+function validateTopology(nodes, edges, initial) {
+    const outgoing = new Map();
+    for (const edge of edges)
+        outgoing.set(edge.from, [...(outgoing.get(edge.from) ?? []), edge]);
+    for (const node of nodes.values()) {
+        const exits = outgoing.get(node.id) ?? [];
+        if (node.kind === 'state') {
+            for (const edge of exits) {
+                if (edge.kind !== 'on' && edge.kind !== 'request')
+                    fail(edge.line, `state '${node.semanticId}' may only have on:/request: exits`);
+                const target = nodes.get(edge.to);
+                if (target.kind !== 'state' && target.kind !== 'guard' && target.kind !== 'action')
+                    fail(edge.line, `${edge.kind} edge must lead to a state, guard, or action`);
+            }
+            const groups = new Map();
+            for (const edge of exits) {
+                const key = `${edge.kind}\\0${edge.semanticId}`;
+                groups.set(key, [...(groups.get(key) ?? []), edge]);
+            }
+            for (const group of groups.values()) {
+                if (group.length < 2)
+                    continue;
+                if (group.some(edge => nodes.get(edge.to).kind !== 'guard') || new Set(group.map(edge => edge.to)).size !== group.length) {
+                    const edge = group[1];
+                    fail(edge.line, `ambiguous input path for ${edge.kind} '${edge.semanticId}' from state '${node.semanticId}'`);
+                }
+            }
+        }
+        else if (node.kind === 'guard') {
+            if (exits.length < 1 || exits.length > 2 || exits.some(edge => edge.kind !== 'true' && edge.kind !== 'false') || new Set(exits.map(edge => edge.kind)).size !== exits.length)
+                fail(node.line, `guard '${node.semanticId}' requires one or two unique true/false exits`);
+            for (const edge of exits)
+                if (!['state', 'guard', 'action'].includes(nodes.get(edge.to).kind))
+                    fail(edge.line, `guard edge '${edge.kind}' must lead to a state, guard, or action`);
+        }
+        else if (node.kind === 'action') {
+            const continuations = exits.filter(edge => edge.kind === 'to' || edge.kind === 'unlabelled');
+            if (continuations.length > 1)
+                fail(node.line, `action '${node.semanticId}' has multiple continuations`);
+            for (const edge of continuations) {
+                const target = nodes.get(edge.to);
+                if (edge.kind === 'to') {
+                    if (target.kind !== 'state')
+                        fail(edge.line, 'to: action continuation must target a state');
+                    if (edge.semanticId !== target.semanticId)
+                        fail(edge.line, `to edge names state '${edge.semanticId}' but targets state '${target.semanticId}'`);
+                }
+                else if (target.kind !== 'state' && target.kind !== 'action')
+                    fail(edge.line, 'unlabelled action continuation must lead to an action or state');
+            }
+            for (const edge of exits.filter(edge => edge.kind === 'emit')) {
+                const target = nodes.get(edge.to);
+                if (target.kind !== 'emit')
+                    fail(edge.line, 'emit edge must lead to an emit node');
+                if (edge.semanticId !== target.semanticId)
+                    fail(edge.line, `emit edge names event '${edge.semanticId}' but targets emit '${target.semanticId}'`);
+            }
+            if (!continuations.length)
+                fail(node.line, `action '${node.semanticId}' must have one continuation`);
+        }
+        else if (exits.length)
+            fail(node.line, `emit node '${node.semanticId}' must not have outgoing edges`);
+    }
+    const reachable = new Set([initial]);
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const edge of edges)
+            if (reachable.has(edge.from) && !reachable.has(edge.to)) {
+                reachable.add(edge.to);
+                changed = true;
+            }
+    }
+    for (const node of nodes.values())
+        if (node.kind === 'state' && !reachable.has(node.id))
+            fail(node.line, `state '${node.semanticId}' is unreachable from initial state '${initial}'`);
+}
+export class GraphRegistry {
+    states;
+    guards;
+    actions;
+    events;
+    constructor(registries = {}) {
+        this.states = registries.states ?? new Set();
+        this.guards = new Map(entries(registries.guards));
+        this.actions = new Map(entries(registries.actions));
+        this.events = new Map(entries(registries.events));
+    }
+}
+export class GraphRuntime {
+    graph;
+    registry;
+    constructor(graphOrSource, registries = {}) {
+        this.graph = typeof graphOrSource === 'string' ? parseGraphV2(graphOrSource) : graphOrSource;
+        this.registry = new GraphRegistry(registries);
+        this.validateRegistries();
+    }
+    validateRegistries() {
+        for (const node of this.graph.nodes.values()) {
+            if (node.kind === 'state' && !this.registry.states.has(node.semanticId))
+                throw new Error(`unknown state '${node.semanticId}'`);
+            if (node.kind === 'guard' && !this.registry.guards.has(node.semanticId))
+                throw new Error(`unknown guard '${node.semanticId}'`);
+            if (node.kind === 'action' && !this.registry.actions.has(node.semanticId))
+                throw new Error(`unknown action '${node.semanticId}'`);
+            if (node.kind === 'emit' && !this.registry.events.has(node.semanticId))
+                throw new Error(`unknown emitted event '${node.semanticId}'`);
+        }
+        for (const edge of this.graph.edges) {
+            if (edge.kind === 'on' || edge.kind === 'emit') {
+                if (!this.registry.events.has(edge.semanticId))
+                    throw new Error(`unknown event '${edge.semanticId}'`);
+            }
+            if (edge.kind === 'request' && !this.registry.actions.has(edge.semanticId))
+                throw new Error(`unknown action '${edge.semanticId}'`);
+        }
+    }
+    validateInput(input) {
+        const definition = input.transport === 'event' ? this.registry.events.get(input.id) : this.registry.actions.get(input.id);
+        if (!definition)
+            throw new Error(`unknown ${input.transport} '${input.id}'`);
+        if (definition.validate && !definition.validate(input.payload))
+            throw new Error(`invalid payload for ${input.transport} '${input.id}'`);
+    }
+    pathFromSync(current, facts) {
+        const actions = [];
+        const visited = new Set();
+        while (true) {
+            if (visited.has(current))
+                throw new Error(`cyclic graph path at '${current}'`);
+            visited.add(current);
+            const currentNode = this.graph.nodes.get(current);
+            if (currentNode.kind === 'state')
+                return { target: currentNode.semanticId, actions };
+            if (currentNode.kind === 'guard') {
+                const guard = this.registry.guards.get(currentNode.semanticId);
+                const result = guard(facts);
+                if (result instanceof Promise)
+                    throw new Error(`guard '${currentNode.semanticId}' is asynchronous; use evaluate()`);
+                const branch = (result ? 'true' : 'false');
+                const branchEdge = this.graph.edges.find(edge => edge.from === currentNode.id && edge.kind === branch);
+                if (!branchEdge)
+                    return null;
+                current = branchEdge.to;
+                continue;
+            }
+            if (currentNode.kind === 'action') {
+                const emittedEvents = this.graph.edges.filter(edge => edge.from === currentNode.id && edge.kind === 'emit').map(edge => edge.semanticId);
+                actions.push({ node: currentNode, emittedEvents });
+                current = this.graph.edges.find(edge => edge.from === currentNode.id && (edge.kind === 'to' || edge.kind === 'unlabelled')).to;
+                continue;
+            }
+            throw new Error(`invalid executable path through emit node '${currentNode.semanticId}'`);
+        }
+    }
+    evaluateSync(facts) {
+        this.validateInput(facts.input);
+        const stateNode = [...this.graph.nodes.values()].find(node => node.kind === 'state' && node.semanticId === facts.currentState);
+        if (!stateNode)
+            throw new Error(`unknown state '${facts.currentState}'`);
+        const edges = this.graph.edges.filter(edge => edge.from === stateNode.id && edge.kind === (facts.input.transport === 'event' ? 'on' : 'request') && edge.semanticId === facts.input.id);
+        const results = edges.map(edge => this.pathFromSync(edge.to, facts)).filter((result) => result !== null);
+        if (results.length === 0)
+            return { accepted: false, source: facts.currentState, reason: 'no_transition' };
+        if (results.length > 1)
+            return { accepted: false, source: facts.currentState, reason: 'ambiguous' };
+        const result = results[0];
+        return { accepted: true, source: facts.currentState, target: result.target, actions: result.actions.map(step => ({ id: step.node.semanticId, input: facts.input, emittedEvents: step.emittedEvents })) };
+    }
+    async evaluate(facts) {
+        this.validateInput(facts.input);
+        const stateNode = [...this.graph.nodes.values()].find(node => node.kind === 'state' && node.semanticId === facts.currentState);
+        if (!stateNode)
+            throw new Error(`unknown state '${facts.currentState}'`);
+        const edges = this.graph.edges.filter(candidate => candidate.from === stateNode.id && candidate.kind === (facts.input.transport === 'event' ? 'on' : 'request') && candidate.semanticId === facts.input.id);
+        const evaluatePath = async (start) => {
+            let current = start;
+            const actions = [];
+            while (true) {
+                const node = this.graph.nodes.get(current);
+                if (node.kind === 'state')
+                    return { target: node.semanticId, actions };
+                if (node.kind === 'guard') {
+                    const result = await this.registry.guards.get(node.semanticId)(facts);
+                    const branch = this.graph.edges.find(candidate => candidate.from === node.id && candidate.kind === (result ? 'true' : 'false'));
+                    if (!branch)
+                        return null;
+                    current = branch.to;
+                    continue;
+                }
+                if (node.kind === 'action') {
+                    const emittedEvents = this.graph.edges.filter(candidate => candidate.from === node.id && candidate.kind === 'emit').map(candidate => candidate.semanticId);
+                    actions.push({ node, emittedEvents });
+                    current = this.graph.edges.find(candidate => candidate.from === node.id && (candidate.kind === 'to' || candidate.kind === 'unlabelled')).to;
+                    continue;
+                }
+                throw new Error(`invalid executable path through emit node '${node.semanticId}'`);
+            }
+        };
+        const results = (await Promise.all(edges.map(edge => evaluatePath(edge.to)))).filter((result) => result !== null);
+        if (results.length === 0)
+            return { accepted: false, source: facts.currentState, reason: 'no_transition' };
+        if (results.length > 1)
+            return { accepted: false, source: facts.currentState, reason: 'ambiguous' };
+        const result = results[0];
+        return { accepted: true, source: facts.currentState, target: result.target, actions: result.actions.map(step => ({ id: step.node.semanticId, input: facts.input, emittedEvents: step.emittedEvents })) };
+    }
+}
+export class GraphDispatcher {
+    runtime;
+    ports;
+    constructor(runtime, ports) {
+        this.runtime = runtime;
+        this.ports = ports;
+    }
+    dispatchSync(facts) {
+        const decision = this.runtime.evaluateSync(facts);
+        if (!decision.accepted)
+            return { decision, receipts: [] };
+        const persisted = this.ports.persistTransition({ source: decision.source, target: decision.target });
+        if (persisted instanceof Promise)
+            throw new Error('GraphDispatcher.dispatchSync requires synchronous persistTransition');
+        const receipts = [];
+        for (const step of decision.actions) {
+            const action = this.runtime.registry.actions.get(step.id);
+            const context = { facts, actionId: step.id, input: step.input };
+            const pending = this.ports.executeAction ? this.ports.executeAction(step.id, context) : action.execute ? action.execute(context) : {};
+            if (pending instanceof Promise)
+                throw new Error('GraphDispatcher.dispatchSync requires synchronous executeAction');
+            const receipt = pending;
+            receipts.push(receipt);
+            if (receipt.ok === false) {
+                const definition = this.runtime.registry.events.get(receipt.failureEvent.id);
+                if (!definition)
+                    throw new Error(`unknown failure event '${receipt.failureEvent.id}'`);
+                if (definition.validate && !definition.validate(receipt.failureEvent.payload))
+                    throw new Error(`invalid payload for failure event '${receipt.failureEvent.id}'`);
+                const published = this.ports.publishEvent(receipt.failureEvent);
+                if (published instanceof Promise)
+                    throw new Error('GraphDispatcher.dispatchSync requires synchronous publishEvent');
+                return { decision, receipts };
+            }
+            const payloads = receipt.payloads ?? {};
+            for (const eventId of step.emittedEvents) {
+                const definition = this.runtime.registry.events.get(eventId);
+                if (!(eventId in payloads))
+                    throw new Error(`action '${step.id}' did not supply payload for emitted event '${eventId}'`);
+                if (definition.validate && !definition.validate(payloads[eventId]))
+                    throw new Error(`invalid payload for emitted event '${eventId}'`);
+            }
+            for (const eventId of step.emittedEvents) {
+                const published = this.ports.publishEvent({ id: eventId, payload: payloads[eventId] });
+                if (published instanceof Promise)
+                    throw new Error('GraphDispatcher.dispatchSync requires synchronous publishEvent');
+            }
+        }
+        return { decision, receipts };
+    }
+    async dispatch(facts) {
+        const decision = await this.runtime.evaluate(facts);
+        if (!decision.accepted)
+            return { decision, receipts: [] };
+        await this.ports.persistTransition({ source: decision.source, target: decision.target });
+        const receipts = [];
+        for (const step of decision.actions) {
+            const action = this.runtime.registry.actions.get(step.id);
+            const context = { facts, actionId: step.id, input: step.input };
+            const receipt = this.ports.executeAction ? await this.ports.executeAction(step.id, context) : action.execute ? await action.execute(context) : {};
+            receipts.push(receipt);
+            if (receipt.ok === false) {
+                const definition = this.runtime.registry.events.get(receipt.failureEvent.id);
+                if (!definition)
+                    throw new Error(`unknown failure event '${receipt.failureEvent.id}'`);
+                if (definition.validate && !definition.validate(receipt.failureEvent.payload))
+                    throw new Error(`invalid payload for failure event '${receipt.failureEvent.id}'`);
+                await this.ports.publishEvent(receipt.failureEvent);
+                return { decision, receipts };
+            }
+            const payloads = receipt.payloads ?? {};
+            for (const eventId of step.emittedEvents) {
+                const definition = this.runtime.registry.events.get(eventId);
+                if (!(eventId in payloads))
+                    throw new Error(`action '${step.id}' did not supply payload for emitted event '${eventId}'`);
+                if (definition.validate && !definition.validate(payloads[eventId]))
+                    throw new Error(`invalid payload for emitted event '${eventId}'`);
+            }
+            for (const eventId of step.emittedEvents)
+                await this.ports.publishEvent({ id: eventId, payload: payloads[eventId] });
+        }
+        return { decision, receipts };
+    }
+}
+export const parseExecutableGraph = parseGraphV2;
+export const loadGraphV2 = (source, registries = {}) => new GraphRuntime(source, registries);

package/dist/workflow/job-reconcile-v2.js

@@ -0,0 +1,19 @@
+import { decideJobLifecycle, dispatchJobLifecycle } from './lifecycle.js';
+import { implementationComplete } from '../runtime-status.js';
+export function decideJobReconcile(job, facts) {
+    return decideJobLifecycle(job, 'reconcile', {
+        prOpen: facts.prState === 'OPEN',
+        reviewDisabled: job.reviewEnabled === false,
+        implementationComplete: implementationComplete(job),
+        autoMerge: job.autoMerge !== false,
+        headAvailable: Boolean(facts.headSha),
+        mergeCapable: facts.mergeCapable,
+    });
+}
+export async function dispatchJobReconcile(job, facts, executeEffect, persist) {
+    return dispatchJobLifecycle(job, 'reconcile', {
+        prOpen: facts.prState === 'OPEN', reviewDisabled: job.reviewEnabled === false,
+        implementationComplete: implementationComplete(job), autoMerge: job.autoMerge !== false,
+        headAvailable: Boolean(facts.headSha), mergeCapable: facts.mergeCapable,
+    }, executeEffect, persist);
+}

package/dist/workflow/lifecycle.js

@@ -1,8 +1,86 @@
-import { jobLifecycleWorkflow, taskLifecycleWorkflow } from './definitions.js';
-import { graphWorkflowDecision } from './runtime.js';
+import { classifyWorkflowActions, emptyWorkflowDecision } from './contracts.js';
+import { jobLifecycleV2, taskLifecycleV2 } from './definitions-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+import { applyJobGraphTarget, applyTaskGraphTarget, applyTaskMutation } from './runtime.js';
+function v2WorkflowDecision(runtime, from, event, facts = {}) {
+    const actions = [];
+    const decision = dispatchWorkflowGraphSync(runtime, {
+        initialState: from,
+        input: { transport: 'event', id: event, payload: {} },
+        durableFacts: facts,
+        executeAction: actionId => { actions.push(actionId); return {}; },
+    });
+    if (!decision.accepted)
+        return emptyWorkflowDecision(decision.reason === 'ambiguous' ? 'ambiguous' : 'no_transition');
+    const classified = classifyWorkflowActions(actions);
+    return {
+        accepted: true,
+        target: decision.target,
+        guard: null,
+        actions,
+        ...classified,
+        reason: 'accepted',
+    };
+}
 export function decideTaskLifecycle(task, event, facts = {}) {
-    return graphWorkflowDecision(taskLifecycleWorkflow, task.state, event, facts);
+    return v2WorkflowDecision(taskLifecycleV2, task.state, event, facts);
 }
 export function decideJobLifecycle(job, event, facts = {}) {
-    return graphWorkflowDecision(jobLifecycleWorkflow, job.state, event, facts);
+    return v2WorkflowDecision(jobLifecycleV2, job.state, event, facts);
+}
+export function dispatchTaskLifecycleSync(task, event, facts = {}) {
+    const actions = [];
+    const result = dispatchWorkflowGraphSync(taskLifecycleV2, {
+        initialState: task.state,
+        input: { transport: 'event', id: event, payload: {} },
+        durableFacts: facts,
+        persistTransition: (_source, target) => applyTaskGraphTarget(task, target),
+        executeAction: actionId => { actions.push(actionId); if (actionId.startsWith('mutation.'))
+            applyTaskMutation(task, actionId); return {}; },
+    });
+    if (!result.accepted)
+        return emptyWorkflowDecision(result.reason === 'ambiguous' ? 'ambiguous' : 'no_transition');
+    return { accepted: true, target: result.target, guard: null, actions, ...classifyWorkflowActions(actions), reason: 'accepted' };
+}
+export async function dispatchTaskLifecycle(task, event, facts = {}, executeEffect, persist) {
+    const actions = [];
+    const result = await dispatchWorkflowGraph(taskLifecycleV2, {
+        initialState: task.state, input: { transport: 'event', id: event, payload: {} }, durableFacts: facts,
+        persistTransition: async (_source, target) => { applyTaskGraphTarget(task, target); await persist?.(); },
+        executeAction: async (actionId) => {
+            actions.push(actionId);
+            if (actionId.startsWith('mutation.'))
+                applyTaskMutation(task, actionId);
+            else
+                await executeEffect?.(actionId);
+            return {};
+        },
+    });
+    if (!result.accepted)
+        return emptyWorkflowDecision(result.reason === 'ambiguous' ? 'ambiguous' : 'no_transition');
+    return { accepted: true, target: result.target, guard: null, actions, ...classifyWorkflowActions(actions), reason: 'accepted' };
+}
+export function dispatchJobLifecycleSync(job, event, facts = {}) {
+    const actions = [];
+    const result = dispatchWorkflowGraphSync(jobLifecycleV2, {
+        initialState: job.state,
+        input: { transport: 'event', id: event, payload: {} },
+        durableFacts: facts,
+        persistTransition: (_source, target) => applyJobGraphTarget(job, target),
+        executeAction: actionId => { actions.push(actionId); return {}; },
+    });
+    if (!result.accepted)
+        return emptyWorkflowDecision(result.reason === 'ambiguous' ? 'ambiguous' : 'no_transition');
+    return { accepted: true, target: result.target, guard: null, actions, ...classifyWorkflowActions(actions), reason: 'accepted' };
+}
+export async function dispatchJobLifecycle(job, event, facts = {}, executeEffect, persist) {
+    const actions = [];
+    const result = await dispatchWorkflowGraph(jobLifecycleV2, {
+        initialState: job.state, input: { transport: 'event', id: event, payload: {} }, durableFacts: facts,
+        persistTransition: async (_source, target) => { applyJobGraphTarget(job, target); await persist?.(); },
+        executeAction: async (actionId) => { actions.push(actionId); await executeEffect?.(actionId); return {}; },
+    });
+    if (!result.accepted)
+        return emptyWorkflowDecision(result.reason === 'ambiguous' ? 'ambiguous' : 'no_transition');
+    return { accepted: true, target: result.target, guard: null, actions, ...classifyWorkflowActions(actions), reason: 'accepted' };
 }

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

@@ -0,0 +1,58 @@
+import { readFileSync } from 'node:fs';
+import { GraphRuntime } from './graph-v2.js';
+import { dispatchWorkflowGraph, dispatchWorkflowGraphSync } from './dispatcher.js';
+import { isEffectivelyBlocked } from '../unblock.js';
+const source = readFileSync(new URL('../../workflow/planner-orchestration-v2.mmd', import.meta.url), 'utf8');
+const boolGuard = (name) => (facts) => facts.durableFacts[name] === true;
+export const plannerOrchestrationV2 = new GraphRuntime(source, {
+    states: new Set([
+        'idle', 'check_legacy_pending', 'check_recover', 'check_seed', 'check_planner',
+        'check_blocked', 'check_work', 'check_materialized', 'check_objective', 'wait', 'recovered', 'created',
+    ]),
+    guards: {
+        autonomousJob: boolGuard('autonomousJob'),
+        legacyPlanningPending: boolGuard('legacyPlanningPending'),
+        recoverablePendingPlan: boolGuard('recoverablePendingPlan'),
+        hasSeedWork: boolGuard('hasSeedWork'),
+        noActivePlanner: boolGuard('noActivePlanner'),
+        noBlockedWork: boolGuard('noBlockedWork'),
+        noActiveImplementation: boolGuard('noActiveImplementation'),
+        continuationMaterialized: boolGuard('continuationMaterialized'),
+        objectiveUnsatisfied: boolGuard('objectiveUnsatisfied'),
+    },
+    actions: {
+        'planner.recoverPending': { id: 'planner.recoverPending' },
+        'planner.createRound': { id: 'planner.createRound' },
+    },
+    events: { 'planner.reconcile': { id: 'planner.reconcile' } },
+});
+export async function dispatchPlannerOrchestration(facts, executeAction) {
+    return dispatchWorkflowGraph(plannerOrchestrationV2, { initialState: 'idle', input: { transport: 'event', id: 'planner.reconcile', payload: {} }, durableFacts: facts, isTransientState: state => state.startsWith('check_'), maxSteps: 9, executeAction });
+}
+export function decidePlannerOrchestration(facts) {
+    return dispatchWorkflowGraphSync(plannerOrchestrationV2, { initialState: 'idle', input: { transport: 'event', id: 'planner.reconcile', payload: {} }, durableFacts: facts, isTransientState: state => state.startsWith('check_'), maxSteps: 9 });
+}
+export function plannerOrchestrationFacts(job, recoverablePendingPlan) {
+    const slot = job.schedule?.currentRunSlot ? Date.parse(job.schedule.currentRunSlot) : Number.NaN;
+    const scopedTasks = Number.isFinite(slot) ? job.tasks.filter(task => Date.parse(task.createdAt) >= slot) : job.tasks;
+    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' && task.state === 'SUCCEEDED' && task.plannerResult)
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt) || a.id.localeCompare(b.id)).at(-1)
+        : undefined;
+    const latestId = latestPlan?.id ?? legacyLatest?.id;
+    const latestObjective = latestPlan?.objectiveStatus ?? legacyLatest?.plannerResult?.objective_status;
+    return {
+        autonomousJob: job.executionMode === 'autonomous',
+        legacyPlanningPending: job.initialPlanning?.status === 'pending',
+        recoverablePendingPlan,
+        hasSeedWork: !((job.plans?.length ?? 0) === 0 && job.tasks.filter(task => task.kind !== 'planner').length === 0),
+        noActivePlanner: !scopedPlans.some(plan => plan.status === 'PLANNING'),
+        noBlockedWork: !scopedTasks.some(task => task.kind !== 'planner' && isEffectivelyBlocked(task)),
+        noActiveImplementation: !scopedTasks.some(task => task.kind !== 'planner' && ['DRAFT', 'QUEUED', 'RUNNING'].includes(task.state)),
+        continuationMaterialized: !(latestObjective === 'in_progress' && latestId && !job.tasks.some(task => task.kind !== 'planner' && task.planningDecisionId === latestId)),
+        objectiveUnsatisfied: latestObjective !== 'satisfied',
+    };
+}