patchrelay 0.37.0 → 0.37.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.37.0",
-  "commit": "e927a73f2d7b",
-  "builtAt": "2026-04-10T13:26:32.780Z"
+  "version": "0.37.1",
+  "commit": "e2c1f3d45497",
+  "builtAt": "2026-04-10T17:31:17.533Z"
 }

package/dist/cli/cluster-health.js

@@ -1,5 +1,6 @@
 import { deriveGateCheckStatusFromRollup } from "../github-rollup.js";
 import { ACTIVE_RUN_STATES } from "../factory-state.js";
+import { hasOpenPr, resolveClosedPrDisposition } from "../pr-state.js";
 const RECONCILIATION_GRACE_MS = 120_000;
 const DOWNSTREAM_STALE_MS = 900_000;
 export async function collectClusterHealth(config, db, runCommand) {
@@ -98,7 +99,7 @@ export async function collectClusterHealth(config, db, runCommand) {
     }
     checks.push(...await collectActiveOverlapFindings(snapshots, runCommand));
     for (const snapshot of snapshots) {
-        if (!snapshot.issue.prNumber) {
+        if (!hasOpenPr(snapshot.issue.prNumber, snapshot.issue.prState)) {
             continue;
         }
         const githubHealth = await evaluateGitHubIssueHealth(snapshot, config, runCommand, reviewQuillProbe, reviewQuillAttemptOwners, mergeStewardProbe);
@@ -277,19 +278,8 @@ async function evaluateGitHubIssueHealth(snapshot, config, runCommand, reviewQui
     const latestBlockingReviewHeadSha = extractLatestBlockingReviewHeadSha(pr.latestReviews);
     const mergeConflictDetected = pr.mergeable === "CONFLICTING" || pr.mergeStateStatus === "DIRTY";
     const reviewQuillAttempt = issue.issueKey ? reviewQuillAttemptOwners?.get(issue.issueKey) : undefined;
-    const ciEntry = buildCiEntry({
-        issue,
-        gateCheckStatus,
-        reviewDecision,
-        reviewRequested,
-        currentHeadSha: pr.headRefOid,
-        latestBlockingReviewHeadSha,
-        mergeConflictDetected,
-        reviewQuillAttempt,
-    });
     if (pr.state === "MERGED" && issue.factoryState !== "done" && ageMs >= RECONCILIATION_GRACE_MS) {
         return {
-            ciEntry,
             finding: {
                 status: "fail",
                 scope: "github:reconcile",
@@ -297,16 +287,29 @@ async function evaluateGitHubIssueHealth(snapshot, config, runCommand, reviewQui
             },
         };
     }
-    if (pr.state === "CLOSED" && issue.factoryState !== "delegated" && issue.factoryState !== "done" && ageMs >= RECONCILIATION_GRACE_MS) {
-        return {
-            ciEntry,
-            finding: {
-                status: "fail",
-                scope: "github:reconcile",
-                message: "PR is closed but the issue is still waiting on PR state",
-            },
-        };
+    if (pr.state === "CLOSED") {
+        const closedPrDisposition = resolveClosedPrDisposition(issue);
+        if (closedPrDisposition === "redelegate" && issue.factoryState !== "delegated" && ageMs >= RECONCILIATION_GRACE_MS) {
+            return {
+                finding: {
+                    status: "fail",
+                    scope: "github:reconcile",
+                    message: "PR is closed but unfinished work has not been re-delegated",
+                },
+            };
+        }
+        return {};
     }
+    const ciEntry = buildCiEntry({
+        issue,
+        gateCheckStatus,
+        reviewDecision,
+        reviewRequested,
+        currentHeadSha: pr.headRefOid,
+        latestBlockingReviewHeadSha,
+        mergeConflictDetected,
+        reviewQuillAttempt,
+    });
     if (gateCheckStatus === "failure" && issue.factoryState !== "repairing_ci" && issue.activeRunId === undefined && ageMs >= RECONCILIATION_GRACE_MS) {
         return {
             ciEntry,
@@ -521,7 +524,7 @@ function needsReviewAutomation(issue) {
     if (issue.factoryState === "awaiting_queue" || issue.factoryState === "done") {
         return false;
     }
-    return issue.prNumber !== undefined;
+    return hasOpenPr(issue.prNumber, issue.prState);
 }
 async function collectReviewQuillAttemptOwners(snapshots, config, runCommand) {
     const owners = new Map();

package/dist/cli/data.js

@@ -119,6 +119,7 @@ export class CliDataAccess extends CliOperatorApiClient {
             ...(latestReport ? { latestReport } : {}),
             ...(latestSummary ? { latestSummary } : {}),
             ...(dbIssue.prNumber ? { prNumber: dbIssue.prNumber } : {}),
+            ...(dbIssue.prState ? { prState: dbIssue.prState } : {}),
             ...(dbIssue.prReviewState ? { prReviewState: dbIssue.prReviewState } : {}),
             ...((dbIssue.sessionState) ? { sessionState: dbIssue.sessionState } : {}),
             ...((dbIssue.waitingReason) ? { waitingReason: dbIssue.waitingReason } : {}),

package/dist/cli/formatters/text.js

@@ -20,7 +20,11 @@ export function formatInspect(result) {
         value("Debug stage", result.issue?.factoryState),
         result.activeRun ? value("Active run", `${result.activeRun.runType} (${result.activeRun.status})`) : undefined,
         result.latestRun && !result.activeRun ? value("Latest run", `${result.latestRun.runType} (${result.latestRun.status})`) : undefined,
-        result.prNumber ? value("PR", `#${result.prNumber}${result.prReviewState ? ` [${result.prReviewState}]` : ""}`) : undefined,
+        result.prNumber
+            ? value("PR", `#${result.prNumber}${result.prState || result.prReviewState
+                ? ` [${[result.prState, result.prReviewState].filter(Boolean).join(", ")}]`
+                : ""}`)
+            : undefined,
         result.completionCheckOutcome ? value("Completion check", result.completionCheckOutcome) : undefined,
         result.completionCheckSummary ? value("Completion summary", truncateLine(result.completionCheckSummary)) : undefined,
         result.completionCheckQuestion ? value("Question", truncateLine(result.completionCheckQuestion)) : undefined,

package/dist/cli/watch/IssueRow.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { hasOpenPr } from "../../pr-state.js";
 import { summarizeIssueStatusNote } from "./issue-status-note.js";
 import { relativeTime, truncate } from "./format-utils.js";
 import { hasDisplayPrBlocker, isApprovedReviewState, isAwaitingReviewState, isChangesRequestedReviewState, isRereviewNeeded, prChecksFact, } from "./pr-status.js";
@@ -19,7 +20,7 @@ function effectiveState(issue) {
         return "blocked";
     if (issue.sessionState === "waiting_input")
         return "awaiting_input";
-    if (issue.prNumber !== undefined)
+    if (hasOpenPr(issue.prNumber, issue.prState))
         return issue.factoryState;
     if (issue.readyForExecution && !issue.activeRunType && !hasDisplayPrBlocker(issue))
         return "ready";
@@ -94,7 +95,7 @@ function buildFacts(issue, selected) {
     else if (isChangesRequestedReviewState(issue.prReviewState)) {
         facts.push({ text: "changes requested", color: "yellow" });
     }
-    else if (issue.prNumber !== undefined
+    else if (hasOpenPr(issue.prNumber, issue.prState)
         && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && !TERMINAL_STATES.has(effectiveState(issue))))) {
         facts.push({ text: "awaiting review", color: "yellow" });
     }
@@ -146,7 +147,7 @@ function blockerText(issue) {
         return "Awaiting re-review after requested changes";
     if (isChangesRequestedReviewState(issue.prReviewState))
         return "Review changes requested";
-    if (issue.prNumber !== undefined && isAwaitingReviewState(issue.prReviewState))
+    if (hasOpenPr(issue.prNumber, issue.prState) && isAwaitingReviewState(issue.prReviewState))
         return "Awaiting review";
     return null;
 }

package/dist/cli/watch/StatusBar.js

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { hasOpenPr } from "../../pr-state.js";
 import { computeAggregates } from "./watch-state.js";
 import { FreshnessBadge } from "./FreshnessBadge.js";
 const FILTER_LABELS = {
@@ -11,7 +12,7 @@ export function StatusBar({ issues, totalCount, filter, connected, lastServerMes
     const showing = filter === "all" ? `${totalCount} issues` : `${issues.length}/${totalCount} issues`;
     const aggregateSource = filter === "all" ? allIssues : issues;
     const agg = computeAggregates(aggregateSource);
-    const withPr = aggregateSource.filter((i) => i.prNumber !== undefined).length;
+    const withPr = aggregateSource.filter((i) => hasOpenPr(i.prNumber, i.prState)).length;
     const waitingInput = aggregateSource.filter((i) => i.sessionState === "waiting_input" || i.factoryState === "awaiting_input").length;
     const intervention = aggregateSource.filter((i) => i.sessionState === "failed" || i.factoryState === "failed" || i.factoryState === "escalated").length;
     const running = aggregateSource.filter((i) => i.sessionState === "running").length;

package/dist/cli/watch/detail-rows.js

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "../../pr-state.js";
 import { buildStateHistory } from "./history-builder.js";
 import { buildTimelineRows } from "./timeline-presentation.js";
 import { planStepColor, planStepSymbol } from "./plan-helpers.js";
@@ -396,7 +397,7 @@ function buildFactSegments(issue, issueContext) {
         facts.push([{ text: "re-review needed", color: "yellow" }]);
     else if (isChangesRequestedReviewState(issue.prReviewState))
         facts.push([{ text: "changes requested", color: "yellow" }]);
-    else if (issue.prNumber !== undefined
+    else if (hasOpenPr(issue.prNumber, issue.prState)
         && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && issue.factoryState === "pr_open")))
         facts.push([{ text: "awaiting review", color: "yellow" }]);
     if (issue.factoryState === "awaiting_queue")
@@ -503,7 +504,7 @@ function effectiveState(issue) {
         return "blocked";
     if (issue.sessionState === "waiting_input")
         return "awaiting_input";
-    if (issue.prNumber !== undefined)
+    if (hasOpenPr(issue.prNumber, issue.prState))
         return issue.factoryState;
     if (issue.readyForExecution && !issue.activeRunType && !hasDisplayPrBlocker(issue))
         return "ready";
@@ -546,7 +547,7 @@ function blockerText(issue, issueContext) {
         return "Awaiting re-review after requested changes";
     if (isChangesRequestedReviewState(issue.prReviewState))
         return "Review changes requested";
-    if (issue.prNumber !== undefined && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && effectiveState(issue) !== "done"))) {
+    if (hasOpenPr(issue.prNumber, issue.prState) && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && effectiveState(issue) !== "done"))) {
         return "Awaiting review";
     }
     return null;

package/dist/cli/watch/pr-status.js

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "../../pr-state.js";
 function isPassingCheckStatus(status) {
     return status === "passed" || status === "success";
 }
@@ -72,7 +73,7 @@ export function prChecksFact(issue) {
     return undefined;
 }
 export function hasDisplayPrBlocker(issue) {
-    if (issue.prNumber === undefined || issue.activeRunType) {
+    if (!hasOpenPr(issue.prNumber, issue.prState) || issue.activeRunType) {
         return false;
     }
     if (issue.factoryState === "pr_open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "repairing_queue") {

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

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "../../pr-state.js";
 const STATE_LABELS = {
     delegated: "delegated",
     implementing: "implementing",
@@ -163,9 +164,12 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
         });
     }
     if (issue.prNumber !== undefined) {
+        const prLabel = hasOpenPr(issue.prNumber, issue.prState)
+            ? `Tracked PR: #${issue.prNumber}`
+            : `Tracked PR: #${issue.prNumber}${issue.prState ? ` (${issue.prState})` : ""}`;
         observations.push({
             tone: "info",
-            text: `Tracked PR: #${issue.prNumber}${issue.prReviewState ? ` (${issue.prReviewState})` : ""}`,
+            text: `${prLabel}${issue.prReviewState ? ` (${issue.prReviewState})` : ""}`,
         });
     }
     return observations.slice(0, 3);

package/dist/factory-state.js

@@ -30,7 +30,7 @@ const TRANSITION_RULES = [
     // pr_closed during an active run is suppressed — Codex may reopen.
     // Without a guard match, the event produces no transition (undefined).
     { event: "pr_closed",
-        guard: (_, ctx) => ctx.activeRunId === undefined,
+        guard: (s, ctx) => ctx.activeRunId === undefined && !TERMINAL_STATES.has(s),
         to: "failed" },
     // ── PR lifecycle ───────────────────────────────────────────────
     { event: "pr_opened",

package/dist/github-webhook-handler.js

@@ -1,4 +1,4 @@
-import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
+import { resolveFactoryStateFromGitHub } from "./factory-state.js";
 import { createGitHubCiSnapshotResolver, createGitHubFailureContextResolver, summarizeGitHubFailureContext, } from "./github-failure-context.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
@@ -7,6 +7,7 @@ import { buildGitHubStateActivity } from "./linear-session-reporting.js";
 import { resolveMergeQueueProtocol, } from "./merge-queue-protocol.js";
 import { buildQueueRepairContextFromEvent } from "./merge-queue-incident.js";
 import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { buildClosedPrCleanupFields, isIssueTerminal, resolveClosedPrFactoryState, resolveClosedPrDisposition, } from "./pr-state.js";
 import { resolveSecret } from "./resolve-secret.js";
 import { safeJsonParse } from "./utils.js";
 /**
@@ -153,6 +154,9 @@ export class GitHubWebhookHandler {
                 : event.reviewState === "approved"
                     ? { lastBlockingReviewHeadSha: null }
                     : {}),
+            ...(event.triggerEvent === "pr_closed"
+                ? buildClosedPrCleanupFields()
+                : {}),
         });
         await this.updateCiSnapshot(issue, event, project);
         await this.updateFailureProvenance(issue, event, project);
@@ -227,11 +231,14 @@ export class GitHubWebhookHandler {
         }
     }
     resolveFactoryStateForEvent(issue, event, project) {
+        if (event.triggerEvent === "pr_closed") {
+            return undefined;
+        }
         if (event.triggerEvent === "check_failed"
             && this.isQueueEvictionFailure(issue, event, project)
             && issue.prState === "open"
             && issue.activeRunId === undefined
-            && !TERMINAL_STATES.has(issue.factoryState)) {
+            && !isIssueTerminal(issue)) {
             return "repairing_queue";
         }
         return resolveFactoryStateFromGitHub(event.triggerEvent, issue.factoryState, {
@@ -318,7 +325,7 @@ export class GitHubWebhookHandler {
             return;
         // Don't trigger on terminal issues — late-arriving webhooks (e.g.
         // merge_group_failed after pr_merged) must not resurrect done issues.
-        if (TERMINAL_STATES.has(issue.factoryState))
+        if (isIssueTerminal(issue))
             return;
         if (!this.isPatchRelayOwnedPr(issue)) {
             this.feed?.publish({
@@ -521,11 +528,14 @@ export class GitHubWebhookHandler {
                         : "Pull request closed during active run",
                 });
             }
+            const terminalFactoryState = event.triggerEvent === "pr_merged"
+                ? "done"
+                : resolveClosedPrFactoryState(issue);
             this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
                 activeRunId: null,
-                factoryState: event.triggerEvent === "pr_merged" ? "done" : "failed",
+                factoryState: terminalFactoryState,
             });
         };
         const activeLease = this.db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
@@ -537,6 +547,18 @@ export class GitHubWebhookHandler {
         }
         this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
         const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        if (event.triggerEvent === "pr_closed" && resolveClosedPrDisposition(issue) === "redelegate") {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                eventType: "delegated",
+                dedupeKey: `github_pr_closed:implementation:${issue.linearIssueId}`,
+            });
+            this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
+            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
+        }
         if (event.triggerEvent === "pr_merged") {
             await this.completeLinearIssueAfterMerge(updatedIssue);
         }

package/dist/idle-reconciliation.js

@@ -1,8 +1,10 @@
+import {} from "./factory-state.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
 import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { parseStoredQueueRepairContext } from "./merge-queue-incident.js";
+import { buildClosedPrCleanupFields, resolveClosedPrDisposition } from "./pr-state.js";
 import { execCommand } from "./utils.js";
 const DEFAULT_REVIEW_FIX_BUDGET = 12;
 function isFailingCheckStatus(status) {
@@ -439,8 +441,23 @@ export class IdleIssueReconciler {
                 return;
             }
             if (pr.state === "CLOSED") {
-                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed, re-delegating for implementation");
-                this.db.issues.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "closed" });
+                const closedPrDisposition = resolveClosedPrDisposition(issue);
+                this.db.issues.upsertIssue({
+                    projectId: issue.projectId,
+                    linearIssueId: issue.linearIssueId,
+                    prState: "closed",
+                    ...buildClosedPrCleanupFields(),
+                });
+                if (closedPrDisposition === "done") {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed for an already completed issue; preserving done state");
+                    this.advanceIdleIssue(issue, "done", { clearFailureProvenance: true });
+                    return;
+                }
+                if (closedPrDisposition === "terminal") {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, factoryState: issue.factoryState }, "Reconciliation: PR was closed on a terminal issue; preserving terminal state");
+                    return;
+                }
+                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed on unfinished work, re-delegating for implementation");
                 this.advanceIdleIssue(issue, "delegated", {
                     pendingRunType: "implementation",
                     clearFailureProvenance: true,

package/dist/implementation-outcome-policy.js

@@ -46,7 +46,9 @@ export class ImplementationOutcomePolicy {
                             ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
                             ...(pr.author?.login ? { prAuthorLogin: pr.author.login } : {}),
                         }, "published PR verification refresh");
-                        return undefined;
+                        if (pr.state?.toLowerCase() !== "closed") {
+                            return undefined;
+                        }
                     }
                 }
             }

package/dist/issue-overview-query.js

@@ -143,6 +143,7 @@ export class IssueOverviewQuery {
             factoryState: issueRecord?.factoryState ?? "delegated",
             pendingRunType: issueRecord?.pendingRunType,
             prNumber: session.prNumber,
+            prState: issueRecord?.prState,
             prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
             prReviewState: issueRecord?.prReviewState,
             prCheckStatus: issueRecord?.prCheckStatus,
@@ -159,6 +160,10 @@ export class IssueOverviewQuery {
             ...(issueRecord?.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
             sessionState: session.sessionState,
             factoryState: issueRecord?.factoryState ?? "delegated",
+            ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),
+            ...(issueRecord?.prState ? { prState: issueRecord.prState } : {}),
+            ...(issueRecord?.prReviewState ? { prReviewState: issueRecord.prReviewState } : {}),
+            ...(issueRecord?.prCheckStatus ? { prCheckStatus: issueRecord.prCheckStatus } : {}),
             blockedByCount: unresolvedBlockedBy.length,
             blockedByKeys,
             readyForExecution: isIssueSessionReadyForExecution({

package/dist/linear-session-reporting.js

@@ -1,5 +1,6 @@
 import { formatRunTypeLabel } from "./agent-session-plan.js";
 import { sanitizeOperatorFacingText } from "./presentation-text.js";
+import { isClosedPrState } from "./pr-state.js";
 function lowerRunTypeLabel(runType) {
     return formatRunTypeLabel(runType).toLowerCase();
 }
@@ -188,15 +189,19 @@ export function buildMergePrepEscalationActivity(attempts) {
 export function summarizeIssueStateForLinear(issue) {
     switch (issue.sessionState) {
         case "waiting_input":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is waiting for input.` : "Waiting for input.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is waiting for input.` : "Waiting for input.");
         case "running":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is actively running.` : "Actively running.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is actively running.` : "Actively running.");
         case "idle":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is idle.` : "Idle.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is idle.` : "Idle.");
         case "done":
-            return issue.prNumber ? `PR #${issue.prNumber} has merged.` : "Change merged.";
+            if (issue.prNumber && issue.prState === "merged")
+                return `PR #${issue.prNumber} has merged.`;
+            if (issue.prNumber && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}.`;
+            return issue.prNumber ? `Completed with PR #${issue.prNumber}.` : "Completed.";
         case "failed":
-            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} needs help to recover.` : "Needs help to recover.");
+            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} needs help to recover.` : "Needs help to recover.");
     }
     switch (issue.factoryState) {
         case "pr_open":
@@ -204,7 +209,11 @@ export function summarizeIssueStateForLinear(issue) {
         case "awaiting_queue":
             return issue.prNumber ? `PR #${issue.prNumber} is approved and awaiting merge.` : "Approved and awaiting merge.";
         case "done":
-            return issue.prNumber ? `PR #${issue.prNumber} has merged.` : "Change merged.";
+            if (issue.prNumber && issue.prState === "merged")
+                return `PR #${issue.prNumber} has merged.`;
+            if (issue.prNumber && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}.`;
+            return issue.prNumber ? `Completed with PR #${issue.prNumber}.` : "Completed.";
         default:
             return undefined;
     }

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

@@ -1,6 +1,7 @@
 import { extractCompletionCheck } from "./completion-check.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+import { isClosedPrState } from "./pr-state.js";
 export async function syncVisibleStatusComment(params) {
     const { db, issue, linear, logger, trackedIssue, options } = params;
     try {
@@ -31,7 +32,9 @@ export function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
         || issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
         return true;
     }
-    if ((issue.sessionState === "done" || issue.factoryState === "done") && issue.prNumber === undefined && !issue.prUrl) {
+    if ((issue.sessionState === "done" || issue.factoryState === "done")
+        && ((issue.prNumber === undefined && !issue.prUrl)
+            || isClosedPrState(issue.prState))) {
         return true;
     }
     return false;
@@ -49,6 +52,7 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         factoryState: issue.factoryState,
         pendingRunType: issue.pendingRunType,
         ...(issue.prNumber !== undefined ? { prNumber: issue.prNumber } : {}),
+        ...(issue.prState ? { prState: issue.prState } : {}),
         prHeadSha: issue.prHeadSha,
         prReviewState: issue.prReviewState,
         prCheckStatus: issue.prCheckStatus,
@@ -110,6 +114,10 @@ function statusHeadline(issue, activeRunType) {
         case "running":
             return issue.prNumber !== undefined ? `PR #${issue.prNumber} is actively running` : "Actively running";
         case "done":
+            if (issue.prNumber !== undefined && issue.prState === "merged")
+                return `Completed with merged PR #${issue.prNumber}`;
+            if (issue.prNumber !== undefined && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}`;
             return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
         case "failed":
             return "Needs operator intervention";
@@ -138,6 +146,10 @@ function statusHeadline(issue, activeRunType) {
         case "escalated":
             return "Needs operator intervention";
         case "done":
+            if (issue.prNumber !== undefined && issue.prState === "merged")
+                return `Completed with merged PR #${issue.prNumber}`;
+            if (issue.prNumber !== undefined && isClosedPrState(issue.prState))
+                return `Completed without merging PR #${issue.prNumber}`;
             return issue.prNumber !== undefined ? `Completed with PR #${issue.prNumber}` : "Completed";
         default:
             return humanize(issue.factoryState);

package/dist/pr-state.js

@@ -0,0 +1,49 @@
+import { TERMINAL_STATES } from "./factory-state.js";
+export function isOpenPrState(prState) {
+    return prState === undefined || prState === "open";
+}
+export function hasOpenPr(prNumber, prState) {
+    // Transitional compatibility: older rows may still have a tracked PR number
+    // before webhook/reconciliation has populated pr_state.
+    return prNumber !== undefined && isOpenPrState(prState);
+}
+export function isClosedPrState(prState) {
+    return prState === "closed";
+}
+export function isCompletedLinearState(currentLinearStateType, currentLinearState) {
+    return currentLinearStateType === "completed"
+        || currentLinearState?.trim().toLowerCase() === "done";
+}
+export function isIssueCompleted(issue) {
+    return issue.factoryState === "done" || isCompletedLinearState(issue.currentLinearStateType, issue.currentLinearState);
+}
+export function isIssueTerminal(issue) {
+    return issue.factoryState !== undefined && TERMINAL_STATES.has(issue.factoryState);
+}
+export function resolveClosedPrDisposition(issue) {
+    if (isIssueCompleted(issue))
+        return "done";
+    if (isIssueTerminal(issue))
+        return "terminal";
+    return "redelegate";
+}
+export function resolveClosedPrFactoryState(issue) {
+    const disposition = resolveClosedPrDisposition(issue);
+    if (disposition === "done")
+        return "done";
+    if (disposition === "terminal")
+        return issue.factoryState;
+    return "delegated";
+}
+export function buildClosedPrCleanupFields() {
+    return {
+        prReviewState: null,
+        prCheckStatus: null,
+        lastBlockingReviewHeadSha: null,
+        lastGitHubCiSnapshotHeadSha: null,
+        lastGitHubCiSnapshotGateCheckName: null,
+        lastGitHubCiSnapshotGateCheckStatus: null,
+        lastGitHubCiSnapshotJson: null,
+        lastGitHubCiSnapshotSettledAt: null,
+    };
+}

package/dist/service-issue-actions.js

@@ -1,4 +1,5 @@
 import { buildOperatorRetryEvent } from "./operator-retry-event.js";
+import { hasOpenPr } from "./pr-state.js";
 export class ServiceIssueActions {
     db;
     codex;
@@ -107,21 +108,21 @@ export class ServiceIssueActions {
         }
         let runType = "implementation";
         let factoryState = "delegated";
-        if (issue.prNumber && issue.lastGitHubFailureSource === "queue_eviction") {
+        if (hasOpenPr(issue.prNumber, issue.prState) && issue.lastGitHubFailureSource === "queue_eviction") {
             runType = "queue_repair";
             factoryState = "repairing_queue";
         }
-        else if (issue.prNumber && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
+        else if (hasOpenPr(issue.prNumber, issue.prState) && (issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure" || issue.lastGitHubFailureSource === "branch_ci")) {
             runType = "ci_repair";
             factoryState = "repairing_ci";
         }
-        else if (issue.prNumber && issue.prReviewState === "changes_requested") {
+        else if (hasOpenPr(issue.prNumber, issue.prState) && issue.prReviewState === "changes_requested") {
             runType = issue.pendingRunType === "branch_upkeep" || issueSession?.lastRunType === "branch_upkeep"
                 ? "branch_upkeep"
                 : "review_fix";
             factoryState = "changes_requested";
         }
-        else if (issue.prNumber) {
+        else if (hasOpenPr(issue.prNumber, issue.prState)) {
             runType = "implementation";
             factoryState = "implementing";
         }

package/dist/tracked-issue-list-query.js

@@ -82,7 +82,7 @@ export class TrackedIssueListQuery {
           s.project_id, s.linear_issue_id, s.issue_key, i.title,
           i.current_linear_state, i.factory_state, s.session_state, s.waiting_reason, s.summary_text, s.updated_at,
           i.pending_run_type,
-          i.pr_number, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
+          i.pr_number, i.pr_state, i.pr_head_sha, i.pr_review_state, i.pr_check_status, i.last_blocking_review_head_sha,
           i.last_github_ci_snapshot_json,
           i.last_github_failure_source,
           i.last_github_failure_head_sha,
@@ -180,6 +180,7 @@ export class TrackedIssueListQuery {
                 factoryState: String(row.factory_state ?? "delegated"),
                 ...(row.pending_run_type !== null ? { pendingRunType: String(row.pending_run_type) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+                ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
                 ...(row.pr_head_sha !== null ? { prHeadSha: String(row.pr_head_sha) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
                 ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
@@ -242,6 +243,7 @@ export class TrackedIssueListQuery {
                 ...(row.latest_run_type !== null ? { latestRunType: String(row.latest_run_type) } : {}),
                 ...(row.latest_run_status !== null ? { latestRunStatus: String(row.latest_run_status) } : {}),
                 ...(row.pr_number !== null ? { prNumber: Number(row.pr_number) } : {}),
+                ...(row.pr_state !== null ? { prState: String(row.pr_state) } : {}),
                 ...(row.pr_review_state !== null ? { prReviewState: String(row.pr_review_state) } : {}),
                 ...(row.pr_check_status !== null ? { prCheckStatus: String(row.pr_check_status) } : {}),
                 ...(prChecksSummary ? { prChecksSummary } : {}),

package/dist/tracked-issue-projector.js

@@ -15,6 +15,7 @@ export function buildTrackedIssueRecord(params) {
         factoryState: params.issue.factoryState,
         pendingRunType: params.issue.pendingRunType,
         prNumber: params.issue.prNumber,
+        prState: params.issue.prState,
         prHeadSha: params.issue.prHeadSha,
         prReviewState: params.issue.prReviewState,
         prCheckStatus: params.issue.prCheckStatus,
@@ -46,6 +47,10 @@ export function buildTrackedIssueRecord(params) {
         ...(params.issue.currentLinearState ? { currentLinearState: params.issue.currentLinearState } : {}),
         ...(params.session?.sessionState ? { sessionState: params.session.sessionState } : {}),
         factoryState: params.issue.factoryState,
+        ...(params.issue.prNumber !== undefined ? { prNumber: params.issue.prNumber } : {}),
+        ...(params.issue.prState ? { prState: params.issue.prState } : {}),
+        ...(params.issue.prReviewState ? { prReviewState: params.issue.prReviewState } : {}),
+        ...(params.issue.prCheckStatus ? { prCheckStatus: params.issue.prCheckStatus } : {}),
         blockedByCount: unresolvedBlockedBy.length,
         blockedByKeys,
         readyForExecution: isIssueSessionReadyForExecution({

package/dist/waiting-reason.js

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "./pr-state.js";
 export const PATCHRELAY_WAITING_REASONS = {
     activeWork: "PatchRelay is actively working",
     finalizingPublishedPr: "PatchRelay is finalizing a published PR",
@@ -14,7 +15,7 @@ export const PATCHRELAY_WAITING_REASONS = {
 };
 export function derivePatchRelayWaitingReason(params) {
     if (params.activeRunType) {
-        if (params.prNumber !== undefined && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
+        if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
             return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
         }
         if (params.factoryState === "done") {
@@ -66,7 +67,7 @@ export function derivePatchRelayWaitingReason(params) {
     if (params.prReviewState === "approved") {
         return PATCHRELAY_WAITING_REASONS.waitingForDownstreamAutomation;
     }
-    if (params.prNumber !== undefined) {
+    if (hasOpenPr(params.prNumber, params.prState)) {
         return PATCHRELAY_WAITING_REASONS.waitingForExternalReview;
     }
     if (params.pendingRunType) {

package/package.json

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