patchrelay 0.68.7 → 0.69.1

package/dist/webhooks/comment-policy.js

@@ -31,6 +31,7 @@ export function isPatchRelayGeneratedActivityComment(body) {
         || body.startsWith("PatchRelay is already working on ")
         || body.startsWith("PatchRelay received the ")
         || body.startsWith("PatchRelay routed your latest instructions into ")
+        || body.startsWith("PatchRelay could not route your latest instructions into ")
         || body.startsWith("PatchRelay status:")
         || body.startsWith("PatchRelay did not start implementation ")
         || body.startsWith("PatchRelay has stopped work as requested.")
@@ -38,5 +39,22 @@ export function isPatchRelayGeneratedActivityComment(body) {
         || body === "This thread is for an agent session with patchrelay.";
 }
 export function hasExplicitPatchRelayWakeIntent(body) {
-    return /\bpatchrelay\b/i.test(body);
+    return extractPatchRelayAddressedText(body) !== undefined;
+}
+export function extractPatchRelayAddressedText(body) {
+    const trimmed = body.trim();
+    if (!trimmed)
+        return undefined;
+    const patterns = [
+        /^@?patchrelay\b[\s,:;-]*/i,
+        /^\bhey\s+@?patchrelay\b[\s,:;-]*/i,
+    ];
+    for (const pattern of patterns) {
+        const match = trimmed.match(pattern);
+        if (!match)
+            continue;
+        const rest = trimmed.slice(match[0].length).trim();
+        return rest || trimmed;
+    }
+    return undefined;
 }

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

@@ -1,20 +1,17 @@
-import { classifyFollowupIntent, followupIntentIsNonActionable, followupIntentQueuesWork } from "../followup-intent.js";
 import { triggerEventAllowed } from "../project-resolution.js";
-import { hasExplicitPatchRelayWakeIntent, isInertPatchRelayComment, isPatchRelayManagedCommentAuthor, } from "./comment-policy.js";
-import { classifyIssue } from "../issue-class.js";
-const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated", "awaiting_input"]);
+import { extractPatchRelayAddressedText, isInertPatchRelayComment, isPatchRelayManagedCommentAuthor, } from "./comment-policy.js";
 export class CommentWakeHandler {
     db;
-    codex;
     wakeDispatcher;
-    logger;
     feed;
-    constructor(db, codex, wakeDispatcher, logger, feed) {
+    conversationAdapter;
+    emitLinearActivity;
+    constructor(db, wakeDispatcher, feed, conversationAdapter, emitLinearActivity) {
         this.db = db;
-        this.codex = codex;
         this.wakeDispatcher = wakeDispatcher;
-        this.logger = logger;
         this.feed = feed;
+        this.conversationAdapter = conversationAdapter;
+        this.emitLinearActivity = emitLinearActivity;
     }
     async handle(params) {
         const { normalized, project, trackedIssue } = params;
@@ -28,10 +25,6 @@ export class CommentWakeHandler {
         const issue = this.db.issues.getIssue(project.id, normalized.issue.id);
         if (!issue)
             return;
-        const issueClass = classifyIssue({
-            issue,
-            childIssueCount: this.db.issues.listCanonicalChildIssues(project.id, normalized.issue.id).length,
-        }).issueClass;
         const trimmedBody = normalized.comment.body.trim();
         const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
         const selfAuthored = isPatchRelayManagedCommentAuthor(installation, normalized.actor, normalized.comment.userName);
@@ -58,168 +51,39 @@ export class CommentWakeHandler {
             });
             return;
         }
-        const directReply = params.isDirectReplyToOutstandingQuestion(issue);
-        const intent = classifyFollowupIntent(trimmedBody);
-        if (!issue.activeRunId) {
-            if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
-                const wakeIntent = issueClass === "orchestration" || directReply || 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;
-                }
-                if (intent === "stop") {
-                    this.wakeDispatcher.recordEventAndDispatch(project.id, normalized.issue.id, {
-                        eventType: "stop_requested",
-                        eventJson: JSON.stringify({
-                            body: trimmedBody,
-                            author: normalized.comment.userName,
-                        }),
-                    });
-                    this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(project.id, normalized.issue.id);
-                    this.feed?.publish({
-                        level: "info",
-                        kind: "comment",
-                        projectId: project.id,
-                        issueKey: trackedIssue?.issueKey,
-                        status: "stopped",
-                        summary: "Stop request recorded from Linear comment",
-                        detail: trimmedBody.slice(0, 200),
-                    });
-                    return;
-                }
-                if (!directReply && !followupIntentQueuesWork(intent)) {
-                    this.feed?.publish({
-                        level: "info",
-                        kind: "comment",
-                        projectId: project.id,
-                        issueKey: trackedIssue?.issueKey,
-                        status: intent === "status" ? "status_requested" : "ignored",
-                        summary: intent === "status"
-                            ? "Ignored status comment without queueing work"
-                            : "Ignored non-actionable follow-up comment",
-                        detail: trimmedBody.slice(0, 200),
-                    });
-                    return;
-                }
-                const runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
-                const queuedRunType = this.wakeDispatcher.recordEventAndDispatch(project.id, normalized.issue.id, {
-                    eventType: directReply ? "direct_reply" : "followup_comment",
-                    eventJson: JSON.stringify({
-                        body: trimmedBody,
-                        author: normalized.comment.userName,
-                    }),
-                });
-                this.feed?.publish({
-                    level: "info",
-                    kind: "comment",
-                    projectId: project.id,
-                    issueKey: trackedIssue?.issueKey,
-                    status: "enqueued",
-                    summary: `Comment enqueued ${(queuedRunType ?? runType)} run`,
-                    detail: trimmedBody.slice(0, 200),
-                });
-            }
-            return;
-        }
-        const run = this.db.runs.getRunById(issue.activeRunId);
-        if (!run?.threadId || !run.turnId)
-            return;
-        if (intent === "stop") {
-            try {
-                await this.codex.steerTurn({
-                    threadId: run.threadId,
-                    turnId: run.turnId,
-                    input: "STOP: The user has requested you stop working immediately. Do not make further changes. Wrap up and exit.",
-                });
-            }
-            catch (error) {
-                this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for comment stop request");
-            }
-            this.db.runs.finishRun(run.id, { status: "released", threadId: run.threadId, turnId: run.turnId });
-            this.db.issueSessions.upsertIssueRespectingActiveLease(project.id, normalized.issue.id, {
-                projectId: project.id,
-                linearIssueId: normalized.issue.id,
-                activeRunId: null,
-                factoryState: "awaiting_input",
-            });
-            this.wakeDispatcher.recordEventAndDispatch(project.id, normalized.issue.id, {
-                eventType: "stop_requested",
-                eventJson: JSON.stringify({
-                    body: trimmedBody,
-                    author: normalized.comment.userName,
-                }),
-            });
-            this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(project.id, normalized.issue.id);
+        const addressedText = extractPatchRelayAddressedText(trimmedBody);
+        if (!addressedText) {
             this.feed?.publish({
                 level: "info",
                 kind: "comment",
                 projectId: project.id,
                 issueKey: trackedIssue?.issueKey,
-                stage: run.runType,
-                status: "stopped",
-                summary: "Stop request delivered to active workflow",
-            });
-            return;
-        }
-        if (!directReply && followupIntentIsNonActionable(intent)) {
-            this.feed?.publish({
-                level: "info",
-                kind: "comment",
-                projectId: project.id,
-                issueKey: trackedIssue?.issueKey,
-                stage: run.runType,
-                status: intent === "status" ? "status_requested" : "ignored",
-                summary: intent === "status"
-                    ? "Ignored status comment without steering active workflow"
-                    : "Ignored non-actionable follow-up comment",
+                status: "ignored",
+                summary: "Ignored issue comment because it did not address PatchRelay",
                 detail: trimmedBody.slice(0, 200),
             });
             return;
         }
-        const body = [
-            "New Linear comment received while you are working.",
-            normalized.comment.userName ? `Author: ${normalized.comment.userName}` : undefined,
-            "",
-            trimmedBody,
-        ].filter(Boolean).join("\n");
-        try {
-            await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input: body });
+        const result = await this.conversationAdapter?.deliverAgentInput({
+            project,
+            issue,
+            source: "addressed_issue_comment",
+            body: addressedText,
+            author: normalized.comment.userName,
+            directReply: params.isDirectReplyToOutstandingQuestion(issue),
+            emitActivity: this.emitLinearActivity
+                ? (content, options) => this.emitLinearActivity(issue, content, options)
+                : undefined,
+        });
+        if (result?.queuedRunType) {
             this.feed?.publish({
                 level: "info",
                 kind: "comment",
                 projectId: project.id,
                 issueKey: trackedIssue?.issueKey,
-                stage: run.runType,
-                status: "delivered",
-                summary: `Delivered follow-up comment to active ${run.runType} workflow`,
-            });
-        }
-        catch (error) {
-            this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up comment");
-            const directReply = params.isDirectReplyToOutstandingQuestion(issue);
-            this.wakeDispatcher.recordEventAndDispatch(project.id, normalized.issue.id, {
-                eventType: directReply ? "direct_reply" : "followup_comment",
-                eventJson: JSON.stringify({
-                    body: trimmedBody,
-                    author: normalized.comment.userName,
-                }),
-            });
-            this.feed?.publish({
-                level: "warn",
-                kind: "comment",
-                projectId: project.id,
-                issueKey: trackedIssue?.issueKey,
-                stage: run.runType,
-                status: "delivery_failed",
-                summary: `Could not deliver follow-up comment to active ${run.runType} workflow`,
+                status: "enqueued",
+                summary: `Comment enqueued ${result.queuedRunType} run`,
+                detail: addressedText.slice(0, 200),
             });
         }
     }

package/infra/patchrelay.service

@@ -25,13 +25,13 @@ Environment=PATH=/home/your-user/.local/share/patchrelay/bin:/home/your-user/.lo
 #
 # When credstore is not configured, PatchRelay falls back to reading secrets
 # from env vars (EnvironmentFile, op run, etc.) via the resolve-secret module.
-LoadCredentialEncrypted=linear-webhook-secret
-LoadCredentialEncrypted=token-encryption-key
-LoadCredentialEncrypted=linear-oauth-client-id
-LoadCredentialEncrypted=linear-oauth-client-secret
+LoadCredentialEncrypted=linear-webhook-secret:/etc/credstore.encrypted/linear-webhook-secret.cred
+LoadCredentialEncrypted=token-encryption-key:/etc/credstore.encrypted/token-encryption-key.cred
+LoadCredentialEncrypted=linear-oauth-client-id:/etc/credstore.encrypted/linear-oauth-client-id.cred
+LoadCredentialEncrypted=linear-oauth-client-secret:/etc/credstore.encrypted/linear-oauth-client-secret.cred
 # Uncomment when GitHub App integration is configured:
-# LoadCredentialEncrypted=github-app-pem
-# LoadCredentialEncrypted=github-app-webhook-secret
+# LoadCredentialEncrypted=github-app-pem:/etc/credstore.encrypted/github-app-pem.cred
+# LoadCredentialEncrypted=github-app-webhook-secret:/etc/credstore.encrypted/github-app-webhook-secret.cred
 
 ExecStart=/usr/bin/env patchrelay serve
 Restart=on-failure

package/package.json

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