patchrelay 0.37.0 → 0.38.0

package/dist/webhooks/decision-helpers.js

@@ -1,4 +1,5 @@
 import { TERMINAL_STATES } from "../factory-state.js";
+import { deriveIssueSessionReactiveIntent } from "../issue-session.js";
 export function decideRunIntent(p) {
     const wakeEligibleState = p.currentState === undefined
         || p.currentState === "delegated"
@@ -26,10 +27,50 @@ export function decideUnDelegation(p) {
         return { clearPending: false };
     if (!p.currentState)
         return { clearPending: false };
-    const pastNoReturn = p.currentState === "awaiting_queue" || TERMINAL_STATES.has(p.currentState);
-    if (pastNoReturn)
+    if (TERMINAL_STATES.has(p.currentState))
         return { clearPending: false };
-    return { factoryState: "awaiting_input", clearPending: true };
+    return { factoryState: p.currentState, clearPending: true };
+}
+export function resolveReDelegationResume(p) {
+    if (!p.delegated || p.previouslyDelegated !== false) {
+        return {};
+    }
+    if (p.prState === "merged") {
+        return { factoryState: "done", pendingRunType: null };
+    }
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: true,
+        prNumber: p.prNumber,
+        prState: p.prState,
+        prReviewState: p.prReviewState,
+        prCheckStatus: p.prCheckStatus,
+        latestFailureSource: p.latestFailureSource,
+    });
+    if (reactiveIntent) {
+        return {
+            factoryState: reactiveIntent.compatibilityFactoryState,
+            pendingRunType: reactiveIntent.runType,
+        };
+    }
+    if (p.prNumber !== undefined && (p.prState === undefined || p.prState === "open")) {
+        if (p.prReviewState === "approved") {
+            return { factoryState: "awaiting_queue", pendingRunType: null };
+        }
+        return { factoryState: "pr_open", pendingRunType: null };
+    }
+    if (p.currentState === "awaiting_input" && p.awaitingInputReason === "completion_check_question") {
+        return {
+            factoryState: "awaiting_input",
+            pendingRunType: null,
+        };
+    }
+    if (p.currentState === "awaiting_input" || p.currentState === "delegated" || p.currentState === "implementing") {
+        return {
+            factoryState: "delegated",
+            pendingRunType: (p.unresolvedBlockers ?? 0) === 0 ? "implementation" : null,
+        };
+    }
+    return {};
 }
 export function decideAgentSession(p) {
     if (p.sessionId)

package/dist/webhooks/dependency-readiness-handler.js

@@ -27,6 +27,7 @@ export class DependencyReadinessHandler {
                 continue;
             }
             if (issue.factoryState !== "delegated"
+                || !issue.delegatedToPatchRelay
                 || issue.activeRunId !== undefined
                 || this.db.issueSessions.hasPendingIssueSessionEvents(projectId, dependent.linearIssueId)) {
                 continue;

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

@@ -1,5 +1,7 @@
 import { triggerEventAllowed } from "../project-resolution.js";
-import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, } from "./decision-helpers.js";
+import { resolveAwaitingInputReason } from "../awaiting-input-reason.js";
+import { decideActiveRunRelease, decideAgentSession, decideRunIntent, decideUnDelegation, isTerminalDelegationState, mergeIssueMetadata, resolveReDelegationResume, } from "./decision-helpers.js";
+import { buildOperatorRetryEvent } from "../operator-retry-event.js";
 export class DesiredStageRecorder {
     db;
     linearProvider;
@@ -16,6 +18,7 @@ export class DesiredStageRecorder {
         }
         const existingIssue = this.db.issues.getIssue(params.project.id, normalizedIssue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
+        const latestRun = existingIssue ? this.db.runs.getLatestRunForIssue(params.project.id, normalizedIssue.id) : undefined;
         const delegated = this.isDelegatedToPatchRelay(params.project, params.normalized);
         const triggerAllowed = triggerEventAllowed(params.project, params.normalized.triggerEvent);
         const incomingAgentSessionId = params.normalized.agentSession?.id;
@@ -46,11 +49,22 @@ export class DesiredStageRecorder {
             triggerEvent: params.normalized.triggerEvent,
             delegated,
             currentState: existingIssue?.factoryState,
+            hasPr: existingIssue?.prNumber !== undefined && existingIssue?.prState !== "merged",
+        });
+        const reDelegationResume = resolveReDelegationResume({
+            delegated,
+            previouslyDelegated: existingIssue?.delegatedToPatchRelay,
+            currentState: existingIssue?.factoryState,
+            awaitingInputReason: existingIssue
+                ? resolveAwaitingInputReason({ issue: existingIssue, latestRun })
+                : undefined,
+            unresolvedBlockers,
+            prNumber: existingIssue?.prNumber,
+            prState: existingIssue?.prState,
+            prReviewState: existingIssue?.prReviewState,
+            prCheckStatus: existingIssue?.prCheckStatus,
+            latestFailureSource: existingIssue?.lastGitHubFailureSource,
         });
-        const delegatedStateRecovery = delegated
-            && !terminal
-            && existingIssue?.factoryState === "awaiting_input"
-            && !undelegation.factoryState;
         const existingWakeRunType = existingIssue
             ? params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id)
             : undefined;
@@ -73,9 +87,13 @@ export class DesiredStageRecorder {
                 ...(hydratedIssue.estimate != null ? { estimate: hydratedIssue.estimate } : {}),
                 ...(hydratedIssue.stateName ? { currentLinearState: hydratedIssue.stateName } : {}),
                 ...(hydratedIssue.stateType ? { currentLinearStateType: hydratedIssue.stateType } : {}),
+                delegatedToPatchRelay: delegated,
                 ...(!existingIssue && !delegated && incomingAgentSessionId ? { factoryState: "awaiting_input" } : {}),
-                ...(delegatedStateRecovery ? { factoryState: "delegated" } : {}),
-                ...(desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
+                ...(reDelegationResume.factoryState ? { factoryState: reDelegationResume.factoryState } : {}),
+                ...(reDelegationResume.pendingRunType !== undefined
+                    ? { pendingRunType: null, pendingRunContextJson: null }
+                    : {}),
+                ...(!reDelegationResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
                 ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(agentSessionId !== undefined ? { agentSessionId } : {}),
                 ...(runRelease.release ? { activeRunId: null } : {}),
@@ -111,12 +129,24 @@ export class DesiredStageRecorder {
                 kind: "stage",
                 issueKey: issue.issueKey,
                 projectId: params.project.id,
-                stage: "awaiting_input",
+                stage: issue.factoryState,
                 status: "un_delegated",
-                summary: "Issue un-delegated from PatchRelay",
+                summary: issue.factoryState === "awaiting_input"
+                    ? "Issue un-delegated from PatchRelay"
+                    : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
+            });
+        }
+        else if (reDelegationResume.pendingRunType) {
+            this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
+                projectId: params.project.id,
+                linearIssueId: normalizedIssue.id,
+                ...buildOperatorRetryEvent(issue, reDelegationResume.pendingRunType, "re_delegated"),
             });
         }
-        else if (desiredStage === "implementation"
+        else if (!reDelegationResume.factoryState
+            && !reDelegationResume.pendingRunType
+            &&
+                desiredStage === "implementation"
             && params.normalized.triggerEvent !== "commentCreated"
             && params.normalized.triggerEvent !== "commentUpdated"
             && params.normalized.triggerEvent !== "agentPrompted") {

package/package.json

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