@atolis-hq/wake 0.3.35 → 0.3.37

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

@@ -1,6 +1,6 @@
 import { createPullRequestService } from '../activities/index.js';
 import { ControlStreamKind, DispatchPolicy, createAdvanceOnce, createControlPlaneService, createRunnerControlService, ineligibleRunners, } from '../control-plane/index.js';
-import { ExternalExecutionState, GitWorkspaceProvider, RecoveryService, TranscriptStore, createExecutionService, } from '../execution/index.js';
+import { ExecutionCancellationReason, ExternalExecutionState, GitWorkspaceProvider, RecoveryService, TranscriptStore, createExecutionService, } from '../execution/index.js';
 import { createGitHubAgentContextReader, gitHubProviderDefinition, resolveGitHubResourceUrl, } from '../integrations/github/index.js';
 import { SystemClock, UlidIdGenerator, } from '../kernel/index.js';
 import { compileWorkflow, createOrchestrationService } from '../orchestration/index.js';
@@ -73,6 +73,9 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
             : {}),
         workspaces,
     });
+    orchestration.setWatchChildCancellation({
+        cancelSupersededWatchChildren: (workflowInstanceIds) => execution.cancelActive(workflowInstanceIds, ExecutionCancellationReason.WorkflowSuperseded),
+    });
     const recovery = new RecoveryService(journal, clock, {
         async inspect() {
             // Unknown external work follows the safe ambiguity path until runners expose inspection.

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 = "g4327396";
+export const wakeVersion = "g82e4db8";

package/dist/src/control-plane/application/advance-once.js

@@ -4,6 +4,7 @@ import { WorkflowStatus } from '../../orchestration/index.js';
 import { WorkStatus } from '../../work/index.js';
 import { ControlStreamKind } from '../contracts/streams.js';
 import { DispatchPolicy } from '../domain/dispatch-policy.js';
+import { findUnresolvedTerminal, isExecutionFailureTerminal } from './execution-reconciliation.js';
 export function createAdvanceOnce(orchestration, execution, resources, clock, dependencies) {
     const runnerIneligibility = dependencies.runnerIneligibility ?? (async () => new Set());
     const isDispatchPaused = dependencies.isDispatchPaused ?? (async () => false);
@@ -133,6 +134,8 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
         // Recheck at the dispatch boundary so maintenance cannot race a selected activation.
         if (await isDispatchPaused())
             return { kind: 'paused' };
+        if ((await orchestration.validateActivationDispatch?.(selected.workflow.workflowInstanceId, context(selected.activation.activationId))) === false)
+            return { kind: 'no-work' };
         await orchestration.markActivationStarted(selected.workflow.workflowInstanceId, selected.activation.activationId, context(selected.activation.activationId));
         const correlated = await resources.correlationsForWork(selected.workflow.workItemId);
         const resourceViews = (await Promise.all(correlated.map((entry) => resources.get(entry.resourceId)))).filter((resource) => resource !== null);
@@ -170,15 +173,3 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
             };
     };
 }
-async function findUnresolvedTerminal(pending, execution) {
-    for (const item of pending) {
-        const run = (await execution.list(item.activation.activationId)).find((candidate) => (candidate.status === RunStatus.Succeeded && candidate.outcome !== undefined) ||
-            isExecutionFailureTerminal(candidate.status));
-        if (run !== undefined && !item.workflow.acceptedOutcomes.includes(item.activation.activationId))
-            return { item, run };
-    }
-    return undefined;
-}
-function isExecutionFailureTerminal(status) {
-    return (status === RunStatus.Failed || status === RunStatus.Cancelled || status === RunStatus.Ambiguous);
-}

package/dist/src/control-plane/application/execution-reconciliation.js

@@ -0,0 +1,13 @@
+import { RunStatus } from '../../execution/index.js';
+export async function findUnresolvedTerminal(pending, execution) {
+    for (const item of pending) {
+        const run = (await execution.list(item.activation.activationId)).find((candidate) => (candidate.status === RunStatus.Succeeded && candidate.outcome !== undefined) ||
+            isExecutionFailureTerminal(candidate.status));
+        if (run !== undefined && !item.workflow.acceptedOutcomes.includes(item.activation.activationId))
+            return { item, run };
+    }
+    return undefined;
+}
+export function isExecutionFailureTerminal(status) {
+    return (status === RunStatus.Failed || status === RunStatus.Cancelled || status === RunStatus.Ambiguous);
+}

package/dist/src/integrations/github/application/inbound-comment-syntax.js

@@ -0,0 +1,21 @@
+import { ReviewActorKind } from '../../../activities/index.js';
+export function isHumanNonWakeReply(actorKind, body) {
+    return actorKind === ReviewActorKind.Human && !body.includes('<!-- wake:');
+}
+export function recognizedCommand(body) {
+    const normalized = body.trim().toLowerCase();
+    if (normalized === '/approved')
+        return '/approved';
+    if (normalized === '/changes' || normalized.startsWith('/changes '))
+        return '/changes';
+    if (normalized === '/retry')
+        return '/retry';
+    return null;
+}
+export function isPlainReply(body) {
+    const normalized = body.trim();
+    return normalized.length > 0 && !normalized.startsWith('/');
+}
+export function shouldResumeBlockedStage(command, plainReply) {
+    return command === '/changes' || plainReply;
+}

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

@@ -3,6 +3,7 @@ import { ApprovalAuthorityKind } from '../../../orchestration/index.js';
 import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resourceId, } from '../../../resources/index.js';
 import { WorkStatus } from '../../../work/index.js';
 import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
+import { isHumanNonWakeReply, isPlainReply, recognizedCommand, shouldResumeBlockedStage, } from './inbound-comment-syntax.js';
 import { commandContext } from './inbound-context.js';
 import { ignoreIneligibleOperatorRetry } from './operator-retry-command.js';
 import { translateGitHubReviewCommand } from './review-command-translator.js';
@@ -61,7 +62,7 @@ async function applyFormalReviewSignal(input) {
 }
 async function applyIssueReviewSignal(input) {
     const { event, resources, work, lookup, orchestration, adapter } = input;
-    if (event.payload.actor.kind !== ReviewActorKind.Human || isWakeDelivery(event.payload.body))
+    if (!isHumanNonWakeReply(event.payload.actor.kind, event.payload.body))
         return;
     if (resources === undefined || lookup === undefined || orchestration === undefined)
         return;
@@ -73,15 +74,15 @@ async function applyIssueReviewSignal(input) {
         return;
     const resource = await resources.get(resourceIdValue);
     const command = recognizedCommand(event.payload.body);
+    const plainReply = isPlainReply(event.payload.body);
     if (command === '/retry') {
-        await applyIssueRetrySignal({
+        return applyIssueRetrySignal({
             event,
             resources,
             work,
             orchestration,
             resourceId: resourceIdValue,
         });
-        return;
     }
     if (resource?.kind === BuiltInResourceKind.PullRequest) {
         await applyWorkflowSignal({
@@ -90,11 +91,24 @@ async function applyIssueReviewSignal(input) {
             orchestration,
             resourceId: resourceIdValue,
             outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
+            acceptWaitingSignal: command !== null,
+            resumeBlockedOnChanges: shouldResumeBlockedStage(command, plainReply),
         });
         return;
     }
     if (command !== null)
         await applyIssueApprovalSignal({ ...input, command });
+    else if (plainReply) {
+        await applyWorkflowSignal({
+            event,
+            resources,
+            orchestration,
+            resourceId: resourceIdValue,
+            outcome: ActivityOutcomeKind.Rejected,
+            acceptWaitingSignal: false,
+            resumeBlockedOnChanges: true,
+        });
+    }
 }
 async function applyIssueRetrySignal(input) {
     const { event, resources, work, orchestration, resourceId: resourceIdValue } = input;
@@ -161,14 +175,14 @@ async function applyPullRequestWorkflowSignal(input) {
     });
 }
 async function applyWorkflowSignal(input) {
-    const { event, resources, orchestration, resourceId: resourceIdValue, outcome, resumeBlockedOnChanges = false, } = input;
+    const { event, resources, orchestration, resourceId: resourceIdValue, outcome, acceptWaitingSignal = true, 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) {
+        if (workflow.waitingFor !== undefined && acceptWaitingSignal) {
             await orchestration.acceptSignal(workflow.workflowInstanceId, {
                 kind: workflow.waitingFor.signalKind,
                 outcome,
@@ -188,16 +202,3 @@ async function applyWorkflowSignal(input) {
         }
     }
 }
-function isWakeDelivery(body) {
-    return body.includes('<!-- wake:');
-}
-function recognizedCommand(body) {
-    const normalized = body.trim().toLowerCase();
-    if (normalized === '/approved')
-        return '/approved';
-    if (normalized === '/changes' || normalized.startsWith('/changes '))
-        return '/changes';
-    if (normalized === '/retry')
-        return '/retry';
-    return null;
-}

package/dist/src/integrations/github/application/wake-labels.js

@@ -11,6 +11,7 @@ export function isGitHubWakeEcho(input) {
         input.labels.some(isGitHubWakeMarker));
 }
 export function createGitHubWakeLabelReconciler(input) {
+    const syncedDesiredLabels = new Map();
     const openWorkItemIds = async (workItemIds) => {
         const open = new Set();
         for (const workItemId of workItemIds) {
@@ -50,17 +51,22 @@ export function createGitHubWakeLabelReconciler(input) {
                     const locator = parseGitHubIssueKey(resource.externalKey.key);
                     if (locator === null)
                         continue;
+                    const fingerprint = desired.join('\u0000');
+                    if (syncedDesiredLabels.get(resource.resourceId) === fingerprint)
+                        continue;
                     // One issue's persistent failure (rate limit, permissions, a stale
                     // resource) must not stop every other open work item from being
                     // reconciled this pass — each correlation is an independent GitHub
                     // call with no ordering dependency on the others.
                     try {
-                        const current = await input.getLabels(locator.owner, locator.repo, locator.number);
+                        const current = await request(input, () => input.getLabels(locator.owner, locator.repo, locator.number));
                         const next = reconcileGitHubWakeLabels(current, desired);
                         if (!sameLabels(current, next))
-                            await input.setLabels(locator.owner, locator.repo, locator.number, next);
+                            await request(input, () => input.setLabels(locator.owner, locator.repo, locator.number, next));
+                        syncedDesiredLabels.set(resource.resourceId, fingerprint);
                     }
                     catch (error) {
+                        syncedDesiredLabels.delete(resource.resourceId);
                         onError({ workItemId: workflow.workItemId, ...locator }, error);
                     }
                 }
@@ -68,6 +74,9 @@ export function createGitHubWakeLabelReconciler(input) {
         },
     };
 }
+function request(input, operation) {
+    return input.requests === undefined ? operation() : input.requests.run(operation);
+}
 function defaultOnError(failure, error) {
     process.stderr.write(`GitHub label reconcile failed for ${failure.owner}/${failure.repo}#${failure.number}: ${error instanceof Error ? error.message : String(error)}\n`);
 }

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

@@ -33,11 +33,12 @@ export const gitHubConfigSchema = z
     polling: z
         .object({
         maxPerRepo: z.number().int().positive().default(25),
+        maxConcurrent: z.number().int().positive().default(4),
         commentPageSize: z.number().int().positive().max(100).default(25),
         lookbackMs: z.number().int().nonnegative().default(60_000),
     })
         .strict()
-        .default({ maxPerRepo: 25, commentPageSize: 25, lookbackMs: 60_000 }),
+        .default({ maxPerRepo: 25, maxConcurrent: 4, commentPageSize: 25, lookbackMs: 60_000 }),
     intake: z.array(intakeRuleSchema).default([]),
     publication: z
         .object({ postStatusComments: z.boolean().default(true) })

package/dist/src/integrations/github/infrastructure/request-coordinator.js

@@ -0,0 +1,123 @@
+export class GitHubRequestCooldownError extends Error {
+    retryAt;
+    constructor(retryAt) {
+        super(`GitHub provider is cooling down until ${new Date(retryAt).toISOString()}`);
+        this.retryAt = retryAt;
+        this.name = 'GitHubRequestCooldownError';
+    }
+}
+export function createGitHubRequestCoordinator(options) {
+    return new CoordinatedGitHubRequests(options);
+}
+class CoordinatedGitHubRequests {
+    options;
+    queue = [];
+    now;
+    active = 0;
+    draining = false;
+    cooldownUntil = 0;
+    transientFailureCount = 0;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+    }
+    run(request) {
+        return new Promise((resolve, reject) => {
+            this.queue.push({
+                request: request,
+                resolve: resolve,
+                reject,
+            });
+            void this.drain();
+        });
+    }
+    async drain() {
+        if (this.draining)
+            return;
+        this.draining = true;
+        try {
+            while (this.active < this.options.maxConcurrent && this.queue.length > 0) {
+                if (this.cooldownUntil > this.now()) {
+                    const error = new GitHubRequestCooldownError(this.cooldownUntil);
+                    this.queue.splice(0).forEach((pending) => pending.reject(error));
+                    return;
+                }
+                const pending = this.queue.shift();
+                this.active += 1;
+                void Promise.resolve()
+                    .then(pending.request)
+                    .then((value) => {
+                    this.transientFailureCount = 0;
+                    pending.resolve(value);
+                }, (error) => {
+                    this.recordFailure(error);
+                    pending.reject(error);
+                })
+                    .finally(() => {
+                    this.active -= 1;
+                    void this.drain();
+                });
+            }
+        }
+        finally {
+            this.draining = false;
+        }
+    }
+    recordFailure(error) {
+        const retryAfterMs = retryAfterMilliseconds(error, this.now());
+        if (statusOf(error) === 429) {
+            this.cooldownUntil = this.now() + (retryAfterMs ?? 60_000);
+            this.transientFailureCount = 0;
+            return;
+        }
+        if (isTransient(error)) {
+            const delay = Math.min(5_000 * 2 ** this.transientFailureCount, 60_000);
+            this.transientFailureCount += 1;
+            this.cooldownUntil = this.now() + delay;
+        }
+    }
+}
+function statusOf(error) {
+    if (typeof error !== 'object' || error === null || !('status' in error))
+        return undefined;
+    return typeof error.status === 'number' ? error.status : undefined;
+}
+function isTransient(error) {
+    const status = statusOf(error);
+    if (status !== undefined)
+        return status >= 500;
+    return (error instanceof TypeError ||
+        (typeof error === 'object' &&
+            error !== null &&
+            'code' in error &&
+            typeof error.code === 'string'));
+}
+function retryAfterMilliseconds(error, now) {
+    const value = retryAfterValue(error);
+    if (value === undefined || value === null)
+        return undefined;
+    const seconds = Number(value);
+    if (Number.isFinite(seconds) && seconds >= 0)
+        return seconds * 1_000;
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? Math.max(0, timestamp - now) : undefined;
+}
+function retryAfterValue(error) {
+    if (typeof error !== 'object' || error === null || !('response' in error))
+        return undefined;
+    const response = error.response;
+    if (typeof response !== 'object' || response === null || !('headers' in response))
+        return undefined;
+    return headerValue(response.headers);
+}
+function headerValue(headers) {
+    if (typeof headers !== 'object' || headers === null)
+        return undefined;
+    if ('get' in headers && typeof headers.get === 'function') {
+        const value = headers.get('retry-after');
+        return typeof value === 'string' ? value : undefined;
+    }
+    if ('retry-after' in headers && typeof headers['retry-after'] === 'string')
+        return headers['retry-after'];
+    return undefined;
+}

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

@@ -2,8 +2,11 @@ import { ReviewerAuthorizationSource, } from '../../../activities/index.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { issueCommentObservation, issueObservation } from './issue-source.js';
 import { createGitHubPullRequestSource } from './pr-source.js';
+import { createGitHubRequestCoordinator, } from './request-coordinator.js';
 import { githubReviewObservation } from './review-source.js';
-export function createGitHubSource(config, client, adapter) {
+export function createGitHubSource(config, client, adapter, requests = createGitHubRequestCoordinator({
+    maxConcurrent: config.polling.maxConcurrent,
+})) {
     let nextPollAt = 0;
     // Draft eventIds are already content fingerprints (see issue-source.ts/pr-source.ts),
     // so the journal itself is idempotent per item. This cache only avoids re-appending
@@ -16,7 +19,14 @@ export function createGitHubSource(config, client, adapter) {
             if (Date.now() < nextPollAt)
                 return [];
             nextPollAt = Date.now() + config.polling.lookbackMs;
-            const perRepository = await Promise.all(config.repositories.map(({ owner, repo }) => pollRepository({ client, config, adapter, signal, owner, repo })));
+            const perRepository = await Promise.all(config.repositories.map(({ owner, repo }) => pollRepository({
+                client: limitGitHubSourceClient(client, requests),
+                config,
+                adapter,
+                signal,
+                owner,
+                repo,
+            })));
             return perRepository.flat().filter((draft) => {
                 if (draft.eventType !== GitHubEventType.WorkObserved)
                     return true;
@@ -27,6 +37,28 @@ export function createGitHubSource(config, client, adapter) {
         },
     };
 }
+function limitGitHubSourceClient(client, requests) {
+    return {
+        ...client,
+        listIssues: (owner, repo, maxResults) => requests.run(() => client.listIssues(owner, repo, maxResults)),
+        listPullRequests: (owner, repo, maxResults) => requests.run(() => client.listPullRequests(owner, repo, maxResults)),
+        listCheckRunsForRef: (owner, repo, ref) => requests.run(() => client.listCheckRunsForRef(owner, repo, ref)),
+        getCombinedStatusForRef: (owner, repo, ref) => requests.run(() => client.getCombinedStatusForRef(owner, repo, ref)),
+        listPullRequestFiles: (owner, repo, pullNumber) => requests.run(() => client.listPullRequestFiles(owner, repo, pullNumber)),
+        listIssueComments: (owner, repo, issueNumber, pageSize) => requests.run(() => client.listIssueComments(owner, repo, issueNumber, pageSize)),
+        listReviews: (owner, repo, pullNumber, pageSize) => requests.run(() => client.listReviews(owner, repo, pullNumber, pageSize)),
+        ...(client.listReviewComments === undefined
+            ? {}
+            : {
+                listReviewComments: (owner, repo, pullNumber, pageSize) => requests.run(() => client.listReviewComments(owner, repo, pullNumber, pageSize)),
+            }),
+        ...(client.collaboratorPermission === undefined
+            ? {}
+            : {
+                collaboratorPermission: (owner, repo, login) => requests.run(() => client.collaboratorPermission(owner, repo, login)),
+            }),
+    };
+}
 async function pollRepository(input) {
     const { client, config, adapter, signal, owner, repo } = input;
     const context = {

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

@@ -9,6 +9,7 @@ import { GitHubEventType } from './contracts/events.js';
 import { createGitHubClient } from './infrastructure/client.js';
 import { createGitHubDelivery } from './infrastructure/delivery.js';
 import { resolveGitHubCliToken } from './infrastructure/gh-auth.js';
+import { createGitHubRequestCoordinator } from './infrastructure/request-coordinator.js';
 import { createGitHubSource } from './infrastructure/source.js';
 export const gitHubProviderDefinition = {
     provider: 'github',
@@ -20,16 +21,20 @@ export const gitHubProviderDefinition = {
         if (services === undefined)
             throw new Error('GitHub provider requires composed services');
         const client = createGitHubClient(config.token ?? resolveGitHubCliToken());
+        const requests = createGitHubRequestCoordinator({
+            maxConcurrent: config.polling.maxConcurrent,
+        });
         return {
             adapter,
             eventTypes: Object.values(GitHubEventType),
-            source: createGitHubSource(config, client, adapter),
+            source: createGitHubSource(config, client, adapter, requests),
             maintenance: createGitHubWakeLabelReconciler({
                 orchestration: services.orchestration,
                 resources: services.resources,
                 work: services.work,
                 getLabels: client.getIssueLabels,
                 setLabels: client.setIssueLabels,
+                requests,
             }),
             delivery: createGitHubDelivery(async (intent, idempotencyKey) => {
                 const resource = await services.resources.get(resourceId(intent.resourceId));

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

@@ -6,6 +6,7 @@ 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 { continuesWaitingForSameWatchGate } from './watch-child-transitions.js';
 import { WorkflowDefinitionRegistry } from './workflow-definition-registry.js';
 export class OrchestrationService {
     startWorkflow;
@@ -14,6 +15,7 @@ export class OrchestrationService {
     advanceWorkflow;
     childWorkflows;
     coordinateAcceptSignal = (operation) => operation();
+    watchChildCancellation;
     constructor(journal, work, definitions, projections) {
         const repository = new OrchestrationRepository(journal);
         const claims = new CoordinationClaims(journal);
@@ -33,34 +35,40 @@ export class OrchestrationService {
         return this.childWorkflows.rejectCausalActivation(request, context);
     }
     acceptOutcome(command, context) {
-        return this.acceptActivityOutcome.execute(command, context);
+        return this.transitionWatchChildren(context, () => this.acceptActivityOutcome.execute(command, context));
     }
     waitForSignal(workflowInstanceId, expectation, context) {
-        return this.acceptWorkflowSignal.wait(workflowInstanceId, expectation, context);
+        return this.transitionWatchChildren(context, () => this.acceptWorkflowSignal.wait(workflowInstanceId, expectation, context));
     }
     acceptSignal(workflowInstanceId, signal, context) {
-        return this.coordinateAcceptSignal(() => this.acceptWorkflowSignal.execute(workflowInstanceId, signal, context));
+        return this.coordinateAcceptSignal(() => this.transitionWatchChildren(context, () => this.acceptWorkflowSignal.execute(workflowInstanceId, signal, context)));
     }
     setAcceptSignalOperationCoordinator(coordinator) {
         this.coordinateAcceptSignal = coordinator;
     }
+    setWatchChildCancellation(cancellation) {
+        this.watchChildCancellation = cancellation;
+    }
     requestSupplementalActivity(workflowInstanceId, request, context) {
         return this.advanceWorkflow.requestSupplementalActivity(workflowInstanceId, request, context);
     }
     markActivationStarted(workflowInstanceId, activationId, context) {
         return this.advanceWorkflow.markActivationStarted(workflowInstanceId, activationId, context);
     }
+    validateActivationDispatch(workflowInstanceId, context) {
+        return this.childWorkflows.validateChildDispatch(workflowInstanceId, context);
+    }
     block(workflowInstanceId, reason, context) {
-        return this.advanceWorkflow.block(workflowInstanceId, reason, context);
+        return this.transitionWatchChildren(context, () => this.advanceWorkflow.block(workflowInstanceId, reason, context));
     }
     resolveExecutionFailure(workflowInstanceId, input, context) {
-        return this.advanceWorkflow.resolveExecutionFailure(workflowInstanceId, input, context);
+        return this.transitionWatchChildren(context, () => this.advanceWorkflow.resolveExecutionFailure(workflowInstanceId, input, context));
     }
     retryBlockedFailedStage(workflowInstanceId, context) {
-        return this.advanceWorkflow.retryBlockedFailedStage(workflowInstanceId, context);
+        return this.transitionWatchChildren(context, () => this.advanceWorkflow.retryBlockedFailedStage(workflowInstanceId, context));
     }
     resumeBlockedStageForChanges(workflowInstanceId, context) {
-        return this.advanceWorkflow.resumeBlockedStageForChanges(workflowInstanceId, context);
+        return this.transitionWatchChildren(context, () => this.advanceWorkflow.resumeBlockedStageForChanges(workflowInstanceId, context));
     }
     get(id) {
         return this.advanceWorkflow.get(id);
@@ -78,7 +86,23 @@ export class OrchestrationService {
         return this.advanceWorkflow.listAll();
     }
     reconcileChildCompletions(context) {
-        return this.childWorkflows.reconcileChildCompletions(context);
+        return this.transitionWatchChildren(context, () => this.childWorkflows.reconcileChildCompletions(context));
+    }
+    async transitionWatchChildren(context, operation) {
+        const before = await this.advanceWorkflow.listAll();
+        const result = await operation();
+        const after = new Map((await this.advanceWorkflow.listAll()).map((workflow) => [
+            workflow.workflowInstanceId,
+            workflow,
+        ]));
+        for (const prior of before) {
+            if (continuesWaitingForSameWatchGate(prior, after.get(prior.workflowInstanceId) ?? null))
+                continue;
+            const superseded = await this.childWorkflows.supersedeChildrenForWait(prior.workflowInstanceId, prior.waitingFor, context);
+            if (superseded.length > 0)
+                await this.watchChildCancellation?.cancelSupersededWatchChildren(superseded);
+        }
+        return result;
     }
     isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
         return this.childWorkflows.isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId);
@@ -90,7 +114,7 @@ export class OrchestrationService {
         return this.advanceWorkflow.listResourceTransitionMatches(event);
     }
     applyResourceTransition(workflowInstanceId, target, evidenceId, context) {
-        return this.advanceWorkflow.applyResourceTransition(workflowInstanceId, target, evidenceId, context);
+        return this.transitionWatchChildren(context, () => 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/request-child.js

@@ -1,7 +1,7 @@
 import { OrchestrationEventType } from '../contracts/events.js';
-import { signalName } from '../contracts/identifiers.js';
+import { signalName, watchId } from '../contracts/identifiers.js';
 import { childOrchestrationGroupStream } from '../contracts/streams.js';
-import { WorkflowStatus } from '../contracts/vocabulary.js';
+import { ApprovalAuthorityKind, WorkflowStatus } from '../contracts/vocabulary.js';
 import { childMetadata, childRequestId, coordinationMetadata } from '../domain/child-policy.js';
 import { coordinationDraft } from '../domain/coordination-events.js';
 import { stateDraft } from '../domain/decision-events.js';
@@ -65,6 +65,39 @@ export class RequestChild {
                 });
         }
     }
+    async supersedeChildrenForWait(parentWorkflowInstanceId, wait, context) {
+        const watchIds = watchIdsFor(wait);
+        if (watchIds.length === 0)
+            return [];
+        const children = (await this.advance.listAll()).filter((child) => child.parentWorkflowInstanceId === parentWorkflowInstanceId &&
+            child.watchId !== undefined &&
+            watchIds.includes(child.watchId) &&
+            child.status !== WorkflowStatus.Completed &&
+            child.status !== WorkflowStatus.Superseded);
+        for (const child of children) {
+            const loaded = await this.repository.loadRequired(child.workflowInstanceId);
+            if (loaded.view.status === WorkflowStatus.Completed ||
+                loaded.view.status === WorkflowStatus.Superseded)
+                continue;
+            await this.repository.append(child.workflowInstanceId, loaded.sequence, [
+                stateDraft(loaded.view, { occurredAt: context.occurredAt, causationId: context.commandId }, OrchestrationEventType.InstanceSuperseded, {}, 1),
+            ]);
+        }
+        return children.map((child) => child.workflowInstanceId);
+    }
+    async validateChildDispatch(childWorkflowInstanceId, context) {
+        const child = await this.repository.loadRequired(childWorkflowInstanceId);
+        if (child.view.parentWorkflowInstanceId === undefined)
+            return true;
+        const parent = await this.repository.loadRequired(child.view.parentWorkflowInstanceId);
+        if (child.view.watchId !== undefined && parentWaitsForWatch(parent.view, child.view.watchId))
+            return true;
+        if (child.view.status !== WorkflowStatus.Superseded)
+            await this.repository.append(childWorkflowInstanceId, child.sequence, [
+                stateDraft(child.view, { occurredAt: context.occurredAt, causationId: context.commandId }, OrchestrationEventType.InstanceSuperseded, {}, 1),
+            ]);
+        return false;
+    }
     async isCausalRepeat(workflowInstanceId, triggerId, causalCycleId, requestId) {
         const parent = await this.repository.loadRequired(workflowInstanceId);
         return (await this.advance.listAll()).some((view) => view.orchestrationGroupId === parent.view.orchestrationGroupId &&
@@ -78,6 +111,8 @@ export class RequestChild {
     }
     async complete(child, context) {
         const metadata = childMetadata(child);
+        if (child.watchId === undefined)
+            throw new Error('Child workflow is missing watch provenance');
         const childLoaded = await this.repository.loadRequired(child.workflowInstanceId);
         if (!childLoaded.view.childCompletionRecorded)
             await this.repository.append(child.workflowInstanceId, childLoaded.sequence, [
@@ -91,6 +126,7 @@ export class RequestChild {
             actorId: 'orchestration',
             actorDecision: { authorized: true, evidenceId: child.workflowInstanceId },
             providerEventId: child.workflowInstanceId,
+            authority: { kind: ApprovalAuthorityKind.Watch, watch: watchId(child.watchId) },
             childWorkflowInstanceId: child.workflowInstanceId,
             requestId: metadata.requestId,
         };
@@ -119,3 +155,14 @@ export class RequestChild {
         }, eventType, payload, ordinal);
     }
 }
+function parentWaitsForWatch(parent, watchId) {
+    if (parent.status !== WorkflowStatus.Waiting)
+        return false;
+    const watchIds = watchIdsFor(parent.waitingFor);
+    return watchIds.includes(watchId);
+}
+function watchIdsFor(wait) {
+    if (wait?.from === undefined)
+        return [];
+    return (wait.from ?? []).flatMap((authority) => authority.kind === ApprovalAuthorityKind.Watch ? [authority.watch] : []);
+}

package/dist/src/orchestration/application/watch-child-transitions.js

@@ -0,0 +1,13 @@
+import { ApprovalAuthorityKind } from '../contracts/vocabulary.js';
+export function continuesWaitingForSameWatchGate(before, after) {
+    if (before.waitingFor === undefined || after?.waitingFor === undefined)
+        return false;
+    if (before.status !== after.status ||
+        before.waitingFor.signalKind !== after.waitingFor.signalKind)
+        return false;
+    const watches = (wait) => (wait.from ?? [])
+        .filter((authority) => authority.kind === ApprovalAuthorityKind.Watch)
+        .map((authority) => authority.watch)
+        .sort();
+    return JSON.stringify(watches(before.waitingFor)) === JSON.stringify(watches(after.waitingFor));
+}

package/package.json

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