@atolis-hq/wake 0.3.77 → 0.3.79

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/surface-api-execution-applications.js

@@ -4,7 +4,7 @@ import { correlationId, EventActorKind } from '../kernel/index.js';
 import { ApiCommandStatus, presentRun } from '../surfaces/index.js';
 import { projectionMeta, sampledMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
-import { withWorkflowContext } from './surface-api-run-context.js';
+import { enrichRun } from './surface-api-run-context.js';
 import { readWorkTranscript } from './surface-api-transcripts.js';
 export function createExecutionApplications(root, now) {
     return {
@@ -43,7 +43,7 @@ export function createExecutionApplications(root, now) {
             });
             return {
                 ...page,
-                items: await Promise.all(page.items.map((item) => withWorkflowContext(root, item))),
+                items: await Promise.all(page.items.map((item) => enrichRun(root, item))),
             };
         },
         async get(runId) {
@@ -51,7 +51,7 @@ export function createExecutionApplications(root, now) {
             if (stored?.value.view == null)
                 return undefined;
             return {
-                data: await withWorkflowContext(root, presentRun(stored.value.view)),
+                data: await enrichRun(root, presentRun(stored.value.view)),
                 meta: await projectionMeta(root.journal, [stored], now()),
             };
         },

package/dist/src/bootstrap/surface-api-run-context.js

@@ -1,5 +1,49 @@
+import { ActivityOutcomeKind } from '../activities/index.js';
+import { DeliveryState, IntegrationStreamKind, } from '../integrations/index.js';
 import { workflowInstanceId } from '../orchestration/index.js';
 export async function withWorkflowContext(root, run) {
     const instance = await root.orchestration.get(workflowInstanceId(run.workflowInstanceId));
     return instance === null ? run : { ...run, workflowName: instance.workflowName };
 }
+const deliveryResolutionSentinels = {
+    [DeliveryState.Confirmed]: 'DONE',
+    [DeliveryState.Failed]: 'FAILED',
+    [DeliveryState.Ambiguous]: 'AMBIGUOUS',
+};
+/**
+ * A run whose own outcome was `waiting` on a delivery is frozen at that
+ * sentinel forever (the run itself never re-fires once terminal). Join it
+ * against the delivery intent it named to surface how that delivery has
+ * since resolved, without rewriting the run's own history.
+ */
+export async function withDeliveryResolution(root, run) {
+    const intentEventId = waitingDeliveryIntentEventId(run);
+    if (intentEventId === undefined)
+        return run;
+    const stored = await root.projections.read(IntegrationStreamKind.Delivery, intentEventId);
+    const delivery = stored?.value;
+    if (delivery === undefined || delivery.resolvedAt === undefined)
+        return run;
+    const sentinel = deliveryResolutionSentinels[delivery.state];
+    return sentinel === undefined
+        ? run
+        : { ...run, resolution: { sentinel, resolvedAt: delivery.resolvedAt } };
+}
+/** Full read-time enrichment applied to every presented run. */
+export async function enrichRun(root, run) {
+    return withDeliveryResolution(root, await withWorkflowContext(root, run));
+}
+function waitingDeliveryIntentEventId(run) {
+    if (typeof run.outcome !== 'object' || run.outcome === null)
+        return undefined;
+    if (Reflect.get(run.outcome, 'kind') !== ActivityOutcomeKind.Waiting)
+        return undefined;
+    const data = Reflect.get(run.outcome, 'data');
+    if (typeof data !== 'object' || data === null)
+        return undefined;
+    const intentEventId = Reflect.get(data, 'intentEventId');
+    const signalKind = Reflect.get(data, 'signalKind');
+    return typeof intentEventId === 'string' && signalKind === 'delivery-result'
+        ? intentEventId
+        : undefined;
+}

package/dist/src/bootstrap/surface-api-work-applications.js

@@ -8,7 +8,7 @@ import { workItemId, WorkStatus } from '../work/index.js';
 import { primaryExternalRef } from './external-ref.js';
 import { projectionMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
-import { withWorkflowContext } from './surface-api-run-context.js';
+import { enrichRun } from './surface-api-run-context.js';
 import { readWorkTranscript, transcriptGroups } from './surface-api-transcripts.js';
 export function createSurfaceWorkApplications(root, now) {
     return {
@@ -115,7 +115,7 @@ async function workDetail(root, key, now) {
                 .map(presentWorkflowInstance),
         },
         execution: {
-            runs: await Promise.all(runs.map((run) => withWorkflowContext(root, presentRun(run)))),
+            runs: await Promise.all(runs.map((run) => enrichRun(root, presentRun(run)))),
             transcriptGroups: await transcriptGroups(root.transcriptStore, id, runs),
         },
         activities: presentPullRequest(pullRequest?.value),

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

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/integrations/delivery/application/delivery-projector.js

@@ -161,20 +161,26 @@ function foldDeliveryFact(previous, delivery) {
         case DeliveryEventType.AttemptStarted:
             return { ...current, attempts: current.attempts + 1 };
         case DeliveryEventType.Confirmed:
-            return { ...current, state: DeliveryState.Confirmed };
+            return { ...current, state: DeliveryState.Confirmed, resolvedAt: delivery.occurredAt };
         case DeliveryEventType.Failed:
-            return { ...current, state: DeliveryState.Failed };
+            return { ...current, state: DeliveryState.Failed, resolvedAt: delivery.occurredAt };
         case DeliveryEventType.Ambiguous:
             return {
                 ...current,
                 state: DeliveryState.Ambiguous,
+                resolvedAt: delivery.occurredAt,
                 reconciliationKey: delivery.payload.reconciliationKey,
             };
         case DeliveryEventType.Escalated:
             return { ...current, escalation: { reason: delivery.payload.reason } };
         case DeliveryEventType.Reconciled:
             if (delivery.payload.result === DeliveryResultKind.Confirmed)
-                return { ...current, state: DeliveryState.Confirmed, escalation: undefined };
+                return {
+                    ...current,
+                    state: DeliveryState.Confirmed,
+                    resolvedAt: delivery.occurredAt,
+                    escalation: undefined,
+                };
             return delivery.payload.result === DeliveryResultKind.Unknown
                 ? { ...current, reconciliationAttempts: (current.reconciliationAttempts ?? 0) + 1 }
                 : current;