patchrelay 0.68.6 → 0.69.0

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

@@ -1,10 +1,7 @@
 import { buildAgentSessionPlanForIssue, } from "../agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "../agent-session-presentation.js";
-import { classifyFollowupIntent, followupIntentIsNonActionable } from "../followup-intent.js";
-import { extractLatestAssistantSummary } from "../issue-session-events.js";
-import { buildAlreadyRunningThought, buildAgentSessionAcknowledgementThought, buildBlockedDelegationActivity, buildDelegationThought, buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveredThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
+import { buildAlreadyRunningThought, buildAgentSessionAcknowledgementThought, buildBlockedDelegationActivity, buildDelegationThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
 import { resolveProject, triggerEventAllowed } from "../project-resolution.js";
-import { deriveIssueStatusNote } from "../status-note.js";
 const PATCHRELAY_AGENT_ACTIVITY_TYPES = new Set([
     "action",
     "elicitation",
@@ -20,7 +17,8 @@ export class AgentSessionHandler {
     wakeDispatcher;
     logger;
     feed;
-    constructor(config, db, linearProvider, codex, wakeDispatcher, logger, feed) {
+    conversationAdapter;
+    constructor(config, db, linearProvider, codex, wakeDispatcher, logger, feed, conversationAdapter) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -28,6 +26,7 @@ export class AgentSessionHandler {
         this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
+        this.conversationAdapter = conversationAdapter;
     }
     async acknowledgeCreated(normalized) {
         if (normalized.triggerEvent !== "agentSessionCreated" || !normalized.agentSession?.id || !normalized.issue) {
@@ -65,7 +64,6 @@ 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);
@@ -128,78 +126,23 @@ export class AgentSessionHandler {
         }
         const promptBody = normalized.agentSession.promptBody?.trim();
         const directReply = promptBody && existingIssue ? params.isDirectReplyToOutstandingQuestion(existingIssue) : false;
-        const promptIntent = promptBody ? classifyFollowupIntent(promptBody) : undefined;
-        if (promptBody && existingIssue && promptIntent === "stop") {
-            await this.handleStopSignal({
-                normalized,
+        if (promptBody && existingIssue && this.conversationAdapter) {
+            const result = await this.conversationAdapter.deliverAgentInput({
                 project,
-                trackedIssue,
-                activeRun,
-                linear,
-                syncAgentSession: (agentSessionId, issue, options) => this.syncAgentSession(linear, agentSessionId, issue, params.peekPendingSessionWakeRunType, options),
-            });
-            return;
-        }
-        if (promptBody && existingIssue && promptIntent === "status" && !directReply) {
-            await this.publishAgentActivity(linear, normalized.agentSession.id, this.buildStatusActivity(existingIssue, activeRun, params.peekPendingSessionWakeRunType));
-            await this.syncAgentSession(linear, normalized.agentSession.id, existingIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, activeRun ? { activeRunType: activeRun.runType } : undefined);
-            return;
-        }
-        if (promptBody && promptIntent && followupIntentIsNonActionable(promptIntent) && !directReply) {
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildNonActionableFollowupActivity(promptIntent));
-            return;
-        }
-        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 {
-                await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
-                this.feed?.publish({
-                    level: "info",
-                    kind: "agent",
-                    projectId: project.id,
-                    issueKey: trackedIssue?.issueKey,
-                    stage: activeRun.runType,
-                    status: "delivered",
-                    summary: `Delivered follow-up prompt to active ${activeRun.runType} workflow`,
-                });
-            }
-            catch (error) {
-                this.logger.warn({ issueKey: trackedIssue?.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to deliver follow-up prompt");
-                this.feed?.publish({
-                    level: "warn",
-                    kind: "agent",
-                    projectId: project.id,
-                    issueKey: trackedIssue?.issueKey,
-                    stage: activeRun.runType,
-                    status: "delivery_failed",
-                    summary: `Could not deliver follow-up prompt to active ${activeRun.runType} workflow`,
-                });
-            }
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
-            return;
-        }
-        if (promptBody && existingIssue && automationEnabled) {
-            if (!directReply && promptIntent && followupIntentIsNonActionable(promptIntent)) {
-                await this.publishAgentActivity(linear, normalized.agentSession.id, buildNonActionableFollowupActivity(promptIntent));
-                return;
-            }
-            const queuedRunType = this.wakeDispatcher.recordEventAndDispatch(project.id, normalized.issue.id, {
-                eventType: directReply ? "direct_reply" : "followup_prompt",
-                eventJson: JSON.stringify({
-                    text: promptBody,
-                    source: "linear_agent_prompt",
-                }),
+                issue: existingIssue,
+                source: "agent_session_prompt",
+                body: promptBody,
+                directReply,
+                emitActivity: (content, options) => this.publishAgentActivity(linear, normalized.agentSession.id, content, options),
+                peekPendingSessionWakeRunType: params.peekPendingSessionWakeRunType,
             });
             const latestIssue = this.db.issues.getIssue(project.id, normalized.issue.id);
-            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, { pendingRunType: queuedRunType ?? wakeRunType ?? (existingIssue.prReviewState === "changes_requested" ? "review_fix" : "implementation") });
-            await this.publishAgentActivity(linear, normalized.agentSession.id, buildPromptDeliveredThought(queuedRunType ?? wakeRunType ?? "implementation"), { ephemeral: true });
+            const syncOptions = result.activeRunType
+                ? { activeRunType: result.activeRunType }
+                : result.queuedRunType ? { pendingRunType: result.queuedRunType }
+                    : wakeRunType ? { pendingRunType: wakeRunType }
+                        : undefined;
+            await this.syncAgentSession(linear, normalized.agentSession.id, latestIssue ?? trackedIssue, params.peekPendingSessionWakeRunType, syncOptions);
             return;
         }
         if (wakeRunType) {
@@ -208,24 +151,6 @@ export class AgentSessionHandler {
             await this.publishAgentActivity(linear, normalized.agentSession.id, buildDelegationThought(wakeRunType, "prompt"), { ephemeral: true });
         }
     }
-    buildStatusActivity(issue, activeRun, peekPendingSessionWakeRunType) {
-        const latestRun = activeRun ?? this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-        const latestEvent = this.db.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId).at(-1);
-        const statusNote = deriveIssueStatusNote({
-            issue,
-            latestRun,
-            latestEvent,
-            sessionSummary: extractLatestAssistantSummary(latestRun),
-            waitingReason: undefined,
-        });
-        const pendingRunType = peekPendingSessionWakeRunType(issue.projectId, issue.linearIssueId);
-        return buildFollowupStatusActivity({
-            issue,
-            ...(statusNote ? { statusNote } : {}),
-            ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}),
-            ...(pendingRunType ? { pendingRunType } : {}),
-        });
-    }
     async handleStopSignal(params) {
         const issueId = params.normalized.issue.id;
         const sessionId = params.normalized.agentSession.id;

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/package.json

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