patchrelay 0.71.2 → 0.72.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.71.2",
-  "commit": "252cbbebc8d3",
-  "builtAt": "2026-05-24T00:18:53.503Z"
+  "version": "0.72.0",
+  "commit": "d4d672824c5f",
+  "builtAt": "2026-05-24T01:19:45.865Z"
 }

package/dist/linear-workflow-state-sync.js

@@ -1,4 +1,4 @@
-import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredDeployLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredMergeQueueLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
@@ -67,24 +67,21 @@ async function syncQueuedForDeployLabel(params) {
         await linear.updateIssueLabels({ issueId: issue.linearIssueId, removeNames: [labelName] });
     }
 }
-// True only when (a) the issue is In Deploy AND (b) the project's
-// Linear workflow has no In Deploy-equivalent state — detected by the
-// preferred-deploying state collapsing to the same name as the
-// preferred-review state. When the project does have a real In Deploy
-// state, `setIssueState` flows the issue there and the label is
-// unnecessary.
+// True only when (a) the issue is in the merge queue (`awaiting_queue`)
+// AND (b) the project's Linear workflow has no dedicated In Merge Queue
+// state — detected by the preferred merge-queue state collapsing to the
+// same name as the reviewing state. When the project has a real In Merge
+// Queue (or Deploying) state, `setIssueState` flows the issue there and
+// the label is unnecessary.
 function isQueuedForDeployFallback(issue, liveIssue) {
     if (issue.factoryState !== "awaiting_queue")
         return false;
-    const deploying = resolvePreferredDeployingLinearState(liveIssue);
-    const review = resolvePreferredReviewLinearState(liveIssue);
-    const deployUnstarted = resolvePreferredDeployLinearState(liveIssue);
-    if (!deploying || !review)
+    const mergeQueue = resolvePreferredMergeQueueLinearState(liveIssue);
+    const reviewing = resolvePreferredReviewingLinearState(liveIssue);
+    if (!mergeQueue || !reviewing)
         return false;
-    // No "deploying"/"deploy" state in the workflow → both resolve to
-    // a review state. That's the fallback condition.
-    return deploying.trim().toLowerCase() === review.trim().toLowerCase()
-        && (deployUnstarted ?? "").trim().toLowerCase() === review.trim().toLowerCase();
+    // No dedicated merge-queue state → it collapses to the reviewing state.
+    return mergeQueue.trim().toLowerCase() === reviewing.trim().toLowerCase();
 }
 async function syncCompletedLinearState(params) {
     const { db, issue, linear, liveIssue } = params;
@@ -121,49 +118,115 @@ function shouldAutoAdvanceLinearState(issue) {
     const normalizedName = issue.currentLinearState?.trim().toLowerCase();
     return normalizedName !== "done" && normalizedName !== "completed" && normalizedName !== "complete";
 }
-function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIssue) {
-    if (issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated"
-        || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
+// ─── Unified PR-lifecycle → Linear-state mapping ─────────────────────
+//
+// Five phases, in lifecycle order:
+//   Implementing → Reviewing → In Merge Queue → Deploying → Done
+//
+// Every phase is decided from DURABLE signals (factoryState, prState,
+// prReviewState) — never the ephemeral activeRunId / sessionState / run
+// type. That is what kills the Implementing↔Reviewing flap: the state
+// only moves on a real lifecycle handoff (a review verdict, an approval,
+// a merge), not on whichever transient webhook happens to recompute it
+// while a run briefly holds a lease.
+//
+// Branches are ordered "furthest along the lifecycle wins" so a stale
+// earlier signal can never pull a more-advanced issue backwards.
+function resolveDesiredActiveWorkflowState(issue, trackedIssue, _options, liveIssue) {
+    // 1. Operator must act — overrides everything.
+    if (needsHumanAttention(issue, trackedIssue)) {
         return resolvePreferredHumanNeededLinearState(liveIssue);
     }
+    // 2. Completed → Done. Covers today's merge→done path (the factory has
+    //    no post-merge state yet), so a done issue never reads as Deploying.
+    if (issue.factoryState === "done") {
+        return resolvePreferredCompletedLinearState(liveIssue);
+    }
+    // 3. Paused with no PR and nothing for us to do → backlog.
     const blocked = (trackedIssue?.blockedByCount ?? 0) > 0;
-    const pausedNoPrWork = issue.prNumber === undefined && (!issue.delegatedToPatchRelay || blocked);
-    if (pausedNoPrWork) {
+    const noPr = issue.prNumber === undefined && !issue.prUrl;
+    if (noPr && (issue.delegatedToPatchRelay === false || blocked)) {
         return resolvePreferredQueuedLinearState(liveIssue);
     }
-    const activelyWorking = issue.delegatedToPatchRelay !== false && (issue.activeRunId !== undefined
-        || options?.activeRunType !== undefined
-        || trackedIssue?.sessionState === "running"
-        || (issue.factoryState === "delegated" && !blocked && trackedIssue?.readyForExecution !== false)
-        || issue.factoryState === "implementing"
-        || issue.factoryState === "changes_requested"
-        || issue.factoryState === "repairing_ci"
-        || issue.factoryState === "repairing_queue");
-    if (activelyWorking) {
+    // 4. Post-merge: the change is on main, deploy running → Deploying.
+    //    Durable signal: the PR is merged. (Until PR3 makes merge a
+    //    non-terminal phase this only fires in the merged-not-yet-done
+    //    window; branch 2 already caught factoryState==="done".)
+    if (normalize(issue.prState) === "merged") {
+        return resolvePreferredDeployingLinearState(liveIssue);
+    }
+    // 5. Patchrelay is actively addressing review/CI/queue feedback →
+    //    Implementing. These factory states persist for the run's whole
+    //    duration, so this is stable, not flappy — and it is exactly the
+    //    "show when patchrelay handles feedback" behavior we want.
+    if (isAddressingFeedback(issue)) {
         return resolvePreferredImplementingLinearState(liveIssue);
     }
-    if (issue.factoryState === "awaiting_queue"
-        || issue.prReviewState === "approved"
-        || isApprovedAndGreen(issue.prReviewState, issue.prCheckStatus)) {
-        return resolvePreferredDeployingLinearState(liveIssue);
+    // 6. Approved / admitted to the merge queue → In Merge Queue.
+    if (isInMergeQueue(issue)) {
+        return resolvePreferredMergeQueueLinearState(liveIssue);
     }
-    if (hasPendingReviewQuillVerdict(issue.lastGitHubCiSnapshotJson)) {
+    // 7. Pre-review-feedback implementation work (incl. a draft PR) →
+    //    Implementing.
+    if (isImplementing(issue, trackedIssue)) {
+        return resolvePreferredImplementingLinearState(liveIssue);
+    }
+    // 8. PR exists and is under review → Reviewing.
+    if (isReviewBound(issue)) {
         return resolvePreferredReviewingLinearState(liveIssue);
     }
-    const reviewBound = issue.prNumber !== undefined
+    return undefined;
+}
+function normalize(value) {
+    const trimmed = value?.trim().toLowerCase();
+    return trimmed ? trimmed : undefined;
+}
+function needsHumanAttention(issue, trackedIssue) {
+    return issue.factoryState === "awaiting_input"
+        || issue.factoryState === "failed"
+        || issue.factoryState === "escalated"
+        || trackedIssue?.sessionState === "waiting_input"
+        || trackedIssue?.sessionState === "failed";
+}
+// Active code work to address feedback. Durable factory states +
+// changes-requested review verdict — no run-id involvement. Gated on
+// delegation: an undelegated PR (operator paused us) is not being worked
+// by patchrelay, so it must not read as Implementing.
+function isAddressingFeedback(issue) {
+    if (issue.delegatedToPatchRelay === false)
+        return false;
+    return issue.factoryState === "changes_requested"
+        || issue.factoryState === "repairing_ci"
+        || issue.factoryState === "repairing_queue"
+        || normalize(issue.prReviewState) === "changes_requested";
+}
+// Approved and heading to / sitting in the merge queue. Not yet merged
+// (branch 4 catches merged first).
+function isInMergeQueue(issue) {
+    return issue.factoryState === "awaiting_queue"
+        || normalize(issue.prReviewState) === "approved";
+}
+// Initial implementation, before review starts. A draft PR still counts
+// as implementing. Gated on delegation so we never claim Implementing
+// for work that isn't ours.
+function isImplementing(issue, trackedIssue) {
+    if (issue.delegatedToPatchRelay === false)
+        return false;
+    if (issue.factoryState === "implementing")
+        return true;
+    if (issue.factoryState === "delegated") {
+        const blocked = (trackedIssue?.blockedByCount ?? 0) > 0;
+        return !blocked && trackedIssue?.readyForExecution !== false;
+    }
+    return issue.prIsDraft === true;
+}
+function isReviewBound(issue) {
+    return issue.prNumber !== undefined
         || Boolean(issue.prUrl)
         || issue.factoryState === "pr_open"
         || issue.prReviewState !== undefined
-        || issue.prCheckStatus !== undefined;
-    if (reviewBound) {
-        return resolvePreferredReviewLinearState(liveIssue);
-    }
-    return undefined;
-}
-function isApprovedAndGreen(prReviewState, prCheckStatus) {
-    const normalizedReview = prReviewState?.trim().toLowerCase();
-    const normalizedChecks = prCheckStatus?.trim().toLowerCase();
-    return normalizedReview === "approved" && (normalizedChecks === "success" || normalizedChecks === "passed");
+        || issue.prCheckStatus !== undefined
+        || hasPendingReviewQuillVerdict(issue.lastGitHubCiSnapshotJson);
 }
 function hasPendingReviewQuillVerdict(snapshotJson) {
     if (!snapshotJson)

package/dist/linear-workflow.js

@@ -59,16 +59,37 @@ export function resolvePreferredReviewingLinearState(issue) {
         fallback: resolvePreferredReviewLinearState(issue),
     });
 }
+// The pre-merge "approved, awaiting/undergoing landing" phase. Covers a
+// PR that is queued, being tested in the speculative branch, or actively
+// merging — i.e. everything the merge queue owns up to (but not past)
+// the merge. NOT post-merge: that is `resolvePreferredDeployingLinearState`.
+// Without a dedicated queue state, collapses to the reviewing state (and
+// the `queued-for-deploy` label disambiguates — see state-sync).
+export function resolvePreferredMergeQueueLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["in merge queue", "merge queue", "in queue", "queued", "queue", "merging", "landing", "ready to merge"],
+        types: ["started"],
+        fallback: resolvePreferredLinearState(issue, {
+            names: ["in merge queue", "merge queue", "queued", "ready to merge", "ready to deploy", "ready for deploy", "to deploy", "merge"],
+            types: ["unstarted"],
+            fallback: resolvePreferredReviewingLinearState(issue),
+        }),
+    });
+}
+// Unstarted deploy column, used as a fallback by the started variant.
 export function resolvePreferredDeployLinearState(issue) {
     return resolvePreferredLinearState(issue, {
-        names: ["deploy", "ready to deploy", "ready for deploy", "merge"],
+        names: ["deploy", "to deploy", "ready to ship"],
         types: ["unstarted"],
-        fallback: resolvePreferredReviewLinearState(issue),
+        fallback: resolvePreferredMergeQueueLinearState(issue),
     });
 }
+// Strictly POST-merge: the change is on main and the deploy workflow is
+// running. "merging" lives in the merge-queue phase, not here. Without a
+// dedicated deploy state, collapses back to the merge-queue state.
 export function resolvePreferredDeployingLinearState(issue) {
     return resolvePreferredLinearState(issue, {
-        names: ["deploying", "merging", "shipping"],
+        names: ["deploying", "deployment", "in deploy", "shipping", "releasing", "rollout"],
         types: ["started"],
         fallback: resolvePreferredDeployLinearState(issue),
     });

package/package.json

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