@atolis-hq/wake 0.2.97 → 0.3.0

package/dist/src/execution/application/recovery-service.js

@@ -0,0 +1,212 @@
+import { correlationId, EventActorKind, EventSourceKind } from '../../kernel/index.js';
+import { createRunExecutionEventDraft } from '../contracts/event-factory.js';
+import { ExecutionEventType } from '../contracts/events.js';
+import { runId } from '../contracts/identifiers.js';
+import { runStream } from '../contracts/streams.js';
+import { ExecutionFailureCode, ExternalExecutionState, RunStatus, } from '../contracts/vocabulary.js';
+import { RunRepository } from './run-repository.js';
+export class RecoveryService {
+    clock;
+    inspector;
+    activities;
+    config;
+    blocker;
+    repository;
+    constructor(journal, clock, inspector, activities, config = {}, blocker) {
+        this.clock = clock;
+        this.inspector = inspector;
+        this.activities = activities;
+        this.config = config;
+        this.blocker = blocker;
+        this.repository = new RunRepository(journal);
+    }
+    async recover(id, owner) {
+        const currentRunId = runId(id);
+        const loaded = await this.repository.load(currentRunId);
+        const run = loaded.view;
+        if (run === null || run.status !== RunStatus.Started)
+            return requireRun(run);
+        if (run.lease !== undefined && new Date(run.lease.expiresAt) > this.clock.now())
+            throw new Error(`Run ${id} does not have an expired lease`);
+        if (run.externalExecution === undefined)
+            return this.appendFailure(currentRunId, run, 'External execution was never reported');
+        const inspection = await this.inspector.inspect(run.externalExecution);
+        if (inspection.kind === ExternalExecutionState.Running)
+            return this.appendLease(currentRunId, run, owner);
+        if (inspection.kind === ExternalExecutionState.Completed)
+            return this.appendRecovered(currentRunId, run, inspection.result);
+        if (inspection.kind === ExternalExecutionState.Absent)
+            return this.appendFailure(currentRunId, run, 'External execution is absent');
+        return this.appendAmbiguity(currentRunId, run, inspection.reason);
+    }
+    async resolve(id, resolution, context) {
+        if (context.actor.kind !== EventActorKind.Operator)
+            throw new Error('Ambiguous Run resolution requires an operator actor');
+        const currentRunId = runId(id);
+        const loaded = await this.repository.load(currentRunId);
+        if (loaded.view === null)
+            throw new Error(`Run ${id} does not exist`);
+        if (!loaded.view.escalated || loaded.view.status !== RunStatus.Ambiguous)
+            throw new Error(`Run ${id} is not escalated`);
+        const draft = resolution.kind === RunStatus.Succeeded
+            ? createRunExecutionEventDraft({
+                ...resolutionMetadata(currentRunId, loaded.view, context),
+                eventType: ExecutionEventType.RunSucceeded,
+                payload: { outcome: resolution.outcome, finishedAt: context.occurredAt },
+            })
+            : createRunExecutionEventDraft({
+                ...resolutionMetadata(currentRunId, loaded.view, context),
+                eventType: ExecutionEventType.RunFailed,
+                payload: { failure: resolution.failure, finishedAt: context.occurredAt },
+            });
+        try {
+            await this.repository.append(currentRunId, loaded.sequence, [draft]);
+        }
+        catch {
+            // A concurrent resolution wins deterministically; return the resulting view.
+        }
+        return (await this.repository.load(currentRunId)).view;
+    }
+    async recoverActive(owner, isLocallyActive = () => false) {
+        const recovered = [];
+        for (const run of await this.repository.list()) {
+            if (run.status !== RunStatus.Started)
+                continue;
+            if (isLocallyActive(run.runId))
+                continue;
+            if (run.lease !== undefined && new Date(run.lease.expiresAt) > this.clock.now())
+                continue;
+            recovered.push(await this.recover(run.runId, owner));
+        }
+        return recovered;
+    }
+    async appendLease(id, run, owner) {
+        const now = this.clock.now().toISOString();
+        return this.append(id, leaseRenewedDraft(id, run, {
+            owner,
+            acquiredAt: now,
+            expiresAt: new Date(this.clock.now().getTime() + (this.config.leaseDurationMs ?? 60_000)).toISOString(),
+        }, now));
+    }
+    async appendRecovered(id, run, result) {
+        const finishedAt = this.clock.now().toISOString();
+        const outcome = recoveredOutcome(run, result, this.activities);
+        return this.append(id, recoveredDraft(id, run, { result, outcome, finishedAt }, finishedAt));
+    }
+    async appendFailure(id, run, message) {
+        const finishedAt = this.clock.now().toISOString();
+        return this.append(id, failedDraft(id, run, { failure: { kind: ExecutionFailureCode.Unexpected, message }, finishedAt }, finishedAt));
+    }
+    async appendAmbiguity(id, run, reason) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null)
+            throw new Error(`Run ${id} does not exist`);
+        if (loaded.view.status !== RunStatus.Started)
+            return loaded.view;
+        const occurredAt = this.clock.now().toISOString();
+        const attempt = loaded.view.ambiguityAttempts + 1;
+        const drafts = [
+            ambiguityObservedDraft(id, loaded.view, { reason, attempt }, occurredAt),
+        ];
+        if (attempt >= (this.config.maxAmbiguityReconciliationAttempts ?? 3))
+            drafts.push(ambiguousDraft(id, loaded.view, { reason, finishedAt: occurredAt }, occurredAt));
+        await this.repository.append(id, loaded.sequence, drafts);
+        const updated = (await this.repository.load(id)).view;
+        if (updated.escalated)
+            await this.blocker?.block(updated.workflowInstanceId, `run-ambiguous-after-${attempt}-attempts`, {
+                commandId: `${id}:recovery-escalation:${attempt}`,
+                correlationId: correlationId(updated.orchestrationGroupId),
+                occurredAt,
+                actor: { kind: EventActorKind.System, id: 'execution-recovery' },
+            });
+        return updated;
+    }
+    async append(id, draft) {
+        const loaded = await this.repository.load(id);
+        if (loaded.view === null)
+            throw new Error(`Run ${id} does not exist`);
+        if (loaded.view.status !== RunStatus.Started)
+            return loaded.view;
+        await this.repository.append(id, loaded.sequence, [draft]);
+        return (await this.repository.load(id)).view;
+    }
+}
+export function createRecoveryCoordinator(service) {
+    return { recoverActive: (owner) => service.recoverActive(owner) };
+}
+function leaseRenewedDraft(id, run, payload, occurredAt) {
+    return createRunExecutionEventDraft({
+        ...eventMetadata(id, run, occurredAt),
+        eventType: ExecutionEventType.RunLeaseRenewed,
+        payload,
+    });
+}
+function recoveredDraft(id, run, payload, occurredAt) {
+    return createRunExecutionEventDraft({
+        ...eventMetadata(id, run, occurredAt),
+        eventType: ExecutionEventType.RunRecovered,
+        payload,
+    });
+}
+function failedDraft(id, run, payload, occurredAt) {
+    return createRunExecutionEventDraft({
+        ...eventMetadata(id, run, occurredAt),
+        eventType: ExecutionEventType.RunFailed,
+        payload,
+    });
+}
+function ambiguityObservedDraft(id, run, payload, occurredAt) {
+    return createRunExecutionEventDraft({
+        ...eventMetadata(id, run, occurredAt),
+        eventId: `${id}:recovery-ambiguity:${payload.attempt}:${occurredAt}`,
+        eventType: ExecutionEventType.RunAmbiguityObserved,
+        payload,
+    });
+}
+function ambiguousDraft(id, run, payload, occurredAt) {
+    return createRunExecutionEventDraft({
+        ...eventMetadata(id, run, occurredAt),
+        eventType: ExecutionEventType.RunAmbiguous,
+        payload,
+    });
+}
+function resolutionMetadata(id, run, context) {
+    return {
+        eventId: `${context.commandId}:run-resolution`,
+        occurredAt: context.occurredAt,
+        correlationId: context.correlationId,
+        causationId: context.commandId,
+        actor: context.actor,
+        source: { kind: EventSourceKind.Internal, id: 'execution-recovery' },
+        stream: runStream(id),
+    };
+}
+function eventMetadata(id, run, occurredAt) {
+    return {
+        eventId: `${id}:recovery:${occurredAt}`,
+        occurredAt,
+        correlationId: run.orchestrationGroupId,
+        causationId: run.activationId,
+        actor: { kind: EventActorKind.System, id: 'execution-recovery' },
+        source: { kind: EventSourceKind.Internal, id: 'execution-recovery' },
+        stream: runStream(id),
+    };
+}
+function recoveredOutcome(run, result, activities) {
+    if (result.transport !== RunStatus.Succeeded)
+        throw new Error(`Recovered result is not successful: ${result.transport}`);
+    return activities.validateOutcome(run.activity, parseRecoveredOutput(result.output));
+}
+function parseRecoveredOutput(output) {
+    try {
+        return JSON.parse(output);
+    }
+    catch {
+        return { kind: output.trim() };
+    }
+}
+function requireRun(run) {
+    if (run === null)
+        throw new Error('Run does not exist');
+    return run;
+}

package/dist/src/execution/application/run-lifecycle.js

@@ -0,0 +1,115 @@
+import { EventActorKind, EventSourceKind, createEventDraft, } from '../../kernel/index.js';
+import { ExecutionEventType } from '../contracts/events.js';
+import { runStream } from '../contracts/streams.js';
+import { RunStatus } from '../contracts/vocabulary.js';
+import { failureFrom } from '../domain/run-result.js';
+import { claimRun } from './run-liveness-service.js';
+export async function startRun(input) {
+    const { dependencies, runId: currentRunId, activation, context, attempt, startedAt, runner, lease, } = input;
+    await dependencies.repository.append(currentRunId, 0, [
+        createRunEvent({
+            runId: currentRunId,
+            eventId: `${currentRunId}:started`,
+            eventType: ExecutionEventType.RunStarted,
+            occurredAt: startedAt,
+            correlationId: context.orchestrationGroupId,
+            causationId: activation.activationId,
+            payload: {
+                activationId: activation.activationId,
+                activity: activation.activity,
+                ...(activation.stage === undefined ? {} : { stage: activation.stage }),
+                workflowInstanceId: context.workflowInstanceId,
+                orchestrationGroupId: context.orchestrationGroupId,
+                attempt,
+                startedAt,
+                ...(runner.name === undefined
+                    ? {}
+                    : {
+                        runner: {
+                            name: runner.name,
+                            ...(runner.model === undefined ? {} : { model: runner.model }),
+                            ...(runner.effort === undefined ? {} : { effort: runner.effort }),
+                            ...(runner.pool === undefined ? {} : { pool: runner.pool }),
+                            ...(runner.cli === undefined ? {} : { cli: runner.cli }),
+                        },
+                    }),
+                ...(lease === undefined
+                    ? {}
+                    : {
+                        workspace: {
+                            mode: lease.mode,
+                            path: lease.path,
+                            ...(lease.branch === undefined ? {} : { branch: lease.branch }),
+                        },
+                    }),
+            },
+        }),
+    ]);
+    await claimRun(dependencies.repository, dependencies.clock, dependencies.config, currentRunId, context.owner ?? 'execution');
+}
+export async function recordWorkspaceCleanupFailure(input) {
+    const { dependencies, runId: currentRunId, activation, context, error } = input;
+    const loaded = await dependencies.repository.load(currentRunId);
+    await dependencies.repository.append(currentRunId, loaded.sequence, [
+        createRunEvent({
+            runId: currentRunId,
+            eventId: `${currentRunId}:workspace-cleanup-failed`,
+            eventType: ExecutionEventType.RunWorkspaceCleanupFailed,
+            occurredAt: dependencies.clock.now().toISOString(),
+            correlationId: context.orchestrationGroupId,
+            causationId: activation.activationId,
+            payload: { message: error instanceof Error ? error.message : `${error}` },
+        }),
+    ]);
+}
+export async function recordRunSuccess(input) {
+    const { dependencies, runId: currentRunId, activation, context, outcome } = input;
+    const finishedAt = dependencies.clock.now().toISOString();
+    const loaded = await dependencies.repository.load(currentRunId);
+    if (loaded.view?.status !== RunStatus.Started)
+        return;
+    await dependencies.repository.append(currentRunId, loaded.sequence, [
+        createRunEvent({
+            runId: currentRunId,
+            eventId: `${currentRunId}:succeeded`,
+            eventType: ExecutionEventType.RunSucceeded,
+            occurredAt: finishedAt,
+            correlationId: context.orchestrationGroupId,
+            causationId: activation.activationId,
+            payload: { outcome, finishedAt },
+        }),
+    ]);
+}
+export async function recordRunFailure(input) {
+    const { dependencies, runId: currentRunId, activation, context, error } = input;
+    const loaded = await dependencies.repository.load(currentRunId);
+    if (loaded.sequence === 0)
+        throw error;
+    if (loaded.view?.status !== RunStatus.Started)
+        return;
+    const finishedAt = dependencies.clock.now().toISOString();
+    await dependencies.repository.append(currentRunId, loaded.sequence, [
+        createRunEvent({
+            runId: currentRunId,
+            eventId: `${currentRunId}:failed`,
+            eventType: ExecutionEventType.RunFailed,
+            occurredAt: finishedAt,
+            correlationId: context.orchestrationGroupId,
+            causationId: activation.activationId,
+            payload: { failure: failureFrom(error), finishedAt },
+        }),
+    ]);
+}
+export function createRunEvent(input) {
+    return createEventDraft({
+        eventId: input.eventId,
+        eventType: input.eventType,
+        occurredAt: input.occurredAt,
+        correlationId: input.correlationId,
+        causationId: input.causationId,
+        actor: { kind: EventActorKind.System, id: 'execution' },
+        source: { kind: EventSourceKind.Internal, id: 'execution' },
+        stream: runStream(input.runId),
+        payload: input.payload,
+    });
+}

package/dist/src/execution/application/run-liveness-service.js

@@ -0,0 +1,80 @@
+import { createEventDraft, EventActorKind, EventSourceKind, } from '../../kernel/index.js';
+import { ExecutionEventType } from '../contracts/events.js';
+import { runStream } from '../contracts/streams.js';
+import { RunStatus } from '../contracts/vocabulary.js';
+const defaultLeaseDurationMs = 60_000;
+export async function claimRun(repository, clock, config, currentRunId, owner) {
+    const loaded = await repository.load(currentRunId);
+    const run = requireActiveRun(loaded.view);
+    const now = clock.now();
+    if (run.lease !== undefined && new Date(run.lease.expiresAt) > now && run.lease.owner !== owner)
+        throw new Error(`Run ${currentRunId} has an unexpired lease`);
+    const lease = {
+        owner,
+        acquiredAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + (config.leaseDurationMs ?? defaultLeaseDurationMs)).toISOString(),
+    };
+    await repository.append(currentRunId, loaded.sequence, [
+        livenessEvent(currentRunId, run, ExecutionEventType.RunLeaseClaimed, lease, now.toISOString()),
+    ]);
+    return (await repository.load(currentRunId)).view;
+}
+export async function renewLease(repository, clock, config, currentRunId, owner) {
+    const loaded = await repository.load(currentRunId);
+    const run = requireActiveRun(loaded.view);
+    if (run.lease?.owner !== owner)
+        throw new Error(`Run ${currentRunId} lease is not owned by ${owner}`);
+    const now = clock.now();
+    const renewalIntervalMs = config.leaseRenewalIntervalMs ?? 0;
+    if (now.getTime() < new Date(run.lease.acquiredAt).getTime() + renewalIntervalMs)
+        throw new Error(`Run ${currentRunId} lease renewal is not due`);
+    const lease = {
+        owner,
+        acquiredAt: now.toISOString(),
+        expiresAt: new Date(now.getTime() + (config.leaseDurationMs ?? defaultLeaseDurationMs)).toISOString(),
+    };
+    await repository.append(currentRunId, loaded.sequence, [
+        livenessEvent(currentRunId, run, ExecutionEventType.RunLeaseRenewed, lease, now.toISOString()),
+    ]);
+    return (await repository.load(currentRunId)).view;
+}
+export async function requestCancellation(repository, clock, currentRunId, reason, active) {
+    const loaded = await repository.load(currentRunId);
+    const run = requireActiveRun(loaded.view);
+    const requestedAt = clock.now().toISOString();
+    await repository.append(currentRunId, loaded.sequence, [
+        livenessEvent(currentRunId, run, ExecutionEventType.RunCancellationRequested, { requestedAt, reason }, requestedAt),
+    ]);
+    active.get(currentRunId)?.abort(reason);
+    return (await repository.load(currentRunId)).view;
+}
+export async function confirmCancellation(repository, clock, currentRunId) {
+    const loaded = await repository.load(currentRunId);
+    const run = requireActiveRun(loaded.view);
+    if (run.cancellation === undefined)
+        throw new Error(`Run ${currentRunId} has no cancellation request`);
+    const confirmedAt = clock.now().toISOString();
+    await repository.append(currentRunId, loaded.sequence, [
+        livenessEvent(currentRunId, run, ExecutionEventType.RunCancellationConfirmed, { confirmedAt }, confirmedAt),
+        livenessEvent(currentRunId, run, ExecutionEventType.RunCancelled, { finishedAt: confirmedAt }, confirmedAt),
+    ]);
+    return (await repository.load(currentRunId)).view;
+}
+function requireActiveRun(run) {
+    if (run === null || run.status !== RunStatus.Started)
+        throw new Error('Run is not active');
+    return run;
+}
+function livenessEvent(currentRunId, run, eventType, payload, occurredAt) {
+    return createEventDraft({
+        eventId: `${currentRunId}:${eventType}:${occurredAt}`,
+        eventType,
+        occurredAt,
+        correlationId: run.orchestrationGroupId,
+        causationId: run.activationId,
+        actor: { kind: EventActorKind.System, id: 'execution' },
+        source: { kind: EventSourceKind.Internal, id: 'execution' },
+        stream: runStream(currentRunId),
+        payload,
+    });
+}

package/dist/src/execution/application/run-repository.js

@@ -0,0 +1,27 @@
+import { decodeRunExecutionEvent, } from '../contracts/events.js';
+import { runId } from '../contracts/identifiers.js';
+import { isRunStream, runStream } from '../contracts/streams.js';
+import { foldRun } from '../domain/run.js';
+export class RunRepository {
+    journal;
+    constructor(journal) {
+        this.journal = journal;
+    }
+    async load(runId) {
+        const events = await this.journal.readStream(runStream(runId));
+        return { sequence: events.length, view: foldRun(events.map(decodeRunExecutionEvent)) };
+    }
+    async append(runId, sequence, drafts) {
+        const events = await this.journal.append(runStream(runId), sequence, drafts);
+        return events.map(decodeRunExecutionEvent);
+    }
+    async list(activationId) {
+        const ids = new Set((await this.journal.readAll(0))
+            .filter((event) => isRunStream(event.stream))
+            .map((event) => runId(event.stream.id)));
+        const runs = (await Promise.all([...ids].map(async (id) => (await this.load(id)).view))).filter((run) => run !== null);
+        return activationId === undefined
+            ? runs
+            : runs.filter((run) => run.activationId === activationId);
+    }
+}

package/dist/src/execution/contracts/commands.js

@@ -0,0 +1 @@
+export {};

package/dist/src/execution/contracts/config.js

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+const isReservedFlag = (arg) => arg === '--output-format' || arg === '--resume';
+const agentRunnerBase = {
+    model: z.string().trim().min(1).optional(),
+    effort: z.string().trim().min(1).optional(),
+    timeoutMs: z.number().int().positive().default(1_800_000),
+    args: z.array(z.string()).default([]),
+};
+const commandRunner = (kind) => z
+    .object({ kind: z.literal(kind), command: z.string().trim().min(1), ...agentRunnerBase })
+    .strict();
+export const executionConfigSchema = z
+    .object({
+    agentRunners: z
+        .record(z.string().trim().min(1), z
+        .discriminatedUnion('kind', [
+        commandRunner('claude-cli'),
+        commandRunner('codex-cli'),
+        commandRunner('cursor-cli'),
+        commandRunner('command'),
+        z.object({ kind: z.literal('fake'), ...agentRunnerBase }).strict(),
+    ])
+        .refine((value) => !value.args.some(isReservedFlag), {
+        message: 'args must not contain --output-format or --resume',
+    }))
+        .default({}),
+    runnerPools: z
+        .record(z.string().trim().min(1), z.array(z.string().trim().min(1)).min(1))
+        .default({}),
+    defaultRunnerPool: z.string().trim().min(1),
+    leaseDurationMs: z.number().int().positive().optional(),
+    leaseRenewalIntervalMs: z.number().int().positive().optional(),
+    maxAmbiguityReconciliationAttempts: z.number().int().positive().optional(),
+})
+    .strict();

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

@@ -0,0 +1 @@
+export {};

package/dist/src/execution/contracts/event-factory.js

@@ -0,0 +1,53 @@
+import { createEventDraft } from '../../kernel/index.js';
+import { ExecutionEventType, } from './events.js';
+// Exhaustive dispatch preserves the closed event-to-payload mapping.
+// eslint-disable-next-line complexity
+export function createRunExecutionEventDraft(input) {
+    switch (input.eventType) {
+        case ExecutionEventType.RunStarted:
+            return createEventDraft(input);
+        case ExecutionEventType.RunSucceeded:
+            return createEventDraft(input);
+        case ExecutionEventType.RunFailed:
+            return createEventDraft(input);
+        case ExecutionEventType.RunLeaseClaimed:
+            return createEventDraft(input);
+        case ExecutionEventType.RunLeaseRenewed:
+            return createEventDraft(input);
+        case ExecutionEventType.RunExternalExecutionReported:
+            return createEventDraft(input);
+        case ExecutionEventType.RunRunnerResultReported:
+            return createEventDraft(input);
+        case ExecutionEventType.RunWorkspaceCleanupFailed:
+            return createEventDraft(input);
+        case ExecutionEventType.RunCancellationRequested:
+            return createEventDraft(input);
+        case ExecutionEventType.RunCancellationConfirmed:
+            return createEventDraft(input);
+        case ExecutionEventType.RunCancelled:
+            return createEventDraft(input);
+        case ExecutionEventType.RunRecovered:
+            return createEventDraft(input);
+        case ExecutionEventType.RunAmbiguityObserved:
+            return createEventDraft(input);
+        case ExecutionEventType.RunAmbiguous:
+            return createEventDraft(input);
+    }
+}
+export function createActivationExecutionEventDraft(input) {
+    switch (input.eventType) {
+        case ExecutionEventType.ActivationClaimed:
+            return createEventDraft(input);
+        case ExecutionEventType.ActivationReleased:
+            return createEventDraft(input);
+    }
+}
+export function createExecutionEventDraft(input) {
+    switch (input.eventType) {
+        case ExecutionEventType.ActivationClaimed:
+        case ExecutionEventType.ActivationReleased:
+            return createActivationExecutionEventDraft(input);
+        default:
+            return createRunExecutionEventDraft(input);
+    }
+}