patchrelay 0.38.1 → 0.39.0

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

@@ -19,16 +19,22 @@ 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;
         const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(params.project.id, normalizedIssue.id) !== undefined;
-        if (!existingIssue && !delegated && !incomingAgentSessionId) {
-            return { issue: undefined, wakeRunType: undefined, delegated };
+        if (!existingIssue && !this.isDelegatedToPatchRelay(params.project, normalizedIssue) && !incomingAgentSessionId) {
+            return { issue: undefined, wakeRunType: undefined, delegated: false };
         }
         const hydratedIssue = await this.syncIssueDependencies(params.project.id, normalizedIssue);
+        const delegated = this.isDelegatedToPatchRelay(params.project, hydratedIssue);
         const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(params.project.id, normalizedIssue.id);
         const terminal = isTerminalDelegationState(existingIssue, hydratedIssue);
+        const openPrExists = existingIssue?.prNumber !== undefined
+            && existingIssue.prState !== "closed"
+            && existingIssue.prState !== "merged";
+        const blockerPausedImplementation = unresolvedBlockers > 0
+            && activeRun?.runType === "implementation"
+            && !openPrExists;
         const desiredStage = decideRunIntent({
             delegated,
             triggerAllowed,
@@ -45,6 +51,9 @@ export class DesiredStageRecorder {
             triggerEvent: params.normalized.triggerEvent,
             delegated,
         });
+        const effectiveRunRelease = blockerPausedImplementation
+            ? { release: true, reason: "Issue became blocked during implementation" }
+            : runRelease;
         const undelegation = decideUnDelegation({
             triggerEvent: params.normalized.triggerEvent,
             delegated,
@@ -96,11 +105,12 @@ export class DesiredStageRecorder {
                 ...(!reDelegationResume.factoryState && desiredStage ? { pendingRunType: null, pendingRunContextJson: null, factoryState: "delegated" } : {}),
                 ...(clearPending ? { pendingRunType: null, pendingRunContextJson: null } : {}),
                 ...(agentSessionId !== undefined ? { agentSessionId } : {}),
-                ...(runRelease.release ? { activeRunId: null } : {}),
+                ...(effectiveRunRelease.release ? { activeRunId: null } : {}),
+                ...(blockerPausedImplementation ? { factoryState: "delegated" } : {}),
                 ...(undelegation.factoryState ? { factoryState: undelegation.factoryState } : {}),
             });
-            if (runRelease.release && activeRun && runRelease.reason) {
-                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: runRelease.reason });
+            if (effectiveRunRelease.release && activeRun && effectiveRunRelease.reason) {
+                this.db.runs.finishRun(activeRun.id, { status: "released", failureReason: effectiveRunRelease.reason });
             }
             return record;
         };
@@ -136,6 +146,22 @@ export class DesiredStageRecorder {
                     : `Issue un-delegated from PatchRelay; ${issue.factoryState} is now paused`,
             });
         }
+        else if (blockerPausedImplementation) {
+            if (activeRun?.threadId && activeRun.turnId) {
+                await params.stopActiveRun(activeRun, "STOP: The issue is now blocked by another task. Stop working immediately and exit without publishing.");
+            }
+            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(params.project.id, normalizedIssue.id);
+            this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(params.project.id, normalizedIssue.id);
+            this.feed?.publish({
+                level: "warn",
+                kind: "stage",
+                issueKey: issue.issueKey,
+                projectId: params.project.id,
+                stage: issue.factoryState,
+                status: "blocked",
+                summary: `Implementation paused because ${issue.issueKey ?? normalizedIssue.id} is now blocked`,
+            });
+        }
         else if (reDelegationResume.pendingRunType) {
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.project.id, normalizedIssue.id, {
                 projectId: params.project.id,
@@ -168,13 +194,11 @@ export class DesiredStageRecorder {
             delegated,
         };
     }
-    isDelegatedToPatchRelay(project, normalized) {
-        if (!normalized.issue)
-            return false;
+    isDelegatedToPatchRelay(project, issue) {
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
         if (!installation?.actorId)
             return false;
-        return normalized.issue.delegateId === installation.actorId;
+        return issue.delegateId === installation.actorId;
     }
     async syncIssueDependencies(projectId, issue) {
         let source = issue;

package/package.json

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