patchrelay 0.7.9 → 0.8.0

package/dist/stage-lifecycle-publisher.js

@@ -1,6 +1,6 @@
-import { buildAwaitingHandoffSessionPlan, buildCompletedSessionPlan, buildRunningSessionPlan, } from "./agent-session-plan.js";
+import { buildAwaitingHandoffSessionPlan, buildCompletedSessionPlan, buildPreparingSessionPlan, buildRunningSessionPlan, } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
-import { buildAwaitingHandoffComment, buildRunningStatusComment, resolveActiveLinearState, resolveWorkflowLabelCleanup, resolveWorkflowLabelNames, } from "./linear-workflow.js";
+import { buildAwaitingHandoffComment, buildHumanNeededComment, buildRunningStatusComment, resolveActiveLinearState, resolveWorkflowLabelCleanup, resolveWorkflowLabelNames, } from "./linear-workflow.js";
 import { sanitizeDiagnosticText } from "./utils.js";
 export class StageLifecyclePublisher {
     config;
@@ -16,7 +16,7 @@ export class StageLifecyclePublisher {
         this.feed = feed;
     }
     async markStageActive(project, issue, stageRun) {
-        const activeState = resolveActiveLinearState(project, stageRun.stage);
+        const activeState = resolveActiveLinearState(project, stageRun.stage, issue.selectedWorkflowId);
         const linear = await this.linearProvider.forProject(stageRun.projectId);
         if (!activeState || !linear) {
             return;
@@ -84,7 +84,7 @@ export class StageLifecyclePublisher {
             await linear.createAgentActivity({
                 agentSessionId: issue.activeAgentSessionId,
                 content: {
-                    type: "thought",
+                    type: "response",
                     body: `PatchRelay started the ${stage} workflow and is working in the background.`,
                 },
             });
@@ -103,24 +103,30 @@ export class StageLifecyclePublisher {
     async publishStageCompletion(stageRun, enqueueIssue) {
         const refreshedIssue = this.stores.issueWorkflows.getTrackedIssue(stageRun.projectId, stageRun.linearIssueId);
         if (refreshedIssue?.desiredStage) {
+            const linear = await this.linearProvider.forProject(stageRun.projectId);
+            if (refreshedIssue.activeAgentSessionId && linear) {
+                await this.updateAgentSession(linear, refreshedIssue, buildPreparingSessionPlan(refreshedIssue.desiredStage), refreshedIssue.desiredStage);
+            }
             this.feed?.publish({
                 level: "info",
                 kind: "stage",
                 issueKey: refreshedIssue.issueKey,
                 projectId: refreshedIssue.projectId,
                 stage: stageRun.stage,
+                ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
+                nextStage: refreshedIssue.desiredStage,
                 status: "queued",
                 summary: `Completed ${stageRun.stage} workflow and queued ${refreshedIssue.desiredStage}`,
             });
             await this.publishAgentCompletion(refreshedIssue, {
                 type: "thought",
-                body: `The ${stageRun.stage} workflow finished. PatchRelay is preparing the next requested workflow.`,
+                body: `The ${stageRun.stage} workflow finished. PatchRelay is preparing the ${refreshedIssue.desiredStage} workflow next.`,
             });
             enqueueIssue(stageRun.projectId, stageRun.linearIssueId);
             return;
         }
         const project = this.config.projects.find((candidate) => candidate.id === stageRun.projectId);
-        const activeState = project ? resolveActiveLinearState(project, stageRun.stage) : undefined;
+        const activeState = project ? resolveActiveLinearState(project, stageRun.stage, refreshedIssue?.selectedWorkflowId) : undefined;
         const linear = project ? await this.linearProvider.forProject(stageRun.projectId) : undefined;
         if (refreshedIssue && linear && project && activeState) {
             try {
@@ -146,6 +152,7 @@ export class StageLifecyclePublisher {
                         issueKey: refreshedIssue.issueKey,
                         projectId: refreshedIssue.projectId,
                         stage: stageRun.stage,
+                        ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
                         status: "handoff",
                         summary: `Completed ${stageRun.stage} workflow`,
                         detail: `Waiting for a Linear state change or follow-up input while the issue remains in ${activeState}.`,
@@ -155,7 +162,7 @@ export class StageLifecyclePublisher {
                             type: "elicitation",
                             body: `PatchRelay finished the ${stageRun.stage} workflow. Move the issue to its next workflow state or leave a follow-up prompt to continue.`,
                         })) || deliveredToSession;
-                    if (!deliveredToSession) {
+                    if (!deliveredToSession && !refreshedIssue.activeAgentSessionId) {
                         const result = await linear.upsertIssueComment({
                             issueId: stageRun.linearIssueId,
                             ...(refreshedIssue.statusCommentId ? { commentId: refreshedIssue.statusCommentId } : {}),
@@ -188,8 +195,11 @@ export class StageLifecyclePublisher {
             }
         }
         if (refreshedIssue) {
+            let deliveredToSession = false;
             if (refreshedIssue.activeAgentSessionId && linear) {
-                await this.updateAgentSession(linear, refreshedIssue, buildCompletedSessionPlan(stageRun.stage));
+                deliveredToSession = await this.updateAgentSession(linear, refreshedIssue, refreshedIssue.lifecycleStatus === "paused"
+                    ? buildAwaitingHandoffSessionPlan(stageRun.stage)
+                    : buildCompletedSessionPlan(stageRun.stage));
             }
             this.feed?.publish({
                 level: "info",
@@ -197,13 +207,28 @@ export class StageLifecyclePublisher {
                 issueKey: refreshedIssue.issueKey,
                 projectId: refreshedIssue.projectId,
                 stage: stageRun.stage,
+                ...(refreshedIssue.selectedWorkflowId ? { workflowId: refreshedIssue.selectedWorkflowId } : {}),
                 status: "completed",
                 summary: `Completed ${stageRun.stage} workflow`,
             });
-            await this.publishAgentCompletion(refreshedIssue, {
-                type: "response",
-                body: `PatchRelay finished the ${stageRun.stage} workflow.`,
-            });
+            deliveredToSession =
+                (await this.publishAgentCompletion(refreshedIssue, {
+                    type: refreshedIssue.lifecycleStatus === "paused" ? "elicitation" : "response",
+                    body: refreshedIssue.lifecycleStatus === "paused"
+                        ? `PatchRelay finished the ${stageRun.stage} workflow and now needs human input before it can continue.`
+                        : `PatchRelay finished the ${stageRun.stage} workflow.`,
+                })) || deliveredToSession;
+            if (refreshedIssue.lifecycleStatus === "paused" && linear && !deliveredToSession) {
+                const result = await linear.upsertIssueComment({
+                    issueId: stageRun.linearIssueId,
+                    ...(refreshedIssue.statusCommentId ? { commentId: refreshedIssue.statusCommentId } : {}),
+                    body: buildHumanNeededComment({
+                        issue: refreshedIssue,
+                        stageRun: this.stores.issueWorkflows.getStageRun(stageRun.id) ?? stageRun,
+                    }),
+                });
+                this.stores.workflowCoordinator.setIssueStatusComment(stageRun.projectId, stageRun.linearIssueId, result.id);
+            }
         }
     }
     async updateAgentSession(linear, issue, plan, stage) {

package/dist/webhook-agent-session-handler.js

@@ -35,7 +35,15 @@ export class AgentSessionWebhookHandler {
         const issueControl = normalized.issue ? this.stores.issueControl.getIssueControl(project.id, normalized.issue.id) : undefined;
         const activeRunLease = issueControl?.activeRunLeaseId !== undefined ? this.stores.runLeases.getRunLease(issueControl.activeRunLeaseId) : undefined;
         const activeStage = activeRunLease?.stage;
-        const runnableWorkflow = normalized.issue?.stateName ? resolveWorkflowStage(project, normalized.issue.stateName) : undefined;
+        const runnableWorkflow = normalized.issue?.stateName
+            ? resolveWorkflowStage(project, normalized.issue.stateName, {
+                ...(issue?.selectedWorkflowId
+                    ? { workflowDefinitionId: issue.selectedWorkflowId }
+                    : normalized.issue
+                        ? { issue: normalized.issue }
+                        : {}),
+            })
+            : undefined;
         if (normalized.triggerEvent === "agentSessionCreated") {
             if (!delegatedToPatchRelay) {
                 if (activeStage) {
@@ -66,7 +74,7 @@ export class AgentSessionWebhookHandler {
             if (desiredStage) {
                 await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
                 await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                    type: "thought",
+                    type: "response",
                     body: `PatchRelay started working on the ${desiredStage} workflow and is preparing the workspace.`,
                 }, { ephemeral: false });
                 return;
@@ -137,7 +145,7 @@ export class AgentSessionWebhookHandler {
         if (!activeRunLease && desiredStage) {
             await this.agentActivity.updateSession(buildSessionUpdateParams(project.id, normalized.agentSession.id, issue?.issueKey ?? normalized.issue?.identifier, buildPreparingSessionPlan(desiredStage)));
             await this.agentActivity.publishForSession(project.id, normalized.agentSession.id, {
-                type: "thought",
+                type: "response",
                 body: `PatchRelay is preparing the ${desiredStage} workflow from your latest prompt.`,
             }, { ephemeral: false });
             return;

package/dist/webhook-desired-stage-recorder.js

@@ -1,5 +1,5 @@
 import { triggerEventAllowed } from "./project-resolution.js";
-import { resolveWorkflowStage } from "./workflow-policy.js";
+import { resolveWorkflowStage, selectWorkflowDefinition } from "./workflow-policy.js";
 function trimPrompt(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed : undefined;
@@ -25,7 +25,8 @@ export class WebhookDesiredStageRecorder {
         const activeStageRun = issueControl?.activeRunLeaseId !== undefined ? this.stores.issueWorkflows.getStageRun(issueControl.activeRunLeaseId) : undefined;
         const delegatedToPatchRelay = this.isDelegatedToPatchRelay(project, normalized);
         const stageAllowed = triggerEventAllowed(project, normalized.triggerEvent);
-        const desiredStage = this.resolveDesiredStage(project, normalized, issue, activeStageRun, delegatedToPatchRelay);
+        const selectedWorkflowId = this.resolveSelectedWorkflowId(project, normalized, issue, activeStageRun, delegatedToPatchRelay);
+        const desiredStage = this.resolveDesiredStage(project, normalized, issue, activeStageRun, delegatedToPatchRelay, selectedWorkflowId);
         const launchInput = this.resolveLaunchInput(normalized.agentSession);
         const activeAgentSessionId = normalized.agentSession?.id ??
             (!activeStageRun && (desiredStage || (normalized.triggerEvent === "delegateChanged" && !delegatedToPatchRelay)) ? null : undefined);
@@ -36,6 +37,7 @@ export class WebhookDesiredStageRecorder {
             ...(normalizedIssue.title ? { title: normalizedIssue.title } : {}),
             ...(normalizedIssue.url ? { issueUrl: normalizedIssue.url } : {}),
             ...(normalizedIssue.stateName ? { currentLinearState: normalizedIssue.stateName } : {}),
+            ...(selectedWorkflowId !== undefined ? { selectedWorkflowId } : {}),
             ...(desiredStage ? { desiredStage } : {}),
             ...(options?.eventReceiptId !== undefined ? { desiredReceiptId: options.eventReceiptId } : {}),
             ...(activeAgentSessionId !== undefined ? { activeAgentSessionId } : {}),
@@ -71,7 +73,7 @@ export class WebhookDesiredStageRecorder {
         }
         return normalizedIssue.delegateId === installation.actorId;
     }
-    resolveDesiredStage(project, normalized, issue, activeStageRun, delegatedToPatchRelay) {
+    resolveDesiredStage(project, normalized, issue, activeStageRun, delegatedToPatchRelay, selectedWorkflowId) {
         const normalizedIssue = normalized.issue;
         if (!normalizedIssue) {
             return undefined;
@@ -82,7 +84,9 @@ export class WebhookDesiredStageRecorder {
         if (!delegatedToPatchRelay || !triggerEventAllowed(project, normalized.triggerEvent)) {
             return undefined;
         }
-        const desiredStage = resolveWorkflowStage(project, normalizedIssue.stateName);
+        const desiredStage = resolveWorkflowStage(project, normalizedIssue.stateName, {
+            ...(selectedWorkflowId ? { workflowDefinitionId: selectedWorkflowId } : {}),
+        });
         if (!desiredStage) {
             return undefined;
         }
@@ -94,6 +98,22 @@ export class WebhookDesiredStageRecorder {
         }
         return desiredStage;
     }
+    resolveSelectedWorkflowId(project, normalized, issue, activeStageRun, delegatedToPatchRelay) {
+        if (activeStageRun) {
+            return issue?.selectedWorkflowId;
+        }
+        if (normalized.triggerEvent !== "agentSessionCreated" && normalized.triggerEvent !== "agentPrompted") {
+            return issue?.selectedWorkflowId;
+        }
+        if (!delegatedToPatchRelay || !triggerEventAllowed(project, normalized.triggerEvent) || !normalized.issue) {
+            return issue?.selectedWorkflowId;
+        }
+        const selectedWorkflow = selectWorkflowDefinition(project, normalized.issue);
+        if (selectedWorkflow) {
+            return selectedWorkflow.id;
+        }
+        return null;
+    }
     resolveLaunchInput(agentSession) {
         const promptBody = trimPrompt(agentSession?.promptBody);
         if (promptBody) {

package/dist/workflow-policy.js

@@ -2,6 +2,9 @@ function normalize(value) {
     const trimmed = value?.trim();
     return trimmed ? trimmed.toLowerCase() : undefined;
 }
+function normalizeWorkflowLabel(value) {
+    return normalize(value)?.replace(/[\s_-]+/g, "");
+}
 function extractIssuePrefix(identifier) {
     const value = identifier?.trim();
     if (!value) {
@@ -10,25 +13,129 @@ function extractIssuePrefix(identifier) {
     const [prefix] = value.split("-", 1);
     return prefix ? prefix.toUpperCase() : undefined;
 }
-export function resolveWorkflow(project, stateName) {
+function withWorkflowDefinitionId(workflowDefinitionId) {
+    return workflowDefinitionId ? { workflowDefinitionId } : undefined;
+}
+export function listProjectWorkflowDefinitions(project) {
+    if (project.workflowDefinitions && project.workflowDefinitions.length > 0) {
+        return project.workflowDefinitions;
+    }
+    return [
+        {
+            id: project.workflowSelection?.defaultWorkflowId ?? "default",
+            stages: project.workflows,
+        },
+    ];
+}
+export function resolveWorkflowDefinitionById(project, workflowDefinitionId) {
+    const normalized = normalize(workflowDefinitionId);
+    if (!normalized) {
+        return undefined;
+    }
+    return listProjectWorkflowDefinitions(project).find((definition) => normalize(definition.id) === normalized);
+}
+export function selectWorkflowDefinition(project, issue) {
+    const workflowDefinitions = listProjectWorkflowDefinitions(project);
+    if (workflowDefinitions.length === 0) {
+        return undefined;
+    }
+    const labelNames = new Set((issue?.labelNames ?? []).map((label) => label.trim().toLowerCase()).filter(Boolean));
+    const matchedWorkflowIds = new Set();
+    for (const rule of project.workflowSelection?.byLabel ?? []) {
+        if (labelNames.has(rule.label.trim().toLowerCase())) {
+            matchedWorkflowIds.add(rule.workflowId);
+        }
+    }
+    if (matchedWorkflowIds.size === 1) {
+        const [workflowId] = [...matchedWorkflowIds];
+        return resolveWorkflowDefinitionById(project, workflowId);
+    }
+    if (matchedWorkflowIds.size > 1) {
+        return undefined;
+    }
+    if (project.workflowSelection?.defaultWorkflowId) {
+        return resolveWorkflowDefinitionById(project, project.workflowSelection.defaultWorkflowId);
+    }
+    return workflowDefinitions[0];
+}
+function resolveStageList(project, options) {
+    if (options?.workflowDefinitionId) {
+        return resolveWorkflowDefinitionById(project, options.workflowDefinitionId)?.stages ?? [];
+    }
+    if (options?.issue) {
+        return selectWorkflowDefinition(project, options.issue)?.stages ?? [];
+    }
+    return project.workflows;
+}
+export function resolveWorkflow(project, stateName, options) {
     const normalized = normalize(stateName);
     if (!normalized) {
         return undefined;
     }
-    return project.workflows.find((workflow) => normalize(workflow.whenState) === normalized);
+    return resolveStageList(project, options).find((workflow) => normalize(workflow.whenState) === normalized);
 }
-export function resolveWorkflowStage(project, stateName) {
-    return resolveWorkflow(project, stateName)?.id;
+export function resolveWorkflowStage(project, stateName, options) {
+    return resolveWorkflow(project, stateName, options)?.id;
 }
-export function resolveWorkflowById(project, workflowId) {
+export function resolveWorkflowStageConfig(project, workflowId, workflowDefinitionId) {
     const normalized = normalize(workflowId);
     if (!normalized) {
         return undefined;
     }
-    return project.workflows.find((workflow) => normalize(workflow.id) === normalized);
+    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).find((workflow) => normalize(workflow.id) === normalized);
+}
+export function listRunnableStates(project, options) {
+    return [...new Set(resolveStageList(project, options).map((workflow) => workflow.whenState))];
+}
+export function listWorkflowStageIds(project, workflowDefinitionId) {
+    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).map((workflow) => workflow.id);
+}
+export function resolveWorkflowIndex(project, workflowId, workflowDefinitionId) {
+    if (!workflowId) {
+        return -1;
+    }
+    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).findIndex((workflow) => workflow.id === workflowId);
 }
-export function listRunnableStates(project) {
-    return project.workflows.map((workflow) => workflow.whenState);
+export function resolveDefaultTransitionTarget(project, currentStage, workflowDefinitionId) {
+    const stages = resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId));
+    const currentIndex = resolveWorkflowIndex(project, currentStage, workflowDefinitionId);
+    if (currentIndex < 0) {
+        return undefined;
+    }
+    const nextStage = stages[currentIndex + 1]?.id;
+    return nextStage ?? "done";
+}
+export function listAllowedTransitionTargets(project, currentStage, workflowDefinitionId) {
+    const stages = resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId));
+    const currentIndex = resolveWorkflowIndex(project, currentStage, workflowDefinitionId);
+    if (currentIndex < 0) {
+        return ["human_needed"];
+    }
+    const targets = new Set(["human_needed"]);
+    const defaultTarget = resolveDefaultTransitionTarget(project, currentStage, workflowDefinitionId);
+    if (defaultTarget) {
+        targets.add(defaultTarget);
+    }
+    if (currentIndex > 0) {
+        targets.add(stages[currentIndex - 1].id);
+    }
+    if (currentIndex > 1) {
+        targets.add(stages[0].id);
+    }
+    return [...targets];
+}
+export function transitionTargetAllowed(project, currentStage, nextTarget, workflowDefinitionId) {
+    return listAllowedTransitionTargets(project, currentStage, workflowDefinitionId).includes(nextTarget);
+}
+export function resolveWorkflowStageCandidate(project, value, workflowDefinitionId) {
+    const normalized = normalizeWorkflowLabel(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return resolveStageList(project, withWorkflowDefinitionId(workflowDefinitionId)).find((workflow) => {
+        const candidates = [workflow.id, workflow.whenState, workflow.activeState];
+        return candidates.some((candidate) => normalizeWorkflowLabel(candidate) === normalized);
+    })?.id;
 }
 export function matchesProject(issue, project) {
     const issuePrefix = extractIssuePrefix(issue.identifier);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "license": "MIT",
   "type": "module",
   "repository": {