patchrelay 0.73.2 → 0.73.3

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.73.2",
-  "commit": "af2df414ed0e",
-  "builtAt": "2026-05-26T00:15:44.683Z"
+  "version": "0.73.3",
+  "commit": "3342a5c6bbc1",
+  "builtAt": "2026-05-26T13:58:45.864Z"
 }

package/dist/idle-reconciliation.js

@@ -17,15 +17,17 @@ export class IdleIssueReconciler {
     logger;
     feed;
     deployEvaluator;
+    syncIssue;
     constructor(db, config, wakeDispatcher, logger, feed, 
     // Injectable for tests; production uses the real `gh`-backed watcher.
-    deployEvaluator = evaluateDeploy) {
+    deployEvaluator = evaluateDeploy, syncIssue) {
         this.db = db;
         this.config = config;
         this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
         this.deployEvaluator = deployEvaluator;
+        this.syncIssue = syncIssue;
     }
     async reconcile() {
         // Wrap the entire reconcile pass in a dispatcher tick. Every
@@ -251,6 +253,12 @@ export class IdleIssueReconciler {
                 }
                 : {}),
         });
+        const updatedIssue = this.db.issues.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        if (this.syncIssue) {
+            void Promise.resolve(this.syncIssue(updatedIssue)).catch((error) => {
+                this.logger.warn({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to sync Linear workflow state after idle reconciliation");
+            });
+        }
         if (options?.pendingRunType) {
             this.recordWakeEvent(issue, options.pendingRunType, options.pendingRunContext, "idle_reconciliation");
         }

package/dist/run-orchestrator.js

@@ -134,7 +134,7 @@ export class RunOrchestrator {
         this.interruptedRunRecovery = new InterruptedRunRecovery(db, logger, this.linearSync, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.recoveryPorts.failRunAndClear, this.recoveryPorts.restoreIdleWorktree, this.runCompletionPolicy, (projectId, issueId) => this.enqueueIssue(projectId, issueId), feed);
         this.runReconciler = new RunReconciler(db, logger, linearProvider, this.linearSync, this.interruptedRunRecovery, this.runFinalizer, this.leasePorts.withHeldLease, this.leasePorts.releaseLease, this.threadPorts.readThreadWithRetry, this.recoveryPorts.recoverOrEscalate, (projectId) => this.config.projects.find((project) => project.id === projectId)?.github?.repoFullName, feed);
         this.runWakePlanner = new RunWakePlanner(db);
-        this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed);
+        this.idleReconciler = new IdleIssueReconciler(db, config, this.wakeDispatcher, logger, feed, undefined, (issue) => this.linearSync.syncSession(issue));
         this.mergedLinearCompletionReconciler = new MergedLinearCompletionReconciler(db, linearProvider, logger);
         this.queueHealthMonitor = new QueueHealthMonitor(db, config, {
             advanceIdleIssue: (issue, newState, options) => this.idleReconciler.advanceIdleIssue(issue, newState, options),

package/dist/webhooks/decision-helpers.js

@@ -18,12 +18,12 @@ export function decideActiveRunRelease(p) {
         return { release: false };
     if (p.terminal)
         return { release: true, reason: "Issue reached terminal state during active run" };
-    if (p.triggerEvent === "delegateChanged" && !p.delegated)
+    if (!p.delegated)
         return { release: true, reason: "Un-delegated from PatchRelay" };
     return { release: false };
 }
 export function decideUnDelegation(p) {
-    if (p.triggerEvent !== "delegateChanged" || p.delegated)
+    if (p.delegated)
         return { clearPending: false };
     if (!p.currentState)
         return { clearPending: false };

package/dist/webhooks/delegation-truth.js

@@ -18,11 +18,14 @@ export function resolveDelegationTruth(input) {
     const observedDelegated = isDelegatedToPatchRelay(input.db, input.project, input.hydratedIssue);
     const explicitDelegateSignal = input.triggerEvent === "delegateChanged";
     const hasObservedDelegate = input.hydratedIssue.delegateId !== undefined;
+    const authoritativeDelegateObservation = hasObservedDelegate || explicitDelegateSignal || input.hydration === "live_linear";
     let delegated = observedDelegated;
     let reason = hasObservedDelegate
         ? "delegate_id_present"
-        : `missing_delegate_identity_after_${input.hydration}`;
-    if (!hasObservedDelegate && !explicitDelegateSignal && previousDelegated !== undefined) {
+        : input.hydration === "live_linear"
+            ? "live_linear_delegate_absent"
+            : `missing_delegate_identity_after_${input.hydration}`;
+    if (!authoritativeDelegateObservation && previousDelegated !== undefined) {
         delegated = previousDelegated;
         reason = `preserved_previous_delegation_after_${input.hydration}`;
     }

package/dist/webhooks.js

@@ -75,15 +75,15 @@ function deriveTriggerEvent(payload) {
             return "issueRemoved";
         }
         const updatedFields = new Set(Object.keys(payload.updatedFrom ?? {}));
+        if (updatedFields.has("delegateId") || updatedFields.has("delegate")) {
+            return "delegateChanged";
+        }
         if (updatedFields.has("labels")) {
             return "labelChanged";
         }
         if (updatedFields.has("stateId") || updatedFields.has("state")) {
             return "statusChanged";
         }
-        if (updatedFields.has("delegateId") || updatedFields.has("delegate")) {
-            return "delegateChanged";
-        }
         if (updatedFields.has("assigneeId") || updatedFields.has("assignee")) {
             return "assignmentChanged";
         }

package/package.json

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