patchrelay 0.37.1 → 0.38.1

package/dist/tracked-issue-projector.js

@@ -10,6 +10,7 @@ export function buildTrackedIssueRecord(params) {
     const failureContext = parseGitHubFailureContext(params.issue.lastGitHubFailureContextJson);
     const blockedByKeys = unresolvedBlockedBy.map((entry) => entry.blockerIssueKey ?? entry.blockerLinearIssueId);
     const waitingReason = derivePatchRelayWaitingReason({
+        delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
         ...(params.issue.activeRunId !== undefined ? { activeRunId: params.issue.activeRunId } : {}),
         blockedByKeys,
         factoryState: params.issue.factoryState,
@@ -40,6 +41,7 @@ export function buildTrackedIssueRecord(params) {
         id: params.issue.id,
         projectId: params.issue.projectId,
         linearIssueId: params.issue.linearIssueId,
+        delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
         ...(params.issue.issueKey ? { issueKey: params.issue.issueKey } : {}),
         ...(params.issue.title ? { title: params.issue.title } : {}),
         ...(params.issue.url ? { issueUrl: params.issue.url } : {}),
@@ -56,6 +58,7 @@ export function buildTrackedIssueRecord(params) {
         readyForExecution: isIssueSessionReadyForExecution({
             sessionState: params.session?.sessionState,
             factoryState: params.issue.factoryState,
+            delegatedToPatchRelay: params.issue.delegatedToPatchRelay,
             activeRunId: params.issue.activeRunId,
             blockedByCount: unresolvedBlockedBy.length,
             hasPendingWake: params.hasPendingWake,

package/dist/waiting-reason.js

@@ -1,6 +1,8 @@
 import { hasOpenPr } from "./pr-state.js";
 export const PATCHRELAY_WAITING_REASONS = {
     activeWork: "PatchRelay is actively working",
+    automationPaused: "PatchRelay automation is paused because the issue is undelegated",
+    automationPausedDownstream: "PatchRelay automation is paused; downstream merge may still continue until the PR is closed",
     finalizingPublishedPr: "PatchRelay is finalizing a published PR",
     finalizingMergedChange: "PatchRelay is finalizing a merged change",
     waitingForOperatorInput: "Waiting on operator input",
@@ -14,6 +16,11 @@ export const PATCHRELAY_WAITING_REASONS = {
     waitingForExternalReview: "Waiting on external review",
 };
 export function derivePatchRelayWaitingReason(params) {
+    if (params.delegatedToPatchRelay === false && params.factoryState !== "done" && params.factoryState !== "failed" && params.factoryState !== "escalated") {
+        return params.factoryState === "awaiting_queue" || (hasLiveOpenPr(params.prNumber, params.prState) && params.prReviewState === "approved")
+            ? PATCHRELAY_WAITING_REASONS.automationPausedDownstream
+            : PATCHRELAY_WAITING_REASONS.automationPaused;
+    }
     if (params.activeRunType) {
         if (hasOpenPr(params.prNumber, params.prState) && (params.factoryState === "pr_open" || params.factoryState === "awaiting_queue")) {
             return PATCHRELAY_WAITING_REASONS.finalizingPublishedPr;
@@ -78,3 +85,6 @@ export function derivePatchRelayWaitingReason(params) {
 function humanize(value) {
     return value.replaceAll("_", " ");
 }
+function hasLiveOpenPr(prNumber, prState) {
+    return prNumber !== undefined && (prState === undefined || prState === "open");
+}

package/dist/webhooks/agent-session-handler.js

@@ -26,6 +26,7 @@ export class AgentSessionHandler {
             return;
         const existingIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
         const activeRun = existingIssue?.activeRunId ? this.db.runs.getRunById(existingIssue.activeRunId) : undefined;
+        const automationEnabled = delegated || existingIssue?.delegatedToPatchRelay === true;
         if (normalized.triggerEvent === "agentSessionCreated") {
             if (!delegated) {
                 const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
@@ -70,6 +71,13 @@ export class AgentSessionHandler {
         if (!triggerEventAllowed(project, normalized.triggerEvent))
             return;
         const promptBody = normalized.agentSession.promptBody?.trim();
+        if (!automationEnabled && promptBody && existingIssue) {
+            await this.publishAgentActivity(linear, normalized.agentSession.id, {
+                type: "thought",
+                body: "PatchRelay is paused because the issue is undelegated.",
+            }, { ephemeral: true });
+            return;
+        }
         if (activeRun && promptBody && activeRun.threadId && activeRun.turnId) {
             const input = `New Linear agent prompt received while you are working.\n\n${promptBody}`;
             try {
@@ -99,7 +107,7 @@ export class AgentSessionHandler {
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
             return;
         }
-        if (promptBody && existingIssue && (delegated || existingIssue.factoryState === "awaiting_input")) {
+        if (promptBody && existingIssue && automationEnabled) {
             const hadPendingWake = this.db.issueSessions.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
             const directReply = params.isDirectReplyToOutstandingQuestion(existingIssue);
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {

package/dist/webhooks/comment-wake-handler.js

@@ -40,6 +40,18 @@ export class CommentWakeHandler {
             });
             return;
         }
+        if (!issue.delegatedToPatchRelay) {
+            this.feed?.publish({
+                level: "info",
+                kind: "comment",
+                projectId: project.id,
+                issueKey: trackedIssue?.issueKey,
+                status: "ignored_undelegated",
+                summary: "Ignored comment because the issue is undelegated",
+                detail: trimmedBody.slice(0, 200),
+            });
+            return;
+        }
         if (!issue.activeRunId) {
             if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
                 const directReply = params.isDirectReplyToOutstandingQuestion(issue);

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.1",
+  "version": "0.38.1",
   "license": "MIT",
   "type": "module",
   "repository": {