patchrelay 0.68.2 → 0.68.4

package/dist/webhooks/desired-stage-recorder.js

@@ -7,6 +7,7 @@ import { isDelegatedToPatchRelay, resolveDelegationTruth } from "./delegation-tr
 import { syncIssueDependencies } from "./issue-dependency-sync.js";
 import { resolveLinkedPrAdoption } from "./linked-pr-adoption.js";
 import { buildOperatorRetryEvent } from "../operator-retry-event.js";
+import { resolveIssueUpdatePlan } from "./issue-update-plan.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -143,6 +144,21 @@ export class DesiredStageRecorder {
             delegated,
         });
         const terminalRunRelease = effectiveRunRelease.release && terminal;
+        const resolvedPlan = resolveIssueUpdatePlan({
+            existingIssue: Boolean(existingIssue),
+            delegated,
+            incomingAgentSessionId,
+            startupResume,
+            desiredStage,
+            terminalRunRelease,
+            blockerPausedImplementation,
+            undelegation,
+            clearPending,
+            effectiveRunRelease,
+            shouldEnterOrchestrationSettle,
+            agentSessionId,
+            computeOrchestrationSettleUntil,
+        });
         const commitIssueUpdate = () => {
             const record = this.db.issues.upsertIssue({
                 projectId: params.project.id,
@@ -161,24 +177,7 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
                 ...(linkedPrAdoption?.issueUpdates ?? {}),
                 delegatedToPatchRelay: delegated,
-                ...(!existingIssue && !delegated && incomingAgentSessionId ? { factoryState: "awaiting_input" } : {}),
-                ...(startupResume.factoryState ? { factoryState: startupResume.factoryState } : {}),
-                ...(startupResume.pendingRunType !== undefined
-                    ? {
-                        pendingRunType: null,
-                        pendingRunContextJson: startupResume.pendingRunContext
-                            ? JSON.stringify(startupResume.pendingRunContext)
-                            : null,
-                    }
-                    : {}),
-                ...(!startupResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
-                ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
-                ...(agentSessionId !== undefined ? { agentSessionId } : {}),
-                ...(effectiveRunRelease.release ? { activeRunId: null } : {}),
-                ...(terminalRunRelease ? { factoryState: "done", pendingRunType: null, pendingRunContextJson: null } : {}),
-                ...(blockerPausedImplementation ? { factoryState: "delegated" } : {}),
-                ...(undelegation.factoryState ? { factoryState: undelegation.factoryState } : {}),
-                ...(shouldEnterOrchestrationSettle ? { orchestrationSettleUntil: computeOrchestrationSettleUntil() } : {}),
+                ...resolvedPlan,
             });
             if (effectiveRunRelease.release && activeRun && effectiveRunRelease.reason) {
                 this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: effectiveRunRelease.reason });

package/dist/webhooks/issue-update-plan.js

@@ -0,0 +1,74 @@
+/**
+ * Picks the single factoryState the caller should write. Priority is the
+ * inverse of the previous spread order — the LAST spread wins in JS, so we
+ * reverse that into a TOP-DOWN check:
+ *
+ *   1. explicit undelegation
+ *   2. blocker-paused implementation (force back to `delegated`)
+ *   3. terminal run release (mark `done`)
+ *   4. fresh `desiredStage` decision (mark `delegated`)
+ *      — but only if startupResume didn't already pick a state
+ *   5. startup resume override
+ *   6. new undelegated + agent-session fallback → `awaiting_input`
+ *   7. no change
+ */
+export function resolveFactoryState(input) {
+    if (input.undelegation.factoryState)
+        return input.undelegation.factoryState;
+    if (input.blockerPausedImplementation)
+        return "delegated";
+    if (input.terminalRunRelease)
+        return "done";
+    if (input.desiredStage && !input.startupResume.factoryState)
+        return "delegated";
+    if (input.startupResume.factoryState)
+        return input.startupResume.factoryState;
+    if (!input.existingIssue && !input.delegated && input.incomingAgentSessionId) {
+        return "awaiting_input";
+    }
+    return undefined;
+}
+/**
+ * Should we clear `pendingRunType` + `pendingRunContextJson`? Several upstream
+ * conditions can independently request this; the resolver folds them into one
+ * predicate.
+ */
+function shouldClearPending(input) {
+    if (input.terminalRunRelease)
+        return true;
+    if (input.clearPending)
+        return true;
+    if (input.desiredStage && !input.startupResume.factoryState)
+        return true;
+    if (input.startupResume.pendingRunType !== undefined)
+        return true;
+    return false;
+}
+function buildStartupResumeContextJson(input) {
+    if (input.startupResume.pendingRunType === undefined)
+        return undefined;
+    return input.startupResume.pendingRunContext
+        ? JSON.stringify(input.startupResume.pendingRunContext)
+        : null;
+}
+export function resolveIssueUpdatePlan(input) {
+    const resolved = {};
+    const factoryState = resolveFactoryState(input);
+    if (factoryState) {
+        resolved.factoryState = factoryState;
+    }
+    if (shouldClearPending(input)) {
+        resolved.pendingRunType = null;
+        resolved.pendingRunContextJson = buildStartupResumeContextJson(input) ?? null;
+    }
+    if (input.effectiveRunRelease.release) {
+        resolved.activeRunId = null;
+    }
+    if (input.agentSessionId !== undefined) {
+        resolved.agentSessionId = input.agentSessionId;
+    }
+    if (input.shouldEnterOrchestrationSettle) {
+        resolved.orchestrationSettleUntil = input.computeOrchestrationSettleUntil();
+    }
+    return resolved;
+}

package/package.json

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