@atolis-hq/wake 0.3.40 → 0.3.42

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

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

@@ -4,7 +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';
+import { findUnresolvedSucceededTerminal, 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);
@@ -84,7 +84,8 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
             (options.workItemId === undefined || workflow.workItemId === options.workItemId)
             ? [{ workflow, activation: workflow.pendingActivation }]
             : []);
-        const recovery = await findUnresolvedTerminal([...pending, ...blocked], execution);
+        const recovery = (await findUnresolvedTerminal(pending, execution)) ??
+            (await findUnresolvedSucceededTerminal(blocked, execution));
         if (recovery !== undefined) {
             if (await isDispatchPaused())
                 return { kind: 'paused' };

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

@@ -8,6 +8,14 @@ export async function findUnresolvedTerminal(pending, execution) {
     }
     return undefined;
 }
+export async function findUnresolvedSucceededTerminal(pending, execution) {
+    for (const item of pending) {
+        const run = (await execution.list(item.activation.activationId)).find((candidate) => candidate.status === RunStatus.Succeeded && candidate.outcome !== undefined);
+        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/orchestration/application/start-workflow.js

@@ -23,8 +23,7 @@ export class StartWorkflow {
         this.definitions = definitions;
     }
     async execute(command, context) {
-        const item = await this.work.get(command.workItemId);
-        if (item === null || item.state !== WorkStatus.Open)
+        if (!(await this.isWorkItemOpen(command.workItemId)))
             throw new Error('WorkItem must exist and be open');
         const { definition, fingerprint } = this.definitions.currentDefinition(command.workflowName);
         const existing = await this.repository.load(command.workflowInstanceId);
@@ -53,6 +52,12 @@ export class StartWorkflow {
             await this.repository.append(command.workflowInstanceId, 0, decision.events);
         return (await this.repository.loadRequired(command.workflowInstanceId)).view;
     }
+    async isWorkItemOpen(workItemId) {
+        const item = await this.work.get(workItemId);
+        if (item === null || item.state !== WorkStatus.Open)
+            return false;
+        return true;
+    }
     definitionFor(view) {
         return this.definitions.resolve(view);
     }

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

@@ -4,6 +4,8 @@ import { ActivityEventType, PullRequestCheckState, selectActivityEvent, } from '
 // status, and predicate all agree with the incoming event.
 export async function matchWatches(loaded, event, workflows, context) {
     const matches = await Promise.all(loaded.map(async ({ view: parent, sequence }) => {
+        if (!(await workflows.isWorkItemOpen(parent.workItemId)))
+            return [];
         const definition = context === undefined
             ? await workflows.definitionFor(parent)
             : await workflows.definitionForOperation(parent, sequence, context);

package/package.json

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