patchrelay 0.20.8 → 0.21.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.20.8",
-  "commit": "669292b8198c",
-  "builtAt": "2026-03-26T09:30:17.898Z"
+  "version": "0.21.0",
+  "commit": "37cae5cfd0e6",
+  "builtAt": "2026-03-26T10:21:53.343Z"
 }

package/dist/cli/watch/App.js

@@ -25,6 +25,22 @@ async function postPrompt(baseUrl, issueKey, text, bearerToken) {
         return { reason: "Request failed" };
     }
 }
+async function postStop(baseUrl, issueKey, bearerToken) {
+    const headers = { "content-type": "application/json" };
+    if (bearerToken)
+        headers.authorization = `Bearer ${bearerToken}`;
+    try {
+        const response = await fetch(new URL(`/api/issues/${encodeURIComponent(issueKey)}/stop`, baseUrl), {
+            method: "POST",
+            headers,
+            signal: AbortSignal.timeout(5000),
+        });
+        return await response.json();
+    }
+    catch {
+        return { reason: "request failed" };
+    }
+}
 async function postRetry(baseUrl, issueKey, bearerToken) {
     const headers = { "content-type": "application/json" };
     if (bearerToken)
@@ -146,6 +162,15 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             else if (input === "p") {
                 setPromptMode(true);
             }
+            else if (input === "s") {
+                if (state.activeDetailKey) {
+                    setPromptStatus("stopping...");
+                    void postStop(baseUrl, state.activeDetailKey, bearerToken).then((result) => {
+                        setPromptStatus(result.ok ? "stop sent" : `stop failed: ${result.reason ?? "unknown"}`);
+                        setTimeout(() => setPromptStatus(null), 3000);
+                    });
+                }
+            }
             else if (input === "j" || key.downArrow) {
                 dispatch({ type: "detail-navigate", direction: "next", filtered });
             }

package/dist/cli/watch/HelpBar.js

@@ -7,7 +7,7 @@ const HELP_TEXT = {
 };
 export function HelpBar({ view, follow }) {
     const text = view === "detail"
-        ? `j/k: prev/next  Esc: list  f: follow ${follow ? "on" : "off"}  p: prompt  r: retry  q: quit`
+        ? `j/k: prev/next  Esc: list  f: follow ${follow ? "on" : "off"}  p: prompt  s: stop  r: retry  q: quit`
         : HELP_TEXT[view];
     return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/http.js

@@ -325,6 +325,17 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.post("/api/issues/:issueKey/stop", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const result = await service.stopIssue(issueKey);
+            if (!result) {
+                return reply.code(404).send({ ok: false, reason: "issue_not_found" });
+            }
+            if ("error" in result) {
+                return reply.code(409).send({ ok: false, reason: result.error });
+            }
+            return reply.send({ ok: true, ...result });
+        });
         app.get("/api/feed", async (request, reply) => {
             const feedQuery = {
                 limit: getPositiveIntegerQueryParam(request, "limit") ?? 50,

package/dist/run-orchestrator.js

@@ -84,6 +84,7 @@ export class RunOrchestrator {
     feed;
     worktreeManager;
     progressThrottle = new Map();
+    activeThreadId;
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
         this.config = config;
@@ -247,9 +248,18 @@ export class RunOrchestrator {
     }
     // ─── Notification handler ─────────────────────────────────────────
     async handleCodexNotification(notification) {
-        const threadId = typeof notification.params.threadId === "string" ? notification.params.threadId : undefined;
+        // threadId is present on turn-level notifications but NOT on item-level ones.
+        // Fall back to the tracked active thread for item/delta notifications.
+        let threadId = typeof notification.params.threadId === "string" ? notification.params.threadId : undefined;
+        if (!threadId) {
+            threadId = this.activeThreadId;
+        }
         if (!threadId)
             return;
+        // Track the active thread from turn/started so item notifications can find it
+        if (notification.method === "turn/started" && threadId) {
+            this.activeThreadId = threadId;
+        }
         const run = this.db.getRunByThreadId(threadId);
         if (!run)
             return;
@@ -299,6 +309,7 @@ export class RunOrchestrator {
             void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType));
             void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
             this.progressThrottle.delete(run.id);
+            this.activeThreadId = undefined;
             return;
         }
         // Complete the run
@@ -348,6 +359,7 @@ export class RunOrchestrator {
         }));
         void this.syncLinearSession(updatedIssue);
         this.progressThrottle.delete(run.id);
+        this.activeThreadId = undefined;
     }
     // ─── In-flight progress ──────────────────────────────────────────
     maybeEmitProgressActivity(notification, run) {

package/dist/service.js

@@ -192,12 +192,20 @@ export class PatchRelayService {
         }));
     }
     subscribeCodexNotifications(listener) {
+        let trackedThreadId;
         const handler = (notification) => {
-            const threadId = typeof notification.params.threadId === "string"
+            let threadId = typeof notification.params.threadId === "string"
                 ? notification.params.threadId
                 : typeof notification.params.thread === "object" && notification.params.thread !== null && "id" in notification.params.thread
                     ? String(notification.params.thread.id)
                     : undefined;
+            // Item-level notifications lack threadId — use the tracked one from turn/started
+            if (!threadId)
+                threadId = trackedThreadId;
+            if (notification.method === "turn/started" && threadId)
+                trackedThreadId = threadId;
+            if (notification.method === "turn/completed")
+                trackedThreadId = undefined;
             let issueKey;
             let runId;
             if (threadId) {
@@ -272,6 +280,40 @@ export class PatchRelayService {
             return { delivered: false, queued: true };
         }
     }
+    async stopIssue(issueKey) {
+        const issue = this.db.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        if (!issue.activeRunId)
+            return { error: "No active run to stop" };
+        const run = this.db.getRun(issue.activeRunId);
+        if (run?.threadId && run.turnId) {
+            try {
+                await this.codex.steerTurn({
+                    threadId: run.threadId,
+                    turnId: run.turnId,
+                    input: "STOP: The operator has requested this run to halt immediately. Finish your current action, commit any partial progress, and stop.",
+                });
+            }
+            catch {
+                // Turn may already be done
+            }
+        }
+        this.db.upsertIssue({
+            projectId: issue.projectId,
+            linearIssueId: issue.linearIssueId,
+            factoryState: "awaiting_input",
+        });
+        this.feed.publish({
+            level: "warn",
+            kind: "workflow",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            status: "stopped",
+            summary: "Operator stopped the run",
+        });
+        return { stopped: true };
+    }
     retryIssue(issueKey) {
         const issue = this.db.getIssueByKey(issueKey);
         if (!issue)

package/dist/webhook-handler.js

@@ -306,8 +306,32 @@ export class WebhookHandler {
         if (!triggerEventAllowed(project, normalized.triggerEvent))
             return;
         const issue = this.db.getIssue(project.id, normalized.issue.id);
-        if (!issue?.activeRunId)
+        if (!issue)
             return;
+        // No active run — enqueue a run with the comment as context if appropriate
+        if (!issue.activeRunId) {
+            const ENQUEUEABLE_STATES = new Set(["pr_open", "changes_requested", "implementing", "delegated"]);
+            if (ENQUEUEABLE_STATES.has(issue.factoryState)) {
+                const runType = issue.prReviewState === "changes_requested" ? "review_fix" : "implementation";
+                this.db.upsertIssue({
+                    projectId: project.id,
+                    linearIssueId: normalized.issue.id,
+                    pendingRunType: runType,
+                    pendingRunContextJson: JSON.stringify({ userComment: normalized.comment.body.trim() }),
+                });
+                this.enqueueIssue(project.id, normalized.issue.id);
+                this.feed?.publish({
+                    level: "info",
+                    kind: "comment",
+                    projectId: project.id,
+                    issueKey: trackedIssue?.issueKey,
+                    status: "enqueued",
+                    summary: `Comment enqueued ${runType} run`,
+                    detail: normalized.comment.body.slice(0, 200),
+                });
+            }
+            return;
+        }
         const run = this.db.getRun(issue.activeRunId);
         if (!run?.threadId || !run.turnId)
             return;

package/package.json

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