patchrelay 0.41.8 → 0.43.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.41.8",
-  "commit": "8142a14a520c",
-  "builtAt": "2026-04-14T13:31:00.535Z"
+  "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/prompting/patchrelay.js

@@ -356,6 +356,22 @@ function buildPublicationContract(runType) {
             "If the worktree already contains relevant changes for this issue, verify them and publish them.",
             "If you changed files for this issue, commit them, push the issue branch, and open or update the PR before stopping.",
             "Do not stop with only local commits or uncommitted changes.",
+            "",
+            "## PR Body Contract",
+            "",
+            "When you open or update a PR, shape the body so a strict reviewer can decide in one pass.",
+            "",
+            "Title: imperative, ≤72 chars. Do not prefix with the issue key — the branch carries it.",
+            "",
+            "Body sections, in this order. Omit any that do not apply but keep the order:",
+            "",
+            "  ## Why — 1-3 sentences on the problem and motivation.",
+            "  ## What — ≤5 bullets naming the files or surfaces that change.",
+            "  ## Tradeoffs — one explicit tradeoff taken, or the single word \"None\".",
+            "  ## Risks — 1-3 things a strict reviewer would ask about. For each, either fix it before committing or explain why it is acceptable. This section is load-bearing; a strict reviewer reads it first.",
+            "",
+            "Do not restate the diff in prose. Quote the ambiguous fragment directly if the reader needs to see it.",
+            "Do not add a \"Verification\" or \"I ran these commands\" section; CI owns pass/fail and posts check runs the reviewer already sees.",
         ].join("\n");
     }
     return [

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.41.8",
+  "version": "0.43.0",
   "license": "MIT",
   "type": "module",
   "repository": {