@atolis-hq/wake 0.2.30 → 0.2.32

package/dist/src/adapters/fake/fake-ticketing-system.js

@@ -125,6 +125,8 @@ export function createFakeTicketingSystem(options) {
                         trigger: 'context-only',
                         payload: {
                             intentEventId: input.event.eventId,
+                            idempotencyKey: input.event.payload.idempotencyKey,
+                            deliveryState: 'CONFIRMED',
                             labels,
                         },
                     }),
@@ -149,6 +151,9 @@ export function createFakeTicketingSystem(options) {
                     trigger: 'context-only',
                     payload: {
                         intentEventId: input.event.eventId,
+                        idempotencyKey: input.event.payload.idempotencyKey,
+                        deliveryState: 'CONFIRMED',
+                        providerId: commentId,
                         kind: input.event.payload.kind,
                         body: input.event.payload.body,
                     },

package/dist/src/adapters/github/github-client.js

@@ -66,6 +66,14 @@ export function createGitHubClient(token) {
                 }),
             });
         },
+        async getIssue(owner, repo, issueNumber) {
+            const { data } = await octokit.rest.issues.get({
+                owner,
+                repo,
+                issue_number: issueNumber,
+            });
+            return data;
+        },
         async createComment(owner, repo, issueNumber, body) {
             return octokit.rest.issues.createComment({
                 owner,

package/dist/src/adapters/github/github-issues-work-source.js

@@ -18,6 +18,11 @@ const pollOverlapMs = 60 * 60 * 1000;
 // expectedEcho bookkeeping surviving a crash (#145).
 const wakeCommentMarker = '<!-- wake:agent -->';
 const githubSource = 'github';
+export function wakeIdempotencyMarker(idempotencyKey) {
+    return typeof idempotencyKey === 'string'
+        ? `<!-- wake:idempotency ${idempotencyKey} -->`
+        : undefined;
+}
 function normalizeTicketUpsert(input) {
     // Names the resource, never the work item — the resolver stamps the
     // canonical workItemKey after the poll (spec D1).
@@ -180,6 +185,9 @@ export async function readControlPlaneUiUrl(wakeRoot) {
         return undefined;
     }
 }
+function isGitHubNotFound(error) {
+    return error instanceof Error && error.status === 404;
+}
 export function formatGitHubError(error) {
     if (error instanceof Error) {
         const octokit = error;
@@ -210,6 +218,7 @@ export function formatWakeComment(payload, controlPlaneUrl) {
     const tokens = typeof payload.tokens === 'string' ? payload.tokens : undefined;
     const cost = typeof payload.cost === 'string' ? payload.cost : undefined;
     const workspacePath = typeof payload.workspacePath === 'string' ? payload.workspacePath : undefined;
+    const idempotencyMarker = wakeIdempotencyMarker(payload.idempotencyKey);
     const details = [
         action === undefined ? undefined : `stage \`${action}\``,
         runnerName === undefined ? undefined : `runner \`${runnerName}\``,
@@ -225,7 +234,7 @@ export function formatWakeComment(payload, controlPlaneUrl) {
         ? defaultAgentIdentity
         : `[${defaultAgentIdentity}](${controlPlaneUrl})`;
     const header = `**${name}** _(Wake ${wakeVersion}${details.length > 0 ? ` · ${details.join(' · ')}` : ''})_`;
-    const sections = [wakeCommentMarker, header, body];
+    const sections = [wakeCommentMarker, idempotencyMarker, header, body].filter((section) => section !== undefined);
     if (kind === 'approval-request') {
         sections.push('_To approve this work, reply with `/approved`. To request changes, reply with `/changes` followed by your feedback. To ask a question without requesting changes, reply with `/ask` followed by your question._');
     }
@@ -257,6 +266,33 @@ export function formatWakeComment(payload, controlPlaneUrl) {
     }
     return sections.join('\n\n');
 }
+function createIssueCommentPublishedEvent(input) {
+    return createEventEnvelope({
+        eventId: `${input.event.eventId}-published`,
+        workItemKey: input.event.workItemKey,
+        streamScope: 'work-item',
+        direction: 'outbound',
+        sourceSystem: 'github',
+        sourceEventType: 'ticket.reply.published',
+        sourceRefs: {
+            repo: input.repo,
+            issueNumber: input.issueNumber,
+            ...(input.commentId === undefined ? {} : { commentId: input.commentId }),
+        },
+        occurredAt: input.publishedAt,
+        ingestedAt: input.publishedAt,
+        trigger: 'context-only',
+        payload: {
+            intentEventId: input.event.eventId,
+            idempotencyKey: input.event.payload.idempotencyKey,
+            deliveryState: 'CONFIRMED',
+            kind: input.event.payload.kind,
+            body: input.event.payload.body,
+            providerEventType: 'github.issue.comment.published',
+            ...(input.commentId === undefined ? {} : { providerId: input.commentId }),
+        },
+    });
+}
 export function createGitHubIssuesWorkSource(deps) {
     /** O(1): one shard read, then a direct projection read by work id. */
     async function readProjectionForIssue(repo, issueNumber) {
@@ -268,6 +304,71 @@ export function createGitHubIssuesWorkSource(deps) {
         return deps.stateStore.readIssueState(workItemKey);
     }
     return {
+        async refreshForDispatch(input) {
+            const repoRef = input.projection.issue.repo;
+            if (deps.client.getIssue === undefined) {
+                return null;
+            }
+            if (!deps.config.sources.github.repos.includes(repoRef)) {
+                return null;
+            }
+            const [owner, repo] = repoRef.split('/');
+            if (owner === undefined || repo === undefined) {
+                return null;
+            }
+            const ingestedAt = deps.now().toISOString();
+            let issue;
+            try {
+                issue = await deps.client.getIssue(owner, repo, input.projection.issue.number);
+            }
+            catch (error) {
+                if (isGitHubNotFound(error)) {
+                    return {
+                        events: [],
+                        sourceRevision: `github:issue:${repoRef}#${input.projection.issue.number}@missing`,
+                        sourceExists: false,
+                    };
+                }
+                throw error;
+            }
+            const events = [];
+            if (input.projection.issue.updatedAt !== issue.updated_at) {
+                events.push(normalizeTicketUpsert({
+                    repo: repoRef,
+                    issue,
+                    ingestedAt,
+                    expectedEcho: isExpectedLabelEcho(issue, input.projection),
+                }));
+            }
+            const comments = await deps.client.listComments(owner, repo, input.projection.issue.number, deps.config.sources.github.polling.commentPageSize);
+            let latestCommentRevision = '';
+            for (const comment of comments) {
+                if (comment.updated_at > latestCommentRevision) {
+                    latestCommentRevision = comment.updated_at;
+                }
+                const known = input.projection.comments.find((entry) => entry.id === String(comment.id));
+                if (known?.updatedAt === comment.updated_at) {
+                    continue;
+                }
+                if (input.projection.wake.expectedEcho.commentIds.includes(String(comment.id))) {
+                    continue;
+                }
+                events.push(normalizeTicketCommentEvent({
+                    repo: repoRef,
+                    issueNumber: input.projection.issue.number,
+                    comment,
+                    ingestedAt,
+                    ...(deps.selfLogin === undefined ? {} : { selfLogin: deps.selfLogin }),
+                    ...(known?.updatedAt === undefined ? {} : { existingUpdatedAt: known.updatedAt }),
+                }));
+            }
+            return {
+                events,
+                sourceRevision: latestCommentRevision.length > 0
+                    ? `github:issue:${repoRef}#${issue.number}@${issue.updated_at};comments@${latestCommentRevision}`
+                    : `github:issue:${repoRef}#${issue.number}@${issue.updated_at}`,
+            };
+        },
         async pollEvents(_input) {
             const ingestedAt = deps.now().toISOString();
             const events = [];
@@ -398,6 +499,8 @@ export function createGitHubIssuesWorkSource(deps) {
                             trigger: 'context-only',
                             payload: {
                                 intentEventId: input.event.eventId,
+                                idempotencyKey: input.event.payload.idempotencyKey,
+                                deliveryState: 'CONFIRMED',
                                 ...(nextStatusLabel !== undefined ? { statusLabel: nextStatusLabel } : {}),
                                 ...(nextStageLabel !== undefined ? { stageLabel: nextStageLabel } : {}),
                                 ...(nextWorkflowLabel !== undefined ? { workflowLabel: nextWorkflowLabel } : {}),
@@ -412,27 +515,75 @@ export function createGitHubIssuesWorkSource(deps) {
             const response = await deps.client.createComment(owner, repoName, issueNumber, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
             const commentId = extractCreatedCommentId(response);
             return [
-                createEventEnvelope({
-                    eventId: `${input.event.eventId}-published`,
-                    workItemKey: input.event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'outbound',
-                    sourceSystem: 'github',
-                    sourceEventType: 'ticket.reply.published',
-                    sourceRefs: {
-                        repo,
-                        issueNumber,
-                        ...(commentId === undefined ? {} : { commentId }),
-                    },
-                    occurredAt: publishedAt,
-                    ingestedAt: publishedAt,
-                    trigger: 'context-only',
-                    payload: {
-                        intentEventId: input.event.eventId,
-                        kind: input.event.payload.kind,
-                        body: input.event.payload.body,
-                        providerEventType: 'github.issue.comment.published',
-                    },
+                createIssueCommentPublishedEvent({
+                    event: input.event,
+                    repo,
+                    issueNumber,
+                    publishedAt,
+                    ...(commentId === undefined ? {} : { commentId }),
+                }),
+            ];
+        },
+        async reconcileIntent(input) {
+            const repo = input.event.sourceRefs.repo;
+            const issueNumber = input.event.sourceRefs.issueNumber;
+            if (repo === undefined || issueNumber === undefined) {
+                return [];
+            }
+            const [owner, repoName] = repo.split('/');
+            if (owner === undefined || repoName === undefined) {
+                return [];
+            }
+            const publishedAt = deps.now().toISOString();
+            if (input.event.sourceEventType === 'wake.labels.requested') {
+                const projection = await deps.stateStore.readIssueState(input.event.workItemKey);
+                const currentLabels = projection?.issue.labels ?? [];
+                const expected = [
+                    input.event.payload.statusLabel,
+                    input.event.payload.stageLabel,
+                    input.event.payload.workflowLabel,
+                ].filter((label) => typeof label === 'string');
+                if (expected.every((label) => currentLabels.includes(label))) {
+                    return [
+                        createEventEnvelope({
+                            eventId: `${input.event.eventId}-labels-updated`,
+                            workItemKey: input.event.workItemKey,
+                            streamScope: 'work-item',
+                            direction: 'outbound',
+                            sourceSystem: 'github',
+                            sourceEventType: 'ticket.labels.updated',
+                            sourceRefs: { repo, issueNumber },
+                            occurredAt: publishedAt,
+                            ingestedAt: publishedAt,
+                            trigger: 'context-only',
+                            payload: {
+                                intentEventId: input.event.eventId,
+                                idempotencyKey: input.event.payload.idempotencyKey,
+                                deliveryState: 'CONFIRMED',
+                                labels: currentLabels,
+                                providerEventType: 'github.issue.labels.updated',
+                            },
+                        }),
+                    ];
+                }
+                return [];
+            }
+            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
+            if (marker === undefined) {
+                return [];
+            }
+            const comments = await deps.client.listComments(owner, repoName, issueNumber, deps.config.sources.github.polling.commentPageSize);
+            const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+            if (existing === undefined) {
+                return [];
+            }
+            return [
+                createIssueCommentPublishedEvent({
+                    event: input.event,
+                    repo,
+                    issueNumber,
+                    publishedAt,
+                    commentId: String(existing.id),
                 }),
             ];
         },

package/dist/src/adapters/github/github-pull-request-activity-source.js

@@ -1,6 +1,6 @@
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { createUnkeyedEventEnvelope, createEventEnvelope } from '../../lib/event-log.js';
-import { formatGitHubError, formatWakeComment, readControlPlaneUiUrl, } from './github-issues-work-source.js';
+import { formatGitHubError, formatWakeComment, readControlPlaneUiUrl, wakeIdempotencyMarker, } from './github-issues-work-source.js';
 const githubPrSource = 'github-pr';
 const wakeCommentMarker = '<!-- wake:agent -->';
 function prResourceUri(repo, number) {
@@ -61,6 +61,27 @@ export function createGitHubPullRequestActivitySource(deps) {
         }
         return { owner, repo, repoRef: `${owner}/${repo}`, number: Number(numberStr) };
     }
+    function reviewThreadRefFromUri(resourceUri) {
+        const locator = resourceUri.split(':').slice(2).join(':');
+        const match = /^([^/]+)\/([^#]+)#(\d+)\/rt_(\d+)$/.exec(locator);
+        if (match === null) {
+            return null;
+        }
+        const [, owner, repo, numberStr, rootIdStr] = match;
+        if (owner === undefined ||
+            repo === undefined ||
+            numberStr === undefined ||
+            rootIdStr === undefined) {
+            return null;
+        }
+        return {
+            owner,
+            repo,
+            repoRef: `${owner}/${repo}`,
+            number: Number(numberStr),
+            rootId: Number(rootIdStr),
+        };
+    }
     async function discoverPullRequests(ingestedAt) {
         const seenPrData = new Map();
         const confirmedOpenRepos = new Set();
@@ -404,19 +425,11 @@ export function createGitHubPullRequestActivitySource(deps) {
             }
             const publishedAt = deps.now().toISOString();
             if (resourceUri.startsWith('github:pr-review-thread:')) {
-                const locator = resourceUri.split(':').slice(2).join(':');
-                const match = /^([^/]+)\/([^#]+)#(\d+)\/rt_(\d+)$/.exec(locator);
-                if (match === null) {
-                    throw new Error(`cannot deliver intent ${input.event.eventId}: malformed review-thread uri ${resourceUri}`);
-                }
-                const [, owner, repo, numberStr, rootIdStr] = match;
-                if (owner === undefined ||
-                    repo === undefined ||
-                    numberStr === undefined ||
-                    rootIdStr === undefined) {
+                const ref = reviewThreadRefFromUri(resourceUri);
+                if (ref === null) {
                     throw new Error(`cannot deliver intent ${input.event.eventId}: malformed review-thread uri ${resourceUri}`);
                 }
-                const response = await deps.client.replyToReviewComment(owner, repo, Number(numberStr), Number(rootIdStr), formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
+                const response = await deps.client.replyToReviewComment(ref.owner, ref.repo, ref.number, ref.rootId, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
                 return [
                     createEventEnvelope({
                         eventId: `${input.event.eventId}-published`,
@@ -434,8 +447,11 @@ export function createGitHubPullRequestActivitySource(deps) {
                         trigger: 'context-only',
                         payload: {
                             intentEventId: input.event.eventId,
+                            idempotencyKey: input.event.payload.idempotencyKey,
+                            deliveryState: 'CONFIRMED',
                             kind: input.event.payload.kind,
                             body: input.event.payload.body,
+                            providerId: response?.id,
                         },
                     }),
                 ];
@@ -444,7 +460,79 @@ export function createGitHubPullRequestActivitySource(deps) {
             if (ref === null) {
                 throw new Error(`cannot deliver intent ${input.event.eventId}: malformed pr uri ${resourceUri}`);
             }
-            await deps.client.createComment(ref.owner, ref.repo, ref.number, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
+            const response = await deps.client.createComment(ref.owner, ref.repo, ref.number, formatWakeComment(input.event.payload, await readControlPlaneUiUrl(deps.config.paths.wakeRoot)));
+            return [
+                createEventEnvelope({
+                    eventId: `${input.event.eventId}-published`,
+                    workItemKey: input.event.workItemKey,
+                    streamScope: 'work-item',
+                    direction: 'outbound',
+                    sourceSystem: githubPrSource,
+                    sourceEventType: 'pr.comment.reply.published',
+                    sourceRefs: { repo: ref.repoRef, resourceUri },
+                    occurredAt: publishedAt,
+                    ingestedAt: publishedAt,
+                    trigger: 'context-only',
+                    payload: {
+                        intentEventId: input.event.eventId,
+                        idempotencyKey: input.event.payload.idempotencyKey,
+                        deliveryState: 'CONFIRMED',
+                        kind: input.event.payload.kind,
+                        body: input.event.payload.body,
+                        providerId: response?.data?.id,
+                    },
+                }),
+            ];
+        },
+        async reconcileIntent(input) {
+            const resourceUri = input.event.sourceRefs.resourceUri;
+            const marker = wakeIdempotencyMarker(input.event.payload.idempotencyKey);
+            if (resourceUri === undefined || marker === undefined) {
+                return [];
+            }
+            const publishedAt = deps.now().toISOString();
+            if (resourceUri.startsWith('github:pr-review-thread:')) {
+                const ref = reviewThreadRefFromUri(resourceUri);
+                if (ref === null) {
+                    return [];
+                }
+                const comments = await deps.client.listReviewComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
+                const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+                if (existing === undefined) {
+                    return [];
+                }
+                return [
+                    createEventEnvelope({
+                        eventId: `${input.event.eventId}-published`,
+                        workItemKey: input.event.workItemKey,
+                        streamScope: 'work-item',
+                        direction: 'outbound',
+                        sourceSystem: githubPrSource,
+                        sourceEventType: 'pr.review-comment.reply.published',
+                        sourceRefs: { resourceUri, sourceUrl: existing.html_url },
+                        occurredAt: publishedAt,
+                        ingestedAt: publishedAt,
+                        trigger: 'context-only',
+                        payload: {
+                            intentEventId: input.event.eventId,
+                            idempotencyKey: input.event.payload.idempotencyKey,
+                            deliveryState: 'CONFIRMED',
+                            kind: input.event.payload.kind,
+                            body: input.event.payload.body,
+                            providerId: existing.id,
+                        },
+                    }),
+                ];
+            }
+            const ref = repoAndNumberFromPrUri(resourceUri);
+            if (ref === null) {
+                return [];
+            }
+            const comments = await deps.client.listComments(ref.owner, ref.repo, ref.number, deps.config.sources.github.pullRequests.commentPageSize);
+            const existing = comments.find((comment) => (comment.body ?? '').includes(marker));
+            if (existing === undefined) {
+                return [];
+            }
             return [
                 createEventEnvelope({
                     eventId: `${input.event.eventId}-published`,
@@ -459,8 +547,11 @@ export function createGitHubPullRequestActivitySource(deps) {
                     trigger: 'context-only',
                     payload: {
                         intentEventId: input.event.eventId,
+                        idempotencyKey: input.event.payload.idempotencyKey,
+                        deliveryState: 'CONFIRMED',
                         kind: input.event.payload.kind,
                         body: input.event.payload.body,
+                        providerId: existing.id,
                     },
                 }),
             ];

package/dist/src/core/event-builders.js

@@ -29,6 +29,8 @@ function isFreshTriggeringComment(candidate) {
 export function createPublishIntentEvent(input) {
     const tokenCount = extractTokenCount(input.runnerResult.tokenUsage);
     const duration = formatDuration(input.startedAt, input.occurredAt);
+    const failureRepeated = input.runnerResult.failureClass !== undefined &&
+        input.previousFailureClass === input.runnerResult.failureClass;
     return createEventEnvelope({
         eventId: `${input.runId}-publish-intent`,
         workItemKey: input.projection.workItemKey,
@@ -107,6 +109,12 @@ export function createPublishIntentEvent(input) {
                 ? {}
                 : { cost: formatCostUsd(input.runnerResult.tokenUsage.costUsd) }),
             ...(input.workspacePath === undefined ? {} : { workspacePath: input.workspacePath }),
+            idempotencyKey: `${input.runId}:result-comment`,
+            deliveryState: 'PENDING',
+            ...(failureRepeated ? { failureRepeated } : {}),
+            ...(input.previousFailureClass === undefined
+                ? {}
+                : { previousFailureClass: input.previousFailureClass }),
         },
         derivedHints: {
             stage: input.sentinel === 'DONE' ? 'done' : input.projection.wake.stage,
@@ -114,6 +122,7 @@ export function createPublishIntentEvent(input) {
     });
 }
 export function createLabelsEvent(input) {
+    const labelKind = input.statusLabel === 'wake:status.working' ? 'working-label' : 'completion-label';
     return createEventEnvelope({
         eventId: `${input.runId}-labels-${input.statusLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.stageLabel.replace(/[^a-z0-9]+/gi, '-')}-${input.workflowLabel.replace(/[^a-z0-9]+/gi, '-')}`,
         workItemKey: input.projection.workItemKey,
@@ -134,6 +143,8 @@ export function createLabelsEvent(input) {
             stageLabel: input.stageLabel,
             workflowLabel: input.workflowLabel,
             origin: input.projection.origin ?? 'github',
+            idempotencyKey: `${input.runId}:${labelKind}`,
+            deliveryState: 'PENDING',
         },
     });
 }

package/dist/src/core/outbox.js

@@ -12,6 +12,10 @@ const outboundConfirmationEventTypes = new Set([
     'pr.comment.reply.published',
     'pr.review-comment.reply.published',
 ]);
+function intentId(event) {
+    const intentEventId = event.payload.intentEventId;
+    return typeof intentEventId === 'string' ? intentEventId : undefined;
+}
 // The outbox: outbound delivery (comments, labels) attempted independently of
 // run-outcome recording, with a durable, bounded retry trace. Extracted from
 // tick-runner.ts so it can be exercised in isolation; it has the cleanest
@@ -33,12 +37,60 @@ export function createOutbox(deps) {
             payload: {
                 intentEventId: intentEvent.eventId,
                 intentEventType: intentEvent.sourceEventType,
+                idempotencyKey: intentEvent.payload.idempotencyKey,
+                deliveryState: 'PENDING',
                 error: err instanceof Error ? err.message : String(err),
             },
         });
         await deps.stateStore.appendEventEnvelope(failureEvent);
         await deps.projectionUpdater.rebuildFromEvents([failureEvent]);
     }
+    async function recordSentUnconfirmed(intentEvent) {
+        const occurredAt = deps.clock.now().toISOString();
+        const sentEvent = createEventEnvelope({
+            eventId: `${intentEvent.eventId}-sent-unconfirmed-${randomUUID()}`,
+            workItemKey: intentEvent.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.publish.sent-unconfirmed',
+            sourceRefs: intentEvent.sourceRefs,
+            occurredAt,
+            ingestedAt: occurredAt,
+            trigger: 'context-only',
+            payload: {
+                intentEventId: intentEvent.eventId,
+                intentEventType: intentEvent.sourceEventType,
+                idempotencyKey: intentEvent.payload.idempotencyKey,
+                deliveryState: 'SENT_UNCONFIRMED',
+            },
+        });
+        await deps.stateStore.appendEventEnvelope(sentEvent);
+        await deps.projectionUpdater.rebuildFromEvents([sentEvent]);
+    }
+    async function recordConfirmed(intentEvent, payload = {}) {
+        const confirmedAt = deps.clock.now().toISOString();
+        const confirmedEvent = createEventEnvelope({
+            eventId: `${intentEvent.eventId}-confirmed`,
+            workItemKey: intentEvent.workItemKey,
+            streamScope: 'work-item',
+            direction: 'internal',
+            sourceSystem: 'wake',
+            sourceEventType: 'wake.publish.confirmed',
+            sourceRefs: intentEvent.sourceRefs,
+            occurredAt: confirmedAt,
+            ingestedAt: confirmedAt,
+            trigger: 'context-only',
+            payload: {
+                intentEventId: intentEvent.eventId,
+                idempotencyKey: intentEvent.payload.idempotencyKey,
+                deliveryState: 'CONFIRMED',
+                ...payload,
+            },
+        });
+        const appended = await deps.stateStore.appendEventEnvelope(confirmedEvent);
+        await deps.projectionUpdater.rebuildFromEvents([appended]);
+    }
     // Outbound delivery (comments, labels) is attempted independently of run-outcome
     // recording: a delivery failure must never rewrite an already-recorded run result
     // (S1), and must always leave a durable, retryable trace instead of being lost
@@ -48,6 +100,7 @@ export function createOutbox(deps) {
             return;
         }
         try {
+            await recordSentUnconfirmed(event);
             const deliveryEvents = await deps.outboundSink.deliverIntent({ event });
             for (const deliveryEvent of deliveryEvents) {
                 await deps.stateStore.appendEventEnvelope(deliveryEvent);
@@ -57,21 +110,7 @@ export function createOutbox(deps) {
                 // No confirmation event was produced (e.g. a no-op label update) but the
                 // sink did not throw. Record that delivery was attempted successfully so
                 // the outbox scan below does not retry it indefinitely.
-                const confirmedAt = deps.clock.now().toISOString();
-                const confirmedEvent = createEventEnvelope({
-                    eventId: `${event.eventId}-confirmed`,
-                    workItemKey: event.workItemKey,
-                    streamScope: 'work-item',
-                    direction: 'internal',
-                    sourceSystem: 'wake',
-                    sourceEventType: 'wake.publish.confirmed',
-                    sourceRefs: event.sourceRefs,
-                    occurredAt: confirmedAt,
-                    ingestedAt: confirmedAt,
-                    trigger: 'context-only',
-                    payload: { intentEventId: event.eventId },
-                });
-                await deps.stateStore.appendEventEnvelope(confirmedEvent);
+                await recordConfirmed(event);
             }
         }
         catch (err) {
@@ -83,6 +122,18 @@ export function createOutbox(deps) {
         await deps.projectionUpdater.rebuildFromEvents([event]);
         await attemptDelivery(event);
     }
+    async function suppressOutboundEvent(event, input) {
+        const suppressedEvent = await deps.stateStore.appendEventEnvelope({
+            ...event,
+            payload: {
+                ...event.payload,
+                deliveryState: 'CONFIRMED',
+                suppressedPublishReason: input.suppressedPublishReason,
+            },
+        });
+        await deps.projectionUpdater.rebuildFromEvents([suppressedEvent]);
+        await recordConfirmed(event, { suppressedPublishReason: input.suppressedPublishReason });
+    }
     // Adopts the outbox pattern: an intent is only considered delivered once a
     // matching confirmation event exists. Anything left unconfirmed by a prior tick
     // (e.g. the process crashed mid-delivery) is retried here, bounded so a
@@ -94,9 +145,10 @@ export function createOutbox(deps) {
         const events = await deps.stateStore.listEventEnvelopes();
         const confirmedIntentIds = new Set();
         const failureAttempts = new Map();
+        const uncertainIntentIds = new Set();
         for (const event of events) {
-            const intentEventId = event.payload.intentEventId;
-            if (typeof intentEventId !== 'string') {
+            const intentEventId = intentId(event);
+            if (intentEventId === undefined) {
                 continue;
             }
             if (outboundConfirmationEventTypes.has(event.sourceEventType)) {
@@ -105,6 +157,9 @@ export function createOutbox(deps) {
             if (event.sourceEventType === 'wake.publish.failed') {
                 failureAttempts.set(intentEventId, (failureAttempts.get(intentEventId) ?? 0) + 1);
             }
+            if (event.sourceEventType === 'wake.publish.sent-unconfirmed') {
+                uncertainIntentIds.add(intentEventId);
+            }
         }
         for (const intent of events) {
             if (!outboundIntentEventTypes.has(intent.sourceEventType)) {
@@ -116,8 +171,30 @@ export function createOutbox(deps) {
             if ((failureAttempts.get(intent.eventId) ?? 0) >= outboxMaxAttempts) {
                 continue;
             }
+            if (uncertainIntentIds.has(intent.eventId) &&
+                deps.outboundSink.reconcileIntent !== undefined) {
+                try {
+                    const reconciledEvents = await deps.outboundSink.reconcileIntent({ event: intent });
+                    for (const reconciledEvent of reconciledEvents) {
+                        await deps.stateStore.appendEventEnvelope(reconciledEvent);
+                    }
+                    await deps.projectionUpdater.rebuildFromEvents(reconciledEvents);
+                    if (reconciledEvents.length > 0) {
+                        continue;
+                    }
+                }
+                catch (err) {
+                    await recordDeliveryFailure(intent, err);
+                    continue;
+                }
+            }
             await attemptDelivery(intent);
         }
     }
-    return { attemptDelivery, deliverOutboundEvent, retryUnconfirmedDeliveries };
+    return {
+        attemptDelivery,
+        deliverOutboundEvent,
+        retryUnconfirmedDeliveries,
+        suppressOutboundEvent,
+    };
 }

package/dist/src/core/sink-router.js

@@ -4,6 +4,18 @@ export function createWorkSourceFanIn(sources) {
             const batches = await Promise.all(sources.map((source) => source.pollEvents(input)));
             return batches.flat();
         },
+        async refreshForDispatch(input) {
+            for (const source of sources) {
+                if (source.refreshForDispatch === undefined) {
+                    continue;
+                }
+                const result = await source.refreshForDispatch(input);
+                if (result !== null) {
+                    return result;
+                }
+            }
+            return null;
+        },
     };
 }
 function intentKind(event) {
@@ -38,36 +50,34 @@ function withSinkRef(event, sink) {
         },
     };
 }
+function targetSinksForEvent(input) {
+    const targetSinks = new Set();
+    const origin = typeof input.event.payload.origin === 'string' ? input.event.payload.origin : undefined;
+    const sourceOrigin = input.event.sourceRefs.sink ?? origin;
+    if (input.event.sourceEventType === 'wake.labels.requested') {
+        const projectionOrigin = typeof input.event.payload.origin === 'string' ? input.event.payload.origin : undefined;
+        if (projectionOrigin !== undefined) {
+            targetSinks.add(projectionOrigin);
+        }
+    }
+    const resourceUri = input.event.sourceRefs.resourceUri;
+    if (input.event.sourceEventType === 'wake.publish.intent.requested' &&
+        sourceOrigin !== undefined) {
+        const resourceSink = resourceUri === undefined ? sourceOrigin : sinkNameForResourceUri(resourceUri, sourceOrigin);
+        targetSinks.add(input.sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);
+    }
+    for (const [sinkName, sinkConfig] of Object.entries(input.config.sinks ?? {})) {
+        if (sinkConfig.subscribe.some((subscription) => subscriptionMatches(input.event, subscription))) {
+            targetSinks.add(sinkName);
+        }
+    }
+    return targetSinks;
+}
 export function createOutboundSinkRouter(input) {
     const sinksByName = new Map(input.sinks.map((sink) => [sink.sink, sink]));
     return {
         async deliverIntent({ event }) {
-            const targetSinks = new Set();
-            const origin = typeof event.payload.origin === 'string' ? event.payload.origin : undefined;
-            const sourceOrigin = event.sourceRefs.sink ?? origin;
-            if (event.sourceEventType === 'wake.labels.requested') {
-                const projectionOrigin = typeof event.payload.origin === 'string' ? event.payload.origin : undefined;
-                if (projectionOrigin !== undefined) {
-                    targetSinks.add(projectionOrigin);
-                }
-            }
-            const resourceUri = event.sourceRefs.resourceUri;
-            if (event.sourceEventType === 'wake.publish.intent.requested' && sourceOrigin !== undefined) {
-                const resourceSink = resourceUri === undefined
-                    ? sourceOrigin
-                    : sinkNameForResourceUri(resourceUri, sourceOrigin);
-                // A resource-derived sink name (e.g. a PR surface) may not be
-                // registered — the source that owns it can be disabled independently
-                // of the origin sink. Falling back to sourceOrigin here, rather than
-                // silently skipping an unregistered sink below, is what keeps a reply
-                // from being dropped-but-marked-delivered when that happens.
-                targetSinks.add(sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);
-            }
-            for (const [sinkName, sinkConfig] of Object.entries(input.config.sinks ?? {})) {
-                if (sinkConfig.subscribe.some((subscription) => subscriptionMatches(event, subscription))) {
-                    targetSinks.add(sinkName);
-                }
-            }
+            const targetSinks = targetSinksForEvent({ event, sinksByName, config: input.config });
             const deliveryEvents = [];
             for (const sinkName of targetSinks) {
                 const sink = sinksByName.get(sinkName);
@@ -79,5 +89,18 @@ export function createOutboundSinkRouter(input) {
             }
             return deliveryEvents;
         },
+        async reconcileIntent({ event }) {
+            const targetSinks = targetSinksForEvent({ event, sinksByName, config: input.config });
+            const deliveryEvents = [];
+            for (const sinkName of targetSinks) {
+                const sink = sinksByName.get(sinkName);
+                if (sink?.reconcileIntent === undefined) {
+                    continue;
+                }
+                const sinkDeliveryEvents = await sink.reconcileIntent({ event });
+                deliveryEvents.push(...sinkDeliveryEvents.map((deliveryEvent) => withSinkRef(deliveryEvent, sinkName)));
+            }
+            return deliveryEvents;
+        },
     };
 }

package/dist/src/core/tick-runner.js

@@ -21,6 +21,15 @@ function latestHumanCommentId(candidate) {
     const human = candidate.comments.filter((c) => !c.isBotAuthored);
     return human.at(-1)?.id;
 }
+function projectedSourceRevision(projection) {
+    const latestCommentUpdatedAt = projection.comments
+        .map((comment) => comment.updatedAt)
+        .sort()
+        .at(-1);
+    return latestCommentUpdatedAt === undefined
+        ? `${projection.issue.repo}#${projection.issue.number}@${projection.issue.updatedAt}`
+        : `${projection.issue.repo}#${projection.issue.number}@${projection.issue.updatedAt};comments@${latestCommentUpdatedAt}`;
+}
 function isLateralReadOnlyAction(action, config) {
     return isCustomCommandAction(action, config);
 }
@@ -41,7 +50,7 @@ export function createTickRunner(deps) {
         resourceIndex: deps.resourceIndex,
         config: deps.config,
     });
-    const { deliverOutboundEvent, retryUnconfirmedDeliveries } = createOutbox({
+    const { deliverOutboundEvent, retryUnconfirmedDeliveries, suppressOutboundEvent } = createOutbox({
         clock: deps.clock,
         stateStore: deps.stateStore,
         projectionUpdater,
@@ -137,6 +146,7 @@ export function createTickRunner(deps) {
                     relation: 'primary',
                     provenance: 'agent-reported',
                     registeredBy: input.runId,
+                    idempotencyKey: `${input.runId}:artifact-registration:${verified.resourceUri}`,
                 },
             });
             const appended = await deps.stateStore.appendEventEnvelope(event);
@@ -220,6 +230,18 @@ export function createTickRunner(deps) {
                 processStartedAt: record.workerProcessStartedAt,
             }));
     }
+    async function hasSchedulerCapacity(now) {
+        const runRecords = await deps.stateStore.listRunRecords();
+        for (const record of runRecords) {
+            if (record.status !== 'running') {
+                continue;
+            }
+            if (await isRunningRecordActive(record, now)) {
+                return false;
+            }
+        }
+        return true;
+    }
     async function parkConfigDriftedProjections(projections) {
         let parked = false;
         for (const projection of projections) {
@@ -313,10 +335,31 @@ export function createTickRunner(deps) {
             if (await parkConfigDriftedProjections(projections)) {
                 return { status: 'processed' };
             }
-            const candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
+            let candidate = projections.find((issue) => policy.resolveNextEligibleAction(issue, deps.config) !== null);
             if (candidate === undefined) {
                 return { status: 'idle' };
             }
+            let sourceRevision = projectedSourceRevision(candidate);
+            let refresh;
+            try {
+                refresh = await deps.workSource.refreshForDispatch?.({ projection: candidate });
+            }
+            catch {
+                return { status: 'idle' };
+            }
+            if (refresh !== undefined && refresh !== null) {
+                if (refresh.sourceExists === false) {
+                    return { status: 'idle' };
+                }
+                sourceRevision = refresh.sourceRevision;
+                if (refresh.events.length > 0) {
+                    await ingestInboundEvents(refresh.events);
+                    candidate = (await deps.stateStore.readIssueState(candidate.workItemKey)) ?? candidate;
+                }
+            }
+            if (policy.resolveNextEligibleAction(candidate, deps.config) === null) {
+                return { status: 'idle' };
+            }
             const workflow = workflowForProjection(candidate, deps.config);
             if (workflow === null) {
                 return { status: 'idle' };
@@ -443,6 +486,9 @@ export function createTickRunner(deps) {
             if (routing === null) {
                 return { status: 'idle' };
             }
+            if (!(await hasSchedulerCapacity(deps.clock.now()))) {
+                return { status: 'idle' };
+            }
             const runId = `run-${candidate.issue.number}-${deps.clock.now().getTime()}`;
             const lease = createRunLease({ clock: deps.clock, ownerInstanceId });
             const workerIdentity = currentProcessIdentity();
@@ -460,6 +506,9 @@ export function createTickRunner(deps) {
                 lease,
                 workerPid: workerIdentity.pid,
                 workerProcessStartedAt: workerIdentity.processStartedAt,
+                metadata: {
+                    sourceRevision,
+                },
             };
             await deps.stateStore.writeRunRecord(runningRecord);
             async function transitionRunLifecycle(lifecycle) {
@@ -488,6 +537,7 @@ export function createTickRunner(deps) {
                     action,
                     priorStage: candidate.wake.stage,
                     claimedStage,
+                    sourceRevision,
                 },
             });
             await deps.stateStore.appendEventEnvelope(claimedEvent);
@@ -721,23 +771,31 @@ export function createTickRunner(deps) {
                     workflowLabel: workflowLabelForWorkflowName(workflowName),
                     occurredAt: finishedAt,
                 }));
+                const publishIntent = createPublishIntentEvent({
+                    projection: candidate,
+                    runId,
+                    action,
+                    runnerResult,
+                    parsedRunnerResult,
+                    sentinel,
+                    occurredAt: finishedAt,
+                    startedAt: nowIso,
+                    ...(workspacePath === undefined ? {} : { workspacePath }),
+                    ...(typeof candidate.context.lastFailureClass === 'string'
+                        ? { previousFailureClass: candidate.context.lastFailureClass }
+                        : {}),
+                });
                 if (shouldPublishRunResult({
                     failureClass: runnerResult.failureClass,
                     previousFailureClass: candidate.context.lastFailureClass,
                 })) {
-                    const publishIntent = createPublishIntentEvent({
-                        projection: candidate,
-                        runId,
-                        action,
-                        runnerResult,
-                        parsedRunnerResult,
-                        sentinel,
-                        occurredAt: finishedAt,
-                        startedAt: nowIso,
-                        ...(workspacePath === undefined ? {} : { workspacePath }),
-                    });
                     await deliverOutboundEvent(publishIntent);
                 }
+                else {
+                    await suppressOutboundEvent(publishIntent, {
+                        suppressedPublishReason: runnerResult.failureClass === 'quota' ? 'quota-failure' : 'repeated-infra-failure',
+                    });
+                }
                 return {
                     status: 'processed',
                     runId,
@@ -759,6 +817,7 @@ export function createTickRunner(deps) {
                     executionOutcome: 'PROCESS_FAILED',
                     summary: err instanceof Error ? err.message : String(err),
                     metadata: {
+                        ...failedRecord.metadata,
                         failureClass: 'infra',
                     },
                 });
@@ -805,6 +864,7 @@ export function createTickRunner(deps) {
                     result: errorMessage,
                     model: 'unknown',
                     cli: 'unknown',
+                    failureClass: 'infra',
                 };
                 const parsedInfraFailureResult = parseRunnerResult(infraFailureResult.result);
                 const failurePublishIntent = createPublishIntentEvent({
@@ -816,6 +876,9 @@ export function createTickRunner(deps) {
                     sentinel,
                     occurredAt: finishedAt,
                     startedAt: nowIso,
+                    ...(typeof candidate.context.lastFailureClass === 'string'
+                        ? { previousFailureClass: candidate.context.lastFailureClass }
+                        : {}),
                 });
                 if (shouldPublishRunResult({
                     failureClass: 'infra',
@@ -823,6 +886,11 @@ export function createTickRunner(deps) {
                 })) {
                     await deliverOutboundEvent(failurePublishIntent);
                 }
+                else {
+                    await suppressOutboundEvent(failurePublishIntent, {
+                        suppressedPublishReason: 'repeated-infra-failure',
+                    });
+                }
                 return {
                     status: 'processed',
                     runId,

package/dist/src/version.js

@@ -124,4 +124,4 @@ export function resolveWakeVersion(options = {}) {
     }
     return '0.1.0-dev';
 }
-export const wakeVersion = "gfb459ce";
+export const wakeVersion = "gd481d17";

package/package.json

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