@atolis-hq/wake 0.2.50 → 0.2.52

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

@@ -1,4 +1,5 @@
 import { access } from 'node:fs/promises';
+import { LABELS_REQUESTED_EVENT } from '../../domain/event-types.js';
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { createEventEnvelope, createUnkeyedEventEnvelope } from '../../lib/event-log.js';
 import { readJsonFile } from '../../lib/json-file.js';
@@ -81,7 +82,7 @@ export function createFakeTicketingSystem(options) {
         },
         async deliverIntent(input) {
             const publishedAt = (options.now ?? (() => new Date()))().toISOString();
-            if (input.event.sourceEventType === 'wake.labels.requested') {
+            if (input.event.sourceEventType === LABELS_REQUESTED_EVENT) {
                 const ticket = options.tickets.find((issue) => issue.repo === input.event.sourceRefs.repo &&
                     issue.number === input.event.sourceRefs.issueNumber);
                 const currentLabels = ticket?.labels ?? [];

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

@@ -1,5 +1,6 @@
 import { readFile } from 'node:fs/promises';
 import { autoApprovalLabel, resolveAutoApprovalIntent } from '../../core/approval-intents.js';
+import { LABELS_REQUESTED_EVENT } from '../../domain/event-types.js';
 import { defaultAgentIdentity } from '../../domain/schema.js';
 import { buildResourceUri } from '../../domain/resource-uri.js';
 import { wakeStageLabelPrefix } from '../../domain/stages.js';
@@ -509,7 +510,7 @@ export function createGitHubIssuesWorkSource(deps) {
                 throw new Error(`cannot deliver intent ${input.event.eventId}: malformed repo "${repo}"`);
             }
             const publishedAt = deps.now().toISOString();
-            if (input.event.sourceEventType === 'wake.labels.requested') {
+            if (input.event.sourceEventType === LABELS_REQUESTED_EVENT) {
                 // Outbound intents are keyed envelopes Wake itself minted, so the work
                 // item is already named on the event — a direct read, not a lookup.
                 const projection = await deps.stateStore.readIssueState(input.event.workItemKey);
@@ -594,7 +595,7 @@ export function createGitHubIssuesWorkSource(deps) {
                 return [];
             }
             const publishedAt = deps.now().toISOString();
-            if (input.event.sourceEventType === 'wake.labels.requested') {
+            if (input.event.sourceEventType === LABELS_REQUESTED_EVENT) {
                 const projection = await deps.stateStore.readIssueState(input.event.workItemKey);
                 const currentLabels = projection?.issue.labels ?? [];
                 const expected = [

package/dist/src/adapters/http/ui-server.js

@@ -3,6 +3,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { dirname } from 'node:path';
 import { createProjectionUpdater } from '../../core/projection-updater.js';
+import { RETRY_REQUESTED_EVENT } from '../../domain/event-types.js';
 import { configuredTicketSource } from '../../domain/sources.js';
 import { createEventEnvelope } from '../../lib/event-log.js';
 import { writeJsonFile } from '../../lib/json-file.js';
@@ -118,7 +119,7 @@ async function handleRequest(req, res, options, now, projectionUpdater) {
             streamScope: 'work-item',
             direction: 'internal',
             sourceSystem: 'wake',
-            sourceEventType: 'wake.retry.requested',
+            sourceEventType: RETRY_REQUESTED_EVENT,
             sourceRefs: { repo: item.issue.repo, issueNumber: item.issue.number },
             occurredAt,
             ingestedAt: occurredAt,

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

@@ -1,3 +1,4 @@
+import { LABELS_REQUESTED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT } from '../domain/event-types.js';
 import { createEventEnvelope } from '../lib/event-log.js';
 import { extractTokenCount, formatCostUsd, formatDuration, formatTokenCount, } from '../lib/format.js';
 function isReviewThreadResourceUri(resourceUri) {
@@ -37,7 +38,7 @@ export function createPublishIntentEvent(input) {
         streamScope: 'work-item',
         direction: 'outbound',
         sourceSystem: 'wake',
-        sourceEventType: 'wake.publish.intent.requested',
+        sourceEventType: PUBLISH_INTENT_REQUESTED_EVENT,
         sourceRefs: {
             repo: input.projection.issue.repo,
             issueNumber: input.projection.issue.number,
@@ -129,7 +130,7 @@ export function createLabelsEvent(input) {
         streamScope: 'work-item',
         direction: 'outbound',
         sourceSystem: 'wake',
-        sourceEventType: 'wake.labels.requested',
+        sourceEventType: LABELS_REQUESTED_EVENT,
         sourceRefs: {
             repo: input.projection.issue.repo,
             issueNumber: input.projection.issue.number,

package/dist/src/core/outbox.js

@@ -1,14 +1,12 @@
 import { randomUUID } from 'node:crypto';
+import { LABELS_REQUESTED_EVENT, PUBLISH_CONFIRMED_EVENT, PUBLISH_FAILED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT, PUBLISH_SENT_UNCONFIRMED_EVENT, } from '../domain/event-types.js';
 import { createEventEnvelope } from '../lib/event-log.js';
 const outboxMaxAttempts = 3;
-const outboundIntentEventTypes = new Set([
-    'wake.publish.intent.requested',
-    'wake.labels.requested',
-]);
+const outboundIntentEventTypes = new Set([PUBLISH_INTENT_REQUESTED_EVENT, LABELS_REQUESTED_EVENT]);
 const outboundConfirmationEventTypes = new Set([
     'ticket.reply.published',
     'ticket.labels.updated',
-    'wake.publish.confirmed',
+    PUBLISH_CONFIRMED_EVENT,
     'pr.comment.reply.published',
     'pr.review-comment.reply.published',
 ]);
@@ -29,7 +27,7 @@ export function createOutbox(deps) {
             streamScope: 'work-item',
             direction: 'internal',
             sourceSystem: 'wake',
-            sourceEventType: 'wake.publish.failed',
+            sourceEventType: PUBLISH_FAILED_EVENT,
             sourceRefs: intentEvent.sourceRefs,
             occurredAt,
             ingestedAt: occurredAt,
@@ -53,7 +51,7 @@ export function createOutbox(deps) {
             streamScope: 'work-item',
             direction: 'internal',
             sourceSystem: 'wake',
-            sourceEventType: 'wake.publish.sent-unconfirmed',
+            sourceEventType: PUBLISH_SENT_UNCONFIRMED_EVENT,
             sourceRefs: intentEvent.sourceRefs,
             occurredAt,
             ingestedAt: occurredAt,
@@ -76,7 +74,7 @@ export function createOutbox(deps) {
             streamScope: 'work-item',
             direction: 'internal',
             sourceSystem: 'wake',
-            sourceEventType: 'wake.publish.confirmed',
+            sourceEventType: PUBLISH_CONFIRMED_EVENT,
             sourceRefs: intentEvent.sourceRefs,
             occurredAt: confirmedAt,
             ingestedAt: confirmedAt,
@@ -154,10 +152,10 @@ export function createOutbox(deps) {
             if (outboundConfirmationEventTypes.has(event.sourceEventType)) {
                 confirmedIntentIds.add(intentEventId);
             }
-            if (event.sourceEventType === 'wake.publish.failed') {
+            if (event.sourceEventType === PUBLISH_FAILED_EVENT) {
                 failureAttempts.set(intentEventId, (failureAttempts.get(intentEventId) ?? 0) + 1);
             }
-            if (event.sourceEventType === 'wake.publish.sent-unconfirmed') {
+            if (event.sourceEventType === PUBLISH_SENT_UNCONFIRMED_EVENT) {
                 uncertainIntentIds.add(intentEventId);
             }
         }

package/dist/src/core/policy-engine.js

@@ -110,7 +110,7 @@ export function createPolicyEngine() {
             const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
             const lastCompletedAction = typeof context.lastCompletedAction === 'string' ? context.lastCompletedAction : undefined;
             const lastRunSentinel = typeof context.lastRunSentinel === 'string' ? context.lastRunSentinel : undefined;
-            const lastFailureClass = typeof context.lastFailureClass === 'string' ? context.lastFailureClass : undefined;
+            const lastRetrySafety = typeof context.lastRetrySafety === 'string' ? context.lastRetrySafety : undefined;
             if (issue.wake.lastRunId === undefined) {
                 return true;
             }
@@ -122,15 +122,15 @@ export function createPolicyEngine() {
             if (isAwaitingApproval(issue)) {
                 return false;
             }
-            if (lastRunSentinel === failedRunnerSentinel && lastFailureClass !== 'quota') {
+            if (lastRunSentinel === failedRunnerSentinel) {
+                if (lastRetrySafety === 'SAFE_TO_RETRY' || lastRetrySafety === 'SAFE_TO_RESUME') {
+                    return belowFailureRetryLimit(issue, config);
+                }
                 return false;
             }
             if (lastRunSentinel === 'BLOCKED') {
                 return false;
             }
-            if (lastFailureClass === 'quota') {
-                return belowFailureRetryLimit(issue, config);
-            }
             const workflowAction = chooseWorkflowAction(issue, workflow);
             return workflowAction !== null && lastCompletedAction !== workflowAction.action;
         },

package/dist/src/core/projection-updater.js

@@ -1,9 +1,9 @@
-import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord, } from '../domain/schema.js';
+import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, RETRY_REQUESTED_EVENT, RUN_CLAIMED_EVENT, RUN_COMPLETED_EVENT, WORKFLOW_SELECTED_EVENT, WORKSPACE_CLEANED_EVENT, } from '../domain/event-types.js';
+import { UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord } from '../domain/schema.js';
 import { doneRunnerSentinel, stageFromLabels } from '../domain/stages.js';
 import { builtInDefaultWorkflowDefinition, defaultWorkflowName, selectWorkflowForEvent, workflowStageVocabulary, } from '../domain/workflows.js';
 import { isCustomCommandAction } from '../domain/custom-commands.js';
 import { createEventEnvelope } from '../lib/event-log.js';
-const WORKFLOW_SELECTED_EVENT = 'wake.workflow.selected';
 function stringArrayFromPayload(value) {
     return Array.isArray(value)
         ? value.filter((entry) => typeof entry === 'string')
@@ -159,7 +159,7 @@ async function applyEvent(current, event, ctx, config) {
             },
         });
     }
-    if (event.sourceEventType === 'wake.run.claimed') {
+    if (event.sourceEventType === RUN_CLAIMED_EVENT) {
         const payload = event.payload;
         if (payload.claimedStage === undefined) {
             return parseIssueStateRecord({
@@ -190,7 +190,7 @@ async function applyEvent(current, event, ctx, config) {
             },
         });
     }
-    if (event.sourceEventType === 'wake.run.completed') {
+    if (event.sourceEventType === RUN_COMPLETED_EVENT) {
         const payload = event.payload;
         if (payload.watcherRun === true) {
             return parseIssueStateRecord({
@@ -253,6 +253,17 @@ async function applyEvent(current, event, ctx, config) {
             ...(payload.workflowOutcome !== undefined
                 ? { lastWorkflowOutcome: payload.workflowOutcome }
                 : {}),
+            ...(payload.failurePhase !== undefined ? { lastFailurePhase: payload.failurePhase } : {}),
+            ...(payload.processStarted !== undefined
+                ? { lastProcessStarted: payload.processStarted }
+                : {}),
+            ...(payload.workspaceChanged !== undefined
+                ? { lastWorkspaceChanged: payload.workspaceChanged }
+                : {}),
+            ...(payload.externalSideEffects !== undefined
+                ? { lastExternalSideEffects: payload.externalSideEffects }
+                : {}),
+            ...(payload.retrySafety !== undefined ? { lastRetrySafety: payload.retrySafety } : {}),
         };
         if (payload.sentinel === 'BLOCKED' || payload.sentinel === 'FAILED') {
             nextContext.blockedFromStage = current.wake.stage;
@@ -317,7 +328,7 @@ async function applyEvent(current, event, ctx, config) {
             },
         });
     }
-    if (event.sourceEventType === 'wake.retry.requested') {
+    if (event.sourceEventType === RETRY_REQUESTED_EVENT) {
         const nextContext = { ...current.context };
         delete nextContext.lastRunSentinel;
         delete nextContext.lastFailureClass;
@@ -332,7 +343,7 @@ async function applyEvent(current, event, ctx, config) {
             },
         });
     }
-    if (event.sourceEventType === 'wake.workspace.cleaned') {
+    if (event.sourceEventType === WORKSPACE_CLEANED_EVENT) {
         return parseIssueStateRecord({
             ...current,
             wake: {

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

@@ -1,3 +1,4 @@
+import { LABELS_REQUESTED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT } from '../domain/event-types.js';
 export function createWorkSourceFanIn(sources) {
     return {
         async pollEvents(input) {
@@ -19,7 +20,7 @@ export function createWorkSourceFanIn(sources) {
     };
 }
 function intentKind(event) {
-    if (event.sourceEventType !== 'wake.publish.intent.requested') {
+    if (event.sourceEventType !== PUBLISH_INTENT_REQUESTED_EVENT) {
         return null;
     }
     return typeof event.payload.kind === 'string' ? event.payload.kind : null;
@@ -54,14 +55,14 @@ 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') {
+    if (input.event.sourceEventType === LABELS_REQUESTED_EVENT) {
         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' &&
+    if (input.event.sourceEventType === PUBLISH_INTENT_REQUESTED_EVENT &&
         sourceOrigin !== undefined) {
         const resourceSink = resourceUri === undefined ? sourceOrigin : sinkNameForResourceUri(resourceUri, sourceOrigin);
         targetSinks.add(input.sinksByName.has(resourceSink) ? resourceSink : sourceOrigin);

package/dist/src/core/stale-run-reconciler.js

@@ -1,4 +1,5 @@
 import { createLabelsEvent } from './event-builders.js';
+import { RUN_COMPLETED_EVENT } from '../domain/event-types.js';
 import { stageLabelForStage } from '../domain/stages.js';
 import { workflowLabelForWorkflowName, workflowNameForProjection } from '../domain/workflows.js';
 import { createEventEnvelope } from '../lib/event-log.js';
@@ -25,6 +26,37 @@ export function createStaleRunReconciler(deps) {
                 return 'SUPERSEDED';
         }
     }
+    function failurePhaseForLifecycle(lifecycle) {
+        switch (lifecycle) {
+            case 'CREATED':
+            case 'CLAIMED':
+            case 'PREPARING':
+                return 'workspace-prep';
+            case 'PROCESS_STARTING':
+                return 'process-starting';
+            case 'RUNNING':
+            case 'FINALISING':
+                return 'running';
+            case 'TERMINAL':
+                return 'unknown';
+        }
+    }
+    function classifyReconciledFailure(record) {
+        const processStarted = record.agentPid !== undefined ||
+            record.agentProcessStartedAt !== undefined ||
+            record.lifecycle === 'RUNNING' ||
+            record.lifecycle === 'FINALISING';
+        const metadata = record.metadata;
+        const workspaceChanged = typeof metadata?.workspacePath === 'string';
+        const retrySafety = processStarted || workspaceChanged ? 'REQUIRES_RECONCILIATION' : 'SAFE_TO_RETRY';
+        return {
+            failurePhase: failurePhaseForLifecycle(record.lifecycle),
+            processStarted,
+            workspaceChanged,
+            externalSideEffects: processStarted ? 'unknown' : 'none',
+            retrySafety,
+        };
+    }
     async function staleReason(record, now) {
         if (record.status !== 'running') {
             return null;
@@ -80,7 +112,7 @@ export function createStaleRunReconciler(deps) {
                 streamScope: 'work-item',
                 direction: 'internal',
                 sourceSystem: 'wake',
-                sourceEventType: 'wake.run.completed',
+                sourceEventType: RUN_COMPLETED_EVENT,
                 sourceRefs: {
                     repo: projection.issue.repo,
                     issueNumber: projection.issue.number,
@@ -93,6 +125,11 @@ export function createStaleRunReconciler(deps) {
                     action: projection.context.lastRunAction,
                     sentinel: 'FAILED',
                     executionOutcome: 'CANCELED_BY_RECONCILIATION',
+                    failurePhase: 'unknown',
+                    processStarted: false,
+                    workspaceChanged: false,
+                    externalSideEffects: 'unknown',
+                    retrySafety: 'MANUAL_REVIEW_REQUIRED',
                     runId,
                     reason: 'runner:missing-run-record',
                 },
@@ -145,6 +182,7 @@ export function createStaleRunReconciler(deps) {
                 continue;
             }
             const staleExecutionOutcome = reason === 'timeout' ? 'TIMED_OUT' : recoveryOutcomeForLifecycle(record.lifecycle);
+            const failureContext = classifyReconciledFailure(record);
             await deps.stateStore.writeRunRecord({
                 ...record,
                 lifecycle: 'TERMINAL',
@@ -152,6 +190,7 @@ export function createStaleRunReconciler(deps) {
                 finishedAt,
                 sentinel: 'FAILED',
                 executionOutcome: staleExecutionOutcome,
+                ...failureContext,
                 summary: `Run exceeded timeout while marked running and was reconciled by a later tick.`,
                 metadata: {
                     ...record.metadata,
@@ -159,6 +198,7 @@ export function createStaleRunReconciler(deps) {
                     recoveryLifecycle: record.lifecycle,
                     staleReason: reason,
                     timeoutMs: deps.runnerTimeoutMs(),
+                    ...failureContext,
                 },
             });
             const runCompletedEvent = createEventEnvelope({
@@ -167,7 +207,7 @@ export function createStaleRunReconciler(deps) {
                 streamScope: 'work-item',
                 direction: 'internal',
                 sourceSystem: 'wake',
-                sourceEventType: 'wake.run.completed',
+                sourceEventType: RUN_COMPLETED_EVENT,
                 sourceRefs: {
                     repo: record.repo,
                     issueNumber: record.issueNumber,
@@ -180,6 +220,7 @@ export function createStaleRunReconciler(deps) {
                     action: record.action,
                     sentinel: 'FAILED',
                     executionOutcome: staleExecutionOutcome,
+                    ...failureContext,
                     runId: record.runId,
                     reason: reason === 'timeout'
                         ? 'runner:stale-timeout'

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

@@ -3,7 +3,8 @@ import { createLifecycleService } from './lifecycle-service.js';
 import { createPolicyEngine } from './policy-engine.js';
 import { createProjectionUpdater } from './projection-updater.js';
 import { acquireFileLock } from '../lib/lock.js';
-import { CORRELATION_REGISTERED_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, parseRunnerArtifacts, parseRunnerResult, } from '../domain/schema.js';
+import { CORRELATION_REGISTERED_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, PR_AUTO_MERGE_ENABLED_EVENT, PR_REVIEW_APPROVED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT, RUN_CLAIMED_EVENT, RUN_COMPLETED_EVENT, } from '../domain/event-types.js';
+import { parseRunnerArtifacts, parseRunnerResult } from '../domain/schema.js';
 import { maxConfiguredRunnerTimeoutMs, resolveRunnerRouting } from '../domain/runner-routing.js';
 import { awaitingApprovalRunnerSentinel, stageLabelForStage } from '../domain/stages.js';
 import { isMeaningfulRuntimeEvent } from '../domain/runtime-events.js';
@@ -51,6 +52,54 @@ function shouldPublishRunResult(input) {
     }
     return input.failureClass !== input.previousFailureClass;
 }
+function hasConfirmedExternalSideEffect(projection) {
+    return projection.correlatedResources.some((resource) => /^[a-z0-9-]+:pr:/.test(resource.resourceUri));
+}
+function failurePhaseForRecord(record) {
+    if (record.agentPid !== undefined || record.agentProcessStartedAt !== undefined) {
+        return 'running';
+    }
+    if (record.lifecycle === 'PROCESS_STARTING' || record.lifecycle === 'RUNNING') {
+        return 'process-starting';
+    }
+    if (record.lifecycle === 'PREPARING') {
+        return 'workspace-prep';
+    }
+    return 'unknown';
+}
+function classifyFailedRun(input) {
+    const processStarted = input.record.agentPid !== undefined || input.record.agentProcessStartedAt !== undefined;
+    const workspaceChanged = input.workspacePath !== undefined;
+    const externalSideEffects = hasConfirmedExternalSideEffect(input.projection)
+        ? 'confirmed'
+        : processStarted
+            ? 'unknown'
+            : 'none';
+    const failurePhase = input.failurePhase ??
+        (input.envelope === 'degraded' && input.sentinel === 'FAILED'
+            ? 'result-parsing'
+            : failurePhaseForRecord(input.record));
+    let retrySafety;
+    if (input.failureClass === 'task') {
+        retrySafety = 'NOT_RETRYABLE';
+    }
+    else if (externalSideEffects === 'confirmed' || workspaceChanged) {
+        retrySafety = 'REQUIRES_RECONCILIATION';
+    }
+    else if (processStarted) {
+        retrySafety = 'SAFE_TO_RESUME';
+    }
+    else {
+        retrySafety = 'SAFE_TO_RETRY';
+    }
+    return {
+        failurePhase,
+        processStarted,
+        workspaceChanged,
+        externalSideEffects,
+        retrySafety,
+    };
+}
 export function createTickRunner(deps) {
     const policy = createPolicyEngine();
     const lifecycle = createLifecycleService();
@@ -184,7 +233,7 @@ export function createTickRunner(deps) {
             streamScope: 'work-item',
             direction: 'internal',
             sourceSystem: 'wake',
-            sourceEventType: 'wake.run.completed',
+            sourceEventType: RUN_COMPLETED_EVENT,
             sourceRefs: {
                 repo: input.projection.issue.repo,
                 issueNumber: input.projection.issue.number,
@@ -214,7 +263,7 @@ export function createTickRunner(deps) {
             streamScope: 'work-item',
             direction: 'outbound',
             sourceSystem: 'wake',
-            sourceEventType: 'wake.publish.intent.requested',
+            sourceEventType: PUBLISH_INTENT_REQUESTED_EVENT,
             sourceRefs: {
                 repo: input.projection.issue.repo,
                 issueNumber: input.projection.issue.number,
@@ -271,7 +320,7 @@ export function createTickRunner(deps) {
                 streamScope: 'work-item',
                 direction: 'internal',
                 sourceSystem: 'wake',
-                sourceEventType: 'wake.pr-review.approved',
+                sourceEventType: PR_REVIEW_APPROVED_EVENT,
                 sourceRefs: {
                     resourceUri: targetResourceUri,
                     commentId: input.approvalResolution.triggeringCommentId,
@@ -295,7 +344,7 @@ export function createTickRunner(deps) {
                 streamScope: 'work-item',
                 direction: 'internal',
                 sourceSystem: 'wake',
-                sourceEventType: 'wake.pr-auto-merge.enabled',
+                sourceEventType: PR_AUTO_MERGE_ENABLED_EVENT,
                 sourceRefs: {
                     resourceUri: targetResourceUri,
                     commentId: input.approvalResolution.triggeringCommentId,
@@ -493,7 +542,7 @@ export function createTickRunner(deps) {
                 streamScope: 'work-item',
                 direction: 'internal',
                 sourceSystem: 'wake',
-                sourceEventType: 'wake.run.completed',
+                sourceEventType: RUN_COMPLETED_EVENT,
                 sourceRefs: {
                     repo: projection.issue.repo,
                     issueNumber: projection.issue.number,
@@ -914,7 +963,7 @@ export function createTickRunner(deps) {
                             streamScope: 'work-item',
                             direction: 'internal',
                             sourceSystem: 'wake',
-                            sourceEventType: 'wake.run.completed',
+                            sourceEventType: RUN_COMPLETED_EVENT,
                             sourceRefs: {
                                 repo: candidate.issue.repo,
                                 issueNumber: candidate.issue.number,
@@ -1111,7 +1160,7 @@ export function createTickRunner(deps) {
                 streamScope: 'work-item',
                 direction: 'internal',
                 sourceSystem: 'wake',
-                sourceEventType: 'wake.run.claimed',
+                sourceEventType: RUN_CLAIMED_EVENT,
                 sourceRefs: {
                     repo: candidate.issue.repo,
                     issueNumber: candidate.issue.number,
@@ -1463,6 +1512,16 @@ export function createTickRunner(deps) {
                             : undefined;
                 await transitionRunLifecycle('FINALISING');
                 const finalisingRecord = (await deps.stateStore.readRunRecord(runId));
+                const failureContext = sentinel === 'FAILED'
+                    ? classifyFailedRun({
+                        projection: candidate,
+                        record: finalisingRecord,
+                        failureClass: runnerResult.failureClass ?? 'task',
+                        ...(workspacePath === undefined ? {} : { workspacePath }),
+                        envelope: parsedRunnerResult.envelope,
+                        sentinel,
+                    })
+                    : undefined;
                 await deps.stateStore.writeRunRecord({
                     ...finalisingRecord,
                     lifecycle: 'TERMINAL',
@@ -1478,6 +1537,7 @@ export function createTickRunner(deps) {
                     sentinel,
                     executionOutcome,
                     ...(workflowOutcome !== undefined ? { workflowOutcome } : {}),
+                    ...(failureContext === undefined ? {} : failureContext),
                     summary: parsedRunnerResult.body,
                     ...(runnerResult.routing === undefined ? {} : { routing: runnerResult.routing }),
                     ...(runnerResult.tokenUsage === undefined ? {} : { tokenUsage: runnerResult.tokenUsage }),
@@ -1492,7 +1552,7 @@ export function createTickRunner(deps) {
                     streamScope: 'work-item',
                     direction: 'internal',
                     sourceSystem: 'wake',
-                    sourceEventType: 'wake.run.completed',
+                    sourceEventType: RUN_COMPLETED_EVENT,
                     sourceRefs: {
                         repo: candidate.issue.repo,
                         issueNumber: candidate.issue.number,
@@ -1518,6 +1578,7 @@ export function createTickRunner(deps) {
                         ...(runnerResult.failureClass === undefined
                             ? {}
                             : { failureClass: runnerResult.failureClass }),
+                        ...(failureContext === undefined ? {} : failureContext),
                         // Only mark the triggering comment handled when the run reached the
                         // agent and produced a real outcome. Quota/infra failures are transient
                         // blips, not an answer to the human's comment — leaving handledCommentId
@@ -1611,6 +1672,18 @@ export function createTickRunner(deps) {
                 const finishedAt = deps.clock.now().toISOString();
                 const sentinel = 'FAILED';
                 const failedRecord = (await deps.stateStore.readRunRecord(runId)) ?? runningRecord;
+                const failedRecordMetadata = failedRecord.metadata;
+                const failedRecordWorkspacePath = typeof failedRecordMetadata?.workspacePath === 'string'
+                    ? failedRecordMetadata.workspacePath
+                    : undefined;
+                const failureContext = classifyFailedRun({
+                    projection: candidate,
+                    record: failedRecord,
+                    failureClass: 'infra',
+                    ...(failedRecordWorkspacePath === undefined
+                        ? {}
+                        : { workspacePath: failedRecordWorkspacePath }),
+                });
                 await deps.stateStore.writeRunRecord({
                     ...failedRecord,
                     lifecycle: 'TERMINAL',
@@ -1618,10 +1691,12 @@ export function createTickRunner(deps) {
                     finishedAt,
                     sentinel,
                     executionOutcome: 'PROCESS_FAILED',
+                    ...failureContext,
                     summary: err instanceof Error ? err.message : String(err),
                     metadata: {
                         ...failedRecord.metadata,
                         failureClass: 'infra',
+                        ...failureContext,
                     },
                 });
                 const runCompletedEvent = createEventEnvelope({
@@ -1630,7 +1705,7 @@ export function createTickRunner(deps) {
                     streamScope: 'work-item',
                     direction: 'internal',
                     sourceSystem: 'wake',
-                    sourceEventType: 'wake.run.completed',
+                    sourceEventType: RUN_COMPLETED_EVENT,
                     sourceRefs: {
                         repo: candidate.issue.repo,
                         issueNumber: candidate.issue.number,
@@ -1645,6 +1720,7 @@ export function createTickRunner(deps) {
                         runId,
                         reason: 'runner:infrastructure-error',
                         failureClass: 'infra',
+                        ...failureContext,
                         executionOutcome: 'PROCESS_FAILED',
                         // Deliberately omit handledCommentId: an infra blip (CLI crash, timeout,
                         // network error) never reached the agent, so it isn't an answer to the

package/dist/src/core/workspace-cleanup.js

@@ -1,5 +1,6 @@
 import { rm } from 'node:fs/promises';
 import { isAbsolute, join, relative } from 'node:path';
+import { WORKSPACE_CLEANED_EVENT, WORKSPACE_CLEANUP_FAILED_EVENT } from '../domain/event-types.js';
 import { createEventEnvelope } from '../lib/event-log.js';
 // Cleans up per-issue workspaces (and, unless retained, transcripts) once the
 // originating issue is closed. A cleanup failure is recorded as an event and
@@ -36,7 +37,7 @@ export function createWorkspaceCleanup(deps) {
                         streamScope: 'work-item',
                         direction: 'internal',
                         sourceSystem: 'wake',
-                        sourceEventType: 'wake.workspace.cleanup-failed',
+                        sourceEventType: WORKSPACE_CLEANUP_FAILED_EVENT,
                         sourceRefs: {
                             repo: projection.issue.repo,
                             issueNumber: projection.issue.number,
@@ -58,7 +59,7 @@ export function createWorkspaceCleanup(deps) {
                     streamScope: 'work-item',
                     direction: 'internal',
                     sourceSystem: 'wake',
-                    sourceEventType: 'wake.workspace.cleaned',
+                    sourceEventType: WORKSPACE_CLEANED_EVENT,
                     sourceRefs: {
                         repo: projection.issue.repo,
                         issueNumber: projection.issue.number,

package/dist/src/domain/event-types.js

@@ -0,0 +1,130 @@
+export const AUTONOMOUS_DECISION_AUDIT_EVENT = 'wake.audit.autonomous-decision';
+export const CORRELATION_PRIMARY_CONFLICT_EVENT = 'wake.correlation.primary-conflict';
+export const CORRELATION_REGISTERED_EVENT = 'wake.correlation.registered';
+export const CORRELATION_RETRACTED_EVENT = 'wake.correlation.retracted';
+export const LABELS_REQUESTED_EVENT = 'wake.labels.requested';
+export const PR_AUTO_MERGE_ENABLED_EVENT = 'wake.pr-auto-merge.enabled';
+export const PR_REVIEW_APPROVED_EVENT = 'wake.pr-review.approved';
+export const PUBLISH_CONFIRMED_EVENT = 'wake.publish.confirmed';
+export const PUBLISH_FAILED_EVENT = 'wake.publish.failed';
+export const PUBLISH_INTENT_REQUESTED_EVENT = 'wake.publish.intent.requested';
+export const PUBLISH_SENT_UNCONFIRMED_EVENT = 'wake.publish.sent-unconfirmed';
+export const RETRY_REQUESTED_EVENT = 'wake.retry.requested';
+export const RUN_CLAIMED_EVENT = 'wake.run.claimed';
+export const RUN_COMPLETED_EVENT = 'wake.run.completed';
+export const WORKFLOW_SELECTED_EVENT = 'wake.workflow.selected';
+export const WORK_ITEM_CREATED_EVENT = 'wake.workitem.created';
+export const WORKSPACE_CLEANED_EVENT = 'wake.workspace.cleaned';
+export const WORKSPACE_CLEANUP_FAILED_EVENT = 'wake.workspace.cleanup-failed';
+export const wakeEventTypeValues = [
+    AUTONOMOUS_DECISION_AUDIT_EVENT,
+    CORRELATION_PRIMARY_CONFLICT_EVENT,
+    CORRELATION_REGISTERED_EVENT,
+    CORRELATION_RETRACTED_EVENT,
+    LABELS_REQUESTED_EVENT,
+    PR_AUTO_MERGE_ENABLED_EVENT,
+    PR_REVIEW_APPROVED_EVENT,
+    PUBLISH_CONFIRMED_EVENT,
+    PUBLISH_FAILED_EVENT,
+    PUBLISH_INTENT_REQUESTED_EVENT,
+    PUBLISH_SENT_UNCONFIRMED_EVENT,
+    RETRY_REQUESTED_EVENT,
+    RUN_CLAIMED_EVENT,
+    RUN_COMPLETED_EVENT,
+    WORKFLOW_SELECTED_EVENT,
+    WORK_ITEM_CREATED_EVENT,
+    WORKSPACE_CLEANED_EVENT,
+    WORKSPACE_CLEANUP_FAILED_EVENT,
+];
+export const wakeEventTypeDefinitions = [
+    {
+        type: AUTONOMOUS_DECISION_AUDIT_EVENT,
+        description: 'Records an autonomous workflow decision and the inputs used to make it.',
+        payloadShape: '{ decisionType, workItemId, runId, workflowRevision, inputsConsidered, outcome, timestamp }',
+    },
+    {
+        type: CORRELATION_PRIMARY_CONFLICT_EVENT,
+        description: 'Warns that a requested primary resource correlation was downgraded because another work item already owns the resource.',
+        payloadShape: '{ resourceUri, incumbentWorkItemKey }',
+    },
+    {
+        type: CORRELATION_REGISTERED_EVENT,
+        description: 'Registers a resource URI as correlated to a work item.',
+        payloadShape: '{ resourceUri, role, relation, provenance, registeredBy? }',
+    },
+    {
+        type: CORRELATION_RETRACTED_EVENT,
+        description: 'Removes a resource URI correlation from a work item.',
+        payloadShape: '{ resourceUri }',
+    },
+    {
+        type: LABELS_REQUESTED_EVENT,
+        description: 'Requests outbound synchronization of Wake status, stage, and workflow labels.',
+        payloadShape: "{ statusLabel, stageLabel, workflowLabel, origin, idempotencyKey, deliveryState: 'PENDING' }",
+    },
+    {
+        type: PR_AUTO_MERGE_ENABLED_EVENT,
+        description: 'Records that Wake enabled auto-merge for an approved pull request.',
+        payloadShape: '{ idempotencyKey }',
+    },
+    {
+        type: PR_REVIEW_APPROVED_EVENT,
+        description: 'Records that Wake approved a pull request review after approval policy passed.',
+        payloadShape: '{ idempotencyKey }',
+    },
+    {
+        type: PUBLISH_CONFIRMED_EVENT,
+        description: 'Confirms that an outbound publish intent was delivered or intentionally suppressed.',
+        payloadShape: "{ intentEventId, idempotencyKey, deliveryState: 'CONFIRMED', ...sinkDetails }",
+    },
+    {
+        type: PUBLISH_FAILED_EVENT,
+        description: 'Records a failed outbound publish attempt for bounded retry.',
+        payloadShape: "{ intentEventId, intentEventType, idempotencyKey, deliveryState: 'PENDING', error }",
+    },
+    {
+        type: PUBLISH_INTENT_REQUESTED_EVENT,
+        description: 'Requests an outbound comment, reply, status update, question, or approval card.',
+        payloadShape: "{ kind, origin, body, action, sentinel, runId, idempotencyKey, deliveryState: 'PENDING', sessionId?, model?, cli?, duration?, tokens?, cost?, workspacePath?, failureRepeated?, previousFailureClass? }",
+    },
+    {
+        type: PUBLISH_SENT_UNCONFIRMED_EVENT,
+        description: 'Marks an outbound publish intent as sent before Wake has observed confirmation.',
+        payloadShape: "{ intentEventId, intentEventType, idempotencyKey, deliveryState: 'SENT_UNCONFIRMED' }",
+    },
+    {
+        type: RETRY_REQUESTED_EVENT,
+        description: 'Requests that a failed work item be retried.',
+        payloadShape: '{ requestedBy }',
+    },
+    {
+        type: RUN_CLAIMED_EVENT,
+        description: 'Records that Wake claimed a work item for an agent run.',
+        payloadShape: '{ action, priorStage, claimedStage?, sourceRevision, watcherRun?, watcherTrigger? }',
+    },
+    {
+        type: RUN_COMPLETED_EVENT,
+        description: 'Records the terminal result of an agent run or internal lifecycle transition.',
+        payloadShape: '{ action?, sentinel, nextStage?, runId, sessionId?, sessionCli?, workspacePath?, reason?, handledCommentId?, failureClass?, blockReason?, executionOutcome?, workflowOutcome?, watcherRun?, allowAutoApproval?, body? }',
+    },
+    {
+        type: WORKFLOW_SELECTED_EVENT,
+        description: 'Pins the workflow selected for a newly minted work item.',
+        payloadShape: '{ workflow, selectedFromEventId }',
+    },
+    {
+        type: WORK_ITEM_CREATED_EVENT,
+        description: 'Mints a Wake work item identity before resource correlation is registered.',
+        payloadShape: '{}',
+    },
+    {
+        type: WORKSPACE_CLEANED_EVENT,
+        description: 'Records successful cleanup of a closed issue workspace.',
+        payloadShape: '{ workspacePath }',
+    },
+    {
+        type: WORKSPACE_CLEANUP_FAILED_EVENT,
+        description: 'Records a workspace cleanup failure without aborting the cleanup sweep.',
+        payloadShape: '{ workspacePath, error }',
+    },
+];

package/dist/src/domain/schema.js

@@ -7,6 +7,7 @@ import { runnerSentinelValues } from './stages.js';
 import { correlationProvenanceSchema, correlationRelationSchema, correlationRoleSchema, resourceUriSchema, } from './resource-uri.js';
 import { runtimeEventTypeValues } from './runtime-events.js';
 import { alwaysManualIgnoredLabels } from './manual-labels.js';
+export { AUTONOMOUS_DECISION_AUDIT_EVENT, CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, WORK_ITEM_CREATED_EVENT, } from './event-types.js';
 const isoTimestampSchema = z.string().datetime({ offset: true });
 const identifierSchema = z.string().min(1);
 export const reportedArtifactSchema = z.object({
@@ -225,12 +226,6 @@ export const eventEnvelopeSourceRefsSchema = z.object({
     // own locator grammar; this keeps that knowledge out of core/.
     parentResourceUri: resourceUriSchema.optional(),
 });
-/** Event type constants for the correlation registry (ADR 0001 §5). */
-export const WORK_ITEM_CREATED_EVENT = 'wake.workitem.created';
-export const CORRELATION_REGISTERED_EVENT = 'wake.correlation.registered';
-export const CORRELATION_RETRACTED_EVENT = 'wake.correlation.retracted';
-export const CORRELATION_PRIMARY_CONFLICT_EVENT = 'wake.correlation.primary-conflict';
-export const AUTONOMOUS_DECISION_AUDIT_EVENT = 'wake.audit.autonomous-decision';
 /**
  * Shared key for events whose resource failed mint qualification (spec D1').
  * Never a real work item: `readIssueState(UNRESOLVED_WORK_ITEM_KEY)` always
@@ -331,6 +326,22 @@ const runLeaseSchema = z.object({
     lastRenewedAt: isoTimestampSchema,
     expiresAt: isoTimestampSchema,
 });
+export const failurePhaseSchema = z.enum([
+    'workspace-prep',
+    'process-starting',
+    'running',
+    'result-parsing',
+    'publishing',
+    'unknown',
+]);
+export const externalSideEffectsSchema = z.enum(['none', 'confirmed', 'unknown']);
+export const retrySafetySchema = z.enum([
+    'SAFE_TO_RETRY',
+    'SAFE_TO_RESUME',
+    'REQUIRES_RECONCILIATION',
+    'MANUAL_REVIEW_REQUIRED',
+    'NOT_RETRYABLE',
+]);
 function legacyRunLifecycle(input) {
     if (input.lifecycle !== undefined) {
         return input;
@@ -374,6 +385,11 @@ export const runRecordSchema = z.preprocess((input) => {
     sentinel: runnerSentinelSchema.optional(),
     executionOutcome: executionOutcomeSchema.optional(),
     workflowOutcome: workflowOutcomeSchema.optional(),
+    failurePhase: failurePhaseSchema.optional(),
+    processStarted: z.boolean().optional(),
+    workspaceChanged: z.boolean().optional(),
+    externalSideEffects: externalSideEffectsSchema.optional(),
+    retrySafety: retrySafetySchema.optional(),
     summary: z.string().optional(),
     routing: runnerRoutingSchema.optional(),
     lease: runLeaseSchema.optional(),

package/dist/src/version.js

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

package/package.json

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