@atolis-hq/wake 0.3.5 → 0.3.7

package/dist/src/activities/agent/agent-activity.js

@@ -97,6 +97,7 @@ async function buildUntrustedContext(workItemId, contextReader) {
         issueTitle: context.title,
         issueBody: context.body,
         comments: context.comments,
+        ...(context.pullRequest === undefined ? {} : { pullRequest: context.pullRequest }),
     };
 }
 function untrustedDataBlock(context) {
@@ -108,6 +109,7 @@ function untrustedDataBlock(context) {
         escapeUntrustedJson(JSON.stringify({
             issue: { title: context.issueTitle, body: context.issueBody },
             comments: context.comments,
+            ...(context.pullRequest === undefined ? {} : { pullRequest: context.pullRequest }),
         }, null, 2)),
         '</wake-untrusted-data>',
     ].join('\n');

package/dist/src/bootstrap/composition-root.js

@@ -46,7 +46,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         name,
         compileWorkflow(name, definition, activities, Object.keys(config.orchestration.workflows)),
     ]));
-    const orchestration = createOrchestrationService(journal, work, definitions);
+    const orchestration = createOrchestrationService(journal, work, definitions, projections);
     const workspaces = new GitWorkspaceProvider(paths.workspacesRoot, {
         async cloneLocator(id) {
             const resource = await resources.get(resourceId(id));

package/dist/src/bootstrap/projection-runtime.js

@@ -2,7 +2,7 @@ import { activityProjectionDefinitions } from '../activities/index.js';
 import { controlPlaneProjectionDefinitions } from '../control-plane/index.js';
 import { executionProjection } from '../execution/index.js';
 import { deliveryProjectionDefinitions } from '../integrations/index.js';
-import { orchestrationProjection } from '../orchestration/index.js';
+import { orchestrationProjection, workflowDefinitionsProjection } from '../orchestration/index.js';
 import { ProjectionRunner } from '../persistence/index.js';
 import { resourceCorrelationProjection, resourceProjection, resourcesByExternalKeyProjection, workCorrelationsProjection, } from '../resources/index.js';
 import { workProjection } from '../work/index.js';
@@ -18,6 +18,7 @@ export const runtimeProjectionDefinitions = [
     ...deliveryProjectionDefinitions,
     ...controlPlaneProjectionDefinitions,
     orchestrationProjection,
+    workflowDefinitionsProjection,
     executionProjection,
     boardProjection,
     analyticsProjection,

package/dist/src/bootstrap/version.js

@@ -108,4 +108,4 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "ga20cb24";
+export const wakeVersion = "g3a1ec02";

package/dist/src/integrations/github/application/agent-context-reader.js

@@ -1,6 +1,8 @@
-import { ResourceCorrelationRole } from '../../../resources/index.js';
+import { PullRequestCheckState, } from '../../../activities/index.js';
+import { BuiltInResourceKind, ResourceCorrelationRole, } from '../../../resources/index.js';
 import { adapterId } from '../../contracts/identifiers.js';
 import { integrationStream } from '../../contracts/streams.js';
+import { boundedDiagnosticEvidence } from '../contracts/check-evidence.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
 import { createCommentHistoryReader } from './comment-history-reader.js';
 export function createGitHubAgentContextReader(journal, resources) {
@@ -11,6 +13,7 @@ export function createGitHubAgentContextReader(journal, resources) {
             return {
                 ...(await currentWorkItemContent(journal, resources, workItemId)),
                 comments,
+                ...pullRequestContextField(await currentPullRequestContext(journal, resources, workItemId)),
             };
         },
     };
@@ -28,6 +31,38 @@ async function currentWorkItemContent(journal, resources, workItemId) {
     return latestWorkObservedContent(await journal.readStream(integrationStream(adapter)), adapter, resource.externalKey.key);
 }
 const emptyWorkItemContent = { title: '', body: '' };
+async function currentPullRequestContext(journal, resources, workItemId) {
+    let current;
+    for (const correlation of await resources.correlationsForWork(workItemId)) {
+        const resource = await resources.get(correlation.resourceId);
+        if (resource?.kind !== BuiltInResourceKind.PullRequest)
+            continue;
+        const adapter = parseAdapterId(resource.externalKey.adapter);
+        if (adapter === null)
+            continue;
+        for (const event of await journal.readStream(integrationStream(adapter))) {
+            const observed = selectGitHubAdapterEvent(event);
+            if (!isCurrentPullRequestObservedEvent(observed, adapter, resource.externalKey.key))
+                continue;
+            if (current === undefined || event.globalPosition > current.position)
+                current = { context: pullRequestContext(observed.payload), position: event.globalPosition };
+        }
+    }
+    return current?.context;
+}
+function pullRequestContext(payload) {
+    return {
+        checks: payload.checks ?? PullRequestCheckState.Unknown,
+        checkRuns: rawEvidenceList(payload.raw.checkRuns),
+        statuses: rawEvidenceList(payload.raw.statuses),
+    };
+}
+function rawEvidenceList(value) {
+    return Array.isArray(value) ? boundedDiagnosticEvidence(value) : [];
+}
+function pullRequestContextField(context) {
+    return context === undefined ? {} : { pullRequest: context };
+}
 function latestWorkObservedContent(events, adapter, externalKey) {
     let current;
     for (const event of events) {
@@ -44,6 +79,10 @@ function isCurrentWorkObservedEvent(observed, adapter, externalKey) {
         observed.source.id === adapter &&
         observed.payload.externalKey === externalKey);
 }
+function isCurrentPullRequestObservedEvent(observed, adapter, externalKey) {
+    return (isCurrentWorkObservedEvent(observed, adapter, externalKey) &&
+        observed.payload.kind === 'pull-request');
+}
 function parseAdapterId(value) {
     try {
         return adapterId(value);

package/dist/src/integrations/github/application/inbound-translator.js

@@ -138,6 +138,7 @@ export class InboundTranslator {
                     BuiltInResourceCapability.Commentable,
                     BuiltInResourceCapability.Reviewable,
                     BuiltInResourceCapability.Revisioned,
+                    BuiltInResourceCapability.ChangedFiles,
                 ]
                 : [BuiltInResourceCapability.Commentable],
             objective: payload.title,

package/dist/src/integrations/github/application/pull-request-translation.js

@@ -6,5 +6,6 @@ export function observePullRequest(resourceId, workItemId, payload) {
         headRevision: payload.headRevision ?? payload.revision,
         baseRevision: payload.baseRevision ?? 'unknown',
         checks: payload.checks ?? 'unknown',
+        ...(payload.changedFiles === undefined ? {} : { changedFiles: payload.changedFiles }),
     };
 }

package/dist/src/integrations/github/contracts/check-evidence.js

@@ -0,0 +1,37 @@
+const diagnosticKeys = [
+    'name',
+    'status',
+    'conclusion',
+    'started_at',
+    'completed_at',
+    'details_url',
+    'html_url',
+    'context',
+    'state',
+    'target_url',
+];
+const maxEvidenceEntries = 20;
+const maxEvidenceBytes = 12_000;
+export function boundedDiagnosticEvidence(evidence) {
+    const bounded = [];
+    let bytes = 0;
+    for (const value of evidence) {
+        if (bounded.length === maxEvidenceEntries)
+            break;
+        if (!isRecord(value))
+            continue;
+        const diagnostic = diagnosticEvidence(value);
+        const entryBytes = Buffer.byteLength(JSON.stringify(diagnostic), 'utf8');
+        if (bytes + entryBytes > maxEvidenceBytes)
+            break;
+        bounded.push(diagnostic);
+        bytes += entryBytes;
+    }
+    return bounded;
+}
+function diagnosticEvidence(entry) {
+    return Object.fromEntries(diagnosticKeys.flatMap((key) => typeof entry[key] === 'string' || entry[key] === null ? [[key, entry[key]]] : []));
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/src/integrations/github/contracts/events.js

@@ -67,6 +67,7 @@ const eventSchema = z.discriminatedUnion('eventType', [
             actor: actorSchema,
             labels: z.array(z.string()).readonly().optional(),
             assignees: z.array(z.string()).readonly().optional(),
+            changedFiles: z.array(z.string()).readonly().optional(),
             raw: rawSchema,
         })
             .strict(),

package/dist/src/integrations/github/infrastructure/client-reads.js

@@ -89,6 +89,20 @@ export async function listReviewComments(octokit, cache, owner, repo, pullNumber
         ...(comment.side === undefined ? {} : { side: comment.side }),
     }));
 }
+export async function listPullRequestFiles(octokit, cache, owner, repo, pullNumber) {
+    const files = await fetchPaginatedWithEtag({
+        cache,
+        key: `pull-files:${owner}/${repo}#${pullNumber}`,
+        pages: (headers) => octokit.paginate.iterator(octokit.rest.pulls.listFiles, {
+            owner,
+            repo,
+            pull_number: pullNumber,
+            per_page: 100,
+            ...(headers === undefined ? {} : { headers }),
+        }),
+    });
+    return files.map((file) => file.filename);
+}
 export function listCheckRunsForRef(octokit, cache, owner, repo, ref) {
     return fetchPaginatedWithEtag({
         cache,

package/dist/src/integrations/github/infrastructure/client.js

@@ -1,7 +1,7 @@
 import { Octokit } from '@octokit/rest';
 import { MergeMethod } from '../../../activities/index.js';
 import { GitHubOutboundAction } from '../contracts/vocabulary.js';
-import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
+import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
 import { createEtagCache } from './etag-cache.js';
 // Octokit's request-log plugin reports every non-2xx response through this
 // callback, including the expected 304 responses produced by conditional ETag
@@ -50,6 +50,7 @@ export function createGitHubClient(token) {
         getPullRequest: (owner, repo, pullNumber) => getPullRequest(octokit, cache, owner, repo, pullNumber),
         listReviews: (owner, repo, pullNumber, pageSize) => listReviews(octokit, cache, owner, repo, pullNumber, pageSize),
         listCheckRunsForRef: (owner, repo, ref) => listCheckRunsForRef(octokit, cache, owner, repo, ref),
+        listPullRequestFiles: (owner, repo, pullNumber) => listPullRequestFiles(octokit, cache, owner, repo, pullNumber),
         getCombinedStatusForRef: (owner, repo, ref) => getCombinedStatusForRef(octokit, cache, owner, repo, ref),
         branch: (owner, repo, name) => branch(octokit, cache, owner, repo, name),
         deliver: (command) => deliver(octokit, command),

package/dist/src/integrations/github/infrastructure/pr-source.js

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { PullRequestCheckState, PullRequestState, ReviewActorKind, } from '../../../activities/index.js';
 import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
 import { integrationStream } from '../../contracts/streams.js';
+import { boundedDiagnosticEvidence } from '../contracts/check-evidence.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { formatGitHubResourceKey } from '../contracts/external-key.js';
 import { gitHubAssigneeLogins, gitHubLabelNames, } from '../contracts/payloads.js';
@@ -16,11 +17,15 @@ export function createGitHubPullRequestSource(input) {
             return mapConcurrent(pullRequests, input.maxConcurrency ?? 4, async (pullRequest) => {
                 signal.throwIfAborted();
                 const headRevision = fallback(pullRequest.head?.sha, pullRequest.updated_at);
-                const evidence = await readCheckEvidence(input.client, owner, repo, headRevision);
+                const [evidence, changedFiles] = await Promise.all([
+                    readCheckEvidence(input.client, owner, repo, headRevision),
+                    readChangedFiles(input.client, owner, repo, pullRequest.number),
+                ]);
                 return pullRequestObservation({
                     repository: input.repository,
                     pullRequest,
                     evidence,
+                    changedFiles,
                     ...(input.adapter === undefined ? {} : { adapter: input.adapter }),
                 });
             });
@@ -53,7 +58,12 @@ function pullRequestObservation(input) {
         },
         labels: gitHubLabelNames(pullRequest),
         assignees: gitHubAssigneeLogins(pullRequest),
-        raw: { number: pullRequest.number },
+        ...(input.changedFiles === undefined ? {} : { changedFiles: input.changedFiles }),
+        raw: {
+            number: pullRequest.number,
+            checkRuns: boundedDiagnosticEvidence(input.evidence.checkRuns),
+            statuses: boundedDiagnosticEvidence(input.evidence.statuses),
+        },
     };
     const fingerprint = evidenceFingerprint(payload, input.evidence);
     return createEventDraft({
@@ -93,6 +103,14 @@ async function readCheckEvidence(client, owner, repo, headRevision) {
         return { available: false, checkRuns: [], statuses: [] };
     }
 }
+async function readChangedFiles(client, owner, repo, pullNumber) {
+    try {
+        return await client.listPullRequestFiles(owner, repo, pullNumber);
+    }
+    catch {
+        return undefined;
+    }
+}
 async function mapConcurrent(values, concurrency, transform) {
     const output = new Array(values.length);
     let nextIndex = 0;

package/dist/src/integrations/github/provider.js

@@ -54,6 +54,7 @@ export const gitHubProviderDefinition = {
                             BuiltInResourceCapability.Approvable,
                             BuiltInResourceCapability.Mergeable,
                             BuiltInResourceCapability.Revisioned,
+                            BuiltInResourceCapability.ChangedFiles,
                         ],
                         ...(pullRequest.head.sha === undefined ? {} : { revision: pullRequest.head.sha }),
                     };

package/dist/src/orchestration/application/accept-activity-outcome.js

@@ -11,14 +11,17 @@ export class AcceptActivityOutcome {
     }
     async execute(command, context) {
         const loaded = await this.repository.loadRequired(command.workflowInstanceId);
-        const decision = decideActivityOutcome(this.workflows.definition(loaded.view.workflowName), loaded.view, {
-            ...command,
-            outcome: orchestrationActivityOutcome(command.outcome),
-            occurredAt: context.occurredAt,
-            causationId: context.commandId,
-        });
-        if (decision.kind === 'append')
-            await this.repository.append(command.workflowInstanceId, loaded.sequence, decision.events);
+        const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+        if (definition !== null) {
+            const decision = decideActivityOutcome(definition, loaded.view, {
+                ...command,
+                outcome: orchestrationActivityOutcome(command.outcome),
+                occurredAt: context.occurredAt,
+                causationId: context.commandId,
+            });
+            if (decision.kind === 'append')
+                await this.repository.append(command.workflowInstanceId, loaded.sequence, decision.events);
+        }
         await this.reconcileChildCompletions(context);
         return (await this.repository.loadRequired(command.workflowInstanceId)).view;
     }

package/dist/src/orchestration/application/accept-signal.js

@@ -22,7 +22,10 @@ export class AcceptSignal {
     async execute(workflowInstanceId, signal, context) {
         const loaded = await this.repository.loadRequired(workflowInstanceId);
         const item = await this.work.get(loaded.view.workItemId);
-        const decision = decideSignal(this.workflows.definition(loaded.view.workflowName), loaded.view, {
+        const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+        if (definition === null)
+            return (await this.repository.loadRequired(workflowInstanceId)).view;
+        const decision = decideSignal(definition, loaded.view, {
             signal,
             occurredAt: context.occurredAt,
             causationId: context.commandId,

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

@@ -1,3 +1,4 @@
+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';
@@ -20,7 +21,10 @@ export class AdvanceWorkflow {
     }
     async requestSupplementalActivity(id, request, context) {
         const loaded = await this.repository.loadRequired(id);
-        const configured = this.workflows.definition(loaded.view.workflowName).commands[commandName(request.command)];
+        const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+        if (definition === null)
+            return (await this.repository.loadRequired(id)).view;
+        const configured = definition.commands[commandName(request.command)];
         if (configured === undefined)
             throw new Error(`Unknown supplemental command: ${request.command}`);
         if (!isAuthorisedActor(configured.allowedActors, context.actor.kind))
@@ -111,7 +115,10 @@ export class AdvanceWorkflow {
             throw new OperatorRetryIneligibleError('WorkflowInstance does not exist');
         if (loaded.view.operatorRetryCommandIds.includes(context.commandId))
             return loaded.view;
-        const decision = decideOperatorRetry(this.workflows.definition(loaded.view.workflowName), loaded.view, {
+        const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+        if (definition === null)
+            return (await this.repository.loadRequired(id)).view;
+        const decision = decideOperatorRetry(definition, loaded.view, {
             commandId: context.commandId,
             occurredAt: context.occurredAt,
             causationId: context.commandId,
@@ -133,28 +140,48 @@ export class AdvanceWorkflow {
         return (await this.repository.load(id)).view;
     }
     async listPendingActivations(workItemId) {
-        return (await this.repository.list())
-            .filter((view) => view !== null &&
-            view.status === WorkflowStatus.Active &&
+        return (await this.listAllLoaded())
+            .filter(({ view }) => view.status === WorkflowStatus.Active &&
             view.pendingActivation !== undefined &&
             (workItemId === undefined || view.workItemId === workItemId))
-            .map((view) => ({ workflow: view, activation: view.pendingActivation }));
+            .map(({ view }) => ({ workflow: view, activation: view.pendingActivation }));
     }
     async listWaiting(signalKind) {
-        return (await this.repository.list()).filter((view) => view?.status === WorkflowStatus.Waiting &&
-            (signalKind === undefined || view.waitingFor?.signalKind === signalKind));
+        return (await this.listAllLoaded())
+            .filter(({ view }) => view.status === WorkflowStatus.Waiting &&
+            (signalKind === undefined || view.waitingFor?.signalKind === signalKind))
+            .map(({ view }) => view);
     }
     async listAll() {
-        return (await this.repository.list()).filter((view) => view !== null);
+        return (await this.listAllLoaded()).map(({ view }) => view);
     }
-    async listWatchMatches(eventType) {
-        return (await this.listAll()).flatMap((parent) => {
-            const definition = this.workflows.definition(parent.workflowName);
+    // 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.
+    async listAllLoaded() {
+        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(eventType) === true &&
+                .filter((watch) => watch.on?.events.includes(event.eventType) === true &&
                 watch.while.stages.includes(parent.currentStage) &&
-                watch.while.statuses.some((status) => status === parent.status))
+                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/application/orchestration-repository.js

@@ -28,7 +28,7 @@ export class OrchestrationRepository {
         const ids = new Set((await this.journal.readAll(0))
             .filter((event) => isWorkflowInstanceStream(event.stream))
             .map((event) => event.stream.id));
-        return Promise.all([...ids].map(async (id) => (await this.load(id)).view));
+        return Promise.all([...ids].map((id) => this.load(id)));
     }
 }
 function isWorkflowEvent(event) {

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

@@ -6,16 +6,17 @@ import { GroupBudgetRecorder } from './group-budget-recorder.js';
 import { OrchestrationRepository } from './orchestration-repository.js';
 import { RequestChild } from './request-child.js';
 import { StartWorkflow } from './start-workflow.js';
+import { WorkflowDefinitionRegistry } from './workflow-definition-registry.js';
 export class OrchestrationService {
     startWorkflow;
     acceptActivityOutcome;
     acceptWorkflowSignal;
     advanceWorkflow;
     childWorkflows;
-    constructor(journal, work, definitions) {
+    constructor(journal, work, definitions, projections) {
         const repository = new OrchestrationRepository(journal);
         const claims = new CoordinationClaims(journal);
-        this.startWorkflow = new StartWorkflow(repository, claims, work, definitions);
+        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.childWorkflows = new RequestChild(repository, claims, new GroupBudgetRecorder(journal), this.startWorkflow, this.advanceWorkflow);
@@ -75,8 +76,8 @@ export class OrchestrationService {
     isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
         return this.childWorkflows.isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId);
     }
-    listWatchMatches(eventType) {
-        return this.advanceWorkflow.listWatchMatches(eventType);
+    listWatchMatches(event, context) {
+        return this.advanceWorkflow.listWatchMatches(event, context);
     }
 }
-export const createOrchestrationService = (journal, work, definitions) => new OrchestrationService(journal, work, definitions);
+export const createOrchestrationService = (journal, work, definitions, projections) => new OrchestrationService(journal, work, definitions, projections);

package/dist/src/orchestration/application/request-child.js

@@ -94,7 +94,10 @@ export class RequestChild {
             childWorkflowInstanceId: child.workflowInstanceId,
             requestId: metadata.requestId,
         };
-        const decision = decideSignal(this.workflows.definition(parent.view.workflowName), parent.view, {
+        const definition = await this.workflows.definitionForOperation(parent.view, parent.sequence, context);
+        if (definition === null)
+            return;
+        const decision = decideSignal(definition, parent.view, {
             signal,
             occurredAt: context.occurredAt,
             causationId: context.commandId,

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

@@ -1,7 +1,16 @@
+import { createEventDraft, EventSourceKind } from '../../kernel/index.js';
 import { WorkStatus } from '../../work/index.js';
-import { WorkflowInstanceKind } from '../contracts/vocabulary.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { workflowInstanceStream } from '../contracts/streams.js';
+import { WorkflowInstanceKind, WorkflowStatus } from '../contracts/vocabulary.js';
 import { validateChildProvenance } from '../domain/child-policy.js';
 import { startInstance } from '../domain/interpreter.js';
+import { WorkflowDefinitionUnavailableError } from './workflow-definition-registry.js';
+const TERMINAL_OR_BLOCKED_STATUSES = new Set([
+    WorkflowStatus.Blocked,
+    WorkflowStatus.Completed,
+    WorkflowStatus.Superseded,
+]);
 export class StartWorkflow {
     repository;
     claims;
@@ -17,7 +26,7 @@ export class StartWorkflow {
         const item = await this.work.get(command.workItemId);
         if (item === null || item.state !== WorkStatus.Open)
             throw new Error('WorkItem must exist and be open');
-        const definition = this.definition(command.workflowName);
+        const { definition, fingerprint } = this.definitions.currentDefinition(command.workflowName);
         const existing = await this.repository.load(command.workflowInstanceId);
         if (existing.view !== null)
             return existing.view;
@@ -31,9 +40,11 @@ export class StartWorkflow {
                 parent.view.orchestrationGroupId !== command.orchestrationGroupId)
                 throw new Error('Child workflow must share its parent WorkItem and orchestration group');
         }
+        await this.definitions.register(command.workflowName, fingerprint, definition, context);
         const decision = startInstance({
             ...command,
             definition,
+            workflowDefinitionFingerprint: fingerprint,
             occurredAt: context.occurredAt,
             correlationId: context.correlationId,
             causationId: context.commandId,
@@ -42,10 +53,34 @@ export class StartWorkflow {
             await this.repository.append(command.workflowInstanceId, 0, decision.events);
         return (await this.repository.loadRequired(command.workflowInstanceId)).view;
     }
-    definition(name) {
-        const definition = this.definitions[name];
-        if (definition === undefined)
-            throw new Error(`Unknown workflow: ${name}`);
-        return definition;
+    definitionFor(view) {
+        return this.definitions.resolve(view);
+    }
+    async definitionForOperation(view, sequence, context) {
+        try {
+            return await this.definitions.resolve(view);
+        }
+        catch (error) {
+            if (!(error instanceof WorkflowDefinitionUnavailableError))
+                throw error;
+            if (!TERMINAL_OR_BLOCKED_STATUSES.has(view.status))
+                await this.repository.append(view.workflowInstanceId, sequence, [
+                    createEventDraft({
+                        // workflowInstanceId is included because listWatchMatches shares one
+                        // CommandContext across every matched parent in a batch; commandId
+                        // alone would collide when two instances block in the same pass.
+                        eventId: `${context.commandId}:${view.workflowInstanceId}:${OrchestrationEventType.InstanceBlocked}`,
+                        eventType: OrchestrationEventType.InstanceBlocked,
+                        occurredAt: context.occurredAt,
+                        correlationId: context.correlationId,
+                        causationId: context.commandId,
+                        actor: context.actor,
+                        source: { kind: EventSourceKind.Internal, id: 'orchestration-service' },
+                        stream: workflowInstanceStream(view.workflowInstanceId),
+                        payload: { reason: 'workflow-definition-unavailable' },
+                    }),
+                ]);
+            return null;
+        }
     }
 }

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

@@ -8,7 +8,7 @@ export function createWatchReactor(orchestration, journal, checkpoints, runs) {
         async react(event, context) {
             const causalCycle = orchestrationCausalCycleId(selectOrchestrationEvent(event));
             const sourceWorkflowInstanceId = await resolveRunWorkflowInstanceId(event, runs);
-            for (const match of await orchestration.listWatchMatches(event.eventType)) {
+            for (const match of await orchestration.listWatchMatches(event, context)) {
                 if (sourceWorkflowInstanceId !== undefined &&
                     match.parent.workflowInstanceId !== sourceWorkflowInstanceId)
                     continue;

package/dist/src/orchestration/application/workflow-definition-registry.js

@@ -0,0 +1,108 @@
+import { createHash } from 'node:crypto';
+import { createEventDraft, EventActorKind, EventSourceKind, WrongExpectedSequenceError, } from '../../kernel/index.js';
+import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { OrchestrationStreamKind, workflowDefinitionsStream } from '../contracts/streams.js';
+export const workflowDefinitionFingerprint = (definition) => createHash('sha256').update(JSON.stringify(definition)).digest('hex');
+export const workflowDefinitionKey = (name, fingerprint) => `${name}:${fingerprint}`;
+export const workflowDefinitionsProjection = {
+    name: OrchestrationStreamKind.WorkflowDefinitions,
+    select(event) {
+        const owned = selectOrchestrationEvent(event);
+        return owned?.eventType === OrchestrationEventType.WorkflowDefinitionRegistered
+            ? { key: workflowDefinitionKey(owned.payload.workflowName, owned.payload.fingerprint) }
+            : null;
+    },
+    initial: () => undefined,
+    project(_previous, event) {
+        const owned = selectOrchestrationEvent(event);
+        if (owned?.eventType !== OrchestrationEventType.WorkflowDefinitionRegistered)
+            throw new Error('Expected workflow definition registration');
+        return owned.payload.compiledDefinition;
+    },
+};
+export class WorkflowDefinitionUnavailableError extends Error {
+    constructor() {
+        super('workflow-definition-unavailable');
+        this.name = 'WorkflowDefinitionUnavailableError';
+    }
+}
+export class WorkflowDefinitionRegistry {
+    journal;
+    projections;
+    current;
+    // WorkflowDefinitionRegistered events are never retracted, so once a
+    // (name, fingerprint) pair is observed registered it stays registered for
+    // the life of this process — caching it skips the shared-stream scan that
+    // register() would otherwise repeat on every workflow/child start.
+    knownRegistered = new Set();
+    constructor(journal, projections, current) {
+        this.journal = journal;
+        this.projections = projections;
+        this.current = current;
+    }
+    currentDefinition(name) {
+        const definition = this.current[name];
+        if (definition === undefined)
+            throw new Error(`Unknown workflow: ${name}`);
+        return { definition, fingerprint: workflowDefinitionFingerprint(definition) };
+    }
+    async register(name, fingerprint, definition, context) {
+        if (await this.isRegistered(name, fingerprint))
+            return;
+        const stream = workflowDefinitionsStream();
+        const draft = createEventDraft({
+            eventId: `workflow-definition:${name}:${fingerprint}`,
+            eventType: OrchestrationEventType.WorkflowDefinitionRegistered,
+            occurredAt: context.occurredAt,
+            correlationId: context.correlationId,
+            causationId: context.commandId,
+            actor: { kind: EventActorKind.System, id: 'orchestration' },
+            source: { kind: EventSourceKind.Internal, id: 'orchestration' },
+            stream,
+            payload: { workflowName: name, fingerprint, compiledDefinition: definition },
+        });
+        // The deterministic event id makes retries idempotent; CAS protects the
+        // one shared registration stream when different definitions race to start.
+        for (;;) {
+            const sequence = (await this.journal.readStream(stream)).length;
+            try {
+                await this.journal.append(stream, sequence, [draft]);
+                this.knownRegistered.add(workflowDefinitionKey(name, fingerprint));
+                return;
+            }
+            catch (error) {
+                if (await this.isRegistered(name, fingerprint))
+                    return;
+                if (!(error instanceof WrongExpectedSequenceError))
+                    throw error;
+            }
+        }
+    }
+    async isRegistered(name, fingerprint) {
+        const key = workflowDefinitionKey(name, fingerprint);
+        if (this.knownRegistered.has(key))
+            return true;
+        const found = (await this.journal.readStream(workflowDefinitionsStream())).some((event) => {
+            const owned = selectOrchestrationEvent(event);
+            return (owned?.eventType === OrchestrationEventType.WorkflowDefinitionRegistered &&
+                owned.payload.workflowName === name &&
+                owned.payload.fingerprint === fingerprint);
+        });
+        if (found)
+            this.knownRegistered.add(key);
+        return found;
+    }
+    async resolve(view) {
+        if (view.workflowDefinitionFingerprint === undefined)
+            return this.currentDefinition(view.workflowName).definition;
+        const current = this.current[view.workflowName];
+        if (current !== undefined &&
+            workflowDefinitionFingerprint(current) === view.workflowDefinitionFingerprint)
+            return current;
+        const stored = await this.projections?.read(workflowDefinitionsProjection.name, workflowDefinitionKey(view.workflowName, view.workflowDefinitionFingerprint));
+        if (stored === null || stored === undefined)
+            throw new WorkflowDefinitionUnavailableError();
+        return stored.value;
+    }
+}

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ApprovalAuthorityKind, WorkflowStatus } from './vocabulary.js';
+import { PullRequestCheckState } from '../../activities/index.js';
 import { WorkspaceMode } from '../../execution/index.js';
 import { MatchMode } from '../../kernel/index.js';
 const identifier = z.string().trim().min(1);
@@ -33,6 +34,9 @@ const watchGateConfigSchema = z.union([
 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]);
+const failingChecksWatchPredicateSchema = z
+    .object({ checks: z.literal(PullRequestCheckState.Failing) })
+    .strict();
 export const watchConfigSchema = z
     .object({
     id: identifier,
@@ -46,6 +50,7 @@ export const watchConfigSchema = z
         .object({ events: z.array(canonicalEventName).min(1).readonly() })
         .strict()
         .optional(),
+    where: failingChecksWatchPredicateSchema.optional(),
     schedule: z.object({ cron: identifier }).strict().optional(),
     workflow: identifier,
     maxPerGroup: z.number().int().positive(),

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

@@ -29,6 +29,12 @@ export const childGroupStreamSchema = z
     id: childGroupIdSchema,
 })
     .strict();
+const workflowDefinitionsStreamSchema = z
+    .object({
+    kind: z.literal(OrchestrationStreamKind.WorkflowDefinitions),
+    id: z.literal('registry'),
+})
+    .strict();
 export const childMetadataShape = {
     parentWorkflowInstanceId: workflowInstanceIdSchema,
     watchId: z.string().min(1),
@@ -169,6 +175,7 @@ const eventSchema = z.discriminatedUnion('eventType', [
             workflowName: brandedStringSchema(workflowName),
             orchestrationGroupId: brandedStringSchema(orchestrationGroupId),
             entry: brandedStringSchema(stageName),
+            workflowDefinitionFingerprint: z.string().min(1).optional(),
         })
             .strict(),
         z
@@ -176,10 +183,22 @@ const eventSchema = z.discriminatedUnion('eventType', [
             workItemId: brandedStringSchema(workItemId),
             workflowName: brandedStringSchema(workflowName),
             entry: brandedStringSchema(stageName),
+            workflowDefinitionFingerprint: z.string().min(1).optional(),
             ...childMetadataShape,
         })
             .strict(),
     ])),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(OrchestrationEventType.WorkflowDefinitionRegistered),
+        stream: workflowDefinitionsStreamSchema,
+        payload: z
+            .object({
+            workflowName: brandedStringSchema(workflowName),
+            fingerprint: z.string().min(1),
+            compiledDefinition: z.custom(),
+        })
+            .strict(),
+    }),
     workflowEnvelope(OrchestrationEventType.StageEntered, z.object({ stage: brandedStringSchema(stageName) }).strict()),
     workflowEnvelope(OrchestrationEventType.ActivityRequested, activityRequestedSchema),
     workflowEnvelope(OrchestrationEventType.ActivityStarted, z.object({ activationId: brandedStringSchema(activationId) }).strict()),
@@ -241,6 +260,8 @@ export function decodeOrchestrationEvent(event) {
     const result = eventSchema.safeParse(event);
     if (!result.success)
         throw invalidOrchestrationEvent(event, result.error);
+    // Zod represents optional object members as `T | undefined`; the durable
+    // contract uses exact optional members for compatibility with old events.
     return result.data;
 }
 export function selectOrchestrationEvent(event) {
@@ -253,6 +274,7 @@ export function selectWorkflowOrchestrationEvent(event) {
     switch (owned.eventType) {
         case OrchestrationEventType.PrimaryClaimed:
         case OrchestrationEventType.GroupClaimed:
+        case OrchestrationEventType.WorkflowDefinitionRegistered:
             return null;
         default:
             return owned;

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

@@ -1,5 +1,6 @@
 import { signalName } from './identifiers.js';
 export const OrchestrationEventType = {
+    WorkflowDefinitionRegistered: 'orchestration.workflow-definition-registered',
     InstanceStarted: 'orchestration.instance-started',
     StageEntered: 'orchestration.stage-entered',
     ActivityRequested: 'orchestration.activity-requested',

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

@@ -1,7 +1,12 @@
 export const OrchestrationStreamKind = {
     WorkflowInstance: 'workflow-instance',
     Group: 'orchestration-group',
+    WorkflowDefinitions: 'workflow-definitions',
 };
+export const workflowDefinitionsStream = () => ({
+    kind: OrchestrationStreamKind.WorkflowDefinitions,
+    id: 'registry',
+});
 export const orchestrationGroupStreamId = (value) => {
     return value.startsWith('primary:')
         ? primaryOrchestrationGroupStreamId(value)

package/dist/src/orchestration/domain/activation-policy.js

@@ -23,6 +23,9 @@ export function startInstance(input) {
                 workflowName: input.definition.name,
                 orchestrationGroupId: input.orchestrationGroupId,
                 entry: input.definition.entry,
+                ...(input.workflowDefinitionFingerprint === undefined
+                    ? {}
+                    : { workflowDefinitionFingerprint: input.workflowDefinitionFingerprint }),
                 ...child,
             }, childEvents.length + 1),
             startDraft(input, OrchestrationEventType.StageEntered, { stage: input.definition.entry }, childEvents.length + 2),

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

@@ -1,4 +1,4 @@
-import { activityName, ActivityOutcomeKind, } from '../../activities/index.js';
+import { ActivityEventType, activityName, ActivityOutcomeKind, } from '../../activities/index.js';
 import { workflowDefinitionConfigSchema, } from '../contracts/config.js';
 import { commandName, signalName, stageName, watchId, workflowName, } from '../contracts/identifiers.js';
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
@@ -42,6 +42,10 @@ function compileWatches(config, stageNames, knownWorkflowNames) {
             throw new Error(`Unknown watch stage: ${unknownStages.join(', ')}`);
         if (!knownWorkflowNames.includes(watch.workflow))
             throw new Error(`Unknown watch workflow: ${watch.workflow}`);
+        if (watch.where !== undefined &&
+            (watch.on === undefined ||
+                watch.on.events.some((event) => event !== ActivityEventType.PrChecksChanged)))
+            throw new Error('Watch where.checks is only valid with pr.checks-changed');
         return Object.freeze({
             ...watch,
             id: watchId(watch.id),

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

@@ -204,6 +204,9 @@ export function immutableWorkflowInstanceView(state) {
         workflowInstanceId: state.workflowInstanceId,
         workItemId: state.workItemId,
         workflowName: state.workflowName,
+        ...(state.workflowDefinitionFingerprint === undefined
+            ? {}
+            : { workflowDefinitionFingerprint: state.workflowDefinitionFingerprint }),
         orchestrationGroupId: state.orchestrationGroupId,
         ...(state.parentWorkflowInstanceId === undefined
             ? {}

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

@@ -10,6 +10,9 @@ export function foldWorkflowInstance(events) {
         workflowInstanceId: first.stream.id,
         workItemId: first.payload.workItemId,
         workflowName: first.payload.workflowName,
+        ...(first.payload.workflowDefinitionFingerprint === undefined
+            ? {}
+            : { workflowDefinitionFingerprint: first.payload.workflowDefinitionFingerprint }),
         orchestrationGroupId: first.payload.orchestrationGroupId,
         ...optionalChildFields(first.payload),
         status: WorkflowStatus.Active,

package/dist/src/orchestration/index.js

@@ -4,6 +4,7 @@ export * from './application/orchestration-service.js';
 export * from './application/advance-workflow.js';
 export * from './application/signal-reactor.js';
 export * from './application/watch-reactor.js';
+export * from './application/workflow-definition-registry.js';
 export * from './contracts/activity-outcome.js';
 export * from './contracts/commands.js';
 export * from './contracts/config.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.5",
+  "version": "0.3.7",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {