@atolis-hq/wake 0.4.40 → 0.4.41

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

@@ -127,7 +127,10 @@ export async function createCompositionRoot(wakeRoot, options = {}) {
             : createTranscriptRetention(transcriptStore, projections, config, clock)),
         runnerIneligibility: createDurableRunnerIneligibility(journal, () => clock.now().toISOString()),
     });
-    const advanceOnce = activationScheduler.runOnce.bind(activationScheduler);
+    const advanceOnce = Object.assign(activationScheduler.runOnce.bind(activationScheduler), {
+        maintain: activationScheduler.maintain.bind(activationScheduler),
+        dispatch: activationScheduler.dispatch.bind(activationScheduler),
+    });
     const activationSchedulerSubscriber = createActivationSchedulerSubscriber(activationScheduler);
     const runtime = await composeIntegrationRuntime({
         config,

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.40";
+export const wakeVersion = "v0.4.41";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/control-plane/application/activation-scheduler.d.ts

@@ -1,8 +1,11 @@
 import { type Clock } from '../../kernel/index.js';
 import type { ResourceService } from '../../resources/index.js';
+import type { MaintenanceResult } from '../contracts/commands.js';
 import type { AdvanceOptions, AdvanceResult } from '../contracts/views.js';
 import type { ActivationSchedulerDependencies, ExecutionPort, OrchestrationPort } from './activation-scheduler-ports.js';
 export interface ActivationScheduler {
     runOnce(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
+    maintain?(signal?: AbortSignal): Promise<MaintenanceResult>;
+    dispatch?(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
 }
 export declare function createActivationScheduler(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): ActivationScheduler;

package/dist/src/control-plane/application/activation-scheduler.js

@@ -21,9 +21,7 @@ export function createActivationScheduler(orchestration, execution, resources, c
         occurredAt: clock.now().toISOString(),
         actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
     });
-    const run = async (options) => {
-        if (options.maxProgress < 1)
-            return { kind: 'exhausted', progressCount: 0 };
+    const maintain = async () => {
         if (await isDispatchPaused())
             return { kind: 'paused' };
         if (workspaceRecovery !== undefined) {
@@ -76,6 +74,13 @@ export function createActivationScheduler(orchestration, execution, resources, c
         if (await isDispatchPaused())
             return { kind: 'paused' };
         await orchestration.reconcileChildCompletions(context('child-completion-reconciliation'));
+        if (await isDispatchPaused())
+            return { kind: 'paused' };
+        return { kind: 'ready' };
+    };
+    const dispatch = async (options) => {
+        if (options.maxProgress < 1)
+            return { kind: 'exhausted', progressCount: 0 };
         if (await isDispatchPaused())
             return { kind: 'paused' };
         const rawPending = await orchestration.listPendingActivations(options.workItemId);
@@ -146,7 +151,16 @@ export function createActivationScheduler(orchestration, execution, resources, c
         });
     };
     const serialise = dependencies.schedulerSerialiser ?? createInProcessSerialiser();
-    return { runOnce: (options, signal) => serialise(() => run(options), signal) };
+    return {
+        runOnce: (options, signal) => serialise(async () => {
+            if (options.maxProgress < 1)
+                return { kind: 'exhausted', progressCount: 0 };
+            const maintenance = await maintain();
+            return maintenance.kind === 'paused' ? { kind: 'paused' } : dispatch(options);
+        }, signal),
+        maintain: (signal) => serialise(maintain, signal),
+        dispatch: (options, signal) => serialise(() => dispatch(options), signal),
+    };
 }
 function createInProcessSerialiser() {
     let prior = Promise.resolve();

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

@@ -40,6 +40,10 @@ export async function runDispatchLoop(pending, ctx) {
     let stopReason;
     while (dispatched.length < ctx.maxDispatches) {
         const allRuns = await ctx.execution.list();
+        const activeActivationIds = new Set(allRuns.filter((run) => isActiveRunStatus(run.status)).map((run) => run.activationId));
+        const branchActiveWorkflowIds = new Set(allRuns
+            .filter((run) => isActiveRunStatus(run.status) && run.workspace?.mode === WorkspaceMode.Branch)
+            .map((run) => run.workflowInstanceId));
         if (allRuns.filter((run) => isActiveRunStatus(run.status)).length >= ctx.maxConcurrentRuns) {
             stopReason = { kind: 'no-work' };
             break;
@@ -49,10 +53,8 @@ export async function runDispatchLoop(pending, ctx) {
             activationId: item.activation.activationId,
             requestedPosition,
             hasActiveRun: dispatchedIds.has(item.activation.activationId) ||
-                (await ctx.execution.list(item.activation.activationId)).some((run) => isActiveRunStatus(run.status)) ||
-                allRuns.some((run) => isActiveRunStatus(run.status) &&
-                    run.workflowInstanceId === item.workflow.workflowInstanceId &&
-                    run.workspace?.mode === WorkspaceMode.Branch),
+                activeActivationIds.has(item.activation.activationId) ||
+                branchActiveWorkflowIds.has(item.workflow.workflowInstanceId),
             cancelled: false,
         }))))[0];
         const selected = selectedCandidate === undefined

package/dist/src/control-plane/application/advance-once.d.ts

@@ -2,4 +2,7 @@ import type { Clock } from '../../kernel/index.js';
 import type { ResourceService } from '../../resources/index.js';
 import type { ActivationSchedulerDependencies, ExecutionPort, OrchestrationPort } from './activation-scheduler-ports.js';
 /** Compatibility facade for callers that still use the former Advancement name. */
-export declare function createAdvanceOnce(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): (options: Parameters<(options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>>[0]) => Promise<import("../index.js").AdvanceResult>;
+export declare function createAdvanceOnce(orchestration: OrchestrationPort, execution: ExecutionPort, resources: ResourceService, clock: Clock, dependencies: ActivationSchedulerDependencies): ((options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>) & {
+    maintain: (signal?: AbortSignal) => Promise<import("../contracts/commands.js").MaintenanceResult>;
+    dispatch: (options: import("../index.js").AdvanceOptions, signal?: AbortSignal) => Promise<import("../index.js").AdvanceResult>;
+};

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

@@ -2,5 +2,8 @@ import { createActivationScheduler } from './activation-scheduler.js';
 /** Compatibility facade for callers that still use the former Advancement name. */
 export function createAdvanceOnce(orchestration, execution, resources, clock, dependencies) {
     const scheduler = createActivationScheduler(orchestration, execution, resources, clock, dependencies);
-    return (options) => scheduler.runOnce(options);
+    return Object.assign(scheduler.runOnce.bind(scheduler), {
+        maintain: scheduler.maintain.bind(scheduler),
+        dispatch: scheduler.dispatch.bind(scheduler),
+    });
 }

package/dist/src/control-plane/contracts/commands.d.ts

@@ -18,3 +18,12 @@ export interface HostResult {
     readonly stoppedBecause: 'idle' | typeof HostStopReason.Waiting | typeof HostStopReason.Blocked | 'budget' | 'paused' | typeof HostStopReason.Shutdown;
 }
 export type AdvanceOnce = (options: AdvanceOptions, signal?: AbortSignal) => Promise<AdvanceResult>;
+/** Optional scheduler phases used by hosts that can make several dispatch attempts in one pass. */
+export interface AdvancePhases {
+    maintain(signal?: AbortSignal): Promise<MaintenanceResult>;
+    dispatch(options: AdvanceOptions, signal?: AbortSignal): Promise<AdvanceResult>;
+}
+export type MaintenanceResult = {
+    readonly kind: 'ready' | 'paused';
+};
+export type PhasedAdvanceOnce = AdvanceOnce & Partial<AdvancePhases>;

package/dist/src/control-plane/infrastructure/tick-host.d.ts

@@ -1,6 +1,6 @@
-import { type AdvanceOnce, type HostBudget, type HostResult } from '../contracts/commands.js';
+import { type HostBudget, type HostResult, type PhasedAdvanceOnce } from '../contracts/commands.js';
 export declare class TickHost {
     private readonly advance;
-    constructor(advance: AdvanceOnce);
+    constructor(advance: PhasedAdvanceOnce);
     run(budget: HostBudget, signal?: AbortSignal): Promise<HostResult>;
 }

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

@@ -9,10 +9,14 @@ export class TickHost {
         const started = Date.now();
         let advances = 0;
         let runs = 0;
+        const preparation = await prepareDispatch(this.advance, budget, started, signal);
+        if (preparation !== undefined)
+            return preparation;
+        const dispatch = this.advance.dispatch;
         while (advances < budget.maxAdvances && runs < budget.maxRuns) {
             if (Date.now() - started >= budget.maxDurationMs)
                 return { advances, runs, stoppedBecause: HostStopReason.Budget };
-            const result = await this.advance({ maxProgress: 1 }, signal);
+            const result = await (dispatch ?? this.advance)({ maxProgress: 1 }, signal);
             if (result.kind === 'progressed') {
                 advances += 1;
                 runs += result.dispatched.length;
@@ -33,3 +37,12 @@ export class TickHost {
         return { advances, runs, stoppedBecause: HostStopReason.Budget };
     }
 }
+async function prepareDispatch(advance, budget, started, signal) {
+    if (advance.dispatch === undefined || advance.maintain === undefined || budget.maxAdvances < 1)
+        return undefined;
+    if (Date.now() - started >= budget.maxDurationMs)
+        return { advances: 0, runs: 0, stoppedBecause: HostStopReason.Budget };
+    return (await advance.maintain(signal)).kind === 'paused'
+        ? { advances: 0, runs: 0, stoppedBecause: HostStopReason.Paused }
+        : undefined;
+}

package/package.json

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