@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/control-plane/application/intake-pipeline.js

@@ -0,0 +1,29 @@
+/**
+ * Runs the externally-rate-limited half of a Wake tick: poll and translate
+ * inbound. Kept separate from RunnerPipeline so its host can back off when
+ * idle without slowing down dispatch/delivery, which never touch a
+ * rate-limited external API.
+ */
+export function createIntakePipeline(stages) {
+    const isPaused = async () => (await stages.isPaused?.()) ?? false;
+    return {
+        async run(signal) {
+            if (await isPaused())
+                return { processed: false };
+            await stages.catchUpProjections();
+            try {
+                if (await isPaused())
+                    return { processed: false };
+                const polled = await stages.poll(signal);
+                if (await isPaused())
+                    return { processed: false };
+                const translated = await stages.translateInbound();
+                return { processed: polled > 0 || translated > 0 };
+            }
+            finally {
+                if (!(await isPaused()))
+                    await stages.catchUpProjections();
+            }
+        },
+    };
+}

package/dist/src/control-plane/application/runner-control-service.js

@@ -0,0 +1,66 @@
+import { EventActorKind, WrongExpectedSequenceError, correlationId, } from '../../kernel/index.js';
+import { ControlEventType, createControlEventDraft, selectControlEvent, } from '../contracts/events.js';
+import { controlPlaneStream } from '../contracts/streams.js';
+export function createRunnerControlService(input) {
+    const commands = new Map();
+    const once = (key, operation) => {
+        const existing = commands.get(key);
+        if (existing !== undefined)
+            return existing;
+        const pending = operation().finally(() => commands.set(key, pending));
+        commands.set(key, pending);
+        return pending;
+    };
+    return {
+        pause: (runnerName, idempotencyKey) => once(`pause:${runnerName}:${idempotencyKey}`, () => append(input, runnerName, idempotencyKey, 'pause')),
+        unpause: (runnerName, idempotencyKey) => once(`unpause:${runnerName}:${idempotencyKey}`, () => append(input, runnerName, idempotencyKey, 'unpause')),
+    };
+}
+async function append(input, runnerName, idempotencyKey, operation) {
+    if (!input.runners.has(runnerName))
+        throw new Error(`Unknown runner: ${runnerName}`);
+    const stream = controlPlaneStream();
+    const events = await input.journal.readStream(stream);
+    const expectedType = operation === 'pause' ? ControlEventType.RunnerPaused : ControlEventType.RunnerResumed;
+    const correlation = correlationId(`runner:${runnerName}:${idempotencyKey}`);
+    if (events.some((event) => event.eventType === expectedType && event.correlationId === correlation))
+        return;
+    if (operation === 'unpause' &&
+        !runnerIsPaused(events, runnerName, input.clock.now().toISOString()))
+        throw new Error(`Runner ${runnerName} is not paused`);
+    const occurredAt = input.clock.now().toISOString();
+    const context = {
+        commandId: input.ids.next('command'),
+        correlationId: correlation,
+        occurredAt,
+        actor: { kind: EventActorKind.Operator, id: 'web' },
+    };
+    const event = operation === 'pause'
+        ? createControlEventDraft(ControlEventType.RunnerPaused, { runnerName, cause: 'manual', reason: 'paused by operator' }, context)
+        : createControlEventDraft(ControlEventType.RunnerResumed, { runnerName, resumedAt: occurredAt }, context);
+    try {
+        await input.journal.append(stream, events.length, [event]);
+    }
+    catch (error) {
+        if (!(error instanceof WrongExpectedSequenceError))
+            throw error;
+        const latest = await input.journal.readStream(stream);
+        if (latest.some((entry) => entry.eventType === expectedType && entry.correlationId === correlation))
+            return;
+        throw error;
+    }
+}
+function runnerIsPaused(events, runnerName, now) {
+    let pause;
+    for (const envelope of events) {
+        const event = selectControlEvent(envelope);
+        if (event?.eventType === ControlEventType.RunnerPaused &&
+            event.payload.runnerName === runnerName)
+            pause = event.payload.resumeAt === undefined ? {} : { resumeAt: event.payload.resumeAt };
+        if (event?.eventType === ControlEventType.RunnerResumed &&
+            event.payload.runnerName === runnerName)
+            pause = undefined;
+    }
+    return (pause !== undefined &&
+        (pause.resumeAt === undefined || Date.parse(pause.resumeAt) > Date.parse(now)));
+}

package/dist/src/control-plane/application/runner-pipeline.js

@@ -0,0 +1,57 @@
+/**
+ * Runs the internal half of a Wake tick: schedules, reactors, Advancement,
+ * and delivery. None of this touches a rate-limited external poll, so its
+ * host runs on a fast, un-backed-off cadence — see IntakePipeline for the
+ * half that does need backoff.
+ */
+export function createRunnerPipeline(stages) {
+    const isPaused = async () => (await stages.isPaused?.()) ?? false;
+    const runOnce = async (options, signal) => {
+        if (await isPaused())
+            return { kind: 'paused' };
+        await stages.catchUpProjections();
+        try {
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.runSchedules();
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.react();
+            if (await isPaused())
+                return { kind: 'paused' };
+            const result = await stages.advance(options);
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.publishAgentRuns?.();
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.catchUpProjections();
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.deliver(signal);
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.catchUpProjections();
+            if (await isPaused())
+                return { kind: 'paused' };
+            await stages.react();
+            return result;
+        }
+        finally {
+            if (!(await isPaused()))
+                await stages.catchUpProjections();
+        }
+    };
+    // The API's manual Tick Now endpoint and the resident tick host share this
+    // pipeline. Serializing all callers prevents them from racing the same run
+    // claim, checkpoint, and workspace lifecycle within one Wake process.
+    let queue = Promise.resolve();
+    return {
+        run(options, signal = new AbortController().signal) {
+            const result = queue.then(() => runOnce(options, signal));
+            // A rejected tick must not prevent the next requested tick from running.
+            queue = result.catch(() => { });
+            return result;
+        },
+    };
+}

package/dist/src/control-plane/application/schedule-service.js

@@ -0,0 +1,47 @@
+import { correlationId } from '../../kernel/index.js';
+import { orchestrationGroupId, workflowInstanceId, workflowName, } from '../../orchestration/index.js';
+import { workItemId } from '../../work/index.js';
+import { SchedulePolicy } from '../domain/schedule-policy.js';
+export class ScheduleService {
+    dependencies;
+    policy = new SchedulePolicy();
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async run(config, context) {
+        const checkpoint = await this.dependencies.checkpoint.load(config.id);
+        const slots = this.policy.elapsedSlots(config, this.dependencies.now(), checkpoint);
+        const accepted = [];
+        for (const slot of slots) {
+            const workflow = workflowInstanceId(`workflow-${safe(slot.at)}`);
+            const slotContext = slotCommandContext(context, slot.identity);
+            const existing = await this.dependencies.orchestration.get(workflow);
+            const item = existing?.workItemId ?? workItemId(this.dependencies.ids.next('work'));
+            if (existing === null) {
+                const workCommand = { workItemId: item, objective: config.objective };
+                await this.dependencies.work.create(workCommand, slotContext);
+            }
+            const start = {
+                workflowInstanceId: workflow,
+                workItemId: item,
+                workflowName: workflowName(config.workflow),
+                orchestrationGroupId: orchestrationGroupId(`primary:${item}`),
+            };
+            await this.dependencies.orchestration.start(start, slotContext);
+            await this.dependencies.checkpoint.save(config.id, slot.at);
+            accepted.push(slot.identity);
+        }
+        return accepted;
+    }
+}
+function slotCommandContext(context, identity) {
+    const suffix = safe(identity);
+    return {
+        ...context,
+        commandId: `${context.commandId}:${suffix}`,
+        correlationId: correlationId(`${context.correlationId}:${suffix}`),
+    };
+}
+function safe(value) {
+    return value.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+}

package/dist/src/control-plane/application/work-cancellation-policy.js

@@ -0,0 +1,31 @@
+import { ExecutionCancellationReason } from '../../execution/index.js';
+import { EventActorKind, correlationId, } from '../../kernel/index.js';
+import { ControlStreamKind } from '../contracts/streams.js';
+/** Applies a Work conclusion (close or cancel) consistently to active workflows and their Runs. */
+export function createWorkCancellationPolicy(work, orchestration, execution, clock, ids) {
+    async function conclude(workItemId, reason, workAction, executionReason, blockReasonPrefix) {
+        const context = commandContext(clock, ids, workItemId);
+        const concluded = await workAction(context);
+        const workflows = (await orchestration.listAll()).filter((workflow) => workflow.workItemId === workItemId);
+        await execution.cancelActive(workflows.map((workflow) => workflow.workflowInstanceId), executionReason);
+        for (const workflow of workflows)
+            await orchestration.block(workflow.workflowInstanceId, `${blockReasonPrefix}: ${reason}`, context);
+        return concluded;
+    }
+    return {
+        cancelWork(workItemId, reason) {
+            return conclude(workItemId, reason, (context) => work.cancel(workItemId, reason, context), ExecutionCancellationReason.WorkCancelled, 'work cancelled');
+        },
+        closeWork(workItemId, reason) {
+            return conclude(workItemId, reason, (context) => work.close(workItemId, reason, context), ExecutionCancellationReason.WorkClosed, 'work closed');
+        },
+    };
+}
+function commandContext(clock, ids, cause) {
+    return {
+        commandId: ids.next('command'),
+        correlationId: correlationId(cause),
+        occurredAt: clock.now().toISOString(),
+        actor: { kind: EventActorKind.System, id: ControlStreamKind.Global },
+    };
+}

package/dist/src/control-plane/contracts/commands.js

@@ -0,0 +1,10 @@
+import { ExecutionCancellationReason } from '../../execution/index.js';
+import { WorkflowStatus } from '../../orchestration/index.js';
+export const HostStopReason = {
+    Idle: 'idle',
+    Waiting: WorkflowStatus.Waiting,
+    Blocked: WorkflowStatus.Blocked,
+    Budget: 'budget',
+    Paused: 'paused',
+    Shutdown: ExecutionCancellationReason.Shutdown,
+};

package/dist/src/control-plane/contracts/config.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+const scheduleSchema = z
+    .object({
+    id: z.string().trim().min(1),
+    workflow: z.string().trim().min(1),
+    cron: z.string().trim().min(1),
+    objective: z.string().trim().min(1),
+})
+    .strict();
+export const controlPlaneConfigSchema = z
+    .object({
+    maxDispatches: z.number().int().positive().default(1),
+    schedules: z.array(scheduleSchema).default([]),
+    resident: z
+        .object({
+        idleBackoffMs: z.number().int().positive().default(1000),
+        maxIdleBackoffMs: z.number().int().positive().optional(),
+    })
+        .strict()
+        .default({ idleBackoffMs: 1000 }),
+})
+    .strict();

package/dist/src/control-plane/contracts/events.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { EventSourceKind, createEventDraft, eventEnvelopeSchema, } from '../../kernel/index.js';
+import { ControlStreamKind, controlPlaneStream } from './streams.js';
+export const ControlEventType = {
+    DispatchPaused: 'control-plane.dispatch-paused',
+    DispatchResumed: 'control-plane.dispatch-resumed',
+    RunnerPaused: 'control-plane.runner-paused',
+    RunnerResumed: 'control-plane.runner-resumed',
+};
+export const RunnerPauseCause = { Manual: 'manual', Quota: 'quota' };
+export const ControlEventNamespace = 'control-plane.';
+const streamSchema = z
+    .object({ kind: z.literal(ControlStreamKind.Global), id: z.literal('global') })
+    .strict();
+const eventSchema = z.discriminatedUnion('eventType', [
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ControlEventType.DispatchPaused),
+        stream: streamSchema,
+        payload: z
+            .object({ resumeAt: z.string().datetime({ offset: true }), reason: z.string().min(1) })
+            .strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ControlEventType.DispatchResumed),
+        stream: streamSchema,
+        payload: z.object({ resumedAt: z.string().datetime({ offset: true }) }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ControlEventType.RunnerPaused),
+        stream: streamSchema,
+        payload: z
+            .object({
+            runnerName: z.string().trim().min(1),
+            cause: z.enum(RunnerPauseCause),
+            reason: z.string().min(1),
+            resumeAt: z.string().datetime({ offset: true }).optional(),
+        })
+            .strict()
+            .superRefine((value, context) => {
+            if (value.cause === RunnerPauseCause.Quota && value.resumeAt === undefined)
+                context.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: 'Quota runner pauses require resumeAt',
+                });
+        }),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ControlEventType.RunnerResumed),
+        stream: streamSchema,
+        payload: z
+            .object({
+            runnerName: z.string().trim().min(1),
+            resumedAt: z.string().datetime({ offset: true }),
+        })
+            .strict(),
+    }),
+]);
+export function decodeControlEvent(event) {
+    const result = eventSchema.safeParse(event);
+    if (!result.success)
+        throw new Error(`Invalid Control Plane event ${event.eventId}: ${result.error.message}`, {
+            cause: result.error,
+        });
+    return result.data;
+}
+export function selectControlEvent(event) {
+    return event.eventType.startsWith(ControlEventNamespace) ? decodeControlEvent(event) : null;
+}
+export function createControlEventDraft(eventType, payload, context) {
+    return createEventDraft({
+        eventId: `${context.commandId}:${eventType}`,
+        eventType,
+        occurredAt: context.occurredAt,
+        correlationId: context.correlationId,
+        causationId: context.commandId,
+        actor: context.actor,
+        source: { kind: EventSourceKind.Internal, id: ControlStreamKind.Global },
+        stream: controlPlaneStream(),
+        payload,
+    });
+}

package/dist/src/control-plane/contracts/streams.js

@@ -0,0 +1,5 @@
+export const ControlStreamKind = { Global: 'control-plane' };
+export const controlPlaneStream = () => ({
+    kind: ControlStreamKind.Global,
+    id: 'global',
+});

package/dist/src/control-plane/domain/dispatch-policy.js

@@ -0,0 +1,15 @@
+export class DispatchPolicy {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    select(candidates, state = {}) {
+        if (state.blocked === true || this.options.maxDispatches <= 0)
+            return [];
+        return [...candidates]
+            .filter((candidate) => !candidate.cancelled && !candidate.hasActiveRun)
+            .sort((left, right) => left.requestedPosition - right.requestedPosition ||
+            left.activationId.localeCompare(right.activationId))
+            .slice(0, this.options.maxDispatches);
+    }
+}

package/dist/src/control-plane/domain/quota-policy.js

@@ -0,0 +1,26 @@
+export class QuotaPolicy {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    decide(now, dispatches, pausedUntil) {
+        const current = parse(now);
+        if (pausedUntil !== null) {
+            const deadline = parse(pausedUntil);
+            return current >= deadline ? { kind: 'resume' } : { kind: 'paused', resumeAt: pausedUntil };
+        }
+        if (dispatches < this.options.maxDispatches)
+            return { kind: 'dispatch' };
+        return {
+            kind: 'pause',
+            resumeAt: new Date(current + this.options.pauseDurationMs).toISOString(),
+            reason: 'dispatch quota exhausted',
+        };
+    }
+}
+function parse(value) {
+    const result = Date.parse(value);
+    if (Number.isNaN(result))
+        throw new Error(`Invalid quota timestamp: ${value}`);
+    return result;
+}

package/dist/src/control-plane/domain/runner-quota.js

@@ -0,0 +1,35 @@
+const reportedUtcReset = /(?:resets?|try again at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*(?:\(utc\)|utc)/i;
+const reportedLocalReset = /(?:resets?|try again at)\s+(\d{1,2})(?::(\d{2}))?\s*(am|pm)\b/i;
+const fallbackPauseMs = 30 * 60_000;
+/** Produces a durable deadline; an unlabelled provider clock is not trusted as UTC. */
+export function resolveRunnerQuotaResumeAt(message, now) {
+    const current = new Date(now);
+    const match = reportedUtcReset.exec(message);
+    if (match === null)
+        return localReset(message, current);
+    let hour = Number(match[1]);
+    if (hour === 12)
+        hour = 0;
+    if (match[3]?.toLowerCase() === 'pm')
+        hour += 12;
+    const reset = new Date(current);
+    reset.setUTCHours(hour, Number(match[2] ?? 0), 0, 0);
+    if (reset.getTime() <= current.getTime())
+        reset.setUTCDate(reset.getUTCDate() + 1);
+    return reset.toISOString();
+}
+function localReset(message, current) {
+    const match = reportedLocalReset.exec(message);
+    if (match === null)
+        return new Date(current.getTime() + fallbackPauseMs).toISOString();
+    let hour = Number(match[1]);
+    if (hour === 12)
+        hour = 0;
+    if (match[3]?.toLowerCase() === 'pm')
+        hour += 12;
+    const reset = new Date(current);
+    reset.setHours(hour, Number(match[2] ?? 0), 0, 0);
+    if (reset.getTime() <= current.getTime())
+        reset.setDate(reset.getDate() + 1);
+    return reset.toISOString();
+}

package/dist/src/control-plane/domain/schedule-policy.js

@@ -0,0 +1,46 @@
+export class SchedulePolicy {
+    elapsedSlots(config, now, checkpoint) {
+        const end = minute(new Date(now));
+        const start = checkpoint === null ? end : minute(new Date(new Date(checkpoint).getTime() + 60_000));
+        if (start > end)
+            return [];
+        const fields = config.cron.trim().split(/\s+/);
+        if (fields.length !== 5)
+            throw new Error(`Schedule ${config.id} must use a five-field cron expression`);
+        const slots = [];
+        for (let cursor = start; cursor <= end; cursor += 60_000) {
+            const date = new Date(cursor);
+            if (matches(fields, date)) {
+                const at = date.toISOString();
+                slots.push({ identity: `schedule:${config.id}:${at}`, at });
+            }
+        }
+        return slots;
+    }
+}
+function minute(value) {
+    if (Number.isNaN(value.getTime()))
+        throw new Error('Schedule timestamps must be valid dates');
+    return Math.floor(value.getTime() / 60_000) * 60_000;
+}
+function matches(fields, date) {
+    return (matchesField(fields[0], date.getUTCMinutes(), 0, 59) &&
+        matchesField(fields[1], date.getUTCHours(), 0, 23) &&
+        matchesField(fields[2], date.getUTCDate(), 1, 31) &&
+        matchesField(fields[3], date.getUTCMonth() + 1, 1, 12) &&
+        matchesField(fields[4], date.getUTCDay(), 0, 6));
+}
+function matchesField(expression, value, minimum, maximum) {
+    return expression.split(',').some((part) => {
+        const [base, stepText] = part.split('/');
+        const step = stepText === undefined ? 1 : Number(stepText);
+        if (!Number.isInteger(step) || step < 1)
+            throw new Error(`Invalid cron step: ${part}`);
+        if (base === '*')
+            return (value - minimum) % step === 0;
+        const number = Number(base);
+        if (!Number.isInteger(number) || number < minimum || number > maximum)
+            throw new Error(`Invalid cron field: ${part}`);
+        return value === number;
+    });
+}

package/dist/src/control-plane/index.js

@@ -0,0 +1,20 @@
+export * from './application/advance-once.js';
+export * from './application/control-plane-projection.js';
+export * from './application/control-plane-service.js';
+export * from './application/runner-control-service.js';
+export * from './application/schedule-service.js';
+export * from './application/intake-pipeline.js';
+export * from './application/runner-pipeline.js';
+export * from './application/work-cancellation-policy.js';
+export * from './contracts/commands.js';
+export * from './contracts/config.js';
+export * from './contracts/events.js';
+export * from './contracts/streams.js';
+export * from './contracts/views.js';
+export * from './domain/dispatch-policy.js';
+export * from './domain/quota-policy.js';
+export * from './domain/runner-quota.js';
+export * from './domain/schedule-policy.js';
+export * from './infrastructure/intake-host.js';
+export * from './infrastructure/resident-host.js';
+export * from './infrastructure/tick-host.js';

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

@@ -0,0 +1,24 @@
+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
+ * only needs `advances > 0` to decide whether its next sleep resets to the
+ * fast end of backoff, which `processed` maps onto directly.
+ */
+export class IntakeHost {
+    cycle;
+    constructor(cycle) {
+        this.cycle = cycle;
+    }
+    async run(_budget) {
+        const controller = new AbortController();
+        const { processed } = await this.cycle(controller.signal);
+        return {
+            advances: processed ? 1 : 0,
+            runs: 0,
+            stoppedBecause: processed ? HostStopReason.Budget : HostStopReason.Idle,
+        };
+    }
+}

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

@@ -0,0 +1,45 @@
+import { HostStopReason } from '../contracts/commands.js';
+export class ResidentHost {
+    tick;
+    sleep;
+    reportError;
+    constructor(tick, sleep = async (signal) => {
+        await new Promise((resolve) => {
+            if (signal.aborted)
+                return resolve();
+            signal.addEventListener('abort', () => resolve(), { once: true });
+        });
+    }, reportError = async () => { }) {
+        this.tick = tick;
+        this.sleep = sleep;
+        this.reportError = reportError;
+    }
+    async run(signal, budget) {
+        let total = { advances: 0, runs: 0, stoppedBecause: HostStopReason.Shutdown };
+        let consecutiveIdleTicks = 0;
+        let consecutiveErrorTicks = 0;
+        while (!signal.aborted) {
+            let madeProgress = false;
+            let errored = false;
+            try {
+                const result = await this.tick.run(budget);
+                madeProgress = result.advances > 0;
+                total = {
+                    advances: total.advances + result.advances,
+                    runs: total.runs + result.runs,
+                    stoppedBecause: result.stoppedBecause,
+                };
+            }
+            catch (error) {
+                errored = true;
+                await this.reportError(error);
+            }
+            consecutiveIdleTicks = madeProgress ? 0 : consecutiveIdleTicks + 1;
+            consecutiveErrorTicks = errored ? consecutiveErrorTicks + 1 : 0;
+            if (signal.aborted)
+                break;
+            await this.sleep(signal, { consecutiveIdleTicks, consecutiveErrorTicks });
+        }
+        return { ...total, stoppedBecause: HostStopReason.Shutdown };
+    }
+}

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

@@ -0,0 +1,35 @@
+import { WorkflowStatus } from '../../orchestration/index.js';
+import { HostStopReason, } from '../contracts/commands.js';
+export class TickHost {
+    advance;
+    constructor(advance) {
+        this.advance = advance;
+    }
+    async run(budget) {
+        const started = Date.now();
+        let advances = 0;
+        let runs = 0;
+        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 });
+            if (result.kind === 'progressed') {
+                advances += 1;
+                runs += 1;
+                continue;
+            }
+            return {
+                advances,
+                runs,
+                stoppedBecause: result.kind === 'no-work'
+                    ? HostStopReason.Idle
+                    : result.kind === WorkflowStatus.Waiting
+                        ? HostStopReason.Waiting
+                        : result.kind === WorkflowStatus.Blocked
+                            ? HostStopReason.Blocked
+                            : HostStopReason.Budget,
+            };
+        }
+        return { advances, runs, stoppedBecause: HostStopReason.Budget };
+    }
+}

package/dist/src/execution/application/activation-claim.js

@@ -0,0 +1,50 @@
+import { EventActorKind, EventSourceKind, } from '../../kernel/index.js';
+import { createActivationExecutionEventDraft } from '../contracts/event-factory.js';
+import { decodeActivationExecutionEvent, ExecutionEventType, } from '../contracts/events.js';
+import { activationStream } from '../contracts/streams.js';
+export async function claimActivation(input) {
+    const { journal, clock, config, activationId, runId, owner, occurredAt } = input;
+    const stream = activationStream(activationId);
+    const events = (await journal.readStream(stream)).map(decodeActivationExecutionEvent);
+    const last = events.at(-1);
+    if (last?.eventType === ExecutionEventType.ActivationClaimed && claimIsUnexpired(last, clock))
+        throw new Error(`Activation ${activationId} already has an active Run claim`);
+    await journal.append(stream, events.length, [
+        createActivationExecutionEventDraft({
+            eventId: `${activationId}:claim:${runId}`,
+            eventType: ExecutionEventType.ActivationClaimed,
+            occurredAt,
+            correlationId: activationId,
+            causationId: runId,
+            actor: { kind: EventActorKind.System, id: owner },
+            source: { kind: EventSourceKind.Internal, id: 'execution' },
+            stream,
+            payload: {
+                runId,
+                owner,
+                expiresAt: new Date(clock.now().getTime() + (config.leaseDurationMs ?? 60_000)).toISOString(),
+            },
+        }),
+    ]);
+}
+export async function releaseActivation(input) {
+    const { journal, clock, activationId, runId } = input;
+    const stream = activationStream(activationId);
+    const events = (await journal.readStream(stream)).map(decodeActivationExecutionEvent);
+    await journal.append(stream, events.length, [
+        createActivationExecutionEventDraft({
+            eventId: `${activationId}:released:${runId}`,
+            eventType: ExecutionEventType.ActivationReleased,
+            occurredAt: clock.now().toISOString(),
+            correlationId: activationId,
+            causationId: runId,
+            actor: { kind: EventActorKind.System, id: 'execution' },
+            source: { kind: EventSourceKind.Internal, id: 'execution' },
+            stream,
+            payload: { runId },
+        }),
+    ]);
+}
+function claimIsUnexpired(event, clock) {
+    return new Date(event.payload.expiresAt) > clock.now();
+}