@atolis-hq/wake 0.3.36 → 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 = "g3fd5716";
+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/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.36",
+  "version": "0.3.37",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {