@atolis-hq/wake 0.3.25 → 0.3.26

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 = "g5d24549";
+export const wakeVersion = "g883e6ff";

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

@@ -5,6 +5,7 @@ import { workflowInstanceStream } from '../contracts/streams.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
 import { requestChangesResume as decideChangesResume, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
 import { isAuthorisedActor } from '../domain/supplemental-policy.js';
+import { appendWithIntentRecovery } from './durable-append.js';
 import { acceptResourceTransition, matchResourceTransitions, } from './resource-transition-matching.js';
 import { matchWatches } from './watch-matching.js';
 export class OperatorRetryIneligibleError extends Error {
@@ -126,15 +127,15 @@ export class AdvanceWorkflow {
         });
         if (decision.kind === 'ignored')
             throw new OperatorRetryIneligibleError(decision.reason);
-        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;
-        }
+        const recovered = await appendWithIntentRecovery({
+            append: async () => {
+                await this.repository.append(id, loaded.sequence, decision.events);
+            },
+            load: () => this.repository.loadRequired(id),
+            alreadyApplied: (reloaded) => reloaded.view.operatorRetryCommandIds.includes(context.commandId),
+        });
+        if (recovered !== undefined)
+            return recovered.view;
         return (await this.repository.loadRequired(id)).view;
     }
     async resumeBlockedStageForChanges(id, context) {
@@ -153,15 +154,15 @@ export class AdvanceWorkflow {
         });
         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;
-        }
+        const recovered = await appendWithIntentRecovery({
+            append: async () => {
+                await this.repository.append(id, loaded.sequence, decision.events);
+            },
+            load: () => this.repository.loadRequired(id),
+            alreadyApplied: (reloaded) => reloaded.view.operatorRetryCommandIds.includes(context.commandId),
+        });
+        if (recovered !== undefined)
+            return recovered.view;
         return (await this.repository.loadRequired(id)).view;
     }
     async get(id) {

package/dist/src/orchestration/application/coordination-claims.js

@@ -1,7 +1,8 @@
-import { createEventDraft, EventSourceKind, WrongExpectedSequenceError, } from '../../kernel/index.js';
+import { createEventDraft, EventSourceKind, } from '../../kernel/index.js';
 import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 import { isOrchestrationGroupStream, primaryOrchestrationGroupStream, } from '../contracts/streams.js';
+import { claimWithCasRetry } from './durable-append.js';
 export class CoordinationClaims {
     journal;
     constructor(journal) {
@@ -9,16 +10,19 @@ export class CoordinationClaims {
     }
     async claimPrimary(workItemId, workflowInstanceId, context) {
         const stream = primaryOrchestrationGroupStream(workItemId);
-        for (;;) {
-            const events = await this.journal.readStream(stream);
-            const owner = primaryOwner(groupEvents(events));
-            if (owner !== undefined) {
+        await claimWithCasRetry({
+            read: () => this.journal.readStream(stream),
+            decode: groupEvents,
+            alreadyClaimed: (events) => {
+                const owner = primaryOwner(events);
+                if (owner === undefined)
+                    return false;
                 if (owner === workflowInstanceId)
-                    return;
+                    return true;
                 throw new Error(`WorkItem already has an active primary workflow owned by ${owner}`);
-            }
-            try {
-                await this.journal.append(stream, events.length, [
+            },
+            append: async (sequence) => {
+                await this.journal.append(stream, sequence, [
                     createEventDraft({
                         eventId: `${context.commandId}:${OrchestrationEventType.PrimaryClaimed}:${workItemId}`,
                         eventType: OrchestrationEventType.PrimaryClaimed,
@@ -31,26 +35,23 @@ export class CoordinationClaims {
                         payload: { workItemId, workflowInstanceId },
                     }),
                 ]);
-                return;
-            }
-            catch (error) {
-                if (!(error instanceof WrongExpectedSequenceError))
-                    throw error;
-            }
-        }
+            },
+        });
     }
     async primaryWorkflowInstanceId(workItemId) {
         return primaryOwner(groupEvents(await this.journal.readStream(primaryOrchestrationGroupStream(workItemId))));
     }
     async claimWithinBudget(stream, request, context) {
-        for (;;) {
-            const events = await this.journal.readStream(stream);
-            if (claimedRequestIds(groupEvents(events)).has(request.requestId))
-                return true;
-            if (events.length >= request.maxPerGroup)
-                return false;
-            try {
-                await this.journal.append(stream, events.length, [
+        const existing = groupEvents(await this.journal.readStream(stream));
+        if (claimedRequestIds(existing).has(request.requestId))
+            return true;
+        const claimed = await claimWithCasRetry({
+            read: () => this.journal.readStream(stream),
+            decode: groupEvents,
+            alreadyClaimed: (events) => claimedRequestIds(events).has(request.requestId),
+            canAppend: (events) => events.length < request.maxPerGroup,
+            append: async (sequence) => {
+                await this.journal.append(stream, sequence, [
                     createEventDraft({
                         eventId: `${context.commandId}:${OrchestrationEventType.GroupClaimed}:${request.requestId}`,
                         eventType: OrchestrationEventType.GroupClaimed,
@@ -63,13 +64,11 @@ export class CoordinationClaims {
                         payload: { key: stream.id, requestId: request.requestId },
                     }),
                 ]);
-                return true;
-            }
-            catch (error) {
-                if (!(error instanceof WrongExpectedSequenceError))
-                    throw error;
-            }
-        }
+            },
+        });
+        if (claimed)
+            return true;
+        return claimedRequestIds(groupEvents(await this.journal.readStream(stream))).has(request.requestId);
     }
 }
 function primaryOwner(events) {

package/dist/src/orchestration/application/durable-append.js

@@ -0,0 +1,36 @@
+import { WrongExpectedSequenceError } from '../../kernel/index.js';
+/** Recover a competing append only when the caller's durable intent is now visible. */
+export async function appendWithIntentRecovery(input) {
+    try {
+        await input.append();
+        return undefined;
+    }
+    catch (error) {
+        const reloaded = await input.load();
+        if (input.alreadyApplied(reloaded))
+            return reloaded;
+        throw error;
+    }
+}
+/**
+ * Append a single claim with optimistic concurrency. The claim is inspected
+ * before every append, so a losing racer terminates on its next read.
+ */
+export async function claimWithCasRetry(input) {
+    for (;;) {
+        const events = await input.read();
+        const decoded = input.decode(events);
+        if (input.alreadyClaimed(decoded))
+            return false;
+        if (input.canAppend?.(events, decoded) === false)
+            return false;
+        try {
+            await input.append(events.length);
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof WrongExpectedSequenceError))
+                throw error;
+        }
+    }
+}

package/dist/src/orchestration/application/resource-transition-matching.js

@@ -1,17 +1,14 @@
-import { OrchestrationEventType } from '../contracts/events.js';
-import { isWorkflowInstanceStream } from '../contracts/streams.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
 import { acceptSignal as decideSignal } from '../domain/interpreter.js';
+import { appendWithIntentRecovery } from './durable-append.js';
+import { resolveTriggerWorkflowInstanceId } from './trigger-workflow-instance.js';
 // Generic: no resource-kind knowledge lives here. A `signal-wait-started`
 // trigger on the instance's own stream returns every declared transition
 // unfiltered, so the reactor's evidence policy can check prior journal
 // history for a fact that arrived before the wait began. Any other event
 // is matched against each instance's declared predicates directly.
-export function matchResourceTransitions(loaded, event) {
-    const waitStart = event.eventType === OrchestrationEventType.SignalWaitStarted &&
-        isWorkflowInstanceStream(event.stream)
-        ? event.stream.id
-        : undefined;
+export async function matchResourceTransitions(loaded, event) {
+    const waitStart = await resolveTriggerWorkflowInstanceId(event, undefined);
     return loaded.flatMap(({ view }) => {
         if (view.status !== WorkflowStatus.Waiting)
             return [];
@@ -67,17 +64,17 @@ export async function acceptResourceTransition(repository, workflows, id, target
         consent: true,
     });
     if (decision.kind === 'append') {
-        try {
-            await repository.append(id, loaded.sequence, decision.events);
-        }
-        catch (error) {
-            const reloaded = await repository.load(id);
-            if (reloaded.view !== null &&
+        const recovered = await appendWithIntentRecovery({
+            append: async () => {
+                await repository.append(id, loaded.sequence, decision.events);
+            },
+            load: () => repository.load(id),
+            alreadyApplied: (reloaded) => reloaded.view !== null &&
                 (reloaded.view.acceptedSignalIds.includes(evidenceId) ||
-                    reloaded.view.waitingFor === undefined))
-                return reloaded.view;
-            throw error;
-        }
+                    reloaded.view.waitingFor === undefined),
+        });
+        if (recovered !== undefined)
+            return recovered.view;
     }
     return (await repository.load(id)).view;
 }

package/dist/src/orchestration/application/trigger-workflow-instance.js

@@ -0,0 +1,20 @@
+import { selectRunExecutionEvent } from '../../execution/index.js';
+import { OrchestrationEventType } from '../contracts/events.js';
+import { isWorkflowInstanceStream } from '../contracts/streams.js';
+/**
+ * Resolve the one instance an event belongs to, when it has one. Run events
+ * inherit their scope from the run. `ChildCompleted` deliberately does not:
+ * it is a cross-instance coordination fact and stream-scoping it would hide
+ * valid parent/child coordination from other eligible instances.
+ */
+export async function resolveTriggerWorkflowInstanceId(event, runs) {
+    if (event.eventType === OrchestrationEventType.SignalWaitStarted &&
+        isWorkflowInstanceStream(event.stream))
+        return event.stream.id;
+    if (runs === undefined)
+        return undefined;
+    const runEvent = selectRunExecutionEvent(event);
+    if (runEvent === null)
+        return undefined;
+    return (await runs.load(runEvent.stream.id)).view?.workflowInstanceId;
+}

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

@@ -1,9 +1,7 @@
-import { selectRunExecutionEvent } from '../../execution/index.js';
 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 { isWorkflowInstanceStream } from '../contracts/streams.js';
+import { resolveTriggerWorkflowInstanceId } from './trigger-workflow-instance.js';
 const checkpoint = 'reactor:orchestration.watch';
 export function createWatchReactor(orchestration, journal, checkpoints, runs) {
     return {
@@ -57,36 +55,6 @@ function commandContext(event) {
         actor: { kind: EventActorKind.System, id: 'watch-reactor' },
     };
 }
-/**
- * A run-lifecycle event (e.g. `execution.run-succeeded`) fires for every run
- * in the system, including a watch's own spawned child re-running its own
- * activity on retry. Without scoping, `listWatchMatches` would treat any
- * currently-eligible parent's declared event type as a match regardless of
- * which run actually produced it, causing a child's own retry (or an
- * unrelated workflow's run) to spuriously re-trigger the same watch.
- *
- * For orchestration events, only `SignalWaitStarted` is scoped to its
- * stream's instance; this is currently the only orchestration event type
- * known to benefit from stream-based filtering. Other orchestration events
- * like `ChildCompleted` are cross-instance coordination facts by design and
- * must fall through unchanged to the async resolver to preserve their
- * existing multi-instance coordination paths.
- */
-async function resolveTriggerWorkflowInstanceId(event, runs) {
-    if (event.eventType === OrchestrationEventType.SignalWaitStarted &&
-        isWorkflowInstanceStream(event.stream))
-        return event.stream.id;
-    return resolveRunWorkflowInstanceId(event, runs);
-}
-async function resolveRunWorkflowInstanceId(event, runs) {
-    if (runs === undefined)
-        return undefined;
-    const runEvent = selectRunExecutionEvent(event);
-    if (runEvent === null)
-        return undefined;
-    const run = (await runs.load(runEvent.stream.id)).view;
-    return run?.workflowInstanceId;
-}
 function orchestrationCausalCycleId(event) {
     return event !== null && 'causalCycleId' in event.payload
         ? event.payload.causalCycleId

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

@@ -98,6 +98,7 @@ function compileStage(context, rawStageName, stage, allStages) {
         const effectiveAwait = defaultApprovalAwait(stage, outcomeKind, route);
         const compiled = Object.freeze({
             target,
+            reentryTarget: { kind: TransitionTargetKind.Stage, stage: stageName(rawStageName) },
             ...(route.repeat === undefined ? {} : { repeat: route.repeat }),
             ...(route.retry === undefined ? {} : { retry: route.retry }),
             ...(followOns === undefined ? {} : { activities: Object.freeze(followOns) }),

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

@@ -24,23 +24,14 @@ export function acceptSignal(definition, state, input) {
     const events = [
         stateDraft(state, input, OrchestrationEventType.SignalAccepted, { ...signal, authority }, 1),
     ];
-    if (signal.outcome === ActivityOutcomeKind.Rejected) {
-        if (expected.onRejectResume !== undefined) {
-            resumeToTarget(events, definition, state, input, expected.onRejectResume);
-        }
-        else {
-            requestCurrentStage(events, definition, state, input);
-        }
-    }
-    else if (expected.resume !== undefined) {
-        resumeToTarget(events, definition, state, input, expected.resume);
-    }
-    else {
-        requestCurrentStage(events, definition, state, input);
-    }
+    const target = signal.outcome === ActivityOutcomeKind.Rejected ? expected.onRejectResume : expected.resume;
+    if (target !== undefined)
+        resumeToTarget(events, definition, state, input, target);
+    else
+        requestLegacyReentry(events, definition, state, input);
     return { kind: 'append', events };
 }
-function requestCurrentStage(events, definition, state, input) {
+function requestLegacyReentry(events, definition, state, input) {
     const stage = definition.stages[stageName(state.currentStage)];
     events.push(stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), stage.activity, stage.with, {
         execution: stage.execution,

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

@@ -2,7 +2,7 @@ import { OrchestrationEventType, ResourceTransitionSignal, WatchGateVerdictSigna
 import { ApprovalAuthorityKind, TransitionTargetKind } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
 // Route completion combines the mutually exclusive wait, await, and target policies.
-// eslint-disable-next-line complexity
+// eslint-disable-next-line complexity, max-lines-per-function
 export function finishRoute(events, definition, state, input, route) {
     if (route.watchGates !== undefined || route.resourceTransitions !== undefined) {
         const gate = route.watchGates?.[0];
@@ -25,7 +25,12 @@ export function finishRoute(events, definition, state, input, route) {
         return;
     }
     if (route.await !== undefined) {
-        events.push(stateDraft(state, input, OrchestrationEventType.SignalWaitStarted, { signalKind: route.await.signal, from: route.await.from, resume: route.await.resume }, events.length + 1));
+        events.push(stateDraft(state, input, OrchestrationEventType.SignalWaitStarted, {
+            signalKind: route.await.signal,
+            from: route.await.from,
+            resume: route.await.resume,
+            onRejectResume: route.reentryTarget,
+        }, events.length + 1));
         return;
     }
     if (route.target.kind !== TransitionTargetKind.Stage) {

package/dist/src/orchestration/index.js

@@ -2,12 +2,14 @@ export * from './application/orchestration-projection.js';
 export * from './application/orchestration-repository.js';
 export * from './application/orchestration-service.js';
 export * from './application/advance-workflow.js';
+export * from './application/durable-append.js';
 export * from './application/pull-request-transition-evidence.js';
 export * from './application/resource-transition-evidence.js';
 export * from './application/resource-transition-matching.js';
 export * from './application/resource-transition-reactor.js';
 export * from './application/signal-reactor.js';
 export * from './application/watch-reactor.js';
+export * from './application/trigger-workflow-instance.js';
 export * from './application/workflow-definition-registry.js';
 export * from './contracts/activity-outcome.js';
 export * from './contracts/commands.js';

package/package.json

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