@atolis-hq/wake 0.2.96 → 0.3.0

package/dist/src/core/live-execution.js

@@ -1,81 +0,0 @@
-import { currentProcessIdentity } from '../lib/process-identity.js';
-function createEventQueue() {
-    const queue = [];
-    const waiters = [];
-    let closed = false;
-    function emit(value) {
-        const waiter = waiters.shift();
-        if (waiter !== undefined) {
-            waiter(value);
-            return;
-        }
-        queue.push(value);
-    }
-    async function nextQueued() {
-        const value = queue.shift();
-        if (value !== undefined)
-            return value;
-        if (closed)
-            return { kind: 'done' };
-        return new Promise((resolve) => waiters.push(resolve));
-    }
-    return {
-        push(event) {
-            if (!closed)
-                emit({ kind: 'event', event });
-        },
-        close() {
-            if (closed)
-                return;
-            closed = true;
-            emit({ kind: 'done' });
-        },
-        fail(error) {
-            if (closed)
-                return;
-            closed = true;
-            emit({ kind: 'error', error });
-        },
-        iterable: {
-            async *[Symbol.asyncIterator]() {
-                while (true) {
-                    const value = await nextQueued();
-                    if (value.kind === 'done')
-                        return;
-                    if (value.kind === 'error')
-                        throw value.error;
-                    yield value.event;
-                }
-            },
-        },
-    };
-}
-export function createAgentExecution(input, execute) {
-    const controller = new AbortController();
-    const events = createEventQueue();
-    const result = Promise.resolve()
-        .then(() => execute({
-        ...input,
-        cancellationSignal: controller.signal,
-        onRuntimeEvent: async (event) => {
-            await input.onRuntimeEvent?.(event);
-            events.push(event);
-        },
-    }))
-        .then((value) => {
-        events.close();
-        return value;
-    }, (error) => {
-        events.fail(error);
-        throw error;
-    });
-    return {
-        runId: input.runId,
-        processIdentity: currentProcessIdentity(),
-        events: events.iterable,
-        async cancel(reason) {
-            controller.abort(reason);
-        },
-        result,
-    };
-}

package/dist/src/core/outbox.js

@@ -1,198 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { LABELS_REQUESTED_EVENT, PUBLISH_CONFIRMED_EVENT, PUBLISH_FAILED_EVENT, PUBLISH_INTENT_REQUESTED_EVENT, PUBLISH_SENT_UNCONFIRMED_EVENT, } from '../domain/event-types.js';
-import { createEventEnvelope } from '../lib/event-log.js';
-const outboxMaxAttempts = 3;
-const outboundIntentEventTypes = new Set([PUBLISH_INTENT_REQUESTED_EVENT, LABELS_REQUESTED_EVENT]);
-const outboundConfirmationEventTypes = new Set([
-    'ticket.reply.published',
-    'ticket.labels.updated',
-    PUBLISH_CONFIRMED_EVENT,
-    'pr.comment.reply.published',
-    'pr.review-comment.reply.published',
-]);
-function intentId(event) {
-    const intentEventId = event.payload.intentEventId;
-    return typeof intentEventId === 'string' ? intentEventId : undefined;
-}
-// The outbox: outbound delivery (comments, labels) attempted independently of
-// run-outcome recording, with a durable, bounded retry trace. Extracted from
-// tick-runner.ts so it can be exercised in isolation; it has the cleanest
-// boundary of the tick's collaborators — no dependency on candidate selection.
-export function createOutbox(deps) {
-    async function recordDeliveryFailure(intentEvent, err) {
-        const occurredAt = deps.clock.now().toISOString();
-        const failureEvent = createEventEnvelope({
-            eventId: `${intentEvent.eventId}-delivery-failed-${randomUUID()}`,
-            workItemKey: intentEvent.workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: PUBLISH_FAILED_EVENT,
-            sourceRefs: intentEvent.sourceRefs,
-            occurredAt,
-            ingestedAt: occurredAt,
-            trigger: 'context-only',
-            payload: {
-                intentEventId: intentEvent.eventId,
-                intentEventType: intentEvent.sourceEventType,
-                idempotencyKey: intentEvent.payload.idempotencyKey,
-                deliveryState: 'PENDING',
-                error: err instanceof Error ? err.message : String(err),
-            },
-        });
-        await deps.stateStore.appendEventEnvelope(failureEvent);
-        await deps.projectionUpdater.rebuildFromEvents([failureEvent]);
-    }
-    async function recordSentUnconfirmed(intentEvent) {
-        const occurredAt = deps.clock.now().toISOString();
-        const sentEvent = createEventEnvelope({
-            eventId: `${intentEvent.eventId}-sent-unconfirmed-${randomUUID()}`,
-            workItemKey: intentEvent.workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: PUBLISH_SENT_UNCONFIRMED_EVENT,
-            sourceRefs: intentEvent.sourceRefs,
-            occurredAt,
-            ingestedAt: occurredAt,
-            trigger: 'context-only',
-            payload: {
-                intentEventId: intentEvent.eventId,
-                intentEventType: intentEvent.sourceEventType,
-                idempotencyKey: intentEvent.payload.idempotencyKey,
-                deliveryState: 'SENT_UNCONFIRMED',
-            },
-        });
-        await deps.stateStore.appendEventEnvelope(sentEvent);
-        await deps.projectionUpdater.rebuildFromEvents([sentEvent]);
-    }
-    async function recordConfirmed(intentEvent, payload = {}) {
-        const confirmedAt = deps.clock.now().toISOString();
-        const confirmedEvent = createEventEnvelope({
-            eventId: `${intentEvent.eventId}-confirmed`,
-            workItemKey: intentEvent.workItemKey,
-            streamScope: 'work-item',
-            direction: 'internal',
-            sourceSystem: 'wake',
-            sourceEventType: PUBLISH_CONFIRMED_EVENT,
-            sourceRefs: intentEvent.sourceRefs,
-            occurredAt: confirmedAt,
-            ingestedAt: confirmedAt,
-            trigger: 'context-only',
-            payload: {
-                intentEventId: intentEvent.eventId,
-                idempotencyKey: intentEvent.payload.idempotencyKey,
-                deliveryState: 'CONFIRMED',
-                ...payload,
-            },
-        });
-        const appended = await deps.stateStore.appendEventEnvelope(confirmedEvent);
-        await deps.projectionUpdater.rebuildFromEvents([appended]);
-    }
-    // Outbound delivery (comments, labels) is attempted independently of run-outcome
-    // recording: a delivery failure must never rewrite an already-recorded run result
-    // (S1), and must always leave a durable, retryable trace instead of being lost
-    // (E5). This never throws — failures become a `wake.publish.failed` event.
-    async function attemptDelivery(event) {
-        if (deps.outboundSink === undefined) {
-            return;
-        }
-        try {
-            await recordSentUnconfirmed(event);
-            const deliveryEvents = await deps.outboundSink.deliverIntent({ event });
-            for (const deliveryEvent of deliveryEvents) {
-                await deps.stateStore.appendEventEnvelope(deliveryEvent);
-            }
-            await deps.projectionUpdater.rebuildFromEvents(deliveryEvents);
-            if (deliveryEvents.length === 0) {
-                // No confirmation event was produced (e.g. a no-op label update) but the
-                // sink did not throw. Record that delivery was attempted successfully so
-                // the outbox scan below does not retry it indefinitely.
-                await recordConfirmed(event);
-            }
-        }
-        catch (err) {
-            await recordDeliveryFailure(event, err);
-        }
-    }
-    async function deliverOutboundEvent(event) {
-        await deps.stateStore.appendEventEnvelope(event);
-        await deps.projectionUpdater.rebuildFromEvents([event]);
-        await attemptDelivery(event);
-    }
-    async function suppressOutboundEvent(event, input) {
-        const suppressedEvent = await deps.stateStore.appendEventEnvelope({
-            ...event,
-            payload: {
-                ...event.payload,
-                deliveryState: 'CONFIRMED',
-                suppressedPublishReason: input.suppressedPublishReason,
-            },
-        });
-        await deps.projectionUpdater.rebuildFromEvents([suppressedEvent]);
-        await recordConfirmed(event, { suppressedPublishReason: input.suppressedPublishReason });
-    }
-    // Adopts the outbox pattern: an intent is only considered delivered once a
-    // matching confirmation event exists. Anything left unconfirmed by a prior tick
-    // (e.g. the process crashed mid-delivery) is retried here, bounded so a
-    // permanently failing sink dead-letters instead of retrying forever.
-    async function retryUnconfirmedDeliveries() {
-        if (deps.outboundSink === undefined) {
-            return;
-        }
-        const events = await deps.stateStore.listEventEnvelopes();
-        const confirmedIntentIds = new Set();
-        const failureAttempts = new Map();
-        const uncertainIntentIds = new Set();
-        for (const event of events) {
-            const intentEventId = intentId(event);
-            if (intentEventId === undefined) {
-                continue;
-            }
-            if (outboundConfirmationEventTypes.has(event.sourceEventType)) {
-                confirmedIntentIds.add(intentEventId);
-            }
-            if (event.sourceEventType === PUBLISH_FAILED_EVENT) {
-                failureAttempts.set(intentEventId, (failureAttempts.get(intentEventId) ?? 0) + 1);
-            }
-            if (event.sourceEventType === PUBLISH_SENT_UNCONFIRMED_EVENT) {
-                uncertainIntentIds.add(intentEventId);
-            }
-        }
-        for (const intent of events) {
-            if (!outboundIntentEventTypes.has(intent.sourceEventType)) {
-                continue;
-            }
-            if (confirmedIntentIds.has(intent.eventId)) {
-                continue;
-            }
-            if ((failureAttempts.get(intent.eventId) ?? 0) >= outboxMaxAttempts) {
-                continue;
-            }
-            if (uncertainIntentIds.has(intent.eventId) &&
-                deps.outboundSink.reconcileIntent !== undefined) {
-                try {
-                    const reconciledEvents = await deps.outboundSink.reconcileIntent({ event: intent });
-                    for (const reconciledEvent of reconciledEvents) {
-                        await deps.stateStore.appendEventEnvelope(reconciledEvent);
-                    }
-                    await deps.projectionUpdater.rebuildFromEvents(reconciledEvents);
-                    if (reconciledEvents.length > 0) {
-                        continue;
-                    }
-                }
-                catch (err) {
-                    await recordDeliveryFailure(intent, err);
-                    continue;
-                }
-            }
-            await attemptDelivery(intent);
-        }
-    }
-    return {
-        attemptDelivery,
-        deliverOutboundEvent,
-        retryUnconfirmedDeliveries,
-        suppressOutboundEvent,
-    };
-}

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

@@ -1,389 +0,0 @@
-import { failedRunnerSentinel } from '../domain/stages.js';
-import { resolveCustomCommand } from '../domain/custom-commands.js';
-import { builtInDefaultWorkflowDefinition, chooseAction as chooseWorkflowAction, isKnownWorkflowStage, selectWorkflowForEvent, workflowForProjection, } from '../domain/workflows.js';
-import { alwaysManualIgnoredLabels } from '../domain/manual-labels.js';
-import { autoApprovalLabel } from './approval-intents.js';
-function isAwaitingApproval(issue) {
-    const context = issue.context;
-    // pendingApprovalAction persists through a changes-requested review round
-    // within the same gated cycle (that fold path never touches it), so it's
-    // the faithful "is this item currently gated on human sign-off" signal —
-    // context.status alone flips between 'awaiting-approval' and
-    // 'changes-requested' within the same gated cycle and can't be used here.
-    // The lastRunSentinel fallback tolerates a projection folded before
-    // pendingApprovalAction was reliably set on every gated DONE.
-    return (typeof context.pendingApprovalAction === 'string' ||
-        context.lastRunSentinel === 'AWAITING_APPROVAL');
-}
-function belowFailureRetryLimit(issue, config) {
-    if (config === undefined) {
-        return true;
-    }
-    const context = issue.context;
-    const failureCount = typeof context.failureCount === 'number' && Number.isInteger(context.failureCount)
-        ? context.failureCount
-        : 0;
-    return failureCount < config.retry.maxFailureRetries;
-}
-// Commands are matched as a token at the start of a (trimmed) line, not as a
-// substring anywhere in the body — so "I have *not* /approved this yet" or a
-// quoted reply containing /approved does not approve the gate.
-const approvedCommandPattern = /^\/approved\b/i;
-const changesCommandPattern = /^\/changes\b/i;
-const prReviewApprovalMarker = '<!-- wake:pr-review-approved -->';
-const prReviewChangesMarker = '<!-- wake:pr-review-changes-requested -->';
-// The action Wake runs when a correlated PR gets new reviewer feedback while
-// the work item is awaiting approval. Not configurable per workflow: it's a
-// lateral response to a PR surface, not a workflow stage.
-const reviewFeedbackAction = 'revise';
-function matchesCommand(body, pattern) {
-    return body.split(/\r?\n/).some((line) => pattern.test(line.trim()));
-}
-function labelsAndAssigneesQualify(input) {
-    if (input.requiredLabels.length === 0 && input.requiredAssignees.length === 0) {
-        return false;
-    }
-    const labels = new Set(input.labels);
-    const assignees = new Set(input.assignees);
-    if (input.requiredLabels.some((label) => !labels.has(label))) {
-        return false;
-    }
-    const ignoredLabels = new Set([...input.ignoredLabels, ...alwaysManualIgnoredLabels]);
-    if ([...ignoredLabels].some((label) => labels.has(label))) {
-        return false;
-    }
-    if (input.requiredAssignees.length > 0 &&
-        !input.requiredAssignees.some((login) => assignees.has(login))) {
-        return false;
-    }
-    return true;
-}
-function latestUnhandledHumanComment(issue) {
-    const context = issue.context;
-    const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
-    // Only consider human comments that appear after the last bot comment.
-    // A human /approved posted before Wake's approval-request comment must not
-    // be re-consumed as approval for a later awaiting-approval cycle.
-    const lastBotIndex = issue.comments.reduce((acc, c, i) => (c.isBotAuthored ? i : acc), -1);
-    const humanCommentsAfterBot = issue.comments
-        .slice(lastBotIndex + 1)
-        .filter((c) => !c.isBotAuthored);
-    const latestHumanComment = humanCommentsAfterBot.at(-1);
-    if (latestHumanComment === undefined || latestHumanComment.id === handledCommentId) {
-        return undefined;
-    }
-    return latestHumanComment;
-}
-function latestUnhandledComment(issue) {
-    const context = issue.context;
-    const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
-    const lastBotIndex = issue.comments.reduce((acc, c, i) => (c.isBotAuthored ? i : acc), -1);
-    const latest = issue.comments.slice(lastBotIndex).at(-1);
-    if (latest === undefined || latest.id === handledCommentId) {
-        return undefined;
-    }
-    return latest;
-}
-export function createPolicyEngine() {
-    return {
-        isEligible(issue, config) {
-            if (issue.issue.state !== 'open') {
-                return false;
-            }
-            if (issue.issue.labels.some((label) => alwaysManualIgnoredLabels.includes(label))) {
-                return false;
-            }
-            // Defense-in-depth: the issues source filters PR-shaped items at poll
-            // time, so no NEW projection can ever have isPullRequest: true. But a
-            // pre-existing state/<workId>.json written by a pre-this-branch
-            // version of Wake could still hold isPullRequest: true, since the old
-            // fold created projections regardless of eligibility.
-            if (issue.issue.isPullRequest) {
-                return false;
-            }
-            // Source policy is always checked first — workflow selectors are optional secondary filter.
-            if (!labelsAndAssigneesQualify({
-                labels: issue.issue.labels,
-                assignees: issue.issue.assignees,
-                requiredLabels: config.sources.github.policy.requiredLabels,
-                ignoredLabels: config.sources.github.policy.ignoredLabels,
-                requiredAssignees: config.sources.github.policy.requiredAssignees,
-            })) {
-                return false;
-            }
-            // If workflow selectors are configured as the routing mechanism, the issue must have
-            // a workflow assigned (set by a matching selector when the issue was first minted).
-            if (config.workflowSelectors.length > 0) {
-                const context = issue.context;
-                return typeof context.workflow === 'string';
-            }
-            return true;
-        },
-        needsWakeAction(issue, workflow = builtInDefaultWorkflowDefinition, config) {
-            const context = issue.context;
-            const handledCommentId = typeof context.lastHandledCommentId === 'string' ? context.lastHandledCommentId : undefined;
-            const lastCompletedAction = typeof context.lastCompletedAction === 'string' ? context.lastCompletedAction : undefined;
-            const lastRunSentinel = typeof context.lastRunSentinel === 'string' ? context.lastRunSentinel : undefined;
-            const lastRetrySafety = typeof context.lastRetrySafety === 'string' ? context.lastRetrySafety : undefined;
-            if (issue.wake.lastRunId === undefined) {
-                return true;
-            }
-            if (issue.latestComment !== undefined &&
-                !issue.latestComment.isBotAuthored &&
-                issue.latestComment.id !== handledCommentId) {
-                if (lastRunSentinel === failedRunnerSentinel) {
-                    return belowFailureRetryLimit(issue, config);
-                }
-                return true;
-            }
-            if (isAwaitingApproval(issue)) {
-                return false;
-            }
-            if (lastRunSentinel === failedRunnerSentinel) {
-                if (lastRetrySafety === 'SAFE_TO_RETRY' || lastRetrySafety === 'SAFE_TO_RESUME') {
-                    return belowFailureRetryLimit(issue, config);
-                }
-                return false;
-            }
-            if (lastRunSentinel === 'REJECTED') {
-                return false;
-            }
-            if (lastRunSentinel === 'BLOCKED') {
-                return false;
-            }
-            const workflowAction = chooseWorkflowAction(issue, workflow);
-            return workflowAction !== null && lastCompletedAction !== workflowAction.action;
-        },
-        chooseAction(issue, workflow = builtInDefaultWorkflowDefinition) {
-            return chooseWorkflowAction(issue, workflow)?.action ?? null;
-        },
-        chooseRetryActionAfterHumanReply(issue, workflow = builtInDefaultWorkflowDefinition) {
-            const context = issue.context;
-            const failed = context.lastRunSentinel === failedRunnerSentinel;
-            const blocked = context.lastRunSentinel === 'BLOCKED';
-            if (failed && context.lastFailureClass === 'quota') {
-                return typeof context.lastRunAction === 'string' ? context.lastRunAction : null;
-            }
-            if (!blocked && !failed) {
-                return null;
-            }
-            if (latestUnhandledHumanComment(issue) === undefined) {
-                return null;
-            }
-            if (typeof context.blockedFromStage !== 'string') {
-                return null;
-            }
-            return (chooseWorkflowAction({
-                ...issue,
-                wake: {
-                    ...issue.wake,
-                    stage: context.blockedFromStage,
-                },
-            }, workflow)?.action ?? null);
-        },
-        resolveApprovalTransition(issue) {
-            if (!isAwaitingApproval(issue)) {
-                return null;
-            }
-            const context = issue.context;
-            const pendingAction = typeof context.pendingApprovalAction === 'string'
-                ? context.pendingApprovalAction
-                : undefined;
-            // No new human comment since the last handled one; stay idle instead of
-            // falling through to the LLM while awaiting explicit approval feedback.
-            const latestHumanComment = latestUnhandledHumanComment(issue);
-            const latestComment = latestUnhandledComment(issue);
-            if (pendingAction === undefined) {
-                return null;
-            }
-            if (context.pendingApprovalAllowAutoApproval === true &&
-                issue.issue.labels.includes(autoApprovalLabel)) {
-                return {
-                    approved: true,
-                    pendingAction,
-                    automatic: true,
-                    reason: 'Issue has wake:auto and the pending action prompt declared allowAutoApproval: true.',
-                };
-            }
-            if (latestComment?.isBotAuthored === true &&
-                latestComment.resourceUri !== undefined &&
-                latestComment.body.includes(prReviewApprovalMarker)) {
-                return {
-                    approved: true,
-                    pendingAction,
-                    targetResourceUri: latestComment.resourceUri,
-                    triggeringCommentId: latestComment.id,
-                    triggeringCommentBody: latestComment.body,
-                };
-            }
-            if (latestHumanComment === undefined) {
-                return null;
-            }
-            const approved = matchesCommand(latestHumanComment.body, approvedCommandPattern);
-            const changesRequested = matchesCommand(latestHumanComment.body, changesCommandPattern);
-            // Neither an explicit /approved nor /changes: treat this as
-            // conversation, not a decision. Stay idle rather than re-running the
-            // pending action off the back of an unmarked clarifying question (S2).
-            // The comment stays unhandled, so it's reconsidered on the next tick and
-            // by a human who follows up with an explicit command.
-            if (!approved && !changesRequested) {
-                return null;
-            }
-            return {
-                approved,
-                pendingAction,
-                ...(changesRequested
-                    ? {
-                        changesRequested: true,
-                        triggeringCommentId: latestHumanComment.id,
-                        triggeringCommentBody: latestHumanComment.body,
-                    }
-                    : {}),
-            };
-        },
-        // Callers must try resolveApprovalTransition first and only fall back to
-        // this when it returns null. resolveApprovalTransition doesn't check
-        // resourceUri, so a PR-surface comment that happens to carry an explicit
-        // /approved or /changes command is deliberately still routed
-        // there — this function only ever sees comments resolveApprovalTransition
-        // already passed on (plain PR feedback with no command).
-        resolvePendingReviewFeedback(issue) {
-            if (!isAwaitingApproval(issue)) {
-                return null;
-            }
-            const latestHumanComment = latestUnhandledHumanComment(issue);
-            const latestComment = latestUnhandledComment(issue);
-            if (latestComment?.isBotAuthored === true &&
-                latestComment.resourceUri !== undefined &&
-                latestComment.body.includes(prReviewChangesMarker)) {
-                return reviewFeedbackAction;
-            }
-            // resourceUri is set only on comments folded from a correlated PR/review
-            // surface (schema.ts's commentSnapshotSchema: "absent = the originating
-            // issue thread"). A comment on that surface is itself the deliberate
-            // act — unlike an issue-thread reply, it doesn't need an explicit
-            // /approved-style command to count as a decision.
-            if (latestHumanComment === undefined || latestHumanComment.resourceUri === undefined) {
-                return null;
-            }
-            return reviewFeedbackAction;
-        },
-        // A rejecting review watcher (or an already-folded /changes reply) sets
-        // context.status = 'changes-requested' with no fresh comment required —
-        // this is the gap #472 described: nothing distinguished a plan-review
-        // rejection from "never reviewed yet." Bounding (escalating to 'blocked'
-        // once config.retry.maxChangesRequestedRetries is exceeded) already
-        // happened at fold time, so this only has to check the current status.
-        resolveChangesRequestedAction(issue) {
-            if (!isAwaitingApproval(issue) || issue.context.status !== 'changes-requested') {
-                return null;
-            }
-            return typeof issue.context.pendingApprovalAction === 'string'
-                ? issue.context.pendingApprovalAction
-                : null;
-        },
-        resolveCustomCommandRequest(issue, config) {
-            return resolveCustomCommand(issue, config);
-        },
-        // The single eligibility predicate: is this issue open, on a known workflow
-        // stage, and does it have a next action Wake should run? Returns the
-        // resolved action plus the workflow it belongs to, or null when there is
-        // nothing to do. This used to be duplicated as two independently-drifting
-        // copies (the pending-label marker and the runner's candidate `find`), which
-        // is exactly the class of "a rule change didn't propagate everywhere" that
-        // caused the #258 incident — keep it as the one source of truth.
-        resolveNextEligibleAction(issue, config) {
-            if (!this.isEligible(issue, config)) {
-                return null;
-            }
-            const workflow = workflowForProjection(issue, config);
-            if (workflow === null || !isKnownWorkflowStage(issue.wake.stage, workflow)) {
-                return null;
-            }
-            if (isAwaitingApproval(issue)) {
-                const customCommand = resolveCustomCommand(issue, config);
-                if (customCommand !== null) {
-                    return { action: customCommand.action, workflow };
-                }
-                const approval = this.resolveApprovalTransition(issue);
-                if (approval !== null) {
-                    return { action: approval.pendingAction, workflow };
-                }
-                const changesRequestedAction = this.resolveChangesRequestedAction(issue);
-                if (changesRequestedAction !== null) {
-                    return { action: changesRequestedAction, workflow };
-                }
-                const reviewAction = this.resolvePendingReviewFeedback(issue);
-                if (reviewAction !== null) {
-                    return { action: reviewAction, workflow };
-                }
-                return null;
-            }
-            const nextAction = resolveCustomCommand(issue, config)?.action ??
-                this.chooseAction(issue, workflow) ??
-                this.chooseRetryActionAfterHumanReply(issue, workflow);
-            if (nextAction === null || !this.needsWakeAction(issue, workflow, config)) {
-                return null;
-            }
-            return { action: nextAction, workflow };
-        },
-        qualifiesForMint(unresolved, config) {
-            const resourceUri = unresolved.sourceRefs.resourceUri;
-            if (resourceUri === undefined) {
-                return false;
-            }
-            const kind = resourceUri.split(':')[1];
-            if (kind === 'schedule') {
-                const workflow = unresolved.payload.workflow;
-                return typeof workflow === 'string' && config.workflows[workflow] !== undefined;
-            }
-            // Source policy enforcement is always checked first — workflow selectors are optional secondary routing.
-            if (kind === 'issue') {
-                // Real github source stamps payload.ticket (sourceEventType
-                // 'ticket.upsert'); the fake ticketing harness stamps payload.issue
-                // (sourceEventType 'fake.issue.upsert') — the same dual-key
-                // recognition projection-updater.ts's createProjectionFromIssueEvent
-                // already applies when folding these into a projection. Qualification
-                // must accept both or the fake never qualifies anything, which would
-                // silently defeat every fixture that exercises minting through it.
-                const ticket = (unresolved.payload.ticket ?? unresolved.payload.issue);
-                if (ticket === undefined) {
-                    return false;
-                }
-                if (!labelsAndAssigneesQualify({
-                    labels: Array.isArray(ticket.labels) ? ticket.labels : [],
-                    assignees: Array.isArray(ticket.assignees) ? ticket.assignees : [],
-                    requiredLabels: config.sources.github.policy.requiredLabels,
-                    ignoredLabels: config.sources.github.policy.ignoredLabels,
-                    requiredAssignees: config.sources.github.policy.requiredAssignees,
-                })) {
-                    return false;
-                }
-                // Issue passed source policy; if workflow selectors are configured, also check routing.
-                if (config.workflowSelectors.length > 0) {
-                    return selectWorkflowForEvent(unresolved, config) !== null;
-                }
-                return true;
-            }
-            if (kind === 'pr') {
-                if (!config.sources.github.pullRequests.enabled) {
-                    return false;
-                }
-                const pr = unresolved.payload.pr;
-                const requiredAuthors = config.sources.github.pullRequests.policy.requiredAuthors;
-                // If requiredAuthors is empty, source policy allows any author.
-                if (requiredAuthors.length > 0) {
-                    if (typeof pr?.author !== 'string' || !requiredAuthors.includes(pr.author)) {
-                        return false;
-                    }
-                }
-                // PR passed source policy; if workflow selectors are configured, also check routing.
-                if (config.workflowSelectors.length > 0) {
-                    return selectWorkflowForEvent(unresolved, config) !== null;
-                }
-                return true;
-            }
-            return false;
-        },
-    };
-}