patchrelay 0.55.2 → 0.56.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.55.2",
-  "commit": "8e07dee509b9",
-  "builtAt": "2026-05-01T14:20:04.619Z"
+  "version": "0.56.1",
+  "commit": "39a7bc21b981",
+  "builtAt": "2026-05-01T15:22:20.307Z"
 }

package/dist/followup-intent.js

@@ -0,0 +1,56 @@
+const IMPLEMENTATION_PATTERNS = [
+    /\b(add|address|adjust|change|create|delete|deploy|fix|implement|install|merge|open|polish|publish|push|remove|rename|set|ship|update)\b/i,
+    /\b(go on and|go ahead and|please|pls)\s+\b(add|address|adjust|change|create|delete|deploy|fix|implement|install|merge|open|polish|publish|push|remove|rename|set|ship|update|use)\b/i,
+    /\b(use|keep|switch|move)\b.+\b(instead|copy|api|contract|behavior|state|repo|branch|team|issue|pr)\b/i,
+];
+const RETRY_PATTERNS = [
+    /\b(continue|go on|keep going|proceed|resume)\b/i,
+    /\b(retry|try again|rerun|run again|restart)\b/i,
+    /\b(next task|next issue)\b/i,
+];
+const STOP_PATTERNS = [
+    /\b(stop|cancel|halt|abort)\b/i,
+    /\b(pause|hold)\s+(work|implementation|the run|patchrelay)\b/i,
+    /\bdo not\s+(continue|proceed|work|implement)\b/i,
+];
+const STATUS_PATTERNS = [
+    /\b(status|progress)\b/i,
+    /\b(status update|progress update|any update|quick update)\b/i,
+    /\b(where are we|what'?s happening|what is happening|what'?s deployed|what is deployed)\b/i,
+    /\b(done so far|deployed so far|current work|current run)\b/i,
+];
+const CLARIFICATION_PATTERNS = [
+    /\b(fyi|for context|heads up|to clarify|clarification|correction|actually|note that)\b/i,
+    /\b(i meant|what i meant|not asking you to|no action needed)\b/i,
+];
+const QUESTION_PATTERNS = [
+    /\?$/,
+    /\b(can|could|do|does|did|is|are|was|were|why|how|what|when|where|which|who|should|would)\b/i,
+];
+export function classifyFollowupIntent(input) {
+    const text = input.trim();
+    if (!text)
+        return "clarification";
+    if (matchesAny(text, STOP_PATTERNS))
+        return "stop";
+    if (matchesAny(text, RETRY_PATTERNS))
+        return "retry";
+    if (matchesAny(text, STATUS_PATTERNS))
+        return "status";
+    if (matchesAny(text, IMPLEMENTATION_PATTERNS))
+        return "implementation_request";
+    if (matchesAny(text, CLARIFICATION_PATTERNS))
+        return "clarification";
+    if (matchesAny(text, QUESTION_PATTERNS))
+        return "question";
+    return "clarification";
+}
+export function followupIntentQueuesWork(intent) {
+    return intent === "implementation_request" || intent === "retry";
+}
+export function followupIntentIsNonActionable(intent) {
+    return intent === "status" || intent === "question" || intent === "clarification";
+}
+function matchesAny(text, patterns) {
+    return patterns.some((pattern) => pattern.test(text));
+}

package/dist/linear-session-reporting.js

@@ -42,6 +42,12 @@ export function buildAlreadyRunningThought(runType) {
         body: `PatchRelay is already working on the ${lowerRunTypeLabel(runType)} workflow.`,
     };
 }
+export function buildAgentSessionAcknowledgementThought() {
+    return {
+        type: "thought",
+        body: "PatchRelay received this agent session and is checking the issue state.",
+    };
+}
 export function buildBlockedDelegationActivity(blockedByKeys = []) {
     const blockers = blockedByKeys.filter((key) => key.trim().length > 0);
     const blockerText = blockers.length > 0
@@ -58,6 +64,24 @@ export function buildPromptDeliveredThought(runType) {
         body: `PatchRelay routed your latest instructions into the active ${lowerRunTypeLabel(runType)} workflow.`,
     };
 }
+export function buildFollowupStatusActivity(params) {
+    const subject = params.issue.issueKey ? `${params.issue.issueKey}` : "this issue";
+    const runNote = params.activeRunType
+        ? ` Active workflow: ${lowerRunTypeLabel(params.activeRunType)}.`
+        : params.pendingRunType ? ` Queued workflow: ${lowerRunTypeLabel(params.pendingRunType)}.` : "";
+    const prNote = params.issue.prNumber ? ` PR #${params.issue.prNumber}.` : "";
+    const statusNote = params.statusNote ? ` ${params.statusNote}` : "";
+    return {
+        type: "response",
+        body: `PatchRelay status: ${subject} is ${formatFactoryState(params.issue.factoryState)}.${prNote}${runNote}${statusNote}`.trim(),
+    };
+}
+export function buildNonActionableFollowupActivity(intent) {
+    const body = intent === "status"
+        ? "PatchRelay status is available in the current agent session."
+        : "PatchRelay did not start implementation because this looks like a question or clarification. Ask PatchRelay to continue, retry, or implement when you want work to run.";
+    return { type: "response", body };
+}
 export function buildRunStartedActivity(runType) {
     switch (runType) {
         case "review_fix":
@@ -73,6 +97,9 @@ export function buildRunStartedActivity(runType) {
             return { type: "action", action: "Implementing", parameter: "requested change" };
     }
 }
+function formatFactoryState(state) {
+    return state.replaceAll("_", " ");
+}
 export function buildRunCompletedActivity(params) {
     const prLabel = params.prNumber ? `PR #${params.prNumber}` : "the pull request";
     const summary = trimSummary(params.completionSummary);

package/dist/webhook-handler.js

@@ -74,6 +74,7 @@ export class WebhookHandler {
                 this.db.webhookEvents.markWebhookProcessed(webhookEventId, "processed");
                 return;
             }
+            await this.agentSessionHandler.acknowledgeCreated(normalized);
             const routed = await this.contextLoader.load(normalized);
             const project = routed?.project;
             if (!project) {

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

@@ -1,7 +1,10 @@
 import { buildAgentSessionPlanForIssue, } from "../agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "../agent-session-presentation.js";
-import { buildAlreadyRunningThought, buildBlockedDelegationActivity, buildDelegationThought, buildPromptDeliveredThought, buildStopConfirmationActivity, } from "../linear-session-reporting.js";
-import { triggerEventAllowed } from "../project-resolution.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 { resolveProject, triggerEventAllowed } from "../project-resolution.js";
+import { deriveIssueStatusNote } from "../status-note.js";
 const PATCHRELAY_AGENT_ACTIVITY_TYPES = new Set([
     "action",
     "elicitation",
@@ -24,6 +27,33 @@ export class AgentSessionHandler {
         this.logger = logger;
         this.feed = feed;
     }
+    async acknowledgeCreated(normalized) {
+        if (normalized.triggerEvent !== "agentSessionCreated" || !normalized.agentSession?.id || !normalized.issue) {
+            return;
+        }
+        const project = resolveProject(this.config, normalized.issue);
+        if (!project || !triggerEventAllowed(project, normalized.triggerEvent)) {
+            return;
+        }
+        const linear = await this.linearProvider.forProject(project.id);
+        if (!linear?.createAgentActivity) {
+            return;
+        }
+        try {
+            await linear.createAgentActivity({
+                agentSessionId: normalized.agentSession.id,
+                content: buildAgentSessionAcknowledgementThought(),
+                ephemeral: true,
+            });
+        }
+        catch (error) {
+            this.logger.warn({
+                agentSessionId: normalized.agentSession.id,
+                issueKey: normalized.issue.identifier,
+                error: error instanceof Error ? error.message : String(error),
+            }, "Failed to acknowledge Linear agent session creation");
+        }
+    }
     async handle(params) {
         const { normalized, project, trackedIssue, wakeRunType, delegated } = params;
         if (!normalized.agentSession?.id || !normalized.issue)
@@ -95,6 +125,28 @@ export class AgentSessionHandler {
             return;
         }
         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,
+                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",
@@ -133,7 +185,10 @@ export class AgentSessionHandler {
         }
         if (promptBody && existingIssue && automationEnabled) {
             const hadPendingWake = this.db.issueSessions.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
-            const directReply = params.isDirectReplyToOutstandingQuestion(existingIssue);
+            if (!directReply && promptIntent && followupIntentIsNonActionable(promptIntent)) {
+                await this.publishAgentActivity(linear, normalized.agentSession.id, buildNonActionableFollowupActivity(promptIntent));
+                return;
+            }
             this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
                 projectId: project.id,
                 linearIssueId: normalized.issue.id,
@@ -157,6 +212,24 @@ 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,8 @@ 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 status:")
+        || body.startsWith("PatchRelay did not start implementation ")
         || body.startsWith("PatchRelay has stopped work as requested.")
         || body.startsWith("Merge preparation failed ")
         || body === "This thread is for an agent session with patchrelay.";

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

@@ -1,3 +1,4 @@
+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";
@@ -57,9 +58,10 @@ export class CommentWakeHandler {
             });
             return;
         }
+        const directReply = params.isDirectReplyToOutstandingQuestion(issue);
+        const intent = classifyFollowupIntent(trimmedBody);
         if (!issue.activeRunId) {
             if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
-                const directReply = params.isDirectReplyToOutstandingQuestion(issue);
                 const wakeIntent = issueClass === "orchestration" || directReply || hasExplicitPatchRelayWakeIntent(trimmedBody);
                 if (!wakeIntent) {
                     this.feed?.publish({
@@ -73,6 +75,42 @@ export class CommentWakeHandler {
                     });
                     return;
                 }
+                if (intent === "stop") {
+                    this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                        projectId: project.id,
+                        linearIssueId: 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 hadPendingWake = this.db.issueSessions.peekIssueSessionWake(project.id, normalized.issue.id) !== undefined;
                 this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
@@ -102,6 +140,60 @@ export class CommentWakeHandler {
         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.db.issueSessions.appendIssueSessionEventRespectingActiveLease(project.id, normalized.issue.id, {
+                projectId: project.id,
+                linearIssueId: 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,
+                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",
+                detail: trimmedBody.slice(0, 200),
+            });
+            return;
+        }
         const body = [
             "New Linear comment received while you are working.",
             normalized.comment.userName ? `Author: ${normalized.comment.userName}` : undefined,

package/package.json

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