patchrelay 0.35.16 → 0.36.0

package/dist/webhook-handler.js

@@ -585,38 +585,55 @@ export class WebhookHandler {
         }
         if (!triggerEventAllowed(project, normalized.triggerEvent))
             return;
-        // Ignore PatchRelay's own comments to prevent self-triggering feedback loops.
-        // When a run completes, PatchRelay posts an activity to Linear, which fires a
-        // commentCreated webhook back — without this guard that re-enqueues a new run.
+        const issue = this.db.getIssue(project.id, normalized.issue.id);
+        if (!issue)
+            return;
+        const trimmedBody = normalized.comment.body.trim();
+        // Ignore PatchRelay-managed comments to prevent status-sync feedback loops.
+        // Linear commentUpdated/commentCreated events can arrive after PatchRelay
+        // refreshes its visible status comment, and those updates should never
+        // consume review-fix budget or wake a new run.
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
-        if (installation?.actorId && normalized.actor?.id === installation.actorId) {
+        const selfAuthored = this.isPatchRelayManagedCommentAuthor(installation, normalized.actor, normalized.comment.userName);
+        const inertPatchRelayComment = this.isInertPatchRelayComment(issue, normalized.comment.id, trimmedBody, normalized.actor?.type);
+        if (selfAuthored || inertPatchRelayComment) {
             this.db.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
                 projectId: project.id,
                 linearIssueId: normalized.issue.id,
                 eventType: "self_comment",
                 eventJson: JSON.stringify({
-                    body: normalized.comment.body.trim(),
+                    body: trimmedBody,
                     author: normalized.comment.userName,
                 }),
             });
             return;
         }
-        const issue = this.db.getIssue(project.id, normalized.issue.id);
-        if (!issue)
-            return;
         // No active run — enqueue a run with the comment as context if appropriate
         if (!issue.activeRunId) {
             const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated", "awaiting_input"]);
             if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
+                const directReply = this.isDirectReplyToOutstandingQuestion(issue);
+                const wakeIntent = directReply || this.hasExplicitPatchRelayWakeIntent(trimmedBody);
+                if (!wakeIntent) {
+                    this.feed?.publish({
+                        level: "info",
+                        kind: "comment",
+                        projectId: project.id,
+                        issueKey: trackedIssue?.issueKey,
+                        status: "ignored",
+                        summary: "Ignored comment with no explicit PatchRelay wake intent",
+                        detail: trimmedBody.slice(0, 200),
+                    });
+                    return;
+                }
                 const runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
                 const hadPendingWake = this.db.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
-                const directReply = this.isDirectReplyToOutstandingQuestion(issue);
                 this.db.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
                     projectId: project.id,
                     linearIssueId: normalized.issue.id,
                     eventType: directReply ? "direct_reply" : "followup_comment",
                     eventJson: JSON.stringify({
-                        body: normalized.comment.body.trim(),
+                        body: trimmedBody,
                         author: normalized.comment.userName,
                     }),
                 });
@@ -630,7 +647,7 @@ export class WebhookHandler {
                     issueKey: trackedIssue?.issueKey,
                     status: "enqueued",
                     summary: `Comment enqueued ${(queuedRunType ?? runType)} run`,
-                    detail: normalized.comment.body.slice(0, 200),
+                    detail: trimmedBody.slice(0, 200),
                 });
             }
             return;
@@ -642,7 +659,7 @@ export class WebhookHandler {
             "New Linear comment received while you are working.",
             normalized.comment.userName ? `Author: ${normalized.comment.userName}` : undefined,
             "",
-            normalized.comment.body.trim(),
+            trimmedBody,
         ].filter(Boolean).join("\n");
         try {
             await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input: body });
@@ -665,7 +682,7 @@ export class WebhookHandler {
                 linearIssueId: normalized.issue.id,
                 eventType: directReply ? "direct_reply" : "followup_comment",
                 eventJson: JSON.stringify({
-                    body: normalized.comment.body.trim(),
+                    body: trimmedBody,
                     author: normalized.comment.userName,
                 }),
             });
@@ -683,6 +700,47 @@ export class WebhookHandler {
             });
         }
     }
+    isInertPatchRelayComment(issue, commentId, body, actorType) {
+        if (commentId === issue.statusCommentId) {
+            return true;
+        }
+        if (body.startsWith("## PatchRelay status")
+            && body.includes("_PatchRelay updates this comment as it works. Review and merge remain downstream._")) {
+            return true;
+        }
+        const normalizedActorType = actorType?.trim().toLowerCase();
+        if (normalizedActorType && normalizedActorType !== "user") {
+            return this.isPatchRelayGeneratedActivityComment(body);
+        }
+        return false;
+    }
+    isPatchRelayManagedCommentAuthor(installation, actor, commentUserName) {
+        const actorName = actor?.name?.trim().toLowerCase();
+        const commentAuthor = commentUserName?.trim().toLowerCase();
+        const installationName = installation?.actorName?.trim().toLowerCase();
+        if (installation?.actorId && actor?.id === installation.actorId) {
+            return true;
+        }
+        if (installationName && actorName === installationName) {
+            return true;
+        }
+        if (actorName === "patchrelay" || commentAuthor === "patchrelay") {
+            return true;
+        }
+        return false;
+    }
+    isPatchRelayGeneratedActivityComment(body) {
+        return body.startsWith("PatchRelay needs human help to continue.")
+            || body.startsWith("PatchRelay is already working on ")
+            || body.startsWith("PatchRelay received the ")
+            || body.startsWith("PatchRelay routed your latest instructions into ")
+            || body.startsWith("PatchRelay has stopped work as requested.")
+            || body.startsWith("Merge preparation failed ")
+            || body === "This thread is for an agent session with patchrelay.";
+    }
+    hasExplicitPatchRelayWakeIntent(body) {
+        return /\bpatchrelay\b/i.test(body);
+    }
     peekPendingSessionWakeRunType(projectId, issueId) {
         return this.db.peekIssueSessionWake(projectId, issueId)?.runType;
     }

package/package.json

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