@atolis-hq/wake 0.3.38 → 0.3.40

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

@@ -151,6 +151,7 @@ export async function composeIntegrationRuntime(input) {
         },
         react: async () => {
             await watch.runOnce();
+            await watch.reconcileOnce();
             await resourceTransitions.runOnce();
             await artifacts.runOnce();
             await outcomes.runOnce();

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 = "gf357dfb";
+export const wakeVersion = "gfda2868";

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

@@ -1,39 +1,46 @@
 import { correlationId, EventActorKind, } from '../../kernel/index.js';
 import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
+import { OrchestrationEventType, } from '../contracts/events.js';
 import { workflowInstanceId, workflowName, } from '../contracts/identifiers.js';
+import { workflowInstanceStream } from '../contracts/streams.js';
+import { ApprovalAuthorityKind } from '../contracts/vocabulary.js';
 import { resolveTriggerWorkflowInstanceId } from './trigger-workflow-instance.js';
 const checkpoint = 'reactor:orchestration.watch';
+const reconciliationCheckpoint = 'reconciler:orchestration.watch';
 export function createWatchReactor(orchestration, journal, checkpoints, runs) {
     return {
         async react(event, context) {
-            const causalCycle = orchestrationCausalCycleId(selectOrchestrationEvent(event));
-            const sourceWorkflowInstanceId = await resolveTriggerWorkflowInstanceId(event, runs);
-            for (const match of await orchestration.listWatchMatches(event, context)) {
-                if (sourceWorkflowInstanceId !== undefined &&
-                    match.parent.workflowInstanceId !== sourceWorkflowInstanceId)
-                    continue;
-                const requestId = workflowInstanceId(`${match.parent.workflowInstanceId}:watch:${match.watch.id}:trigger:${event.eventId}`);
-                const request = {
-                    parentWorkflowInstanceId: match.parent.workflowInstanceId,
-                    watchId: match.watch.id,
-                    triggerId: event.eventId,
-                    workflowName: workflowName(match.watch.workflow),
-                    causalCycleId: causalCycle ?? requestId,
-                    requestId,
-                    maxPerGroup: match.watch.maxPerGroup,
-                };
-                const requestContext = {
-                    ...context,
-                    commandId: watchCommandId(context, match, event),
-                };
-                if ((await orchestration.isCausalRepeat?.(match.parent.workflowInstanceId, event.eventId, causalCycle, request.requestId)) === true) {
-                    await orchestration.rejectCausalActivation(request, requestContext);
-                    continue;
+            await dispatch(orchestration, runs, event, context, await orchestration.listWatchMatches(event, context));
+        },
+        async reconcileOnce(limit = 100) {
+            if (journal === undefined || checkpoints === undefined)
+                throw new Error('WatchReactor journal and checkpoints are required to reconcile');
+            if (orchestration.listWaiting === undefined)
+                throw new Error('WatchReactor listWaiting is required to reconcile');
+            const events = await journal.readAll(await checkpoints.load(reconciliationCheckpoint), limit);
+            const waiting = new Map((await orchestration.listWaiting()).map((parent) => [
+                parent.workflowInstanceId,
+                new Set((parent.waitingFor?.from ?? []).flatMap((authority) => authority.kind === ApprovalAuthorityKind.Watch && authority.watch !== undefined
+                    ? [authority.watch]
+                    : [])),
+            ]));
+            let reconciled = 0;
+            for (const event of events) {
+                const context = commandContext(event);
+                const matches = (await Promise.all((await orchestration.listWatchMatches(event, context)).map(async (match) => {
+                    const watches = waiting.get(match.parent.workflowInstanceId);
+                    return watches?.has(match.watch.id) === true &&
+                        !(await hasDurableWatchOutcome(orchestration, journal, match, event.eventId))
+                        ? match
+                        : null;
+                }))).filter((match) => match !== null);
+                if (matches.length > 0) {
+                    await dispatch(orchestration, runs, event, context, matches);
+                    reconciled += 1;
                 }
-                const result = await orchestration.requestChild(request, requestContext);
-                if (result === undefined || result === null)
-                    throw new Error(`Watch child request ${request.requestId} did not complete durably`);
+                await checkpoints.save(reconciliationCheckpoint, event.globalPosition);
             }
+            return reconciled;
         },
         async runOnce(limit = 100) {
             if (journal === undefined || checkpoints === undefined)
@@ -47,6 +54,45 @@ export function createWatchReactor(orchestration, journal, checkpoints, runs) {
         },
     };
 }
+async function dispatch(orchestration, runs, event, context, matches) {
+    const causalCycle = orchestrationCausalCycleId(selectOrchestrationEvent(event));
+    const sourceWorkflowInstanceId = await resolveTriggerWorkflowInstanceId(event, runs);
+    for (const match of matches) {
+        if (sourceWorkflowInstanceId !== undefined &&
+            match.parent.workflowInstanceId !== sourceWorkflowInstanceId)
+            continue;
+        const requestId = workflowInstanceId(`${match.parent.workflowInstanceId}:watch:${match.watch.id}:trigger:${event.eventId}`);
+        const request = {
+            parentWorkflowInstanceId: match.parent.workflowInstanceId,
+            watchId: match.watch.id,
+            triggerId: event.eventId,
+            workflowName: workflowName(match.watch.workflow),
+            causalCycleId: causalCycle ?? requestId,
+            requestId,
+            maxPerGroup: match.watch.maxPerGroup,
+        };
+        const requestContext = { ...context, commandId: watchCommandId(context, match, event) };
+        if ((await orchestration.isCausalRepeat?.(match.parent.workflowInstanceId, event.eventId, causalCycle, request.requestId)) === true) {
+            await orchestration.rejectCausalActivation(request, requestContext);
+            continue;
+        }
+        const result = await orchestration.requestChild(request, requestContext);
+        if (result === undefined || result === null)
+            throw new Error(`Watch child request ${request.requestId} did not complete durably`);
+    }
+}
+async function hasDurableWatchOutcome(orchestration, journal, match, triggerId) {
+    const requestId = workflowInstanceId(`${match.parent.workflowInstanceId}:watch:${match.watch.id}:trigger:${triggerId}`);
+    const child = await orchestration.get?.(requestId);
+    if (child !== undefined && child !== null)
+        return true;
+    const parentEvents = await journal.readStream(workflowInstanceStream(match.parent.workflowInstanceId));
+    return parentEvents.some((event) => {
+        const owned = selectOrchestrationEvent(event);
+        return (owned?.eventType === OrchestrationEventType.GroupBudgetExhausted &&
+            owned.payload.requestId === requestId);
+    });
+}
 function commandContext(event) {
     return {
         commandId: `${event.eventId}:watch`,

package/package.json

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