@atolis-hq/wake 0.3.19 → 0.3.21

package/dist/src/orchestration/application/advance-workflow.js

@@ -1,4 +1,3 @@
-import { ActivityEventType, PullRequestCheckState, selectActivityEvent, } from '../../activities/index.js';
 import { EventSourceKind, createEventDraft } from '../../kernel/index.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
@@ -6,6 +5,8 @@ import { workflowInstanceStream } from '../contracts/streams.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
 import { requestChangesResume as decideChangesResume, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
 import { isAuthorisedActor } from '../domain/supplemental-policy.js';
+import { acceptResourceTransition, matchResourceTransitions, } from './resource-transition-matching.js';
+import { matchWatches } from './watch-matching.js';
 export class OperatorRetryIneligibleError extends Error {
     constructor(detail) {
         super(detail);
@@ -182,6 +183,15 @@ export class AdvanceWorkflow {
     async listAll() {
         return (await this.listAllLoaded()).map(({ view }) => view);
     }
+    // Matching and application are generic (see resource-transition-matching.ts):
+    // this module holds no resource-kind knowledge.
+    async listResourceTransitionMatches(event) {
+        return matchResourceTransitions(await this.listAllLoaded(), event);
+    }
+    applyResourceTransition(id, target, evidenceId, context) {
+        const { repository, workflows } = this;
+        return acceptResourceTransition(repository, workflows, id, target, evidenceId, context);
+    }
     // One shared load per live instance, reused for both the watch match and
     // (when a match needs blocking) the append sequence — avoids reloading
     // every instance a second time just to recover its sequence.
@@ -189,26 +199,6 @@ export class AdvanceWorkflow {
         return (await this.repository.list()).filter((loaded) => loaded.view !== null);
     }
     async listWatchMatches(event, context) {
-        const matches = await Promise.all((await this.listAllLoaded()).map(async ({ view: parent, sequence }) => {
-            const definition = context === undefined
-                ? await this.workflows.definitionFor(parent)
-                : await this.workflows.definitionForOperation(parent, sequence, context);
-            if (definition === null)
-                return [];
-            return definition.watches
-                .filter((watch) => watch.on?.events.includes(event.eventType) === true &&
-                watch.while.stages.includes(parent.currentStage) &&
-                watch.while.statuses.some((status) => status === parent.status) &&
-                matchesWatchPredicate(watch.where, event))
-                .map((watch) => ({ parent, watch }));
-        }));
-        return matches.flat();
+        return matchWatches(await this.listAllLoaded(), event, this.workflows, context);
     }
 }
-function matchesWatchPredicate(predicate, event) {
-    if (predicate === undefined)
-        return true;
-    const activityEvent = selectActivityEvent(event);
-    return (activityEvent?.eventType === ActivityEventType.PrChecksChanged &&
-        activityEvent.payload.checks === PullRequestCheckState.Failing);
-}

package/dist/src/orchestration/application/orchestration-repository.js

@@ -25,10 +25,25 @@ export class OrchestrationRepository {
         return events.map(decodeOrchestrationEvent).filter(isWorkflowEvent);
     }
     async list() {
-        const ids = new Set((await this.journal.readAll(0))
-            .filter((event) => isWorkflowInstanceStream(event.stream))
-            .map((event) => event.stream.id));
-        return Promise.all([...ids].map((id) => this.load(id)));
+        const events = await this.journal.readAll(0);
+        const streams = new Map();
+        for (const event of events) {
+            if (!isWorkflowInstanceStream(event.stream))
+                continue;
+            const existing = streams.get(event.stream.id);
+            if (existing === undefined)
+                streams.set(event.stream.id, [event]);
+            else
+                existing.push(event);
+        }
+        // `sequence` counts every event on the stream, matching readStream, while the
+        // fold sees only owned orchestration events — exactly what load() computes.
+        return [...streams.values()].map((streamEvents) => ({
+            sequence: streamEvents.length,
+            view: foldWorkflowInstance(streamEvents
+                .map(selectWorkflowOrchestrationEvent)
+                .filter((event) => event !== null && isWorkflowInstanceStream(event.stream))),
+        }));
     }
 }
 function isWorkflowEvent(event) {

package/dist/src/orchestration/application/orchestration-service.js

@@ -13,12 +13,13 @@ export class OrchestrationService {
     acceptWorkflowSignal;
     advanceWorkflow;
     childWorkflows;
+    coordinateAcceptSignal = (operation) => operation();
     constructor(journal, work, definitions, projections) {
         const repository = new OrchestrationRepository(journal);
         const claims = new CoordinationClaims(journal);
         this.startWorkflow = new StartWorkflow(repository, claims, work, new WorkflowDefinitionRegistry(journal, projections, definitions));
-        this.acceptWorkflowSignal = new AcceptSignal(repository, this.startWorkflow, work);
         this.advanceWorkflow = new AdvanceWorkflow(repository, this.startWorkflow);
+        this.acceptWorkflowSignal = new AcceptSignal(repository, this.startWorkflow, work);
         this.childWorkflows = new RequestChild(repository, claims, new GroupBudgetRecorder(journal), this.startWorkflow, this.advanceWorkflow);
         this.acceptActivityOutcome = new AcceptActivityOutcome(repository, this.startWorkflow, (context) => this.childWorkflows.reconcileChildCompletions(context));
     }
@@ -38,7 +39,10 @@ export class OrchestrationService {
         return this.acceptWorkflowSignal.wait(workflowInstanceId, expectation, context);
     }
     acceptSignal(workflowInstanceId, signal, context) {
-        return this.acceptWorkflowSignal.execute(workflowInstanceId, signal, context);
+        return this.coordinateAcceptSignal(() => this.acceptWorkflowSignal.execute(workflowInstanceId, signal, context));
+    }
+    setAcceptSignalOperationCoordinator(coordinator) {
+        this.coordinateAcceptSignal = coordinator;
     }
     requestSupplementalActivity(workflowInstanceId, request, context) {
         return this.advanceWorkflow.requestSupplementalActivity(workflowInstanceId, request, context);
@@ -82,5 +86,11 @@ export class OrchestrationService {
     listWatchMatches(event, context) {
         return this.advanceWorkflow.listWatchMatches(event, context);
     }
+    listResourceTransitionMatches(event) {
+        return this.advanceWorkflow.listResourceTransitionMatches(event);
+    }
+    applyResourceTransition(workflowInstanceId, target, evidenceId, context) {
+        return this.advanceWorkflow.applyResourceTransition(workflowInstanceId, target, evidenceId, context);
+    }
 }
 export const createOrchestrationService = (journal, work, definitions, projections) => new OrchestrationService(journal, work, definitions, projections);

package/dist/src/orchestration/application/pull-request-transition-evidence.js

@@ -0,0 +1,70 @@
+import { ActivityEventType, ActivityResourceRole, decidePullRequestAuthority, PullRequestCheckState, PullRequestState, selectActivityEvent, selectPrimaryPullRequest, } from '../../activities/index.js';
+const triggers = [
+    ActivityEventType.PrReviewAccepted,
+    ActivityEventType.PrStateChanged,
+    ActivityEventType.PrChecksChanged,
+];
+export function createPullRequestTransitionEvidence(pullRequests) {
+    return {
+        triggers,
+        async resolve({ workItemId, transitions, fact, }) {
+            const input = await pullRequests.authorityInput(workItemId);
+            const selected = selectPrimaryPullRequest(input, workItemId);
+            if (selected === null)
+                return null;
+            const resourceId = selected.pullRequest.resourceId;
+            const candidates = fact === undefined ? await pullRequests.factsFor(resourceId) : scoped(fact, resourceId);
+            if (candidates.length === 0)
+                return null;
+            // Only pay for the authority decision when a review-accepted
+            // transition is actually in play; it doesn't vary per candidate, so
+            // it's computed once here rather than inside the matcher. Built from
+            // the `input` snapshot already read above (not re-read via the
+            // service) so the primary-resource selection and the authority
+            // decision can't observe different journal states.
+            const authorized = transitions.some((transition) => transition.event === ActivityEventType.PrReviewAccepted)
+                ? decidePullRequestAuthority(input, {
+                    target: ActivityResourceRole.Primary,
+                    requireAcceptedReview: true,
+                    requireChecks: false,
+                }).allowed
+                : false;
+            return firstMatch(candidates, transitions, selected.pullRequest, authorized);
+        },
+    };
+}
+// A live fact carries its own resource stream; a fact about another work
+// item's resource is not evidence for this instance's transitions.
+function scoped(fact, resourceId) {
+    const activity = selectActivityEvent(fact);
+    return activity !== null && activity.stream.id === resourceId ? [activity] : [];
+}
+function firstMatch(candidates, transitions, pullRequest, authorized) {
+    for (const candidate of candidates) {
+        const transition = transitions.find((entry) => matchesPrimaryPullRequestTransition(entry, candidate, pullRequest, authorized));
+        if (transition !== undefined)
+            return { transition, evidenceId: candidate.eventId };
+    }
+    return null;
+}
+// The closed V1 event union is intentionally matched exhaustively here.
+// eslint-disable-next-line complexity
+function matchesPrimaryPullRequestTransition(transition, event, pullRequest, authorized) {
+    if (transition.event !== event.eventType)
+        return false;
+    if (event.eventType === ActivityEventType.PrReviewAccepted)
+        return event.payload.revision === pullRequest.headRevision && authorized;
+    if (event.eventType === ActivityEventType.PrStateChanged)
+        return (transition.where !== undefined &&
+            'state' in transition.where &&
+            transition.where.state === event.payload.state &&
+            event.payload.state === PullRequestState.Merged &&
+            pullRequest.state === PullRequestState.Merged);
+    if (event.eventType !== ActivityEventType.PrChecksChanged)
+        return false;
+    return (transition.where !== undefined &&
+        'checks' in transition.where &&
+        transition.where.checks === event.payload.checks &&
+        event.payload.checks === PullRequestCheckState.Failing &&
+        pullRequest.checks === PullRequestCheckState.Failing);
+}

package/dist/src/orchestration/application/resource-transition-evidence.js

@@ -0,0 +1 @@
+export {};

package/dist/src/orchestration/application/resource-transition-matching.js

@@ -0,0 +1,83 @@
+import { OrchestrationEventType } from '../contracts/events.js';
+import { isWorkflowInstanceStream } from '../contracts/streams.js';
+import { WorkflowStatus } from '../contracts/vocabulary.js';
+import { acceptSignal as decideSignal } from '../domain/interpreter.js';
+// Generic: no resource-kind knowledge lives here. A `signal-wait-started`
+// trigger on the instance's own stream returns every declared transition
+// unfiltered, so the reactor's evidence policy can check prior journal
+// history for a fact that arrived before the wait began. Any other event
+// is matched against each instance's declared predicates directly.
+export function matchResourceTransitions(loaded, event) {
+    const waitStart = event.eventType === OrchestrationEventType.SignalWaitStarted &&
+        isWorkflowInstanceStream(event.stream)
+        ? event.stream.id
+        : undefined;
+    return loaded.flatMap(({ view }) => {
+        if (view.status !== WorkflowStatus.Waiting)
+            return [];
+        const declared = view.waitingFor?.resourceTransitions;
+        if (declared === undefined)
+            return [];
+        if (waitStart !== undefined)
+            return view.workflowInstanceId === waitStart
+                ? [
+                    {
+                        workflowInstanceId: view.workflowInstanceId,
+                        workItemId: view.workItemId,
+                        transitions: declared,
+                    },
+                ]
+                : [];
+        const transitions = declared.filter((transition) => matchesFact(transition, event));
+        return transitions.length === 0
+            ? []
+            : [{ workflowInstanceId: view.workflowInstanceId, workItemId: view.workItemId, transitions }];
+    });
+}
+// Compares the declared predicate key-wise against the event payload.
+function matchesFact(transition, event) {
+    if (transition.event !== event.eventType)
+        return false;
+    if (transition.where === undefined)
+        return true;
+    const payload = event.payload;
+    return Object.entries(transition.where).every(([key, value]) => payload[key] === value);
+}
+// Applies a transition the reactor's evidence policy already confirmed. The
+// route target comes from the matched transition, not the wait's own
+// resume, so the decision is taken against the transition's destination.
+// Once applied the instance leaves Waiting, so a repeated call with the
+// same evidence is a no-op — there is no separate consumed-fact guard.
+export async function acceptResourceTransition(repository, workflows, id, target, evidenceId, context) {
+    const loaded = await repository.load(id);
+    if (loaded.view === null || loaded.view.waitingFor === undefined)
+        return loaded.view;
+    const definition = await workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+    if (definition === null)
+        return loaded.view;
+    const decision = decideSignal(definition, { ...loaded.view, waitingFor: { ...loaded.view.waitingFor, resume: target } }, {
+        signal: {
+            kind: loaded.view.waitingFor.signalKind,
+            actorId: 'resource-transition',
+            actorDecision: { authorized: true, evidenceId },
+            providerEventId: evidenceId,
+        },
+        occurredAt: context.occurredAt,
+        causationId: `${context.commandId}:${evidenceId}`,
+        consent: true,
+    });
+    if (decision.kind === 'append') {
+        try {
+            await repository.append(id, loaded.sequence, decision.events);
+        }
+        catch (error) {
+            const reloaded = await repository.load(id);
+            if (reloaded.view !== null &&
+                (reloaded.view.acceptedSignalIds.includes(evidenceId) ||
+                    reloaded.view.waitingFor === undefined))
+                return reloaded.view;
+            throw error;
+        }
+    }
+    return (await repository.load(id)).view;
+}

package/dist/src/orchestration/application/resource-transition-reactor.js

@@ -0,0 +1,65 @@
+import { correlationId, EventActorKind, } from '../../kernel/index.js';
+import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+const checkpoint = 'reactor:orchestration.resource-transition';
+const batchSize = 100;
+export function createResourceTransitionReactor(orchestration, evidence, journal, checkpoints) {
+    let queue = Promise.resolve();
+    const react = async (event, context) => {
+        const orchestrationEvent = selectOrchestrationEvent(event);
+        const isWaitStart = orchestrationEvent?.eventType === OrchestrationEventType.SignalWaitStarted;
+        if (!isWaitStart && !evidence.triggers.includes(event.eventType))
+            return;
+        const fact = isWaitStart ? undefined : event;
+        for (const match of await orchestration.listResourceTransitionMatches(event)) {
+            const resolved = await evidence.resolve({
+                workItemId: match.workItemId,
+                transitions: match.transitions,
+                ...(fact === undefined ? {} : { fact }),
+            });
+            if (resolved === null)
+                continue;
+            await orchestration.applyResourceTransition(match.workflowInstanceId, resolved.transition.target, resolved.evidenceId, context);
+        }
+    };
+    const runBatch = async (limit = batchSize) => {
+        if (journal === undefined || checkpoints === undefined)
+            throw new Error('ResourceTransitionReactor journal and checkpoints are required to run');
+        const events = await journal.readAll(await checkpoints.load(checkpoint), limit);
+        for (const event of events) {
+            await react(event, commandContext(event));
+            await checkpoints.save(checkpoint, event.globalPosition);
+        }
+        return events.length;
+    };
+    const serialize = (operation) => {
+        const result = queue.then(operation);
+        queue = result.catch(() => { });
+        return result;
+    };
+    return {
+        react,
+        runOnce(limit = batchSize) {
+            return serialize(() => runBatch(limit));
+        },
+        drain() {
+            return serialize(async () => {
+                let total = 0;
+                let processed;
+                do {
+                    processed = await runBatch();
+                    total += processed;
+                } while (processed === batchSize);
+                return total;
+            });
+        },
+    };
+}
+function commandContext(event) {
+    return {
+        commandId: `${event.eventId}:resource-transition`,
+        correlationId: correlationId(event.correlationId),
+        occurredAt: event.occurredAt,
+        actor: { kind: EventActorKind.System, id: 'resource-transition-reactor' },
+    };
+}

package/dist/src/orchestration/application/watch-matching.js

@@ -0,0 +1,27 @@
+import { ActivityEventType, PullRequestCheckState, selectActivityEvent, } from '../../activities/index.js';
+// Loads a definition per instance (operation-scoped when a command context is
+// given, read-only otherwise) and returns every watch whose event, stage,
+// status, and predicate all agree with the incoming event.
+export async function matchWatches(loaded, event, workflows, context) {
+    const matches = await Promise.all(loaded.map(async ({ view: parent, sequence }) => {
+        const definition = context === undefined
+            ? await workflows.definitionFor(parent)
+            : await workflows.definitionForOperation(parent, sequence, context);
+        if (definition === null)
+            return [];
+        return definition.watches
+            .filter((watch) => watch.on?.events.includes(event.eventType) === true &&
+            watch.while.stages.includes(parent.currentStage) &&
+            watch.while.statuses.some((status) => status === parent.status) &&
+            matchesWatchPredicate(watch.where, event))
+            .map((watch) => ({ parent, watch }));
+    }));
+    return matches.flat();
+}
+function matchesWatchPredicate(predicate, event) {
+    if (predicate === undefined)
+        return true;
+    const activityEvent = selectActivityEvent(event);
+    return (activityEvent?.eventType === ActivityEventType.PrChecksChanged &&
+        activityEvent.payload.checks === PullRequestCheckState.Failing);
+}

package/dist/src/orchestration/contracts/config.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { ApprovalAuthorityKind, WorkflowStatus } from './vocabulary.js';
-import { PullRequestCheckState } from '../../activities/index.js';
+import { ActivityEventType, PullRequestCheckState, PullRequestState, } from '../../activities/index.js';
 import { WorkspaceMode } from '../../execution/index.js';
 import { MatchMode } from '../../kernel/index.js';
 const identifier = z.string().trim().min(1);
@@ -31,6 +31,28 @@ const watchGateConfigSchema = z.union([
     })
         .strict(),
 ]);
+const resourceTransitionConfigSchema = z.union([
+    z
+        .object({
+        events: z.tuple([z.literal(ActivityEventType.PrReviewAccepted)]),
+        then: identifier.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        events: z.tuple([z.literal(ActivityEventType.PrStateChanged)]),
+        where: z.object({ state: z.literal(PullRequestState.Merged) }).strict(),
+        then: identifier.optional(),
+    })
+        .strict(),
+    z
+        .object({
+        events: z.tuple([z.literal(ActivityEventType.PrChecksChanged)]),
+        where: z.object({ checks: z.literal(PullRequestCheckState.Failing) }).strict(),
+        then: identifier.optional(),
+    })
+        .strict(),
+]);
 const commandName = z.string().regex(/^\/[a-z][a-z0-9-]*$/);
 const canonicalEventName = z.string().regex(/^[a-z][a-z0-9-]*(\.[a-z][a-z0-9-]*)+$/);
 const watchStatus = z.enum([WorkflowStatus.Active, WorkflowStatus.Waiting, WorkflowStatus.Blocked]);
@@ -73,6 +95,7 @@ export const outcomeRouteConfigSchema = z
     retry: bound.optional(),
     await: awaitConfigSchema.optional(),
     watchGates: z.array(watchGateConfigSchema).optional(),
+    resourceTransitions: z.array(resourceTransitionConfigSchema).min(1).optional(),
 })
     .strict();
 export const stageConfigSchema = z

package/dist/src/orchestration/contracts/event-decoder.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { activationId, activityName, ActivityOutcomeKind } from '../../activities/index.js';
+import { activationId, ActivityEventType, activityName, ActivityOutcomeKind, PullRequestCheckState, PullRequestState, } from '../../activities/index.js';
 import { WorkspaceMode } from '../../execution/index.js';
 import { brandedStringSchema, eventEnvelopeSchema, } from '../../kernel/index.js';
 import { workItemId } from '../../work/index.js';
@@ -99,6 +99,22 @@ const transitionTargetSchema = z.discriminatedUnion('kind', [
     })
         .strict(),
 ]);
+const resourceTransitionSchema = z
+    .object({
+    event: z.enum([
+        ActivityEventType.PrReviewAccepted,
+        ActivityEventType.PrStateChanged,
+        ActivityEventType.PrChecksChanged,
+    ]),
+    where: z
+        .union([
+        z.object({ state: z.literal(PullRequestState.Merged) }).strict(),
+        z.object({ checks: z.literal(PullRequestCheckState.Failing) }).strict(),
+    ])
+        .optional(),
+    target: transitionTargetSchema,
+})
+    .strict();
 export const expectationSchema = z
     .object({
     signalKind: brandedStringSchema(signalName),
@@ -107,6 +123,7 @@ export const expectationSchema = z
     from: z.array(approvalAuthoritySchema).min(1).optional(),
     resume: transitionTargetSchema.optional(),
     onRejectResume: transitionTargetSchema.optional(),
+    resourceTransitions: z.array(resourceTransitionSchema).min(1).optional(),
 })
     .strict();
 export const signalSchema = z

package/dist/src/orchestration/contracts/events.js

@@ -29,6 +29,7 @@ export const OrchestrationEventType = {
 };
 export const WatchGateVerdictSignal = signalName('orchestration.watch-gate-verdict');
 export const ApprovedSignal = signalName('approved');
+export const ResourceTransitionSignal = signalName('orchestration.resource-transition');
 /**
  * Every consumer that needs to know whether a wait renders as "awaiting
  * approval" externally (GitHub labels, the operator board, the agent-run

package/dist/src/orchestration/domain/approval-defaults.js

@@ -11,6 +11,7 @@ export function defaultApprovalAwait(stage, outcomeKind, route) {
         return route.await;
     if (outcomeKind !== ActivityOutcomeKind.Done ||
         route.watchGates !== undefined ||
+        route.resourceTransitions !== undefined ||
         stage.requiresApproval === false)
         return undefined;
     return { signal: 'approved', from: [ApprovalAuthorityKind.Human] };

package/dist/src/orchestration/domain/compiler.js

@@ -3,6 +3,7 @@ import { workflowDefinitionConfigSchema, } from '../contracts/config.js';
 import { commandName, signalName, stageName, watchId, workflowName, } from '../contracts/identifiers.js';
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
 import { defaultApprovalAwait } from './approval-defaults.js';
+import { compileResourceTransitions } from './resource-transition-compiler.js';
 import { assertCyclesBounded, assertReachable } from './workflow-graph.js';
 export function compileWorkflow(name, input, activities, knownWorkflowNames = [name]) {
     const compiledName = workflowName(name);
@@ -72,16 +73,23 @@ function compileStages(compiledWorkflowName, configured, activities, declaredWat
         compileStage(context, stageName, stage, configured),
     ]));
 }
+// The stage compiler keeps route validation and compilation together.
+// eslint-disable-next-line max-lines-per-function
 function compileStage(context, rawStageName, stage, allStages) {
     const { workflowName: compiledWorkflowName, activities, declaredWatchIds } = context;
     const definition = activities.describe(activityName(stage.activity));
-    const on = Object.fromEntries(Object.entries(stage.on).map(([outcomeKind, route]) => {
+    const on = Object.fromEntries(Object.entries(stage.on).map(
+    // The route schema is deliberately closed and validated in one compiler pass.
+    // eslint-disable-next-line complexity
+    ([outcomeKind, route]) => {
         if (!definition.outcomeKinds.includes(outcomeKind))
             throw new Error(`Workflow outcome route ${outcomeKind} is not declared by Activity ${definition.name}`);
         if (!isReservedTerminal(route.then) && !(route.then in allStages))
             throw new Error(`Unknown transition target: ${route.then}`);
         if (route.await !== undefined && route.watchGates !== undefined)
             throw new Error(`Route ${compiledWorkflowName}:${rawStageName}:${outcomeKind} cannot configure both await and watchGates`);
+        if (route.resourceTransitions !== undefined && outcomeKind !== ActivityOutcomeKind.Done)
+            throw new Error(`Route ${compiledWorkflowName}:${rawStageName}:${outcomeKind} resourceTransitions are only valid on done`);
         const followOns = route.activities?.map((activity) => ({
             use: activityName(activity.use),
             with: activities.validateInput(activityName(activity.use), activity.with),
@@ -103,6 +111,11 @@ function compileStage(context, rawStageName, stage, allStages) {
                 : {
                     watchGates: compileWatchGates(compiledWorkflowName, rawStageName, outcomeKind, route.watchGates, declaredWatchIds, allStages),
                 }),
+            ...(route.resourceTransitions === undefined
+                ? {}
+                : {
+                    resourceTransitions: compileResourceTransitions(route.resourceTransitions, route.then, outcomeKind, allStages, isReservedTerminal, compileTarget),
+                }),
             id: `${compiledWorkflowName}:${rawStageName}:${outcomeKind}`,
         });
         return [outcomeKind, compiled];

package/dist/src/orchestration/domain/resource-transition-compiler.js

@@ -0,0 +1,12 @@
+export function compileResourceTransitions(entries, inheritedThen, outcomeKind, allStages, isReservedTerminal, compileTarget) {
+    return Object.freeze(entries.map((entry) => {
+        const then = entry.then ?? inheritedThen;
+        if (!isReservedTerminal(then) && !(then in allStages))
+            throw new Error(`Unknown resourceTransitions target: ${then}`);
+        return Object.freeze({
+            event: entry.events[0],
+            ...(!('where' in entry) || entry.where === undefined ? {} : { where: entry.where }),
+            target: compileTarget(then, outcomeKind),
+        });
+    }));
+}

package/dist/src/orchestration/domain/transition.js

@@ -1,17 +1,26 @@
-import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/events.js';
+import { OrchestrationEventType, ResourceTransitionSignal, WatchGateVerdictSignal, } from '../contracts/events.js';
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+// Route completion combines the mutually exclusive wait, await, and target policies.
+// eslint-disable-next-line complexity
 export function finishRoute(events, definition, state, input, route) {
-    if (route.watchGates !== undefined) {
-        const gate = route.watchGates[0];
+    if (route.watchGates !== undefined || route.resourceTransitions !== undefined) {
+        const gate = route.watchGates?.[0];
         events.push(stateDraft(state, input, OrchestrationEventType.SignalWaitStarted, {
-            signalKind: WatchGateVerdictSignal,
-            from: Object.freeze([
-                { kind: ApprovalAuthorityKind.Watch, watch: gate.watch },
-                { kind: ApprovalAuthorityKind.Human },
-            ]),
+            signalKind: gate === undefined ? ResourceTransitionSignal : WatchGateVerdictSignal,
+            ...(gate === undefined
+                ? {}
+                : {
+                    from: Object.freeze([
+                        { kind: ApprovalAuthorityKind.Watch, watch: gate.watch },
+                        { kind: ApprovalAuthorityKind.Human },
+                    ]),
+                }),
             resume: route.target,
-            onRejectResume: gate.onRejectTarget,
+            ...(gate === undefined ? {} : { onRejectResume: gate.onRejectTarget }),
+            ...(route.resourceTransitions === undefined
+                ? {}
+                : { resourceTransitions: route.resourceTransitions }),
         }, events.length + 1));
         return;
     }

package/dist/src/orchestration/domain/workflow-graph.js

@@ -1,7 +1,11 @@
 import { stageName } from '../contracts/identifiers.js';
 import { TransitionTargetKind } from '../contracts/vocabulary.js';
 function edges(stages, name) {
-    return Object.values(stages[name].on).flatMap((route) => route.target.kind === TransitionTargetKind.Stage ? [route.target.stage] : []);
+    return Object.values(stages[name].on).flatMap((route) => [
+        route.target,
+        ...(route.watchGates ?? []).map((gate) => gate.onRejectTarget),
+        ...(route.resourceTransitions ?? []).map((transition) => transition.target),
+    ].flatMap((target) => (target.kind === TransitionTargetKind.Stage ? [target.stage] : [])));
 }
 export function assertReachable(entry, stages) {
     const reached = new Set();

package/dist/src/orchestration/domain/workflow-instance-events.js

@@ -178,6 +178,9 @@ function applySignalWaitStarted(state, event) {
         ...(event.payload.onRejectResume === undefined
             ? {}
             : { onRejectResume: event.payload.onRejectResume }),
+        ...(event.payload.resourceTransitions === undefined
+            ? {}
+            : { resourceTransitions: event.payload.resourceTransitions }),
     };
 }
 function updateActivationStatus(state, activationId, status) {

package/dist/src/orchestration/index.js

@@ -2,6 +2,10 @@ export * from './application/orchestration-projection.js';
 export * from './application/orchestration-repository.js';
 export * from './application/orchestration-service.js';
 export * from './application/advance-workflow.js';
+export * from './application/pull-request-transition-evidence.js';
+export * from './application/resource-transition-evidence.js';
+export * from './application/resource-transition-matching.js';
+export * from './application/resource-transition-reactor.js';
 export * from './application/signal-reactor.js';
 export * from './application/watch-reactor.js';
 export * from './application/workflow-definition-registry.js';