patchrelay 0.37.1 → 0.38.0

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/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

@@ -17,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",
@@ -95,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);

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,7 +80,7 @@ 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_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,
@@ -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,6 +176,7 @@ 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"),

package/dist/tracked-issue-projector.js

@@ -10,6 +10,7 @@ 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,
@@ -40,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 } : {}),
@@ -56,6 +58,7 @@ export function buildTrackedIssueRecord(params) {
         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,6 +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",
@@ -14,6 +16,11 @@ 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 (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
             return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
@@ -78,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);

package/dist/webhooks/decision-helpers.js

@@ -1,4 +1,5 @@
 import { TERMINAL_STATES } from "../factory-state.js";
+import { deriveIssueSessionReactiveIntent } from "../issue-session.js";
 export function decideRunIntent(p) {
     const wakeEligibleState = p.currentState === undefined
         || p.currentState === "delegated"
@@ -26,10 +27,50 @@ export function decideUnDelegation(p) {
         return { clearPending: false };
     if (!p.currentState)
         return { clearPending: false };
-    const pastNoReturn = p.currentState === "awaiting_queue" || TERMINAL_STATES.has(p.currentState);
-    if (pastNoReturn)
+    if (TERMINAL_STATES.has(p.currentState))
         return { clearPending: false };
-    return { factoryState: "awaiting_input", clearPending: true };
+    return { factoryState: p.currentState, clearPending: true };
+}
+export function resolveReDelegationResume(p) {
+    if (!p.delegated || p.previouslyDelegated !== false) {
+        return {};
+    }
+    if (p.prState === "merged") {
+        return { factoryState: "done", pendingRunType: null };
+    }
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: true,
+        prNumber: p.prNumber,
+        prState: p.prState,
+        prReviewState: p.prReviewState,
+        prCheckStatus: p.prCheckStatus,
+        latestFailureSource: p.latestFailureSource,
+    });
+    if (reactiveIntent) {
+        return {
+            factoryState: reactiveIntent.compatibilityFactoryState,
+            pendingRunType: reactiveIntent.runType,
+        };
+    }
+    if (p.prNumber !== undefined && (p.prState === undefined || p.prState === "open")) {
+        if (p.prReviewState === "approved") {
+            return { factoryState: "awaiting_queue", pendingRunType: null };
+        }
+        return { factoryState: "pr_open", pendingRunType: null };
+    }
+    if (p.currentState === "awaiting_input" && p.awaitingInputReason === "completion_check_question") {
+        return {
+            factoryState: "awaiting_input",
+            pendingRunType: null,
+        };
+    }
+    if (p.currentState === "awaiting_input" || p.currentState === "delegated" || p.currentState === "implementing") {
+        return {
+            factoryState: "delegated",
+            pendingRunType: (p.unresolvedBlockers ?? 0) === 0 ? "implementation" : null,
+        };
+    }
+    return {};
 }
 export function decideAgentSession(p) {
     if (p.sessionId)

package/dist/webhooks/dependency-readiness-handler.js

@@ -27,6 +27,7 @@ export class DependencyReadinessHandler {
                 continue;
             }
             if (issue.factoryState !== "delegated"
+                || !issue.delegatedToPatchRelay
                 || issue.activeRunId !== undefined
                 || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                 continue;

package/dist/webhooks/desired-stage-recorder.js

@@ -1,5 +1,7 @@
 import { triggerEventAllowed } from "../project-resolution.js";
-import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, } from "./decision-helpers.js";
+import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
+import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
+import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -16,6 +18,7 @@ export class DesiredStageRecorder {
         }
         const existingIssue = this.db.issues.getIssue(params.project.id, normalizedIssue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
+        const latestRun = existingIssue ? this.db.runs.getLatestRunForIssue(params.project.id, normalizedIssue.id) : undefined;
         const delegated = this.isDelegatedToPatchRelay(params.project, params.normalized);
         const triggerAllowed = triggerEventAllowed(params.project, params.normalized.triggerEvent);
         const incomingAgentSessionId = params.normalized.agentSession?.id;
@@ -46,11 +49,22 @@ export class DesiredStageRecorder {
             triggerEvent: params.normalized.triggerEvent,
             delegated,
             currentState: existingIssue?.factoryState,
+            hasPr: existingIssue?.prNumber !== undefined && existingIssue?.prState !== "merged",
+        });
+        const reDelegationResume = resolveReDelegationResume({
+            delegated,
+            previouslyDelegated: existingIssue?.delegatedToPatchRelay,
+            currentState: existingIssue?.factoryState,
+            awaitingInputReason: existingIssue
+                ? resolveAwaitingInputReason({ issue: existingIssue, latestRun })
+                : undefined,
+            unresolvedBlockers,
+            prNumber: existingIssue?.prNumber,
+            prState: existingIssue?.prState,
+            prReviewState: existingIssue?.prReviewState,
+            prCheckStatus: existingIssue?.prCheckStatus,
+            latestFailureSource: existingIssue?.lastGitHubFailureSource,
         });
-        const delegatedStateRecovery = delegated
-            && !terminal
-            && existingIssue?.factoryState === "awaiting_input"
-            && !undelegation.factoryState;
         const existingWakeRunType = existingIssue
             ? params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id)
             : undefined;
@@ -73,9 +87,13 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
                 ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
+                delegatedToPatchRelay: delegated,
                 ...(!existingIssue && !delegated && incomingAgentSessionId ? { factoryState: "awaiting_input" } : {}),
-                ...(delegatedStateRecovery ? { factoryState: "delegated" } : {}),
-                ...(desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
+                ...(reDelegationResume.factoryState ? { factoryState: reDelegationResume.factoryState } : {}),
+                ...(reDelegationResume.pendingRunType !== undefined
+                    ? { pendingRunType: null, pendingRunContextJson: null }
+                    : {}),
+                ...(!reDelegationResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
                 ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(agentSessionId !== undefined ? { agentSessionId } : {}),
                 ...(runRelease.release ? { activeRunId: null } : {}),
@@ -111,12 +129,24 @@ export class DesiredStageRecorder {
                 kind: "stage",
                 issueKey: issue.issueKey,
                 projectId: params.project.id,
-                stage: "awaiting_input",
+                stage: issue.factoryState,
                 status: "un_delegated",
-                summary: "Issue un-delegated from PatchRelay",
+                summary: issue.factoryState === "awaiting_input"
+                    ? "Issue un-delegated from PatchRelay"
+                    : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
+            });
+        }
+        else if (reDelegationResume.pendingRunType) {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
+                projectId: params.project.id,
+                linearIssueId: normalizedIssue.id,
+                ...buildOperatorRetryEvent(issue, reDelegationResume.pendingRunType, "re_delegated"),
             });
         }
-        else if (desiredStage === "implementation"
+        else if (!reDelegationResume.factoryState
+            && !reDelegationResume.pendingRunType
+            &&
+                desiredStage === "implementation"
             && params.normalized.triggerEvent !== "commentCreated"
             && params.normalized.triggerEvent !== "commentUpdated"
             && params.normalized.triggerEvent !== "agentPrompted") {

package/package.json

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