patchrelay 0.37.1 → 0.38.1

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/reactive-pr-state.js

@@ -0,0 +1,65 @@
+import { readRemotePrState } from "./remote-pr-state.js";
+export function isRequestedChangesRunType(runType) {
+    return runType === "review_fix" || runType === "branch_upkeep";
+}
+export function normalizeRemotePrState(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "OPEN")
+        return "open";
+    if (normalized === "CLOSED")
+        return "closed";
+    if (normalized === "MERGED")
+        return "merged";
+    return undefined;
+}
+export function normalizeRemoteReviewDecision(value) {
+    const normalized = value?.trim().toUpperCase();
+    if (normalized === "APPROVED")
+        return "approved";
+    if (normalized === "CHANGES_REQUESTED")
+        return "changes_requested";
+    if (normalized === "REVIEW_REQUIRED")
+        return "commented";
+    return undefined;
+}
+export function isDirtyMergeStateStatus(value) {
+    return value?.trim().toUpperCase() === "DIRTY";
+}
+export function buildReviewFixBranchUpkeepContext(prNumber, baseBranch, pr, context) {
+    const promptContext = [
+        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${String(pr.mergeStateStatus)} against latest ${baseBranch}.`,
+        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
+        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
+    ].join(" ");
+    return {
+        ...(context ?? {}),
+        branchUpkeepRequired: true,
+        reviewFixMode: "branch_upkeep",
+        wakeReason: "branch_upkeep",
+        promptContext,
+        ...(pr.mergeStateStatus ? { mergeStateStatus: pr.mergeStateStatus } : {}),
+        ...(pr.headRefOid ? { failingHeadSha: pr.headRefOid } : {}),
+        baseBranch,
+    };
+}
+export async function readReactivePrSnapshot(config, projectId, prNumber) {
+    const project = config.projects.find((entry) => entry.id === projectId);
+    const repoFullName = project?.github?.repoFullName;
+    if (!repoFullName) {
+        return undefined;
+    }
+    const pr = await readRemotePrState(repoFullName, prNumber);
+    if (!pr) {
+        return undefined;
+    }
+    return {
+        projectId,
+        repoFullName,
+        baseBranch: project?.github?.baseBranch ?? "main",
+        pr,
+        prState: normalizeRemotePrState(pr.state),
+        reviewState: normalizeRemoteReviewDecision(pr.reviewDecision),
+        headSha: pr.headRefOid,
+        gateCheckName: project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify",
+    };
+}

package/dist/reactive-run-policy.js

@@ -1,47 +1,4 @@
-import { execCommand } from "./utils.js";
-function isRequestedChangesRunType(runType) {
-    return runType === "review_fix" || runType === "branch_upkeep";
-}
-function normalizeRemotePrState(value) {
-    const normalized = value?.trim().toUpperCase();
-    if (normalized === "OPEN")
-        return "open";
-    if (normalized === "CLOSED")
-        return "closed";
-    if (normalized === "MERGED")
-        return "merged";
-    return undefined;
-}
-function normalizeRemoteReviewDecision(value) {
-    const normalized = value?.trim().toUpperCase();
-    if (normalized === "APPROVED")
-        return "approved";
-    if (normalized === "CHANGES_REQUESTED")
-        return "changes_requested";
-    if (normalized === "REVIEW_REQUIRED")
-        return "commented";
-    return undefined;
-}
-function isDirtyMergeStateStatus(value) {
-    return value?.trim().toUpperCase() === "DIRTY";
-}
-function buildReviewFixBranchUpkeepContext(prNumber, baseBranch, pr, context) {
-    const promptContext = [
-        `The requested code change may already be present, but GitHub still reports PR #${prNumber} as ${String(pr.mergeStateStatus)} against latest ${baseBranch}.`,
-        `This turn is branch upkeep on the existing PR branch: update onto latest ${baseBranch}, resolve any conflicts, rerun the narrowest relevant verification, and push a newer head.`,
-        "Do not stop just because the requested code change is already present. Review can only move forward after a new pushed head.",
-    ].join(" ");
-    return {
-        ...(context ?? {}),
-        branchUpkeepRequired: true,
-        reviewFixMode: "branch_upkeep",
-        wakeReason: "branch_upkeep",
-        promptContext,
-        ...(pr.mergeStateStatus ? { mergeStateStatus: pr.mergeStateStatus } : {}),
-        ...(pr.headRefOid ? { failingHeadSha: pr.headRefOid } : {}),
-        baseBranch,
-    };
-}
+import { buildReviewFixBranchUpkeepContext, isDirtyMergeStateStatus, isRequestedChangesRunType, readReactivePrSnapshot, } from "./reactive-pr-state.js";
 export class ReactiveRunPolicy {
     config;
     db;
@@ -60,15 +17,11 @@ export class ReactiveRunPolicy {
         if (!issue.prNumber || issue.prState !== "open" || !issue.lastGitHubFailureHeadSha) {
             return undefined;
         }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        if (!project?.github?.repoFullName) {
-            return undefined;
-        }
         try {
-            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
-            if (!pr || pr.state?.toUpperCase() !== "OPEN")
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot || snapshot.prState !== "open")
                 return undefined;
-            if (!pr.headRefOid || pr.headRefOid !== issue.lastGitHubFailureHeadSha)
+            if (!snapshot.headSha || snapshot.headSha !== issue.lastGitHubFailureHeadSha)
                 return undefined;
             return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
         }
@@ -91,18 +44,14 @@ export class ReactiveRunPolicy {
         if (!run.sourceHeadSha) {
             return `Requested-changes run finished for PR #${issue.prNumber} without a recorded starting head SHA. PatchRelay cannot verify that a new head was published.`;
         }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        if (!project?.github?.repoFullName) {
-            return undefined;
-        }
         try {
-            const pr = await this.loadRemotePrState(project.github.repoFullName, issue.prNumber);
-            if (!pr || pr.state?.toUpperCase() !== "OPEN")
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot || snapshot.prState !== "open")
                 return undefined;
-            if (!pr.headRefOid) {
+            if (!snapshot.headSha) {
                 return `Requested-changes run finished for PR #${issue.prNumber} but GitHub did not report a current head SHA.`;
             }
-            if (pr.headRefOid === run.sourceHeadSha) {
+            if (snapshot.headSha === run.sourceHeadSha) {
                 return `Requested-changes run finished for PR #${issue.prNumber} without pushing a new head; PatchRelay must not hand the same SHA back to review.`;
             }
             return undefined;
@@ -123,28 +72,20 @@ export class ReactiveRunPolicy {
         if (!issue.prNumber) {
             return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
         }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        const repoFullName = project?.github?.repoFullName;
-        if (!repoFullName) {
-            return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        }
         try {
-            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
-            if (!pr) {
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot) {
                 return this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? issue;
             }
-            const nextPrState = normalizeRemotePrState(pr.state);
-            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
-            const gateCheckName = project?.gateChecks?.find((entry) => entry.trim())?.trim() ?? "verify";
-            const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== issue.lastGitHubFailureHeadSha);
+            const headAdvanced = Boolean(snapshot.headSha && snapshot.headSha !== issue.lastGitHubFailureHeadSha);
             const reviewFixHeadAdvanced = isRequestedChangesRunType(run.runType)
-                && Boolean(pr.headRefOid && run.sourceHeadSha && pr.headRefOid !== run.sourceHeadSha);
+                && Boolean(snapshot.headSha && run.sourceHeadSha && snapshot.headSha !== run.sourceHeadSha);
             this.upsertIssueIfLeaseHeld(run.projectId, run.linearIssueId, {
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
-                ...(nextPrState ? { prState: nextPrState } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+                ...(snapshot.prState ? { prState: snapshot.prState } : {}),
+                ...(snapshot.headSha ? { prHeadSha: snapshot.headSha } : {}),
+                ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
                 ...((headAdvanced || reviewFixHeadAdvanced)
                     ? {
                         prCheckStatus: "pending",
@@ -158,8 +99,8 @@ export class ReactiveRunPolicy {
                         lastQueueIncidentJson: null,
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
-                        lastGitHubCiSnapshotHeadSha: pr.headRefOid ?? null,
-                        lastGitHubCiSnapshotGateCheckName: gateCheckName,
+                        lastGitHubCiSnapshotHeadSha: snapshot.headSha ?? null,
+                        lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName,
                         lastGitHubCiSnapshotGateCheckStatus: "pending",
                         lastGitHubCiSnapshotJson: null,
                         lastGitHubCiSnapshotSettledAt: null,
@@ -183,31 +124,24 @@ export class ReactiveRunPolicy {
         if (!issue.prNumber || issue.prState !== "open" || issue.prReviewState !== "changes_requested") {
             return context;
         }
-        const project = this.config.projects.find((entry) => entry.id === issue.projectId);
-        const repoFullName = project?.github?.repoFullName;
-        if (!repoFullName) {
-            return context;
-        }
         try {
-            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
-            if (!pr)
+            const snapshot = await readReactivePrSnapshot(this.config, issue.projectId, issue.prNumber);
+            if (!snapshot)
                 return context;
-            const nextPrState = normalizeRemotePrState(pr.state);
-            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
             this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
-                ...(nextPrState ? { prState: nextPrState } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+                ...(snapshot.prState ? { prState: snapshot.prState } : {}),
+                ...(snapshot.headSha ? { prHeadSha: snapshot.headSha } : {}),
+                ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
             }, "review-fix wake refresh");
-            if (nextPrState !== "open")
+            if (snapshot.prState !== "open")
                 return context;
-            if (nextReviewState && nextReviewState !== "changes_requested")
+            if (snapshot.reviewState && snapshot.reviewState !== "changes_requested")
                 return context;
-            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+            if (!isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus))
                 return context;
-            return buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr, context);
+            return buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr, context);
         }
         catch (error) {
             this.logger.debug({
@@ -228,34 +162,27 @@ export class ReactiveRunPolicy {
         if (issue.prReviewState !== "changes_requested") {
             return undefined;
         }
-        const project = this.config.projects.find((entry) => entry.id === run.projectId);
-        const repoFullName = project?.github?.repoFullName;
-        if (!repoFullName) {
-            return undefined;
-        }
         try {
-            const pr = await this.loadRemotePrState(repoFullName, issue.prNumber);
-            if (!pr)
+            const snapshot = await readReactivePrSnapshot(this.config, run.projectId, issue.prNumber);
+            if (!snapshot)
                 return undefined;
-            const nextPrState = normalizeRemotePrState(pr.state);
-            const nextReviewState = normalizeRemoteReviewDecision(pr.reviewDecision);
             this.upsertIssueIfLeaseHeld(issue.projectId, issue.linearIssueId, {
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
-                ...(nextPrState ? { prState: nextPrState } : {}),
-                ...(pr.headRefOid ? { prHeadSha: pr.headRefOid } : {}),
-                ...(nextReviewState ? { prReviewState: nextReviewState } : {}),
+                ...(snapshot.prState ? { prState: snapshot.prState } : {}),
+                ...(snapshot.headSha ? { prHeadSha: snapshot.headSha } : {}),
+                ...(snapshot.reviewState ? { prReviewState: snapshot.reviewState } : {}),
             }, "post-run follow-up refresh");
-            if (nextPrState !== "open")
+            if (snapshot.prState !== "open")
                 return undefined;
-            if (nextReviewState && nextReviewState !== "changes_requested")
+            if (snapshot.reviewState && snapshot.reviewState !== "changes_requested")
                 return undefined;
-            if (!isDirtyMergeStateStatus(pr.mergeStateStatus))
+            if (!isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus))
                 return undefined;
             return {
                 pendingRunType: "branch_upkeep",
                 factoryState: "changes_requested",
-                context: buildReviewFixBranchUpkeepContext(issue.prNumber, project?.github?.baseBranch ?? "main", pr),
+                context: buildReviewFixBranchUpkeepContext(issue.prNumber, snapshot.baseBranch, snapshot.pr),
                 summary: `PR #${issue.prNumber} is still dirty after review fix; queued branch upkeep`,
             };
         }
@@ -268,16 +195,6 @@ export class ReactiveRunPolicy {
             return undefined;
         }
     }
-    async loadRemotePrState(repoFullName, prNumber) {
-        const { stdout, exitCode } = await execCommand("gh", [
-            "pr", "view", String(prNumber),
-            "--repo", repoFullName,
-            "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
-        ], { timeoutMs: 10_000 });
-        if (exitCode !== 0)
-            return undefined;
-        return JSON.parse(stdout);
-    }
     upsertIssueIfLeaseHeld(projectId, linearIssueId, params, context) {
         const updated = this.withHeldLease(projectId, linearIssueId, (lease) => this.db.issueSessions.upsertIssueWithLease(lease, params));
         if (updated === undefined) {

package/dist/remote-pr-state.js

@@ -0,0 +1,11 @@
+import { execCommand } from "./utils.js";
+export async function readRemotePrState(repoFullName, prNumber) {
+    const { stdout, exitCode } = await execCommand("gh", [
+        "pr", "view", String(prNumber),
+        "--repo", repoFullName,
+        "--json", "headRefOid,state,reviewDecision,mergeStateStatus",
+    ], { timeoutMs: 10_000 });
+    if (exitCode !== 0)
+        return undefined;
+    return JSON.parse(stdout);
+}

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";
@@ -54,6 +54,20 @@ export class RunOrchestrator {
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
+    threadPorts = {
+        readThreadWithRetry: (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries),
+    };
+    leasePorts = {
+        withHeldLease: (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn),
+        releaseLease: (projectId, linearIssueId) => this.releaseIssueSessionLease(projectId, linearIssueId),
+        heartbeatLease: (projectId, linearIssueId) => this.heartbeatIssueSessionLease(projectId, linearIssueId),
+        getHeldLease: (projectId, linearIssueId) => this.getHeldIssueSessionLease(projectId, linearIssueId),
+    };
+    recoveryPorts = {
+        failRunAndClear: (run, message, nextState) => this.failRunAndClear(run, message, nextState),
+        restoreIdleWorktree: (issue) => this.restoreIdleWorktree(issue),
+        recoverOrEscalate: (issue, runType, reason) => this.recoverOrEscalate(issue, runType, reason),
+    };
     activeSessionLeases;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
@@ -66,16 +80,16 @@ export class RunOrchestrator {
         this.feed = feed;
         this.worktreeManager = new WorktreeManager(config);
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
-        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries));
+        this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry);
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
-        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, (projectId, linearIssueId, fn) => this.withHeldIssueSessionLease(projectId, linearIssueId, fn));
+        this.runCompletionPolicy = new RunCompletionPolicy(config, db, logger, this.leasePorts.withHeldLease);
         this.completionCheck = new CompletionCheckService(codex, logger);
-        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.runFinalizer = new RunFinalizer(db, logger, this.linearSync, this.enqueueIssue, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.recoveryPorts.failRunAndClear, 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.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.runNotificationHandler = new RunNotificationHandler(config, db, logger, this.linearSync, this.runFinalizer, this.threadPorts.readThreadWithRetry, this.leasePorts.withHeldLease, this.leasePorts.heartbeatLease, this.leasePorts.releaseLease, feed);
+        this.runRecovery = new RunRecoveryService(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.getHeldLease, (lease, issue, runType, context, dedupeScope) => this.appendWakeEventWithLease(lease, issue, runType, context, dedupeScope), this.leasePorts.releaseLease, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
+        this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
+        this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, feed);
         this.runWakePlanner = new RunWakePlanner(db);
         this.idleReconciler = new IdleIssueReconciler(db, config, {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
@@ -302,9 +316,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"),