patchrelay 0.69.2 → 0.69.4

package/dist/agent-input-service.js

@@ -0,0 +1,300 @@
+import { buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveryFailedActivity, buildPromptDeliveredThought, } from "./linear-session-reporting.js";
+import { deriveIssueStatusNote } from "./status-note.js";
+import { extractLatestAssistantSummary } from "./issue-session-events.js";
+export class AgentInputService {
+    db;
+    codex;
+    wakeDispatcher;
+    logger;
+    feed;
+    followupClassifier;
+    constructor(db, codex, wakeDispatcher, logger, feed, followupClassifier) {
+        this.db = db;
+        this.codex = codex;
+        this.wakeDispatcher = wakeDispatcher;
+        this.logger = logger;
+        this.feed = feed;
+        this.followupClassifier = followupClassifier;
+    }
+    async deliverAgentInput(params) {
+        const body = params.body.trim();
+        if (!body)
+            return { status: "ignored" };
+        const issue = this.db.issues.getIssue(params.issue.projectId, params.issue.linearIssueId) ?? params.issue;
+        const activeRun = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
+        const intent = await this.classify(body, params.source, issue, activeRun, params.directReply === true);
+        if (intent?.intent === "status" && !params.directReply) {
+            await params.emitActivity?.(this.buildStatusActivity(issue, activeRun, params.peekPendingSessionWakeRunType, activeRun ? "thought" : "response"), activeRun ? { ephemeral: true } : undefined);
+            return { status: "answered", ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}) };
+        }
+        if (intent?.intent === "stop") {
+            if (activeRun) {
+                await this.stopActiveRun(issue, activeRun, body, params.source);
+            }
+            else {
+                this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
+                    eventType: "stop_requested",
+                    eventJson: JSON.stringify({ body, source: params.source, ...(params.author ? { author: params.author } : {}) }),
+                });
+                this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+            }
+            return { status: "stopped", ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}) };
+        }
+        if (!issue.delegatedToPatchRelay && !(activeRun && params.source === "patchrelay_operator_prompt")) {
+            await params.emitActivity?.({ type: "thought", body: "PatchRelay is paused because the issue is undelegated." }, { ephemeral: true });
+            return { status: "ignored" };
+        }
+        if (activeRun) {
+            return await this.steerActiveRun({
+                issue,
+                activeRun,
+                body,
+                source: params.source,
+                author: params.author,
+                operatorSource: params.operatorSource,
+                emitActivity: params.emitActivity,
+            });
+        }
+        return await this.queueIdleInput({
+            project: params.project,
+            issue,
+            body,
+            source: params.source,
+            author: params.author,
+            operatorSource: params.operatorSource,
+            directReply: params.directReply === true,
+            emitActivity: params.emitActivity,
+        });
+    }
+    async classify(body, source, issue, activeRun, directReply) {
+        if (source === "patchrelay_operator_prompt")
+            return undefined;
+        if (!this.followupClassifier)
+            return undefined;
+        return await this.followupClassifier.classify(body, {
+            source: source === "linear_agent_session" ? "agentPrompted" : "comment",
+            ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}),
+            factoryState: issue.factoryState,
+            directReply,
+            delegatedToPatchRelay: issue.delegatedToPatchRelay,
+            prReviewState: issue.prReviewState,
+            explicitWakeIntent: true,
+        });
+    }
+    async steerActiveRun(params) {
+        const { issue, activeRun, body, source } = params;
+        if (!activeRun.threadId || !activeRun.turnId) {
+            const queuedRunType = this.queueFollowUpEvent(issue, body, source, params.author, params.operatorSource, false);
+            return { status: "queued", ...(queuedRunType ? { queuedRunType } : {}) };
+        }
+        const input = [
+            source === "linear_agent_session"
+                ? "New Linear agent-session prompt received while you are working."
+                : source === "linear_addressed_comment"
+                    ? "New explicitly addressed Linear issue comment received while you are working."
+                    : "New PatchRelay operator prompt received while you are working.",
+            params.author ? `Author: ${params.author}` : undefined,
+            "",
+            "Checkpoint contract: incorporate this instruction before your next meaningful side effect when possible. If you are already inside a non-interruptible command, finish that command, then re-plan with this input before continuing.",
+            "",
+            body,
+        ].filter(Boolean).join("\n");
+        try {
+            await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
+            this.recordPromptDelivery({
+                issue,
+                source,
+                runId: activeRun.id,
+                runType: activeRun.runType,
+                status: "delivered",
+                body,
+                primitive: "turn/steer",
+                threadId: activeRun.threadId,
+                turnId: activeRun.turnId,
+            });
+            this.feed?.publish({
+                level: "info",
+                kind: inputFeedKind(source),
+                projectId: issue.projectId,
+                issueKey: issue.issueKey,
+                stage: activeRun.runType,
+                status: "delivered",
+                summary: `Delivered agent input to active ${activeRun.runType} workflow`,
+            });
+            await params.emitActivity?.(buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
+            return { status: "steered", activeRunType: activeRun.runType };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey: issue.issueKey, error: message }, "Failed to deliver agent input to active Codex turn");
+            this.recordPromptDelivery({
+                issue,
+                source,
+                runId: activeRun.id,
+                runType: activeRun.runType,
+                status: "delivery_failed",
+                body,
+                primitive: "turn/steer",
+                threadId: activeRun.threadId,
+                turnId: activeRun.turnId,
+                error: message,
+            });
+            const queuedRunType = this.queueFollowUpEvent(issue, body, source, params.author, params.operatorSource, false);
+            this.feed?.publish({
+                level: "warn",
+                kind: inputFeedKind(source),
+                projectId: issue.projectId,
+                issueKey: issue.issueKey,
+                stage: activeRun.runType,
+                status: "delivery_failed",
+                summary: `Could not deliver agent input to active ${activeRun.runType} workflow`,
+            });
+            await params.emitActivity?.(buildPromptDeliveryFailedActivity(activeRun.runType, message));
+            return { status: "delivery_failed", activeRunType: activeRun.runType, ...(queuedRunType ? { queuedRunType } : {}) };
+        }
+    }
+    async queueIdleInput(params) {
+        const originalIssue = params.issue;
+        let issue = originalIssue;
+        const replacementPrRequired = originalIssue.factoryState === "done" && originalIssue.prNumber !== undefined;
+        if (replacementPrRequired) {
+            issue = this.prepareReplacementWork(params.project, originalIssue);
+        }
+        const queuedRunType = this.queueFollowUpEvent(issue, params.body, params.source, params.author, params.operatorSource, params.directReply, replacementPrRequired ? originalIssue : undefined);
+        if (queuedRunType) {
+            await params.emitActivity?.(replacementPrRequired
+                ? { type: "action", action: "Reopening", parameter: `completed PR #${originalIssue.prNumber} for replacement work` }
+                : buildPromptDeliveredThought(queuedRunType), { ephemeral: true });
+        }
+        else {
+            await params.emitActivity?.(buildNonActionableFollowupActivity("unknown_needs_ack"));
+        }
+        return { status: queuedRunType ? "queued" : "ignored", ...(queuedRunType ? { queuedRunType } : {}) };
+    }
+    queueFollowUpEvent(issue, body, source, author, operatorSource, directReply, previousIssue) {
+        return this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
+            eventType: directReply ? "direct_reply" : inputSourceEventType(source),
+            eventJson: JSON.stringify({
+                ...(source === "linear_addressed_comment" ? { body } : { text: body }),
+                source: inputSourcePayloadSource(source),
+                ...(author ? { author } : {}),
+                ...(operatorSource ? { operatorSource } : {}),
+                ...(previousIssue?.prNumber !== undefined
+                    ? {
+                        replacementPrRequired: true,
+                        previousPrNumber: previousIssue.prNumber,
+                        ...(previousIssue.prUrl ? { previousPrUrl: previousIssue.prUrl } : {}),
+                        ...(previousIssue.prState ? { previousPrState: previousIssue.prState } : {}),
+                        ...(previousIssue.prHeadSha ? { previousPrHeadSha: previousIssue.prHeadSha } : {}),
+                    }
+                    : {}),
+            }),
+        });
+    }
+    prepareReplacementWork(project, issue) {
+        const issueRef = (issue.issueKey ?? issue.linearIssueId).replace(/[^a-zA-Z0-9._-]+/g, "-");
+        const suffix = Date.now().toString(36);
+        return this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: "delegated",
+            branchName: `${project.branchPrefix}/${issueRef}-replacement-${suffix}`,
+            prNumber: null,
+            prUrl: null,
+            prState: null,
+            prIsDraft: null,
+            prHeadSha: null,
+            prAuthorLogin: null,
+            prReviewState: null,
+            prCheckStatus: null,
+            lastBlockingReviewHeadSha: null,
+        }) ?? issue;
+    }
+    async stopActiveRun(issue, run, body, source) {
+        if (run.threadId && run.turnId) {
+            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: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop request");
+            }
+            this.db.runs.finishRun(run.id, { status: "released", threadId: run.threadId, turnId: run.turnId });
+        }
+        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            activeRunId: null,
+            factoryState: "awaiting_input",
+        });
+        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
+            eventType: "stop_requested",
+            eventJson: JSON.stringify({ body, source }),
+        });
+        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
+        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
+    }
+    buildStatusActivity(issue, activeRun, peekPendingSessionWakeRunType, activityType) {
+        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 } : {}),
+            activityType,
+        });
+    }
+    recordPromptDelivery(params) {
+        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.issue.projectId, params.issue.linearIssueId, {
+            projectId: params.issue.projectId,
+            linearIssueId: params.issue.linearIssueId,
+            eventType: "prompt_delivered",
+            eventJson: JSON.stringify({
+                source: inputSourcePayloadSource(params.source),
+                runId: params.runId,
+                runType: params.runType,
+                status: params.status,
+                body: params.body,
+                primitive: params.primitive,
+                ...(params.threadId ? { threadId: params.threadId } : {}),
+                ...(params.turnId ? { turnId: params.turnId } : {}),
+                ...(params.error ? { error: params.error } : {}),
+            }),
+        });
+    }
+}
+function inputSourceEventType(source) {
+    switch (source) {
+        case "linear_agent_session":
+            return "followup_prompt";
+        case "linear_addressed_comment":
+            return "followup_comment";
+        case "patchrelay_operator_prompt":
+            return "operator_prompt";
+    }
+}
+function inputSourcePayloadSource(source) {
+    switch (source) {
+        case "linear_agent_session":
+            return "linear_agent_prompt";
+        case "linear_addressed_comment":
+            return "linear_comment";
+        case "patchrelay_operator_prompt":
+            return "patchrelay_operator_prompt";
+    }
+}
+function inputFeedKind(source) {
+    return source === "linear_agent_session" ? "agent" : "comment";
+}

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.69.2",
-  "commit": "aff7f71749de",
-  "builtAt": "2026-05-22T21:13:33.138Z"
+  "version": "0.69.4",
+  "commit": "56b3535ee459",
+  "builtAt": "2026-05-22T22:23:51.490Z"
 }

package/dist/codex-conversation-adapter.js

@@ -1,270 +1 @@
-import { buildFollowupStatusActivity, buildNonActionableFollowupActivity, buildPromptDeliveryFailedActivity, buildPromptDeliveredThought, } from "./linear-session-reporting.js";
-import { deriveIssueStatusNote } from "./status-note.js";
-import { extractLatestAssistantSummary } from "./issue-session-events.js";
-export class CodexConversationAdapter {
-    db;
-    codex;
-    wakeDispatcher;
-    logger;
-    feed;
-    followupClassifier;
-    constructor(db, codex, wakeDispatcher, logger, feed, followupClassifier) {
-        this.db = db;
-        this.codex = codex;
-        this.wakeDispatcher = wakeDispatcher;
-        this.logger = logger;
-        this.feed = feed;
-        this.followupClassifier = followupClassifier;
-    }
-    async deliverAgentInput(params) {
-        const body = params.body.trim();
-        if (!body)
-            return { status: "ignored" };
-        const issue = this.db.issues.getIssue(params.issue.projectId, params.issue.linearIssueId) ?? params.issue;
-        const activeRun = issue.activeRunId ? this.db.runs.getRunById(issue.activeRunId) : undefined;
-        const intent = await this.classify(body, params.source, issue, activeRun, params.directReply === true);
-        if (intent?.intent === "status" && !params.directReply) {
-            await params.emitActivity?.(this.buildStatusActivity(issue, activeRun, params.peekPendingSessionWakeRunType, activeRun ? "thought" : "response"), activeRun ? { ephemeral: true } : undefined);
-            return { status: "answered", ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}) };
-        }
-        if (intent?.intent === "stop") {
-            if (activeRun) {
-                await this.stopActiveRun(issue, activeRun, body, params.source);
-            }
-            else {
-                this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-                    eventType: "stop_requested",
-                    eventJson: JSON.stringify({ body, source: params.source, ...(params.author ? { author: params.author } : {}) }),
-                });
-                this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-            }
-            return { status: "stopped", ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}) };
-        }
-        if (!issue.delegatedToPatchRelay) {
-            await params.emitActivity?.({ type: "thought", body: "PatchRelay is paused because the issue is undelegated." }, { ephemeral: true });
-            return { status: "ignored" };
-        }
-        if (activeRun) {
-            return await this.steerActiveRun({
-                issue,
-                activeRun,
-                body,
-                source: params.source,
-                author: params.author,
-                emitActivity: params.emitActivity,
-            });
-        }
-        return await this.queueIdleInput({
-            project: params.project,
-            issue,
-            body,
-            source: params.source,
-            author: params.author,
-            directReply: params.directReply === true,
-            emitActivity: params.emitActivity,
-        });
-    }
-    async classify(body, source, issue, activeRun, directReply) {
-        if (!this.followupClassifier)
-            return undefined;
-        return await this.followupClassifier.classify(body, {
-            source: source === "agent_session_prompt" ? "agentPrompted" : "comment",
-            ...(activeRun?.runType ? { activeRunType: activeRun.runType } : {}),
-            factoryState: issue.factoryState,
-            directReply,
-            delegatedToPatchRelay: issue.delegatedToPatchRelay,
-            prReviewState: issue.prReviewState,
-            explicitWakeIntent: true,
-        });
-    }
-    async steerActiveRun(params) {
-        const { issue, activeRun, body, source } = params;
-        if (!activeRun.threadId || !activeRun.turnId) {
-            const queuedRunType = this.queueFollowUpEvent(issue, body, source, params.author, false);
-            return { status: "queued", ...(queuedRunType ? { queuedRunType } : {}) };
-        }
-        const input = [
-            source === "agent_session_prompt"
-                ? "New Linear agent-session prompt received while you are working."
-                : "New explicitly addressed Linear issue comment received while you are working.",
-            params.author ? `Author: ${params.author}` : undefined,
-            "",
-            "Checkpoint contract: incorporate this instruction before your next meaningful side effect when possible. If you are already inside a non-interruptible command, finish that command, then re-plan with this input before continuing.",
-            "",
-            body,
-        ].filter(Boolean).join("\n");
-        try {
-            await this.codex.steerTurn({ threadId: activeRun.threadId, turnId: activeRun.turnId, input });
-            this.recordPromptDelivery({
-                issue,
-                source,
-                runId: activeRun.id,
-                runType: activeRun.runType,
-                status: "delivered",
-                body,
-                primitive: "turn/steer",
-                threadId: activeRun.threadId,
-                turnId: activeRun.turnId,
-            });
-            this.feed?.publish({
-                level: "info",
-                kind: source === "agent_session_prompt" ? "agent" : "comment",
-                projectId: issue.projectId,
-                issueKey: issue.issueKey,
-                stage: activeRun.runType,
-                status: "delivered",
-                summary: `Delivered agent input to active ${activeRun.runType} workflow`,
-            });
-            await params.emitActivity?.(buildPromptDeliveredThought(activeRun.runType), { ephemeral: true });
-            return { status: "steered", activeRunType: activeRun.runType };
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey: issue.issueKey, error: message }, "Failed to deliver agent input to active Codex turn");
-            this.recordPromptDelivery({
-                issue,
-                source,
-                runId: activeRun.id,
-                runType: activeRun.runType,
-                status: "delivery_failed",
-                body,
-                primitive: "turn/steer",
-                threadId: activeRun.threadId,
-                turnId: activeRun.turnId,
-                error: message,
-            });
-            const queuedRunType = this.queueFollowUpEvent(issue, body, source, params.author, false);
-            this.feed?.publish({
-                level: "warn",
-                kind: source === "agent_session_prompt" ? "agent" : "comment",
-                projectId: issue.projectId,
-                issueKey: issue.issueKey,
-                stage: activeRun.runType,
-                status: "delivery_failed",
-                summary: `Could not deliver agent input to active ${activeRun.runType} workflow`,
-            });
-            await params.emitActivity?.(buildPromptDeliveryFailedActivity(activeRun.runType, message));
-            return { status: "delivery_failed", activeRunType: activeRun.runType, ...(queuedRunType ? { queuedRunType } : {}) };
-        }
-    }
-    async queueIdleInput(params) {
-        const originalIssue = params.issue;
-        let issue = originalIssue;
-        const replacementPrRequired = originalIssue.factoryState === "done" && originalIssue.prNumber !== undefined;
-        if (replacementPrRequired) {
-            issue = this.prepareReplacementWork(params.project, originalIssue);
-        }
-        const queuedRunType = this.queueFollowUpEvent(issue, params.body, params.source, params.author, params.directReply, replacementPrRequired ? originalIssue : undefined);
-        if (queuedRunType) {
-            await params.emitActivity?.(replacementPrRequired
-                ? { type: "action", action: "Reopening", parameter: `completed PR #${originalIssue.prNumber} for replacement work` }
-                : buildPromptDeliveredThought(queuedRunType), { ephemeral: true });
-        }
-        else {
-            await params.emitActivity?.(buildNonActionableFollowupActivity("unknown_needs_ack"));
-        }
-        return { status: queuedRunType ? "queued" : "ignored", ...(queuedRunType ? { queuedRunType } : {}) };
-    }
-    queueFollowUpEvent(issue, body, source, author, directReply, previousIssue) {
-        return this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-            eventType: directReply ? "direct_reply" : source === "agent_session_prompt" ? "followup_prompt" : "followup_comment",
-            eventJson: JSON.stringify({
-                ...(source === "agent_session_prompt" ? { text: body } : { body }),
-                source: source === "agent_session_prompt" ? "linear_agent_prompt" : "linear_comment",
-                ...(author ? { author } : {}),
-                ...(previousIssue?.prNumber !== undefined
-                    ? {
-                        replacementPrRequired: true,
-                        previousPrNumber: previousIssue.prNumber,
-                        ...(previousIssue.prUrl ? { previousPrUrl: previousIssue.prUrl } : {}),
-                        ...(previousIssue.prState ? { previousPrState: previousIssue.prState } : {}),
-                        ...(previousIssue.prHeadSha ? { previousPrHeadSha: previousIssue.prHeadSha } : {}),
-                    }
-                    : {}),
-            }),
-        });
-    }
-    prepareReplacementWork(project, issue) {
-        const issueRef = (issue.issueKey ?? issue.linearIssueId).replace(/[^a-zA-Z0-9._-]+/g, "-");
-        const suffix = Date.now().toString(36);
-        return this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            factoryState: "delegated",
-            branchName: `${project.branchPrefix}/${issueRef}-replacement-${suffix}`,
-            prNumber: null,
-            prUrl: null,
-            prState: null,
-            prIsDraft: null,
-            prHeadSha: null,
-            prAuthorLogin: null,
-            prReviewState: null,
-            prCheckStatus: null,
-            lastBlockingReviewHeadSha: null,
-        }) ?? issue;
-    }
-    async stopActiveRun(issue, run, body, source) {
-        if (run.threadId && run.turnId) {
-            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: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to steer Codex turn for stop request");
-            }
-            this.db.runs.finishRun(run.id, { status: "released", threadId: run.threadId, turnId: run.turnId });
-        }
-        this.db.issueSessions.upsertIssueRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            activeRunId: null,
-            factoryState: "awaiting_input",
-        });
-        this.wakeDispatcher.recordEventAndDispatch(issue.projectId, issue.linearIssueId, {
-            eventType: "stop_requested",
-            eventJson: JSON.stringify({ body, source }),
-        });
-        this.db.issueSessions.clearPendingIssueSessionEventsRespectingActiveLease(issue.projectId, issue.linearIssueId);
-        this.db.issueSessions.releaseIssueSessionLeaseRespectingActiveLease(issue.projectId, issue.linearIssueId);
-    }
-    buildStatusActivity(issue, activeRun, peekPendingSessionWakeRunType, activityType) {
-        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 } : {}),
-            activityType,
-        });
-    }
-    recordPromptDelivery(params) {
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(params.issue.projectId, params.issue.linearIssueId, {
-            projectId: params.issue.projectId,
-            linearIssueId: params.issue.linearIssueId,
-            eventType: "prompt_delivered",
-            eventJson: JSON.stringify({
-                source: params.source === "agent_session_prompt" ? "linear_agent_prompt" : "linear_comment",
-                runId: params.runId,
-                runType: params.runType,
-                status: params.status,
-                body: params.body,
-                primitive: params.primitive,
-                ...(params.threadId ? { threadId: params.threadId } : {}),
-                ...(params.turnId ? { turnId: params.turnId } : {}),
-                ...(params.error ? { error: params.error } : {}),
-            }),
-        });
-    }
-}
+export { AgentInputService as CodexConversationAdapter, } from "./agent-input-service.js";

package/dist/db/issue-session-store.js

@@ -6,14 +6,12 @@ export class IssueSessionStore {
     mapIssueSessionEventRow;
     issues;
     runs;
-    deriveImplicitReactiveWake;
-    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, issues, runs, deriveImplicitReactiveWake) {
+    constructor(connection, mapIssueSessionRow, mapIssueSessionEventRow, issues, runs) {
         this.connection = connection;
         this.mapIssueSessionRow = mapIssueSessionRow;
         this.mapIssueSessionEventRow = mapIssueSessionEventRow;
         this.issues = issues;
         this.runs = runs;
-        this.deriveImplicitReactiveWake = deriveImplicitReactiveWake;
     }
     getIssueSession(projectId, linearIssueId) {
         const row = this.connection
@@ -108,16 +106,7 @@ export class IssueSessionStore {
                 resumeThread: plan.resumeThread,
             };
         }
-        const implicitWake = this.deriveImplicitReactiveWake(issue);
-        if (!implicitWake)
-            return undefined;
-        return {
-            eventIds: [],
-            runType: implicitWake.runType,
-            context: implicitWake.context,
-            wakeReason: implicitWake.wakeReason,
-            resumeThread: false,
-        };
+        return undefined;
     }
     acquireIssueSessionLease(params) {
         const now = params.now ?? isoNow();

package/dist/db.js

@@ -1,4 +1,3 @@
-import { deriveIssueSessionReactiveIntent, } from "./issue-session.js";
 import {} from "./issue-session-events.js";
 import { IssueStore } from "./db/issue-store.js";
 import { IssueSessionStore } from "./db/issue-session-store.js";
@@ -11,84 +10,7 @@ import { runPatchRelayMigrations } from "./db/migrations.js";
 import { SqliteConnection } from "./db/shared.js";
 import { syncIssueSessionFromIssue } from "./issue-session-projector.js";
 import { TrackedIssueQuery } from "./tracked-issue-query.js";
-function parseObjectJson(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        const parsed = JSON.parse(raw);
-        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
-            ? parsed
-            : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-function hasUnattemptedFailureSignature(issue, fallbackHeadSha) {
-    const signature = issue.lastGitHubFailureSignature;
-    if (!signature)
-        return false;
-    const headSha = issue.lastGitHubFailureHeadSha ?? fallbackHeadSha;
-    return issue.lastAttemptedFailureSignature !== signature
-        || (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha);
-}
-function deriveImplicitReactiveWake(issue) {
-    const reactiveIntent = deriveIssueSessionReactiveIntent({
-        delegatedToPatchRelay: issue.delegatedToPatchRelay,
-        activeRunId: issue.activeRunId,
-        prNumber: issue.prNumber,
-        prState: issue.prState,
-        prReviewState: issue.prReviewState,
-        prCheckStatus: issue.prCheckStatus,
-        latestFailureSource: issue.lastGitHubFailureSource,
-    });
-    if (!reactiveIntent)
-        return undefined;
-    if (reactiveIntent.runType === "ci_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
-        const snapshot = parseObjectJson(issue.lastGitHubCiSnapshotJson);
-        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
-            ? failureContext.failureHeadSha
-            : issue.lastGitHubFailureHeadSha ?? issue.prHeadSha;
-        const failureSignature = issue.lastGitHubFailureSignature
-            ?? (fallbackHeadSha ? `implicit_branch_ci::${fallbackHeadSha}` : undefined);
-        if (!failureSignature || issue.prState !== "open")
-            return undefined;
-        if (issue.lastAttemptedFailureSignature === failureSignature
-            && (fallbackHeadSha === undefined || issue.lastAttemptedFailureHeadSha === fallbackHeadSha)) {
-            return undefined;
-        }
-        return {
-            runType: reactiveIntent.runType,
-            wakeReason: reactiveIntent.wakeReason,
-            context: {
-                ...failureContext,
-                failureSignature,
-                ...(fallbackHeadSha ? { failureHeadSha: fallbackHeadSha } : {}),
-                ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
-                ...(snapshot ? { ciSnapshot: snapshot } : {}),
-            },
-        };
-    }
-    if (reactiveIntent.runType === "queue_repair") {
-        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
-        const incidentContext = parseObjectJson(issue.lastQueueIncidentJson) ?? {};
-        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
-            ? failureContext.failureHeadSha
-            : undefined;
-        if (!hasUnattemptedFailureSignature(issue, fallbackHeadSha))
-            return undefined;
-        return {
-            runType: reactiveIntent.runType,
-            wakeReason: reactiveIntent.wakeReason,
-            context: {
-                ...incidentContext,
-                ...failureContext,
-            },
-        };
-    }
-    return undefined;
-}
+import { WorkflowWakeResolver } from "./workflow-wake-resolver.js";
 export class PatchRelayDatabase {
     connection;
     linearInstallations;
@@ -97,6 +19,7 @@ export class PatchRelayDatabase {
     webhookEvents;
     issues;
     issueSessions;
+    workflowWakes;
     runs;
     trackedIssues;
     constructor(databasePath, wal) {
@@ -118,8 +41,9 @@ export class PatchRelayDatabase {
             issue,
             ...(options ? { options } : {}),
         }));
-        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs, deriveImplicitReactiveWake);
-        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.runs);
+        this.issueSessions = new IssueSessionStore(this.connection, mapIssueSessionRow, mapIssueSessionEventRow, this.issues, this.runs);
+        this.workflowWakes = new WorkflowWakeResolver(this.issues, this.issueSessions);
+        this.trackedIssues = new TrackedIssueQuery(this.issues, this.issueSessions, this.workflowWakes, this.runs);
     }
     runMigrations() {
         runPatchRelayMigrations(this.connection);

package/dist/idle-reconciliation.js

@@ -513,7 +513,7 @@ export class IdleIssueReconciler {
             }
             if (issue.delegatedToPatchRelay
                 && reactiveIntent?.runType === "review_fix"
-                && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined) {
+                && this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) === undefined) {
                 this.logger.info({
                     issueKey: issue.issueKey,
                     prNumber: issue.prNumber,

package/dist/interrupted-run-recovery.js

@@ -147,7 +147,7 @@ export class InterruptedRunRecovery {
             eventType: "delegated",
             dedupeKey: `interrupted_implementation:implementation:${run.linearIssueId}`,
         });
-        if (!this.db.issueSessions.peekIssueSessionWake(run.projectId, run.linearIssueId)) {
+        if (!this.db.workflowWakes.peekIssueWake(run.projectId, run.linearIssueId)) {
             const failedIssue = this.db.issues.getIssue(run.projectId, run.linearIssueId) ?? refreshedIssue;
             this.feed?.publish({
                 level: "error",

package/dist/issue-overview-query.js

@@ -127,7 +127,7 @@ export class IssueOverviewQuery {
                 delegatedToPatchRelay: issueRecord?.delegatedToPatchRelay,
                 ...(activeRun ? { activeRunId: activeRun.id } : {}),
                 blockedByCount: unresolvedBlockedBy.length,
-                hasPendingWake: this.db.issueSessions.peekIssueSessionWake(session.projectId, session.linearIssueId) !== undefined,
+                hasPendingWake: this.db.workflowWakes.peekIssueWake(session.projectId, session.linearIssueId) !== undefined,
                 hasLegacyPendingRun: issueRecord?.pendingRunType !== undefined,
                 orchestrationSettleUntil: issueRecord?.orchestrationSettleUntil,
                 ...(session.prNumber !== undefined ? { prNumber: session.prNumber } : {}),

package/dist/run-wake-planner.js

@@ -5,7 +5,7 @@ export class RunWakePlanner {
         this.db = db;
     }
     resolveRunWake(issue) {
-        const sessionWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId);
+        const sessionWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId);
         if (!sessionWake)
             return undefined;
         return {

package/dist/service-issue-actions.js

@@ -1,13 +1,17 @@
 import { buildOperatorRetryEvent } from "./operator-retry-event.js";
 import { buildManualRetryAttemptReset, resolveRetryTarget } from "./manual-issue-actions.js";
 export class ServiceIssueActions {
+    config;
     db;
+    agentInput;
     codex;
     runtime;
     feed;
     logger;
-    constructor(db, codex, runtime, feed, logger) {
+    constructor(config, db, agentInput, codex, runtime, feed, logger) {
+        this.config = config;
         this.db = db;
+        this.agentInput = agentInput;
         this.codex = codex;
         this.runtime = runtime;
         this.feed = feed;
@@ -20,6 +24,9 @@ export class ServiceIssueActions {
         if (!issue.delegatedToPatchRelay && !issue.activeRunId) {
             return { error: "Issue is undelegated from PatchRelay; delegate it again before prompting work" };
         }
+        const project = this.config.projects.find((entry) => entry.id === issue.projectId);
+        if (!project)
+            return { error: `Project ${issue.projectId} is not configured` };
         this.feed.publish({
             level: "info",
             kind: "comment",
@@ -30,28 +37,18 @@ export class ServiceIssueActions {
             summary: `Operator prompt (${source})`,
             detail: text.slice(0, 200),
         });
-        if (!issue.activeRunId) {
-            this.queueOperatorPrompt(issue, text, source);
-            return { delivered: false, queued: true };
-        }
-        const run = this.db.runs.getRunById(issue.activeRunId);
-        if (!run?.threadId || !run.turnId) {
-            return { error: "Active run has no thread or turn yet" };
-        }
-        try {
-            await this.codex.steerTurn({
-                threadId: run.threadId,
-                turnId: run.turnId,
-                input: `Operator prompt (${source}):\n\n${text}`,
-            });
-            return { delivered: true };
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            this.logger.warn({ issueKey, error: msg }, "steerTurn failed, queuing prompt for next run");
-            this.queueOperatorPrompt(issue, text, source);
+        const result = await this.agentInput.deliverAgentInput({
+            project,
+            issue,
+            source: "patchrelay_operator_prompt",
+            body: text,
+            operatorSource: source,
+        });
+        if (result.status === "ignored")
+            return { delivered: false };
+        if (result.status === "delivery_failed" || result.status === "queued")
             return { delivered: false, queued: true };
-        }
+        return { delivered: result.status === "steered" || result.status === "answered" || result.status === "stopped" };
     }
     async stopIssue(issueKey) {
         const issue = this.db.issues.getIssueByKey(issueKey);
@@ -137,7 +134,7 @@ export class ServiceIssueActions {
             status: "retry",
             summary: `Retry queued: ${retryTarget.runType}`,
         });
-        if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+        if (this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId)) {
             this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
         return { issueKey, runType: retryTarget.runType };
@@ -206,15 +203,6 @@ export class ServiceIssueActions {
             ...(run ? { releasedRunId: run.id } : {}),
         };
     }
-    queueOperatorPrompt(issue, text, source) {
-        this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
-            projectId: issue.projectId,
-            linearIssueId: issue.linearIssueId,
-            eventType: "operator_prompt",
-            eventJson: JSON.stringify({ text, source }),
-        });
-        this.runtime.enqueueIssue(issue.projectId, issue.linearIssueId);
-    }
     appendOperatorRetryEvent(issue, runType) {
         this.db.issueSessions.appendIssueSessionEventRespectingActiveLease(issue.projectId, issue.linearIssueId, {
             projectId: issue.projectId,

package/dist/service-startup-recovery.js

@@ -90,7 +90,7 @@ export class ServiceStartupRecovery {
             }
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
-            const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined;
+            const hasPendingWake = this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId) !== undefined;
             const shouldRecoverPausedLocalWork = delegated
                 && isResumablePausedLocalWork({
                     issue: {
@@ -147,7 +147,7 @@ export class ServiceStartupRecovery {
                         dedupeKey: `delegated:${issue.linearIssueId}`,
                     });
                 }
-                if (this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId)) {
+                if (this.db.workflowWakes.peekIssueWake(issue.projectId, issue.linearIssueId)) {
                     this.enqueueIssue(issue.projectId, issue.linearIssueId);
                 }
                 this.logger.info({

package/dist/service.js

@@ -13,6 +13,8 @@ import { WakeDispatcher } from "./wake-dispatcher.js";
 import { WebhookHandler } from "./webhook-handler.js";
 import { acceptIncomingWebhook } from "./service-webhooks.js";
 import { parseStringArray, TrackedIssueListQuery } from "./tracked-issue-list-query.js";
+import { AgentInputService } from "./agent-input-service.js";
+import { CodexFollowupIntentClassifier } from "./followup-intent.js";
 export class PatchRelayService {
     config;
     db;
@@ -52,9 +54,10 @@ export class PatchRelayService {
         // orchestrator (its construction depends on the Codex client). All
         // downstream consumers receive this single dispatcher instance.
         const dispatcher = new WakeDispatcher(db, (projectId, issueId) => enqueueIssue(projectId, issueId), (projectId, issueId) => leaseRelease(projectId, issueId), logger, this.feed);
+        const agentInput = new AgentInputService(db, codex, dispatcher, logger, this.feed, new CodexFollowupIntentClassifier(codex, logger));
         this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), dispatcher, logger, this.feed, this.configPath);
         leaseRelease = (projectId, issueId) => this.orchestrator.leaseService.release(projectId, issueId);
-        this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, dispatcher, logger, this.feed);
+        this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, dispatcher, logger, this.feed, undefined, agentInput);
         this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, dispatcher, logger, codex, this.feed);
         const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
             processIssue: async (item) => {
@@ -65,7 +68,7 @@ export class PatchRelayService {
         this.oauthService = new LinearOAuthService(config, { linearInstallations: db.linearInstallations }, logger);
         this.queryService = new IssueQueryService(db, codex, this.orchestrator);
         this.runtime = runtime;
-        this.issueActions = new ServiceIssueActions(db, codex, runtime, this.feed, logger);
+        this.issueActions = new ServiceIssueActions(config, db, agentInput, codex, runtime, this.feed, logger);
         this.startupRecovery = new ServiceStartupRecovery(db, this.linearProvider, this.orchestrator.linearSync, (projectId, issueId) => runtime.enqueueIssue(projectId, issueId), logger);
         this.trackedIssueListQuery = new TrackedIssueListQuery(db);
         // Optional GitHub App token management for bot identity

package/dist/tracked-issue-list-query.js

@@ -155,7 +155,7 @@ export class TrackedIssueListQuery {
             const blockedByCount = Number(row.blocked_by_count ?? 0);
             const hasPendingSessionEvents = Number(row.pending_session_event_count ?? 0) > 0;
             const hasPendingWake = hasPendingSessionEvents
-                || this.db.issueSessions.peekIssueSessionWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
+                || this.db.workflowWakes.peekIssueWake(String(row.project_id), String(row.linear_issue_id)) !== undefined;
             const detachedActiveRun = hasDetachedActiveLatestRun({
                 activeRunId: row.active_run_type !== null ? 1 : undefined,
                 latestRun: row.latest_run_status !== null

package/dist/tracked-issue-query.js

@@ -4,10 +4,12 @@ import { resolveEffectiveActiveRun } from "./effective-active-run.js";
 export class TrackedIssueQuery {
     issues;
     issueSessions;
+    workflowWakes;
     runs;
-    constructor(issues, issueSessions, runs) {
+    constructor(issues, issueSessions, workflowWakes, runs) {
         this.issues = issues;
         this.issueSessions = issueSessions;
+        this.workflowWakes = workflowWakes;
         this.runs = runs;
     }
     listIssuesReadyForExecution() {
@@ -20,7 +22,7 @@ export class TrackedIssueQuery {
             }),
             activeRunId: issue.activeRunId,
             blockedByCount: this.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId),
-            hasPendingWake: this.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+            hasPendingWake: this.workflowWakes.hasPendingWake(issue.projectId, issue.linearIssueId),
             hasLegacyPendingRun: issue.pendingRunType !== undefined,
             prNumber: issue.prNumber,
             prState: issue.prState,
@@ -38,7 +40,7 @@ export class TrackedIssueQuery {
             issue,
             session: this.issueSessions.getIssueSession(issue.projectId, issue.linearIssueId),
             blockedBy: this.issues.listIssueDependencies(issue.projectId, issue.linearIssueId),
-            hasPendingWake: this.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) !== undefined,
+            hasPendingWake: this.workflowWakes.hasPendingWake(issue.projectId, issue.linearIssueId),
             latestRun: this.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId),
             latestEvent: this.issueSessions.listIssueSessionEvents(issue.projectId, issue.linearIssueId, { limit: 1 }).at(-1),
         });

package/dist/wake-dispatcher.js

@@ -69,7 +69,7 @@ export class WakeDispatcher {
         const issue = this.db.issues.getIssue(projectId, linearIssueId);
         if (issue?.activeRunId !== undefined)
             return undefined;
-        const wake = this.db.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        const wake = this.db.workflowWakes.peekIssueWake(projectId, linearIssueId);
         // Fall back to the legacy pending_run_type column. The orchestrator
         // materializes it into a real event at run time, but the poke still
         // needs to happen now so the orchestrator gets called at all.
@@ -97,7 +97,7 @@ export class WakeDispatcher {
     // check paths publish their own more-specific event and pass false.
     releaseRunAndDispatch(params) {
         this.releaseLease(params.run.projectId, params.run.linearIssueId);
-        const wake = this.db.issueSessions.peekIssueSessionWake(params.run.projectId, params.run.linearIssueId);
+        const wake = this.db.workflowWakes.peekIssueWake(params.run.projectId, params.run.linearIssueId);
         if (!wake)
             return undefined;
         this.enqueueIssue(params.run.projectId, params.run.linearIssueId);

package/dist/webhook-handler.js

@@ -13,7 +13,7 @@ import { safeJsonParse, sanitizeDiagnosticText } from "./utils.js";
 import { extractLatestAssistantSummary } from "./issue-session-events.js";
 import { WakeDispatcher } from "./wake-dispatcher.js";
 import { CodexFollowupIntentClassifier } from "./followup-intent.js";
-import { CodexConversationAdapter } from "./codex-conversation-adapter.js";
+import { AgentInputService } from "./agent-input-service.js";
 export class WebhookHandler {
     config;
     db;
@@ -30,7 +30,7 @@ export class WebhookHandler {
     dependencyReadinessHandler;
     linearSync;
     wakeDispatcher;
-    constructor(config, db, linearProvider, codex, wakeDispatcherOrEnqueueIssue, logger, feed, followupClassifier) {
+    constructor(config, db, linearProvider, codex, wakeDispatcherOrEnqueueIssue, logger, feed, followupClassifier, agentInput) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -48,9 +48,9 @@ export class WebhookHandler {
         this.issueRemovalHandler = new IssueRemovalHandler(db, feed);
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         const intentClassifier = followupClassifier ?? new CodexFollowupIntentClassifier(codex, logger);
-        const conversationAdapter = new CodexConversationAdapter(db, codex, this.wakeDispatcher, logger, feed, intentClassifier);
-        this.commentWakeHandler = new CommentWakeHandler(db, this.wakeDispatcher, feed, conversationAdapter, (issue, content, options) => this.linearSync.emitActivity(issue, content, options));
-        this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, this.wakeDispatcher, logger, feed, conversationAdapter);
+        const agentInputService = agentInput ?? new AgentInputService(db, codex, this.wakeDispatcher, logger, feed, intentClassifier);
+        this.commentWakeHandler = new CommentWakeHandler(db, this.wakeDispatcher, feed, agentInputService, (issue, content, options) => this.linearSync.emitActivity(issue, content, options));
+        this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, this.wakeDispatcher, logger, feed, agentInputService);
         this.desiredStageRecorder = new DesiredStageRecorder(db, linearProvider, this.wakeDispatcher, feed);
         this.contextLoader = new WebhookContextLoader(config, linearProvider);
         this.dependencyReadinessHandler = new DependencyReadinessHandler(db, this.wakeDispatcher, (projectId, issueId) => this.peekPendingSessionWakeRunType(projectId, issueId));
@@ -232,7 +232,7 @@ export class WebhookHandler {
         }
     }
     peekPendingSessionWakeRunType(projectId, issueId) {
-        return this.db.issueSessions.peekIssueSessionWake(projectId, issueId)?.runType;
+        return this.db.workflowWakes.peekIssueWake(projectId, issueId)?.runType;
     }
     enqueuePendingSessionWake(projectId, issueId) {
         return this.wakeDispatcher.dispatchIfWakePending(projectId, issueId);

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

@@ -17,8 +17,8 @@ export class AgentSessionHandler {
     wakeDispatcher;
     logger;
     feed;
-    conversationAdapter;
-    constructor(config, db, linearProvider, codex, wakeDispatcher, logger, feed, conversationAdapter) {
+    agentInput;
+    constructor(config, db, linearProvider, codex, wakeDispatcher, logger, feed, agentInput) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
@@ -26,7 +26,7 @@ export class AgentSessionHandler {
         this.wakeDispatcher = wakeDispatcher;
         this.logger = logger;
         this.feed = feed;
-        this.conversationAdapter = conversationAdapter;
+        this.agentInput = agentInput;
     }
     async acknowledgeCreated(normalized) {
         if (normalized.triggerEvent !== "agentSessionCreated" || !normalized.agentSession?.id || !normalized.issue) {
@@ -126,11 +126,11 @@ export class AgentSessionHandler {
         }
         const promptBody = normalized.agentSession.promptBody?.trim();
         const directReply = promptBody && existingIssue ? params.isDirectReplyToOutstandingQuestion(existingIssue) : false;
-        if (promptBody && existingIssue && this.conversationAdapter) {
-            const result = await this.conversationAdapter.deliverAgentInput({
+        if (promptBody && existingIssue && this.agentInput) {
+            const result = await this.agentInput.deliverAgentInput({
                 project,
                 issue: existingIssue,
-                source: "agent_session_prompt",
+                source: "linear_agent_session",
                 body: promptBody,
                 directReply,
                 emitActivity: (content, options) => this.publishAgentActivity(linear, normalized.agentSession.id, content, options),

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

@@ -4,13 +4,13 @@ export class CommentWakeHandler {
     db;
     wakeDispatcher;
     feed;
-    conversationAdapter;
+    agentInput;
     emitLinearActivity;
-    constructor(db, wakeDispatcher, feed, conversationAdapter, emitLinearActivity) {
+    constructor(db, wakeDispatcher, feed, agentInput, emitLinearActivity) {
         this.db = db;
         this.wakeDispatcher = wakeDispatcher;
         this.feed = feed;
-        this.conversationAdapter = conversationAdapter;
+        this.agentInput = agentInput;
         this.emitLinearActivity = emitLinearActivity;
     }
     async handle(params) {
@@ -64,10 +64,10 @@ export class CommentWakeHandler {
             });
             return;
         }
-        const result = await this.conversationAdapter?.deliverAgentInput({
+        const result = await this.agentInput?.deliverAgentInput({
             project,
             issue,
-            source: "addressed_issue_comment",
+            source: "linear_addressed_comment",
             body: addressedText,
             author: normalized.comment.userName,
             directReply: params.isDirectReplyToOutstandingQuestion(issue),

package/dist/webhooks/desired-stage-recorder.js

@@ -29,7 +29,7 @@ export class DesiredStageRecorder {
         const latestRun = existingIssue ? this.db.runs.getLatestRunForIssue(params.project.id, normalizedIssue.id) : undefined;
         const triggerAllowed = triggerEventAllowed(params.project, params.normalized.triggerEvent);
         const incomingAgentSessionId = params.normalized.agentSession?.id;
-        const hasPendingWake = this.db.issueSessions.peekIssueSessionWake(params.project.id, normalizedIssue.id) !== undefined;
+        const hasPendingWake = params.peekPendingSessionWakeRunType(params.project.id, normalizedIssue.id) !== undefined;
         if (!existingIssue && !isDelegatedToPatchRelay(this.db, params.project, normalizedIssue) && !incomingAgentSessionId) {
             return { issue: undefined, wakeRunType: undefined, delegated: false };
         }

package/dist/workflow-wake-resolver.js

@@ -0,0 +1,108 @@
+import { deriveIssueSessionReactiveIntent } from "./issue-session.js";
+function parseObjectJson(raw) {
+    if (!raw)
+        return undefined;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function hasUnattemptedFailureSignature(issue, fallbackHeadSha) {
+    const signature = issue.lastGitHubFailureSignature;
+    if (!signature)
+        return false;
+    const headSha = issue.lastGitHubFailureHeadSha ?? fallbackHeadSha;
+    return issue.lastAttemptedFailureSignature !== signature
+        || (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha);
+}
+export function deriveImplicitReactiveWake(issue) {
+    const reactiveIntent = deriveIssueSessionReactiveIntent({
+        delegatedToPatchRelay: issue.delegatedToPatchRelay,
+        activeRunId: issue.activeRunId,
+        prNumber: issue.prNumber,
+        prState: issue.prState,
+        prReviewState: issue.prReviewState,
+        prCheckStatus: issue.prCheckStatus,
+        latestFailureSource: issue.lastGitHubFailureSource,
+    });
+    if (!reactiveIntent)
+        return undefined;
+    if (reactiveIntent.runType === "ci_repair") {
+        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
+        const snapshot = parseObjectJson(issue.lastGitHubCiSnapshotJson);
+        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
+            ? failureContext.failureHeadSha
+            : issue.lastGitHubFailureHeadSha ?? issue.prHeadSha;
+        const failureSignature = issue.lastGitHubFailureSignature
+            ?? (fallbackHeadSha ? `implicit_branch_ci::${fallbackHeadSha}` : undefined);
+        if (!failureSignature || issue.prState !== "open")
+            return undefined;
+        if (issue.lastAttemptedFailureSignature === failureSignature
+            && (fallbackHeadSha === undefined || issue.lastAttemptedFailureHeadSha === fallbackHeadSha)) {
+            return undefined;
+        }
+        return {
+            runType: reactiveIntent.runType,
+            wakeReason: reactiveIntent.wakeReason,
+            context: {
+                ...failureContext,
+                failureSignature,
+                ...(fallbackHeadSha ? { failureHeadSha: fallbackHeadSha } : {}),
+                ...(issue.lastGitHubFailureCheckName ? { checkName: issue.lastGitHubFailureCheckName } : {}),
+                ...(snapshot ? { ciSnapshot: snapshot } : {}),
+            },
+        };
+    }
+    if (reactiveIntent.runType === "queue_repair") {
+        const failureContext = parseObjectJson(issue.lastGitHubFailureContextJson) ?? {};
+        const incidentContext = parseObjectJson(issue.lastQueueIncidentJson) ?? {};
+        const fallbackHeadSha = typeof failureContext.failureHeadSha === "string"
+            ? failureContext.failureHeadSha
+            : undefined;
+        if (!hasUnattemptedFailureSignature(issue, fallbackHeadSha))
+            return undefined;
+        return {
+            runType: reactiveIntent.runType,
+            wakeReason: reactiveIntent.wakeReason,
+            context: {
+                ...incidentContext,
+                ...failureContext,
+            },
+        };
+    }
+    return undefined;
+}
+export class WorkflowWakeResolver {
+    issues;
+    issueSessions;
+    constructor(issues, issueSessions) {
+        this.issues = issues;
+        this.issueSessions = issueSessions;
+    }
+    peekIssueWake(projectId, linearIssueId) {
+        const explicitWake = this.issueSessions.peekIssueSessionWake(projectId, linearIssueId);
+        if (explicitWake)
+            return explicitWake;
+        const issue = this.issues.getIssue(projectId, linearIssueId);
+        if (!issue)
+            return undefined;
+        const implicitWake = deriveImplicitReactiveWake(issue);
+        if (!implicitWake)
+            return undefined;
+        return {
+            eventIds: [],
+            runType: implicitWake.runType,
+            context: implicitWake.context,
+            wakeReason: implicitWake.wakeReason,
+            resumeThread: false,
+        };
+    }
+    hasPendingWake(projectId, linearIssueId) {
+        return this.peekIssueWake(projectId, linearIssueId) !== undefined;
+    }
+}

package/package.json

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