@atolis-hq/wake 0.3.7 → 0.3.8

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 = "g3a1ec02";
+export const wakeVersion = "g42cf498";

package/dist/src/integrations/github/application/inbound-review-signals.js

@@ -101,6 +101,7 @@ async function applyIssueApprovalSignal(input) {
         orchestration,
         resourceId: resourceIdValue,
         outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
+        resumeBlockedOnChanges: command === '/changes',
     });
 }
 async function applyPullRequestWorkflowSignal(input) {
@@ -125,25 +126,28 @@ async function applyPullRequestWorkflowSignal(input) {
     });
 }
 async function applyWorkflowSignal(input) {
-    const { event, resources, orchestration, resourceId: resourceIdValue, outcome } = input;
+    const { event, resources, orchestration, resourceId: resourceIdValue, outcome, 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)
-            continue;
-        await orchestration.acceptSignal(workflow.workflowInstanceId, {
-            kind: workflow.waitingFor.signalKind,
-            outcome,
-            actorId: event.payload.actor.id,
-            actorDecision: {
-                authorized: event.payload.actor.kind === ReviewActorKind.Human,
-                evidenceId: event.eventId,
-            },
-            providerEventId: event.eventId,
-        }, commandContext(event));
+        if (workflow.waitingFor !== undefined) {
+            await orchestration.acceptSignal(workflow.workflowInstanceId, {
+                kind: workflow.waitingFor.signalKind,
+                outcome,
+                actorId: event.payload.actor.id,
+                actorDecision: {
+                    authorized: event.payload.actor.kind === ReviewActorKind.Human,
+                    evidenceId: event.eventId,
+                },
+                providerEventId: event.eventId,
+            }, commandContext(event));
+        }
+        else if (resumeBlockedOnChanges) {
+            await orchestration.resumeBlockedStageForChanges(workflow.workflowInstanceId, commandContext(event));
+        }
     }
 }
 function isWakeDelivery(body) {

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

@@ -4,7 +4,7 @@ import { OrchestrationEventType } from '../contracts/events.js';
 import { commandName, workflowInstanceId, } from '../contracts/identifiers.js';
 import { workflowInstanceStream } from '../contracts/streams.js';
 import { WorkflowStatus } from '../contracts/vocabulary.js';
-import { requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
+import { requestChangesResume as decideChangesResume, requestOperatorRetry as decideOperatorRetry, requestSupplementalActivity as decideSupplementalActivity, } from '../domain/interpreter.js';
 import { isAuthorisedActor } from '../domain/supplemental-policy.js';
 export class OperatorRetryIneligibleError extends Error {
     constructor(detail) {
@@ -136,6 +136,33 @@ export class AdvanceWorkflow {
         }
         return (await this.repository.loadRequired(id)).view;
     }
+    async resumeBlockedStageForChanges(id, context) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null)
+            return null;
+        if (loaded.view.operatorRetryCommandIds.includes(context.commandId))
+            return loaded.view;
+        const definition = await this.workflows.definitionForOperation(loaded.view, loaded.sequence, context);
+        if (definition === null)
+            return (await this.repository.loadRequired(id)).view;
+        const decision = decideChangesResume(definition, loaded.view, {
+            commandId: context.commandId,
+            occurredAt: context.occurredAt,
+            causationId: context.commandId,
+        });
+        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;
+        }
+        return (await this.repository.loadRequired(id)).view;
+    }
     async get(id) {
         return (await this.repository.load(id)).view;
     }

package/dist/src/orchestration/application/orchestration-service.js

@@ -55,6 +55,9 @@ export class OrchestrationService {
     retryBlockedFailedStage(workflowInstanceId, context) {
         return this.advanceWorkflow.retryBlockedFailedStage(workflowInstanceId, context);
     }
+    resumeBlockedStageForChanges(workflowInstanceId, context) {
+        return this.advanceWorkflow.resumeBlockedStageForChanges(workflowInstanceId, context);
+    }
     get(id) {
         return this.advanceWorkflow.get(id);
     }

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

@@ -10,7 +10,7 @@ import { finishRoute } from './transition.js';
 export { startInstance } from './activation-policy.js';
 export { acceptSignal, waitForSignal } from './signal-policy.js';
 export { requestSupplementalActivity } from './supplemental-policy.js';
-export { isOperatorRetryEligible, requestOperatorRetry } from './operator-retry-policy.js';
+export { isChangesResumeEligible, isOperatorRetryEligible, requestChangesResume, requestOperatorRetry, } from './operator-retry-policy.js';
 export function acceptActivityOutcome(definition, state, input) {
     if (!isPendingOutcome(state, input))
         return { kind: 'ignored', reason: 'outcome is not for the pending activation' };

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

@@ -1,4 +1,4 @@
-import { ActivityOutcomeKind } from '../../activities/index.js';
+import { ActivityOutcomeKind, BuiltInActivityName } from '../../activities/index.js';
 import { OrchestrationEventType } from '../contracts/events.js';
 import { stageName } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, WorkflowStatus } from '../contracts/vocabulary.js';
@@ -14,6 +14,18 @@ export function isOperatorRetryEligible(view) {
         view.lastOutcome?.kind === ActivityOutcomeKind.Failed &&
         view.acceptedOutcomes.includes(pending.activationId));
 }
+export function isChangesResumeEligible(view) {
+    const pending = view.pendingActivation;
+    return (view.status === WorkflowStatus.Blocked &&
+        view.blockReason === 'unconfigured outcome blocked' &&
+        pending !== undefined &&
+        pending.activity === BuiltInActivityName.Agent &&
+        pending.status === ActivityActivationStatus.Completed &&
+        pending.supplemental !== true &&
+        pending.followOnIndex === undefined &&
+        view.lastOutcome?.kind === ActivityOutcomeKind.Blocked &&
+        view.acceptedOutcomes.includes(pending.activationId));
+}
 export function requestOperatorRetry(definition, state, input) {
     if (input.commandId.length === 0)
         return { kind: 'ignored', reason: 'operator retry command id is required' };
@@ -32,3 +44,23 @@ export function requestOperatorRetry(definition, state, input) {
     ];
     return { kind: 'append', events };
 }
+export function requestChangesResume(definition, state, input) {
+    if (input.commandId.length === 0)
+        return { kind: 'ignored', reason: 'changes resume command id is required' };
+    if (!isChangesResumeEligible(state))
+        return {
+            kind: 'ignored',
+            reason: 'workflow is not blocked for an unconfigured agent blocked outcome',
+        };
+    const stage = definition.stages[stageName(state.currentStage)];
+    return {
+        kind: 'append',
+        events: [
+            stateDraft(state, input, OrchestrationEventType.OperatorRetryRequested, { activationId: state.pendingActivation.activationId, commandId: input.commandId }, 1),
+            stateDraft(state, input, OrchestrationEventType.ActivityRequested, activation(state.workflowInstanceId, nextOrdinal(state), stage.activity, stage.with, {
+                execution: stage.execution,
+                stage: stageName(state.currentStage),
+            }), 2),
+        ],
+    };
+}

package/package.json

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