@atolis-hq/wake 0.3.10 → 0.3.12

package/dist/src/activities/contracts/event-schema.js

@@ -116,6 +116,14 @@ export const deniedOutcomeSchema = z
     .strict();
 export function createResourceFactDraftSchemas(eventTypes) {
     return [
+        resourceFactDraft(eventTypes.IssueCompleteRequested, z
+            .object({
+            idempotencyKey: z.string(),
+            activationId: brandedStringSchema(activationId),
+            workflowInstanceId: z.string().min(1),
+            resourceId: resourceIdSchema,
+        })
+            .strict()),
         resourceFactDraft(eventTypes.PrDiscovered, z
             .object({
             workItemId: workItemIdSchema,
@@ -210,7 +218,7 @@ function createDecisionClaimSchemas(eventTypes, resourceFacts, denials) {
             activationId: brandedStringSchema(activationId),
             decisionKind: z.literal('requested'),
             outcome: requestedOutcomeSchema,
-            fact: resourceFacts[9],
+            fact: resourceFacts[10],
         })
             .strict(),
         z
@@ -230,7 +238,7 @@ function createDecisionClaimSchemas(eventTypes, resourceFacts, denials) {
             activationId: brandedStringSchema(activationId),
             decisionKind: z.literal('requested'),
             outcome: requestedOutcomeSchema,
-            fact: resourceFacts[10],
+            fact: resourceFacts[11],
         })
             .strict(),
         z

package/dist/src/activities/contracts/events.js

@@ -1,5 +1,6 @@
 import { createActivityEventSchemas } from './event-schema.js';
 export const ActivityEventType = {
+    IssueCompleteRequested: 'issue.complete-requested',
     PrDiscovered: 'pr.discovered',
     PrRevisionChanged: 'pr.revision-changed',
     PrStateChanged: 'pr.state-changed',
@@ -34,6 +35,7 @@ export function decodeActivityEventDraft(draft) {
 }
 function ownsActivityEventType(eventType) {
     return (eventType.startsWith('activities.') ||
+        eventType.startsWith('issue.') ||
         eventType.startsWith('pr.') ||
         eventType.startsWith('review.'));
 }

package/dist/src/activities/contracts/vocabulary.js

@@ -55,4 +55,5 @@ export const BuiltInActivityName = {
     Agent: activityName(ActivityExecutionKind.Agent),
     PullRequestApprove: activityName('pr.approve'),
     PullRequestMerge: activityName('pr.merge'),
+    IssueComplete: activityName('issue.complete'),
 };

package/dist/src/activities/index.js

@@ -1,6 +1,7 @@
 export * from './agent/agent-activity-definition.js';
 export * from './agent/agent-activity.js';
 export * from './agent/agent-result.js';
+export * from './issue/complete.js';
 export * from './contracts/activity.js';
 export * from './contracts/config.js';
 export * from './contracts/events.js';

package/dist/src/activities/issue/complete.js

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { createEventDraft, EventActorKind, EventSourceKind, } from '../../kernel/index.js';
+import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, resourceStream, } from '../../resources/index.js';
+import { ActivityEventType } from '../contracts/events.js';
+import { ActivityExecutionKind, ActivityOutcomeKind, ActivityResourceRole, BuiltInActivityName, } from '../contracts/vocabulary.js';
+const inputSchema = z
+    .object({ target: z.literal(ActivityResourceRole.Primary).default(ActivityResourceRole.Primary) })
+    .strict();
+const outcomeSchema = z.union([
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Done),
+        data: z.object({ deliveryEventId: z.string() }).strict(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Waiting),
+        data: z
+            .object({ intentEventId: z.string(), signalKind: z.literal('delivery-result') })
+            .strict(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Blocked),
+        data: z.object({ reason: z.literal('missing-completable-primary-issue') }).strict(),
+    })
+        .strict(),
+]);
+/** Requests completion of the one primary issue only; delivery owns provider effects. */
+export function createIssueCompleteActivity(journal, resources) {
+    return {
+        name: BuiltInActivityName.IssueComplete,
+        inputSchema,
+        outcomeSchema,
+        outcomeKinds: [
+            ActivityOutcomeKind.Waiting,
+            ActivityOutcomeKind.Done,
+            ActivityOutcomeKind.Blocked,
+        ],
+        resources: [],
+        executionKind: ActivityExecutionKind.Deterministic,
+        handler: {
+            execute: (invocation, context) => execute(journal, resources, invocation, context.occurredAt),
+        },
+    };
+}
+async function execute(journal, resources, invocation, occurredAt) {
+    const candidates = await Promise.all(invocation.resources.map(async (candidate) => ({
+        candidate,
+        correlations: await resources.correlations(candidate.resourceId),
+    })));
+    const resource = candidates.filter(({ candidate, correlations }) => candidate.kind === BuiltInResourceKind.Issue &&
+        candidate.capabilities.includes(BuiltInResourceCapability.Completable) &&
+        correlations.some((correlation) => correlation.role === ResourceCorrelationRole.Primary &&
+            correlation.workItemId === invocation.workItemId));
+    if (resource.length !== 1)
+        return {
+            kind: ActivityOutcomeKind.Blocked,
+            data: { reason: 'missing-completable-primary-issue' },
+        };
+    const target = resource[0].candidate;
+    const eventId = `${invocation.activationId}:${ActivityEventType.IssueCompleteRequested}`;
+    const stream = resourceStream(target.resourceId);
+    const existing = await journal.readStream(stream);
+    if (!existing.some((event) => event.eventId === eventId)) {
+        await journal.append(stream, existing.length, [
+            createEventDraft({
+                eventId,
+                eventType: ActivityEventType.IssueCompleteRequested,
+                occurredAt,
+                correlationId: invocation.orchestrationGroupId,
+                causationId: invocation.activationId,
+                actor: { kind: EventActorKind.System, id: 'activities-issue' },
+                source: { kind: EventSourceKind.Internal, id: 'activities-issue' },
+                stream,
+                payload: {
+                    idempotencyKey: eventId,
+                    activationId: invocation.activationId,
+                    workflowInstanceId: invocation.workflowInstanceId,
+                    resourceId: target.resourceId,
+                },
+            }),
+        ]);
+    }
+    return {
+        kind: ActivityOutcomeKind.Waiting,
+        data: { intentEventId: eventId, signalKind: 'delivery-result' },
+    };
+}

package/dist/src/activities/pr/projection.js

@@ -77,6 +77,7 @@ function projectPullRequest(previous, event) {
 }
 function ignorePullRequestEvent(previous, event) {
     switch (event.eventType) {
+        case ActivityEventType.IssueCompleteRequested:
         case ActivityEventType.ReviewAcceptanceSignalRecorded:
         case ActivityEventType.PrReviewRejected:
         case ActivityEventType.PrMergeDenied:
@@ -120,6 +121,7 @@ function ignoreAcceptedSignalFact(previous, event) {
         case ActivityEventType.PrMergeAuthorized:
         case ActivityEventType.PrApproveRequested:
         case ActivityEventType.PrMergeRequested:
+        case ActivityEventType.IssueCompleteRequested:
             return previous;
         default:
             return assertNever(event);

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

@@ -1,4 +1,4 @@
-import { ActivityRegistry, agentActivityDefinition, createAgentActivity, createPullRequestApproveActivity, createPullRequestMergeActivity, createPullRequestService, } from '../activities/index.js';
+import { ActivityRegistry, agentActivityDefinition, createAgentActivity, createIssueCompleteActivity, createPullRequestApproveActivity, createPullRequestMergeActivity, createPullRequestService, } from '../activities/index.js';
 import { ControlStreamKind, DispatchPolicy, ScheduleService, createAdvanceOnce, createControlPlaneService, createIntakePipeline, createRunnerControlService, createRunnerPipeline, createWorkCancellationPolicy, ineligibleRunners, } from '../control-plane/index.js';
 import { ExternalExecutionState, GitWorkspaceProvider, RecoveryService, RunRepository, TranscriptStore, createExecutionService, loadPromptTemplate, renderPromptTemplate, } from '../execution/index.js';
 import { AgentRunPublicationReactor, ArtifactRegistrationReactor, DeliveryOutcomeReactor, DeliveryService, IntegrationStreamKind, PollService, ProviderRegistry, fakeProviderDefinition, } from '../integrations/index.js';
@@ -370,6 +370,7 @@ function createBuiltInActivityRegistry(journal, pullRequests, resources, wakeRoo
         }, contextReader),
     });
     activities.register(createStatusPublishActivity(journal));
+    activities.register(createIssueCompleteActivity(journal, resources));
     activities.register(createPullRequestApproveActivity(journal, pullRequests));
     activities.register(createPullRequestMergeActivity(journal, pullRequests));
     return activities;

package/dist/src/bootstrap/surface-cli-applications.js

@@ -118,8 +118,7 @@ export async function runProjectionPump(root, signal) {
     const intervalMs = 1000;
     while (!signal.aborted) {
         try {
-            if (!(await root.isPaused()))
-                await root.projectionRunner.runRegisteredOnce();
+            await root.projectionRunner.runRegisteredOnce();
         }
         catch (error) {
             process.stderr.write(`Wake projection pump failed: ${error instanceof Error ? error.message : String(error)}\n`);

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 = "g7df87c0";
+export const wakeVersion = "g3e33fd6";

package/dist/src/control-plane/application/intake-pipeline.js

@@ -8,8 +8,10 @@ export function createIntakePipeline(stages) {
     const isPaused = async () => (await stages.isPaused?.()) ?? false;
     return {
         async run(signal) {
-            if (await isPaused())
+            if (await isPaused()) {
+                await stages.catchUpProjections();
                 return { processed: false };
+            }
             await stages.catchUpProjections();
             try {
                 if (await isPaused())
@@ -21,8 +23,7 @@ export function createIntakePipeline(stages) {
                 return { processed: polled > 0 || translated > 0 };
             }
             finally {
-                if (!(await isPaused()))
-                    await stages.catchUpProjections();
+                await stages.catchUpProjections();
             }
         },
     };

package/dist/src/control-plane/application/runner-pipeline.js

@@ -7,8 +7,10 @@
 export function createRunnerPipeline(stages) {
     const isPaused = async () => (await stages.isPaused?.()) ?? false;
     const runOnce = async (options, signal) => {
-        if (await isPaused())
+        if (await isPaused()) {
+            await stages.catchUpProjections();
             return { kind: 'paused' };
+        }
         await stages.catchUpProjections();
         try {
             if (await isPaused())
@@ -38,8 +40,7 @@ export function createRunnerPipeline(stages) {
             return result;
         }
         finally {
-            if (!(await isPaused()))
-                await stages.catchUpProjections();
+            await stages.catchUpProjections();
         }
     };
     // The API's manual Tick Now endpoint and the resident tick host share this

package/dist/src/integrations/delivery/application/delivery-projector.js

@@ -45,6 +45,23 @@ function intentView(event) {
 }
 function activityIntentView(event) {
     const intent = selectActivityEvent(event);
+    if (intent?.eventType === ActivityEventType.IssueCompleteRequested)
+        return {
+            eventId: intent.eventId,
+            view: {
+                intentEventId: intent.eventId,
+                globalPosition: intent.globalPosition,
+                workflowInstanceId: intent.payload.workflowInstanceId,
+                activationId: intent.payload.activationId,
+                kind: DeliveryIntentKind.IssueComplete,
+                resourceId: intent.payload.resourceId,
+                payload: { kind: DeliveryIntentKind.IssueComplete },
+                state: DeliveryState.Pending,
+                attempts: 0,
+                occurrenceOrdinal: 0,
+                reconciliationAttempts: 0,
+            },
+        };
     if (intent?.eventType === ActivityEventType.PrApproveRequested)
         return {
             eventId: intent.eventId,

package/dist/src/integrations/delivery/application/delivery-service.js

@@ -61,7 +61,7 @@ export class DeliveryService {
         const adapter = this.dependencies.adapter(resource.adapter);
         const occurrence = { ordinal: intent.occurrenceOrdinal + 1 };
         if (intent.state === DeliveryState.Ambiguous || intent.attempts > 0) {
-            const reconciled = await adapter.reconcile(intent.reconciliationKey ?? intent.intentEventId, signal);
+            const reconciled = await adapter.reconcile(intent, intent.reconciliationKey ?? intent.intentEventId, signal);
             await this.append(this.reconciled(intent, occurrence, reconciled));
             if (reconciled.kind === DeliveryResultKind.Unknown) {
                 const count = (intent.reconciliationAttempts ?? 0) + 1;

package/dist/src/integrations/delivery/contracts/vocabulary.js

@@ -16,6 +16,7 @@ export const DeliveryResultKind = defineClosedVocabulary({
 export const DeliveryIntentKind = {
     PrApprove: BuiltInActivityName.PullRequestApprove,
     PrMerge: BuiltInActivityName.PullRequestMerge,
+    IssueComplete: BuiltInActivityName.IssueComplete,
     StatusPublish: 'status.publish',
     ReplyPublish: 'reply.publish',
     AgentRunPublish: 'agent-run.publish',

package/dist/src/integrations/fake/durable-delivery-provider.js

@@ -30,7 +30,7 @@ export class DurableFakeDeliveryProvider {
     rememberAmbiguous(intentEventId, reconciliationKey) {
         this.ambiguous.set(reconciliationKey, intentEventId);
     }
-    async reconcile(reconciliationKey) {
+    async reconcile(_intent, reconciliationKey) {
         const intentEventId = this.ambiguous.get(reconciliationKey) ?? reconciliationKey;
         const externalId = this.effects.get(intentEventId);
         return externalId === undefined

package/dist/src/integrations/fake/inbound-translator.js

@@ -73,7 +73,7 @@ export class FakeInboundTranslator {
                         ? []
                         : [BuiltInResourceCapability.ChangedFiles]),
                 ]
-                : [BuiltInResourceCapability.Commentable],
+                : [BuiltInResourceCapability.Commentable, BuiltInResourceCapability.Completable],
             objective: evidence.title,
             tags: evidence.tags ?? [],
             ...(evidence.revision === undefined ? {} : { revision: evidence.revision }),
@@ -100,6 +100,9 @@ export class FakeInboundTranslator {
             }, context);
         if (isPullRequest)
             await this.observePullRequest(existing.resourceId, correlation.workItemId, evidence, event, context);
+        // Fake issue evidence has no terminal state, so its existing behaviour is
+        // intentionally unchanged; production inbound suppression lives with the
+        // provider observation that carries the terminal outcome.
         return true;
     }
     async observePullRequest(resourceId, workItemId, evidence, event, context) {

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

@@ -1,11 +1,13 @@
 /* eslint-disable max-lines */
-import { createPullRequestService, } from '../../../activities/index.js';
+import { ActivityEventType, createPullRequestService, } from '../../../activities/index.js';
 import { UlidIdGenerator, } from '../../../kernel/index.js';
-import { BuiltInResourceCapability, BuiltInResourceKind, ResourceCorrelationRole, resourceId, } from '../../../resources/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 { DeliveryEventType, selectDeliveryEvent } from '../../delivery/contracts/events.js';
 import { GitHubEventType, selectGitHubAdapterEvent } from '../contracts/events.js';
 import { GitHubAdapter } from '../contracts/vocabulary.js';
 import { commandContext } from './inbound-context.js';
@@ -140,7 +142,7 @@ export class InboundTranslator {
                     BuiltInResourceCapability.Revisioned,
                     BuiltInResourceCapability.ChangedFiles,
                 ]
-                : [BuiltInResourceCapability.Commentable],
+                : [BuiltInResourceCapability.Commentable, BuiltInResourceCapability.Completable],
             objective: payload.title,
             tags: intake.tags,
             revision: payload.revision,
@@ -165,7 +167,14 @@ export class InboundTranslator {
                 revision: payload.revision,
                 ...(current.title === undefined ? {} : { title: current.title }),
             }, context);
-            if (payload.outcome !== undefined && this.conclusion !== undefined) {
+            const wakeCompletion = await this.unconsumedWakeCompletion(resourceIdValue);
+            if (payload.outcome === undefined && wakeCompletion !== null) {
+                await this.supersedeWakeCompletion(resourceIdValue, wakeCompletion, context);
+            }
+            else if (payload.outcome !== undefined && wakeCompletion !== null) {
+                await this.consumeWakeCompletion(resourceIdValue, wakeCompletion, context);
+            }
+            else if (payload.outcome !== undefined && this.conclusion !== undefined) {
                 await concludeObservedWork({ work: this.work, conclusion: this.conclusion }, {
                     workItemId: workItemIdValue,
                     outcome: payload.outcome,
@@ -176,6 +185,33 @@ export class InboundTranslator {
         if (payload.kind === 'pull-request')
             await pullRequests.observe(observePullRequest(current.resourceId, workItemIdValue, payload), context);
     }
+    /** A confirmed completion consumes exactly one matching terminal observation. */
+    async unconsumedWakeCompletion(resourceIdValue) {
+        const events = await this.journal.readStream(resourceStream(resourceIdValue));
+        const intents = events.filter((event) => event.eventType === ActivityEventType.IssueCompleteRequested);
+        for (const intent of intents) {
+            if (events.some((event) => (event.eventType === ResourceEventType.IssueCompletionObservationConsumed ||
+                event.eventType === ResourceEventType.IssueCompletionObservationSuperseded) &&
+                event.payload !== null &&
+                typeof event.payload === 'object' &&
+                'intentEventId' in event.payload &&
+                event.payload.intentEventId === intent.eventId))
+                continue;
+            const deliveries = await this.journal.readStream(deliveryStream(intent.eventId));
+            if (deliveries.some((event) => {
+                const delivery = selectDeliveryEvent(event);
+                return delivery?.eventType === DeliveryEventType.Confirmed;
+            }))
+                return intent.eventId;
+        }
+        return null;
+    }
+    async consumeWakeCompletion(resourceIdValue, intentEventId, context) {
+        await this.resources.consumeIssueCompletion(resourceIdValue, intentEventId, context);
+    }
+    async supersedeWakeCompletion(resourceIdValue, intentEventId, context) {
+        await this.resources.supersedeIssueCompletion(resourceIdValue, intentEventId, context);
+    }
     mintIdentity(externalKey) {
         const key = `${externalKey.adapter}:${externalKey.key}`;
         const existing = this.minted.get(key);

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

@@ -37,6 +37,8 @@ function outboundAction(intent) {
             return 'autoMerge' in intent.payload && intent.payload.autoMerge
                 ? GitHubOutboundAction.EnableAutoMerge
                 : GitHubOutboundAction.Merge;
+        case DeliveryIntentKind.IssueComplete:
+            return GitHubOutboundAction.Close;
         case DeliveryIntentKind.StatusPublish:
             return GitHubOutboundAction.Status;
         case DeliveryIntentKind.ReplyPublish:

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

@@ -52,4 +52,5 @@ export const GitHubOutboundAction = {
     Merge: MergeMethod.Merge,
     Status: 'status',
     Reply: 'reply',
+    Close: 'close',
 };

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

@@ -1,5 +1,5 @@
 import { Octokit } from '@octokit/rest';
-import { MergeMethod } from '../../../activities/index.js';
+import { MergeMethod, PullRequestState } from '../../../activities/index.js';
 import { GitHubOutboundAction } from '../contracts/vocabulary.js';
 import { branch, getCombinedStatusForRef, getIssueLabels, getPullRequest, listCheckRunsForRef, listIssueComments, listIssues, listPullRequestFiles, listPullRequests, listReviewComments, listReviews, } from './client-reads.js';
 import { createEtagCache } from './etag-cache.js';
@@ -39,6 +39,10 @@ export function createGitHubClient(token) {
         listIssueComments: (owner, repo, issueNumber, pageSize) => listIssueComments(octokit, cache, owner, repo, issueNumber, pageSize),
         listReviewComments: (owner, repo, pullNumber, pageSize) => listReviewComments(octokit, cache, owner, repo, pullNumber, pageSize),
         getIssueLabels: (owner, repo, issueNumber) => getIssueLabels(octokit, cache, owner, repo, issueNumber),
+        getIssue: async (owner, repo, issueNumber) => octokit.rest.issues.get({ owner, repo, issue_number: issueNumber }).then(({ data }) => ({
+            id: String(data.id),
+            state: data.state,
+        })),
         setIssueLabels: async (owner, repo, issueNumber, labels) => {
             await octokit.rest.issues.setLabels({
                 owner,
@@ -78,6 +82,17 @@ async function deliver(octokit, command) {
     if (command.action === GitHubOutboundAction.EnableAutoMerge) {
         return enableAutoMerge(octokit, command);
     }
+    if (command.action === GitHubOutboundAction.Close) {
+        if (command.issue_number === undefined)
+            throw new Error('GitHub issue completion requires an issue');
+        const response = await octokit.rest.issues.update({
+            owner: command.owner,
+            repo: command.repo,
+            issue_number: command.issue_number,
+            state: PullRequestState.Closed,
+        });
+        return String(response.data.id);
+    }
     const issueNumber = command.issue_number ?? command.pull_number;
     if (issueNumber === undefined)
         throw new Error('GitHub comment requires an issue or pull request');

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

@@ -1,6 +1,7 @@
+import { BuiltInActivityName } from '../../../activities/index.js';
 import { DeliveryResultKind } from '../../delivery/contracts/vocabulary.js';
 const GitHubDeliveryFailureCode = 'github-error';
-export function createGitHubDelivery(deliver) {
+export function createGitHubDelivery(deliver, reconcileIssue) {
     return {
         async deliver(intent) {
             try {
@@ -17,8 +18,18 @@ export function createGitHubDelivery(deliver) {
                 };
             }
         },
-        async reconcile() {
-            return { kind: DeliveryResultKind.Unknown };
+        async reconcile(intent) {
+            if (intent.kind !== BuiltInActivityName.IssueComplete || reconcileIssue === undefined)
+                return { kind: DeliveryResultKind.Unknown };
+            try {
+                const externalId = await reconcileIssue(intent);
+                return externalId === null
+                    ? { kind: DeliveryResultKind.NotFound }
+                    : { kind: DeliveryResultKind.Confirmed, externalId };
+            }
+            catch {
+                return { kind: DeliveryResultKind.Unknown };
+            }
         },
     };
 }

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

@@ -1,3 +1,4 @@
+import { BuiltInActivityName, PullRequestState } from '../../activities/index.js';
 import { BuiltInResourceCapability, resourceId, resourceKind } from '../../resources/index.js';
 import { ArtifactVerificationResult } from '../contracts/artifact-vocabulary.js';
 import { InboundTranslator } from './application/inbound-translator.js';
@@ -35,6 +36,17 @@ export const gitHubProviderDefinition = {
                 if (resource === null)
                     throw new Error(`GitHub resource ${intent.resourceId} is unavailable`);
                 return client.deliver({ ...translateGitHubOutbound(resource, intent), idempotencyKey });
+            }, async (intent) => {
+                if (intent.kind !== BuiltInActivityName.IssueComplete)
+                    return null;
+                const resource = await services.resources.get(resourceId(intent.resourceId));
+                if (resource === null)
+                    return null;
+                const parsed = parsePullRequestKey(resource.externalKey.key);
+                if (parsed === null)
+                    return null;
+                const issue = await client.getIssue(parsed.owner, parsed.repo, parsed.number);
+                return issue.state === PullRequestState.Closed ? issue.id : null;
             }),
             verifyArtifact: async (kind, externalKey, context) => {
                 if (kind !== resourceKind('pull-request'))

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

@@ -6,6 +6,7 @@ export const resourceProjection = {
         return owned === null ? null : { key: owned.stream.id };
     },
     initial: () => null,
+    // eslint-disable-next-line complexity
     project(previous, event) {
         const owned = selectResourceEvent(event);
         if (owned === null)
@@ -35,6 +36,8 @@ export const resourceProjection = {
                     };
             case ResourceEventType.WorkCorrelationEstablished:
             case ResourceEventType.WorkCorrelationRetracted:
+            case ResourceEventType.IssueCompletionObservationConsumed:
+            case ResourceEventType.IssueCompletionObservationSuperseded:
                 return previous;
             default:
                 return assertNever(owned);
@@ -70,6 +73,8 @@ export const resourceCorrelationProjection = {
             case ResourceEventType.ResourceDiscovered:
             case ResourceEventType.ResourceRevisionObserved:
             case ResourceEventType.WorkCorrelationConflicted:
+            case ResourceEventType.IssueCompletionObservationConsumed:
+            case ResourceEventType.IssueCompletionObservationSuperseded:
                 return previous;
             default:
                 return assertNever(owned);

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

@@ -24,6 +24,16 @@ export function createResourceService(journal, lookup) {
                 workItemId,
             }));
         },
+        async consumeIssueCompletion(resourceId, intentEventId, context) {
+            await appendResourceEvent(repository, resourceId, resourceDraft(resourceId, context, ResourceEventType.IssueCompletionObservationConsumed, {
+                intentEventId,
+            }));
+        },
+        async supersedeIssueCompletion(resourceId, intentEventId, context) {
+            await appendResourceEvent(repository, resourceId, resourceDraft(resourceId, context, ResourceEventType.IssueCompletionObservationSuperseded, {
+                intentEventId,
+            }));
+        },
     };
 }
 async function discoverResource(repository, command, context) {

package/dist/src/resources/contracts/events.js

@@ -10,6 +10,8 @@ export const ResourceEventType = {
     WorkCorrelationEstablished: 'resources.work-correlation-established',
     WorkCorrelationRetracted: 'resources.work-correlation-retracted',
     WorkCorrelationConflicted: 'resources.work-correlation-conflicted',
+    IssueCompletionObservationConsumed: 'resources.issue-completion-observation-consumed',
+    IssueCompletionObservationSuperseded: 'resources.issue-completion-observation-superseded',
 };
 const streamSchema = z
     .object({
@@ -68,6 +70,16 @@ const eventSchema = z.discriminatedUnion('eventType', [
         })
             .strict(),
     }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.IssueCompletionObservationConsumed),
+        stream: streamSchema,
+        payload: z.object({ intentEventId: z.string().min(1) }).strict(),
+    }),
+    eventEnvelopeSchema.extend({
+        eventType: z.literal(ResourceEventType.IssueCompletionObservationSuperseded),
+        stream: streamSchema,
+        payload: z.object({ intentEventId: z.string().min(1) }).strict(),
+    }),
 ]);
 export function decodeResourceEvent(event) {
     const result = eventSchema.safeParse(event);

package/dist/src/resources/contracts/vocabulary.js

@@ -12,6 +12,8 @@ export const BuiltInResourceCapability = {
     Mergeable: resourceCapability('mergeable'),
     Revisioned: resourceCapability('revisioned'),
     Editable: resourceCapability('editable'),
+    /** Provider can move an issue to its completed terminal state. */
+    Completable: resourceCapability('completable'),
     // Provider can report which file paths a revision changed.
     ChangedFiles: resourceCapability('changed-files'),
 };

package/dist/src/resources/domain/resource.js

@@ -49,6 +49,9 @@ function applyResourceEvent(resource, active, event) {
         case ResourceEventType.WorkCorrelationRetracted:
             active.delete(event.payload.workItemId);
             break;
+        case ResourceEventType.IssueCompletionObservationConsumed:
+        case ResourceEventType.IssueCompletionObservationSuperseded:
+            break;
         default:
             assertNever(event);
     }

package/package.json

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