@atolis-hq/wake 0.2.97 → 0.3.1

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

@@ -0,0 +1,42 @@
+import { createActivityEventSchemas } from './event-schema.js';
+export const ActivityEventType = {
+    PrDiscovered: 'pr.discovered',
+    PrRevisionChanged: 'pr.revision-changed',
+    PrStateChanged: 'pr.state-changed',
+    PrChecksChanged: 'pr.checks-changed',
+    PrReviewAccepted: 'pr.review-accepted',
+    ReviewAcceptanceSignalRecorded: 'review.acceptance-signal-recorded',
+    PrReviewChangesRequested: 'pr.review-changes-requested',
+    PrReviewRejected: 'pr.review-rejected',
+    PrMergeDenied: 'pr.merge-denied',
+    PrApproveDenied: 'pr.approve-denied',
+    PrMergeAuthorized: 'pr.merge-authorized',
+    PrApproveRequested: 'pr.approve-requested',
+    PrMergeRequested: 'pr.merge-requested',
+    PrApproveDecisionClaimed: 'pr.approve-decision-claimed',
+    PrMergeDecisionClaimed: 'pr.merge-decision-claimed',
+};
+const { draftSchema, eventSchema } = createActivityEventSchemas(ActivityEventType);
+export function decodeActivityEvent(event) {
+    const result = eventSchema.safeParse(event);
+    if (!result.success)
+        throw invalidActivityEvent(event, result.error);
+    return result.data;
+}
+export function selectActivityEvent(event) {
+    return ownsActivityEventType(event.eventType) ? decodeActivityEvent(event) : null;
+}
+export function decodeActivityEventDraft(draft) {
+    const result = draftSchema.safeParse(draft);
+    if (!result.success)
+        throw new Error(`Invalid Activity event draft ${draft.eventId} (${draft.eventType}): ${result.error.message}`, { cause: result.error });
+    return result.data;
+}
+function ownsActivityEventType(eventType) {
+    return (eventType.startsWith('activities.') ||
+        eventType.startsWith('pr.') ||
+        eventType.startsWith('review.'));
+}
+function invalidActivityEvent(event, cause) {
+    return new Error(`Invalid Activity event ${event.eventId} at global position ${event.globalPosition} (${event.eventType}): ${cause.message}`, { cause });
+}

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

@@ -0,0 +1,29 @@
+export const activityName = (value) => {
+    if (!/^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/.test(value))
+        throw new Error(`Invalid Activity name: ${value}`);
+    return value;
+};
+export const activationId = (value) => {
+    if (value.trim().length === 0)
+        throw new Error('ActivationId must not be empty');
+    if (!isWellFormedUnicode(value))
+        throw new Error('ActivationId must contain well-formed Unicode');
+    return value;
+};
+function isWellFormedUnicode(value) {
+    for (let index = 0; index < value.length; index += 1) {
+        const code = value.charCodeAt(index);
+        if (code >= 0xd800 && code <= 0xdbff) {
+            if (index + 1 >= value.length)
+                return false;
+            const next = value.charCodeAt(index + 1);
+            if (next < 0xdc00 || next > 0xdfff)
+                return false;
+            index += 1;
+        }
+        else if (code >= 0xdc00 && code <= 0xdfff) {
+            return false;
+        }
+    }
+    return true;
+}

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

@@ -0,0 +1,71 @@
+import { activityName } from './identifiers.js';
+export class ActivityRegistry {
+    entries = new Map();
+    register(definition) {
+        activityName(definition.name);
+        if (this.entries.has(definition.name))
+            throw new Error(`Activity ${definition.name} is already registered`);
+        const uniqueKinds = new Set(definition.outcomeKinds);
+        if (uniqueKinds.size !== definition.outcomeKinds.length)
+            throw new Error(`Duplicate Activity outcome kind declared by ${definition.name}`);
+        const descriptor = Object.freeze({
+            name: definition.name,
+            outcomeKinds: Object.freeze([...definition.outcomeKinds]),
+            resources: Object.freeze([...definition.resources]),
+            executionKind: definition.executionKind,
+        });
+        this.entries.set(definition.name, {
+            descriptor,
+            validateInput(input) {
+                return parse(definition.name, 'input', definition.inputSchema, input);
+            },
+            validateOutcome(output) {
+                assertDeclaredOutcomeKind(descriptor, output);
+                return parse(definition.name, 'outcome', definition.outcomeSchema, output);
+            },
+            async execute(invocation, context) {
+                const input = parse(definition.name, 'input', definition.inputSchema, invocation.input);
+                const output = await definition.handler.execute({ ...invocation, input }, context);
+                assertDeclaredOutcomeKind(descriptor, output);
+                return parse(definition.name, 'outcome', definition.outcomeSchema, output);
+            },
+        });
+    }
+    describe(name) {
+        return this.entry(name).descriptor;
+    }
+    validateInput(name, input) {
+        return this.entry(name).validateInput(input);
+    }
+    validateOutcome(name, output) {
+        return this.entry(name).validateOutcome(output);
+    }
+    execute(invocation, context) {
+        return this.entry(invocation.activity).execute(invocation, context);
+    }
+    list() {
+        return [...this.entries.values()].map((entry) => entry.descriptor);
+    }
+    entry(name) {
+        const parsedName = activityName(name);
+        const entry = this.entries.get(parsedName);
+        if (entry === undefined)
+            throw new Error(`Unknown Activity: ${name}`);
+        return entry;
+    }
+}
+function assertDeclaredOutcomeKind(definition, value) {
+    if (typeof value !== 'object' || value === null || !('kind' in value))
+        return;
+    const kind = Reflect.get(value, 'kind');
+    if (typeof kind === 'string' && !definition.outcomeKinds.includes(kind))
+        throw new Error(`Undeclared Activity outcome kind ${kind} returned by ${definition.name}`);
+}
+function parse(name, kind, schema, value) {
+    const parsed = schema.safeParse(value);
+    if (parsed.success)
+        return parsed.data;
+    const issues = parsed.error?.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`).join('; ') ??
+        'invalid value';
+    throw new Error(`Activity ${name} ${kind} invalid: ${issues}`);
+}

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

@@ -0,0 +1,17 @@
+export const ActivityStreamKind = { Decision: 'activity-decision' };
+export const activityDecisionId = (value, action) => {
+    if (!value.endsWith(`:pr.${action}`) || value.length === `:pr.${action}`.length) {
+        throw new Error(`Invalid ${action} ActivityDecisionId: ${value}`);
+    }
+    return value;
+};
+export const activityDecisionStream = (activation, action) => ({
+    kind: ActivityStreamKind.Decision,
+    id: activityDecisionId(`${segment(activation)}:pr.${segment(action)}`, action),
+});
+export const isActivityDecisionStream = (stream) => stream.kind === ActivityStreamKind.Decision;
+function segment(value) {
+    if (value.trim().length === 0)
+        throw new Error('Activity decision stream segment must not be empty');
+    return encodeURIComponent(value);
+}

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

@@ -0,0 +1,58 @@
+import { defineClosedVocabulary } from '../../kernel/index.js';
+import { activityName } from './identifiers.js';
+export const ActivityExecutionKind = defineClosedVocabulary({
+    Agent: 'agent',
+    Script: 'script',
+    Deterministic: 'deterministic',
+});
+export const ActivityWorkspaceMode = defineClosedVocabulary({
+    ReadOnly: 'read-only',
+    Branch: 'branch',
+});
+export const ActivityResourceCardinality = defineClosedVocabulary({
+    ZeroOrOne: 'zero-or-one',
+    ExactlyOne: 'exactly-one',
+    OneOrMore: 'one-or-more',
+});
+export const ActivityResourceRole = defineClosedVocabulary({
+    Primary: 'primary',
+    Secondary: 'secondary',
+});
+export const ExternalExecutionKind = defineClosedVocabulary({
+    Process: 'process',
+    RemoteSession: 'remote-session',
+});
+export const RetrySafety = defineClosedVocabulary({
+    SafeToRetry: 'safe-to-retry',
+    RequiresReconciliation: 'requires-reconciliation',
+});
+export const ActivityFailureCode = defineClosedVocabulary({
+    IntentWriteFailed: 'intent-write-failed',
+    InvalidAgentResult: 'invalid-agent-result',
+    AmbiguousRunnerResult: 'ambiguous-runner-result',
+    RunnerFailed: 'runner-failed',
+});
+export const ActivityOutcomeKind = defineClosedVocabulary({
+    Waiting: 'waiting',
+    Done: 'done',
+    Rejected: 'rejected',
+    Blocked: 'blocked',
+    Failed: 'failed',
+});
+export const ActivityRunnerTransportStatus = defineClosedVocabulary({
+    Succeeded: 'succeeded',
+    Failed: 'failed',
+    Cancelled: 'cancelled',
+    Ambiguous: 'ambiguous',
+});
+export const IntentAppendStatus = defineClosedVocabulary({
+    Appended: 'appended',
+    Known: 'known',
+    Ambiguous: 'ambiguous',
+    Failed: 'failed',
+});
+export const BuiltInActivityName = {
+    Agent: activityName(ActivityExecutionKind.Agent),
+    PullRequestApprove: activityName('pr.approve'),
+    PullRequestMerge: activityName('pr.merge'),
+};

package/dist/src/activities/index.js

@@ -0,0 +1,21 @@
+export * from './agent/agent-activity-definition.js';
+export * from './agent/agent-activity.js';
+export * from './agent/agent-result.js';
+export * from './contracts/activity.js';
+export * from './contracts/config.js';
+export * from './contracts/events.js';
+export * from './contracts/identifiers.js';
+export * from './contracts/registry.js';
+export * from './contracts/streams.js';
+export * from './contracts/vocabulary.js';
+export * from './pr/application.js';
+export * from './pr/approve.js';
+export * from './pr/contracts.js';
+export * from './pr/merge-authority-gate.js';
+export * from './pr/merge.js';
+export * from './pr/policy.js';
+export * from './pr/projection.js';
+export * from './pr/vocabulary.js';
+export * from './review/authorization.js';
+export * from './review/contracts.js';
+export * from './review/signals.js';

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

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { ActivityFailureCode, ActivityOutcomeKind, ActivityResourceRole, IntentAppendStatus, } from '../contracts/vocabulary.js';
+import { PullRequestDenialCode } from './vocabulary.js';
+import { ResourceCorrelationRole, resourceId, } from '../../resources/index.js';
+import { isPullRequestLikeResource } from './capability.js';
+export const pullRequestTargetSchema = z
+    .union([
+    z.literal(ActivityResourceRole.Primary),
+    z.object({ resourceId: z.string().min(1).transform(resourceId) }).strict(),
+])
+    .default(ActivityResourceRole.Primary);
+export const pullRequestOutcomeSchema = z.union([
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Waiting),
+        data: z
+            .object({ intentEventId: z.string(), signalKind: z.literal('delivery-result') })
+            .strict(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Done),
+        data: z.object({ deliveryEventId: z.string() }).strict(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Blocked),
+        data: z
+            .object({
+            reason: z.enum([
+                PullRequestDenialCode.MissingResource,
+                PullRequestDenialCode.AmbiguousResource,
+                PullRequestDenialCode.CorrelationConflict,
+                PullRequestDenialCode.Closed,
+                PullRequestDenialCode.StaleApproval,
+                PullRequestDenialCode.ChecksPending,
+                PullRequestDenialCode.ChecksFailing,
+                PullRequestDenialCode.UntrustedActor,
+                PullRequestDenialCode.TooManyFilesChanged,
+                PullRequestDenialCode.BlockedPathChanged,
+                PullRequestDenialCode.ChangedFilesUnavailable,
+            ]),
+        })
+            .strict(),
+    })
+        .strict(),
+    z
+        .object({
+        kind: z.literal(ActivityOutcomeKind.Failed),
+        data: z
+            .object({
+            reason: z.literal(ActivityFailureCode.IntentWriteFailed),
+        })
+            .strict(),
+    })
+        .strict(),
+]);
+export function resolvePrimaryCapability(invocationResources, authority, workItemId, target, capability) {
+    const primaryCandidates = authority.resources.filter((entry) => isPullRequestLikeResource(entry.resource.capabilities) &&
+        entry.correlations.some((correlation) => correlation.role === ResourceCorrelationRole.Primary &&
+            correlation.workItemId === workItemId));
+    const targetedCandidates = primaryCandidates.filter((entry) => target === ActivityResourceRole.Primary || entry.resource.resourceId === target.resourceId);
+    const capableIds = new Set(invocationResources
+        .filter((resource) => resource.capabilities.includes(capability))
+        .map((resource) => resource.resourceId));
+    const matches = targetedCandidates.filter((entry) => capableIds.has(entry.resource.resourceId));
+    if (matches.length === 1)
+        return { allowed: true, resourceId: matches[0].resource.resourceId };
+    return {
+        allowed: false,
+        reason: matches.length === 0
+            ? PullRequestDenialCode.MissingResource
+            : PullRequestDenialCode.AmbiguousResource,
+        candidates: candidateAudit(authority, primaryCandidates.map((entry) => entry.resource.resourceId)),
+    };
+}
+export function selectionDenialAudit(target, candidates) {
+    return {
+        target,
+        candidates,
+        resourceId: null,
+        revision: null,
+    };
+}
+export function selectedDenialAudit(authority, selected) {
+    const view = authority.pullRequests.find((candidate) => candidate.resourceId === selected);
+    return {
+        resourceId: selected,
+        revision: view?.headRevision ?? null,
+    };
+}
+export async function appendResolved(journal, appender, stream, event) {
+    const result = await appender.append(stream, event);
+    if (result !== IntentAppendStatus.Ambiguous)
+        return result;
+    const events = await journal.readStream(stream);
+    return events.some((candidate) => candidate.eventId === event.eventId)
+        ? IntentAppendStatus.Known
+        : IntentAppendStatus.Failed;
+}
+function candidateAudit(authority, resourceIds) {
+    return [...resourceIds]
+        .sort((left, right) => left.localeCompare(right))
+        .map((id) => ({
+        resourceId: id,
+        revision: authority.pullRequests.find((candidate) => candidate.resourceId === id)?.headRevision ??
+            null,
+    }));
+}

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

@@ -0,0 +1,158 @@
+import { resourceStream, } from '../../resources/index.js';
+import { workItemStream } from '../../work/index.js';
+import { ActivityEventType } from '../contracts/events.js';
+import { ActivityResourceRole } from '../contracts/vocabulary.js';
+import { isReviewAuthorized } from '../review/authorization.js';
+import { isPullRequestLikeResource } from './capability.js';
+import { checksChanged, discovered, mergeAuthorized, mergeDenied, reviewAcceptanceSignalRecorded, reviewAccepted, reviewChangesRequested, reviewRejected, revisionChanged, stateChanged, } from './event-drafts.js';
+import { decidePullRequestAuthority } from './policy.js';
+import { acceptedReviewSignalProjection, pullRequestProjection } from './projection.js';
+import { PullRequestDenialCode } from './vocabulary.js';
+export function createPullRequestService(journal, work, resources) {
+    return new JournalPullRequestService(journal, work, resources);
+}
+class JournalPullRequestService {
+    journal;
+    work;
+    resources;
+    constructor(journal, work, resources) {
+        this.journal = journal;
+        this.work = work;
+        this.resources = resources;
+    }
+    async get(resourceId) {
+        const events = await this.journal.readStream(resourceStream(resourceId));
+        return events.reduce((view, event) => pullRequestProjection.project(view, event), pullRequestProjection.initial(resourceId));
+    }
+    async observe(command, context) {
+        if (!(await this.hasVerifiedPrimaryCorrelation(command)))
+            throw new Error('Pull request lacks verified primary correlation');
+        if ((await this.work.get(command.workItemId)) === null)
+            throw new Error('Pull request WorkItem missing');
+        const current = await this.get(command.resourceId);
+        if (current === null) {
+            await this.append(command.resourceId, discovered(command, context));
+        }
+        else {
+            await this.appendObservationChanges(current, command, context);
+        }
+        const view = await this.get(command.resourceId);
+        if (view === null)
+            throw new Error('Pull request observation was not recorded');
+        return view;
+    }
+    async acceptReviewSignal(command, context) {
+        const rejection = await this.reviewRejection(command.resourceId, command.revision);
+        if (rejection !== null) {
+            await this.append(command.resourceId, reviewRejected(command.resourceId, rejection, context));
+            return;
+        }
+        const signal = reviewAcceptanceSignalRecorded(command, context);
+        const outcome = isReviewAuthorized(command)
+            ? reviewAccepted(command, context)
+            : reviewRejected(command.resourceId, PullRequestDenialCode.UntrustedActor, context);
+        await this.append(command.resourceId, [signal, outcome]);
+    }
+    async requestChangesSignal(command, context) {
+        const rejection = await this.reviewRejection(command.resourceId, command.revision);
+        await this.append(command.resourceId, rejection === null
+            ? reviewChangesRequested(command, context)
+            : reviewRejected(command.resourceId, rejection, context));
+    }
+    async authorizeMerge(workItemId, context) {
+        const prior = await this.priorMergeDecision(context.commandId);
+        if (prior !== null)
+            return prior;
+        const input = await this.authorityInput(workItemId);
+        const decision = decidePullRequestAuthority(input);
+        if (decision.allowed) {
+            const stream = resourceStream(decision.resourceId);
+            await this.appendStream(stream, mergeAuthorized(stream, decision.revision, context));
+            return true;
+        }
+        const stream = denialStream(input, workItemId);
+        await this.appendStream(stream, mergeDenied(stream, decision.reason, context));
+        return false;
+    }
+    async decideAuthority(workItemId, options) {
+        return decidePullRequestAuthority(await this.authorityInput(workItemId), options);
+    }
+    async appendObservationChanges(current, command, context) {
+        if (current.headRevision !== command.headRevision ||
+            current.baseRevision !== command.baseRevision)
+            await this.append(command.resourceId, revisionChanged(command, context));
+        if (current.state !== command.state)
+            await this.append(command.resourceId, stateChanged(command, context));
+        if (current.checks !== command.checks)
+            await this.append(command.resourceId, checksChanged(command, context));
+    }
+    async append(resourceId, event) {
+        const stream = resourceStream(resourceId);
+        await this.appendStream(stream, event);
+    }
+    async appendStream(stream, event) {
+        const events = Array.isArray(event) ? event : [event];
+        await this.journal.append(stream, (await this.journal.readStream(stream)).length, events);
+    }
+    async priorMergeDecision(commandId) {
+        const events = await this.journal.readAll(0);
+        if (events.some((event) => event.eventId === `${commandId}:${ActivityEventType.PrMergeAuthorized}`))
+            return true;
+        return events.some((event) => event.eventId === `${commandId}:${ActivityEventType.PrMergeDenied}`)
+            ? false
+            : null;
+    }
+    async hasVerifiedPrimaryCorrelation(command) {
+        const resource = await this.resources.get(command.resourceId);
+        if (resource === null ||
+            !isPullRequestLikeResource(resource.capabilities) ||
+            resource.primaryCorrelationConflict !== undefined)
+            return false;
+        const correlations = await this.resources.correlations(command.resourceId);
+        const primary = correlations.filter((value) => value.role === ActivityResourceRole.Primary);
+        return primary.length === 1 && primary[0]?.workItemId === command.workItemId;
+    }
+    async reviewRejection(resourceId, revision) {
+        const resource = await this.resources.get(resourceId);
+        const view = await this.get(resourceId);
+        if (resource === null || !isPullRequestLikeResource(resource.capabilities) || view === null)
+            return PullRequestDenialCode.MissingResource;
+        const correlations = await this.resources.correlations(resourceId);
+        if (resource.primaryCorrelationConflict !== undefined ||
+            correlations.filter((value) => value.role === ActivityResourceRole.Primary).length !== 1)
+            return PullRequestDenialCode.CorrelationConflict;
+        return view.headRevision === revision ? null : PullRequestDenialCode.StaleApproval;
+    }
+    async authorityInput(workItemId) {
+        const correlations = await this.resources.correlationsForWork(workItemId);
+        const entries = await Promise.all(correlations.map(async ({ resourceId }) => this.resourceEntry(resourceId)));
+        const resources = entries.filter(isPresent);
+        const pullRequests = (await Promise.all(resources.map(({ resource }) => this.get(resource.resourceId)))).filter(isPresent);
+        const acceptedSignals = (await Promise.all(resources.map(({ resource }) => this.acceptedSignals(resource.resourceId)))).flat();
+        return {
+            work: await this.work.get(workItemId),
+            resources,
+            pullRequests,
+            acceptedSignals,
+        };
+    }
+    async acceptedSignals(resourceId) {
+        const events = await this.journal.readStream(resourceStream(resourceId));
+        return events.reduce((view, event) => acceptedReviewSignalProjection.project(view, event), acceptedReviewSignalProjection.initial(resourceId));
+    }
+    async resourceEntry(resourceId) {
+        const resource = await this.resources.get(resourceId);
+        if (resource === null)
+            return null;
+        return { resource, correlations: await this.resources.correlations(resourceId) };
+    }
+}
+function isPresent(value) {
+    return value !== null;
+}
+function denialStream(input, workItemId) {
+    const resource = input.resources.find((entry) => isPullRequestLikeResource(entry.resource.capabilities));
+    return resource === undefined
+        ? workItemStream(workItemId)
+        : resourceStream(resource.resource.resourceId);
+}

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

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { ActivityOutcomeKind } from '../contracts/vocabulary.js';
+import { BuiltInResourceCapability, resourceStream } from '../../resources/index.js';
+import { workItemStream } from '../../work/index.js';
+import { ActivityEventType } from '../contracts/events.js';
+import { ActivityExecutionKind, BuiltInActivityName } from '../contracts/vocabulary.js';
+import { pullRequestOutcomeSchema, pullRequestTargetSchema, resolvePrimaryCapability, selectedDenialAudit, selectionDenialAudit, } from './activity-support.js';
+import { claimAndCompleteDecision, completeDecisionClaim, readDecisionClaim, } from './decision-claim.js';
+import { approveDenied, deliveryIntentRequested } from './event-drafts.js';
+import { activityCommandContext, createJournalIntentAppender, } from './intent.js';
+import { decidePullRequestAuthority } from './policy.js';
+const inputSchema = z
+    .object({ target: pullRequestTargetSchema, body: z.string().optional() })
+    .strict()
+    .transform((input) => input.body === undefined
+    ? { target: input.target }
+    : { target: input.target, body: input.body });
+export function createPullRequestApproveActivity(journal, pullRequests, appender = createJournalIntentAppender(journal)) {
+    return {
+        name: BuiltInActivityName.PullRequestApprove,
+        inputSchema,
+        outcomeSchema: pullRequestOutcomeSchema,
+        outcomeKinds: [
+            ActivityOutcomeKind.Waiting,
+            ActivityOutcomeKind.Done,
+            ActivityOutcomeKind.Blocked,
+            ActivityOutcomeKind.Failed,
+        ],
+        resources: [],
+        executionKind: ActivityExecutionKind.Deterministic,
+        handler: {
+            execute: (invocation, context) => executeApproval(journal, pullRequests, appender, invocation, context),
+        },
+    };
+}
+async function executeApproval(journal, pullRequests, appender, invocation, context) {
+    const command = activityCommandContext(invocation.activationId, invocation.orchestrationGroupId, context.occurredAt);
+    const prior = await readDecisionClaim(journal, invocation.activationId, 'approve');
+    if (prior !== null)
+        return completeDecisionClaim(journal, appender, prior);
+    const authority = await pullRequests.authorityInput(invocation.workItemId);
+    const resource = resolvePrimaryCapability(invocation.resources, authority, invocation.workItemId, invocation.input.target, BuiltInResourceCapability.Approvable);
+    if (!resource.allowed) {
+        const denial = approveDenied(workItemStream(invocation.workItemId), resource.reason, command, {
+            ...selectionDenialAudit(invocation.input.target, resource.candidates),
+            body: invocation.input.body ?? null,
+        });
+        return claimAndCompleteDecision(journal, appender, invocation.activationId, 'approve', {
+            decisionKind: 'denied',
+            outcome: { kind: ActivityOutcomeKind.Blocked, data: { reason: resource.reason } },
+            fact: denial,
+        });
+    }
+    const decision = decidePullRequestAuthority(authority, {
+        target: { resourceId: resource.resourceId },
+        requireAcceptedReview: false,
+        requireChecks: false,
+    });
+    if (!decision.allowed) {
+        const denial = approveDenied(resourceStream(resource.resourceId), decision.reason, command, {
+            ...selectedDenialAudit(authority, resource.resourceId),
+            body: invocation.input.body ?? null,
+        });
+        return claimAndCompleteDecision(journal, appender, invocation.activationId, 'approve', {
+            decisionKind: 'denied',
+            outcome: { kind: ActivityOutcomeKind.Blocked, data: { reason: decision.reason } },
+            fact: denial,
+        });
+    }
+    const intent = deliveryIntentRequested(decision.resourceId, ActivityEventType.PrApproveRequested, {
+        activationId: invocation.activationId,
+        workflowInstanceId: invocation.workflowInstanceId,
+        resourceId: decision.resourceId,
+        revision: decision.revision,
+        body: invocation.input.body ?? null,
+    }, command);
+    return claimAndCompleteDecision(journal, appender, invocation.activationId, 'approve', {
+        decisionKind: 'requested',
+        outcome: {
+            kind: ActivityOutcomeKind.Waiting,
+            data: { intentEventId: intent.eventId, signalKind: 'delivery-result' },
+        },
+        fact: intent,
+    });
+}

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

@@ -0,0 +1,11 @@
+import { BuiltInResourceCapability } from '../../resources/index.js';
+// A resource is PR-shaped by what it can do, never by its registered kind —
+// a provider may model a mergeable resource under a different kind entirely.
+const PULL_REQUEST_CAPABILITIES = [
+    BuiltInResourceCapability.Mergeable,
+    BuiltInResourceCapability.Reviewable,
+    BuiltInResourceCapability.Approvable,
+];
+export function isPullRequestLikeResource(capabilities) {
+    return PULL_REQUEST_CAPABILITIES.some((capability) => capabilities.includes(capability));
+}