patchrelay 0.37.0 → 0.38.0

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";
 /**
@@ -33,7 +34,6 @@ export class GitHubWebhookHandler {
     failureContextResolver;
     ciSnapshotResolver;
     fetchImpl;
-    patchRelayAuthorLogins = new Set();
     constructor(config, db, linearProvider, enqueueIssue, logger, codex, feed, failureContextResolver = createGitHubFailureContextResolver(), ciSnapshotResolver = createGitHubCiSnapshotResolver(), fetchImpl = fetch) {
         this.config = config;
         this.db = db;
@@ -45,18 +45,6 @@ export class GitHubWebhookHandler {
         this.failureContextResolver = failureContextResolver;
         this.ciSnapshotResolver = ciSnapshotResolver;
         this.fetchImpl = fetchImpl;
-        for (const login of resolvePatchRelayAuthorLoginsFromEnv()) {
-            this.patchRelayAuthorLogins.add(login);
-        }
-    }
-    setPatchRelayAuthorLogins(logins) {
-        this.patchRelayAuthorLogins.clear();
-        for (const login of logins) {
-            const normalized = normalizeAuthorLogin(login);
-            if (normalized) {
-                this.patchRelayAuthorLogins.add(normalized);
-            }
-        }
     }
     async acceptGitHubWebhook(params) {
         // Deduplicate
@@ -129,13 +117,17 @@ export class GitHubWebhookHandler {
             this.logger.debug({ eventType: params.eventType }, "GitHub webhook: unrecognized event type or action");
             return;
         }
-        // Route to issue via branch name
-        const issue = this.db.issues.getIssueByBranch(event.branchName);
+        const project = this.config.projects.find((candidate) => candidate.github?.repoFullName === event.repoFullName);
+        if (!project) {
+            this.logger.debug({ repoFullName: event.repoFullName, triggerEvent: event.triggerEvent }, "GitHub webhook: no configured project for repository");
+            return;
+        }
+        const resolved = this.resolveIssueForEvent(project, event);
+        const issue = resolved?.issue;
         if (!issue) {
-            this.logger.debug({ branchName: event.branchName, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching issue for branch");
+            this.logger.debug({ repoFullName: event.repoFullName, branchName: event.branchName, prNumber: event.prNumber, triggerEvent: event.triggerEvent }, "GitHub webhook: no matching tracked issue");
             return;
         }
-        const project = this.config.projects.find((p) => p.id === issue.projectId);
         const immediateCheckStatus = this.deriveImmediatePrCheckStatus(issue, event, project);
         // Update PR state on the issue
         this.db.issues.upsertIssue({
@@ -148,11 +140,15 @@ export class GitHubWebhookHandler {
             ...(event.prAuthorLogin !== undefined ? { prAuthorLogin: event.prAuthorLogin } : {}),
             ...(event.reviewState !== undefined ? { prReviewState: event.reviewState } : {}),
             ...(immediateCheckStatus !== undefined ? { prCheckStatus: immediateCheckStatus } : {}),
+            ...(resolved.linkedBy === "issue_key" ? { branchName: event.branchName } : {}),
             ...(event.reviewState === "changes_requested"
                 ? { lastBlockingReviewHeadSha: event.reviewCommitId ?? event.headSha ?? null }
                 : event.reviewState === "approved"
                     ? { lastBlockingReviewHeadSha: null }
                     : {}),
+            ...(event.triggerEvent === "pr_closed"
+                ? buildClosedPrCleanupFields()
+                : {}),
         });
         await this.updateCiSnapshot(issue, event, project);
         await this.updateFailureProvenance(issue, event, project);
@@ -226,18 +222,75 @@ export class GitHubWebhookHandler {
             await this.handleTerminalPrEvent(freshIssue, event);
         }
     }
+    resolveIssueForEvent(project, event) {
+        if (event.prNumber !== undefined) {
+            const byPr = this.db.issues.getIssueByPrNumber(event.prNumber);
+            if (byPr && byPr.projectId === project.id) {
+                return { issue: byPr, linkedBy: "pr" };
+            }
+        }
+        const byBranch = this.db.issues.getIssueByBranch(event.branchName);
+        if (byBranch && byBranch.projectId === project.id) {
+            return { issue: byBranch, linkedBy: "branch" };
+        }
+        const byIssueKey = this.resolveIssueByExplicitIssueKey(project, event);
+        if (byIssueKey) {
+            return { issue: byIssueKey, linkedBy: "issue_key" };
+        }
+        return undefined;
+    }
+    resolveIssueByExplicitIssueKey(project, event) {
+        const candidates = new Set();
+        const sources = [event.prTitle, event.prBody, event.branchName];
+        for (const prefix of project.issueKeyPrefixes) {
+            const normalizedPrefix = prefix.trim();
+            if (!normalizedPrefix)
+                continue;
+            const pattern = new RegExp(`\\b${escapeRegExp(normalizedPrefix)}-\\d+\\b`, "gi");
+            for (const source of sources) {
+                if (!source)
+                    continue;
+                for (const match of source.matchAll(pattern)) {
+                    candidates.add(match[0].toUpperCase());
+                }
+            }
+        }
+        if (candidates.size !== 1) {
+            return undefined;
+        }
+        const [issueKey] = [...candidates];
+        if (!issueKey) {
+            return undefined;
+        }
+        const issue = this.db.issues.getIssueByKey(issueKey);
+        return issue?.projectId === project.id ? issue : undefined;
+    }
     resolveFactoryStateForEvent(issue, event, project) {
+        if (event.triggerEvent === "pr_closed") {
+            return undefined;
+        }
+        const effectiveCurrentState = (issue.factoryState === "awaiting_input" || issue.factoryState === "delegated")
+            && (event.prState === "open" || event.prNumber !== undefined)
+            ? "pr_open"
+            : issue.factoryState;
         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, {
+        const resolved = resolveFactoryStateFromGitHub(event.triggerEvent, effectiveCurrentState, {
             prReviewState: issue.prReviewState,
             activeRunId: issue.activeRunId,
         });
+        if (resolved !== undefined) {
+            return resolved;
+        }
+        if (effectiveCurrentState !== issue.factoryState) {
+            return effectiveCurrentState;
+        }
+        return undefined;
     }
     async updateCiSnapshot(issue, event, project) {
         if (event.triggerEvent === "pr_merged") {
@@ -318,17 +371,17 @@ 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)) {
+        if (!issue.delegatedToPatchRelay) {
             this.feed?.publish({
                 level: "info",
                 kind: "github",
                 issueKey: issue.issueKey,
                 projectId: issue.projectId,
                 stage: issue.factoryState,
-                status: "ignored_non_patchrelay_pr",
-                summary: `Ignored ${event.triggerEvent} on non-PatchRelay-owned PR`,
+                status: "ignored_undelegated",
+                summary: `Ignored ${event.triggerEvent} because the issue is undelegated`,
             });
             return;
         }
@@ -365,7 +418,6 @@ export class GitHubWebhookHandler {
                     }),
                     dedupeKey: failureContext.failureSignature,
                 });
-                this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
                 const queuedRunType = hadPendingWake
                     ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
                     : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
@@ -423,7 +475,6 @@ export class GitHubWebhookHandler {
                     }),
                     dedupeKey: failureContext.failureSignature,
                 });
-                this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
                 const queuedRunType = hadPendingWake
                     ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
                     : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
@@ -469,7 +520,6 @@ export class GitHubWebhookHandler {
                     event.reviewerName ?? "unknown-reviewer",
                 ].join("::"),
             });
-            this.db.issueSessions.setBranchOwnerRespectingActiveLease(issue.projectId, issue.linearIssueId, "patchrelay");
             const queuedRunType = hadPendingWake
                 ? this.peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId)
                 : this.enqueuePendingSessionWake(issue.projectId, issue.linearIssueId);
@@ -521,11 +571,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 +590,17 @@ 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}`,
+            });
+            if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
+            }
+        }
         if (event.triggerEvent === "pr_merged") {
             await this.completeLinearIssueAfterMerge(updatedIssue);
         }
@@ -687,7 +751,7 @@ export class GitHubWebhookHandler {
         if (!signature)
             return false;
         const pendingWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
-        if (pendingWake?.runType === runType) {
+        if (pendingWake?.runType === runType && pendingWake.eventIds.length > 0) {
             const existing = pendingWake.context;
             if (existing?.failureSignature === signature
                 && (headSha === undefined || existing.failureHeadSha === headSha || existing.headSha === headSha)) {
@@ -923,8 +987,6 @@ export class GitHubWebhookHandler {
         const issue = this.db.issues.getIssueByPrNumber(prNumber);
         if (!issue)
             return;
-        if (!this.isPatchRelayOwnedPr(issue))
-            return;
         this.feed?.publish({
             level: "info",
             kind: "comment",
@@ -987,30 +1049,9 @@ export class GitHubWebhookHandler {
         this.enqueueIssue(projectId, issueId);
         return wake.runType;
     }
-    isPatchRelayOwnedPr(issue) {
-        const author = normalizeAuthorLogin(issue.prAuthorLogin);
-        if (author) {
-            if (this.patchRelayAuthorLogins.size > 0) {
-                return this.patchRelayAuthorLogins.has(author);
-            }
-            return author.includes("patchrelay");
-        }
-        // Transitional fallback for rows written before author tracking existed.
-        return issue.prNumber !== undefined && issue.branchOwner === "patchrelay";
-    }
-}
-function normalizeAuthorLogin(login) {
-    const normalized = login?.trim().toLowerCase();
-    return normalized ? normalized : undefined;
 }
-function resolvePatchRelayAuthorLoginsFromEnv() {
-    return [
-        process.env.PATCHRELAY_GITHUB_BOT_LOGIN,
-        process.env.PATCHRELAY_GITHUB_BOT_NAME,
-    ]
-        .flatMap((value) => (value ?? "").split(","))
-        .map((value) => normalizeAuthorLogin(value))
-        .filter((value) => Boolean(value));
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 function buildGitHubReviewUrl(repoFullName, prNumber, reviewId) {
     if (!repoFullName || prNumber === undefined || reviewId === undefined) {

package/dist/github-webhooks.js

@@ -61,6 +61,8 @@ function normalizePullRequestEvent(payload, repoFullName) {
         repoFullName,
         branchName: pr.head.ref,
         headSha: pr.head.sha,
+        prTitle: pr.title ?? undefined,
+        prBody: pr.body ?? undefined,
         prNumber: pr.number,
         prUrl: pr.html_url,
         prState,
@@ -98,6 +100,8 @@ function normalizePullRequestReviewEvent(payload, repoFullName) {
         repoFullName,
         branchName: pr.head.ref,
         headSha: pr.head.sha,
+        prTitle: pr.title ?? undefined,
+        prBody: pr.body ?? undefined,
         prNumber: pr.number,
         prUrl: pr.html_url,
         prState: "open",

package/dist/idle-reconciliation.js

@@ -3,6 +3,7 @@ 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) {
@@ -88,15 +89,6 @@ function hasFailureProvenance(issue) {
         || issue.lastAttemptedFailureHeadSha
         || issue.lastAttemptedFailureSignature);
 }
-export function resolveBranchOwnerForStateTransition(newState, pendingRunType) {
-    if (pendingRunType)
-        return "patchrelay";
-    if (newState === "awaiting_queue")
-        return "patchrelay";
-    if (newState === "repairing_ci" || newState === "repairing_queue")
-        return "patchrelay";
-    return undefined;
-}
 export class IdleIssueReconciler {
     db;
     config;
@@ -152,6 +144,8 @@ export class IdleIssueReconciler {
             await this.reconcileFromGitHub(issue);
         }
         for (const issue of this.db.issues.listBlockedDelegatedIssues()) {
+            if (!issue.delegatedToPatchRelay)
+                continue;
             const unresolved = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
                 this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
@@ -205,10 +199,6 @@ export class IdleIssueReconciler {
                 }
                 : {}),
         });
-        const branchOwner = resolveBranchOwnerForStateTransition(newState, options?.pendingRunType);
-        if (branchOwner) {
-            this.db.issues.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
-        }
         if (options?.pendingRunType) {
             this.appendWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
         }
@@ -253,6 +243,9 @@ export class IdleIssueReconciler {
         });
     }
     async routeFailedIssue(issue) {
+        if (!issue.delegatedToPatchRelay) {
+            return;
+        }
         issue = await this.refreshMissingFailureProvenance(issue);
         issue = await this.reclassifyStaleBranchFailure(issue);
         const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
@@ -439,12 +432,33 @@ 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" });
-                this.advanceIdleIssue(issue, "delegated", {
-                    pendingRunType: "implementation",
-                    clearFailureProvenance: true,
+                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;
+                }
+                if (issue.delegatedToPatchRelay) {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed on unfinished delegated work, re-delegating for implementation");
+                    this.advanceIdleIssue(issue, "delegated", {
+                        pendingRunType: "implementation",
+                        clearFailureProvenance: true,
+                    });
+                }
+                else {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed while undelegated; preserving paused local-work state");
+                    this.advanceIdleIssue(issue, "delegated", { clearFailureProvenance: true });
+                }
                 return;
             }
             const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== previousHeadSha);
@@ -464,7 +478,8 @@ export class IdleIssueReconciler {
                     return;
                 }
             }
-            if (isReviewDecisionReviewRequired(pr.reviewDecision)
+            if (issue.delegatedToPatchRelay
+                && isReviewDecisionReviewRequired(pr.reviewDecision)
                 && gateCheckStatus === "success"
                 && hasCompletedReviewQuillVerdict(pr.statusCheckRollup)) {
                 this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewDecision: pr.reviewDecision }, "Reconciliation: review-quill completed without a decisive GitHub review; escalating for operator input");
@@ -492,7 +507,8 @@ export class IdleIssueReconciler {
                 mergeConflictDetected,
                 downstreamOwned,
             });
-            if ((issue.factoryState === "escalated" || issue.factoryState === "failed")
+            if (issue.delegatedToPatchRelay
+                && (issue.factoryState === "escalated" || issue.factoryState === "failed")
                 && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
                 if (issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
                     this.logger.debug({
@@ -521,7 +537,7 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
-            if (reactiveIntent?.runType === "branch_upkeep" && mergeConflictDetected) {
+            if (issue.delegatedToPatchRelay && reactiveIntent?.runType === "branch_upkeep" && mergeConflictDetected) {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR still needs branch upkeep after requested changes");
                 this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
                     pendingRunType: reactiveIntent.runType,
@@ -538,7 +554,7 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
-            if (reactiveIntent?.runType === "queue_repair" && mergeConflictDetected) {
+            if (issue.delegatedToPatchRelay && reactiveIntent?.runType === "queue_repair" && mergeConflictDetected) {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR needs queue repair from fresh GitHub truth");
                 this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
                     pendingRunType: reactiveIntent.runType,

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

@@ -138,11 +138,13 @@ export class IssueOverviewQuery {
         const liveThread = await this.readLiveThread(activeRun);
         const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
         const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
+            delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
             ...(activeRun ? { activeRunType: activeRun.runType } : {}),
             blockedByKeys,
             factoryState: issueRecord?.factoryState ?? "delegated",
             pendingRunType: issueRecord?.pendingRunType,
             prNumber: session.prNumber,
+            prState: issueRecord?.prState,
             prHeadSha: issueRecord?.prHeadSha ?? session.prHeadSha,
             prReviewState: issueRecord?.prReviewState,
             prCheckStatus: issueRecord?.prCheckStatus,
@@ -153,17 +155,23 @@ export class IssueOverviewQuery {
             id: issueRecord?.id ?? session.id,
             projectId: session.projectId,
             linearIssueId: session.linearIssueId,
+            delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay ?? true,
             ...(session.issueKey ? { issueKey: session.issueKey } : {}),
             ...(issueRecord?.title ? { title: issueRecord.title } : {}),
             ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
             ...(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({
                 sessionState: session.sessionState,
                 factoryState: issueRecord?.factoryState ?? "delegated",
+                delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
                 hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,

package/dist/issue-session-projector.js

@@ -26,6 +26,7 @@ export function syncIssueSessionFromIssue(params) {
     });
     const lastWakeReason = options?.lastWakeReason
         ?? deriveIssueSessionWakeReason({
+            delegatedToPatchRelay: issue.delegatedToPatchRelay,
             pendingRunType: issue.pendingRunType,
             factoryState: issue.factoryState,
             prNumber: issue.prNumber,

package/dist/issue-session.js

@@ -14,6 +14,8 @@ export function deriveIssueSessionWaitingReason(params) {
     return derivePatchRelayWaitingReason(params);
 }
 export function deriveIssueSessionWakeReason(params) {
+    if (params.delegatedToPatchRelay === false)
+        return undefined;
     if (params.pendingRunType === "implementation")
         return "delegated";
     if (params.pendingRunType === "review_fix")
@@ -27,6 +29,7 @@ export function deriveIssueSessionWakeReason(params) {
     if (params.factoryState === "awaiting_input")
         return "waiting_for_human_reply";
     const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: params.delegatedToPatchRelay,
         prNumber: params.prNumber,
         prState: params.prState,
         prReviewState: params.prReviewState,
@@ -38,6 +41,8 @@ export function deriveIssueSessionWakeReason(params) {
     return undefined;
 }
 export function deriveIssueSessionReactiveIntent(params) {
+    if (params.delegatedToPatchRelay === false)
+        return undefined;
     if (params.activeRunId !== undefined)
         return undefined;
     if (params.prNumber === undefined)
@@ -75,6 +80,8 @@ export function deriveIssueSessionReactiveIntent(params) {
     return undefined;
 }
 export function isIssueSessionReadyForExecution(params) {
+    if (params.delegatedToPatchRelay === false)
+        return false;
     if (params.activeRunId !== undefined)
         return false;
     if (params.blockedByCount > 0)
@@ -92,6 +99,7 @@ export function isIssueSessionReadyForExecution(params) {
         return false;
     }
     if (deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: params.delegatedToPatchRelay,
         prNumber: params.prNumber,
         prState: params.prState,
         prReviewState: params.prReviewState,

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,23 +189,60 @@ 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":
+            if (!issue.delegatedToPatchRelay) {
+                break;
+            }
             return issue.waitingReason ?? (issue.prNumber ? `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 "delegated":
+            if (!issue.delegatedToPatchRelay) {
+                return "PatchRelay is queued to start work, but automation is paused.";
+            }
+            return "Queued to start work.";
+        case "implementing":
+            if (!issue.delegatedToPatchRelay) {
+                return "Implementation is paused because the issue is undelegated.";
+            }
+            return "Implementation in progress.";
         case "pr_open":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} is awaiting review while PatchRelay is paused.`;
+            }
             return issue.prNumber ? `PR #${issue.prNumber} is awaiting review.` : "Awaiting review.";
+        case "changes_requested":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} has requested changes while PatchRelay is paused.`;
+            }
+            return issue.prNumber ? `PR #${issue.prNumber} has requested changes.` : "Requested changes received.";
+        case "repairing_ci":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} has failing CI while PatchRelay is paused.`;
+            }
+            return issue.prNumber ? `PR #${issue.prNumber} has failing CI.` : "Failing CI.";
         case "awaiting_queue":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} is approved and awaiting merge while PatchRelay is paused.`;
+            }
             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-session-sync.js

@@ -29,9 +29,17 @@ export class LinearSessionSync {
             if (!linear)
                 return;
             const trackedIssue = this.db.getTrackedIssue(syncedIssue.projectId, syncedIssue.linearIssueId);
+            const visibleIssue = trackedIssue
+                ? {
+                    ...trackedIssue,
+                    delegatedToPatchRelay: syncedIssue.delegatedToPatchRelay,
+                    prNumber: syncedIssue.prNumber,
+                    prUrl: syncedIssue.prUrl,
+                }
+                : syncedIssue;
             await syncActiveWorkflowState({ db: this.db, issue: syncedIssue, linear, ...(trackedIssue ? { trackedIssue } : {}), ...(options ? { options } : {}) });
             await this.agentSessions.syncSessionPlan(syncedIssue, linear, options);
-            if (shouldSyncVisibleIssueComment(trackedIssue ?? syncedIssue, Boolean(syncedIssue.agentSessionId))) {
+            if (shouldSyncVisibleIssueComment(visibleIssue, Boolean(syncedIssue.agentSessionId))) {
                 await syncVisibleStatusComment({
                     db: this.db,
                     issue: syncedIssue,