@atolis-hq/wake 0.3.79 → 0.3.81

package/dist/src/bootstrap/resource-transition-evidence.js

@@ -1,17 +1,27 @@
 import { ResourceCorrelationRole } from '../resources/index.js';
 export function createCapabilityResourceTransitionEvidence(input) {
+    const registrationFor = (capabilities) => input.policies.find((registration) => registration.capabilities.some((capability) => capabilities.includes(capability)));
     return {
         triggers: [...new Set(input.policies.flatMap(({ policy }) => policy.triggers))],
         async resolve(evidence) {
+            // A work item may hold several primary correlations (e.g. its
+            // originating issue and an implementation PR). Only the correlation
+            // whose resource matches a registered policy's capabilities is
+            // relevant here; the rest drop out rather than blocking resolution.
             const correlations = await input.resources.correlationsForWork(evidence.workItemId);
             const primaries = correlations.filter(({ role }) => role === ResourceCorrelationRole.Primary);
-            if (primaries.length !== 1)
+            const registrations = [];
+            for (const primary of primaries) {
+                const resource = await input.resources.get(primary.resourceId);
+                if (resource === null)
+                    continue;
+                const registration = registrationFor(resource.capabilities);
+                if (registration !== undefined)
+                    registrations.push(registration);
+            }
+            if (registrations.length !== 1)
                 return null;
-            const resource = await input.resources.get(primaries[0].resourceId);
-            if (resource === null)
-                return null;
-            const registration = input.policies.find(({ capabilities }) => capabilities.some((capability) => resource.capabilities.includes(capability)));
-            return registration?.policy.resolve(evidence) ?? null;
+            return registrations[0].policy.resolve(evidence);
         },
     };
 }

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 = "gb43010f";
+export const wakeVersion = "gb8f09ad";

package/dist/src/orchestration/domain/operator-retry-policy.js

@@ -1,22 +1,36 @@
 import { ActivityOutcomeKind, BuiltInActivityName } from '../../activities/index.js';
 import { OrchestrationEventType, WatchGateVerdictSignal } from '../contracts/events.js';
-import { stageName, watchId } from '../contracts/identifiers.js';
+import { signalName, stageName, watchId } from '../contracts/identifiers.js';
 import { ActivityActivationStatus, ApprovalAuthorityKind, WorkflowStatus, } from '../contracts/vocabulary.js';
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
+// `then: await-human` on a `failed` route compiles its wait to this literal
+// signal name (see compileTarget); a workflow parked there has exhausted
+// whatever automatic retries it had and is durably equivalent to a blocked
+// failed stage for operator-retry purposes.
+const FailedOutcomeSignal = signalName(ActivityOutcomeKind.Failed);
 export function isOperatorRetryEligible(view) {
     const pending = view.pendingActivation;
-    const eligibleActivation = view.status === WorkflowStatus.Blocked &&
-        pending !== undefined &&
+    const eligibleActivation = pending !== undefined &&
         pending.status === ActivityActivationStatus.Completed &&
         pending.supplemental !== true &&
         pending.followOnIndex === undefined &&
         view.acceptedOutcomes.includes(pending.activationId);
     if (!eligibleActivation || pending === undefined)
         return false;
+    if (view.status === WorkflowStatus.Blocked)
+        return isRetryEligibleBlock(view, pending);
+    return isRetryEligibleFailedWait(view);
+}
+function isRetryEligibleBlock(view, pending) {
     return ((view.blockReason === 'unconfigured outcome failed' &&
         view.lastOutcome?.kind === ActivityOutcomeKind.Failed) ||
         view.executionFailure?.activationId === pending.activationId);
 }
+function isRetryEligibleFailedWait(view) {
+    return (view.status === WorkflowStatus.Waiting &&
+        view.waitingFor?.signalKind === FailedOutcomeSignal &&
+        view.lastOutcome?.kind === ActivityOutcomeKind.Failed);
+}
 export function selectOperatorRetryTarget(workflows) {
     const primary = workflows.find((workflow) => workflow.parentWorkflowInstanceId === undefined);
     if (primary === undefined)
@@ -52,7 +66,7 @@ export function requestOperatorRetry(definition, state, input) {
     if (!isOperatorRetryEligible(state))
         return {
             kind: 'ignored',
-            reason: 'workflow is not blocked for a retryable failed stage',
+            reason: 'workflow is not in a retryable failed-stage state',
         };
     const stage = definition.stages[stageName(state.currentStage)];
     const events = [

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

@@ -53,9 +53,10 @@ export class FileEventJournal {
                 const directory = join(this.root, 'events');
                 await mkdir(directory, { recursive: true });
                 const day = recordedAt.slice(0, 10);
-                await appendFile(join(directory, `${day}.jsonl`), newEnvelopes.map((event) => JSON.stringify(event)).join('\n') + '\n', 'utf8');
+                const file = `${day}.jsonl`;
+                await appendFile(join(directory, file), newEnvelopes.map((event) => JSON.stringify(event)).join('\n') + '\n', 'utf8');
+                await this.extendCache(file, current, newEnvelopes);
             }
-            this.cached = undefined;
             return finalizedEnvelopes;
         });
     }
@@ -77,6 +78,20 @@ export class FileEventJournal {
         const events = await this.scan();
         return events.at(-1)?.globalPosition ?? 0;
     }
+    // Extends the cache in place rather than invalidating it, so a self-caused
+    // write doesn't force the next read (by this call or any other reader
+    // sharing this instance) to re-parse the entire on-disk history. Only a
+    // change this instance didn't make itself — another process writing to the
+    // same journal — falls through to scan()'s full re-read.
+    async extendCache(file, priorEvents, newEnvelopes) {
+        const info = await stat(join(this.root, 'events', file));
+        const updatedEntry = { file, size: info.size, mtimeMs: info.mtimeMs };
+        const priorEntries = this.cached?.entries ?? [];
+        const entries = priorEntries.some((entry) => entry.file === file)
+            ? priorEntries.map((entry) => (entry.file === file ? updatedEntry : entry))
+            : [...priorEntries, updatedEntry];
+        this.cached = { entries, events: [...priorEvents, ...newEnvelopes] };
+    }
     async scan() {
         const directory = join(this.root, 'events');
         let files;
@@ -90,11 +105,11 @@ export class FileEventJournal {
                 return [];
             throw error;
         }
-        const fingerprint = (await Promise.all(files.map(async (file) => {
+        const entries = await Promise.all(files.map(async (file) => {
             const info = await stat(join(directory, file));
-            return `${file}:${info.size}:${info.mtimeMs}`;
-        }))).join('|');
-        if (this.cached?.fingerprint === fingerprint)
+            return { file, size: info.size, mtimeMs: info.mtimeMs };
+        }));
+        if (this.cached !== undefined && sameEntries(this.cached.entries, entries))
             return this.cached.events;
         const events = [];
         for (const file of files) {
@@ -115,10 +130,17 @@ export class FileEventJournal {
                 }
             }
         }
-        this.cached = { fingerprint, events };
+        this.cached = { entries, events };
         return events;
     }
 }
+function sameEntries(a, b) {
+    return (a.length === b.length &&
+        a.every((entry, index) => {
+            const other = b[index];
+            return (entry.file === other.file && entry.size === other.size && entry.mtimeMs === other.mtimeMs);
+        }));
+}
 const key = (stream) => `${stream.kind}:${stream.id}`;
 const sameDraft = (event, draft) => isDeepStrictEqual({
     eventId: event.eventId,

package/dist/src/persistence/filesystem/file-projection-store.js

@@ -17,9 +17,25 @@ export class FileProjectionStore {
             throw error;
         }
     }
+    // Patches the cached entry in place rather than invalidating the whole
+    // namespace, so a self-caused write doesn't force the next list() to
+    // re-read every other unchanged projection file in the namespace. Falls
+    // back to a full list() re-read for a namespace nothing has cached yet.
     async write(projection) {
-        await atomicJson(this.path(projection.namespace, projection.key), projection);
-        this.listCache.delete(projection.namespace);
+        const path = this.path(projection.namespace, projection.key);
+        await atomicJson(path, projection);
+        const cached = this.listCache.get(projection.namespace);
+        if (cached === undefined)
+            return;
+        const info = await stat(path);
+        const file = `${encode(projection.key)}.json`;
+        const updatedEntry = {
+            file,
+            size: info.size,
+            mtimeMs: info.mtimeMs,
+            value: projection,
+        };
+        this.listCache.set(projection.namespace, [...cached.filter((entry) => entry.file !== file), updatedEntry].sort((a, b) => a.file < b.file ? -1 : a.file > b.file ? 1 : 0));
     }
     // Callers (advance-once, orchestration-service, DeliveryService, ...) list()
     // an entire namespace unconditionally on every control-plane tick, even when
@@ -41,16 +57,21 @@ export class FileProjectionStore {
             }
             throw error;
         }
-        const fingerprint = (await Promise.all(files.map(async (file) => {
+        const stats = await Promise.all(files.map(async (file) => {
             const info = await stat(join(directory, file));
-            return `${file}:${info.size}:${info.mtimeMs}`;
-        }))).join('|');
+            return { file, size: info.size, mtimeMs: info.mtimeMs };
+        }));
         const cached = this.listCache.get(namespace);
-        if (cached?.fingerprint === fingerprint)
-            return cached.entries;
-        const entries = await Promise.all(files.map(async (file) => JSON.parse(await readFile(join(directory, file), 'utf8'))));
-        this.listCache.set(namespace, { fingerprint, entries });
-        return entries;
+        if (cached !== undefined && sameProjectionFiles(cached, stats))
+            return cached.map((entry) => entry.value);
+        const entries = await Promise.all(stats.map(async ({ file, size, mtimeMs }) => ({
+            file,
+            size,
+            mtimeMs,
+            value: JSON.parse(await readFile(join(directory, file), 'utf8')),
+        })));
+        this.listCache.set(namespace, entries);
+        return entries.map((entry) => entry.value);
     }
     async clear(namespace) {
         await rm(namespace === undefined
@@ -65,6 +86,13 @@ export class FileProjectionStore {
         return join(this.root, 'projections', encode(namespace), `${encode(key)}.json`);
     }
 }
+function sameProjectionFiles(cached, stats) {
+    return (cached.length === stats.length &&
+        cached.every((entry, index) => {
+            const other = stats[index];
+            return (entry.file === other.file && entry.size === other.size && entry.mtimeMs === other.mtimeMs);
+        }));
+}
 export function encode(value) {
     if (value.length === 0 || /[\\/]/.test(value))
         throw new Error('Storage name must not contain path separators');

package/package.json

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