patchrelay 0.19.0 → 0.20.1

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.19.0",
-  "commit": "0172365b885d",
-  "builtAt": "2026-03-25T20:06:12.646Z"
+  "version": "0.20.1",
+  "commit": "d3e7ac8f36d2",
+  "builtAt": "2026-03-25T21:27:48.361Z"
 }

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,23 @@ 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}`;
+    try {
+        const response = await fetch(new URL(`/api/issues/${encodeURIComponent(issueKey)}/prompt`, baseUrl), {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ text }),
+            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)
@@ -28,12 +45,60 @@ 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 [promptStatus, setPromptStatus] = useState(null);
+    const handlePromptSubmit = useCallback(() => {
+        const text = promptBuffer.trim();
+        if (!state.activeDetailKey || !text) {
+            setPromptMode(false);
+            setPromptBuffer("");
+            return;
+        }
+        // Add synthetic userMessage to timeline immediately
+        dispatch({
+            type: "codex-notification",
+            method: "item/started",
+            params: { item: { id: `prompt-${Date.now()}`, type: "userMessage", status: "completed", text } },
+        });
+        setPromptMode(false);
+        setPromptBuffer("");
+        setPromptStatus("sending...");
+        void postPrompt(baseUrl, state.activeDetailKey, text, bearerToken).then((result) => {
+            if (result.delivered) {
+                setPromptStatus("delivered");
+            }
+            else if (result.queued) {
+                setPromptStatus("queued for next run");
+            }
+            else if (result.reason) {
+                setPromptStatus(`failed: ${result.reason}`);
+            }
+            setTimeout(() => setPromptStatus(null), 3000);
+        });
+    }, [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 +133,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 +149,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: "_" })] })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : (_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/ItemLine.js

@@ -64,6 +64,9 @@ export function ItemLine({ item, isLast }) {
         case "plan":
             content = renderPlan(item);
             break;
+        case "userMessage":
+            content = (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "you: " }), _jsx(Text, { children: truncate(item.text ?? "", 120) })] }));
+            break;
         default:
             content = renderDefault(item);
             break;

package/dist/cli/watch/format-utils.js

@@ -0,0 +1,43 @@
+/** Format ISO timestamp as HH:MM:SS (24h, en-GB). */
+export function formatTime(iso) {
+    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false });
+}
+/** Format ISO timestamp as compact relative time: "3s", "12m", "2h", "5d". */
+export function relativeTime(iso) {
+    const ms = Date.now() - new Date(iso).getTime();
+    if (ms < 0)
+        return "now";
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 24)
+        return `${hours}h`;
+    const days = Math.floor(hours / 24);
+    return `${days}d`;
+}
+/** Format millisecond duration as "2m 30s" or "45s". */
+export function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+/** Format token count with k/M suffix. */
+export function formatTokens(n) {
+    if (n >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (n >= 1_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    return String(n);
+}
+/** Truncate text to max length with ellipsis. Collapses newlines. */
+export function truncate(text, max) {
+    const line = text.replace(/\n/g, " ").trim();
+    return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
+}

package/dist/cli/watch/sse-parser.js

@@ -0,0 +1,43 @@
+/**
+ * Shared SSE (Server-Sent Events) stream parser.
+ * Extracts event type + data from a ReadableStream, calls onEvent for each complete event.
+ */
+export async function readSSEStream(body, onEvent) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let eventType = "";
+    let dataLines = [];
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIndex = buffer.indexOf("\n");
+        while (newlineIndex !== -1) {
+            const rawLine = buffer.slice(0, newlineIndex);
+            buffer = buffer.slice(newlineIndex + 1);
+            const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+            if (!line) {
+                if (dataLines.length > 0) {
+                    onEvent(eventType, dataLines.join("\n"));
+                    dataLines = [];
+                    eventType = "";
+                }
+                newlineIndex = buffer.indexOf("\n");
+                continue;
+            }
+            if (line.startsWith(":")) {
+                newlineIndex = buffer.indexOf("\n");
+                continue;
+            }
+            if (line.startsWith("event:")) {
+                eventType = line.slice(6).trim();
+            }
+            else if (line.startsWith("data:")) {
+                dataLines.push(line.slice(5).trimStart());
+            }
+            newlineIndex = buffer.indexOf("\n");
+        }
+    }
+}

package/dist/cli/watch/theme.js

@@ -0,0 +1,55 @@
+// ─── Factory State Colors ─────────────────────────────────────────
+export const FACTORY_STATE_COLORS = {
+    delegated: "blue",
+    preparing: "blue",
+    implementing: "yellow",
+    awaiting_input: "yellow",
+    pr_open: "cyan",
+    changes_requested: "magenta",
+    repairing_ci: "magenta",
+    repairing_queue: "magenta",
+    awaiting_queue: "green",
+    done: "green",
+    failed: "red",
+    escalated: "red",
+};
+// ─── Item Status Symbols & Colors ─────────────────────────────────
+export const ITEM_STATUS_SYMBOLS = {
+    completed: "\u2713",
+    failed: "\u2717",
+    declined: "\u2717",
+    inProgress: "\u25cf",
+};
+export const ITEM_STATUS_COLORS = {
+    completed: "green",
+    failed: "red",
+    declined: "red",
+    inProgress: "yellow",
+};
+// ─── CI Check Symbols & Colors ────────────────────────────────────
+export const CHECK_SYMBOLS = {
+    passed: "\u2713",
+    failed: "\u2717",
+    pending: "\u25cf",
+};
+export const CHECK_COLORS = {
+    passed: "green",
+    failed: "red",
+    pending: "yellow",
+};
+// ─── Feed Event Colors ────────────────────────────────────────────
+export const FEED_LEVEL_COLORS = {
+    info: "white",
+    warn: "yellow",
+    error: "red",
+};
+export const FEED_KIND_COLORS = {
+    stage: "cyan",
+    turn: "yellow",
+    github: "green",
+    webhook: "blue",
+    agent: "magenta",
+    service: "white",
+    workflow: "cyan",
+    linear: "blue",
+};

package/dist/cli/watch/timeline-builder.js

@@ -303,7 +303,7 @@ export function appendCodexItemToTimeline(timeline, params, activeRunId) {
     const type = typeof itemObj.type === "string" ? itemObj.type : "unknown";
     const status = typeof itemObj.status === "string" ? itemObj.status : "inProgress";
     const item = { id, type, status };
-    if (type === "agentMessage" && typeof itemObj.text === "string")
+    if ((type === "agentMessage" || type === "userMessage") && typeof itemObj.text === "string")
         item.text = itemObj.text;
     if (type === "commandExecution") {
         const cmd = itemObj.command;

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")

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,
@@ -282,6 +288,56 @@ 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)

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, ...result });
+        });
         app.get("/api/feed", async (request, reply) => {
             const feedQuery = {
                 limit: getPositiveIntegerQueryParam(request, "limit") ?? 50,

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,60 @@ export class PatchRelayService {
         this.codex.on("notification", handler);
         return () => { this.codex.off("notification", handler); };
     }
+    async promptIssue(issueKey, text, source = "watch") {
+        const issue = this.db.getIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        // Publish to operator feed so all clients see the prompt
+        this.feed.publish({
+            level: "info",
+            kind: "comment",
+            issueKey: issue.issueKey,
+            projectId: issue.projectId,
+            stage: issue.factoryState,
+            status: "operator_prompt",
+            summary: `Operator prompt (${source})`,
+            detail: text.slice(0, 200),
+        });
+        // If no active run, queue as pending context for the next run
+        if (!issue.activeRunId) {
+            const existing = issue.pendingRunContextJson
+                ? JSON.parse(issue.pendingRunContextJson)
+                : {};
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunContextJson: JSON.stringify({ ...existing, operatorPrompt: text }),
+            });
+            return { delivered: false, queued: true };
+        }
+        const run = this.db.getRun(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) {
+            // Turn may have completed between check and steer — queue for next run
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.warn({ issueKey, error: msg }, "steerTurn failed, queuing prompt for next run");
+            const existing = issue.pendingRunContextJson
+                ? JSON.parse(issue.pendingRunContextJson)
+                : {};
+            this.db.upsertIssue({
+                projectId: issue.projectId,
+                linearIssueId: issue.linearIssueId,
+                pendingRunContextJson: JSON.stringify({ ...existing, operatorPrompt: text }),
+            });
+            return { delivered: false, queued: true };
+        }
+    }
     retryIssue(issueKey) {
         const issue = this.db.getIssueByKey(issueKey);
         if (!issue)

package/package.json

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