@atolis-hq/wake 0.3.6 → 0.3.8

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 = "gd042cce";
+export const wakeVersion = "g42cf498";

package/dist/src/integrations/github/application/inbound-review-signals.js

@@ -101,6 +101,7 @@ async function applyIssueApprovalSignal(input) {
         orchestration,
         resourceId: resourceIdValue,
         outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
+        resumeBlockedOnChanges: command === '/changes',
     });
 }
 async function applyPullRequestWorkflowSignal(input) {
@@ -125,25 +126,28 @@ async function applyPullRequestWorkflowSignal(input) {
     });
 }
 async function applyWorkflowSignal(input) {
-    const { event, resources, orchestration, resourceId: resourceIdValue, outcome } = input;
+    const { event, resources, orchestration, resourceId: resourceIdValue, outcome, resumeBlockedOnChanges = false, } = input;
     const workItemIds = (await resources.correlations(resourceIdValue))
         .filter((correlation) => correlation.role === ResourceCorrelationRole.Primary)
         .map((correlation) => correlation.workItemId);
     for (const workflow of await orchestration.listAll()) {
         if (!workItemIds.includes(workflow.workItemId))
             continue;
-        if (workflow.waitingFor === undefined)
-            continue;
-        await orchestration.acceptSignal(workflow.workflowInstanceId, {
-            kind: workflow.waitingFor.signalKind,
-            outcome,
-            actorId: event.payload.actor.id,
-            actorDecision: {
-                authorized: event.payload.actor.kind === ReviewActorKind.Human,
-                evidenceId: event.eventId,
-            },
-            providerEventId: event.eventId,
-        }, commandContext(event));
+        if (workflow.waitingFor !== undefined) {
+            await orchestration.acceptSignal(workflow.workflowInstanceId, {
+                kind: workflow.waitingFor.signalKind,
+                outcome,
+                actorId: event.payload.actor.id,
+                actorDecision: {
+                    authorized: event.payload.actor.kind === ReviewActorKind.Human,
+                    evidenceId: event.eventId,
+                },
+                providerEventId: event.eventId,
+            }, commandContext(event));
+        }
+        else if (resumeBlockedOnChanges) {
+            await orchestration.resumeBlockedStageForChanges(workflow.workflowInstanceId, commandContext(event));
+        }
     }
 }
 function isWakeDelivery(body) {

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/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

@@ -17,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 }),
                 });
             });
@@ -54,6 +58,7 @@ function pullRequestObservation(input) {
         },
         labels: gitHubLabelNames(pullRequest),
         assignees: gitHubAssigneeLogins(pullRequest),
+        ...(input.changedFiles === undefined ? {} : { changedFiles: input.changedFiles }),
         raw: {
             number: pullRequest.number,
             checkRuns: boundedDiagnosticEvidence(input.evidence.checkRuns),
@@ -98,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

@@ -4,7 +4,7 @@ import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
 import { workflowInstanceStream } from '../contracts/streams.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
-import { requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
+import { requestChangesResume as decideChangesResume, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
 import { isAuthorisedActor } from '../domain/supplemental-policy.js';
 export class OperatorRetryIneligibleError extends Error {
     constructor(detail) {
@@ -21,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))
@@ -112,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,
@@ -130,34 +136,73 @@ export class AdvanceWorkflow {
         }
         return (await this.repository.loadRequired(id)).view;
     }
+    async resumeBlockedStageForChanges(id, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null)
+            return null;
+        if (loaded.view.operatorRetryCommandIds.includes(context.commandId))
+            return 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 = decideChangesResume(definition, loaded.view, {
+            commandId: context.commandId,
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        if (decision.kind === 'ignored')
+            return loaded.view;
+        try {
+            await this.repository.append(id, loaded.sequence, decision.events);
+        }
+        catch (error) {
+            const reloaded = await this.repository.loadRequired(id);
+            if (reloaded.view.operatorRetryCommandIds.includes(context.commandId))
+                return reloaded.view;
+            throw error;
+        }
+        return (await this.repository.loadRequired(id)).view;
+    }
     async get(id) {
         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(event) {
-        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(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) {

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);
@@ -54,6 +55,9 @@ export class OrchestrationService {
     retryBlockedFailedStage(workflowInstanceId, context) {
         return this.advanceWorkflow.retryBlockedFailedStage(workflowInstanceId, context);
     }
+    resumeBlockedStageForChanges(workflowInstanceId, context) {
+        return this.advanceWorkflow.resumeBlockedStageForChanges(workflowInstanceId, context);
+    }
     get(id) {
         return this.advanceWorkflow.get(id);
     }
@@ -75,8 +79,8 @@ export class OrchestrationService {
     isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
         return this.childWorkflows.isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId);
     }
-    listWatchMatches(event) {
-        return this.advanceWorkflow.listWatchMatches(event);
+    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)) {
+            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/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/interpreter.js

@@ -10,7 +10,7 @@ import { finishRoute } from './transition.js';
 export { startInstance } from './activation-policy.js';
 export { acceptSignal, waitForSignal } from './signal-policy.js';
 export { requestSupplementalActivity } from './supplemental-policy.js';
-export { isOperatorRetryEligible, requestOperatorRetry } from './operator-retry-policy.js';
+export { isChangesResumeEligible, isOperatorRetryEligible, requestChangesResume, requestOperatorRetry, } from './operator-retry-policy.js';
 export function acceptActivityOutcome(definition, state, input) {
     if (!isPendingOutcome(state, input))
         return { kind: 'ignored', reason: 'outcome is not for the pending activation' };

package/dist/src/orchestration/domain/operator-retry-policy.js

@@ -1,4 +1,4 @@
-import { ActivityOutcomeKind } from '../../activities/index.js';
+import { ActivityOutcomeKind, BuiltInActivityName } from '../../activities/index.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 import { stageName } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, WorkflowStatus } from '../contracts/vocabulary.js';
@@ -14,6 +14,18 @@ export function isOperatorRetryEligible(view) {
         view.lastOutcome?.kind === ActivityOutcomeKind.Failed &&
         view.acceptedOutcomes.includes(pending.activationId));
 }
+export function isChangesResumeEligible(view) {
+    const pending = view.pendingActivation;
+    return (view.status === WorkflowStatus.Blocked &&
+        view.blockReason === 'unconfigured outcome blocked' &&
+        pending !== undefined &&
+        pending.activity === BuiltInActivityName.Agent &&
+        pending.status === ActivityActivationStatus.Completed &&
+        pending.supplemental !== true &&
+        pending.followOnIndex === undefined &&
+        view.lastOutcome?.kind === ActivityOutcomeKind.Blocked &&
+        view.acceptedOutcomes.includes(pending.activationId));
+}
 export function requestOperatorRetry(definition, state, input) {
     if (input.commandId.length === 0)
         return { kind: 'ignored', reason: 'operator retry command id is required' };
@@ -32,3 +44,23 @@ export function requestOperatorRetry(definition, state, input) {
     ];
     return { kind: 'append', events };
 }
+export function requestChangesResume(definition, state, input) {
+    if (input.commandId.length === 0)
+        return { kind: 'ignored', reason: 'changes resume command id is required' };
+    if (!isChangesResumeEligible(state))
+        return {
+            kind: 'ignored',
+            reason: 'workflow is not blocked for an unconfigured agent blocked outcome',
+        };
+    const stage = definition.stages[stageName(state.currentStage)];
+    return {
+        kind: 'append',
+        events: [
+            stateDraft(state, input, OrchestrationEventType.OperatorRetryRequested, { activationId: state.pendingActivation.activationId, commandId: input.commandId }, 1),
+            stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), stage.activity, stage.with, {
+                execution: stage.execution,
+                stage: stageName(state.currentStage),
+            }), 2),
+        ],
+    };
+}

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.6",
+  "version": "0.3.8",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {