patchrelay 0.37.0 → 0.38.0

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

@@ -1,6 +1,8 @@
 import { extractCompletionCheck } from "./completion-check.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
+import { isClosedPrState } from "./pr-state.js";
+import { isUndelegatedPausedIssue } from "./paused-issue-state.js";
 export async function syncVisibleStatusComment(params) {
     const { db, issue, linear, logger, trackedIssue, options } = params;
     try {
@@ -31,7 +33,12 @@ 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 (isUndelegatedPausedIssue(issue)) {
+        return true;
+    }
+    if ((issue.sessionState === "done" || issue.factoryState === "done")
+        && ((issue.prNumber === undefined && !issue.prUrl)
+            || isClosedPrState(issue.prState))) {
         return true;
     }
     return false;
@@ -44,11 +51,13 @@ function renderStatusComment(db, issue, trackedIssue, options) {
         ? (options?.activeRunType ?? activeRun?.runType)
         : undefined;
     const waitingReason = trackedIssue?.waitingReason ?? derivePatchRelayWaitingReason({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
         ...(activeRunType ? { activeRunType } : {}),
         ...(issue.activeRunId !== undefined ? { activeRunId: issue.activeRunId } : {}),
         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,
@@ -58,7 +67,15 @@ function renderStatusComment(db, issue, trackedIssue, options) {
     const lines = [
         "## PatchRelay status",
         "",
-        statusHeadline(trackedIssue ?? issue, activeRunType),
+        statusHeadline(trackedIssue
+            ? {
+                ...trackedIssue,
+                delegatedToPatchRelay: issue.delegatedToPatchRelay,
+                prNumber: issue.prNumber,
+                prReviewState: issue.prReviewState,
+                prCheckStatus: issue.prCheckStatus,
+            }
+            : issue, activeRunType),
     ];
     const statusNote = trackedIssue?.statusNote ?? deriveIssueStatusNote({ issue, latestRun, latestEvent, waitingReason });
     if (waitingReason) {
@@ -110,12 +127,36 @@ 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";
         default:
             break;
     }
+    if (!issue.delegatedToPatchRelay && issue.prNumber !== undefined) {
+        if (issue.factoryState === "awaiting_queue" || issue.prReviewState === "approved") {
+            return `PR #${issue.prNumber} is awaiting downstream merge while PatchRelay is paused`;
+        }
+        if (issue.factoryState === "changes_requested" || issue.prReviewState === "changes_requested") {
+            return `PR #${issue.prNumber} has requested changes while PatchRelay is paused`;
+        }
+        if (issue.factoryState === "repairing_ci" || issue.prCheckStatus === "failed" || issue.prCheckStatus === "failure") {
+            return `PR #${issue.prNumber} has failing CI while PatchRelay is paused`;
+        }
+        return `PR #${issue.prNumber} is awaiting review while PatchRelay is paused`;
+    }
+    if (!issue.delegatedToPatchRelay) {
+        if (issue.factoryState === "implementing") {
+            return "Implementation is paused because the issue is undelegated";
+        }
+        if (issue.factoryState === "delegated") {
+            return "Queued to start work while PatchRelay is paused";
+        }
+    }
     switch (issue.factoryState) {
         case "delegated":
             return "Queued to start work";
@@ -138,6 +179,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/linear-workflow-state-sync.js

@@ -53,14 +53,14 @@ function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIss
         || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
         return resolvePreferredHumanNeededLinearState(liveIssue);
     }
-    const activelyWorking = issue.activeRunId !== undefined
+    const activelyWorking = issue.delegatedToPatchRelay !== false && (issue.activeRunId !== undefined
         || options?.activeRunType !== undefined
         || trackedIssue?.sessionState === "running"
         || issue.factoryState === "delegated"
         || issue.factoryState === "implementing"
         || issue.factoryState === "changes_requested"
         || issue.factoryState === "repairing_ci"
-        || issue.factoryState === "repairing_queue";
+        || issue.factoryState === "repairing_queue");
     if (activelyWorking) {
         return resolvePreferredImplementingLinearState(liveIssue);
     }

package/dist/operator-retry-event.js

@@ -9,7 +9,7 @@ function parseObjectJson(value) {
         return undefined;
     }
 }
-export function buildOperatorRetryEvent(issue, runType) {
+export function buildOperatorRetryEvent(issue, runType, source = "operator_retry") {
     if (runType === "queue_repair") {
         const queueIncident = parseObjectJson(issue.lastQueueIncidentJson);
         const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson);
@@ -18,9 +18,9 @@ export function buildOperatorRetryEvent(issue, runType) {
             eventJson: JSON.stringify({
                 ...(queueIncident ?? {}),
                 ...(failureContext ?? {}),
-                source: "operator_retry",
+                source,
             }),
-            dedupeKey: `operator_retry:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
+            dedupeKey: `${source}:queue_repair:${issue.linearIssueId}:${issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown-sha"}`,
         };
     }
     if (runType === "ci_repair") {
@@ -29,9 +29,9 @@ export function buildOperatorRetryEvent(issue, runType) {
             eventType: "settled_red_ci",
             eventJson: JSON.stringify({
                 ...(failureContext ?? {}),
-                source: "operator_retry",
+                source,
             }),
-            dedupeKey: `operator_retry:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
+            dedupeKey: `${source}:ci_repair:${issue.linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? "unknown-sha"}`,
         };
     }
     if (runType === "review_fix" || runType === "branch_upkeep") {
@@ -39,20 +39,23 @@ export function buildOperatorRetryEvent(issue, runType) {
             eventType: "review_changes_requested",
             eventJson: JSON.stringify({
                 reviewBody: runType === "branch_upkeep"
-                    ? "Operator requested retry of branch upkeep after requested changes."
-                    : "Operator requested retry of review-fix work.",
+                    ? `${humanizeSource(source)} requested retry of branch upkeep after requested changes.`
+                    : `${humanizeSource(source)} requested retry of review-fix work.`,
                 ...(runType === "branch_upkeep" ? { branchUpkeepRequired: true, wakeReason: "branch_upkeep" } : {}),
-                source: "operator_retry",
+                source,
             }),
-            dedupeKey: `operator_retry:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
+            dedupeKey: `${source}:${runType}:${issue.linearIssueId}:${issue.prHeadSha ?? "unknown-sha"}`,
         };
     }
     return {
         eventType: "delegated",
         eventJson: JSON.stringify({
-            promptContext: "Operator requested retry of PatchRelay work.",
-            source: "operator_retry",
+            promptContext: `${humanizeSource(source)} requested PatchRelay work resume.`,
+            source,
         }),
-        dedupeKey: `operator_retry:implementation:${issue.linearIssueId}`,
+        dedupeKey: `${source}:implementation:${issue.linearIssueId}`,
     };
 }
+function humanizeSource(source) {
+    return source.replaceAll("_", " ");
+}

package/dist/paused-issue-state.js

@@ -0,0 +1,24 @@
+import { resolveAwaitingInputReason } from "./awaiting-input-reason.js";
+export function isUndelegatedPausedIssue(issue) {
+    return issue.delegatedToPatchRelay === false
+        && issue.factoryState !== "done"
+        && issue.factoryState !== "failed"
+        && issue.factoryState !== "escalated";
+}
+export function isUndelegatedPausedNoPrWork(issue) {
+    return isUndelegatedPausedIssue(issue)
+        && issue.prNumber === undefined
+        && (issue.factoryState === "delegated" || issue.factoryState === "implementing");
+}
+export function isResumablePausedLocalWork(params) {
+    if (params.issue.delegatedToPatchRelay === false) {
+        return false;
+    }
+    if (params.issue.prNumber !== undefined) {
+        return false;
+    }
+    if (params.issue.factoryState === "delegated" || params.issue.factoryState === "implementing") {
+        return true;
+    }
+    return resolveAwaitingInputReason(params) === "paused_local_work";
+}

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/run-launcher.js

@@ -106,7 +106,6 @@ export class RunLauncher {
             });
             this.db.issueSessions.consumeIssueSessionEvents(params.item.projectId, params.item.issueId, freshWake.eventIds, created.id);
             this.db.issueSessions.setIssueSessionLastWakeReason(params.item.projectId, params.item.issueId, freshWake.wakeReason ?? null);
-            this.db.issueSessions.setBranchOwnerWithLease({ projectId: params.item.projectId, linearIssueId: params.item.issueId, leaseId: params.leaseId }, "patchrelay");
             return created;
         });
     }

package/dist/run-orchestrator.js

@@ -4,7 +4,7 @@ import { CompletionCheckService } from "./completion-check.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { MergedLinearCompletionReconciler } from "./merged-linear-completion-reconciler.js";
 import { QueueHealthMonitor } from "./queue-health-monitor.js";
-import { IdleIssueReconciler, resolveBranchOwnerForStateTransition } from "./idle-reconciliation.js";
+import { IdleIssueReconciler } from "./idle-reconciliation.js";
 import { LinearSessionSync } from "./linear-session-sync.js";
 import { IssueSessionLeaseService } from "./issue-session-lease-service.js";
 import { InterruptedRunRecovery } from "./interrupted-run-recovery.js";
@@ -73,7 +73,7 @@ export class RunOrchestrator {
         this.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (run, message, nextState) => this.failRunAndClear(run, message, nextState), this.runCompletionPolicy, this.completionCheck, feed);
         this.runLauncher = new RunLauncher(config, db, codex, logger, this.worktreeManager);
         this.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), feed);
-        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), (newState, pendingRunType) => this.resolveBranchOwnerForStateTransition(newState, pendingRunType), feed);
+        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId), (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (run, message, nextState) => this.failRunAndClear(run, message, nextState), (issue) => this.restoreIdleWorktree(issue), this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn), (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId), (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries), (issue, runType, reason) => this.recoverOrEscalate(issue, runType, reason), feed);
         this.runWakePlanner = new RunWakePlanner(db);
@@ -302,9 +302,6 @@ export class RunOrchestrator {
             nextState,
         });
     }
-    resolveBranchOwnerForStateTransition(newState, pendingRunType) {
-        return resolveBranchOwnerForStateTransition(newState, pendingRunType);
-    }
     async resolveRequestedChangesWakeContext(issue, runType, context) {
         return await this.runCompletionPolicy.resolveRequestedChangesWakeContext(issue, runType, context);
     }

package/dist/run-reconciler.js

@@ -31,6 +31,16 @@ export class RunReconciler {
     async reconcile(params) {
         const { run, issue, recoveryLease } = params;
         const acquiredRecoveryLease = recoveryLease === true;
+        if (!issue.delegatedToPatchRelay) {
+            this.withHeldLease(run.projectId, run.linearIssueId, () => {
+                this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue was un-delegated during active run" });
+                this.db.issues.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null, factoryState: issue.factoryState });
+            });
+            const pausedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            void this.linearSync.syncSession(pausedIssue, { activeRunType: run.runType });
+            this.releaseLease(run.projectId, run.linearIssueId);
+            return;
+        }
         if (TERMINAL_STATES.has(issue.factoryState)) {
             this.withHeldLease(run.projectId, run.linearIssueId, () => {
                 this.db.runs.finishRun(run.id, { status: "released", failureReason: "Issue reached terminal state during active run" });

package/dist/run-recovery-service.js

@@ -10,9 +10,8 @@ export class RunRecoveryService {
     appendWakeEventWithLease;
     releaseLease;
     enqueueIssue;
-    resolveBranchOwnerForStateTransition;
     feed;
-    constructor(db, logger, linearSync, withHeldLease, getHeldLease, appendWakeEventWithLease, releaseLease, enqueueIssue, resolveBranchOwnerForStateTransition, feed) {
+    constructor(db, logger, linearSync, withHeldLease, getHeldLease, appendWakeEventWithLease, releaseLease, enqueueIssue, feed) {
         this.db = db;
         this.logger = logger;
         this.linearSync = linearSync;
@@ -21,7 +20,6 @@ export class RunRecoveryService {
         this.appendWakeEventWithLease = appendWakeEventWithLease;
         this.releaseLease = releaseLease;
         this.enqueueIssue = enqueueIssue;
-        this.resolveBranchOwnerForStateTransition = resolveBranchOwnerForStateTransition;
         this.feed = feed;
     }
     recoverOrEscalate(params) {
@@ -189,13 +187,6 @@ export class RunRecoveryService {
                 activeRunId: null,
                 factoryState: nextState,
             });
-            const branchOwner = this.resolveBranchOwnerForStateTransition(nextState);
-            if (branchOwner) {
-                const heldLease = this.getHeldLease(run.projectId, run.linearIssueId);
-                if (heldLease) {
-                    this.db.issueSessions.setBranchOwnerWithLease(heldLease, branchOwner);
-                }
-            }
             return true;
         });
         if (!updated) {

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;
@@ -16,6 +17,9 @@ export class ServiceIssueActions {
         const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
+        if (!issue.delegatedToPatchRelay && !issue.activeRunId) {
+            return { error: "Issue is undelegated from PatchRelay; delegate it again before prompting work" };
+        }
         this.feed.publish({
             level: "info",
             kind: "comment",
@@ -94,6 +98,8 @@ export class ServiceIssueActions {
         const issue = this.db.issues.getIssueByKey(issueKey);
         if (!issue)
             return undefined;
+        if (!issue.delegatedToPatchRelay)
+            return { error: "Issue is undelegated from PatchRelay; delegate it again before retrying" };
         if (issue.activeRunId)
             return { error: "Issue already has an active run" };
         const issueSession = this.db.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId);
@@ -107,21 +113,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/service-startup-recovery.js

@@ -1,3 +1,4 @@
+import { isResumablePausedLocalWork } from "./paused-issue-state.js";
 export class ServiceStartupRecovery {
     db;
     linearProvider;
@@ -65,12 +66,14 @@ export class ServiceStartupRecovery {
             });
             const delegated = liveIssue.delegateId === installation.actorId;
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
-            const shouldRecoverAwaitingInput = delegated
-                && issue.factoryState === "awaiting_input"
+            const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+            const shouldRecoverPausedLocalWork = delegated
+                && isResumablePausedLocalWork({ issue, latestRun })
                 && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
             const updated = this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
+                delegatedToPatchRelay: delegated,
                 ...(liveIssue.identifier ? { issueKey: liveIssue.identifier } : {}),
                 ...(liveIssue.title ? { title: liveIssue.title } : {}),
                 ...(liveIssue.description ? { description: liveIssue.description } : {}),
@@ -79,9 +82,9 @@ export class ServiceStartupRecovery {
                 ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
                 ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
                 ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                ...(shouldRecoverAwaitingInput ? { factoryState: "delegated" } : {}),
+                ...(shouldRecoverPausedLocalWork ? { factoryState: "delegated" } : {}),
             });
-            if (!shouldRecoverAwaitingInput) {
+            if (!shouldRecoverPausedLocalWork) {
                 continue;
             }
             if (unresolvedBlockers === 0) {
@@ -94,10 +97,10 @@ export class ServiceStartupRecovery {
                 if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
                     this.enqueueIssue(issue.projectId, issue.linearIssueId);
                 }
-                this.logger.info({ issueKey: updated.issueKey }, "Recovered delegated issue from stale awaiting_input state and re-queued implementation");
+                this.logger.info({ issueKey: updated.issueKey }, "Recovered delegated issue from paused local-work state and re-queued implementation");
             }
             else {
-                this.logger.info({ issueKey: updated.issueKey, unresolvedBlockers }, "Recovered delegated blocked issue from stale awaiting_input state");
+                this.logger.info({ issueKey: updated.issueKey, unresolvedBlockers }, "Recovered delegated blocked issue from paused local-work state");
             }
         }
     }

package/dist/service.js

@@ -103,7 +103,6 @@ export class PatchRelayService {
             const identity = this.githubAppTokenManager.botIdentity();
             if (identity) {
                 this.orchestrator.botIdentity = identity;
-                this.githubWebhookHandler.setPatchRelayAuthorLogins([identity.name]);
             }
         }
         await this.runtime.start();

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

@@ -80,9 +80,9 @@ export class TrackedIssueListQuery {
         const rows = this.db.connection
             .prepare(`SELECT
           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.current_linear_state, i.factory_state, i.delegated_to_patchrelay, 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,
@@ -157,6 +157,7 @@ export class TrackedIssueListQuery {
             const readyForExecution = isIssueSessionReadyForExecution({
                 ...(typeof row.session_state === "string" ? { sessionState: String(row.session_state) } : {}),
                 factoryState: String(row.factory_state ?? "delegated"),
+                ...(row.delegated_to_patchrelay !== null ? { delegatedToPatchRelay: Number(row.delegated_to_patchrelay) !== 0 } : {}),
                 ...(row.active_run_type !== null ? { activeRunId: 1 } : {}),
                 blockedByCount,
                 hasPendingWake,
@@ -175,11 +176,13 @@ export class TrackedIssueListQuery {
                 ? row.summary_text
                 : undefined;
             const waitingReason = sessionWaitingReason ?? derivePatchRelayWaitingReason({
+                ...(row.delegated_to_patchrelay !== null ? { delegatedToPatchRelay: Number(row.delegated_to_patchrelay) !== 0 } : {}),
                 ...(row.active_run_type !== null ? { activeRunType: String(row.active_run_type) } : {}),
                 blockedByKeys,
                 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 +245,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

@@ -10,11 +10,13 @@ export function buildTrackedIssueRecord(params) {
     const failureContext = parseGitHubFailureContext(params.issue.lastGitHubFailureContextJson);
     const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
     const waitingReason = derivePatchRelayWaitingReason({
+        delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
         ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
         blockedByKeys,
         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,
@@ -39,6 +41,7 @@ export function buildTrackedIssueRecord(params) {
         id: params.issue.id,
         projectId: params.issue.projectId,
         linearIssueId: params.issue.linearIssueId,
+        delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
         ...(params.issue.issueKey ? { issueKey: params.issue.issueKey } : {}),
         ...(params.issue.title ? { title: params.issue.title } : {}),
         ...(params.issue.url ? { issueUrl: params.issue.url } : {}),
@@ -46,11 +49,16 @@ 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({
             sessionState: params.session?.sessionState,
             factoryState: params.issue.factoryState,
+            delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
             activeRunId: params.issue.activeRunId,
             blockedByCount: unresolvedBlockedBy.length,
             hasPendingWake: params.hasPendingWake,

package/dist/waiting-reason.js

@@ -1,5 +1,8 @@
+import { hasOpenPr } from "./pr-state.js";
 export const PATCHRELAY_WAITING_REASONS = {
     activeWork: "PatchRelay is actively working",
+    automationPaused: "PatchRelay automation is paused because the issue is undelegated",
+    automationPausedDownstream: "PatchRelay automation is paused; downstream merge may still continue until the PR is closed",
     finalizingPublishedPr: "PatchRelay is finalizing a published PR",
     finalizingMergedChange: "PatchRelay is finalizing a merged change",
     waitingForOperatorInput: "Waiting on operator input",
@@ -13,8 +16,13 @@ export const PATCHRELAY_WAITING_REASONS = {
     waitingForExternalReview: "Waiting on external review",
 };
 export function derivePatchRelayWaitingReason(params) {
+    if (params.delegatedToPatchRelay === false && params.factoryState !== "done" && params.factoryState !== "failed" && params.factoryState !== "escalated") {
+        return params.factoryState === "awaiting_queue" || (hasLiveOpenPr(params.prNumber, params.prState) && params.prReviewState === "approved")
+            ? PATCHRELAY_WAITING_REASONS.automationPausedDownstream
+            : PATCHRELAY_WAITING_REASONS.automationPaused;
+    }
     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 +74,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) {
@@ -77,3 +85,6 @@ export function derivePatchRelayWaitingReason(params) {
 function humanize(value) {
     return value.replaceAll("_", " ");
 }
+function hasLiveOpenPr(prNumber, prState) {
+    return prNumber !== undefined && (prState === undefined || prState === "open");
+}

package/dist/webhooks/agent-session-handler.js

@@ -26,6 +26,7 @@ export class AgentSessionHandler {
             return;
         const existingIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
+        const automationEnabled = delegated || existingIssue?.delegatedToPatchRelay === true;
         if (normalized.triggerEvent === "agentSessionCreated") {
             if (!delegated) {
                 const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
@@ -70,6 +71,13 @@ export class AgentSessionHandler {
         if (!triggerEventAllowed(project, normalized.triggerEvent))
             return;
         const promptBody = normalized.agentSession.promptBody?.trim();
+        if (!automationEnabled && promptBody && existingIssue) {
+            await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                type: "thought",
+                body: "PatchRelay is paused because the issue is undelegated.",
+            }, { ephemeral: true });
+            return;
+        }
         if (activeRun && promptBody && activeRun.threadId && activeRun.turnId) {
             const input = `New Linear agent prompt received while you are working.\n\n${promptBody}`;
             try {
@@ -99,7 +107,7 @@ export class AgentSessionHandler {
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
             return;
         }
-        if (promptBody && existingIssue && (delegated || existingIssue.factoryState === "awaiting_input")) {
+        if (promptBody && existingIssue && automationEnabled) {
             const hadPendingWake = this.db.issueSessions.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
             const directReply = params.isDirectReplyToOutstandingQuestion(existingIssue);
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {

package/dist/webhooks/comment-wake-handler.js

@@ -40,6 +40,18 @@ export class CommentWakeHandler {
             });
             return;
         }
+        if (!issue.delegatedToPatchRelay) {
+            this.feed?.publish({
+                level: "info",
+                kind: "comment",
+                projectId: project.id,
+                issueKey: trackedIssue?.issueKey,
+                status: "ignored_undelegated",
+                summary: "Ignored comment because the issue is undelegated",
+                detail: trimmedBody.slice(0, 200),
+            });
+            return;
+        }
         if (!issue.activeRunId) {
             if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
                 const directReply = params.isDirectReplyToOutstandingQuestion(issue);