@atolis-hq/wake 0.3.76 → 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/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 = "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/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/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];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atolis-hq/wake",
-  "version": "0.3.76",
+  "version": "0.3.77",
   "description": "Local autonomous agent control plane for software development",
   "license": "Apache-2.0",
   "repository": {