patchrelay 0.35.5 → 0.35.7

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.5",
-  "commit": "9abdef5af6a1",
-  "builtAt": "2026-04-03T11:16:59.270Z"
+  "version": "0.35.7",
+  "commit": "880bc08921ac",
+  "builtAt": "2026-04-03T11:50:11.628Z"
 }

package/dist/run-orchestrator.js

@@ -461,6 +461,7 @@ export class RunOrchestrator {
                 projectId: run.projectId,
                 linearIssueId: run.linearIssueId,
                 activeRunId: null,
+                ...(postRunState === "awaiting_queue" ? { queueLabelApplied: false } : {}),
                 ...(postRunState ? { factoryState: postRunState } : {}),
                 ...(postRunState === "awaiting_queue" || postRunState === "done"
                     ? {
@@ -742,11 +743,12 @@ export class RunOrchestrator {
                     const inferProject = this.config.projects.find((p) => p.id === issue.projectId);
                     const inferProtocol = resolveMergeQueueProtocol(inferProject);
                     let inferred = "branch_ci";
-                    if (inferProject?.github?.repoFullName && issue.prNumber && issue.lastGitHubFailureHeadSha) {
+                    const probeSha = issue.lastGitHubFailureHeadSha ?? issue.lastGitHubCiSnapshotHeadSha;
+                    if (inferProject?.github?.repoFullName && issue.prNumber && probeSha) {
                         try {
                             const { stdout } = await execCommand("gh", [
                                 "api",
-                                `repos/${inferProject.github.repoFullName}/commits/${issue.lastGitHubFailureHeadSha}/check-runs`,
+                                `repos/${inferProject.github.repoFullName}/commits/${probeSha}/check-runs`,
                                 "--jq", `.check_runs[] | select(.name == "${inferProtocol.evictionCheckName}" and .conclusion == "failure") | .name`,
                             ], { timeoutMs: 10_000 });
                             if (stdout.trim().length > 0)
@@ -823,6 +825,9 @@ export class RunOrchestrator {
             return;
         }
         this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType: options?.pendingRunType }, "Reconciliation: advancing idle issue");
+        // Reset queueLabelApplied when entering or leaving awaiting_queue so
+        // the retry loop re-applies the label on each queue cycle.
+        const resetQueueLabel = newState === "awaiting_queue" || issue.factoryState === "awaiting_queue";
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
@@ -833,6 +838,7 @@ export class RunOrchestrator {
                     pendingRunContextJson: options.pendingRunContext ? JSON.stringify(options.pendingRunContext) : null,
                 }
                 : {}),
+            ...(resetQueueLabel ? { queueLabelApplied: false } : {}),
             ...(options?.clearFailureProvenance
                 ? {
                     lastGitHubFailureSource: null,
@@ -1068,6 +1074,7 @@ export class RunOrchestrator {
                     projectId: run.projectId,
                     linearIssueId: run.linearIssueId,
                     activeRunId: null,
+                    ...(postRunState === "awaiting_queue" ? { queueLabelApplied: false } : {}),
                     ...(postRunState ? { factoryState: postRunState } : {}),
                     ...(postRunState === "awaiting_queue" || postRunState === "done"
                         ? {

package/dist/webhook-handler.js

@@ -185,74 +185,74 @@ export class WebhookHandler {
         if (!normalizedIssue) {
             return { issue: undefined, desiredStage: undefined, delegated: false };
         }
+        // ── 1. Fetch data ────────────────────────────────────────────
         const existingIssue = this.db.getIssue(project.id, normalizedIssue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.getRun(existingIssue.activeRunId) : undefined;
         const delegated = this.isDelegatedToPatchRelay(project, normalized);
         const triggerAllowed = triggerEventAllowed(project, normalized.triggerEvent);
-        const shouldTrack = Boolean(existingIssue || delegated);
-        if (!shouldTrack) {
+        if (!existingIssue && !delegated) {
             return { issue: undefined, desiredStage: undefined, delegated };
         }
         const hydratedIssue = await this.syncIssueDependencies(project.id, normalizedIssue);
         const unresolvedBlockers = this.db.countUnresolvedBlockers(project.id, normalizedIssue.id);
         const pendingRunContextJson = mergePendingImplementationContext(existingIssue?.pendingRunContextJson, normalized);
-        const terminalForAutomation = isTerminalDelegationState(existingIssue, hydratedIssue);
-        let pendingRunType;
-        if (delegated && triggerAllowed && unresolvedBlockers === 0 && !activeRun && !existingIssue?.pendingRunType && !terminalForAutomation) {
-            pendingRunType = "implementation";
-        }
-        let clearPendingImplementation = unresolvedBlockers > 0 && existingIssue?.pendingRunType === "implementation" && !activeRun;
-        // Release active run when issue reaches a terminal state or is un-delegated.
-        let clearActiveRun = false;
-        if (activeRun && existingIssue) {
-            if (terminalForAutomation) {
-                clearActiveRun = true;
-            }
-            if (normalized.triggerEvent === "delegateChanged" && !delegated) {
-                clearActiveRun = true;
-                clearPendingImplementation = Boolean(existingIssue.pendingRunType);
-            }
-        }
-        // Un-delegation: transition to awaiting_input unless past point of no return.
-        // awaiting_queue means the PR is approved and in the merge queue — let it merge.
-        let undelegatedFactoryState;
-        if (normalized.triggerEvent === "delegateChanged" && !delegated && existingIssue) {
-            const pastNoReturn = existingIssue.factoryState === "awaiting_queue"
-                || TERMINAL_STATES.has(existingIssue.factoryState);
-            if (!pastNoReturn) {
-                undelegatedFactoryState = "awaiting_input";
-                clearPendingImplementation = Boolean(existingIssue.pendingRunType);
+        const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
+        // ── 2. Pure decisions ────────────────────────────────────────
+        const pendingRunType = decideRunIntent({
+            delegated, triggerAllowed, unresolvedBlockers,
+            hasActiveRun: Boolean(activeRun),
+            hasPendingRun: Boolean(existingIssue?.pendingRunType),
+            terminal,
+        });
+        const runRelease = decideActiveRunRelease({
+            hasActiveRun: Boolean(activeRun),
+            terminal,
+            triggerEvent: normalized.triggerEvent,
+            delegated,
+        });
+        const undelegation = decideUnDelegation({
+            triggerEvent: normalized.triggerEvent,
+            delegated,
+            currentState: existingIssue?.factoryState,
+        });
+        const clearPending = (unresolvedBlockers > 0 && existingIssue?.pendingRunType === "implementation" && !activeRun)
+            || undelegation.clearPending;
+        const agentSessionId = decideAgentSession({
+            sessionId: normalized.agentSession?.id,
+            hasActiveRun: Boolean(activeRun),
+            hasPendingRun: Boolean(pendingRunType),
+            triggerEvent: normalized.triggerEvent,
+            delegated,
+        });
+        // ── 3. Transactional commit ──────────────────────────────────
+        const issue = this.db.transaction(() => {
+            const record = this.db.upsertIssue({
+                projectId: project.id,
+                linearIssueId: normalizedIssue.id,
+                ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
+                ...(hydratedIssue.title ? { title: hydratedIssue.title } : {}),
+                ...(hydratedIssue.description ? { description: hydratedIssue.description } : {}),
+                ...(hydratedIssue.url ? { url: hydratedIssue.url } : {}),
+                ...(hydratedIssue.priority != null ? { priority: hydratedIssue.priority } : {}),
+                ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
+                ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
+                ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
+                ...(pendingRunType ? { pendingRunType, factoryState: "delegated" } : {}),
+                ...(clearPending ? { pendingRunType: null } : {}),
+                ...((pendingRunType || existingIssue?.pendingRunType === "implementation") && pendingRunContextJson
+                    ? { pendingRunContextJson }
+                    : {}),
+                ...(agentSessionId !== undefined ? { agentSessionId } : {}),
+                ...(runRelease.release ? { activeRunId: null } : {}),
+                ...(undelegation.factoryState ? { factoryState: undelegation.factoryState } : {}),
+            });
+            if (runRelease.release && activeRun && runRelease.reason) {
+                this.db.finishRun(activeRun.id, { status: "released", failureReason: runRelease.reason });
             }
-        }
-        // Resolve agent session
-        const agentSessionId = normalized.agentSession?.id ??
-            (!activeRun && (pendingRunType || (normalized.triggerEvent === "delegateChanged" && !delegated)) ? null : undefined);
-        // Upsert the issue
-        const issue = this.db.upsertIssue({
-            projectId: project.id,
-            linearIssueId: normalizedIssue.id,
-            ...(hydratedIssue.identifier ? { issueKey: hydratedIssue.identifier } : {}),
-            ...(hydratedIssue.title ? { title: hydratedIssue.title } : {}),
-            ...(hydratedIssue.description ? { description: hydratedIssue.description } : {}),
-            ...(hydratedIssue.url ? { url: hydratedIssue.url } : {}),
-            ...(hydratedIssue.priority != null ? { priority: hydratedIssue.priority } : {}),
-            ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
-            ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
-            ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
-            ...(pendingRunType ? { pendingRunType, factoryState: "delegated" } : {}),
-            ...(clearPendingImplementation ? { pendingRunType: null } : {}),
-            ...((pendingRunType || existingIssue?.pendingRunType === "implementation") && pendingRunContextJson
-                ? { pendingRunContextJson }
-                : {}),
-            ...(agentSessionId !== undefined ? { agentSessionId } : {}),
-            ...(clearActiveRun ? { activeRunId: null } : {}),
-            ...(undelegatedFactoryState ? { factoryState: undelegatedFactoryState } : {}),
+            return record;
         });
-        if (clearActiveRun && activeRun) {
-            const reason = terminalForAutomation ? "Issue reached terminal state during active run" : "Un-delegated from PatchRelay";
-            this.db.finishRun(activeRun.id, { status: "released", failureReason: reason });
-        }
-        if (undelegatedFactoryState) {
+        // ── 4. Side effects (after transaction) ──────────────────────
+        if (undelegation.factoryState) {
             this.feed?.publish({
                 level: "warn",
                 kind: "stage",
@@ -612,6 +612,41 @@ export class WebhookHandler {
         return undefined;
     }
 }
+// ─── Pure decision functions for recordDesiredStage ──────────────
+function decideRunIntent(p) {
+    if (p.delegated && p.triggerAllowed && p.unresolvedBlockers === 0
+        && !p.hasActiveRun && !p.hasPendingRun && !p.terminal) {
+        return "implementation";
+    }
+    return undefined;
+}
+function decideActiveRunRelease(p) {
+    if (!p.hasActiveRun)
+        return { release: false };
+    if (p.terminal)
+        return { release: true, reason: "Issue reached terminal state during active run" };
+    if (p.triggerEvent === "delegateChanged" && !p.delegated)
+        return { release: true, reason: "Un-delegated from PatchRelay" };
+    return { release: false };
+}
+function decideUnDelegation(p) {
+    if (p.triggerEvent !== "delegateChanged" || p.delegated)
+        return { clearPending: false };
+    if (!p.currentState)
+        return { clearPending: false };
+    const pastNoReturn = p.currentState === "awaiting_queue" || TERMINAL_STATES.has(p.currentState);
+    if (pastNoReturn)
+        return { clearPending: false };
+    return { factoryState: "awaiting_input", clearPending: true };
+}
+function decideAgentSession(p) {
+    if (p.sessionId)
+        return p.sessionId;
+    if (!p.hasActiveRun && (p.hasPendingRun || (p.triggerEvent === "delegateChanged" && !p.delegated)))
+        return null;
+    return undefined;
+}
+// ─── Helper predicates ──────────────────────────────────────────
 function isResolvedLinearState(stateType, stateName) {
     return stateType === "completed" || stateName?.trim().toLowerCase() === "done";
 }

package/package.json

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