@atolis-hq/wake 0.1.11 → 0.1.12

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

@@ -1,6 +1,6 @@
 import { awaitingApprovalRunnerSentinel, failedRunnerSentinel } from '../domain/stages.js';
 import { resolveCustomCommand } from '../domain/custom-commands.js';
-import { builtInDefaultWorkflowDefinition, chooseAction as chooseWorkflowAction, } from '../domain/workflows.js';
+import { builtInDefaultWorkflowDefinition, chooseAction as chooseWorkflowAction, selectWorkflowForEvent, } from '../domain/workflows.js';
 function isAwaitingApproval(issue) {
     const context = issue.context;
     return context.lastRunSentinel === awaitingApprovalRunnerSentinel;
@@ -57,6 +57,10 @@ export function createPolicyEngine() {
             if (issue.issue.state !== 'open') {
                 return false;
             }
+            const context = issue.context;
+            if (config.workflowSelectors.length > 0) {
+                return typeof context.workflow === 'string';
+            }
             // 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
@@ -105,7 +109,7 @@ export function createPolicyEngine() {
         chooseAction(issue, workflow = builtInDefaultWorkflowDefinition) {
             return chooseWorkflowAction(issue, workflow)?.action ?? null;
         },
-        chooseRetryActionAfterHumanReply(issue) {
+        chooseRetryActionAfterHumanReply(issue, workflow = builtInDefaultWorkflowDefinition) {
             const context = issue.context;
             const failed = context.lastRunSentinel === failedRunnerSentinel;
             const blocked = context.lastRunSentinel === 'BLOCKED';
@@ -118,7 +122,16 @@ export function createPolicyEngine() {
             if (latestUnhandledHumanComment(issue) === undefined) {
                 return null;
             }
-            return typeof context.lastRunAction === 'string' ? context.lastRunAction : 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)) {
@@ -179,6 +192,9 @@ export function createPolicyEngine() {
                 return false;
             }
             const kind = resourceUri.split(':')[1];
+            if (config.workflowSelectors.length > 0) {
+                return selectWorkflowForEvent(unresolved, config) !== null;
+            }
             if (kind === 'issue') {
                 // Real github source stamps payload.ticket (sourceEventType
                 // 'ticket.upsert'); the fake ticketing harness stamps payload.issue

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

@@ -1,8 +1,9 @@
 import { CORRELATION_PRIMARY_CONFLICT_EVENT, CORRELATION_REGISTERED_EVENT, CORRELATION_RETRACTED_EVENT, UNRESOLVED_WORK_ITEM_KEY, parseIssueStateRecord, } from '../domain/schema.js';
 import { doneRunnerSentinel, stageFromLabels } from '../domain/stages.js';
-import { builtInDefaultWorkflowDefinition, defaultWorkflowName, workflowStageVocabulary, } from '../domain/workflows.js';
+import { builtInDefaultWorkflowDefinition, defaultWorkflowName, selectWorkflowForEvent, workflowStageVocabulary, } from '../domain/workflows.js';
 import { isCustomCommandAction } from '../domain/custom-commands.js';
 import { createEventEnvelope } from '../lib/event-log.js';
+const WORKFLOW_SELECTED_EVENT = 'wake.workflow.selected';
 function stringArrayFromPayload(value) {
     return Array.isArray(value)
         ? value.filter((entry) => typeof entry === 'string')
@@ -37,6 +38,33 @@ function createProjectionFromIssueEvent(event, config) {
         context: {},
     });
 }
+async function pinSelectedWorkflow(projection, event, ctx, config) {
+    const context = projection.context;
+    if (config === undefined || typeof context.workflow === 'string') {
+        return projection;
+    }
+    const workflow = selectWorkflowForEvent(event, config);
+    if (workflow === null) {
+        return projection;
+    }
+    const selectedEvent = await ctx.appendEvent(createEventEnvelope({
+        eventId: `workflow-selected-${projection.workItemKey}`,
+        workItemKey: projection.workItemKey,
+        streamScope: 'work-item',
+        direction: 'internal',
+        sourceSystem: 'wake',
+        sourceEventType: WORKFLOW_SELECTED_EVENT,
+        sourceRefs: event.sourceRefs,
+        occurredAt: event.occurredAt,
+        ingestedAt: event.ingestedAt,
+        trigger: 'context-only',
+        payload: {
+            workflow,
+            selectedFromEventId: event.eventId,
+        },
+    }));
+    return applyEvent(projection, selectedEvent, ctx, config);
+}
 async function applyEvent(current, event, ctx, config) {
     // The shared sentinel for events whose resource failed mint qualification
     // (tick-runner.ts's resolveInboundEvent, spec D1'). These are durable and
@@ -55,11 +83,11 @@ async function applyEvent(current, event, ctx, config) {
             return current;
         }
         if (current === null) {
-            return next;
+            return pinSelectedWorkflow(next, event, ctx, config);
         }
         const nextStageFromLabels = stageFromLabels(next.issue.labels, configuredStagesForLabels(config));
         const shouldReconcileStage = nextStageFromLabels !== undefined && nextStageFromLabels !== current.wake.stage;
-        return parseIssueStateRecord({
+        const updated = parseIssueStateRecord({
             ...current,
             origin: current.origin,
             issue: next.issue,
@@ -80,10 +108,29 @@ async function applyEvent(current, event, ctx, config) {
                 recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
             },
         });
+        return pinSelectedWorkflow(updated, event, ctx, config);
     }
     if (current === null) {
         return null;
     }
+    if (event.sourceEventType === WORKFLOW_SELECTED_EVENT) {
+        const workflow = event.payload.workflow;
+        if (typeof workflow !== 'string') {
+            return current;
+        }
+        return parseIssueStateRecord({
+            ...current,
+            context: {
+                ...current.context,
+                workflow,
+            },
+            wake: {
+                ...current.wake,
+                syncedAt: event.ingestedAt,
+                recentEventIds: [...current.wake.recentEventIds, event.eventId].slice(-10),
+            },
+        });
+    }
     if (event.sourceEventType === 'fake.issue.comment.created' ||
         event.sourceEventType === 'ticket.comment.created' ||
         event.sourceEventType === 'ticket.comment.updated' ||
@@ -156,31 +203,38 @@ async function applyEvent(current, event, ctx, config) {
             config !== undefined &&
             isCustomCommandAction(payload.action, config);
         const shouldClearSession = isForwardProgression || isFailed;
+        const nextContext = {
+            ...current.context,
+            lastFailureClass: payload.failureClass,
+            ...(payload.handledCommentId === undefined
+                ? {}
+                : { lastHandledCommentId: payload.handledCommentId }),
+            ...(payload.sentinel === undefined || isCompletedCustomCommand
+                ? {}
+                : { lastRunSentinel: payload.sentinel }),
+            ...(payload.action === undefined || isCompletedCustomCommand
+                ? {}
+                : { lastRunAction: payload.action }),
+            ...(payload.sentinel === doneRunnerSentinel &&
+                payload.action !== undefined &&
+                !isCompletedCustomCommand
+                ? { lastCompletedAction: payload.action }
+                : {}),
+            // Remembered so the approval path knows which action to resume or
+            // skip when a human posts /approved.
+            ...(payload.sentinel === 'AWAITING_APPROVAL' && payload.action !== undefined
+                ? { pendingApprovalAction: payload.action }
+                : {}),
+        };
+        if (payload.sentinel === 'BLOCKED' || payload.sentinel === 'FAILED') {
+            nextContext.blockedFromStage = current.wake.stage;
+        }
+        else if (payload.sentinel !== undefined) {
+            delete nextContext.blockedFromStage;
+        }
         return parseIssueStateRecord({
             ...current,
-            context: {
-                ...current.context,
-                lastFailureClass: payload.failureClass,
-                ...(payload.handledCommentId === undefined
-                    ? {}
-                    : { lastHandledCommentId: payload.handledCommentId }),
-                ...(payload.sentinel === undefined || isCompletedCustomCommand
-                    ? {}
-                    : { lastRunSentinel: payload.sentinel }),
-                ...(payload.action === undefined || isCompletedCustomCommand
-                    ? {}
-                    : { lastRunAction: payload.action }),
-                ...(payload.sentinel === doneRunnerSentinel &&
-                    payload.action !== undefined &&
-                    !isCompletedCustomCommand
-                    ? { lastCompletedAction: payload.action }
-                    : {}),
-                // Remembered so the approval path knows which action to resume or
-                // skip when a human posts /approved.
-                ...(payload.sentinel === 'AWAITING_APPROVAL' && payload.action !== undefined
-                    ? { pendingApprovalAction: payload.action }
-                    : {}),
-            },
+            context: nextContext,
             wake: {
                 ...current.wake,
                 stage: payload.nextStage ?? current.wake.stage,

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

@@ -222,7 +222,7 @@ export function createTickRunner(deps) {
         }
         const nextAction = policy.resolveCustomCommandRequest(projection, deps.config)?.action ??
             policy.chooseAction(projection, workflow) ??
-            policy.chooseRetryActionAfterHumanReply(projection);
+            policy.chooseRetryActionAfterHumanReply(projection, workflow);
         return nextAction !== null && policy.needsWakeAction(projection, workflow);
     }
     function createLabelsEvent(input) {
@@ -965,7 +965,7 @@ export function createTickRunner(deps) {
                 }
                 const nextAction = policy.resolveCustomCommandRequest(issue, deps.config)?.action ??
                     policy.chooseAction(issue, workflow) ??
-                    policy.chooseRetryActionAfterHumanReply(issue);
+                    policy.chooseRetryActionAfterHumanReply(issue, workflow);
                 return nextAction !== null && policy.needsWakeAction(issue, workflow);
             });
             if (candidate === undefined) {
@@ -1069,7 +1069,7 @@ export function createTickRunner(deps) {
                 // back to a full fresh `implement` run and lost the PR-feedback
                 // context).
                 const nextAction = policy.resolveCustomCommandRequest(candidate, deps.config)?.action ??
-                    policy.chooseRetryActionAfterHumanReply(candidate) ??
+                    policy.chooseRetryActionAfterHumanReply(candidate, workflow) ??
                     workflowAction?.action ??
                     null;
                 if (nextAction === null) {

package/dist/src/domain/schema.js

@@ -316,6 +316,26 @@ const workflowDefinitionSchema = z.object({
     entryStage: identifierSchema.optional(),
     stages: z.record(identifierSchema, workflowStageSchema),
 });
+const workflowSelectorMatchSchema = z
+    .object({
+    kind: z.string().min(1).optional(),
+    sourceEventType: z.string().min(1).optional(),
+    repo: z.string().min(1).optional(),
+    requiredLabels: z.array(z.string()).default([]),
+    ignoredLabels: z.array(z.string()).default([]),
+    requiredAssignees: z.array(z.string()).default([]),
+    requiredAuthors: z.array(z.string()).default([]),
+})
+    .default({
+    requiredLabels: [],
+    ignoredLabels: [],
+    requiredAssignees: [],
+    requiredAuthors: [],
+});
+const workflowSelectorSchema = z.object({
+    workflow: identifierSchema,
+    match: workflowSelectorMatchSchema,
+});
 function defaultPromptsRoot() {
     const sourceDir = dirname(fileURLToPath(import.meta.url));
     for (const candidate of [
@@ -515,6 +535,7 @@ export const wakeConfigSchema = z
             },
         },
     }),
+    workflowSelectors: z.array(workflowSelectorSchema).default([]),
     commands: z.record(identifierSchema, customCommandSchema).default({
         ask: {
             action: 'ask',
@@ -707,6 +728,15 @@ export const wakeConfigSchema = z
             });
         }
     }
+    for (const [index, selector] of config.workflowSelectors.entries()) {
+        if (config.workflows[selector.workflow] === undefined) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['workflowSelectors', index, 'workflow'],
+                message: `Workflow selector targets unknown workflow "${selector.workflow}".`,
+            });
+        }
+    }
     for (const [commandName, command] of commandEntries) {
         if (reservedCommandNames.includes(commandName.toLowerCase())) {
             ctx.addIssue({

package/dist/src/domain/workflows.js

@@ -37,6 +37,75 @@ export function workflowNameForProjection(projection, config) {
     const context = projection.context;
     return typeof context.workflow === 'string' ? context.workflow : defaultWorkflowName(config);
 }
+function stringArray(value) {
+    return Array.isArray(value)
+        ? value.filter((entry) => typeof entry === 'string')
+        : [];
+}
+function repoFromResourceUri(resourceUri) {
+    if (resourceUri === undefined) {
+        return undefined;
+    }
+    const [, , rest] = resourceUri.split(':', 3);
+    return rest?.split('#')[0];
+}
+export function workflowSelectorInputFromEvent(event) {
+    const resourceUri = event.sourceRefs.resourceUri ?? event.sourceRefs.parentResourceUri;
+    const kind = resourceUri?.split(':')[1];
+    const ticket = (event.payload.ticket ?? event.payload.issue);
+    const pr = event.payload.pr;
+    const repo = (typeof ticket?.repo === 'string' ? ticket.repo : undefined) ??
+        event.sourceRefs.repo ??
+        repoFromResourceUri(resourceUri);
+    return {
+        ...(kind === undefined ? {} : { kind }),
+        sourceEventType: event.sourceEventType,
+        ...(repo === undefined ? {} : { repo }),
+        labels: stringArray(ticket?.labels),
+        assignees: stringArray(ticket?.assignees),
+        ...(typeof pr?.author === 'string' ? { author: pr.author } : {}),
+    };
+}
+function labelsAndAssigneesMatch(input) {
+    const labels = new Set(input.labels);
+    const assignees = new Set(input.assignees);
+    if (input.requiredLabels.some((label) => !labels.has(label))) {
+        return false;
+    }
+    if (input.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 selectorMatches(selector, input) {
+    const match = selector.match;
+    if (match.kind !== undefined && match.kind !== input.kind) {
+        return false;
+    }
+    if (match.sourceEventType !== undefined && match.sourceEventType !== input.sourceEventType) {
+        return false;
+    }
+    if (match.repo !== undefined && match.repo !== input.repo) {
+        return false;
+    }
+    if (!labelsAndAssigneesMatch({ ...match, labels: input.labels, assignees: input.assignees })) {
+        return false;
+    }
+    if (match.requiredAuthors.length > 0 &&
+        (input.author === undefined || !match.requiredAuthors.includes(input.author))) {
+        return false;
+    }
+    return true;
+}
+export function selectWorkflowForEvent(event, config) {
+    const input = workflowSelectorInputFromEvent(event);
+    const selector = config.workflowSelectors.find((candidate) => selectorMatches(candidate, input));
+    return selector?.workflow ?? null;
+}
 export function configuredStageNames(workflow) {
     return Object.keys(workflow.stages);
 }

package/dist/src/version.js

@@ -1 +1 @@
-export const wakeVersion = "0.1.11+gbbbf616";
+export const wakeVersion = "0.1.12+g6a4753f";

package/package.json

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