patchrelay 0.42.0 → 0.43.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.42.0",
-  "commit": "ad4fbfa6efc4",
-  "builtAt": "2026-04-14T14:44:46.179Z"
+  "version": "0.43.0",
+  "commit": "cfb77c67aa5e",
+  "builtAt": "2026-04-15T08:38:14.720Z"
 }

package/dist/db/issue-store.js

@@ -192,6 +192,10 @@ export class IssueStore {
                 sets.push("last_attempted_failure_signature = @lastAttemptedFailureSignature");
                 values.lastAttemptedFailureSignature = params.lastAttemptedFailureSignature;
             }
+            if (params.lastAttemptedFailureAt !== undefined) {
+                sets.push("last_attempted_failure_at = @lastAttemptedFailureAt");
+                values.lastAttemptedFailureAt = params.lastAttemptedFailureAt;
+            }
             if (params.ciRepairAttempts !== undefined) {
                 sets.push("ci_repair_attempts = @ciRepairAttempts");
                 values.ciRepairAttempts = params.ciRepairAttempts;
@@ -226,7 +230,7 @@ export class IssueStore {
           last_github_failure_source, last_github_failure_head_sha, last_github_failure_signature, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_context_json, last_github_failure_at,
           last_github_ci_snapshot_head_sha, last_github_ci_snapshot_gate_check_name, last_github_ci_snapshot_gate_check_status, last_github_ci_snapshot_json, last_github_ci_snapshot_settled_at,
           last_queue_signal_at, last_queue_incident_json,
-          last_attempted_failure_head_sha, last_attempted_failure_signature,
+          last_attempted_failure_head_sha, last_attempted_failure_signature, last_attempted_failure_at,
           ci_repair_attempts, queue_repair_attempts, review_fix_attempts, zombie_recovery_attempts, last_zombie_recovery_at,
           updated_at
         ) VALUES (
@@ -239,7 +243,7 @@ export class IssueStore {
           @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt,
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
           @lastQueueSignalAt, @lastQueueIncidentJson,
-          @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature,
+          @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature, @lastAttemptedFailureAt,
           @ciRepairAttempts, @queueRepairAttempts, @reviewFixAttempts, @zombieRecoveryAttempts, @lastZombieRecoveryAt,
           @now
         )
@@ -290,6 +294,7 @@ export class IssueStore {
                 lastQueueIncidentJson: params.lastQueueIncidentJson ?? null,
                 lastAttemptedFailureHeadSha: params.lastAttemptedFailureHeadSha ?? null,
                 lastAttemptedFailureSignature: params.lastAttemptedFailureSignature ?? null,
+                lastAttemptedFailureAt: params.lastAttemptedFailureAt ?? null,
                 ciRepairAttempts: params.ciRepairAttempts ?? 0,
                 queueRepairAttempts: params.queueRepairAttempts ?? 0,
                 reviewFixAttempts: params.reviewFixAttempts ?? 0,
@@ -556,6 +561,9 @@ export function mapIssueRow(row) {
         ...(row.last_attempted_failure_signature !== null && row.last_attempted_failure_signature !== undefined
             ? { lastAttemptedFailureSignature: String(row.last_attempted_failure_signature) }
             : {}),
+        ...(row.last_attempted_failure_at !== null && row.last_attempted_failure_at !== undefined
+            ? { lastAttemptedFailureAt: String(row.last_attempted_failure_at) }
+            : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),

package/dist/db/migrations.js

@@ -293,6 +293,7 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "last_queue_incident_json", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_signature", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_attempted_failure_at", "TEXT");
     removeRetiredIssueColumnsIfPresent(connection);
 }
 function addColumnIfMissing(connection, table, column, definition) {
@@ -359,6 +360,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         last_queue_incident_json TEXT,
         last_attempted_failure_head_sha TEXT,
         last_attempted_failure_signature TEXT,
+        last_attempted_failure_at TEXT,
         ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
         queue_repair_attempts INTEGER NOT NULL DEFAULT 0,
         review_fix_attempts INTEGER NOT NULL DEFAULT 0,
@@ -416,6 +418,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         last_queue_incident_json,
         last_attempted_failure_head_sha,
         last_attempted_failure_signature,
+        last_attempted_failure_at,
         ci_repair_attempts,
         queue_repair_attempts,
         review_fix_attempts,
@@ -471,6 +474,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         last_queue_incident_json,
         last_attempted_failure_head_sha,
         last_attempted_failure_signature,
+        last_attempted_failure_at,
         COALESCE(ci_repair_attempts, 0),
         COALESCE(queue_repair_attempts, 0),
         COALESCE(review_fix_attempts, 0),

package/dist/github-webhook-state-projector.js

@@ -80,6 +80,7 @@ export async function projectGitHubWebhookState(deps, issue, event, project, lin
             lastQueueIncidentJson: null,
             lastAttemptedFailureHeadSha: null,
             lastAttemptedFailureSignature: null,
+            lastAttemptedFailureAt: null,
         });
     }
     deps.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
@@ -240,6 +241,7 @@ async function updateGitHubFailureProvenance(deps, issue, event, project, failur
             lastQueueIncidentJson: null,
             lastAttemptedFailureHeadSha: null,
             lastAttemptedFailureSignature: null,
+            lastAttemptedFailureAt: null,
         });
     }
 }

package/dist/idle-reconciliation.js

@@ -50,8 +50,19 @@ function isDuplicateRepairAttempt(issue, context) {
         : typeof context?.headSha === "string" ? context.headSha : undefined;
     if (!signature)
         return false;
-    return issue.lastAttemptedFailureSignature === signature
-        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+    if (issue.lastAttemptedFailureSignature !== signature)
+        return false;
+    if (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha)
+        return false;
+    // A signature+headSha match alone isn't enough: for queue evictions the PR head
+    // doesn't advance (we haven't pushed) and the steward's check name is constant,
+    // so a fresh incident after main advances looks identical. Treat the attempt as
+    // stale if a newer failure has been observed since it was recorded.
+    if (issue.lastAttemptedFailureAt && issue.lastGitHubFailureAt
+        && issue.lastGitHubFailureAt > issue.lastAttemptedFailureAt) {
+        return false;
+    }
+    return true;
 }
 function buildFailureContext(issue) {
     const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
@@ -196,6 +207,7 @@ export class IdleIssueReconciler {
                     lastQueueIncidentJson: null,
                     lastAttemptedFailureHeadSha: null,
                     lastAttemptedFailureSignature: null,
+                    lastAttemptedFailureAt: null,
                 }
                 : {}),
         });

package/dist/interrupted-run-recovery.js

@@ -90,6 +90,7 @@ export class InterruptedRunRecovery {
                     linearIssueId: issue.linearIssueId,
                     lastAttemptedFailureHeadSha: null,
                     lastAttemptedFailureSignature: null,
+                    lastAttemptedFailureAt: null,
                 });
             }
             return true;

package/dist/issue-session-lease-service.js

@@ -14,10 +14,10 @@ export class IssueSessionLeaseService {
         this.readThreadWithRetry = readThreadWithRetry;
     }
     hasLocalLease(projectId, linearIssueId) {
-        return this.activeSessionLeases.has(this.issueSessionLeaseKey(projectId, linearIssueId));
+        return this.getValidatedLocalLeaseId(projectId, linearIssueId) !== undefined;
     }
     getHeldLease(projectId, linearIssueId) {
-        const leaseId = this.activeSessionLeases.get(this.issueSessionLeaseKey(projectId, linearIssueId));
+        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
         if (!leaseId)
             return undefined;
         return { projectId, linearIssueId, leaseId };
@@ -133,10 +133,21 @@ export class IssueSessionLeaseService {
     }
     release(projectId, linearIssueId) {
         const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.activeSessionLeases.get(key);
+        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
         this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
         this.activeSessionLeases.delete(key);
     }
+    getValidatedLocalLeaseId(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key);
+        if (!leaseId)
+            return undefined;
+        if (this.db.issueSessions.hasActiveIssueSessionLease(projectId, linearIssueId, leaseId)) {
+            return leaseId;
+        }
+        this.activeSessionLeases.delete(key);
+        return undefined;
+    }
     issueSessionLeaseKey(projectId, linearIssueId) {
         return `${projectId}:${linearIssueId}`;
     }

package/dist/linear-workflow-state-sync.js

@@ -1,4 +1,4 @@
-import { resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 export async function syncActiveWorkflowState(params) {
@@ -72,10 +72,15 @@ function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIss
         || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
         return resolvePreferredHumanNeededLinearState(liveIssue);
     }
+    const blocked = (trackedIssue?.blockedByCount ?? 0) > 0;
+    const pausedNoPrWork = issue.prNumber === undefined && (!issue.delegatedToPatchRelay || blocked);
+    if (pausedNoPrWork) {
+        return resolvePreferredQueuedLinearState(liveIssue);
+    }
     const activelyWorking = issue.delegatedToPatchRelay !== false && (issue.activeRunId !== undefined
         || options?.activeRunType !== undefined
         || trackedIssue?.sessionState === "running"
-        || issue.factoryState === "delegated"
+        || (issue.factoryState === "delegated" && !blocked && trackedIssue?.readyForExecution !== false)
         || issue.factoryState === "implementing"
         || issue.factoryState === "changes_requested"
         || issue.factoryState === "repairing_ci"

package/dist/linear-workflow.js

@@ -24,6 +24,16 @@ export function resolvePreferredStartedLinearState(issue) {
     });
     return preferred?.name ?? startedStates[0]?.name;
 }
+export function resolvePreferredQueuedLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["backlog", "start", "todo", "to do", "planned", "ready"],
+        types: ["backlog", "unstarted"],
+        fallback: issue.workflowStates.find((state) => {
+            const normalizedType = normalizeLinearState(state.type);
+            return normalizedType === "backlog" || normalizedType === "unstarted";
+        })?.name,
+    });
+}
 export function resolvePreferredImplementingLinearState(issue) {
     return resolvePreferredLinearState(issue, {
         names: ["implementing", "in progress", "in-progress", "started", "doing"],

package/dist/no-pr-completion-check.js

@@ -188,6 +188,7 @@ export async function handleNoPrCompletionCheck(params) {
                 lastQueueIncidentJson: null,
                 lastAttemptedFailureHeadSha: null,
                 lastAttemptedFailureSignature: null,
+                lastAttemptedFailureAt: null,
             });
             return true;
         });

package/dist/reactive-run-policy.js

@@ -23,6 +23,13 @@ export class ReactiveRunPolicy {
                 return undefined;
             if (!snapshot.headSha || snapshot.headSha !== issue.lastGitHubFailureHeadSha)
                 return undefined;
+            // For queue repairs, the agent's no-op is legitimate when the incident has
+            // already self-resolved: GitHub reports the PR as mergeable, so there is no
+            // conflict left to push. Only flag as failed when the merge state is still
+            // DIRTY after the run — then the agent really did miss the fix.
+            if (run.runType === "queue_repair" && !isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus)) {
+                return undefined;
+            }
             return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
         }
         catch (error) {
@@ -99,6 +106,7 @@ export class ReactiveRunPolicy {
                         lastQueueIncidentJson: null,
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
+                        lastAttemptedFailureAt: null,
                         lastGitHubCiSnapshotHeadSha: snapshot.headSha ?? null,
                         lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName,
                         lastGitHubCiSnapshotGateCheckStatus: "pending",

package/dist/run-finalizer.js

@@ -168,6 +168,7 @@ export class RunFinalizer {
                         lastQueueIncidentJson: null,
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
+                        lastAttemptedFailureAt: null,
                     }
                     : {})),
             });

package/dist/run-launcher.js

@@ -101,6 +101,7 @@ export class RunLauncher {
                     ? {
                         lastAttemptedFailureSignature: failureSignature,
                         lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                        lastAttemptedFailureAt: new Date().toISOString(),
                     }
                     : {}),
             });

package/dist/service-startup-recovery.js

@@ -38,7 +38,7 @@ export class ServiceStartupRecovery {
         }
     }
     async recoverDelegatedIssueStateFromLinear() {
-        for (const issue of this.db.issues.listIssuesWithAgentSessions()) {
+        for (const issue of this.db.issues.listIssues()) {
             if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
                 continue;
             }
@@ -87,7 +87,13 @@ export class ServiceStartupRecovery {
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
             const shouldRecoverPausedLocalWork = delegated
-                && isResumablePausedLocalWork({ issue, latestRun })
+                && isResumablePausedLocalWork({
+                    issue: {
+                        ...issue,
+                        delegatedToPatchRelay: delegated,
+                    },
+                    latestRun,
+                })
                 && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
             const updated = this.db.issues.upsertIssue({
                 projectId: issue.projectId,

package/dist/webhook-handler.js

@@ -1,4 +1,5 @@
 import { deriveIssueStatusNote } from "./status-note.js";
+import { LinearSessionSync } from "./linear-session-sync.js";
 import { trustedActorAllowed } from "./project-resolution.js";
 import { normalizeWebhook } from "./webhooks.js";
 import { InstallationWebhookHandler } from "./webhook-installation-handler.js";
@@ -25,6 +26,7 @@ export class WebhookHandler {
     desiredStageRecorder;
     contextLoader;
     dependencyReadinessHandler;
+    linearSync;
     constructor(config, db, linearProvider, codex, enqueueIssue, logger, feed) {
         this.config = config;
         this.db = db;
@@ -39,6 +41,7 @@ export class WebhookHandler {
         this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, logger, feed);
         this.desiredStageRecorder = new DesiredStageRecorder(db, linearProvider, feed);
         this.contextLoader = new WebhookContextLoader(config, linearProvider);
+        this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         this.dependencyReadinessHandler = new DependencyReadinessHandler(db, (projectId, issueId) => this.peekPendingSessionWakeRunType(projectId, issueId));
     }
     async processWebhookEvent(webhookEventId) {
@@ -114,6 +117,9 @@ export class WebhookHandler {
             });
             const trackedIssue = result.issue;
             const newlyReadyDependents = this.dependencyReadinessHandler.reconcile(project.id, issue.id);
+            const syncTargets = new Set(shouldSyncLinearStateAfterWebhook(hydrated.triggerEvent)
+                ? [issue.id, ...newlyReadyDependents]
+                : newlyReadyDependents);
             // Handle issue removal: release active runs, mark as failed.
             if (hydrated.triggerEvent === "issueRemoved") {
                 await this.issueRemovalHandler.handle({
@@ -172,6 +178,13 @@ export class WebhookHandler {
                     detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
                 });
             }
+            for (const issueId of syncTargets) {
+                const syncIssue = this.db.getIssue(project.id, issueId);
+                if (!syncIssue) {
+                    continue;
+                }
+                await this.linearSync.syncSession(syncIssue);
+            }
         }
         catch (error) {
             this.db.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
@@ -233,3 +246,10 @@ export class WebhookHandler {
         return Boolean(statusNote?.endsWith("?"));
     }
 }
+function shouldSyncLinearStateAfterWebhook(triggerEvent) {
+    return triggerEvent !== "agentSessionCreated"
+        && triggerEvent !== "agentPrompted"
+        && triggerEvent !== "commentCreated"
+        && triggerEvent !== "commentUpdated"
+        && triggerEvent !== "commentRemoved";
+}

package/package.json

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