patchrelay 0.71.2 → 0.73.0

package/dist/agent-session-plan.js

@@ -161,6 +161,13 @@ export function buildAgentSessionPlan(params) {
             ], ["completed", "completed", "completed", "inProgress"]);
         case "repairing_queue":
             return setStatuses(queueRepairPlan(params.queueRepairAttempts ?? 1), ["completed", "completed", "completed", "inProgress"]);
+        case "deploying":
+            return setStatuses([
+                { content: "Prepare workspace", status: "completed" },
+                { content: "Verification passed", status: "completed" },
+                { content: "Merged", status: "completed" },
+                { content: "Deploying", status: "inProgress" },
+            ], ["completed", "completed", "completed", "inProgress"]);
         case "awaiting_input":
             return awaitingInputPlan();
         case "escalated":

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.73.0",
+  "commit": "46cf80cc9eb7",
+  "builtAt": "2026-05-24T02:06:29.741Z"
 }

package/dist/cli/watch/state-visualization.js

@@ -8,12 +8,13 @@ const STATE_LABELS = {
     repairing_ci: "repairing_ci",
     awaiting_queue: "awaiting_queue",
     repairing_queue: "repairing_queue",
+    deploying: "deploying",
     awaiting_input: "awaiting_input",
     escalated: "escalated",
     done: "done",
     failed: "failed",
 };
-const MAIN_STATES = ["delegated", "implementing", "pr_open", "awaiting_queue", "done"];
+const MAIN_STATES = ["delegated", "implementing", "pr_open", "awaiting_queue", "deploying", "done"];
 const PR_LOOP_STATES = ["changes_requested", "repairing_ci"];
 const QUEUE_LOOP_STATES = ["repairing_queue"];
 const EXIT_STATES = ["awaiting_input", "escalated", "failed"];
@@ -139,6 +140,12 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
                             : "PatchRelay is preparing or waiting to resume queue repair.",
                     });
                     break;
+                case "deploying":
+                    observations.push({
+                        tone: "info",
+                        text: "PatchRelay merged the PR and is watching the deploy workflow on main.",
+                    });
+                    break;
                 case "done":
                     observations.push({
                         tone: "success",

package/dist/db/issue-store.js

@@ -480,5 +480,8 @@ export function mapIssueRow(row) {
         ...(row.orchestration_settle_until !== null && row.orchestration_settle_until !== undefined
             ? { orchestrationSettleUntil: String(row.orchestration_settle_until) }
             : {}),
+        ...(row.deploy_started_at !== null && row.deploy_started_at !== undefined
+            ? { deployStartedAt: String(row.deploy_started_at) }
+            : {}),
     };
 }

package/dist/db/issue-upsert-columns.js

@@ -71,6 +71,7 @@ export const ISSUE_COLUMN_DEFS = {
     zombieRecoveryAttempts: { column: "zombie_recovery_attempts", insertDefault: 0 },
     lastZombieRecoveryAt: { column: "last_zombie_recovery_at" },
     orchestrationSettleUntil: { column: "orchestration_settle_until" },
+    deployStartedAt: { column: "deploy_started_at" },
 };
 export const ISSUE_COLUMN_KEYS = Object.keys(ISSUE_COLUMN_DEFS);
 /**

package/dist/db/migrations.js

@@ -359,6 +359,10 @@ export function runPatchRelayMigrations(connection) {
     removeRetiredIssueColumnsIfPresent(connection);
     addColumnIfMissing(connection, "issues", "issue_triage_hash", "TEXT");
     addColumnIfMissing(connection, "issues", "issue_triage_result_json", "TEXT");
+    // PR3: post-merge deploy tracking. Timestamp the issue entered the
+    // `deploying` state, so the deploy watcher only considers deploy runs
+    // created at/after the merge (and can time out a never-arriving deploy).
+    addColumnIfMissing(connection, "issues", "deploy_started_at", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/github-webhook-terminal-handler.js

@@ -1,10 +1,16 @@
 import { resolveClosedPrDisposition, resolveClosedPrFactoryState } from "./pr-state.js";
+import { resolvePostMergeFactoryState } from "./post-merge-deploy.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
 import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
 import { wakeOrchestrationParentsForChildEvent } from "./orchestration-parent-wake.js";
 export async function handleGitHubTerminalPrEvent(params) {
     const { db, linearProvider, wakeDispatcher, logger, codex, issue, event, config } = params;
     const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
+    // PR3: when the project configures a deploy workflow, a merge enters the
+    // `deploying` watch state instead of completing immediately. Linear
+    // completion is deferred until the deploy succeeds (idle reconciler).
+    const project = config.projects.find((candidate) => candidate.id === issue.projectId);
+    const postMergeState = resolvePostMergeFactoryState(project);
     db.issueSessions.appendIssueSessionEvent({
         projectId: issue.projectId,
         linearIssueId: issue.linearIssueId,
@@ -37,13 +43,14 @@ export async function handleGitHubTerminalPrEvent(params) {
             });
         }
         const terminalFactoryState = event.triggerEvent === "pr_merged"
-            ? "done"
+            ? postMergeState
             : resolveClosedPrFactoryState(issue);
         db.issues.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             activeRunId: null,
             factoryState: terminalFactoryState,
+            ...(terminalFactoryState === "deploying" ? { deployStartedAt: new Date().toISOString() } : {}),
         });
     };
     const activeLease = db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
@@ -68,7 +75,12 @@ export async function handleGitHubTerminalPrEvent(params) {
             eventType: "child_delivered",
             wakeDispatcher,
         });
-        await completeLinearIssueAfterMerge(params, updatedIssue);
+        // Only complete Linear now when there's no deploy to watch. While
+        // `deploying`, the issue stays in the Deploying state and the idle
+        // reconciler completes it once the deploy workflow succeeds.
+        if (postMergeState === "done") {
+            await completeLinearIssueAfterMerge(params, updatedIssue);
+        }
     }
     void syncGitHubLinearSession({
         config,

package/dist/idle-reconciliation.js

@@ -1,3 +1,5 @@
+import { TERMINAL_STATES } from "./factory-state.js";
+import { DEPLOY_WATCH_TIMEOUT_MS, evaluateDeploy, isDeployTrackingEnabled, } from "./post-merge-deploy.js";
 import { buildBranchUpkeepContext, buildFailureContext, getGateCheckNames, hasCompletedReviewQuillVerdict, hasFailureProvenance, isDuplicateRepairAttempt, isFailingCheckStatus, isReviewDecisionApproved, isReviewDecisionReviewRequired, } from "./idle-reconciliation-helpers.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
@@ -14,12 +16,16 @@ export class IdleIssueReconciler {
     wakeDispatcher;
     logger;
     feed;
-    constructor(db, config, wakeDispatcher, logger, feed) {
+    deployEvaluator;
+    constructor(db, config, wakeDispatcher, logger, feed, 
+    // Injectable for tests; production uses the real `gh`-backed watcher.
+    deployEvaluator = evaluateDeploy) {
         this.db = db;
         this.config = config;
         this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
+        this.deployEvaluator = deployEvaluator;
     }
     async reconcile() {
         // Wrap the entire reconcile pass in a dispatcher tick. Every
@@ -34,7 +40,7 @@ export class IdleIssueReconciler {
     async reconcileBody() {
         for (const issue of this.db.issues.listIdleNonTerminalIssues()) {
             if (issue.prState === "merged") {
-                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                await this.handleMergedIssue(issue);
                 continue;
             }
             if (issue.lastGitHubFailureSource === "queue_eviction") {
@@ -119,8 +125,101 @@ export class IdleIssueReconciler {
             return false;
         if (issue.pendingRunType !== undefined)
             return false;
+        // A merged PR cannot be un-merged: never re-probe it back toward the
+        // queue. This matters for deploy-failed issues (escalated while
+        // prState === "merged") — recovery-to-awaiting_queue would be wrong.
+        if (issue.prState === "merged")
+            return false;
         return issue.factoryState === "escalated" || issue.factoryState === "failed";
     }
+    // PR3: route a merged PR either into post-merge deploy tracking or
+    // straight to done. Called from both the idle pass and the GitHub
+    // reconcile path, so the deploying-vs-done decision lives in one place.
+    async handleMergedIssue(issue) {
+        if (issue.factoryState === "deploying") {
+            await this.watchDeploy(issue);
+            return;
+        }
+        // Already finalized (done/escalated/failed) — never re-open it.
+        if (TERMINAL_STATES.has(issue.factoryState))
+            return;
+        const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
+        if (isDeployTrackingEnabled(project)) {
+            this.advanceIdleIssue(issue, "deploying", { clearFailureProvenance: true });
+            this.db.issues.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                deployStartedAt: new Date().toISOString(),
+            });
+        }
+        else {
+            this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+        }
+    }
+    // Poll the project's deploy workflow for a merged issue sitting in
+    // `deploying`: success → done, failure → escalate, still running → wait
+    // (with a timeout backstop so a never-arriving deploy can't strand it).
+    async watchDeploy(issue) {
+        const project = this.config.projects.find((candidate) => candidate.id === issue.projectId);
+        const protocol = resolveMergeQueueProtocol(project);
+        const workflowName = protocol.deployWorkflowName;
+        const repoFullName = protocol.repoFullName;
+        if (!workflowName || !repoFullName) {
+            // Misconfigured / tracking disabled after entering — don't strand it.
+            this.finishDeploy(issue, "done");
+            return;
+        }
+        const since = issue.deployStartedAt ?? issue.updatedAt;
+        const outcome = await this.deployEvaluator({
+            repoFullName,
+            workflowName,
+            baseBranch: protocol.baseBranch ?? "main",
+            sinceIso: since,
+            logger: this.logger,
+        });
+        if (outcome === "succeeded") {
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Deploy succeeded; completing issue");
+            this.finishDeploy(issue, "done");
+            this.feed?.publish({
+                level: "info",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "done",
+                status: "deployed",
+                summary: `Deploy succeeded for PR #${issue.prNumber}`,
+            });
+            return;
+        }
+        if (outcome === "failed") {
+            this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Deploy failed; escalating for operator attention");
+            this.finishDeploy(issue, "escalated");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: issue.issueKey,
+                projectId: issue.projectId,
+                stage: "deploying",
+                status: "deploy_failed",
+                summary: `Deploy failed for PR #${issue.prNumber}; needs operator attention`,
+            });
+            return;
+        }
+        // Still pending — apply the timeout backstop.
+        const sinceMs = Date.parse(since);
+        if (Number.isFinite(sinceMs) && Date.now() - sinceMs > DEPLOY_WATCH_TIMEOUT_MS) {
+            this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Deploy not observed within timeout; completing issue (change is already on main)");
+            this.finishDeploy(issue, "done");
+        }
+    }
+    finishDeploy(issue, state) {
+        this.advanceIdleIssue(issue, state, state === "done" ? { clearFailureProvenance: true } : undefined);
+        this.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            deployStartedAt: null,
+        });
+    }
     advanceIdleIssue(issue, newState, options) {
         if (issue.factoryState === newState && !options?.pendingRunType && !options?.clearFailureProvenance) {
             return;
@@ -367,7 +466,8 @@ export class IdleIssueReconciler {
             });
             if (pr.state === "MERGED") {
                 this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
-                this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                const merged = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? { ...issue, prState: "merged" };
+                await this.handleMergedIssue(merged);
                 return;
             }
             if (pr.state === "CLOSED") {

package/dist/linear-status-comment-sync.js

@@ -203,6 +203,8 @@ function statusHeadline(issue, activeRunType) {
             return "Handed off downstream for merge";
         case "repairing_queue":
             return "Repairing merge handoff";
+        case "deploying":
+            return issue.prNumber !== undefined ? `Deploying merged PR #${issue.prNumber}` : "Deploying after merge";
         case "awaiting_input":
             return "Waiting for more input";
         case "failed":

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,114 @@ 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 signals: factoryState === "deploying" (post-merge deploy
+    //    watch in progress) or the PR is merged but not yet done.
+    if (issue.factoryState === "deploying" || 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/dist/merge-queue-protocol.js

@@ -19,5 +19,6 @@ export function resolveMergeQueueProtocol(project) {
         specBranchPattern: project?.github?.specBranchPattern ?? DEFAULT_SPEC_BRANCH_PATTERN,
         noCacheLabel: project?.github?.noCacheLabel ?? DEFAULT_NO_CACHE_LABEL,
         queuedForDeployLabel: project?.github?.queuedForDeployLabel ?? DEFAULT_QUEUED_FOR_DEPLOY_LABEL,
+        deployWorkflowName: project?.github?.deployWorkflowName,
     };
 }

package/dist/post-merge-deploy.js

@@ -0,0 +1,83 @@
+import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
+import { execCommand } from "./utils.js";
+// How long an issue may sit in `deploying` before we give up watching and
+// advance to `done` anyway. The change is already on `main`; if no deploy
+// run ever shows up (no workflow triggered, or it was superseded and GC'd),
+// we must not strand the issue. 20 minutes comfortably covers a queued +
+// running deploy without leaving issues stuck for hours.
+export const DEPLOY_WATCH_TIMEOUT_MS = 20 * 60_000;
+// Small grace window: a deploy run triggered by the merge push can be
+// created a few seconds before we stamp `deployStartedAt`. Don't exclude it.
+const SINCE_GRACE_MS = 2 * 60_000;
+/**
+ * Whether a merge should enter the `deploying` watch state. Opt-in per
+ * project via `github.deployWorkflowName`; absent → advance straight to
+ * `done` (today's behavior, no risk of stranding issues).
+ */
+export function isDeployTrackingEnabled(project) {
+    return Boolean(resolveMergeQueueProtocol(project).deployWorkflowName);
+}
+export function resolvePostMergeFactoryState(project) {
+    return isDeployTrackingEnabled(project) ? "deploying" : "done";
+}
+/**
+ * Decide the deploy outcome from the recent runs of the deploy workflow on
+ * the base branch. Pure and total so it can be unit-tested without GitHub.
+ *
+ * Only runs created at/after `sinceIso` (minus a small grace) count — any
+ * deploy on `main` after the merge includes the merged change, since `main`
+ * only moves forward. The most recent decisive run wins; cancelled/skipped
+ * runs are ignored (a later run supersedes them).
+ */
+export function interpretDeployRuns(runs, sinceIso) {
+    const sinceMs = Date.parse(sinceIso);
+    const cutoff = Number.isFinite(sinceMs) ? sinceMs - SINCE_GRACE_MS : -Infinity;
+    const relevant = runs
+        .filter((r) => {
+        const t = Date.parse(r.createdAt);
+        return Number.isFinite(t) && t >= cutoff;
+    })
+        .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt));
+    for (const run of relevant) {
+        const conclusion = (run.conclusion ?? "").toLowerCase();
+        const status = run.status.toLowerCase();
+        if (status !== "completed") {
+            // queued / in_progress / waiting / requested → still deploying.
+            return "pending";
+        }
+        if (conclusion === "success")
+            return "succeeded";
+        if (conclusion === "failure" || conclusion === "timed_out" || conclusion === "startup_failure") {
+            return "failed";
+        }
+        // cancelled / skipped / neutral / stale / action_required — not decisive;
+        // look at the next-most-recent run.
+    }
+    return "pending";
+}
+/**
+ * Query the deploy workflow's recent runs on the base branch and interpret
+ * them. Returns "pending" on any query error so the watcher simply retries
+ * next tick (and the timeout backstops a permanently-absent deploy).
+ */
+export async function evaluateDeploy(params) {
+    const { repoFullName, workflowName, baseBranch, sinceIso, logger } = params;
+    try {
+        const { stdout } = await execCommand("gh", [
+            "run", "list",
+            "--repo", repoFullName,
+            "--workflow", workflowName,
+            "--branch", baseBranch,
+            "--json", "status,conclusion,createdAt",
+            "-L", "15",
+        ], { timeoutMs: 15_000 });
+        const runs = JSON.parse(stdout);
+        if (!Array.isArray(runs))
+            return "pending";
+        return interpretDeployRuns(runs, sinceIso);
+    }
+    catch (error) {
+        logger?.debug({ repoFullName, workflowName, error: error instanceof Error ? error.message : String(error) }, "Deploy watch query failed; will retry");
+        return "pending";
+    }
+}

package/package.json

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