@atolis-hq/wake 0.3.78 → 0.3.80

package/dist/src/bootstrap/composition-root.js

@@ -113,6 +113,7 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
         ids,
         dispatchPolicy: new DispatchPolicy({ maxDispatches: config.controlPlane.maxDispatches }),
         maxConcurrentRuns: config.controlPlane.maxConcurrentRuns,
+        maxDispatches: config.controlPlane.maxDispatches,
         isDispatchPaused: isRuntimePaused,
         workspaceRecovery: workspaces,
         work,

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

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

@@ -0,0 +1,109 @@
+import { ActivationClaimConflictError, RunStatus, WorkspaceMode } from '../../execution/index.js';
+import { WorkflowStatus } from '../../orchestration/index.js';
+import { isExecutionFailureTerminal } from './execution-reconciliation.js';
+/**
+ * Fills open capacity within one Advancement call: dispatches ready
+ * activations one at a time, rechecking `maxConcurrentRuns` and reselecting
+ * fresh candidates after every dispatch (per #346's capacity-recheck
+ * principle), until capacity, the per-call `maxDispatches` burst cap, or
+ * eligible candidates are exhausted. Candidates dispatched earlier in the
+ * same call are excluded from later selection via `dispatchedIds`, since
+ * their `RunStarted` event is not guaranteed visible through
+ * `execution.list()` yet.
+ */
+export async function runDispatchLoop(pending, ctx) {
+    const dispatched = [];
+    const dispatchedIds = new Set();
+    let stopReason;
+    while (dispatched.length < ctx.maxDispatches) {
+        const allRuns = await ctx.execution.list();
+        if (allRuns.filter((run) => run.status === RunStatus.Started).length >= ctx.maxConcurrentRuns) {
+            stopReason = { kind: 'no-work' };
+            break;
+        }
+        const selectedCandidate = ctx.dispatchPolicy.select(await Promise.all(pending.map(async (item, requestedPosition) => ({
+            workItemId: item.workflow.workItemId,
+            activationId: item.activation.activationId,
+            requestedPosition,
+            hasActiveRun: dispatchedIds.has(item.activation.activationId) ||
+                (await ctx.execution.list(item.activation.activationId)).some((run) => run.status === RunStatus.Started) ||
+                allRuns.some((run) => run.status === RunStatus.Started &&
+                    run.workflowInstanceId === item.workflow.workflowInstanceId &&
+                    run.workspace?.mode === WorkspaceMode.Branch),
+            cancelled: false,
+        }))))[0];
+        const selected = selectedCandidate === undefined
+            ? undefined
+            : pending.find((item) => item.activation.activationId === selectedCandidate.activationId);
+        if (selected === undefined) {
+            const waiting = (await ctx.orchestration.listWaiting()).find((view) => view !== null);
+            stopReason =
+                waiting === undefined
+                    ? { kind: 'no-work' }
+                    : { kind: WorkflowStatus.Waiting, workflowInstanceId: waiting.workflowInstanceId };
+            break;
+        }
+        // Recheck at the dispatch boundary so maintenance cannot race a selected activation.
+        if (await ctx.isDispatchPaused()) {
+            stopReason = { kind: 'paused' };
+            break;
+        }
+        if ((await ctx.orchestration.validateActivationDispatch?.(selected.workflow.workflowInstanceId, ctx.commandContext(selected.activation.activationId))) === false) {
+            stopReason = { kind: 'no-work' };
+            break;
+        }
+        await ctx.orchestration.markActivationStarted(selected.workflow.workflowInstanceId, selected.activation.activationId, ctx.commandContext(selected.activation.activationId));
+        const correlated = await ctx.resources.correlationsForWork(selected.workflow.workItemId);
+        const resourceViews = (await Promise.all(correlated.map((entry) => ctx.resources.get(entry.resourceId)))).filter((resource) => resource !== null);
+        const ineligible = await ctx.runnerIneligibility();
+        let run;
+        try {
+            run = await ctx.execution.attempt(selected.activation, {
+                workItemId: selected.workflow.workItemId,
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                orchestrationGroupId: selected.workflow.orchestrationGroupId,
+                resources: resourceViews,
+                sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
+                awaitImmediateCompletion: true,
+                ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
+            });
+        }
+        catch (error) {
+            if (error instanceof ActivationClaimConflictError) {
+                stopReason = { kind: 'no-work' };
+                break;
+            }
+            throw error;
+        }
+        if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
+            if (await ctx.isDispatchPaused()) {
+                stopReason = { kind: 'paused' };
+                break;
+            }
+            await ctx.orchestration.acceptOutcome({
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                activationId: selected.activation.activationId,
+                outcome: run.outcome,
+            }, ctx.commandContext(run.runId));
+        }
+        if (isExecutionFailureTerminal(run.status))
+            await ctx.orchestration.resolveExecutionFailure?.(selected.workflow.workflowInstanceId, {
+                activationId: selected.activation.activationId,
+                runId: run.runId,
+                reason: run.failure?.message ?? 'execution failed',
+            }, ctx.commandContext(run.runId));
+        if (run.status !== RunStatus.Succeeded && run.status !== RunStatus.Started) {
+            stopReason = {
+                kind: WorkflowStatus.Blocked,
+                workflowInstanceId: selected.workflow.workflowInstanceId,
+                reason: run.failure?.message ?? 'execution failed',
+            };
+            break;
+        }
+        dispatched.push({ activationId: selected.activation.activationId, runId: run.runId });
+        dispatchedIds.add(selected.activation.activationId);
+    }
+    return dispatched.length > 0
+        ? { kind: 'progressed', dispatched }
+        : (stopReason ?? { kind: 'no-work' });
+}

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

@@ -1,10 +1,12 @@
-import { ActivationClaimConflictError, RunStatus, WorkspaceMode } from '../../execution/index.js';
+/* eslint-disable complexity, max-lines-per-function */
+import { RunStatus } from '../../execution/index.js';
 import { correlationId, EventActorKind } from '../../kernel/index.js';
 import { isAmbiguityResolutionBlock, 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 { findUnresolvedSucceededTerminal, findUnresolvedTerminal, isExecutionFailureTerminal, } from './execution-reconciliation.js';
+import { runDispatchLoop } from './advance-once-dispatch.js';
+import { findUnresolvedSucceededTerminal, findUnresolvedTerminal, } 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);
@@ -12,6 +14,7 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
     const transcriptRetention = dependencies.transcriptRetention;
     const dispatchPolicy = dependencies.dispatchPolicy ?? new DispatchPolicy({ maxDispatches: 1 });
     const maxConcurrentRuns = dependencies.maxConcurrentRuns ?? 1;
+    const maxDispatches = dependencies.maxDispatches ?? 1;
     const context = (cause) => ({
         commandId: dependencies.ids.next('command'),
         correlationId: correlationId(cause),
@@ -100,8 +103,9 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
                 }, context(recovery.run.runId));
                 return {
                     kind: 'progressed',
-                    activationId: recovery.item.activation.activationId,
-                    runId: recovery.run.runId,
+                    dispatched: [
+                        { activationId: recovery.item.activation.activationId, runId: recovery.run.runId },
+                    ],
                 };
             }
             await orchestration.resolveExecutionFailure?.(recovery.item.workflow.workflowInstanceId, {
@@ -115,76 +119,17 @@ export function createAdvanceOnce(orchestration, execution, resources, clock, de
                 reason: recovery.run.failure?.message ?? 'execution failed',
             };
         }
-        const allRuns = await execution.list();
-        if (allRuns.filter((run) => run.status === RunStatus.Started).length >= maxConcurrentRuns)
-            return { kind: 'no-work' };
-        const selectedCandidate = dispatchPolicy.select(await Promise.all(pending.map(async (item, requestedPosition) => ({
-            workItemId: item.workflow.workItemId,
-            activationId: item.activation.activationId,
-            requestedPosition,
-            hasActiveRun: (await execution.list(item.activation.activationId)).some((run) => run.status === RunStatus.Started) ||
-                allRuns.some((run) => run.status === RunStatus.Started &&
-                    run.workflowInstanceId === item.workflow.workflowInstanceId &&
-                    run.workspace?.mode === WorkspaceMode.Branch),
-            cancelled: false,
-        }))))[0];
-        const selected = selectedCandidate === undefined
-            ? undefined
-            : pending.find((item) => item.activation.activationId === selectedCandidate.activationId);
-        if (selected === undefined) {
-            const waiting = (await orchestration.listWaiting()).find((view) => view !== null);
-            return waiting === undefined
-                ? { kind: 'no-work' }
-                : { kind: WorkflowStatus.Waiting, workflowInstanceId: waiting.workflowInstanceId };
-        }
-        // Recheck at the dispatch boundary so maintenance cannot race a selected activation.
-        if (await isDispatchPaused())
-            return { kind: 'paused' };
-        if ((await orchestration.validateActivationDispatch?.(selected.workflow.workflowInstanceId, context(selected.activation.activationId))) === false)
-            return { kind: 'no-work' };
-        await orchestration.markActivationStarted(selected.workflow.workflowInstanceId, selected.activation.activationId, context(selected.activation.activationId));
-        const correlated = await resources.correlationsForWork(selected.workflow.workItemId);
-        const resourceViews = (await Promise.all(correlated.map((entry) => resources.get(entry.resourceId)))).filter((resource) => resource !== null);
-        const ineligible = await runnerIneligibility();
-        let run;
-        try {
-            run = await execution.attempt(selected.activation, {
-                workItemId: selected.workflow.workItemId,
-                workflowInstanceId: selected.workflow.workflowInstanceId,
-                orchestrationGroupId: selected.workflow.orchestrationGroupId,
-                resources: resourceViews,
-                sessionPolicy: selected.workflow.parentWorkflowInstanceId === undefined ? 'resume-stage' : 'fresh',
-                awaitImmediateCompletion: true,
-                ...(ineligible.size === 0 ? {} : { ineligibleRunners: ineligible }),
-            });
-        }
-        catch (error) {
-            if (error instanceof ActivationClaimConflictError)
-                return { kind: 'no-work' };
-            throw error;
-        }
-        if (run.status === RunStatus.Succeeded && run.outcome !== undefined) {
-            if (await isDispatchPaused())
-                return { kind: 'paused' };
-            await orchestration.acceptOutcome({
-                workflowInstanceId: selected.workflow.workflowInstanceId,
-                activationId: selected.activation.activationId,
-                outcome: run.outcome,
-            }, context(run.runId));
-        }
-        if (isExecutionFailureTerminal(run.status))
-            await orchestration.resolveExecutionFailure?.(selected.workflow.workflowInstanceId, {
-                activationId: selected.activation.activationId,
-                runId: run.runId,
-                reason: run.failure?.message ?? 'execution failed',
-            }, context(run.runId));
-        return run.status === RunStatus.Succeeded || run.status === RunStatus.Started
-            ? { kind: 'progressed', activationId: selected.activation.activationId, runId: run.runId }
-            : {
-                kind: WorkflowStatus.Blocked,
-                workflowInstanceId: selected.workflow.workflowInstanceId,
-                reason: run.failure?.message ?? 'execution failed',
-            };
+        return runDispatchLoop(pending, {
+            orchestration,
+            execution,
+            resources,
+            dispatchPolicy,
+            maxConcurrentRuns,
+            maxDispatches,
+            runnerIneligibility,
+            isDispatchPaused,
+            commandContext: context,
+        });
     };
     // Tick, resident, and API callers share this advancement instance. Serialize the
     // capacity check through Run creation so concurrent callers cannot over-dispatch.

package/dist/src/control-plane/infrastructure/intake-host.js

@@ -2,8 +2,8 @@ import { HostStopReason } from '../contracts/commands.js';
 /**
  * Bounded host for IntakePipeline. Unlike TickHost, one cycle is always
  * exactly one poll-and-translate pass — there's no Advancement to loop
- * within a budget, and AdvanceResult's `progressed` variant requires an
- * activationId/runId that intake has no honest value for. ResidentHost
+ * within a budget, and AdvanceResult's `progressed` variant requires a
+ * dispatched batch that intake has no honest value for. ResidentHost
  * only needs `advances > 0` to decide whether its next sleep resets to the
  * fast end of backoff, which `processed` maps onto directly.
  */

package/dist/src/control-plane/infrastructure/tick-host.js

@@ -15,7 +15,7 @@ export class TickHost {
             const result = await this.advance({ maxProgress: 1 });
             if (result.kind === 'progressed') {
                 advances += 1;
-                runs += 1;
+                runs += result.dispatched.length;
                 continue;
             }
             return {

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.78",
+  "version": "0.3.80",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {