@atolis-hq/wake 0.3.22 → 0.3.24

package/dist/src/bootstrap/external-ref.js

@@ -1,12 +1,13 @@
-import { ResourceCorrelationRole } from '../resources/index.js';
+import { ResourceCorrelationRole, } from '../resources/index.js';
 import { workItemId } from '../work/index.js';
 // Work items never embed a provider/repo/issue number (see docs/adrs/0001); this joins
 // the primary correlated resource's adapter-formatted key at the presentation layer only.
-export async function primaryExternalRef(root, rawWorkItemId) {
-    const correlations = await root.resources.correlationsForWork(workItemId(rawWorkItemId));
+export async function primaryExternalRef(root, rawWorkItemId, suppliedCorrelations, suppliedResources) {
+    const correlations = suppliedCorrelations ?? (await root.resources.correlationsForWork(workItemId(rawWorkItemId)));
     const primary = correlations.find((value) => value.role === ResourceCorrelationRole.Primary);
     if (primary === undefined)
         return undefined;
-    const resource = await root.resources.get(primary.resourceId);
+    const resource = suppliedResources?.find((value) => value.resourceId === primary.resourceId) ??
+        (await root.resources.get(primary.resourceId));
     return resource?.externalKey.key;
 }

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

@@ -2,9 +2,26 @@ import { FileCheckpointStore, FileEventJournal, FileProjectionStore, } from '../
 function identity(value) {
     return value;
 }
+function serializeJournalAppends(journal) {
+    let appendTail = Promise.resolve();
+    return {
+        append(stream, expectedSequence, events) {
+            const appended = appendTail.then(() => journal.append(stream, expectedSequence, events));
+            appendTail = appended.then(() => undefined, () => undefined);
+            return appended;
+        },
+        readStream: (stream) => journal.readStream(stream),
+        readAll: (afterGlobalPosition, limit) => journal.readAll(afterGlobalPosition, limit),
+        ...(journal.readLatest === undefined
+            ? {}
+            : {
+                readLatest: (beforeGlobalPosition, limit) => journal.readLatest(beforeGlobalPosition, limit),
+            }),
+    };
+}
 export function composePersistence(paths, clock, options) {
     return {
-        journal: (options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock)),
+        journal: serializeJournalAppends((options.decorateJournal ?? identity)(options.journal ?? new FileEventJournal(paths.dataRoot, clock))),
         projections: (options.decorateProjections ?? identity)(options.projections ?? new FileProjectionStore(paths.dataRoot)),
         checkpoints: (options.decorateCheckpoints ?? identity)(options.checkpoints ?? new FileCheckpointStore(paths.dataRoot)),
     };

package/dist/src/bootstrap/projection-runtime.js

@@ -1,8 +1,8 @@
 import { activityProjectionDefinitions } from '../activities/index.js';
 import { controlPlaneProjectionDefinitions } from '../control-plane/index.js';
-import { executionProjection } from '../execution/index.js';
+import { executionProjection, runsByWorkflowInstanceProjection } from '../execution/index.js';
 import { deliveryProjectionDefinitions } from '../integrations/index.js';
-import { orchestrationProjection, workflowDefinitionsProjection } from '../orchestration/index.js';
+import { orchestrationProjection, workflowDefinitionsProjection, workflowsByWorkItemProjection, } from '../orchestration/index.js';
 import { ProjectionRunner } from '../persistence/index.js';
 import { resourceCorrelationProjection, resourceProjection, resourcesByExternalKeyProjection, workCorrelationsProjection, } from '../resources/index.js';
 import { workProjection } from '../work/index.js';
@@ -18,8 +18,10 @@ export const runtimeProjectionDefinitions = [
     ...deliveryProjectionDefinitions,
     ...controlPlaneProjectionDefinitions,
     orchestrationProjection,
+    workflowsByWorkItemProjection,
     workflowDefinitionsProjection,
     executionProjection,
+    runsByWorkflowInstanceProjection,
     boardProjection,
     analyticsProjection,
 ];

package/dist/src/bootstrap/surface-api-work-applications.js

@@ -1,6 +1,8 @@
+import { pullRequestProjection } from '../activities/index.js';
+import { executionProjection, runsByWorkflowInstanceProjection, } from '../execution/index.js';
 import { correlationId, EventActorKind } from '../kernel/index.js';
-import { isOperatorRetryEligible, OperatorRetryIneligibleError, } from '../orchestration/index.js';
-import { ResourceEventType, selectResourceEvent } from '../resources/index.js';
+import { isOperatorRetryEligible, OperatorRetryIneligibleError, orchestrationProjection, workflowsByWorkItemProjection, } from '../orchestration/index.js';
+import { workCorrelationsProjection, } from '../resources/index.js';
 import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, } from '../surfaces/index.js';
 import { workItemId, WorkStatus } from '../work/index.js';
 import { primaryExternalRef } from './external-ref.js';
@@ -92,14 +94,16 @@ async function workDetail(root, key, now) {
     const work = await root.work.get(id);
     if (work === null)
         return undefined;
-    const correlations = await root.resources.correlationsForWork(id);
+    const correlationProjection = await root.projections.read(workCorrelationsProjection.name, id);
+    const correlations = correlationProjection?.value ?? workCorrelationsProjection.initial(id);
     const resources = (await Promise.all(correlations.map((item) => root.resources.get(item.resourceId)))).filter((value) => value !== null);
-    const workflows = (await root.orchestration.listAll()).filter((value) => value.workItemId === id);
+    const workflowIds = (await root.projections.read(workflowsByWorkItemProjection.name, id))
+        ?.value ?? workflowsByWorkItemProjection.initial(id);
+    const workflows = (await Promise.all(workflowIds.map((workflowInstanceId) => root.projections.read(orchestrationProjection.name, workflowInstanceId)))).flatMap((entry) => (entry === null || entry.value.view === null ? [] : [entry.value.view]));
     const runs = await runsForWorkItem(root, id, workflows);
-    const pullRequests = await root.projections.list('activities-pr');
-    const pullRequest = pullRequests.find((entry) => resources.some((resource) => resource.resourceId === entry.key));
+    const pullRequest = (await Promise.all(resources.map((resource) => root.projections.read(pullRequestProjection.name, resource.resourceId)))).find((entry) => entry !== null && entry.value !== null);
     const primary = workflows.find((value) => value.parentWorkflowInstanceId === undefined) ?? null;
-    const externalRef = await primaryExternalRef(root, work.workItemId);
+    const externalRef = await primaryExternalRef(root, work.workItemId, correlations, resources);
     const data = {
         work: { ...presentWorkItem(work), ...(externalRef === undefined ? {} : { externalRef }) },
         resources: resources.map(presentResource(root.resolveResourceLink)),
@@ -117,23 +121,25 @@ async function workDetail(root, key, now) {
     };
     const [projections, correlationFacts] = await Promise.all([
         contributingProjections(root, id, resources, workflows, runs),
-        contributingResourceCorrelationFacts(root, id),
+        Promise.resolve(correlationProjection).then((entry) => (entry === null ? [] : [entry])),
     ]);
     return {
         data,
-        meta: await projectionMeta(root.journal, [...projections, ...correlationFacts, ...(pullRequest === undefined ? [] : [pullRequest])], now()),
+        meta: await projectionMeta(root.journal, [...projections, ...correlationFacts, ...(pullRequest == null ? [] : [pullRequest])], now()),
     };
 }
 async function runsForWorkItem(root, id, workflows) {
-    const matching = workflows ??
-        (await root.projections.list('orchestration'))
-            .flatMap((entry) => (entry.value.view === null ? [] : [entry.value.view]))
-            .filter((workflow) => workflow.workItemId === id);
-    return (await root.projections.list('execution'))
-        .flatMap((entry) => (entry.value.view === null ? [] : [entry.value.view]))
-        .filter((run) => matching.some((workflow) => workflow.workflowInstanceId === run.workflowInstanceId))
+    const matching = workflows ?? (await workflowsForWorkItem(root, id));
+    const runIds = (await Promise.all(matching.map((workflow) => root.projections.read(runsByWorkflowInstanceProjection.name, workflow.workflowInstanceId)))).flatMap((entry) => entry?.value ?? []);
+    return (await Promise.all(runIds.map((runId) => root.projections.read(executionProjection.name, runId))))
+        .flatMap((entry) => (entry === null || entry.value.view === null ? [] : [entry.value.view]))
         .sort((left, right) => right.startedAt.localeCompare(left.startedAt));
 }
+async function workflowsForWorkItem(root, id) {
+    const workflowIds = (await root.projections.read(workflowsByWorkItemProjection.name, id))
+        ?.value ?? workflowsByWorkItemProjection.initial(id);
+    return (await Promise.all(workflowIds.map((workflowInstanceId) => root.projections.read(orchestrationProjection.name, workflowInstanceId)))).flatMap((entry) => (entry === null || entry.value.view === null ? [] : [entry.value.view]));
+}
 function decodeWorkItemId(key) {
     try {
         return workItemId(fromWorkItemKey(key));
@@ -159,24 +165,11 @@ async function contributingProjections(root, id, resources, workflows, runs) {
     const records = await Promise.all([
         root.projections.read('work', id),
         ...resources.map((value) => root.projections.read('resources', value.resourceId)),
-        ...workflows.map((value) => root.projections.read('orchestration', value.workflowInstanceId)),
-        ...runs.map((value) => root.projections.read('execution', value.runId)),
+        ...workflows.map((value) => root.projections.read(orchestrationProjection.name, value.workflowInstanceId)),
+        ...runs.map((value) => root.projections.read(executionProjection.name, value.runId)),
     ]);
     return records.filter((value) => value !== null);
 }
-async function contributingResourceCorrelationFacts(root, id) {
-    const events = await root.journal.readAll(0);
-    return events.flatMap((event) => {
-        const owned = selectResourceEvent(event);
-        if (owned === null)
-            return [];
-        if (owned.eventType !== ResourceEventType.WorkCorrelationEstablished &&
-            owned.eventType !== ResourceEventType.WorkCorrelationRetracted &&
-            owned.eventType !== ResourceEventType.WorkCorrelationConflicted)
-            return [];
-        return owned.payload.workItemId === id ? [{ lastGlobalPosition: owned.globalPosition }] : [];
-    });
-}
 function commandContext(idempotencyKey, now) {
     const occurredAt = now();
     return {

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 = "gd39350a";
+export const wakeVersion = "g8b5a9f8";

package/dist/src/execution/application/execution-projection.js

@@ -1,4 +1,4 @@
-import { selectRunExecutionEvent } from '../contracts/events.js';
+import { ExecutionEventType, selectRunExecutionEvent, } from '../contracts/events.js';
 import { foldRun } from '../domain/run.js';
 export const executionProjection = {
     name: 'execution',
@@ -15,3 +15,20 @@ export const executionProjection = {
         return { events, view: foldRun(events) };
     },
 };
+/** Run membership keyed by workflow instance for scoped readers. */
+export const runsByWorkflowInstanceProjection = {
+    name: 'runs-by-workflow-instance',
+    select(event) {
+        const owned = selectRunExecutionEvent(event);
+        return owned?.eventType === ExecutionEventType.RunStarted
+            ? { key: owned.payload.workflowInstanceId }
+            : null;
+    },
+    initial: () => [],
+    project(previous, event) {
+        const owned = selectRunExecutionEvent(event);
+        if (owned?.eventType !== ExecutionEventType.RunStarted)
+            return previous;
+        return previous.includes(owned.stream.id) ? previous : [...previous, owned.stream.id];
+    },
+};

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

@@ -1,6 +1,7 @@
-import { ActivityOutcomeKind, ReviewActorKind, ReviewDecisionKind, ReviewerAuthorizationSource, createPullRequestService, } from '../../../activities/index.js';
+import { ActivityOutcomeKind, ReviewActorKind, ReviewDecisionKind, ReviewerAuthorizationSource, createPullRequestService, isReviewAuthorized, } from '../../../activities/index.js';
 import { ApprovalAuthorityKind } from '../../../orchestration/index.js';
 import { BuiltInResourceKind, ResourceCorrelationRole, ResourceStreamKind, resourceId, } from '../../../resources/index.js';
+import { WorkStatus } from '../../../work/index.js';
 import { UnknownGitHubIdentity } from '../contracts/vocabulary.js';
 import { commandContext } from './inbound-context.js';
 import { translateGitHubReviewCommand } from './review-command-translator.js';
@@ -10,7 +11,7 @@ export async function applyReviewSignal(input) {
         return;
     const payload = event.payload;
     if (payload.reviewKind === 'issue') {
-        await applyIssueReviewSignal({ event, resources, lookup, orchestration, adapter });
+        await applyIssueReviewSignal({ event, resources, work, lookup, orchestration, adapter });
         return;
     }
     await applyFormalReviewSignal({ ...input, journal, resources, work });
@@ -58,7 +59,7 @@ async function applyFormalReviewSignal(input) {
     });
 }
 async function applyIssueReviewSignal(input) {
-    const { event, resources, lookup, orchestration, adapter } = input;
+    const { event, resources, work, lookup, orchestration, adapter } = input;
     if (event.payload.actor.kind !== ReviewActorKind.Human || isWakeDelivery(event.payload.body))
         return;
     if (resources === undefined || lookup === undefined || orchestration === undefined)
@@ -70,22 +71,54 @@ async function applyIssueReviewSignal(input) {
     if (resourceIdValue === null)
         return;
     const resource = await resources.get(resourceIdValue);
+    const command = recognizedCommand(event.payload.body);
+    if (command === '/retry') {
+        await applyIssueRetrySignal({
+            event,
+            resources,
+            work,
+            orchestration,
+            resourceId: resourceIdValue,
+        });
+        return;
+    }
     if (resource?.kind === BuiltInResourceKind.PullRequest) {
         await applyWorkflowSignal({
             event,
             resources,
             orchestration,
             resourceId: resourceIdValue,
-            outcome: recognizedCommand(event.payload.body) === '/approved'
-                ? ActivityOutcomeKind.Done
-                : ActivityOutcomeKind.Rejected,
+            outcome: command === '/approved' ? ActivityOutcomeKind.Done : ActivityOutcomeKind.Rejected,
         });
         return;
     }
-    const command = recognizedCommand(event.payload.body);
     if (command !== null)
         await applyIssueApprovalSignal({ ...input, command });
 }
+async function applyIssueRetrySignal(input) {
+    const { event, resources, work, orchestration, resourceId: resourceIdValue } = input;
+    if (work === undefined || orchestration === undefined)
+        return;
+    if (!isReviewAuthorized({
+        actorId: event.payload.actor.id,
+        actorKind: event.payload.actor.kind,
+        resourceAuthorId: UnknownGitHubIdentity,
+        authorization: event.payload.authorization ?? { source: ReviewerAuthorizationSource.None },
+    }))
+        return;
+    const workItemIds = (await resources.correlations(resourceIdValue))
+        .filter((correlation) => correlation.role === ResourceCorrelationRole.Primary)
+        .map((correlation) => correlation.workItemId);
+    for (const workflow of await orchestration.listAll()) {
+        if (!workItemIds.includes(workflow.workItemId) ||
+            workflow.parentWorkflowInstanceId !== undefined)
+            continue;
+        const item = await work.get(workflow.workItemId);
+        if (item === null || item.deleted || item.frozen || item.state !== WorkStatus.Open)
+            continue;
+        await orchestration.retryBlockedFailedStage(workflow.workflowInstanceId, commandContext(event));
+    }
+}
 async function applyIssueApprovalSignal(input) {
     const { event, command, resources, lookup, orchestration, adapter } = input;
     if (resources === undefined || lookup === undefined || orchestration === undefined)
@@ -163,5 +196,7 @@ function recognizedCommand(body) {
         return '/approved';
     if (normalized === '/changes' || normalized.startsWith('/changes '))
         return '/changes';
+    if (normalized === '/retry')
+        return '/retry';
     return null;
 }

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

@@ -103,6 +103,7 @@ const eventSchema = z.discriminatedUnion('eventType', [
                     .strict()
                     .optional(),
                 actor: actorSchema,
+                authorization: authorizationSchema.optional(),
                 raw: rawSchema,
             })
                 .strict(),

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

@@ -1,5 +1,5 @@
 import { Octokit } from '@octokit/rest';
-import { MergeMethod, PullRequestState } from '../../../activities/index.js';
+import { MergeMethod, ProviderPermission, 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';
@@ -38,6 +38,14 @@ export function createGitHubClient(token) {
         listPullRequests: (owner, repo, maxResults) => listPullRequests(octokit, cache, owner, repo, maxResults),
         listIssueComments: (owner, repo, issueNumber, pageSize) => listIssueComments(octokit, cache, owner, repo, issueNumber, pageSize),
         listReviewComments: (owner, repo, pullNumber, pageSize) => listReviewComments(octokit, cache, owner, repo, pullNumber, pageSize),
+        collaboratorPermission: async (owner, repo, login) => {
+            const { data } = await octokit.rest.repos.getCollaboratorPermissionLevel({
+                owner,
+                repo,
+                username: login,
+            });
+            return providerPermission(data.permission);
+        },
         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),
@@ -60,6 +68,18 @@ export function createGitHubClient(token) {
         deliver: (command) => deliver(octokit, command),
     };
 }
+function providerPermission(permission) {
+    switch (permission) {
+        case ProviderPermission.Read:
+        case ProviderPermission.Triage:
+        case ProviderPermission.Write:
+        case ProviderPermission.Maintain:
+        case ProviderPermission.Admin:
+            return permission;
+        default:
+            return ProviderPermission.None;
+    }
+}
 async function deliver(octokit, command) {
     const marker = `<!-- wake:delivery:${command.idempotencyKey} -->`;
     if (command.action === 'approve') {

package/dist/src/integrations/github/infrastructure/issue-source.js

@@ -1,4 +1,4 @@
-import { PullRequestState, ReviewActorKind } from '../../../activities/index.js';
+import { PullRequestState, ReviewActorKind, } from '../../../activities/index.js';
 import { createEventDraft, EventActorKind, EventSourceKind } from '../../../kernel/index.js';
 import { ExternalWorkOutcome } from '../../contracts/outcome-vocabulary.js';
 import { integrationStream } from '../../contracts/streams.js';
@@ -95,6 +95,7 @@ export function issueCommentObservation(input) {
                 id: input.comment.user?.login ?? UnknownGitHubIdentity,
                 kind: input.comment.user?.type === 'Bot' ? ReviewActorKind.Bot : ReviewActorKind.Human,
             },
+            ...(input.authorization === undefined ? {} : { authorization: input.authorization }),
             raw: { id: input.comment.id },
         },
     });

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

@@ -1,3 +1,4 @@
+import { ReviewerAuthorizationSource, } from '../../../activities/index.js';
 import { GitHubEventType } from '../contracts/events.js';
 import { issueCommentObservation, issueObservation } from './issue-source.js';
 import { createGitHubPullRequestSource } from './pr-source.js';
@@ -71,15 +72,10 @@ async function pollRepository(input) {
 async function reviewCommentEventsFor(context, pullRequests) {
     if (context.client.listReviewComments === undefined)
         return [];
-    const items = await Promise.all(pullRequests.map(async (pullRequest) => (await context.client.listReviewComments(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize)).flatMap((comment) => {
-        const event = issueCommentObservation({
-            repository: context.repository,
-            issue: pullRequest,
-            comment,
-            ...(context.adapter === undefined ? {} : { adapter: context.adapter }),
-        });
-        return event === null ? [] : [event];
-    })));
+    const items = await Promise.all(pullRequests.map(async (pullRequest) => (async () => {
+        const comments = await context.client.listReviewComments(context.owner, context.repo, pullRequest.number, context.config.polling.commentPageSize);
+        return (await Promise.all(comments.map((comment) => issueCommentEventsForComment(context, pullRequest, comment)))).flat();
+    })()));
     return items.flat();
 }
 async function reviewEventsFor(context, pullRequestPayloads) {
@@ -95,14 +91,36 @@ async function reviewEventsFor(context, pullRequestPayloads) {
     return items.flat();
 }
 async function issueCommentEventsFor(context, issues) {
-    const items = await Promise.all(issues.map(async (issue) => (await context.client.listIssueComments(context.owner, context.repo, issue.number, context.config.polling.commentPageSize)).flatMap((comment) => {
-        const event = issueCommentObservation({
-            repository: context.repository,
-            issue,
-            comment,
-            ...(context.adapter === undefined ? {} : { adapter: context.adapter }),
-        });
-        return event === null ? [] : [event];
-    })));
+    const items = await Promise.all(issues.map(async (issue) => (async () => {
+        const comments = await context.client.listIssueComments(context.owner, context.repo, issue.number, context.config.polling.commentPageSize);
+        return (await Promise.all(comments.map((comment) => issueCommentEventsForComment(context, issue, comment)))).flat();
+    })()));
     return items.flat();
 }
+async function issueCommentEventsForComment(context, issue, comment) {
+    const authorization = await retryAuthorization(context, comment);
+    const event = issueCommentObservation({
+        repository: context.repository,
+        issue,
+        comment,
+        ...(authorization === undefined ? {} : { authorization }),
+        ...(context.adapter === undefined ? {} : { adapter: context.adapter }),
+    });
+    return event === null ? [] : [event];
+}
+async function retryAuthorization(context, comment) {
+    if (comment.body?.trim().toLowerCase() !== '/retry')
+        return undefined;
+    const login = comment.user?.login;
+    if (login === undefined || context.client.collaboratorPermission === undefined)
+        return { source: ReviewerAuthorizationSource.None };
+    try {
+        return {
+            source: ReviewerAuthorizationSource.ProviderPermission,
+            permission: await context.client.collaboratorPermission(context.owner, context.repo, login),
+        };
+    }
+    catch {
+        return { source: ReviewerAuthorizationSource.None };
+    }
+}

package/dist/src/orchestration/application/orchestration-projection.js

@@ -1,4 +1,5 @@
 import { selectWorkflowOrchestrationEvent } from '../contracts/event-decoder.js';
+import { OrchestrationEventType } from '../contracts/events.js';
 import { isWorkflowInstanceStream } from '../contracts/streams.js';
 import { foldWorkflowInstance } from '../domain/workflow-instance.js';
 export const orchestrationProjection = {
@@ -18,3 +19,22 @@ export const orchestrationProjection = {
         return { events, view: foldWorkflowInstance(events) };
     },
 };
+/** Workflow-instance membership keyed by its owning work item for scoped readers. */
+export const workflowsByWorkItemProjection = {
+    name: 'workflows-by-work-item',
+    select(event) {
+        const owned = selectWorkflowOrchestrationEvent(event);
+        return owned?.eventType === OrchestrationEventType.InstanceStarted &&
+            isWorkflowInstanceStream(owned.stream)
+            ? { key: owned.payload.workItemId }
+            : null;
+    },
+    initial: () => [],
+    project(previous, event) {
+        const owned = selectWorkflowOrchestrationEvent(event);
+        if (owned?.eventType !== OrchestrationEventType.InstanceStarted ||
+            !isWorkflowInstanceStream(owned.stream))
+            return previous;
+        return previous.includes(owned.stream.id) ? previous : [...previous, owned.stream.id];
+    },
+};

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

@@ -5,14 +5,17 @@ import { ActivityActivationStatus, WorkflowStatus } from '../contracts/vocabular
 import { activation, nextOrdinal, stateDraft } from './decision-events.js';
 export function isOperatorRetryEligible(view) {
     const pending = view.pendingActivation;
-    return (view.status === WorkflowStatus.Blocked &&
-        view.blockReason === 'unconfigured outcome failed' &&
+    const eligibleActivation = view.status === WorkflowStatus.Blocked &&
         pending !== undefined &&
         pending.status === ActivityActivationStatus.Completed &&
         pending.supplemental !== true &&
         pending.followOnIndex === undefined &&
-        view.lastOutcome?.kind === ActivityOutcomeKind.Failed &&
-        view.acceptedOutcomes.includes(pending.activationId));
+        view.acceptedOutcomes.includes(pending.activationId);
+    if (!eligibleActivation || pending === undefined)
+        return false;
+    return ((view.blockReason === 'unconfigured outcome failed' &&
+        view.lastOutcome?.kind === ActivityOutcomeKind.Failed) ||
+        view.executionFailure?.activationId === pending.activationId);
 }
 export function isChangesResumeEligible(view) {
     const pending = view.pendingActivation;
@@ -32,7 +35,7 @@ export function requestOperatorRetry(definition, state, input) {
     if (!isOperatorRetryEligible(state))
         return {
             kind: 'ignored',
-            reason: 'workflow is not blocked for an unconfigured failed outcome',
+            reason: 'workflow is not blocked for a retryable failed stage',
         };
     const stage = definition.stages[stageName(state.currentStage)];
     const events = [

package/dist/src/orchestration/domain/workflow-instance-events.js

@@ -58,6 +58,7 @@ function applyActivityFact(state, event) {
             return;
         case OrchestrationEventType.ActivityExecutionFailed:
             state.acceptedOutcomes.push(event.payload.activationId);
+            state.executionFailure = event.payload;
             updateActivationStatus(state, event.payload.activationId, ActivityActivationStatus.Completed);
             return;
         case OrchestrationEventType.ActivityWaiting:
@@ -234,6 +235,7 @@ export function immutableWorkflowInstanceView(state) {
             ? {}
             : { pendingActivation: state.pendingActivation }),
         ...(state.lastOutcome === undefined ? {} : { lastOutcome: state.lastOutcome }),
+        ...(state.executionFailure === undefined ? {} : { executionFailure: state.executionFailure }),
         ...(state.waitingFor === undefined ? {} : { waitingFor: state.waitingFor }),
     };
 }

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

@@ -24,6 +24,8 @@ export const workCorrelationsProjection = {
             return { key: owned.payload.workItemId };
         if (owned?.eventType === ResourceEventType.WorkCorrelationRetracted)
             return { key: owned.payload.workItemId };
+        if (owned?.eventType === ResourceEventType.WorkCorrelationConflicted)
+            return { key: owned.payload.workItemId };
         return null;
     },
     initial: () => [],

package/package.json

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