@atolis-hq/wake 0.2.97 → 0.3.1

package/dist/src/integrations/application/artifact-registration-reactor.js

@@ -0,0 +1,159 @@
+import { reportedArtifactSchema } from '../../activities/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind, } from '../../kernel/index.js';
+import { OrchestrationEventType, selectWorkflowOrchestrationEvent, workflowInstanceStream, } from '../../orchestration/index.js';
+import { ResourceCorrelationProvenance, ResourceCorrelationRole, resourceId, resourceKind, ResourceStreamKind, } from '../../resources/index.js';
+import { ArtifactEventType, decodeArtifactEvent, } from '../contracts/artifact-events.js';
+import { ArtifactVerificationResult, ArtifactVerificationStatus, } from '../contracts/artifact-vocabulary.js';
+import { integrationStream } from '../contracts/streams.js';
+export class ArtifactRegistrationReactor {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async runOnce(limit = 100) {
+        const consumer = 'reactor:artifact-registration';
+        const events = await this.dependencies.journal.readAll(await this.dependencies.checkpoints.load(consumer), limit);
+        for (const event of events) {
+            const outcome = selectWorkflowOrchestrationEvent(event);
+            if (outcome?.eventType === OrchestrationEventType.ActivityOutcomeAccepted)
+                await this.register(outcome);
+            await this.dependencies.checkpoints.save(consumer, event.globalPosition);
+        }
+        await this.reconcileAmbiguous();
+        return events.length;
+    }
+    async register(outcome) {
+        const artifacts = reportedArtifacts(outcome.payload.outcome.data);
+        if (artifacts.length === 0)
+            return;
+        const branch = await this.branchFor(outcome.payload.activationId);
+        if (branch === undefined)
+            return;
+        const workItemId = await this.workItemFor(outcome.stream.id);
+        if (workItemId === null)
+            return;
+        for (const artifact of artifacts)
+            await this.verifyAndRegister({
+                workflowInstanceId: outcome.stream.id,
+                activationId: outcome.payload.activationId,
+                artifact,
+                correlationId: outcome.correlationId,
+                causationId: outcome.eventId,
+                occurredAt: outcome.recordedAt,
+            }, branch, workItemId, 1);
+    }
+    async reconcileAmbiguous() {
+        const latest = new Map();
+        for (const event of await this.dependencies.journal.readAll(0)) {
+            if (event.eventType !== ArtifactEventType.VerificationUnresolved)
+                continue;
+            const decoded = decodeArtifactEvent(event);
+            const key = `${decoded.causationId}:${decoded.payload.artifact.externalKey.adapter}:${decoded.payload.artifact.externalKey.key}`;
+            latest.set(key, decoded);
+        }
+        for (const event of latest.values()) {
+            if (event.payload.status !== ArtifactVerificationStatus.Ambiguous || event.payload.escalated)
+                continue;
+            const branch = await this.branchFor(event.payload.activationId);
+            const workItemId = await this.workItemFor(event.payload.workflowInstanceId);
+            if (branch === undefined || workItemId === null)
+                continue;
+            await this.verifyAndRegister({
+                workflowInstanceId: event.payload.workflowInstanceId,
+                activationId: event.payload.activationId,
+                artifact: event.payload.artifact,
+                correlationId: event.correlationId,
+                causationId: event.causationId,
+                occurredAt: event.recordedAt,
+            }, branch, workItemId, event.payload.attempt + 1);
+        }
+    }
+    async verifyAndRegister(record, branch, workItemId, attempt) {
+        const provider = this.dependencies.providers.find((candidate) => candidate.adapter === record.artifact.externalKey.adapter);
+        if (provider === undefined)
+            return;
+        const verified = await provider.verifyArtifact(record.artifact.kind, record.artifact.externalKey, {
+            workspaceBranch: branch,
+        });
+        if (typeof verified === 'string') {
+            await this.recordUnresolved(provider, record, verified, attempt);
+            return;
+        }
+        await this.registerVerified(record, verified, workItemId);
+    }
+    async registerVerified(record, verified, workItemId) {
+        const existing = await this.dependencies.resources.findByExternalKey(verified.externalKey);
+        const resource = existing ??
+            (await this.dependencies.resources.discover({
+                resourceId: resourceId(this.dependencies.ids.next(ResourceStreamKind.Resource)),
+                kind: verified.kind,
+                externalKey: verified.externalKey,
+                capabilities: verified.capabilities,
+                ...(verified.revision === undefined ? {} : { revision: verified.revision }),
+            }, context(record.causationId, record.correlationId, record.occurredAt)));
+        try {
+            await this.dependencies.resources.correlate(resource.resourceId, workItemId, ResourceCorrelationRole.Primary, context(record.causationId, record.correlationId, record.occurredAt), ResourceCorrelationProvenance.AgentReported);
+        }
+        catch {
+            // Resources records primary conflicts durably; this flow never guesses a secondary relation.
+        }
+    }
+    async recordUnresolved(provider, record, result, attempt) {
+        const stream = integrationStream(provider.adapter);
+        const sequence = (await this.dependencies.journal.readStream(stream)).length;
+        const ambiguous = result === ArtifactVerificationResult.Ambiguous;
+        const escalated = ambiguous && attempt >= (this.dependencies.maxAmbiguityReconciliationAttempts ?? 3);
+        await this.dependencies.journal.append(stream, sequence, [
+            createEventDraft({
+                eventId: `${record.causationId}:artifact:${record.artifact.externalKey.key}:unresolved:${attempt}`,
+                eventType: ArtifactEventType.VerificationUnresolved,
+                occurredAt: record.occurredAt,
+                correlationId: record.correlationId,
+                causationId: record.causationId,
+                actor: { kind: EventActorKind.Integration, id: 'artifact-registration' },
+                source: { kind: EventSourceKind.Internal, id: 'artifact-registration' },
+                stream,
+                payload: {
+                    workflowInstanceId: record.workflowInstanceId,
+                    activationId: record.activationId,
+                    artifact: record.artifact,
+                    status: ambiguous
+                        ? ArtifactVerificationStatus.Ambiguous
+                        : ArtifactVerificationStatus.Failed,
+                    attempt,
+                    escalated,
+                },
+            }),
+        ]);
+    }
+    async branchFor(activationId) {
+        return (await this.dependencies.runs.list(activationId)).at(-1)?.workspace?.branch;
+    }
+    async workItemFor(workflow) {
+        const events = await this.dependencies.journal.readStream(workflowInstanceStream(workflow));
+        const started = events
+            .map(selectWorkflowOrchestrationEvent)
+            .find((event) => event?.eventType === OrchestrationEventType.InstanceStarted);
+        return started?.payload.workItemId ?? null;
+    }
+}
+function reportedArtifacts(value) {
+    if (typeof value !== 'object' || value === null || !('reportedArtifacts' in value))
+        return [];
+    const artifacts = value.reportedArtifacts;
+    if (!Array.isArray(artifacts))
+        return [];
+    return artifacts
+        .map((artifact) => reportedArtifactSchema.safeParse(artifact))
+        .flatMap((result) => result.success
+        ? [{ kind: resourceKind(result.data.kind), externalKey: result.data.externalKey }]
+        : []);
+}
+function context(commandId, correlationId, occurredAt) {
+    return {
+        commandId: `${commandId}:artifact-registration`,
+        correlationId: correlationId,
+        occurredAt,
+        actor: { kind: EventActorKind.Integration, id: 'artifact-registration' },
+    };
+}

package/dist/src/integrations/application/poll-service.js

@@ -0,0 +1,25 @@
+import { integrationStream } from '../contracts/streams.js';
+export class PollService {
+    journal;
+    instance;
+    constructor(journal, instance) {
+        this.journal = journal;
+        this.instance = instance;
+    }
+    /** Resolves to the count of newly appended drafts, so callers can tell activity from a quiet poll. */
+    async pollOnce(signal) {
+        const drafts = await this.instance.source.poll(signal);
+        let appended = 0;
+        for (const draft of drafts) {
+            if (!this.instance.eventTypes.includes(draft.eventType))
+                throw new Error(`Provider ${this.instance.adapter} emitted an unknown event type`);
+            const stream = integrationStream(this.instance.adapter);
+            const existing = await this.journal.readStream(stream);
+            if (existing.some((event) => event.eventId === draft.eventId))
+                continue;
+            await this.journal.append(stream, existing.length, [{ ...draft, stream }]);
+            appended += 1;
+        }
+        return appended;
+    }
+}

package/dist/src/integrations/application/terminal-agent-run-report.js

@@ -0,0 +1,40 @@
+export function projectTerminalAgentRunReport(input) {
+    if (input.run.finishedAt === undefined)
+        return null;
+    const agent = input.run.agent;
+    return {
+        runId: input.run.runId,
+        ...(input.stage === undefined ? {} : { stage: input.stage }),
+        ...runnerFields(input.run.runner),
+        startedAt: input.run.startedAt,
+        finishedAt: input.run.finishedAt,
+        displayBody: displayBodyFor(agent, input.run.failure),
+        outcome: agent?.outcome ?? 'FAILED',
+        ...sessionIdField(agent),
+        ...(input.run.workspace === undefined ? {} : { workspacePath: input.run.workspace.path }),
+        metadata: agent?.metadata ?? {},
+        ...(input.awaitingApproval === true ? { awaitingApproval: true } : {}),
+        ...(input.watchGateVerdict === undefined ? {} : { watchGateVerdict: input.watchGateVerdict }),
+    };
+}
+function runnerFields(runner) {
+    if (runner === undefined)
+        return {};
+    return {
+        runner: runner.name,
+        ...(runner.model === undefined ? {} : { model: runner.model }),
+        ...(runner.pool === undefined ? {} : { runnerPool: runner.pool }),
+        ...(runner.cli === undefined ? {} : { cli: runner.cli }),
+    };
+}
+function displayBodyFor(agent, failure) {
+    if (agent?.displayBody !== undefined && agent.displayBody.length > 0)
+        return agent.displayBody;
+    if (failure?.message !== undefined && failure.message.length > 0)
+        return failure.message;
+    return 'Runner failed without a response.';
+}
+function sessionIdField(agent) {
+    const sessionId = agent?.metadata.sessionId;
+    return typeof sessionId === 'string' ? { sessionId } : {};
+}

package/dist/src/integrations/application/work-admission.js

@@ -0,0 +1,31 @@
+import { orchestrationGroupId, workflowInstanceId, } from '../../orchestration/index.js';
+import { ResourceCorrelationRole, } from '../../resources/index.js';
+// The single place a newly observed external object becomes Wake work: discover the
+// resource, create the WorkItem with its intake tags, correlate the two, then start the
+// workflow configuration selects. No adapter proposes a workflow name.
+export async function admitObservedWork(services, input, context, 
+// Provider evidence that the entry stage must already see, recorded before the start.
+beforeStart) {
+    await services.resources.discover({
+        resourceId: input.resourceId,
+        kind: input.kind,
+        externalKey: input.externalKey,
+        capabilities: input.capabilities,
+        ...(input.revision === undefined ? {} : { revision: input.revision }),
+        ...(input.title === undefined ? {} : { title: input.title }),
+    }, context);
+    await services.work.create({ workItemId: input.workItemId, objective: input.objective, tags: input.tags }, context);
+    await services.resources.correlate(input.resourceId, input.workItemId, ResourceCorrelationRole.Primary, context);
+    if (beforeStart !== undefined)
+        await beforeStart();
+    await services.orchestration.start({
+        workflowInstanceId: workflowInstanceId(`primary:${input.workItemId}`),
+        workItemId: input.workItemId,
+        workflowName: services.routing.select({
+            tags: input.tags,
+            kind: input.kind,
+            adapter: input.adapter,
+        }),
+        orchestrationGroupId: orchestrationGroupId(`primary:${input.workItemId}`),
+    }, context);
+}

package/dist/src/integrations/application/work-conclusion.js

@@ -0,0 +1,19 @@
+import { WorkStatus } from '../../work/index.js';
+import { ExternalWorkOutcome } from '../contracts/outcome-vocabulary.js';
+// Mirrors work-admission.ts's shared, adapter-neutral seam: an adapter
+// translator calls this once it observes an external resource's terminal
+// outcome. Self-idempotent — a duplicate or replayed observation, or Wake's
+// own close echoing back through the next poll, is a safe no-op because it
+// checks current WorkItem state rather than relying on WorkService's
+// throw-on-non-Open guard.
+export async function concludeObservedWork(services, input) {
+    const current = await services.work.get(input.workItemId);
+    if (current === null || current.state !== WorkStatus.Open)
+        return;
+    if (input.outcome === ExternalWorkOutcome.Completed) {
+        await services.conclusion.closeWork(input.workItemId, input.reason);
+    }
+    else {
+        await services.conclusion.cancelWork(input.workItemId, input.reason);
+    }
+}

package/dist/src/integrations/contracts/artifact-events.js

@@ -0,0 +1,60 @@
+import { z } from 'zod';
+import { activationId } from '../../activities/index.js';
+import { brandedStringSchema, eventEnvelopeSchema, } from '../../kernel/index.js';
+import { workflowInstanceId } from '../../orchestration/index.js';
+import { resourceKind } from '../../resources/index.js';
+import { ArtifactVerificationStatus, } from './artifact-vocabulary.js';
+import { adapterId } from './identifiers.js';
+import { IntegrationStreamKind, integrationStream } from './streams.js';
+export const ArtifactEventType = {
+    VerificationUnresolved: 'integration.artifact-verification-unresolved',
+};
+const schema = eventEnvelopeSchema
+    .extend({
+    eventType: z.literal(ArtifactEventType.VerificationUnresolved),
+    stream: z
+        .object({
+        kind: z.literal(IntegrationStreamKind.Integration),
+        id: brandedStringSchema(adapterId),
+    })
+        .strict(),
+    payload: z
+        .object({
+        workflowInstanceId: brandedStringSchema(workflowInstanceId),
+        activationId: brandedStringSchema(activationId),
+        artifact: z
+            .object({
+            kind: brandedStringSchema(resourceKind),
+            externalKey: z
+                .object({ adapter: brandedStringSchema(adapterId), key: z.string().min(1) })
+                .strict(),
+        })
+            .strict(),
+        status: z.enum([ArtifactVerificationStatus.Failed, ArtifactVerificationStatus.Ambiguous]),
+        attempt: z.number().int().positive(),
+        escalated: z.boolean(),
+    })
+        .strict(),
+})
+    .superRefine((event, context) => {
+    if (event.stream.id !== event.payload.artifact.externalKey.adapter)
+        context.addIssue({
+            code: 'custom',
+            path: [],
+            message: 'Artifact adapter must identify its integration stream',
+        });
+});
+export function decodeArtifactEvent(event) {
+    const result = schema.safeParse(event);
+    if (!result.success)
+        throw new Error(`Invalid artifact event ${event.eventId}: ${result.error.message}`, {
+            cause: result.error,
+        });
+    return result.data;
+}
+export function artifactVerificationUnresolvedDraft(input) {
+    return { ...input, schemaVersion: 1 };
+}
+export function artifactIntegrationStream(adapter) {
+    return integrationStream(adapter);
+}

package/dist/src/integrations/contracts/artifact-vocabulary.js

@@ -0,0 +1,9 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+export const ArtifactVerificationResult = defineClosedVocabulary({
+    NotFound: 'not-found',
+    Ambiguous: 'ambiguous',
+});
+export const ArtifactVerificationStatus = defineClosedVocabulary({
+    Failed: 'failed',
+    Ambiguous: 'ambiguous',
+});

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

@@ -0,0 +1,14 @@
+import { z } from 'zod';
+const providerEntrySchema = z
+    .looseObject({
+    provider: z
+        .string()
+        .trim()
+        .regex(/^[a-z][a-z0-9-]*$/)
+        .optional(),
+    enabled: z.boolean().default(true),
+})
+    .transform((value) => ({ ...value, enabled: value.enabled ?? true }));
+export const integrationsConfigSchema = z
+    .record(z.string().regex(/^[a-z][a-z0-9-]*$/), providerEntrySchema)
+    .default({});

package/dist/src/integrations/contracts/identifiers.js

@@ -0,0 +1,5 @@
+export const adapterId = (value) => {
+    if (!/^[a-z][a-z0-9-]*$/.test(value))
+        throw new Error(`Invalid AdapterId: ${value}`);
+    return value;
+};

package/dist/src/integrations/contracts/intake-rules.js

@@ -0,0 +1,14 @@
+import { matchesRequiredValues } from '../../kernel/index.js';
+// With no rules configured every observation is admitted and carries no tags; otherwise an
+// observation must match at least one rule, and collects the tags of every rule it matches.
+export function evaluateIntakeRules(rules, facts) {
+    if (rules.length === 0)
+        return { admitted: true, tags: [] };
+    const matched = rules.filter((rule) => ruleMatches(rule, facts));
+    if (matched.length === 0)
+        return { admitted: false, tags: [] };
+    return { admitted: true, tags: [...new Set(matched.flatMap((rule) => rule.tags))] };
+}
+function ruleMatches(rule, facts) {
+    return Object.entries(rule.where).every(([facet, required]) => matchesRequiredValues(rule.matchMode, required, facts[facet] ?? []));
+}

package/dist/src/integrations/contracts/intake.js

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

package/dist/src/integrations/contracts/outcome-vocabulary.js

@@ -0,0 +1,7 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+// How an external resource (a GitHub issue today; any future adapter's
+// ticket) concluded, independent of that provider's own vocabulary.
+export const ExternalWorkOutcome = defineClosedVocabulary({
+    Completed: 'completed',
+    Cancelled: 'cancelled',
+});

package/dist/src/integrations/contracts/provider.js

@@ -0,0 +1,37 @@
+import { adapterId } from './identifiers.js';
+export class ProviderRegistry {
+    definitions = new Map();
+    register(definition) {
+        if (this.definitions.has(definition.provider))
+            throw new Error(`Provider ${definition.provider} exists`);
+        this.definitions.set(definition.provider, definition);
+    }
+    compose(config, services) {
+        const instances = [];
+        const failures = [];
+        for (const [name, entry] of Object.entries(config)) {
+            if (!entry.enabled)
+                continue;
+            const provider = entry.provider ?? name;
+            const definition = this.definitions.get(provider);
+            if (definition === undefined)
+                throw new Error(`Provider ${provider} is not registered`);
+            const adapter = adapterId(name);
+            try {
+                instances.push(definition.create({
+                    adapter,
+                    config: definition.parseConfig(entry),
+                    ...(services === undefined ? {} : { services }),
+                }));
+            }
+            catch (error) {
+                failures.push({
+                    adapter,
+                    provider,
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        return { instances, failures };
+    }
+}

package/dist/src/integrations/contracts/streams.js

@@ -0,0 +1,10 @@
+export const IntegrationStreamKind = { Integration: 'integration', Delivery: 'delivery' };
+export const integrationStream = (id) => ({
+    kind: IntegrationStreamKind.Integration,
+    id,
+});
+export const isIntegrationStream = (stream) => stream.kind === IntegrationStreamKind.Integration;
+export const deliveryStream = (intentEventId) => ({
+    kind: IntegrationStreamKind.Delivery,
+    id: intentEventId,
+});

package/dist/src/integrations/delivery/application/delivery-outcome-reactor.js

@@ -0,0 +1,75 @@
+import { ActivityOutcomeKind, activationId } from '../../../activities/index.js';
+import { EventActorKind } from '../../../kernel/index.js';
+import { ActivityActivationStatus, workflowInstanceId, } from '../../../orchestration/index.js';
+import { DeliveryEventType, selectDeliveryEvent } from '../contracts/events.js';
+import { DeliveryResultKind } from '../contracts/vocabulary.js';
+const deliveryResultSignalKind = 'delivery-result';
+export class DeliveryOutcomeReactor {
+    journal;
+    checkpoints;
+    orchestration;
+    constructor(journal, checkpoints, orchestration) {
+        this.journal = journal;
+        this.checkpoints = checkpoints;
+        this.orchestration = orchestration;
+    }
+    async runOnce() {
+        const consumer = 'reactor:delivery-outcomes';
+        const events = await this.journal.readAll(await this.checkpoints.load(consumer));
+        for (const event of events) {
+            const delivery = selectDeliveryEvent(event);
+            if (delivery !== null) {
+                const command = {
+                    workflowInstanceId: workflowInstanceId(delivery.payload.workflowInstanceId),
+                    activationId: activationId(delivery.payload.activationId),
+                };
+                if (await this.isAwaitingThisDelivery(command, delivery.payload.intentEventId)) {
+                    if (delivery.eventType === DeliveryEventType.Confirmed ||
+                        (delivery.eventType === DeliveryEventType.Reconciled &&
+                            delivery.payload.result === DeliveryResultKind.Confirmed))
+                        await this.orchestration.acceptOutcome({
+                            ...command,
+                            outcome: {
+                                kind: ActivityOutcomeKind.Done,
+                                data: { deliveryEventId: delivery.eventId },
+                            },
+                        }, {
+                            commandId: delivery.eventId,
+                            correlationId: event.correlationId,
+                            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
+                            occurredAt: event.recordedAt,
+                        });
+                    if (delivery.eventType === DeliveryEventType.Failed)
+                        await this.orchestration.acceptOutcome({
+                            ...command,
+                            outcome: {
+                                kind: ActivityOutcomeKind.Failed,
+                                data: { reason: delivery.payload.code },
+                            },
+                        }, {
+                            commandId: delivery.eventId,
+                            correlationId: event.correlationId,
+                            actor: { kind: EventActorKind.System, id: 'delivery-outcome-reactor' },
+                            occurredAt: event.recordedAt,
+                        });
+                }
+            }
+            await this.checkpoints.save(consumer, event.globalPosition);
+        }
+        return events.length;
+    }
+    /**
+     * A delivery's own completion may only resolve the activation that
+     * actually asked to wait on it (an activity outcome of `waiting` with
+     * `signalKind: 'delivery-result'`, e.g. pr.approve/pr.merge) — never a
+     * merely-still-open activation left pending for an unrelated reason
+     * (e.g. a technical failure with no configured route for that stage).
+     */
+    async isAwaitingThisDelivery(command, intentEventId) {
+        const view = await this.orchestration.get(command.workflowInstanceId);
+        return (view?.pendingActivation?.activationId === command.activationId &&
+            view.pendingActivation.status === ActivityActivationStatus.Waiting &&
+            view.waitingFor?.signalKind === deliveryResultSignalKind &&
+            view.waitingFor.intentEventId === intentEventId);
+    }
+}