@atolis-hq/wake 0.3.75 → 0.3.77

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-applications.js

@@ -203,12 +203,21 @@ function createSystemApplications(root, now) {
                         detail: `rolled back from ${selfUpdateFailure.tag} at ${selfUpdateFailure.occurredAt}: ${selfUpdateFailure.message}`,
                     },
             ];
+            const adapters = root.providers.flatMap((instance) => (instance.health?.() ?? []).map((check) => ({
+                adapter: instance.adapter,
+                provider: instance.provider,
+                ...check,
+            })));
             return {
                 data: {
-                    status: checks.some((check) => check.status === 'degraded') ? 'degraded' : 'ok',
+                    status: checks.some((check) => check.status === 'degraded') ||
+                        adapters.some((check) => check.status === 'degraded')
+                        ? 'degraded'
+                        : 'ok',
                     version: wakeVersion,
                     checkedAt,
                     checks,
+                    adapters,
                 },
                 meta: sampledMeta(checkedAt),
             };

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 = "g370f0e6";
+export const wakeVersion = "gd101844";

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/adapter-health-tracker.js

@@ -0,0 +1,43 @@
+const DEFINITIVE_STATUSES = new Set([401, 403, 429]);
+export function createAdapterHealthTracker(options = {}) {
+    const now = options.now ?? Date.now;
+    const threshold = options.degradeAfterConsecutiveFailures ?? 3;
+    let successCount = 0;
+    let failureCount = 0;
+    let consecutiveFailures = 0;
+    let degradedDetail;
+    return {
+        recordSuccess() {
+            successCount += 1;
+            consecutiveFailures = 0;
+            degradedDetail = undefined;
+        },
+        recordFailure(error) {
+            failureCount += 1;
+            consecutiveFailures += 1;
+            const status = statusOf(error);
+            const occurredAt = new Date(now()).toISOString();
+            const message = error instanceof Error ? error.message : String(error);
+            if (status !== undefined && DEFINITIVE_STATUSES.has(status)) {
+                degradedDetail = `${status} at ${occurredAt}: ${message}`;
+                return;
+            }
+            if (consecutiveFailures >= threshold) {
+                degradedDetail = `${consecutiveFailures} consecutive failures, last: ${status ?? 'error'} at ${occurredAt}: ${message}`;
+            }
+        },
+        snapshot() {
+            return {
+                status: degradedDetail === undefined ? 'ok' : 'degraded',
+                ...(degradedDetail === undefined ? {} : { detail: degradedDetail }),
+                successCount,
+                failureCount,
+            };
+        },
+    };
+}
+function statusOf(error) {
+    if (typeof error !== 'object' || error === null || !('status' in error))
+        return undefined;
+    return typeof error.status === 'number' ? error.status : undefined;
+}

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/contracts/provider.js

@@ -18,11 +18,14 @@ export class ProviderRegistry {
                 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 }),
-                }));
+                instances.push({
+                    ...definition.create({
+                        adapter,
+                        config: definition.parseConfig(entry),
+                        ...(services === undefined ? {} : { services }),
+                    }),
+                    provider,
+                });
             }
             catch (error) {
                 failures.push({

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

@@ -1,4 +1,5 @@
 import { GitHubEventType } from '../contracts/events.js';
+import { createGitHubAdapterHealthRegistry, } from './adapter-health-registry.js';
 import { issueCommentEventsFor, reviewCommentEventsFor, reviewEventsFor, } from './comment-source.js';
 import { issueObservation } from './issue-source.js';
 import { loadWatermark, overlapSince, reportPartialPollFailure, watermarkCheckpoint, } from './poll-watermark.js';
@@ -7,6 +8,7 @@ import { createGitHubRequestCoordinator, } from './request-coordinator.js';
 export function createGitHubSource(config, client, adapter, requests = createGitHubRequestCoordinator({
     maxConcurrent: config.polling.maxConcurrent,
 }), state) {
+    const health = state?.health ?? createGitHubAdapterHealthRegistry(config.repositories);
     // Draft eventIds are already content fingerprints (see issue-source.ts/pr-source.ts),
     // so the journal itself is idempotent per item. This cache only avoids re-appending
     // (and re-triggering downstream translation) an unchanged item on every poll within
@@ -14,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,
@@ -24,7 +35,8 @@ 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)
                 if (result.succeeded)
@@ -40,10 +52,11 @@ export function createGitHubSource(config, client, adapter, requests = createGit
             });
         },
         async markPollPersisted() {
-            if (state === undefined)
+            if (state?.checkpoints === undefined)
                 return;
+            const checkpoints = state.checkpoints;
             for (const [repository, watermark] of pendingWatermarks) {
-                await state.checkpoints.save(watermarkCheckpoint(adapter, repository), watermark);
+                await checkpoints.save(watermarkCheckpoint(adapter, repository), watermark);
                 pendingWatermarks.delete(repository);
             }
         },
@@ -72,7 +85,7 @@ function limitGitHubSourceClient(client, requests) {
     };
 }
 async function pollRepository(input) {
-    const { client, config, adapter, signal, owner, repo } = input;
+    const { client, config, adapter, signal, owner, repo, health } = input;
     const queriedAt = input.now();
     const context = {
         client,
@@ -87,10 +100,18 @@ async function pollRepository(input) {
         client.listIssues(owner, repo, config.polling.maxPerRepo, since),
         client.listPullRequests(owner, repo, config.polling.maxPerRepo),
     ]);
-    if (!isFulfilled(issuesResult))
+    if (isFulfilled(issuesResult))
+        health.recordSuccess(context.repository, 'poll');
+    else {
         reportPartialPollFailure(context.repository, 'issues');
-    if (!isFulfilled(pullRequestsResult))
+        health.recordFailure(context.repository, 'poll', issuesResult.reason);
+    }
+    if (isFulfilled(pullRequestsResult))
+        health.recordSuccess(context.repository, 'poll');
+    else {
         reportPartialPollFailure(context.repository, 'pull requests');
+        health.recordFailure(context.repository, 'poll', pullRequestsResult.reason);
+    }
     const issues = isFulfilled(issuesResult) ? issuesResult.value : [];
     const pullRequestPayloads = isFulfilled(pullRequestsResult)
         ? pullRequestsResult.value.filter((pullRequest) => since === undefined || pullRequest.updated_at >= since)

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

@@ -6,6 +6,7 @@ import { translateGitHubOutbound } from './application/outbound-translator.js';
 import { createGitHubWakeLabelReconciler } from './application/wake-labels.js';
 import { gitHubConfigSchema } from './contracts/config.js';
 import { GitHubEventType } from './contracts/events.js';
+import { createGitHubAdapterHealthRegistry } from './infrastructure/adapter-health-registry.js';
 import { createGitHubClient } from './infrastructure/client.js';
 import { createGitHubDelivery } from './infrastructure/delivery.js';
 import { resolveGitHubCliToken } from './infrastructure/gh-auth.js';
@@ -24,12 +25,14 @@ export const gitHubProviderDefinition = {
         const requests = createGitHubRequestCoordinator({
             maxConcurrent: config.polling.maxConcurrent,
         });
+        const health = createGitHubAdapterHealthRegistry(config.repositories);
         return {
             adapter,
             eventTypes: Object.values(GitHubEventType),
             source: createGitHubSource(config, client, adapter, requests, {
                 checkpoints: services.checkpoints,
                 now: () => services.clock.now().getTime(),
+                health,
             }),
             maintenance: createGitHubWakeLabelReconciler({
                 orchestration: services.orchestration,
@@ -39,16 +42,29 @@ export const gitHubProviderDefinition = {
                 setLabels: client.setIssueLabels,
                 requests,
             }),
+            health: () => health.snapshotAll(),
             delivery: createGitHubDelivery(async (intent, idempotencyKey) => {
                 const resource = await services.resources.get(resourceId(intent.resourceId));
                 if (resource === null)
                     throw new Error(`GitHub resource ${intent.resourceId} is unavailable`);
-                return client.deliver({
-                    ...translateGitHubOutbound(resource, intent, {
-                        publicUiUrl: services.publicUiUrl,
-                    }),
-                    idempotencyKey,
-                });
+                const parsedKey = parsePullRequestKey(resource.externalKey.key);
+                const repository = parsedKey === null ? null : `${parsedKey.owner}/${parsedKey.repo}`;
+                try {
+                    const externalId = await client.deliver({
+                        ...translateGitHubOutbound(resource, intent, {
+                            publicUiUrl: services.publicUiUrl,
+                        }),
+                        idempotencyKey,
+                    });
+                    if (repository !== null)
+                        health.recordSuccess(repository, 'deliver');
+                    return externalId;
+                }
+                catch (error) {
+                    if (repository !== null)
+                        health.recordFailure(repository, 'deliver', error);
+                    throw error;
+                }
             }, async (intent) => {
                 if (intent.kind !== BuiltInActivityName.IssueComplete)
                     return null;

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];