@atolis-hq/wake 0.3.28 → 0.3.30

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 = "g69f927b";
+export const wakeVersion = "ga9fe8dd";

package/dist/src/integrations/github/application/inbound-review-signals.js

@@ -4,6 +4,7 @@ import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resou
 import { WorkStatus } from '../../../work/index.js';
 import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
 import { commandContext } from './inbound-context.js';
+import { ignoreIneligibleOperatorRetry } from './operator-retry-command.js';
 import { translateGitHubReviewCommand } from './review-command-translator.js';
 export async function applyReviewSignal(input) {
     const { event, journal, resources, work, lookup, adapter, orchestration } = input;
@@ -116,7 +117,7 @@ async function applyIssueRetrySignal(input) {
         const item = await work.get(workflow.workItemId);
         if (item === null || item.deleted || item.frozen || item.state !== WorkStatus.Open)
             continue;
-        await orchestration.retryBlockedFailedStage(workflow.workflowInstanceId, commandContext(event));
+        await ignoreIneligibleOperatorRetry(() => orchestration.retryBlockedFailedStage(workflow.workflowInstanceId, commandContext(event)));
     }
 }
 async function applyIssueApprovalSignal(input) {

package/dist/src/integrations/github/application/inbound-translator.js

@@ -1,12 +1,12 @@
 /* eslint-disable max-lines */
 import { ActivityEventType, createPullRequestService, } from '../../../activities/index.js';
-import { UlidIdGenerator, } from '../../../kernel/index.js';
+import { createEventDraft, EventActorKind, EventSourceKind, UlidIdGenerator, WrongExpectedSequenceError, } from '../../../kernel/index.js';
 import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, ResourceEventType, resourceId, resourceStream, } from '../../../resources/index.js';
 import { workItemId } from '../../../work/index.js';
 import { admitObservedWork } from '../../application/work-admission.js';
 import { concludeObservedWork } from '../../application/work-conclusion.js';
 import { evaluateIntakeRules } from '../../contracts/intake-rules.js';
-import { deliveryStream } from '../../contracts/streams.js';
+import { deliveryStream, integrationStream } from '../../contracts/streams.js';
 import { DeliveryEventType, selectDeliveryEvent } from '../../delivery/contracts/events.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
 import { GitHubAdapter } from '../contracts/vocabulary.js';
@@ -117,6 +117,10 @@ export class InboundTranslator {
         const identity = await this.resolveIdentity({ adapter: this.adapter, key: payload.externalKey }, intake.admitted);
         if (identity === null)
             return;
+        if (identity.deleted) {
+            await this.recordDeletedWorkObservation(event, identity.workItemId);
+            return;
+        }
         if (!identity.created) {
             await this.applyReobservation({
                 payload,
@@ -244,25 +248,85 @@ export class InboundTranslator {
         const key = `${externalKey.adapter}:${externalKey.key}`;
         const inBatch = this.minted.get(key);
         if (inBatch !== undefined)
-            return { ...inBatch, created: false };
+            return this.inBatchIdentity(inBatch);
         if (this.lookup === undefined)
             throw new Error('InboundTranslator lookup is required');
         const resourceIdValue = await this.lookup.resourceIdForExternalKey(externalKey);
-        if (resourceIdValue !== null) {
-            if (this.resources === undefined)
-                throw new Error('InboundTranslator resources are required');
-            const correlation = (await this.resources.correlations(resourceIdValue)).find((value) => value.role === ResourceCorrelationRole.Primary);
-            // A deleted WorkItem retracts its primary correlation while retaining the external
-            // resource as a durable tombstone. Do not remint it or let it block later intake.
-            if (correlation === undefined)
-                return null;
-            const identity = { resourceId: resourceIdValue, workItemId: correlation.workItemId };
-            this.minted.set(key, identity);
-            return { ...identity, created: false };
-        }
+        if (resourceIdValue !== null)
+            return this.correlatedIdentity(key, resourceIdValue);
         // An ineligible object Wake has never seen produces no WorkItem, Run, or effect.
         if (!admitted)
             return null;
-        return { ...this.mintIdentity(externalKey), created: true };
+        return { ...this.mintIdentity(externalKey), created: true, deleted: false };
+    }
+    async inBatchIdentity(identity) {
+        const existing = await this.work?.get(identity.workItemId);
+        return { ...identity, created: false, deleted: existing?.deleted === true };
+    }
+    async correlatedIdentity(key, resourceIdValue) {
+        if (this.resources === undefined)
+            throw new Error('InboundTranslator resources are required');
+        const correlation = (await this.resources.correlations(resourceIdValue)).find((value) => value.role === ResourceCorrelationRole.Primary);
+        if (correlation === undefined)
+            return this.historicalIdentity(resourceIdValue);
+        const identity = { resourceId: resourceIdValue, workItemId: correlation.workItemId };
+        this.minted.set(key, identity);
+        return { ...identity, created: false, deleted: false };
+    }
+    async historicalIdentity(resourceIdValue) {
+        const historical = await this.resources.primaryCorrelation(resourceIdValue);
+        if (historical === null)
+            throw new Error(`Resource ${resourceIdValue} has no primary correlation`);
+        const historicalWork = await this.work?.get(historical.workItemId);
+        if (historicalWork?.deleted)
+            return {
+                resourceId: resourceIdValue,
+                workItemId: historical.workItemId,
+                created: false,
+                deleted: true,
+            };
+        throw new Error(`Resource ${resourceIdValue} has no active primary correlation`);
+    }
+    async recordDeletedWorkObservation(event, workItemId) {
+        const stream = integrationStream(this.adapter);
+        const eventId = `github:deleted-work-skip:${event.eventId}:${workItemId}`;
+        const payload = {
+            externalKey: event.payload.externalKey,
+            workItemId,
+            sourceEventId: event.eventId,
+            revision: event.payload.revision,
+            reason: 'work-item-deleted',
+        };
+        for (;;) {
+            const existing = await this.journal.readStream(stream);
+            const recorded = existing.find((candidate) => candidate.eventId === eventId);
+            if (recorded !== undefined) {
+                const diagnostic = selectGitHubAdapterEvent(recorded);
+                if (diagnostic?.eventType !== GitHubEventType.DeletedWorkObservationSkipped ||
+                    JSON.stringify(diagnostic.payload) !== JSON.stringify(payload))
+                    throw new Error(`Event id ${eventId} has already been used with different content`);
+                return;
+            }
+            try {
+                await this.journal.append(stream, existing.length, [
+                    createEventDraft({
+                        eventId,
+                        eventType: GitHubEventType.DeletedWorkObservationSkipped,
+                        occurredAt: event.occurredAt,
+                        correlationId: event.correlationId,
+                        causationId: event.eventId,
+                        actor: { kind: EventActorKind.Integration, id: this.adapter },
+                        source: { kind: EventSourceKind.Internal, id: 'github-inbound-translator' },
+                        stream,
+                        payload,
+                    }),
+                ]);
+                return;
+            }
+            catch (error) {
+                if (!(error instanceof WrongExpectedSequenceError))
+                    throw error;
+            }
+        }
     }
 }

package/dist/src/integrations/github/application/operator-retry-command.js

@@ -0,0 +1,11 @@
+import { OperatorRetryIneligibleError } from '../../../orchestration/index.js';
+export async function ignoreIneligibleOperatorRetry(retry) {
+    try {
+        await retry();
+    }
+    catch (error) {
+        if (error instanceof OperatorRetryIneligibleError)
+            return;
+        throw error;
+    }
+}

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

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { ProviderPermission, PullRequestCheckState, PullRequestState, ReviewActorKind, ReviewerAuthorizationSource, } from '../../../activities/index.js';
-import { eventEnvelopeSchema, } from '../../../kernel/index.js';
+import { brandedStringSchema, eventEnvelopeSchema, } from '../../../kernel/index.js';
+import { workItemId } from '../../../work/index.js';
 import { adapterId } from '../../contracts/identifiers.js';
 import { ExternalWorkOutcome } from '../../contracts/outcome-vocabulary.js';
 import { IntegrationStreamKind } from '../../contracts/streams.js';
@@ -8,6 +9,7 @@ export const GitHubEventType = {
     WorkObserved: 'integration.github.work-observed',
     CommentObserved: 'integration.github.comment-observed',
     DeliveryObserved: 'integration.github.delivery-observed',
+    DeletedWorkObservationSkipped: 'integration.github.deleted-work-observation-skipped',
 };
 const streamSchema = z
     .object({
@@ -114,6 +116,19 @@ const eventSchema = z.discriminatedUnion('eventType', [
         stream: streamSchema,
         payload: z.object({ deliveryId: z.string(), raw: rawSchema }).strict(),
     }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(GitHubEventType.DeletedWorkObservationSkipped),
+        stream: streamSchema,
+        payload: z
+            .object({
+            externalKey: z.string(),
+            workItemId: brandedStringSchema(workItemId),
+            sourceEventId: z.string(),
+            revision: z.string(),
+            reason: z.literal('work-item-deleted'),
+        })
+            .strict(),
+    }),
 ]);
 export function decodeGitHubAdapterEvent(event) {
     const result = eventSchema.safeParse(event);

package/dist/src/resources/application/resource-lookup.js

@@ -1,3 +1,6 @@
+import { ResourceEventType, selectResourceEvent } from '../contracts/events.js';
+import { resourceStream } from '../contracts/streams.js';
+import { ResourceCorrelationRole } from '../contracts/vocabulary.js';
 import { externalKeyProjectionKey, resourcesByExternalKeyProjection, workCorrelationsProjection, } from './lookup-projections.js';
 export function createResourceLookup(dependencies) {
     const seeded = async (definition, key) => {
@@ -12,5 +15,32 @@ export function createResourceLookup(dependencies) {
     return {
         resourceIdForExternalKey: (externalKey) => seeded(resourcesByExternalKeyProjection, externalKeyProjectionKey(externalKey)),
         correlationsForWork: (workItemId) => seeded(workCorrelationsProjection, workItemId),
+        async primaryCorrelation(resourceId) {
+            const active = new Map();
+            const retracted = [];
+            for (const event of await dependencies.journal.readStream(resourceStream(resourceId))) {
+                const owned = selectResourceEvent(event);
+                if (owned?.eventType === ResourceEventType.WorkCorrelationEstablished) {
+                    active.set(owned.payload.workItemId, {
+                        resourceId,
+                        workItemId: owned.payload.workItemId,
+                        role: owned.payload.role,
+                        provenance: owned.payload.provenance,
+                        establishedByEventId: owned.eventId,
+                    });
+                }
+                if (owned?.eventType === ResourceEventType.WorkCorrelationRetracted) {
+                    const correlation = active.get(owned.payload.workItemId);
+                    if (correlation !== undefined) {
+                        active.delete(owned.payload.workItemId);
+                        if (correlation.role === ResourceCorrelationRole.Primary)
+                            retracted.push(correlation);
+                    }
+                }
+            }
+            return ([...active.values()].find((value) => value.role === ResourceCorrelationRole.Primary) ??
+                retracted.at(-1) ??
+                null);
+        },
     };
 }

package/dist/src/resources/application/resource-service.js

@@ -17,6 +17,7 @@ export function createResourceService(journal, lookup) {
         async correlations(resourceId) {
             return (await repository.load(resourceId)).resource?.correlations ?? [];
         },
+        primaryCorrelation: (resourceId) => lookup.primaryCorrelation(resourceId),
         correlationsForWork: (workItemId) => lookup.correlationsForWork(workItemId),
         correlate: (resourceId, workItemId, role, context, provenance) => correlateResource(repository, resourceId, workItemId, role, context, provenance),
         async retract(resourceId, workItemId, context) {

package/package.json

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