patchrelay 0.72.0 → 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.72.0",
-  "commit": "d4d672824c5f",
-  "builtAt": "2026-05-24T01:19:45.865Z"
+  "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

@@ -149,10 +149,9 @@ function resolveDesiredActiveWorkflowState(issue, trackedIssue, _options, liveIs
         return resolvePreferredQueuedLinearState(liveIssue);
     }
     // 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") {
+    //    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 →

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.72.0",
+  "version": "0.73.0",
   "license": "MIT",
   "type": "module",
   "repository": {