patchrelay 0.18.0 → 0.20.0

package/dist/agent-session-plan.js

@@ -14,33 +14,33 @@ export function formatRunTypeLabel(runType) {
 function implementationPlan() {
     return [
         { content: "Prepare workspace", status: "pending" },
-        { content: "Implement or update branch", status: "pending" },
-        { content: "Await review", status: "pending" },
-        { content: "Land change", status: "pending" },
+        { content: "Implementing", status: "pending" },
+        { content: "Awaiting verification", status: "pending" },
+        { content: "Merge", status: "pending" },
     ];
 }
 function reviewFixPlan() {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Address review feedback", status: "pending" },
-        { content: "Await re-review", status: "pending" },
-        { content: "Land change", status: "pending" },
+        { content: "Addressing review feedback", status: "pending" },
+        { content: "Awaiting re-verification", status: "pending" },
+        { content: "Merge", status: "pending" },
     ];
 }
 function ciRepairPlan(attempt) {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Implement or update branch", status: "completed" },
-        { content: `Repair failing checks (${attemptLabel(attempt)})`, status: "pending" },
-        { content: "Return to merge flow", status: "pending" },
+        { content: "Implementing", status: "completed" },
+        { content: `Repairing checks (${attemptLabel(attempt)})`, status: "pending" },
+        { content: "Merge", status: "pending" },
     ];
 }
 function queueRepairPlan(attempt) {
     return [
         { content: "Prepare workspace", status: "completed" },
-        { content: "Implement or update branch", status: "completed" },
-        { content: "Review approved", status: "completed" },
-        { content: `Repair merge queue (${attemptLabel(attempt)})`, status: "pending" },
+        { content: "Implementing", status: "completed" },
+        { content: "Verification passed", status: "completed" },
+        { content: `Repairing merge (${attemptLabel(attempt)})`, status: "pending" },
     ];
 }
 function awaitingInputPlan() {
@@ -101,9 +101,9 @@ export function buildAgentSessionPlan(params) {
         case "awaiting_queue":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
-                { content: "Implement or update branch", status: "completed" },
-                { content: "Review approved", status: "completed" },
-                { content: "Queued for merge", status: "inProgress" },
+                { content: "Implementing", status: "completed" },
+                { content: "Verification passed", status: "completed" },
+                { content: "Awaiting merge", status: "inProgress" },
             ], ["completed", "completed", "completed", "inProgress"]);
         case "repairing_queue":
             return setStatuses(queueRepairPlan(params.queueRepairAttempts ?? 1), ["completed", "completed", "completed", "inProgress"]);
@@ -116,8 +116,8 @@ export function buildAgentSessionPlan(params) {
         case "done":
             return setStatuses([
                 { content: "Prepare workspace", status: "completed" },
-                { content: "Implement or update branch", status: "completed" },
-                { content: "Review approved", status: "completed" },
+                { content: "Implementing", status: "completed" },
+                { content: "Verification passed", status: "completed" },
                 { content: "Merged", status: "completed" },
             ], ["completed", "completed", "completed", "completed"]);
     }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.18.0",
-  "commit": "37f3bf8f344f",
-  "builtAt": "2026-03-25T19:56:49.875Z"
+  "version": "0.20.0",
+  "commit": "e3ce50c81db1",
+  "builtAt": "2026-03-25T20:18:22.070Z"
 }

package/dist/cli/watch/App.js

@@ -1,6 +1,6 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { useReducer, useMemo, useCallback } from "react";
-import { Box, useApp, useInput } from "ink";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useReducer, useMemo, useCallback, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
 import { watchReducer, initialWatchState, filterIssues } from "./watch-state.js";
 import { useWatchStream } from "./use-watch-stream.js";
 import { useDetailStream } from "./use-detail-stream.js";
@@ -8,6 +8,17 @@ import { useFeedStream } from "./use-feed-stream.js";
 import { IssueListView } from "./IssueListView.js";
 import { IssueDetailView } from "./IssueDetailView.js";
 import { FeedView } from "./FeedView.js";
+async function postPrompt(baseUrl, issueKey, text, bearerToken) {
+    const headers = { "content-type": "application/json" };
+    if (bearerToken)
+        headers.authorization = `Bearer ${bearerToken}`;
+    await fetch(new URL(`/api/issues/${encodeURIComponent(issueKey)}/prompt`, baseUrl), {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ text }),
+        signal: AbortSignal.timeout(5000),
+    }).catch(() => { });
+}
 async function postRetry(baseUrl, issueKey, bearerToken) {
     const headers = { "content-type": "application/json" };
     if (bearerToken)
@@ -28,12 +39,37 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
     useWatchStream({ baseUrl, bearerToken, dispatch });
     useDetailStream({ baseUrl, bearerToken, issueKey: state.activeDetailKey, dispatch });
     useFeedStream({ baseUrl, bearerToken, active: state.view === "feed", dispatch });
+    const [promptMode, setPromptMode] = useState(false);
+    const [promptBuffer, setPromptBuffer] = useState("");
     const handleRetry = useCallback(() => {
         if (state.activeDetailKey) {
             void postRetry(baseUrl, state.activeDetailKey, bearerToken);
         }
     }, [baseUrl, bearerToken, state.activeDetailKey]);
+    const handlePromptSubmit = useCallback(() => {
+        if (state.activeDetailKey && promptBuffer.trim()) {
+            void postPrompt(baseUrl, state.activeDetailKey, promptBuffer.trim(), bearerToken);
+        }
+        setPromptMode(false);
+        setPromptBuffer("");
+    }, [baseUrl, bearerToken, state.activeDetailKey, promptBuffer]);
     useInput((input, key) => {
+        if (promptMode) {
+            if (key.escape) {
+                setPromptMode(false);
+                setPromptBuffer("");
+            }
+            else if (key.return) {
+                handlePromptSubmit();
+            }
+            else if (key.backspace || key.delete) {
+                setPromptBuffer((b) => b.slice(0, -1));
+            }
+            else if (input && !key.ctrl && !key.meta) {
+                setPromptBuffer((b) => b + input);
+            }
+            return;
+        }
         if (input === "q") {
             exit();
             return;
@@ -68,6 +104,9 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             else if (input === "r") {
                 handleRetry();
             }
+            else if (input === "p") {
+                setPromptMode(true);
+            }
             else if (input === "j" || key.downArrow) {
                 dispatch({ type: "detail-navigate", direction: "next", filtered });
             }
@@ -81,5 +120,5 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             }
         }
     });
-    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, allIssues: filtered, activeDetailKey: state.activeDetailKey })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, allIssues: filtered, activeDetailKey: state.activeDetailKey }), promptMode && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "prompt> " }), _jsx(Text, { children: promptBuffer }), _jsx(Text, { dimColor: true, children: "_" })] }))] })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
 }

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"}  r: retry  q: quit`
+        ? `j/k: prev/next  Esc: list  f: follow ${follow ? "on" : "off"}  p: prompt  r: retry  q: quit`
         : HELP_TEXT[view];
     return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/cli/watch/TimelineRow.js

@@ -28,15 +28,24 @@ function FeedRow({ entry }) {
     const statusLabel = feed.status ?? feed.feedKind;
     return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { color: "cyan", children: statusLabel.padEnd(16) }), _jsx(Text, { children: feed.summary })] }));
 }
+const RUN_TYPE_LABELS = {
+    implementation: "implementing",
+    ci_repair: "repairing checks",
+    review_fix: "addressing feedback",
+    queue_repair: "repairing merge",
+};
+function runLabel(runType) {
+    return RUN_TYPE_LABELS[runType] ?? runType;
+}
 function RunStartRow({ entry }) {
     const run = entry.run;
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: "yellow", children: run.runType.padEnd(16) }), _jsx(Text, { bold: true, children: "run started" })] }));
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: "yellow", children: runLabel(run.runType).padEnd(20) }), _jsx(Text, { bold: true, children: "started" })] }));
 }
 function RunEndRow({ entry }) {
     const run = entry.run;
     const color = run.status === "completed" ? "green" : "red";
     const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : "";
-    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: color, children: run.runType.padEnd(16) }), _jsx(Text, { bold: true, color: color, children: run.status }), duration ? _jsxs(Text, { dimColor: true, children: ["(", duration, ")"] }) : null] }));
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: color, children: runLabel(run.runType).padEnd(20) }), _jsx(Text, { bold: true, color: color, children: run.status }), duration ? _jsxs(Text, { dimColor: true, children: ["(", duration, ")"] }) : null] }));
 }
 function ItemRow({ entry }) {
     const item = entry.item;

package/dist/config.js

@@ -30,6 +30,10 @@ const projectSchema = z.object({
     allow_labels: z.array(z.string().min(1)).default([]),
     trigger_events: z.array(z.string().min(1)).min(1).optional(),
     branch_prefix: z.string().min(1).optional(),
+    /** Check names that are review gates (AI Review, quality analysis). Default: code class. */
+    review_checks: z.array(z.string().min(1)).default([]),
+    /** Check names that are policy gates (conventional title, release policy). Default: code class. */
+    gate_checks: z.array(z.string().min(1)).default([]),
     github: z.object({
         webhook_secret: z.string().min(1).optional(),
         repo_full_name: z.string().min(1).optional(),
@@ -394,6 +398,8 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 issueKeyPrefixes: project.issue_key_prefixes,
                 linearTeamIds: project.linear_team_ids,
                 allowLabels: project.allow_labels,
+                reviewChecks: project.review_checks,
+                gateChecks: project.gate_checks,
                 triggerEvents: normalizeTriggerEvents(parsed.linear.oauth.actor, repoSettings?.trigger_events ??
                     project.trigger_events),
                 branchPrefix: repoSettings?.branch_prefix ?? project.branch_prefix ?? defaultBranchPrefix(project.id),

package/dist/db.js

@@ -233,6 +233,10 @@ export class PatchRelayDatabase {
         const row = this.connection.prepare("SELECT * FROM issues WHERE branch_name = ?").get(branchName);
         return row ? mapIssueRow(row) : undefined;
     }
+    getIssueByPrNumber(prNumber) {
+        const row = this.connection.prepare("SELECT * FROM issues WHERE pr_number = ?").get(prNumber);
+        return row ? mapIssueRow(row) : undefined;
+    }
     listIssuesReadyForExecution() {
         const rows = this.connection
             .prepare("SELECT project_id, linear_issue_id FROM issues WHERE (pending_run_type IS NOT NULL OR pending_merge_prep = 1) AND active_run_id IS NULL")
@@ -246,9 +250,13 @@ export class PatchRelayDatabase {
      * Issues idle in pr_open with no active run — candidates for state
      * advancement based on stored PR metadata (missed GitHub webhooks).
      */
-    listIdlePrOpenIssues() {
+    listIdleNonTerminalIssues() {
         const rows = this.connection
-            .prepare("SELECT * FROM issues WHERE factory_state = 'pr_open' AND active_run_id IS NULL AND pending_run_type IS NULL AND pr_number IS NOT NULL")
+            .prepare(`SELECT * FROM issues
+         WHERE factory_state NOT IN ('done', 'escalated', 'failed', 'awaiting_input')
+         AND active_run_id IS NULL
+         AND pending_run_type IS NULL
+         AND pr_number IS NOT NULL`)
             .all();
         return rows.map(mapIssueRow);
     }

package/dist/github-webhook-handler.js

@@ -25,14 +25,16 @@ export class GitHubWebhookHandler {
     enqueueIssue;
     mergeQueue;
     logger;
+    codex;
     feed;
-    constructor(config, db, linearProvider, enqueueIssue, mergeQueue, logger, feed) {
+    constructor(config, db, linearProvider, enqueueIssue, mergeQueue, logger, codex, feed) {
         this.config = config;
         this.db = db;
         this.linearProvider = linearProvider;
         this.enqueueIssue = enqueueIssue;
         this.mergeQueue = mergeQueue;
         this.logger = logger;
+        this.codex = codex;
         this.feed = feed;
     }
     async acceptGitHubWebhook(params) {
@@ -100,6 +102,10 @@ export class GitHubWebhookHandler {
             }
             return;
         }
+        if (params.eventType === "issue_comment") {
+            await this.handlePrComment(payload);
+            return;
+        }
         const event = normalizeGitHubWebhook({
             eventType: params.eventType,
             payload: payload,
@@ -182,10 +188,11 @@ export class GitHubWebhookHandler {
             detail: event.checkName ?? event.reviewBody?.slice(0, 200) ?? undefined,
         });
         if (!isMetadataOnlyCheckEvent(event)) {
-            this.maybeEnqueueReactiveRun(freshIssue, event);
+            const project = this.config.projects.find((p) => p.id === freshIssue.projectId);
+            this.maybeEnqueueReactiveRun(freshIssue, event, project);
         }
     }
-    maybeEnqueueReactiveRun(issue, event) {
+    maybeEnqueueReactiveRun(issue, event, project) {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
@@ -197,6 +204,7 @@ export class GitHubWebhookHandler {
                 pendingRunContextJson: JSON.stringify({
                     checkName: event.checkName,
                     checkUrl: event.checkUrl,
+                    checkClass: resolveCheckClass(event.checkName, project),
                 }),
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
@@ -280,4 +288,63 @@ export class GitHubWebhookHandler {
             this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to sync Linear session from GitHub webhook");
         }
     }
+    async handlePrComment(payload) {
+        if (payload.action !== "created")
+            return;
+        const issuePayload = payload.issue;
+        const comment = payload.comment;
+        if (!issuePayload || !comment)
+            return;
+        if (!issuePayload.pull_request)
+            return; // only PR comments
+        const body = typeof comment.body === "string" ? comment.body : "";
+        if (!body.trim())
+            return;
+        const user = comment.user;
+        const author = typeof user?.login === "string" ? user.login : "unknown";
+        if (typeof user?.type === "string" && user.type === "Bot")
+            return;
+        const prNumber = typeof issuePayload.number === "number" ? issuePayload.number : undefined;
+        if (!prNumber)
+            return;
+        const issue = this.db.getIssueByPrNumber(prNumber);
+        if (!issue)
+            return;
+        this.feed?.publish({
+            level: "info",
+            kind: "comment",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "pr_comment",
+            summary: `GitHub PR comment from ${author}`,
+            detail: body.slice(0, 200),
+        });
+        if (issue.activeRunId) {
+            const run = this.db.getRun(issue.activeRunId);
+            if (run?.threadId && run.turnId) {
+                try {
+                    await this.codex.steerTurn({
+                        threadId: run.threadId,
+                        turnId: run.turnId,
+                        input: `GitHub PR comment from ${author}:\n\n${body}`,
+                    });
+                    this.logger.info({ issueKey: issue.issueKey, author }, "Forwarded GitHub PR comment to active run");
+                }
+                catch (error) {
+                    const msg = error instanceof Error ? error.message : String(error);
+                    this.logger.warn({ issueKey: issue.issueKey, error: msg }, "Failed to forward GitHub PR comment");
+                }
+            }
+        }
+    }
+}
+function resolveCheckClass(checkName, project) {
+    if (!checkName || !project)
+        return "code";
+    if (project.reviewChecks.some((name) => checkName.includes(name)))
+        return "review";
+    if (project.gateChecks.some((name) => checkName.includes(name)))
+        return "gate";
+    return "code";
 }

package/dist/http.js

@@ -309,6 +309,22 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.post("/api/issues/:issueKey/prompt", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const body = request.body;
+            const text = body?.text;
+            if (!text || typeof text !== "string") {
+                return reply.code(400).send({ ok: false, reason: "missing text field" });
+            }
+            const result = await service.promptIssue(issueKey, text);
+            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, delivered: true });
+        });
         app.get("/api/feed", async (request, reply) => {
             const feedQuery = {
                 limit: getPositiveIntegerQueryParam(request, "limit") ?? 50,

package/dist/run-orchestrator.js

@@ -410,53 +410,70 @@ export class RunOrchestrator {
         }
         // Advance issues stuck in pr_open whose stored PR metadata already
         // shows they should transition (e.g. approved PR, missed webhook).
-        await this.reconcileIdlePrOpenIssues();
+        await this.reconcileIdleIssues();
     }
-    async reconcileIdlePrOpenIssues() {
-        for (const issue of this.db.listIdlePrOpenIssues()) {
+    async reconcileIdleIssues() {
+        for (const issue of this.db.listIdleNonTerminalIssues()) {
+            // PR already merged — advance to done regardless of current state
             if (issue.prState === "merged") {
                 this.advanceIdleIssue(issue, "done");
                 continue;
             }
-            if (issue.prReviewState === "approved") {
+            // Review approved + checks not failed — advance to awaiting_queue
+            if (issue.prReviewState === "approved" && issue.prCheckStatus !== "failed") {
                 this.advanceIdleIssue(issue, "awaiting_queue");
                 continue;
             }
-            // Stored metadata may be stale (missed webhooks during downtime).
-            // Query GitHub for the actual PR review state.
-            const project = this.config.projects.find((p) => p.id === issue.projectId);
-            if (!project?.github?.repoFullName || !issue.prNumber)
+            // Checks failed + idle (not already in a repair state) — enqueue ci_repair
+            if (issue.prCheckStatus === "failed" && issue.factoryState !== "repairing_ci") {
+                this.advanceIdleIssue(issue, "repairing_ci", "ci_repair");
+                continue;
+            }
+            // Awaiting queue with stale pending merge prep — re-enqueue
+            if (issue.factoryState === "awaiting_queue" && issue.pendingMergePrep) {
+                this.enqueueIssue(issue.projectId, issue.linearIssueId);
                 continue;
-            try {
-                const { stdout } = await execCommand("gh", [
-                    "pr", "view", String(issue.prNumber),
-                    "--repo", project.github.repoFullName,
-                    "--json", "state,reviewDecision",
-                ], { timeoutMs: 10_000 });
-                const pr = JSON.parse(stdout);
-                if (pr.state === "MERGED") {
-                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
-                    this.advanceIdleIssue(issue, "done");
-                }
-                else if (pr.reviewDecision === "APPROVED") {
-                    this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
-                    this.advanceIdleIssue(issue, "awaiting_queue");
-                }
             }
-            catch (error) {
-                this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+            // For pr_open issues with no review decision, check GitHub for stale metadata
+            if (issue.factoryState === "pr_open" && !issue.prReviewState) {
+                await this.reconcileFromGitHub(issue);
             }
         }
     }
-    advanceIdleIssue(issue, newState) {
-        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState }, "Reconciliation: advancing idle issue from stored PR metadata");
+    async reconcileFromGitHub(issue) {
+        const project = this.config.projects.find((p) => p.id === issue.projectId);
+        if (!project?.github?.repoFullName || !issue.prNumber)
+            return;
+        try {
+            const { stdout } = await execCommand("gh", [
+                "pr", "view", String(issue.prNumber),
+                "--repo", project.github.repoFullName,
+                "--json", "state,reviewDecision",
+            ], { timeoutMs: 10_000 });
+            const pr = JSON.parse(stdout);
+            if (pr.state === "MERGED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prState: "merged" });
+                this.advanceIdleIssue(issue, "done");
+            }
+            else if (pr.reviewDecision === "APPROVED") {
+                this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, prReviewState: "approved" });
+                this.advanceIdleIssue(issue, "awaiting_queue");
+            }
+        }
+        catch (error) {
+            this.logger.debug({ issueKey: issue.issueKey, error: error instanceof Error ? error.message : String(error) }, "Failed to query GitHub PR state during reconciliation");
+        }
+    }
+    advanceIdleIssue(issue, newState, pendingRunType) {
+        this.logger.info({ issueKey: issue.issueKey, from: issue.factoryState, to: newState, pendingRunType }, "Reconciliation: advancing idle issue");
         this.db.upsertIssue({
             projectId: issue.projectId,
             linearIssueId: issue.linearIssueId,
             factoryState: newState,
             ...(newState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
+            ...(pendingRunType ? { pendingRunType: pendingRunType } : {}),
         });
-        if (newState === "awaiting_queue") {
+        if (newState === "awaiting_queue" || pendingRunType) {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }

package/dist/service.js

@@ -57,7 +57,7 @@ export class PatchRelayService {
             })();
         });
         this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
-        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), this.mergeQueue, logger, this.feed);
+        this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), this.mergeQueue, logger, codex, this.feed);
         const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {
             processIssue: async (item) => {
                 const issue = db.getIssue(item.projectId, item.issueId);
@@ -218,6 +218,24 @@ export class PatchRelayService {
         this.codex.on("notification", handler);
         return () => { this.codex.off("notification", handler); };
     }
+    async promptIssue(issueKey, text) {
+        const issue = this.db.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        if (!issue.activeRunId)
+            return { error: "No active run" };
+        const run = this.db.getRun(issue.activeRunId);
+        if (!run?.threadId || !run.turnId)
+            return { error: "No active thread or turn" };
+        try {
+            await this.codex.steerTurn({ threadId: run.threadId, turnId: run.turnId, input: `Operator prompt from watch TUI:\n\n${text}` });
+            return { delivered: true };
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { error: `Failed to deliver prompt: ${msg}` };
+        }
+    }
     retryIssue(issueKey) {
         const issue = this.db.getIssueByKey(issueKey);
         if (!issue)

package/package.json

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