patchrelay 0.51.4 → 0.52.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.51.4",
-  "commit": "68e71c39b593",
-  "builtAt": "2026-04-22T04:33:28.283Z"
+  "version": "0.52.0",
+  "commit": "818b35cc9b05",
+  "builtAt": "2026-04-22T14:41:18.426Z"
 }

package/dist/github-webhook-reactive-run.js

@@ -5,8 +5,6 @@ import { buildGitHubQueueFailureContext, getRelevantGitHubCiSnapshot, resolveGit
 import { isQueueEvictionFailure, isSettledBranchFailure } from "./github-webhook-policy.js";
 export async function maybeEnqueueGitHubReactiveRun(params) {
     const { issue, event, project, logger, feed, enqueueIssue, db, fetchImpl, failureContextResolver } = params;
-    if (issue.activeRunId !== undefined)
-        return;
     if (isIssueTerminal(issue))
         return;
     if (!issue.delegatedToPatchRelay) {
@@ -22,6 +20,9 @@ export async function maybeEnqueueGitHubReactiveRun(params) {
         return;
     }
     if (event.triggerEvent === "check_failed" && issue.prState === "open") {
+        if (issue.activeRunId !== undefined) {
+            return;
+        }
         await handleCheckFailedEvent({
             db,
             logger,
@@ -175,8 +176,14 @@ async function handleRequestedChangesEvent(params) {
     });
     const queuedRunType = hadPendingWake
         ? db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType
-        : enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId);
-    logger.info({ issueKey: issue.issueKey, reviewerName: event.reviewerName }, "Enqueued review fix run");
+        : issue.activeRunId === undefined
+            ? enqueuePendingSessionWake(db, enqueueIssue, issue.projectId, issue.linearIssueId)
+            : db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)?.runType;
+    logger.info({
+        issueKey: issue.issueKey,
+        reviewerName: event.reviewerName,
+        deferredUntilRunRelease: issue.activeRunId !== undefined,
+    }, "Captured requested-changes follow-up");
     feed?.publish({
         level: "warn",
         kind: "github",
@@ -184,7 +191,9 @@ async function handleRequestedChangesEvent(params) {
         projectId: issue.projectId,
         stage: "changes_requested",
         status: "review_fix_queued",
-        summary: `${queuedRunType ?? "review_fix"} queued after requested changes`,
+        summary: issue.activeRunId === undefined
+            ? `${queuedRunType ?? "review_fix"} queued after requested changes`
+            : `${queuedRunType ?? "review_fix"} recorded and will resume after the active run finishes`,
         detail: reviewComments && reviewComments.length > 0
             ? `${reviewComments.length} inline review comment${reviewComments.length === 1 ? "" : "s"} captured`
             : event.reviewBody?.slice(0, 200) ?? event.reviewerName,

package/dist/idle-reconciliation.js

@@ -603,6 +603,30 @@ export class IdleIssueReconciler {
                 });
                 return;
             }
+            if (issue.delegatedToPatchRelay
+                && reactiveIntent?.runType === "review_fix"
+                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined) {
+                this.logger.info({
+                    issueKey: issue.issueKey,
+                    prNumber: issue.prNumber,
+                    from: issue.factoryState,
+                    runType: reactiveIntent.runType,
+                }, "Reconciliation: re-queued requested-changes follow-up from GitHub truth");
+                this.advanceIdleIssue(issue, reactiveIntent.compatibilityFactoryState, {
+                    pendingRunType: reactiveIntent.runType,
+                    clearFailureProvenance: true,
+                });
+                this.feed?.publish({
+                    level: "warn",
+                    kind: "github",
+                    issueKey: issue.issueKey,
+                    projectId: issue.projectId,
+                    stage: reactiveIntent.compatibilityFactoryState,
+                    status: "review_fix_queued",
+                    summary: `PR #${issue.prNumber} still has requested changes on the current head, dispatching review fix`,
+                });
+                return;
+            }
             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, {

package/dist/linear-progress-facts.js

@@ -26,21 +26,24 @@ function deriveProgressFactFromCompletedItem(rawItem, issue) {
         return {
             kind: "verification_started",
             meaningKey: `verification:${normalizeMeaningKey(body)}`,
-            content: { type: "thought", body },
+            ephemeralContent: { type: "thought", body },
+            historyContent: { type: "thought", body },
         };
     }
     if (looksLikePublishing(body)) {
         return {
             kind: "publishing_started",
             meaningKey: `publishing:${normalizeMeaningKey(body)}`,
-            content: { type: "thought", body },
+            ephemeralContent: { type: "thought", body },
+            historyContent: { type: "thought", body },
         };
     }
     if (looksLikeRootCause(body)) {
         return {
             kind: "root_cause_found",
             meaningKey: `finding:${normalizeMeaningKey(body)}`,
-            content: { type: "thought", body },
+            ephemeralContent: { type: "thought", body },
+            historyContent: { type: "thought", body },
         };
     }
     return undefined;
@@ -59,7 +62,12 @@ function deriveProgressFactFromPlan(rawPlan, issue) {
         return {
             kind: "verification_started",
             meaningKey: `verification:${normalizeMeaningKey(activeStep.step)}`,
-            content: {
+            ephemeralContent: {
+                type: "action",
+                action: "Verifying",
+                parameter: summarizePlanStep(activeStep.step, "latest changes before publishing"),
+            },
+            historyContent: {
                 type: "action",
                 action: "Verifying",
                 parameter: summarizePlanStep(activeStep.step, "latest changes before publishing"),
@@ -71,7 +79,12 @@ function deriveProgressFactFromPlan(rawPlan, issue) {
         return {
             kind: "publishing_started",
             meaningKey: `publishing:${normalizeMeaningKey(activeStep.step)}`,
-            content: {
+            ephemeralContent: {
+                type: "action",
+                action: "Publishing",
+                parameter,
+            },
+            historyContent: {
                 type: "action",
                 action: "Publishing",
                 parameter,

package/dist/linear-progress-reporter.js

@@ -17,22 +17,79 @@ export class LinearProgressReporter {
             return;
         }
         const previous = this.publicationsByRun.get(run.id);
-        if (previous?.meaningKey === fact.meaningKey) {
+        const shouldEmitEphemeral = previous?.ephemeralMeaningKey !== fact.meaningKey;
+        const shouldEmitHistory = previous?.historyMeaningKey !== fact.meaningKey;
+        if (!shouldEmitEphemeral && !shouldEmitHistory) {
             return;
         }
+        const now = Date.now();
         const publication = {
-            meaningKey: fact.meaningKey,
-            publishedAtMs: Date.now(),
+            ...previous,
+            ...(shouldEmitEphemeral
+                ? {
+                    ephemeralMeaningKey: fact.meaningKey,
+                    ephemeralPublishedAtMs: now,
+                }
+                : {}),
+            ...(shouldEmitHistory
+                ? {
+                    historyMeaningKey: fact.meaningKey,
+                    historyPublishedAtMs: now,
+                }
+                : {}),
         };
         this.publicationsByRun.set(run.id, publication);
-        void this.emitActivity(issue, fact.content, { ephemeral: true }).catch(() => {
-            const current = this.publicationsByRun.get(run.id);
-            if (current?.publishedAtMs === publication.publishedAtMs && current.meaningKey === publication.meaningKey) {
-                this.publicationsByRun.delete(run.id);
-            }
-        });
+        if (shouldEmitEphemeral) {
+            void this.emitActivity(issue, fact.ephemeralContent, { ephemeral: true }).catch(() => {
+                this.clearFailedPublication(run.id, "ephemeral", fact.meaningKey, now);
+            });
+        }
+        if (shouldEmitHistory) {
+            void this.emitActivity(issue, fact.historyContent).catch(() => {
+                this.clearFailedPublication(run.id, "history", fact.meaningKey, now);
+            });
+        }
     }
     clearProgress(runId) {
         this.publicationsByRun.delete(runId);
     }
+    clearFailedPublication(runId, channel, meaningKey, publishedAtMs) {
+        const current = this.publicationsByRun.get(runId);
+        if (!current) {
+            return;
+        }
+        if (channel === "ephemeral") {
+            if (current.ephemeralMeaningKey !== meaningKey || current.ephemeralPublishedAtMs !== publishedAtMs) {
+                return;
+            }
+            const next = {};
+            if (current.historyMeaningKey !== undefined) {
+                next.historyMeaningKey = current.historyMeaningKey;
+            }
+            if (current.historyPublishedAtMs !== undefined) {
+                next.historyPublishedAtMs = current.historyPublishedAtMs;
+            }
+            if (!next.historyMeaningKey) {
+                this.publicationsByRun.delete(runId);
+                return;
+            }
+            this.publicationsByRun.set(runId, next);
+            return;
+        }
+        if (current.historyMeaningKey !== meaningKey || current.historyPublishedAtMs !== publishedAtMs) {
+            return;
+        }
+        const next = {};
+        if (current.ephemeralMeaningKey !== undefined) {
+            next.ephemeralMeaningKey = current.ephemeralMeaningKey;
+        }
+        if (current.ephemeralPublishedAtMs !== undefined) {
+            next.ephemeralPublishedAtMs = current.ephemeralPublishedAtMs;
+        }
+        if (!next.ephemeralMeaningKey) {
+            this.publicationsByRun.delete(runId);
+            return;
+        }
+        this.publicationsByRun.set(runId, next);
+    }
 }

package/dist/run-finalizer.js

@@ -135,6 +135,26 @@ export class RunFinalizer {
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);
     }
+    enqueuePendingWakeIfPresent(params) {
+        const wake = this.db.issueSessions.peekIssueSessionWake(params.run.projectId, params.run.linearIssueId);
+        if (!wake)
+            return undefined;
+        this.enqueueIssue(params.run.projectId, params.run.linearIssueId);
+        this.feed?.publish({
+            level: "info",
+            kind: "stage",
+            issueKey: params.issueKey,
+            projectId: params.run.projectId,
+            stage: wake.runType,
+            status: "deferred_follow_up_queued",
+            summary: `${wake.runType} queued after ${params.run.runType} released authority`,
+            ...(wake.wakeReason ? { detail: `wake reason: ${wake.wakeReason}` } : {}),
+        });
+        return {
+            runType: wake.runType,
+            ...(wake.wakeReason ? { wakeReason: wake.wakeReason } : {}),
+        };
+    }
     publishTurnEvent(params) {
         this.feed?.publish({
             level: params.level,
@@ -294,7 +314,6 @@ export class RunFinalizer {
                 status: "follow_up_queued",
                 summary: postRunFollowUp.summary,
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
         }
         this.publishTurnEvent({
             level: "info",
@@ -320,6 +339,7 @@ export class RunFinalizer {
             void this.linearSync.emitActivity(updatedIssue, linearActivity);
         }
         void this.linearSync.syncSession(updatedIssue);
+        this.enqueuePendingWakeIfPresent({ run, issueKey: updatedIssue.issueKey });
         this.linearSync.clearProgress(run.id);
         this.releaseLease(run.projectId, run.linearIssueId);
     }

package/dist/service-startup-recovery.js

@@ -1,4 +1,5 @@
 import { appendDelegationObservedEvent } from "./delegation-audit.js";
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
 import { isResumablePausedLocalWork } from "./paused-issue-state.js";
 export class ServiceStartupRecovery {
     db;
@@ -89,6 +90,7 @@ export class ServiceStartupRecovery {
             }
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
+            const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined;
             const shouldRecoverPausedLocalWork = delegated
                 && isResumablePausedLocalWork({
                     issue: {
@@ -97,7 +99,21 @@ export class ServiceStartupRecovery {
                     },
                     latestRun,
                 })
-                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
+                && !hasPendingWake;
+            const reactiveIntent = delegated && !hasPendingWake
+                ? deriveIssueSessionReactiveIntent({
+                    delegatedToPatchRelay: delegated,
+                    prNumber: issue.prNumber,
+                    prState: issue.prState,
+                    prIsDraft: issue.prIsDraft,
+                    prReviewState: issue.prReviewState,
+                    prCheckStatus: issue.prCheckStatus,
+                    latestFailureSource: issue.lastGitHubFailureSource,
+                })
+                : undefined;
+            const shouldRecoverReactivePrWork = delegated
+                && issue.prNumber !== undefined
+                && reactiveIntent !== undefined;
             const updated = this.db.issues.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -110,26 +126,64 @@ export class ServiceStartupRecovery {
                 ...(liveIssue.estimate != null ? { estimate: liveIssue.estimate } : {}),
                 ...(liveIssue.stateName ? { currentLinearState: liveIssue.stateName } : {}),
                 ...(liveIssue.stateType ? { currentLinearStateType: liveIssue.stateType } : {}),
-                ...(shouldRecoverPausedLocalWork ? { factoryState: "delegated" } : {}),
+                ...(shouldRecoverPausedLocalWork
+                    ? { factoryState: "delegated" }
+                    : shouldRecoverReactivePrWork
+                        ? { factoryState: reactiveIntent.compatibilityFactoryState }
+                        : {}),
             });
-            if (!shouldRecoverPausedLocalWork) {
+            if (!shouldRecoverPausedLocalWork && !shouldRecoverReactivePrWork) {
                 continue;
             }
             if (unresolvedBlockers === 0) {
-                this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-                    projectId: issue.projectId,
-                    linearIssueId: issue.linearIssueId,
-                    eventType: "delegated",
-                    dedupeKey: `delegated:${issue.linearIssueId}`,
-                });
+                if (shouldRecoverReactivePrWork && reactiveIntent) {
+                    this.appendReactiveWakeEvent(issue.projectId, issue.linearIssueId, issue, reactiveIntent.runType);
+                }
+                else {
+                    this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+                        projectId: issue.projectId,
+                        linearIssueId: issue.linearIssueId,
+                        eventType: "delegated",
+                        dedupeKey: `delegated:${issue.linearIssueId}`,
+                    });
+                }
                 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 paused local-work state and re-queued implementation");
+                this.logger.info({
+                    issueKey: updated.issueKey,
+                    ...(shouldRecoverReactivePrWork && reactiveIntent ? { runType: reactiveIntent.runType } : {}),
+                }, shouldRecoverReactivePrWork
+                    ? "Recovered delegated PR issue from reactive paused state and re-queued follow-up work"
+                    : "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 paused local-work state");
+                this.logger.info({
+                    issueKey: updated.issueKey,
+                    unresolvedBlockers,
+                    ...(shouldRecoverReactivePrWork && reactiveIntent ? { runType: reactiveIntent.runType } : {}),
+                }, shouldRecoverReactivePrWork
+                    ? "Recovered delegated blocked PR issue from reactive paused state"
+                    : "Recovered delegated blocked issue from paused local-work state");
             }
         }
     }
+    appendReactiveWakeEvent(projectId, linearIssueId, issue, runType) {
+        const eventType = runType === "queue_repair"
+            ? "merge_steward_incident"
+            : runType === "ci_repair"
+                ? "settled_red_ci"
+                : "review_changes_requested";
+        const dedupeKey = runType === "queue_repair"
+            ? `startup_recovery:queue_repair:${linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`
+            : runType === "ci_repair"
+                ? `startup_recovery:ci_repair:${linearIssueId}:${issue.lastGitHubFailureSignature ?? issue.prHeadSha ?? issue.lastGitHubFailureHeadSha ?? "unknown"}`
+                : `startup_recovery:${runType}:${linearIssueId}:${issue.prHeadSha ?? "unknown"}`;
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(projectId, linearIssueId, {
+            projectId,
+            linearIssueId,
+            eventType,
+            dedupeKey,
+        });
+    }
 }

package/package.json

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