@atolis-hq/wake 0.3.76 → 0.3.78

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

@@ -12,6 +12,7 @@ function serializeJournalAppends(journal) {
         },
         readStream: (stream) => journal.readStream(stream),
         readAll: (afterGlobalPosition, limit) => journal.readAll(afterGlobalPosition, limit),
+        latestGlobalPosition: () => journal.latestGlobalPosition(),
         ...(journal.readLatest === undefined
             ? {}
             : {

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 = "gad83503";
+export const wakeVersion = "g8656e9f";

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

@@ -1,11 +1,14 @@
+import { cachedJournalView, } from '../../kernel/index.js';
 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;
+    runs;
     constructor(journal) {
         this.journal = journal;
+        this.runs = cachedJournalView(journal, deriveRuns);
     }
     async load(runId) {
         const events = await this.journal.readStream(runStream(runId));
@@ -17,18 +20,21 @@ export class RunRepository {
         return events.map(decodeRunExecutionEvent);
     }
     async list(activationId) {
-        const grouped = new Map();
-        for (const event of await this.journal.readAll(0)) {
-            if (!isRunStream(event.stream))
-                continue;
-            const id = runId(event.stream.id);
-            const events = grouped.get(id) ?? [];
-            events.push(decodeRunExecutionEvent(event));
-            grouped.set(id, events);
-        }
-        const runs = (await Promise.all([...grouped.values()].map(foldRun))).filter((run) => run !== null);
+        const runs = await this.runs.get();
         return activationId === undefined
             ? runs
             : runs.filter((run) => run.activationId === activationId);
     }
 }
+function deriveRuns(events) {
+    const grouped = new Map();
+    for (const event of events) {
+        if (!isRunStream(event.stream))
+            continue;
+        const id = runId(event.stream.id);
+        const decoded = grouped.get(id) ?? [];
+        decoded.push(decodeRunExecutionEvent(event));
+        grouped.set(id, decoded);
+    }
+    return [...grouped.values()].map(foldRun).filter((run) => run !== null);
+}

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

@@ -1,5 +1,5 @@
 import { reportedArtifactSchema } from '../../activities/index.js';
-import { createEventDraft, EventActorKind, EventSourceKind, } from '../../kernel/index.js';
+import { cachedJournalView, 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';
@@ -7,8 +7,10 @@ import { ArtifactVerificationResult, ArtifactVerificationStatus, } from '../cont
 import { integrationStream } from '../contracts/streams.js';
 export class ArtifactRegistrationReactor {
     dependencies;
+    latestUnresolved;
     constructor(dependencies) {
         this.dependencies = dependencies;
+        this.latestUnresolved = cachedJournalView(dependencies.journal, deriveLatestUnresolved);
     }
     async runOnce(limit = 100) {
         const consumer = 'reactor:artifact-registration';
@@ -43,14 +45,7 @@ export class ArtifactRegistrationReactor {
             }, 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);
-        }
+        const latest = await this.latestUnresolved.get();
         for (const event of latest.values()) {
             if (event.payload.status !== ArtifactVerificationStatus.Ambiguous || event.payload.escalated)
                 continue;
@@ -137,6 +132,17 @@ export class ArtifactRegistrationReactor {
         return started?.payload.workItemId ?? null;
     }
 }
+function deriveLatestUnresolved(events) {
+    const latest = new Map();
+    for (const event of events) {
+        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);
+    }
+    return latest;
+}
 function reportedArtifacts(value) {
     if (typeof value !== 'object' || value === null || !('reportedArtifacts' in value))
         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;

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

@@ -37,9 +37,16 @@ export const gitHubConfigSchema = z
         maxConcurrent: z.number().int().positive().default(4),
         commentPageSize: z.number().int().positive().max(100).default(25),
         lookbackMs: z.number().int().nonnegative().default(60_000),
+        intervalMs: z.number().int().positive().default(30_000),
     })
         .strict()
-        .default({ maxPerRepo: 25, maxConcurrent: 4, commentPageSize: 25, lookbackMs: 60_000 }),
+        .default({
+        maxPerRepo: 25,
+        maxConcurrent: 4,
+        commentPageSize: 25,
+        lookbackMs: 60_000,
+        intervalMs: 30_000,
+    }),
     intake: z.array(intakeRuleSchema).default([]),
     publication: z
         .object({ postStatusComments: z.boolean().default(true) })

package/dist/src/integrations/github/infrastructure/source.js

@@ -16,8 +16,17 @@ export function createGitHubSource(config, client, adapter, requests = createGit
     // so it's safe for it to reset on restart.
     const lastEventIds = new Map();
     const pendingWatermarks = new Map();
+    const now = state?.now ?? Date.now;
+    // In-memory only: an extra real poll after a process restart is harmless,
+    // the same tradeoff already made for lastEventIds above.
+    let lastPolledAt;
     return {
         async poll(signal) {
+            const currentTime = now();
+            if (lastPolledAt !== undefined && currentTime - lastPolledAt < config.polling.intervalMs) {
+                return [];
+            }
+            lastPolledAt = currentTime;
             const perRepository = await Promise.all(config.repositories.map(async ({ owner, repo }) => pollRepository({
                 client: limitGitHubSourceClient(client, requests),
                 config,
@@ -26,7 +35,7 @@ export function createGitHubSource(config, client, adapter, requests = createGit
                 owner,
                 repo,
                 watermark: await loadWatermark(state?.checkpoints, adapter, owner, repo),
-                now: state?.now ?? Date.now,
+                now,
                 health,
             })));
             for (const result of perRepository)

package/dist/src/kernel/index.js

@@ -13,5 +13,6 @@ export * from './contracts/vocabulary.js';
 export * from './domain/event-envelope.js';
 export * from './domain/match-mode.js';
 export * from './domain/relation.js';
+export * from './infrastructure/cached-journal-view.js';
 export * from './infrastructure/system-clock.js';
 export * from './infrastructure/ulid-id-generator.js';

package/dist/src/kernel/infrastructure/cached-journal-view.js

@@ -0,0 +1,21 @@
+// Memoizes a full-journal derivation — a fold, decode, or index built from
+// every event in history — so a resident loop calling it every tick only
+// pays that cost when the journal has actually moved since the last call.
+// Same gate ProjectionRunner keeps for itself (a last-seen global position),
+// generalized for callers that want a materialized view rather than an
+// incremental batch. Depends only on the EventJournal port, not on any
+// concrete persistence implementation, so it lives in kernel rather than
+// persistence — domain and adapter modules may call it directly.
+export function cachedJournalView(journal, derive) {
+    let cache;
+    return {
+        async get() {
+            const position = await journal.latestGlobalPosition();
+            if (cache !== undefined && cache.position === position)
+                return cache.value;
+            const value = await derive(await journal.readAll(0));
+            cache = { position, value };
+            return value;
+        },
+    };
+}

package/dist/src/orchestration/application/orchestration-repository.js

@@ -1,11 +1,14 @@
+import { cachedJournalView, } from '../../kernel/index.js';
 import { decodeOrchestrationEvent, selectWorkflowOrchestrationEvent, } from '../contracts/event-decoder.js';
 import { workflowInstanceId } from '../contracts/identifiers.js';
 import { isWorkflowInstanceStream, workflowInstanceStream } from '../contracts/streams.js';
 import { foldWorkflowInstance } from '../domain/workflow-instance.js';
 export class OrchestrationRepository {
     journal;
+    listed;
     constructor(journal) {
         this.journal = journal;
+        this.listed = cachedJournalView(journal, (events) => deriveList(events));
     }
     async load(id) {
         const events = await this.journal.readStream(workflowInstanceStream(workflowInstanceId(id)));
@@ -25,27 +28,29 @@ export class OrchestrationRepository {
         return events.map(decodeOrchestrationEvent).filter(isWorkflowEvent);
     }
     async list() {
-        const events = await this.journal.readAll(0);
-        const streams = new Map();
-        for (const event of events) {
-            if (!isWorkflowInstanceStream(event.stream))
-                continue;
-            const existing = streams.get(event.stream.id);
-            if (existing === undefined)
-                streams.set(event.stream.id, [event]);
-            else
-                existing.push(event);
-        }
-        // `sequence` counts every event on the stream, matching readStream, while the
-        // fold sees only owned orchestration events — exactly what load() computes.
-        return [...streams.values()].map((streamEvents) => ({
-            sequence: streamEvents.length,
-            view: foldWorkflowInstance(streamEvents
-                .map(selectWorkflowOrchestrationEvent)
-                .filter((event) => event !== null && isWorkflowInstanceStream(event.stream))),
-        }));
+        return this.listed.get();
     }
 }
 function isWorkflowEvent(event) {
     return isWorkflowInstanceStream(event.stream);
 }
+// `sequence` counts every event on the stream, matching readStream, while the
+// fold sees only owned orchestration events — exactly what load() computes.
+function deriveList(events) {
+    const streams = new Map();
+    for (const event of events) {
+        if (!isWorkflowInstanceStream(event.stream))
+            continue;
+        const existing = streams.get(event.stream.id);
+        if (existing === undefined)
+            streams.set(event.stream.id, [event]);
+        else
+            existing.push(event);
+    }
+    return [...streams.values()].map((streamEvents) => ({
+        sequence: streamEvents.length,
+        view: foldWorkflowInstance(streamEvents
+            .map(selectWorkflowOrchestrationEvent)
+            .filter((event) => event !== null && isWorkflowInstanceStream(event.stream))),
+    }));
+}

package/dist/src/persistence/filesystem/file-event-journal.js

@@ -73,6 +73,10 @@ export class FileEventJournal {
             .slice(-limit)
             .reverse();
     }
+    async latestGlobalPosition() {
+        const events = await this.scan();
+        return events.at(-1)?.globalPosition ?? 0;
+    }
     async scan() {
         const directory = join(this.root, 'events');
         let files;

package/dist/src/persistence/memory/in-memory-event-journal.js

@@ -55,6 +55,9 @@ export class InMemoryEventJournal {
             .slice(-limit)
             .reverse();
     }
+    async latestGlobalPosition() {
+        return this.events.length;
+    }
     rejectChangedEventIds(drafts, existingEvents) {
         for (const [index, draft] of drafts.entries()) {
             const existing = existingEvents[index];