@atolis-hq/wake 0.4.58 → 0.4.59

package/dist/src/activities/contracts/event-schema.d.ts

@@ -51,6 +51,14 @@ export declare const deniedOutcomeSchema: z.ZodObject<{
             "blocked-path-changed": "blocked-path-changed";
             "changed-files-unavailable": "changed-files-unavailable";
         }>;
+        resourceId: z.ZodOptional<z.ZodString>;
+        revision: z.ZodOptional<z.ZodString>;
+        policy: z.ZodOptional<z.ZodObject<{
+            blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+            filesChanged: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
     }, z.core.$strict>;
 }, z.core.$strict>;
 export declare function createResourceFactDraftSchemas(eventTypes: ActivityEventTypes): readonly [z.ZodObject<{
@@ -1147,6 +1155,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                             "blocked-path-changed": "blocked-path-changed";
                             "changed-files-unavailable": "changed-files-unavailable";
                         }>;
+                        resourceId: z.ZodOptional<z.ZodString>;
+                        revision: z.ZodOptional<z.ZodString>;
+                        policy: z.ZodOptional<z.ZodObject<{
+                            blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+                            filesChanged: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>;
                 }, z.core.$strict>;
                 fact: z.ZodObject<{
@@ -1351,6 +1367,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                             "blocked-path-changed": "blocked-path-changed";
                             "changed-files-unavailable": "changed-files-unavailable";
                         }>;
+                        resourceId: z.ZodOptional<z.ZodString>;
+                        revision: z.ZodOptional<z.ZodString>;
+                        policy: z.ZodOptional<z.ZodObject<{
+                            blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+                            filesChanged: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>;
                 }, z.core.$strict>;
                 fact: z.ZodObject<{
@@ -1457,6 +1481,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                     kind: "blocked";
                     data: {
                         reason: "closed" | "missing-resource" | "ambiguous-resource" | "correlation-conflict" | "stale-approval" | "checks-pending" | "checks-failing" | "untrusted-actor" | "too-many-files-changed" | "blocked-path-changed" | "changed-files-unavailable";
+                        resourceId?: string | undefined;
+                        revision?: string | undefined;
+                        policy?: {
+                            blockedPaths?: string[] | undefined;
+                            matchedPaths?: string[] | undefined;
+                            maxFilesChanged?: number | undefined;
+                            filesChanged?: number | undefined;
+                        } | undefined;
                     };
                 };
             }, {
@@ -1467,6 +1499,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                     kind: "blocked";
                     data: {
                         reason: "closed" | "missing-resource" | "ambiguous-resource" | "correlation-conflict" | "stale-approval" | "checks-pending" | "checks-failing" | "untrusted-actor" | "too-many-files-changed" | "blocked-path-changed" | "changed-files-unavailable";
+                        resourceId?: string | undefined;
+                        revision?: string | undefined;
+                        policy?: {
+                            blockedPaths?: string[] | undefined;
+                            matchedPaths?: string[] | undefined;
+                            maxFilesChanged?: number | undefined;
+                            filesChanged?: number | undefined;
+                        } | undefined;
                     };
                 };
                 fact: {
@@ -1614,6 +1654,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                             "blocked-path-changed": "blocked-path-changed";
                             "changed-files-unavailable": "changed-files-unavailable";
                         }>;
+                        resourceId: z.ZodOptional<z.ZodString>;
+                        revision: z.ZodOptional<z.ZodString>;
+                        policy: z.ZodOptional<z.ZodObject<{
+                            blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+                            filesChanged: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>;
                 }, z.core.$strict>;
                 fact: z.ZodObject<{
@@ -1828,6 +1876,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                             "blocked-path-changed": "blocked-path-changed";
                             "changed-files-unavailable": "changed-files-unavailable";
                         }>;
+                        resourceId: z.ZodOptional<z.ZodString>;
+                        revision: z.ZodOptional<z.ZodString>;
+                        policy: z.ZodOptional<z.ZodObject<{
+                            blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+                            filesChanged: z.ZodOptional<z.ZodNumber>;
+                        }, z.core.$strict>>;
                     }, z.core.$strict>;
                 }, z.core.$strict>;
                 fact: z.ZodObject<{
@@ -1934,6 +1990,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                     kind: "blocked";
                     data: {
                         reason: "closed" | "missing-resource" | "ambiguous-resource" | "correlation-conflict" | "stale-approval" | "checks-pending" | "checks-failing" | "untrusted-actor" | "too-many-files-changed" | "blocked-path-changed" | "changed-files-unavailable";
+                        resourceId?: string | undefined;
+                        revision?: string | undefined;
+                        policy?: {
+                            blockedPaths?: string[] | undefined;
+                            matchedPaths?: string[] | undefined;
+                            maxFilesChanged?: number | undefined;
+                            filesChanged?: number | undefined;
+                        } | undefined;
                     };
                 };
             }, {
@@ -1944,6 +2008,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                     kind: "blocked";
                     data: {
                         reason: "closed" | "missing-resource" | "ambiguous-resource" | "correlation-conflict" | "stale-approval" | "checks-pending" | "checks-failing" | "untrusted-actor" | "too-many-files-changed" | "blocked-path-changed" | "changed-files-unavailable";
+                        resourceId?: string | undefined;
+                        revision?: string | undefined;
+                        policy?: {
+                            blockedPaths?: string[] | undefined;
+                            matchedPaths?: string[] | undefined;
+                            maxFilesChanged?: number | undefined;
+                            filesChanged?: number | undefined;
+                        } | undefined;
                     };
                 };
                 fact: {
@@ -2570,6 +2642,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                         "blocked-path-changed": "blocked-path-changed";
                         "changed-files-unavailable": "changed-files-unavailable";
                     }>;
+                    resourceId: z.ZodOptional<z.ZodString>;
+                    revision: z.ZodOptional<z.ZodString>;
+                    policy: z.ZodOptional<z.ZodObject<{
+                        blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+                        filesChanged: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>;
                 }, z.core.$strict>;
             }, z.core.$strict>;
             fact: z.ZodObject<{
@@ -2732,6 +2812,14 @@ export declare function createActivityEventSchemas(eventTypes: ActivityEventType
                         "blocked-path-changed": "blocked-path-changed";
                         "changed-files-unavailable": "changed-files-unavailable";
                     }>;
+                    resourceId: z.ZodOptional<z.ZodString>;
+                    revision: z.ZodOptional<z.ZodString>;
+                    policy: z.ZodOptional<z.ZodObject<{
+                        blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+                        filesChanged: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>>;
                 }, z.core.$strict>;
             }, z.core.$strict>;
             fact: z.ZodObject<{

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { mergePolicyDetailsSchema } from '../pr/merge-policy-denial.js';
 import { eventDataSchema, eventEnvelopeSchema } from '@atolis-hq/eventing';
 import { brandedStringSchema } from '../../kernel/index.js';
 import { ResourceStreamKind, resourceId } from '../../resources/index.js';
@@ -114,7 +115,14 @@ export const requestedOutcomeSchema = z
 export const deniedOutcomeSchema = z
     .object({
     kind: z.literal(ActivityOutcomeKind.Blocked),
-    data: z.object({ reason: denialCodeSchema }).strict(),
+    data: z
+        .object({
+        reason: denialCodeSchema,
+        resourceId: z.string().optional(),
+        revision: z.string().optional(),
+        policy: mergePolicyDetailsSchema.optional(),
+    })
+        .strict(),
 })
     .strict();
 export function createResourceFactDraftSchemas(eventTypes) {

package/dist/src/activities/index.d.ts

@@ -21,3 +21,4 @@ export * from './pr/vocabulary.js';
 export * from './review/authorization.js';
 export * from './review/contracts.js';
 export * from './review/signals.js';
+export * from './pr/merge-policy-denial.js';

package/dist/src/activities/index.js

@@ -21,3 +21,4 @@ export * from './pr/vocabulary.js';
 export * from './review/authorization.js';
 export * from './review/contracts.js';
 export * from './review/signals.js';
+export * from './pr/merge-policy-denial.js';

package/dist/src/activities/pr/activity-support.js

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ActivityFailureCode, ActivityOutcomeKind, ActivityResourceRole, IntentAppendStatus, } from '../contracts/vocabulary.js';
+import { mergePolicyDetailsSchema } from './merge-policy-denial.js';
 import { PullRequestDenialCode } from './vocabulary.js';
 import { ResourceCorrelationRole, resourceId, } from '../../resources/index.js';
 import { isPullRequestLikeResource } from './capability.js';
@@ -29,6 +30,9 @@ export const pullRequestOutcomeSchema = z.union([
         kind: z.literal(ActivityOutcomeKind.Blocked),
         data: z
             .object({
+            resourceId: z.string().optional(),
+            revision: z.string().optional(),
+            policy: mergePolicyDetailsSchema.optional(),
             reason: z.enum([
                 PullRequestDenialCode.MissingResource,
                 PullRequestDenialCode.AmbiguousResource,

package/dist/src/activities/pr/contracts.d.ts

@@ -2,6 +2,7 @@ import type { ResourceCorrelationView, ResourceId, ResourceView } from '../../re
 import type { WorkItemId, WorkItemView } from '../../work/index.js';
 import type { ActivityFailureCode, ActivityOutcomeKind, ActivityResourceRole } from '../contracts/vocabulary.js';
 import type { ReviewActorKind, ReviewerAuthorizationEvidence } from '../review/contracts.js';
+import type { MergePolicyDetails } from './merge-policy-denial.js';
 import type { MergeMethod, PullRequestCheckState, PullRequestDenialCode, PullRequestState } from './vocabulary.js';
 export interface PullRequestView {
     readonly resourceId: ResourceId;
@@ -89,6 +90,9 @@ export type PullRequestActivityOutcome = {
     readonly kind: typeof ActivityOutcomeKind.Blocked;
     readonly data: {
         readonly reason: PullRequestDenialCode;
+        readonly resourceId?: string | undefined;
+        readonly revision?: string | undefined;
+        readonly policy?: MergePolicyDetails | undefined;
     };
 } | {
     readonly kind: typeof ActivityOutcomeKind.Failed;
@@ -130,4 +134,5 @@ export type PullRequestAuthorityDecision = {
 } | {
     readonly allowed: false;
     readonly reason: PullRequestDenialCode;
+    readonly policy?: MergePolicyDetails;
 };

package/dist/src/activities/pr/merge-policy-denial.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const mergePolicyDetailsSchema: z.ZodObject<{
+    blockedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    matchedPaths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxFilesChanged: z.ZodOptional<z.ZodNumber>;
+    filesChanged: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+export type MergePolicyDetails = z.infer<typeof mergePolicyDetailsSchema>;
+export declare function readMergePolicyDenial(outcome: unknown): {
+    reason: "too-many-files-changed" | "blocked-path-changed" | "changed-files-unavailable";
+    resourceId?: string | undefined;
+    revision?: string | undefined;
+    policy?: {
+        blockedPaths?: string[] | undefined;
+        matchedPaths?: string[] | undefined;
+        maxFilesChanged?: number | undefined;
+        filesChanged?: number | undefined;
+    } | undefined;
+} | null;

package/dist/src/activities/pr/merge-policy-denial.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { ActivityOutcomeKind } from '../contracts/vocabulary.js';
+import { PullRequestDenialCode } from './vocabulary.js';
+export const mergePolicyDetailsSchema = z
+    .object({
+    blockedPaths: z.array(z.string()).optional(),
+    matchedPaths: z.array(z.string()).optional(),
+    maxFilesChanged: z.number().int().positive().optional(),
+    filesChanged: z.number().int().nonnegative().optional(),
+})
+    .strict();
+const denialSchema = z
+    .object({
+    kind: z.literal(ActivityOutcomeKind.Blocked),
+    data: z
+        .object({
+        reason: z.enum([
+            PullRequestDenialCode.BlockedPathChanged,
+            PullRequestDenialCode.TooManyFilesChanged,
+            PullRequestDenialCode.ChangedFilesUnavailable,
+        ]),
+        resourceId: z.string().optional(),
+        revision: z.string().optional(),
+        policy: mergePolicyDetailsSchema.optional(),
+    })
+        .strict(),
+})
+    .strict();
+export function readMergePolicyDenial(outcome) {
+    const parsed = denialSchema.safeParse(outcome);
+    return parsed.success ? parsed.data.data : null;
+}

package/dist/src/activities/pr/merge.d.ts

@@ -1,7 +1,9 @@
+import { z } from 'zod';
 import type { EventJournal } from '@atolis-hq/eventing';
 import type { ActivityDefinition } from '../contracts/activity.js';
 import { BuiltInActivityName } from '../contracts/vocabulary.js';
 import type { PullRequestService } from './application.js';
 import type { PullRequestActivityOutcome, PullRequestMergeInput } from './contracts.js';
 import { type IntentAppender } from './intent.js';
+export declare const pullRequestMergeInputSchema: z.ZodType<PullRequestMergeInput>;
 export declare function createPullRequestMergeActivity(journal: EventJournal, pullRequests: PullRequestService, appender?: IntentAppender): ActivityDefinition<typeof BuiltInActivityName.PullRequestMerge, PullRequestMergeInput, PullRequestActivityOutcome>;

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

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { ActivityOutcomeKind } from '../contracts/vocabulary.js';
+import { readMergePolicyDenial } from './merge-policy-denial.js';
 import { MergeMethod } from './vocabulary.js';
 import { BuiltInResourceCapability, resourceStream } from '../../resources/index.js';
 import { workItemStream } from '../../work/index.js';
@@ -10,7 +11,7 @@ import { claimAndCompleteDecision, completeDecisionClaim, readDecisionClaim, } f
 import { deliveryIntentRequested, mergeDenied } from './event-data.js';
 import { activityCommandContext, createJournalIntentAppender, } from './intent.js';
 import { decidePullRequestAuthority } from './policy.js';
-const inputSchema = z
+export const pullRequestMergeInputSchema = z
     .object({
     target: pullRequestTargetSchema,
     method: z.enum([MergeMethod.Merge, MergeMethod.Squash, MergeMethod.Rebase]),
@@ -32,7 +33,7 @@ const inputSchema = z
 export function createPullRequestMergeActivity(journal, pullRequests, appender = createJournalIntentAppender(journal)) {
     return {
         name: BuiltInActivityName.PullRequestMerge,
-        inputSchema,
+        inputSchema: pullRequestMergeInputSchema,
         outcomeSchema: pullRequestOutcomeSchema,
         outcomeKinds: [
             ActivityOutcomeKind.Waiting,
@@ -83,13 +84,30 @@ async function executeMerge(journal, pullRequests, appender, invocation, context
     });
     if (!decision.allowed) {
         const factStream = resourceStream(resource.resourceId);
+        const audit = selectedDenialAudit(authority, resource.resourceId);
+        const policyDenial = readMergePolicyDenial({
+            kind: ActivityOutcomeKind.Blocked,
+            data: { reason: decision.reason },
+        });
         const denial = mergeDenied(decision.reason, command, {
             ...selectedDenialAudit(authority, resource.resourceId),
             method: invocation.input.method,
         });
         return claimAndCompleteDecision(journal, appender, invocation.activationId, MergeMethod.Merge, {
             decisionKind: 'denied',
-            outcome: { kind: ActivityOutcomeKind.Blocked, data: { reason: decision.reason } },
+            outcome: {
+                kind: ActivityOutcomeKind.Blocked,
+                data: {
+                    reason: decision.reason,
+                    ...(policyDenial === null
+                        ? {}
+                        : {
+                            resourceId: resource.resourceId,
+                            ...(audit.revision === null ? {} : { revision: audit.revision }),
+                        }),
+                    ...(decision.policy === undefined ? {} : { policy: decision.policy }),
+                },
+            },
             fact: denial,
             factStream,
         });

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

@@ -123,9 +123,18 @@ function changedFilesAuthority(pullRequest, resource, policy) {
     if (changedFiles === undefined)
         return denied(PullRequestDenialCode.ChangedFilesUnavailable);
     if (policy.maxFilesChanged !== undefined && changedFiles.length > policy.maxFilesChanged)
-        return denied(PullRequestDenialCode.TooManyFilesChanged);
-    return policy.blockedPaths.some((blocked) => changedFiles.includes(blocked))
-        ? denied(PullRequestDenialCode.BlockedPathChanged)
+        return {
+            allowed: false,
+            reason: PullRequestDenialCode.TooManyFilesChanged,
+            policy: { maxFilesChanged: policy.maxFilesChanged, filesChanged: changedFiles.length },
+        };
+    const matchedPaths = policy.blockedPaths.filter((blocked) => changedFiles.includes(blocked));
+    return matchedPaths.length > 0
+        ? {
+            allowed: false,
+            reason: PullRequestDenialCode.BlockedPathChanged,
+            policy: { blockedPaths: [...policy.blockedPaths], matchedPaths },
+        }
         : null;
 }
 function checkAuthority(pullRequest, allowPendingChecks) {

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

@@ -105,8 +105,15 @@ export async function composeIntegrationRuntime(input) {
         ],
     });
     const resourceTransitions = createResourceTransitionReactor(input.orchestration, resourceTransitionEvidence);
+    const recoverMergedWaits = () => input.orchestration.recoverPolicyBlockedMerges(resourceTransitionEvidence, {
+        commandId: input.ids.next('command'),
+        correlationId: 'merge-recovery',
+        occurredAt: input.clock.now().toISOString(),
+        actor: { kind: EventActorKind.System, id: 'merge-recovery' },
+    });
     input.orchestration.setAcceptSignalOperationCoordinator(async (operation) => {
         await input.processorRuntime.catchUpThrough('resource-transition signal', await input.journal.latestGlobalPosition(), [resourceTransitions.processor]);
+        await recoverMergedWaits();
         return operation();
     });
     const outcomes = new DeliveryOutcomeReactor(input.journal, input.orchestration, input.projections, input.processorState, input.conversations, input.subscriptionRunSerialiser);
@@ -139,6 +146,7 @@ export async function composeIntegrationRuntime(input) {
                 });
         }),
         maintain: () => observeMemory(memoryProfile, 'runner.maintenance', async () => {
+            await recoverMergedWaits();
             await watchReconciler.reconcileOnce();
             await artifacts.reconcileOnce();
             await outcomes.reconcileOnce();

package/dist/src/bootstrap/surface-api-merge-policy.d.ts

@@ -0,0 +1,19 @@
+import { type WorkflowInstanceView } from '../orchestration/index.js';
+import type { CompositionRoot } from './composition-root.js';
+export declare function mergePolicyBlockForWork(root: CompositionRoot, workflow: WorkflowInstanceView): Promise<import("../surfaces/index.js").MergePolicyBlockResponse | undefined>;
+export declare function presentPrimaryWorkflow(root: CompositionRoot, workflow: WorkflowInstanceView | null): Promise<{
+    mergePolicyBlock?: import("../surfaces/index.js").MergePolicyBlockResponse;
+    workflowInstanceId: string;
+    workItemKey: string;
+    workflowName: string;
+    orchestrationGroupId: string;
+    parentWorkflowInstanceId?: string;
+    status: string;
+    currentStage: string;
+    blockReason?: string;
+    retryEligible?: boolean;
+    extendEligible?: boolean;
+    waitingFor?: {
+        readonly signalKind: string;
+    };
+} | null>;

package/dist/src/bootstrap/surface-api-merge-policy.js

@@ -0,0 +1,52 @@
+import { BuiltInActivityName, PullRequestDenialCode, pullRequestMergeInputSchema, readMergePolicyDenial, selectPrimaryPullRequest, } from '../activities/index.js';
+import { WorkflowStatus } from '../orchestration/index.js';
+import { presentMergePolicyBlock, presentWorkflowInstance } from '../surfaces/index.js';
+export async function mergePolicyBlockForWork(root, workflow) {
+    const denial = readMergePolicyDenial(workflow.lastOutcome);
+    if (denial === null ||
+        workflow.status !== WorkflowStatus.Waiting ||
+        workflow.pendingActivation?.activity !== BuiltInActivityName.PullRequestMerge)
+        return undefined;
+    const selected = selectPrimaryPullRequest(await root.pullRequests.authorityInput(workflow.workItemId), workflow.workItemId);
+    if (selected === null ||
+        (denial.resourceId !== undefined && denial.resourceId !== selected.pullRequest.resourceId))
+        return undefined;
+    const policy = denial.policy ??
+        (await legacyPolicy(root, workflow, denial.reason, selected.pullRequest.changedFiles));
+    return presentMergePolicyBlock({
+        workflow,
+        pullRequest: selected.pullRequest,
+        policy,
+        href: root.resolveResourceLink(selected.resource.resource.externalKey) ?? undefined,
+    });
+}
+async function legacyPolicy(root, workflow, reason, files) {
+    const definition = await root.orchestration.definitionFor(workflow).catch(() => null);
+    const parsed = pullRequestMergeInputSchema.safeParse(definition?.stages[workflow.currentStage]?.with);
+    if (!parsed.success)
+        return undefined;
+    if (reason === PullRequestDenialCode.BlockedPathChanged)
+        return {
+            blockedPaths: [...parsed.data.blockedPaths],
+            ...(files === undefined
+                ? {}
+                : { matchedPaths: parsed.data.blockedPaths.filter((path) => files.includes(path)) }),
+        };
+    if (reason === PullRequestDenialCode.TooManyFilesChanged)
+        return {
+            ...(parsed.data.maxFilesChanged === undefined
+                ? {}
+                : { maxFilesChanged: parsed.data.maxFilesChanged }),
+            ...(files === undefined ? {} : { filesChanged: files.length }),
+        };
+    return undefined;
+}
+export async function presentPrimaryWorkflow(root, workflow) {
+    if (workflow === null)
+        return null;
+    const mergePolicyBlock = await mergePolicyBlockForWork(root, workflow);
+    return {
+        ...presentWorkflowInstance(workflow),
+        ...(mergePolicyBlock === undefined ? {} : { mergePolicyBlock }),
+    };
+}

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

@@ -7,6 +7,7 @@ import { workCorrelationsProjection, } from '../resources/index.js';
 import { ApiCommandStatus, fromWorkItemKey, presentResource, presentRun, presentWorkflowInstance, presentWorkItem, toWorkItemKey, } from '../surfaces/index.js';
 import { workItemId, WorkStatus } from '../work/index.js';
 import { primaryExternalRef } from './external-ref.js';
+import { presentPrimaryWorkflow } from './surface-api-merge-policy.js';
 import { projectionMeta } from './surface-api-metadata.js';
 import { projectionPage } from './surface-api-projection-pages.js';
 import { enrichRun } from './surface-api-run-context.js';
@@ -200,7 +201,7 @@ async function workDetail(root, key, now) {
         work: presentDetailWork(work, externalRef, runs),
         resources: resources.map(presentResource(root.resolveResourceLink)),
         orchestration: {
-            primary: primary === null ? null : presentWorkflowInstance(primary),
+            primary: await presentPrimaryWorkflow(root, primary),
             children: workflows
                 .filter((value) => value.parentWorkflowInstanceId !== undefined)
                 .map(presentWorkflowInstance),

package/dist/src/bootstrap/version.js

@@ -124,6 +124,6 @@ export function resolveWakeVersion(options = {}) {
         return `g${headHash.slice(0, 7)}`;
     return '0.1.0-dev';
 }
-export const wakeVersion = "v0.4.58";
+export const wakeVersion = "v0.4.59";
 /** The registry-installable version used by packaged sandbox images. */
 export const wakePackageVersion = packageVersion(defaultRepoRoot) ?? wakeVersion;

package/dist/src/orchestration/application/orchestration-service.d.ts

@@ -1,3 +1,4 @@
+import type { ResourceTransitionEvidence } from './resource-transition-evidence.js';
 import type { CommandContext, EventJournal, ProjectionStore } from '@atolis-hq/eventing';
 import type { ActivationId, ActivityOutcome } from '../../activities/index.js';
 import { type WorkItemId, type WorkService } from '../../work/index.js';
@@ -91,6 +92,7 @@ export declare class OrchestrationService {
         parent: WorkflowInstanceView;
         watch: Readonly<import("../contracts/config.js").CompiledWatch>;
     }[]>;
+    recoverPolicyBlockedMerges(evidence: ResourceTransitionEvidence, context: CommandContext): Promise<void>;
     listResourceTransitionMatches(event: Parameters<AdvanceWorkflow['listResourceTransitionMatches']>[0]): Promise<readonly import("./resource-transition-matching.js").ResourceTransitionMatch[]>;
     applyResourceTransition(workflowInstanceId: WorkflowInstanceId, target: TransitionTarget, evidenceId: string, context: CommandContext): Promise<WorkflowInstanceView | null>;
 }

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

@@ -1,3 +1,4 @@
+import { recoverPolicyBlockedMerges } from './policy-blocked-merge-recovery.js';
 import { WorkStatus } from '../../work/index.js';
 import { selectOrchestrationEvent } from '../contracts/event-decoder.js';
 import { OrchestrationEventType } from '../contracts/events.js';
@@ -228,6 +229,9 @@ export class OrchestrationService {
     listWatchMatches(event, context) {
         return this.advanceWorkflow.listWatchMatches(event, context);
     }
+    recoverPolicyBlockedMerges(evidence, context) {
+        return recoverPolicyBlockedMerges(new OrchestrationRepository(this.journal), this.startWorkflow, evidence, context);
+    }
     listResourceTransitionMatches(event) {
         return this.advanceWorkflow.listResourceTransitionMatches(event);
     }

package/dist/src/orchestration/application/policy-blocked-merge-recovery.d.ts

@@ -0,0 +1,7 @@
+import type { CommandContext } from '@atolis-hq/eventing';
+import type { WorkflowInstanceView } from '../contracts/views.js';
+import type { OrchestrationRepository } from './orchestration-repository.js';
+import type { ResourceTransitionEvidence } from './resource-transition-evidence.js';
+import type { StartWorkflow } from './start-workflow.js';
+export declare function recoverPolicyBlockedMerges(repository: OrchestrationRepository, workflows: StartWorkflow, evidence: ResourceTransitionEvidence, context: CommandContext): Promise<void>;
+export declare function isPolicyBlockedMergeWait(view: WorkflowInstanceView): boolean;

package/dist/src/orchestration/application/policy-blocked-merge-recovery.js

@@ -0,0 +1,54 @@
+import { ActivityEventType, ActivityOutcomeKind, BuiltInActivityName, PullRequestState, readMergePolicyDenial, } from '../../activities/index.js';
+import { TransitionTargetKind, WorkflowStatus } from '../contracts/vocabulary.js';
+import { acceptResourceTransition } from './resource-transition-matching.js';
+export async function recoverPolicyBlockedMerges(repository, workflows, evidence, context) {
+    for (const loaded of await repository.list()) {
+        const view = loaded.view;
+        if (view === null || !isPolicyBlockedMergeWait(view))
+            continue;
+        const definition = await workflows.definitionForOperation(view, loaded.sequence, context);
+        if (definition === null)
+            continue;
+        const stage = definition.stages[view.currentStage];
+        if (!isBlockedRouteWait(stage, view))
+            continue;
+        // The pinned definition supplies the completion destination, never current config.
+        const transitions = mergedTransitions(stage);
+        const activationId = view.acceptedOutcomes.at(-1);
+        if (transitions === undefined || transitions.length !== 1 || activationId === undefined)
+            continue;
+        const resolved = await evidence.resolve({
+            workItemId: view.workItemId,
+            transitions,
+            mergeDenialActivationId: activationId,
+        });
+        if (resolved === null)
+            continue;
+        await acceptResourceTransition(repository, workflows, view.workflowInstanceId, resolved.transition.target, resolved.evidenceId, { ...context, expectedSequence: loaded.sequence });
+    }
+}
+export function isPolicyBlockedMergeWait(view) {
+    return (view.status === WorkflowStatus.Waiting &&
+        view.parentWorkflowInstanceId === undefined &&
+        view.waitingFor !== undefined &&
+        view.waitingFor.intentEventId === undefined &&
+        view.pendingActivation?.activity === BuiltInActivityName.PullRequestMerge &&
+        readMergePolicyDenial(view.lastOutcome) !== null);
+}
+function isBlockedRouteWait(stage, view) {
+    const blocked = stage?.on[ActivityOutcomeKind.Blocked];
+    return (stage?.activity === BuiltInActivityName.PullRequestMerge &&
+        blocked?.target.kind === TransitionTargetKind.AwaitSignal &&
+        blocked.target.signal === view.waitingFor?.signalKind);
+}
+function isMergedTransition(transition) {
+    return (transition.event === ActivityEventType.PrStateChanged &&
+        transition.where !== undefined &&
+        'state' in transition.where &&
+        transition.where.state === PullRequestState.Merged &&
+        (transition.target.kind === TransitionTargetKind.Stage ||
+            transition.target.kind === TransitionTargetKind.Complete));
+}
+function mergedTransitions(stage) {
+    return stage?.on[ActivityOutcomeKind.Done]?.resourceTransitions?.filter(isMergedTransition);
+}

package/dist/src/orchestration/application/pull-request-transition-evidence.js

@@ -1,4 +1,4 @@
-import { ActivityEventType, ActivityResourceRole, decidePullRequestAuthority, PullRequestCheckState, PullRequestState, selectActivityEvent, selectPrimaryPullRequest, } from '../../activities/index.js';
+import { ActivityEventType, ActivityResourceRole, decidePullRequestAuthority, PullRequestCheckState, PullRequestDenialCode, PullRequestState, selectActivityEvent, selectPrimaryPullRequest, } from '../../activities/index.js';
 const triggers = [
     ActivityEventType.PrReviewAccepted,
     ActivityEventType.PrStateChanged,
@@ -7,12 +7,21 @@ const triggers = [
 export function createPullRequestTransitionEvidence(pullRequests) {
     return {
         triggers,
-        async resolve({ workItemId, transitions, fact, }) {
+        async resolve({ workItemId, transitions, fact, mergeDenialActivationId, }) {
             const input = await pullRequests.authorityInput(workItemId);
             const selected = selectPrimaryPullRequest(input, workItemId);
             if (selected === null)
                 return null;
             const resourceId = selected.pullRequest.resourceId;
+            if (mergeDenialActivationId !== undefined) {
+                const denied = (await pullRequests.factsFor(resourceId)).some((entry) => entry.event.eventType === ActivityEventType.PrMergeDenied &&
+                    entry.event.causationId === mergeDenialActivationId &&
+                    (entry.event.payload.reason === PullRequestDenialCode.BlockedPathChanged ||
+                        entry.event.payload.reason === PullRequestDenialCode.TooManyFilesChanged ||
+                        entry.event.payload.reason === PullRequestDenialCode.ChangedFilesUnavailable));
+                if (!denied)
+                    return null;
+            }
             const candidates = fact === undefined ? await pullRequests.factsFor(resourceId) : scoped(fact, resourceId);
             if (candidates.length === 0)
                 return null;

package/dist/src/orchestration/application/resource-transition-evidence.d.ts

@@ -6,6 +6,8 @@ export interface ResourceTransitionEvidenceInput {
     readonly workItemId: WorkItemId;
     readonly transitions: readonly CompiledResourceTransition[];
     readonly fact?: ResourceTransitionFact;
+    /** Requires a policy denial on the selected PR from this exact activation. */
+    readonly mergeDenialActivationId?: string;
 }
 export interface ResourceTransitionEvidenceResolution {
     readonly transition: CompiledResourceTransition;