patchrelay 0.37.1 → 0.38.1

package/dist/github-webhook-terminal-handler.js

@@ -0,0 +1,111 @@
+import { resolveClosedPrDisposition, resolveClosedPrFactoryState } from "./pr-state.js";
+import { resolvePreferredCompletedLinearState } from "./linear-workflow.js";
+import { syncGitHubLinearSession } from "./github-linear-session-sync.js";
+export async function handleGitHubTerminalPrEvent(params) {
+    const { db, linearProvider, enqueueIssue, logger, codex, issue, event, config } = params;
+    const eventType = event.triggerEvent === "pr_merged" ? "pr_merged" : "pr_closed";
+    db.issueSessions.appendIssueSessionEvent({
+        projectId: issue.projectId,
+        linearIssueId: issue.linearIssueId,
+        eventType,
+        dedupeKey: [eventType, issue.prNumber ?? event.prNumber ?? "unknown-pr", issue.prHeadSha ?? event.headSha ?? "unknown-sha"].join("::"),
+    });
+    db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    const run = issue.activeRunId ? db.runs.getRunById(issue.activeRunId) : undefined;
+    if (run?.threadId && run.turnId) {
+        try {
+            await codex.steerTurn({
+                threadId: run.threadId,
+                turnId: run.turnId,
+                input: event.triggerEvent === "pr_merged"
+                    ? "STOP: The pull request has already merged. Stop working immediately and exit without making further changes."
+                    : "STOP: The pull request was closed. Stop working immediately and exit without making further changes.",
+            });
+        }
+        catch (error) {
+            logger.warn({ issueKey: issue.issueKey, runId: run.id, error: error instanceof Error ? error.message : String(error) }, "Failed to steer active run after terminal PR event");
+        }
+    }
+    const commitTerminalUpdate = () => {
+        if (run) {
+            db.runs.finishRun(run.id, {
+                status: "released",
+                failureReason: event.triggerEvent === "pr_merged"
+                    ? "Pull request merged during active run"
+                    : "Pull request closed during active run",
+            });
+        }
+        const terminalFactoryState = event.triggerEvent === "pr_merged"
+            ? "done"
+            : resolveClosedPrFactoryState(issue);
+        db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            activeRunId: null,
+            factoryState: terminalFactoryState,
+        });
+    };
+    const activeLease = db.issueSessions.getActiveIssueSessionLease(issue.projectId, issue.linearIssueId);
+    if (activeLease) {
+        db.issueSessions.withIssueSessionLease(issue.projectId, issue.linearIssueId, activeLease.leaseId, commitTerminalUpdate);
+    }
+    else {
+        db.transaction(commitTerminalUpdate);
+    }
+    db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    const updatedIssue = db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+    if (event.triggerEvent === "pr_closed" && resolveClosedPrDisposition(issue) === "redelegate") {
+        db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            eventType: "delegated",
+            dedupeKey: `github_pr_closed:implementation:${issue.linearIssueId}`,
+        });
+        if (db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+            enqueueIssue(issue.projectId, issue.linearIssueId);
+        }
+    }
+    if (event.triggerEvent === "pr_merged") {
+        await completeLinearIssueAfterMerge(params, updatedIssue);
+    }
+    void syncGitHubLinearSession({
+        config,
+        linearProvider,
+        logger,
+        issue: updatedIssue,
+    });
+}
+async function completeLinearIssueAfterMerge(params, issue) {
+    const linear = await params.linearProvider.forProject(issue.projectId).catch(() => undefined);
+    if (!linear)
+        return;
+    try {
+        const liveIssue = await linear.getIssue(issue.linearIssueId);
+        const targetState = resolvePreferredCompletedLinearState(liveIssue);
+        if (!targetState) {
+            params.logger.warn({ issueKey: issue.issueKey }, "Could not find a completed Linear workflow state after merge");
+            return;
+        }
+        const normalizedCurrent = liveIssue.stateName?.trim().toLowerCase();
+        if (normalizedCurrent === targetState.trim().toLowerCase()) {
+            params.db.issues.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
+                ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
+            });
+            return;
+        }
+        const updated = await linear.setIssueState(issue.linearIssueId, targetState);
+        params.db.issues.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            ...(updated.stateName ? { currentLinearState: updated.stateName } : {}),
+            ...(updated.stateType ? { currentLinearStateType: updated.stateType } : {}),
+        });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        params.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to move merged issue to a completed Linear state");
+    }
+}

package/dist/github-webhooks.js

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

package/dist/idle-reconciliation.js

@@ -1,4 +1,3 @@
-import {} from "./factory-state.js";
 import { resolveMergeQueueProtocol } from "./merge-queue-protocol.js";
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { deriveGateCheckStatusFromRollup } from "./github-rollup.js";
@@ -90,15 +89,6 @@ function hasFailureProvenance(issue) {
         || issue.lastAttemptedFailureHeadSha
         || issue.lastAttemptedFailureSignature);
 }
-export function resolveBranchOwnerForStateTransition(newState, pendingRunType) {
-    if (pendingRunType)
-        return "patchrelay";
-    if (newState === "awaiting_queue")
-        return "patchrelay";
-    if (newState === "repairing_ci" || newState === "repairing_queue")
-        return "patchrelay";
-    return undefined;
-}
 export class IdleIssueReconciler {
     db;
     config;
@@ -154,6 +144,8 @@ export class IdleIssueReconciler {
             await this.reconcileFromGitHub(issue);
         }
         for (const issue of this.db.issues.listBlockedDelegatedIssues()) {
+            if (!issue.delegatedToPatchRelay)
+                continue;
             const unresolved = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             if (unresolved === 0) {
                 this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
@@ -207,10 +199,6 @@ export class IdleIssueReconciler {
                 }
                 : {}),
         });
-        const branchOwner = resolveBranchOwnerForStateTransition(newState, options?.pendingRunType);
-        if (branchOwner) {
-            this.db.issues.setBranchOwner(issue.projectId, issue.linearIssueId, branchOwner);
-        }
         if (options?.pendingRunType) {
             this.appendWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
         }
@@ -255,6 +243,9 @@ export class IdleIssueReconciler {
         });
     }
     async routeFailedIssue(issue) {
+        if (!issue.delegatedToPatchRelay) {
+            return;
+        }
         issue = await this.refreshMissingFailureProvenance(issue);
         issue = await this.reclassifyStaleBranchFailure(issue);
         const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
@@ -457,11 +448,17 @@ export class IdleIssueReconciler {
                     this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, factoryState: issue.factoryState }, "Reconciliation: PR was closed on a terminal issue; preserving terminal state");
                     return;
                 }
-                this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed on unfinished work, re-delegating for implementation");
-                this.advanceIdleIssue(issue, "delegated", {
-                    pendingRunType: "implementation",
-                    clearFailureProvenance: true,
-                });
+                if (issue.delegatedToPatchRelay) {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed on unfinished delegated work, re-delegating for implementation");
+                    this.advanceIdleIssue(issue, "delegated", {
+                        pendingRunType: "implementation",
+                        clearFailureProvenance: true,
+                    });
+                }
+                else {
+                    this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber }, "Reconciliation: PR was closed while undelegated; preserving paused local-work state");
+                    this.advanceIdleIssue(issue, "delegated", { clearFailureProvenance: true });
+                }
                 return;
             }
             const headAdvanced = Boolean(pr.headRefOid && pr.headRefOid !== previousHeadSha);
@@ -481,7 +478,8 @@ export class IdleIssueReconciler {
                     return;
                 }
             }
-            if (isReviewDecisionReviewRequired(pr.reviewDecision)
+            if (issue.delegatedToPatchRelay
+                && isReviewDecisionReviewRequired(pr.reviewDecision)
                 && gateCheckStatus === "success"
                 && hasCompletedReviewQuillVerdict(pr.statusCheckRollup)) {
                 this.logger.warn({ issueKey: issue.issueKey, prNumber: issue.prNumber, reviewDecision: pr.reviewDecision }, "Reconciliation: review-quill completed without a decisive GitHub review; escalating for operator input");
@@ -509,7 +507,8 @@ export class IdleIssueReconciler {
                 mergeConflictDetected,
                 downstreamOwned,
             });
-            if ((issue.factoryState === "escalated" || issue.factoryState === "failed")
+            if (issue.delegatedToPatchRelay
+                && (issue.factoryState === "escalated" || issue.factoryState === "failed")
                 && (reactiveIntent?.runType === "review_fix" || reactiveIntent?.runType === "branch_upkeep")) {
                 if (issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
                     this.logger.debug({
@@ -538,7 +537,7 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
-            if (reactiveIntent?.runType === "branch_upkeep" && mergeConflictDetected) {
+            if (issue.delegatedToPatchRelay && reactiveIntent?.runType === "branch_upkeep" && mergeConflictDetected) {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable, mergeStateStatus: pr.mergeStateStatus }, "Reconciliation: PR still needs branch upkeep after requested changes");
                 this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
                     pendingRunType: reactiveIntent.runType,
@@ -555,7 +554,7 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
-            if (reactiveIntent?.runType === "queue_repair" && mergeConflictDetected) {
+            if (issue.delegatedToPatchRelay && reactiveIntent?.runType === "queue_repair" && mergeConflictDetected) {
                 this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, mergeable: pr.mergeable }, "Reconciliation: PR needs queue repair from fresh GitHub truth");
                 this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
                     pendingRunType: reactiveIntent.runType,

package/dist/issue-overview-query.js

@@ -1,5 +1,6 @@
 import { parseGitHubFailureContext } from "./github-failure-context.js";
 import { isIssueSessionReadyForExecution } from "./issue-session.js";
+import { getLegacyIssueOverview } from "./legacy-issue-overview.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 export function parseStageReport(reportJson, runStatus) {
@@ -25,7 +26,13 @@ export class IssueOverviewQuery {
     async getIssueOverview(issueKey) {
         const session = this.db.issueSessions.getIssueSessionByKey(issueKey);
         if (!session) {
-            return await this.getLegacyIssueOverview(issueKey);
+            return await getLegacyIssueOverview({
+                db: this.db,
+                issueKey,
+                runStatusProvider: this.runStatusProvider,
+                buildRuns: (projectId, linearIssueId) => this.buildRuns(projectId, linearIssueId),
+                readLiveThread: (run) => this.readLiveThread(run),
+            });
         }
         return await this.getSessionIssueOverview(issueKey, session);
     }
@@ -66,62 +73,6 @@ export class IssueOverviewQuery {
             })(),
         }));
     }
-    async getLegacyIssueOverview(issueKey) {
-        const legacy = this.db.getIssueOverview(issueKey);
-        if (!legacy)
-            return undefined;
-        const issueRecord = this.db.issues.getIssueByKey(issueKey);
-        const activeStatus = await this.runStatusProvider.getActiveRunStatus(issueKey);
-        const activeRun = activeStatus?.run ?? legacy.activeRun;
-        const latestRun = this.db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
-        const latestEvent = this.db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
-        const runs = this.buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
-        const runCount = runs.length;
-        const liveThread = await this.readLiveThread(activeRun);
-        const statusNote = issueRecord
-            ? deriveIssueStatusNote({
-                issue: issueRecord,
-                latestRun,
-                latestEvent,
-                failureSummary: legacy.issue.latestFailureSummary,
-                blockedByKeys: legacy.issue.blockedByKeys,
-                waitingReason: legacy.issue.waitingReason,
-            })
-            : legacy.issue.statusNote;
-        return {
-            issue: {
-                ...legacy.issue,
-                ...(statusNote ? { statusNote } : {}),
-            },
-            ...(activeRun ? { activeRun } : {}),
-            ...(latestRun ? { latestRun } : {}),
-            ...(liveThread ? { liveThread } : {}),
-            ...(runs.length > 0 ? { runs } : {}),
-            ...(issueRecord
-                ? {
-                    issueContext: {
-                        ...(issueRecord.description ? { description: issueRecord.description } : {}),
-                        ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
-                        ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
-                        ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
-                        ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
-                        ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
-                        ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
-                        ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
-                        ciRepairAttempts: issueRecord.ciRepairAttempts,
-                        queueRepairAttempts: issueRecord.queueRepairAttempts,
-                        reviewFixAttempts: issueRecord.reviewFixAttempts,
-                        ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
-                        ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
-                        ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
-                        ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
-                        ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
-                        runCount,
-                    },
-                }
-                : {}),
-        };
-    }
     async getSessionIssueOverview(issueKey, session) {
         const issueRecord = this.db.issues.getIssueByKey(issueKey);
         const blockedBy = this.db.issues.listIssueDependencies(session.projectId, session.linearIssueId);
@@ -138,6 +89,7 @@ export class IssueOverviewQuery {
         const liveThread = await this.readLiveThread(activeRun);
         const failureContext = parseGitHubFailureContext(issueRecord?.lastGitHubFailureContextJson);
         const waitingReason = session.waitingReason ?? derivePatchRelayWaitingReason({
+            delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
             ...(activeRun ? { activeRunType: activeRun.runType } : {}),
             blockedByKeys,
             factoryState: issueRecord?.factoryState ?? "delegated",
@@ -154,6 +106,7 @@ export class IssueOverviewQuery {
             id: issueRecord?.id ?? session.id,
             projectId: session.projectId,
             linearIssueId: session.linearIssueId,
+            delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay ?? true,
             ...(session.issueKey ? { issueKey: session.issueKey } : {}),
             ...(issueRecord?.title ? { title: issueRecord.title } : {}),
             ...(issueRecord?.url ? { issueUrl: issueRecord.url } : {}),
@@ -169,6 +122,7 @@ export class IssueOverviewQuery {
             readyForExecution: isIssueSessionReadyForExecution({
                 sessionState: session.sessionState,
                 factoryState: issueRecord?.factoryState ?? "delegated",
+                delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
                 hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,

package/dist/issue-session-projector.js

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

package/dist/issue-session.js

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

package/dist/legacy-issue-overview.js

@@ -0,0 +1,58 @@
+import { deriveIssueStatusNote } from "./status-note.js";
+export async function getLegacyIssueOverview(params) {
+    const { db, issueKey, runStatusProvider, buildRuns, readLiveThread } = params;
+    const legacy = db.getIssueOverview(issueKey);
+    if (!legacy)
+        return undefined;
+    const issueRecord = db.issues.getIssueByKey(issueKey);
+    const activeStatus = await runStatusProvider.getActiveRunStatus(issueKey);
+    const activeRun = activeStatus?.run ?? legacy.activeRun;
+    const latestRun = db.runs.getLatestRunForIssue(legacy.issue.projectId, legacy.issue.linearIssueId);
+    const latestEvent = db.issueSessions.listIssueSessionEvents(legacy.issue.projectId, legacy.issue.linearIssueId, { limit: 1 }).at(-1);
+    const runs = buildRuns(legacy.issue.projectId, legacy.issue.linearIssueId);
+    const runCount = runs.length;
+    const liveThread = await readLiveThread(activeRun);
+    const statusNote = issueRecord
+        ? deriveIssueStatusNote({
+            issue: issueRecord,
+            latestRun,
+            latestEvent,
+            failureSummary: legacy.issue.latestFailureSummary,
+            blockedByKeys: legacy.issue.blockedByKeys,
+            waitingReason: legacy.issue.waitingReason,
+        })
+        : legacy.issue.statusNote;
+    return {
+        issue: {
+            ...legacy.issue,
+            ...(statusNote ? { statusNote } : {}),
+        },
+        ...(activeRun ? { activeRun } : {}),
+        ...(latestRun ? { latestRun } : {}),
+        ...(liveThread ? { liveThread } : {}),
+        ...(runs.length > 0 ? { runs } : {}),
+        ...(issueRecord
+            ? {
+                issueContext: {
+                    ...(issueRecord.description ? { description: issueRecord.description } : {}),
+                    ...(issueRecord.currentLinearState ? { currentLinearState: issueRecord.currentLinearState } : {}),
+                    ...(issueRecord.url ? { issueUrl: issueRecord.url } : {}),
+                    ...(issueRecord.worktreePath ? { worktreePath: issueRecord.worktreePath } : {}),
+                    ...(issueRecord.branchName ? { branchName: issueRecord.branchName } : {}),
+                    ...(issueRecord.prUrl ? { prUrl: issueRecord.prUrl } : {}),
+                    ...(issueRecord.priority != null ? { priority: issueRecord.priority } : {}),
+                    ...(issueRecord.estimate != null ? { estimate: issueRecord.estimate } : {}),
+                    ciRepairAttempts: issueRecord.ciRepairAttempts,
+                    queueRepairAttempts: issueRecord.queueRepairAttempts,
+                    reviewFixAttempts: issueRecord.reviewFixAttempts,
+                    ...(legacy.issue.latestFailureSource ? { latestFailureSource: legacy.issue.latestFailureSource } : {}),
+                    ...(legacy.issue.latestFailureHeadSha ? { latestFailureHeadSha: legacy.issue.latestFailureHeadSha } : {}),
+                    ...(legacy.issue.latestFailureCheckName ? { latestFailureCheckName: legacy.issue.latestFailureCheckName } : {}),
+                    ...(legacy.issue.latestFailureStepName ? { latestFailureStepName: legacy.issue.latestFailureStepName } : {}),
+                    ...(legacy.issue.latestFailureSummary ? { latestFailureSummary: legacy.issue.latestFailureSummary } : {}),
+                    runCount,
+                },
+            }
+            : {}),
+    };
+}

package/dist/linear-session-reporting.js

@@ -193,7 +193,10 @@ export function summarizeIssueStateForLinear(issue) {
         case "running":
             return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is actively running.` : "Actively running.");
         case "idle":
-            return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} is idle.` : "Idle.");
+            if (!issue.delegatedToPatchRelay) {
+                break;
+            }
+            return issue.waitingReason ?? (issue.prNumber ? `PR #${issue.prNumber} is idle.` : "Idle.");
         case "done":
             if (issue.prNumber && issue.prState === "merged")
                 return `PR #${issue.prNumber} has merged.`;
@@ -204,9 +207,35 @@ export function summarizeIssueStateForLinear(issue) {
             return issue.waitingReason ?? (issue.prNumber && !isClosedPrState(issue.prState) ? `PR #${issue.prNumber} needs help to recover.` : "Needs help to recover.");
     }
     switch (issue.factoryState) {
+        case "delegated":
+            if (!issue.delegatedToPatchRelay) {
+                return "PatchRelay is queued to start work, but automation is paused.";
+            }
+            return "Queued to start work.";
+        case "implementing":
+            if (!issue.delegatedToPatchRelay) {
+                return "Implementation is paused because the issue is undelegated.";
+            }
+            return "Implementation in progress.";
         case "pr_open":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} is awaiting review while PatchRelay is paused.`;
+            }
             return issue.prNumber ? `PR #${issue.prNumber} is awaiting review.` : "Awaiting review.";
+        case "changes_requested":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} has requested changes while PatchRelay is paused.`;
+            }
+            return issue.prNumber ? `PR #${issue.prNumber} has requested changes.` : "Requested changes received.";
+        case "repairing_ci":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} has failing CI while PatchRelay is paused.`;
+            }
+            return issue.prNumber ? `PR #${issue.prNumber} has failing CI.` : "Failing CI.";
         case "awaiting_queue":
+            if (!issue.delegatedToPatchRelay && issue.prNumber) {
+                return `PR #${issue.prNumber} is approved and awaiting merge while PatchRelay is paused.`;
+            }
             return issue.prNumber ? `PR #${issue.prNumber} is approved and awaiting merge.` : "Approved and awaiting merge.";
         case "done":
             if (issue.prNumber && issue.prState === "merged")

package/dist/linear-session-sync.js

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

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

@@ -2,6 +2,7 @@ import { extractCompletionCheck } from "./completion-check.js";
 import { deriveIssueStatusNote } from "./status-note.js";
 import { derivePatchRelayWaitingReason } from "./waiting-reason.js";
 import { isClosedPrState } from "./pr-state.js";
+import { isUndelegatedPausedIssue } from "./paused-issue-state.js";
 export async function syncVisibleStatusComment(params) {
     const { db, issue, linear, logger, trackedIssue, options } = params;
     try {
@@ -32,6 +33,9 @@ export function shouldSyncVisibleIssueComment(issue, hasAgentSession) {
         || issue.factoryState === "awaiting_input" || issue.factoryState === "failed" || issue.factoryState === "escalated") {
         return true;
     }
+    if (isUndelegatedPausedIssue(issue)) {
+        return true;
+    }
     if ((issue.sessionState === "done" || issue.factoryState === "done")
         && ((issue.prNumber === undefined && !issue.prUrl)
             || isClosedPrState(issue.prState))) {
@@ -47,6 +51,7 @@ 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,
@@ -62,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) {
@@ -124,6 +137,26 @@ function statusHeadline(issue, activeRunType) {
         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";

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);
     }