@atolis-hq/wake 0.3.79 → 0.3.80

package/dist/src/bootstrap/resource-transition-evidence.js

@@ -1,17 +1,27 @@
 import { ResourceCorrelationRole } from '../resources/index.js';
 export function createCapabilityResourceTransitionEvidence(input) {
+    const registrationFor = (capabilities) => input.policies.find((registration) => registration.capabilities.some((capability) => capabilities.includes(capability)));
     return {
         triggers: [...new Set(input.policies.flatMap(({ policy }) => policy.triggers))],
         async resolve(evidence) {
+            // A work item may hold several primary correlations (e.g. its
+            // originating issue and an implementation PR). Only the correlation
+            // whose resource matches a registered policy's capabilities is
+            // relevant here; the rest drop out rather than blocking resolution.
             const correlations = await input.resources.correlationsForWork(evidence.workItemId);
             const primaries = correlations.filter(({ role }) => role === ResourceCorrelationRole.Primary);
-            if (primaries.length !== 1)
+            const registrations = [];
+            for (const primary of primaries) {
+                const resource = await input.resources.get(primary.resourceId);
+                if (resource === null)
+                    continue;
+                const registration = registrationFor(resource.capabilities);
+                if (registration !== undefined)
+                    registrations.push(registration);
+            }
+            if (registrations.length !== 1)
                 return null;
-            const resource = await input.resources.get(primaries[0].resourceId);
-            if (resource === null)
-                return null;
-            const registration = input.policies.find(({ capabilities }) => capabilities.some((capability) => resource.capabilities.includes(capability)));
-            return registration?.policy.resolve(evidence) ?? null;
+            return registrations[0].policy.resolve(evidence);
         },
     };
 }

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 = "gb43010f";
+export const wakeVersion = "g3986c6c";

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

@@ -1,22 +1,36 @@
 import { ActivityOutcomeKind, BuiltInActivityName } from '../../activities/index.js';
 import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/events.js';
-import { stageName, watchId } from '../contracts/identifiers.js';
+import { signalName, stageName, watchId } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+// `then: await-human` on a `failed` route compiles its wait to this literal
+// signal name (see compileTarget); a workflow parked there has exhausted
+// whatever automatic retries it had and is durably equivalent to a blocked
+// failed stage for operator-retry purposes.
+const FailedOutcomeSignal = signalName(ActivityOutcomeKind.Failed);
 export function isOperatorRetryEligible(view) {
     const pending = view.pendingActivation;
-    const eligibleActivation = view.status === WorkflowStatus.Blocked &&
-        pending !== undefined &&
+    const eligibleActivation = pending !== undefined &&
         pending.status === ActivityActivationStatus.Completed &&
         pending.supplemental !== true &&
         pending.followOnIndex === undefined &&
         view.acceptedOutcomes.includes(pending.activationId);
     if (!eligibleActivation || pending === undefined)
         return false;
+    if (view.status === WorkflowStatus.Blocked)
+        return isRetryEligibleBlock(view, pending);
+    return isRetryEligibleFailedWait(view);
+}
+function isRetryEligibleBlock(view, pending) {
     return ((view.blockReason === 'unconfigured outcome failed' &&
         view.lastOutcome?.kind === ActivityOutcomeKind.Failed) ||
         view.executionFailure?.activationId === pending.activationId);
 }
+function isRetryEligibleFailedWait(view) {
+    return (view.status === WorkflowStatus.Waiting &&
+        view.waitingFor?.signalKind === FailedOutcomeSignal &&
+        view.lastOutcome?.kind === ActivityOutcomeKind.Failed);
+}
 export function selectOperatorRetryTarget(workflows) {
     const primary = workflows.find((workflow) => workflow.parentWorkflowInstanceId === undefined);
     if (primary === undefined)
@@ -52,7 +66,7 @@ export function requestOperatorRetry(definition, state, input) {
     if (!isOperatorRetryEligible(state))
         return {
             kind: 'ignored',
-            reason: 'workflow is not blocked for a retryable failed stage',
+            reason: 'workflow is not in a retryable failed-stage state',
         };
     const stage = definition.stages[stageName(state.currentStage)];
     const events = [

package/package.json

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