patchrelay 0.17.0 → 0.18.0

package/dist/agent-session-plan.js

@@ -93,7 +93,6 @@ export function buildAgentSessionPlan(params) {
         case "implementing":
             return setStatuses(planForRunType("implementation", params), ["completed", "inProgress", "pending", "pending"]);
         case "pr_open":
-        case "awaiting_review":
             return setStatuses(implementationPlan(), ["completed", "completed", "inProgress", "pending"]);
         case "changes_requested":
             return setStatuses(reviewFixPlan(), ["completed", "inProgress", "pending", "pending"]);
@@ -164,7 +163,7 @@ export function buildCompletedSessionPlan(runType) {
     if (runType === "ci_repair" || runType === "queue_repair") {
         return buildAgentSessionPlan({ factoryState: "awaiting_queue" });
     }
-    return buildAgentSessionPlan({ factoryState: "awaiting_review" });
+    return buildAgentSessionPlan({ factoryState: "pr_open" });
 }
 export function buildAwaitingHandoffSessionPlan(runType) {
     return buildCompletedSessionPlan(runType);

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.17.0",
-  "commit": "972d51f6e0da",
-  "builtAt": "2026-03-25T12:55:22.635Z"
+  "version": "0.18.0",
+  "commit": "37f3bf8f344f",
+  "builtAt": "2026-03-25T19:56:49.875Z"
 }

package/dist/cli/watch/App.js

@@ -4,8 +4,10 @@ import { Box, 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";
+import { useFeedStream } from "./use-feed-stream.js";
 import { IssueListView } from "./IssueListView.js";
 import { IssueDetailView } from "./IssueDetailView.js";
+import { FeedView } from "./FeedView.js";
 async function postRetry(baseUrl, issueKey, bearerToken) {
     const headers = { "content-type": "application/json" };
     if (bearerToken)
@@ -25,6 +27,7 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
     const filtered = useMemo(() => filterIssues(state.issues, state.filter), [state.issues, state.filter]);
     useWatchStream({ baseUrl, bearerToken, dispatch });
     useDetailStream({ baseUrl, bearerToken, issueKey: state.activeDetailKey, dispatch });
+    useFeedStream({ baseUrl, bearerToken, active: state.view === "feed", dispatch });
     const handleRetry = useCallback(() => {
         if (state.activeDetailKey) {
             void postRetry(baseUrl, state.activeDetailKey, bearerToken);
@@ -51,6 +54,9 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             else if (key.tab) {
                 dispatch({ type: "cycle-filter" });
             }
+            else if (input === "F" || input === "f") {
+                dispatch({ type: "enter-feed" });
+            }
         }
         else if (state.view === "detail") {
             if (key.escape || key.backspace || key.delete) {
@@ -62,7 +68,18 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             else if (input === "r") {
                 handleRetry();
             }
+            else if (input === "j" || key.downArrow) {
+                dispatch({ type: "detail-navigate", direction: "next", filtered });
+            }
+            else if (input === "k" || key.upArrow) {
+                dispatch({ type: "detail-navigate", direction: "prev", filtered });
+            }
+        }
+        else if (state.view === "feed") {
+            if (key.escape || key.backspace || key.delete) {
+                dispatch({ type: "exit-feed" });
+            }
         }
     });
-    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : (_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 })) }));
+    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 })) }));
 }

package/dist/cli/watch/FeedView.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { HelpBar } from "./HelpBar.js";
+const TAIL_SIZE = 30;
+const LEVEL_COLORS = {
+    info: "white",
+    warn: "yellow",
+    error: "red",
+};
+const KIND_COLORS = {
+    stage: "cyan",
+    turn: "yellow",
+    github: "green",
+    webhook: "blue",
+    agent: "magenta",
+    service: "white",
+    workflow: "cyan",
+    linear: "blue",
+};
+function formatTime(iso) {
+    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false });
+}
+function FeedEventRow({ event }) {
+    const kindColor = KIND_COLORS[event.kind] ?? "white";
+    const levelColor = LEVEL_COLORS[event.level] ?? "white";
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(event.at) }), _jsx(Text, { color: kindColor, children: event.kind.padEnd(10) }), event.issueKey && _jsx(Text, { bold: true, children: event.issueKey.padEnd(10) }), event.stage && _jsx(Text, { color: "cyan", children: event.stage.padEnd(16) }), _jsx(Text, { color: levelColor, children: event.summary })] }));
+}
+export function FeedView({ events, connected }) {
+    const visible = events.length > TAIL_SIZE ? events.slice(-TAIL_SIZE) : events;
+    const skipped = events.length - visible.length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { justifyContent: "space-between", children: [_jsx(Text, { bold: true, children: "Operator Feed" }), _jsx(Text, { color: connected ? "green" : "red", children: connected ? "\u25cf connected" : "\u25cb disconnected" })] }), _jsx(Text, { dimColor: true, children: "\u2500".repeat(72) }), events.length === 0 ? (_jsx(Text, { dimColor: true, children: "No feed events yet." })) : (_jsxs(Box, { flexDirection: "column", children: [skipped > 0 && _jsxs(Text, { dimColor: true, children: ["  ... ", skipped, " earlier events"] }), visible.map((event) => (_jsx(FeedEventRow, { event: event }, event.id)))] })), _jsx(Text, { dimColor: true, children: "\u2500".repeat(72) }), _jsx(HelpBar, { view: "feed" })] }));
+}

package/dist/cli/watch/HelpBar.js

@@ -1,7 +1,13 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+const HELP_TEXT = {
+    list: "j/k: navigate  Enter: detail  F: feed  Tab: filter  q: quit",
+    detail: "",
+    feed: "Esc: list  q: quit",
+};
 export function HelpBar({ view, follow }) {
-    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: view === "list"
-                ? "j/k: navigate  Enter: detail  Tab: filter  q: quit"
-                : `Esc: back  f: follow ${follow ? "on" : "off"}  r: retry  q: quit` }) }));
+    const text = view === "detail"
+        ? `j/k: prev/next  Esc: list  f: follow ${follow ? "on" : "off"}  r: retry  q: quit`
+        : HELP_TEXT[view];
+    return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/cli/watch/IssueDetailView.js

@@ -35,10 +35,76 @@ function planStepColor(status) {
         return "yellow";
     return "white";
 }
-export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, tokenUsage, diffSummary, plan, }) {
+// ─── Compact Issue Sidebar (#4 split-pane) ───────────────────────
+const SIDEBAR_STATE_COLORS = {
+    delegated: "blue", preparing: "blue",
+    implementing: "yellow", awaiting_input: "yellow",
+    pr_open: "cyan", awaiting_review: "cyan",
+    changes_requested: "magenta", repairing_ci: "magenta", repairing_queue: "magenta",
+    awaiting_queue: "green", done: "green",
+    failed: "red", escalated: "red",
+};
+function CompactSidebar({ issues, activeKey }) {
+    return (_jsxs(Box, { flexDirection: "column", width: 28, borderStyle: "single", borderColor: "gray", paddingLeft: 1, paddingRight: 1, children: [_jsx(Text, { bold: true, dimColor: true, children: "Issues" }), issues.map((issue) => {
+                const key = issue.issueKey ?? issue.projectId;
+                const isCurrent = key === activeKey;
+                const stateColor = SIDEBAR_STATE_COLORS[issue.factoryState] ?? "white";
+                return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: isCurrent ? "blueBright" : "white", bold: isCurrent, children: isCurrent ? "\u25b8" : " " }), _jsx(Text, { bold: isCurrent, children: key.padEnd(10) }), _jsx(Text, { color: stateColor, children: issue.factoryState.slice(0, 12) })] }, key));
+            })] }));
+}
+// ─── Issue Context Panel (#5) ────────────────────────────────────
+const PRIORITY_LABELS = {
+    0: { label: "none", color: "" },
+    1: { label: "urgent", color: "red" },
+    2: { label: "high", color: "yellow" },
+    3: { label: "medium", color: "cyan" },
+    4: { label: "low", color: "" },
+};
+function ContextPanel({ issue, ctx }) {
+    const parts = [];
+    if (ctx.priority != null && ctx.priority > 0) {
+        const p = PRIORITY_LABELS[ctx.priority] ?? { label: String(ctx.priority), color: "" };
+        parts.push({ label: "priority", value: p.label, color: p.color });
+    }
+    if (ctx.estimate != null) {
+        parts.push({ label: "estimate", value: String(ctx.estimate), color: "" });
+    }
+    if (ctx.currentLinearState) {
+        parts.push({ label: "linear", value: ctx.currentLinearState, color: "" });
+    }
+    if (issue.prNumber) {
+        const prInfo = `#${issue.prNumber}${issue.prReviewState === "approved" ? " \u2713" : issue.prReviewState === "changes_requested" ? " \u2717" : ""}${issue.prCheckStatus ? ` ci:${issue.prCheckStatus}` : ""}`;
+        const prColor = issue.prReviewState === "approved" ? "green" : issue.prReviewState === "changes_requested" ? "red" : "";
+        parts.push({ label: "pr", value: prInfo, color: prColor });
+    }
+    if (ctx.runCount > 0) {
+        parts.push({ label: "runs", value: String(ctx.runCount), color: "" });
+    }
+    const retries = [
+        ctx.ciRepairAttempts > 0 ? `ci:${ctx.ciRepairAttempts}` : "",
+        ctx.queueRepairAttempts > 0 ? `queue:${ctx.queueRepairAttempts}` : "",
+        ctx.reviewFixAttempts > 0 ? `review:${ctx.reviewFixAttempts}` : "",
+    ].filter(Boolean).join(" ");
+    if (retries) {
+        parts.push({ label: "retries", value: retries, color: "yellow" });
+    }
+    if (ctx.branchName) {
+        parts.push({ label: "branch", value: ctx.branchName, color: "" });
+    }
+    const hasDescription = Boolean(ctx.description);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { gap: 2, flexWrap: "wrap", children: parts.map((p) => (_jsxs(Text, { dimColor: true, children: [p.label, ": ", p.color ? _jsx(Text, { color: p.color, children: p.value }) : _jsx(Text, { dimColor: true, children: p.value })] }, p.label))) }), hasDescription && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [ctx.description.slice(0, 200), ctx.description.length > 200 ? "\u2026" : ""] }))] }));
+}
+// ─── Detail Panel (right side of split) ──────────────────────────
+function DetailPanel({ issue, timeline, follow, activeRunStartedAt, tokenUsage, diffSummary, plan, issueContext, }) {
     if (!issue) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
+        return _jsx(Text, { color: "red", children: "Issue not found." });
     }
     const key = issue.issueKey ?? issue.projectId;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["PR #", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt })] }), issue.title && _jsx(Text, { dimColor: true, children: issue.title }), _jsxs(Box, { gap: 2, children: [tokenUsage && (_jsxs(Text, { dimColor: true, children: ["tokens: ", formatTokens(tokenUsage.inputTokens), " in / ", formatTokens(tokenUsage.outputTokens), " out"] })), diffSummary && diffSummary.filesChanged > 0 && (_jsxs(Text, { dimColor: true, children: ["diff: ", diffSummary.filesChanged, " file", diffSummary.filesChanged !== 1 ? "s" : "", " ", "+", diffSummary.linesAdded, " -", diffSummary.linesRemoved] })), follow && _jsx(Text, { color: "yellow", children: "follow" })] }), plan && plan.length > 0 && (_jsx(Box, { flexDirection: "column", children: plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`))) })), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(Timeline, { entries: timeline, follow: follow }), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
+    return (_jsxs(Box, { flexDirection: "column", flexGrow: 1, children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["PR #", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt })] }), issue.title && _jsx(Text, { dimColor: true, children: issue.title }), _jsxs(Box, { gap: 2, children: [tokenUsage && (_jsxs(Text, { dimColor: true, children: ["tokens: ", formatTokens(tokenUsage.inputTokens), " in / ", formatTokens(tokenUsage.outputTokens), " out"] })), diffSummary && diffSummary.filesChanged > 0 && (_jsxs(Text, { dimColor: true, children: ["diff: ", diffSummary.filesChanged, " file", diffSummary.filesChanged !== 1 ? "s" : "", " ", "+", diffSummary.linesAdded, " -", diffSummary.linesRemoved] })), follow && _jsx(Text, { color: "yellow", children: "follow" })] }), issueContext && _jsx(ContextPanel, { issue: issue, ctx: issueContext }), plan && plan.length > 0 && (_jsx(Box, { flexDirection: "column", children: plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`))) })), _jsx(Text, { dimColor: true, children: "\u2500".repeat(60) }), _jsx(Timeline, { entries: timeline, follow: follow })] }));
+}
+// ─── Main Detail View (split layout) ─────────────────────────────
+export function IssueDetailView(props) {
+    const { allIssues, activeDetailKey, follow, ...detailProps } = props;
+    const showSidebar = allIssues.length > 1;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { flexDirection: "row", flexGrow: 1, children: [showSidebar && _jsx(CompactSidebar, { issues: allIssues, activeKey: activeDetailKey }), _jsx(DetailPanel, { ...detailProps, follow: follow })] }), _jsx(Text, { dimColor: true, children: "\u2500".repeat(72) }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
 }

package/dist/cli/watch/IssueListView.js

@@ -3,6 +3,6 @@ import { Box, Text } from "ink";
 import { IssueRow } from "./IssueRow.js";
 import { StatusBar } from "./StatusBar.js";
 import { HelpBar } from "./HelpBar.js";
-export function IssueListView({ issues, selectedIndex, connected, filter, totalCount }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { issues: issues, totalCount: totalCount, filter: filter, connected: connected }), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No issues match the current filter." })) : (_jsx(Box, { flexDirection: "column", children: issues.map((issue, index) => (_jsx(IssueRow, { issue: issue, selected: index === selectedIndex }, issue.issueKey ?? `${issue.projectId}-${index}`))) })), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(HelpBar, { view: "list" })] }));
+export function IssueListView({ issues, allIssues, selectedIndex, connected, filter, totalCount }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { issues: issues, totalCount: totalCount, filter: filter, connected: connected, allIssues: allIssues }), _jsx(Text, { dimColor: true, children: "\u2500".repeat(72) }), issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No issues match the current filter." })) : (_jsx(Box, { flexDirection: "column", children: issues.map((issue, index) => (_jsx(IssueRow, { issue: issue, selected: index === selectedIndex }, issue.issueKey ?? `${issue.projectId}-${index}`))) })), _jsx(Text, { dimColor: true, children: "\u2500".repeat(72) }), _jsx(HelpBar, { view: "list" })] }));
 }

package/dist/cli/watch/IssueRow.js

@@ -5,7 +5,6 @@ const STATE_COLORS = {
     preparing: "blue",
     implementing: "yellow",
     pr_open: "cyan",
-    awaiting_review: "cyan",
     changes_requested: "magenta",
     repairing_ci: "magenta",
     awaiting_queue: "green",

package/dist/cli/watch/StatusBar.js

@@ -1,11 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
+import { computeAggregates } from "./watch-state.js";
 const FILTER_LABELS = {
     "all": "all",
     "active": "active",
     "non-done": "in progress",
 };
-export function StatusBar({ issues, totalCount, filter, connected }) {
+export function StatusBar({ issues, totalCount, filter, connected, allIssues }) {
     const showing = filter === "all" ? `${totalCount} issues` : `${issues.length}/${totalCount} issues`;
-    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: showing }), _jsxs(Text, { dimColor: true, children: [" [", FILTER_LABELS[filter], "]"] })] }), _jsx(Text, { color: connected ? "green" : "red", children: connected ? "\u25cf connected" : "\u25cb disconnected" })] }));
+    const agg = computeAggregates(allIssues);
+    return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { bold: true, children: showing }), _jsxs(Text, { dimColor: true, children: ["[", FILTER_LABELS[filter], "]"] }), _jsx(Text, { dimColor: true, children: "|" }), agg.active > 0 && _jsxs(Text, { color: "yellow", children: [agg.active, " active"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] })] }), _jsx(Text, { color: connected ? "green" : "red", children: connected ? "\u25cf connected" : "\u25cb disconnected" })] }));
 }

package/dist/cli/watch/use-detail-stream.js

@@ -38,12 +38,31 @@ async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
             threadId: r.threadId,
             ...(r.report ? { report: r.report } : {}),
         }));
+        let issueContext = null;
+        if (data.issue) {
+            const i = data.issue;
+            issueContext = {
+                description: typeof i.description === "string" ? i.description : undefined,
+                currentLinearState: typeof i.currentLinearState === "string" ? i.currentLinearState : undefined,
+                issueUrl: typeof i.issueUrl === "string" ? i.issueUrl : undefined,
+                worktreePath: typeof i.worktreePath === "string" ? i.worktreePath : undefined,
+                branchName: typeof i.branchName === "string" ? i.branchName : undefined,
+                prUrl: typeof i.prUrl === "string" ? i.prUrl : undefined,
+                priority: typeof i.priority === "number" ? i.priority : undefined,
+                estimate: typeof i.estimate === "number" ? i.estimate : undefined,
+                ciRepairAttempts: typeof i.ciRepairAttempts === "number" ? i.ciRepairAttempts : 0,
+                queueRepairAttempts: typeof i.queueRepairAttempts === "number" ? i.queueRepairAttempts : 0,
+                reviewFixAttempts: typeof i.reviewFixAttempts === "number" ? i.reviewFixAttempts : 0,
+                runCount: runs.length,
+            };
+        }
         dispatch({
             type: "timeline-rehydrate",
             runs,
             feedEvents: data.feedEvents ?? [],
             liveThread: data.liveThread ?? null,
             activeRunId: data.activeRunId ?? null,
+            issueContext,
         });
     }
     catch {

package/dist/cli/watch/use-feed-stream.js

@@ -0,0 +1,92 @@
+import { useEffect, useRef } from "react";
+export function useFeedStream(options) {
+    const optionsRef = useRef(options);
+    optionsRef.current = options;
+    useEffect(() => {
+        if (!options.active)
+            return;
+        const abortController = new AbortController();
+        const { baseUrl, bearerToken, dispatch } = optionsRef.current;
+        void (async () => {
+            try {
+                const url = new URL("/api/feed", baseUrl);
+                url.searchParams.set("follow", "1");
+                url.searchParams.set("limit", "100");
+                const headers = { accept: "text/event-stream" };
+                if (bearerToken)
+                    headers.authorization = `Bearer ${bearerToken}`;
+                const response = await fetch(url, { headers, signal: abortController.signal });
+                if (!response.ok || !response.body)
+                    return;
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                let eventType = "";
+                let dataLines = [];
+                let initialBatch = [];
+                let snapshotSent = false;
+                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 && eventType === "feed") {
+                                try {
+                                    const event = JSON.parse(dataLines.join("\n"));
+                                    if (!snapshotSent) {
+                                        initialBatch.push(event);
+                                    }
+                                    else {
+                                        dispatch({ type: "feed-new-event", event });
+                                    }
+                                }
+                                catch { /* ignore parse errors */ }
+                                dataLines = [];
+                                eventType = "";
+                            }
+                            // After processing a batch of initial events, flush snapshot
+                            if (!snapshotSent && initialBatch.length > 0) {
+                                // Use a microtask to batch initial events
+                                const batch = initialBatch;
+                                initialBatch = [];
+                                snapshotSent = true;
+                                dispatch({ type: "feed-snapshot", events: batch });
+                            }
+                            newlineIndex = buffer.indexOf("\n");
+                            continue;
+                        }
+                        if (line.startsWith(":")) {
+                            // Keepalive or comment - flush initial batch if pending
+                            if (!snapshotSent && initialBatch.length > 0) {
+                                snapshotSent = true;
+                                dispatch({ type: "feed-snapshot", events: initialBatch });
+                                initialBatch = [];
+                            }
+                            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");
+                    }
+                }
+            }
+            catch {
+                // Stream ended or aborted
+            }
+        })();
+        return () => {
+            abortController.abort();
+        };
+    }, [options.active]);
+}

package/dist/cli/watch/watch-state.js

@@ -6,6 +6,7 @@ const DETAIL_INITIAL = {
     tokenUsage: null,
     diffSummary: null,
     plan: null,
+    issueContext: null,
 };
 export const initialWatchState = {
     connected: false,
@@ -16,6 +17,7 @@ export const initialWatchState = {
     filter: "non-done",
     follow: true,
     ...DETAIL_INITIAL,
+    feedEvents: [],
 };
 const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
 export function filterIssues(issues, filter) {
@@ -28,6 +30,22 @@ export function filterIssues(issues, filter) {
             return issues.filter((i) => !TERMINAL_FACTORY_STATES.has(i.factoryState));
     }
 }
+const DONE_STATES = new Set(["done"]);
+const FAILED_STATES = new Set(["failed", "escalated"]);
+export function computeAggregates(issues) {
+    let active = 0;
+    let done = 0;
+    let failed = 0;
+    for (const issue of issues) {
+        if (issue.activeRunType)
+            active++;
+        if (DONE_STATES.has(issue.factoryState))
+            done++;
+        if (FAILED_STATES.has(issue.factoryState))
+            failed++;
+    }
+    return { active, done, failed, total: issues.length };
+}
 function nextFilter(filter) {
     switch (filter) {
         case "non-done": return "active";
@@ -59,6 +77,19 @@ export function watchReducer(state, action) {
             return { ...state, view: "detail", activeDetailKey: action.issueKey, ...DETAIL_INITIAL };
         case "exit-detail":
             return { ...state, view: "list", activeDetailKey: null, ...DETAIL_INITIAL };
+        case "detail-navigate": {
+            const list = action.filtered;
+            if (list.length === 0)
+                return state;
+            const curIdx = list.findIndex((i) => i.issueKey === state.activeDetailKey);
+            const nextIdx = action.direction === "next"
+                ? (curIdx + 1) % list.length
+                : (curIdx - 1 + list.length) % list.length;
+            const nextIssue = list[nextIdx];
+            if (!nextIssue?.issueKey || nextIssue.issueKey === state.activeDetailKey)
+                return state;
+            return { ...state, activeDetailKey: nextIssue.issueKey, selectedIndex: nextIdx, ...DETAIL_INITIAL };
+        }
         case "timeline-rehydrate": {
             const timeline = buildTimelineFromRehydration(action.runs, action.feedEvents, action.liveThread, action.activeRunId);
             const activeRun = action.runs.find((r) => r.id === action.activeRunId);
@@ -67,6 +98,7 @@ export function watchReducer(state, action) {
                 timeline,
                 activeRunId: action.activeRunId,
                 activeRunStartedAt: activeRun?.startedAt ?? null,
+                issueContext: action.issueContext,
             };
         }
         case "codex-notification":
@@ -75,6 +107,14 @@ export function watchReducer(state, action) {
             return { ...state, filter: nextFilter(state.filter), selectedIndex: 0 };
         case "toggle-follow":
             return { ...state, follow: !state.follow };
+        case "enter-feed":
+            return { ...state, view: "feed", activeDetailKey: null, ...DETAIL_INITIAL };
+        case "exit-feed":
+            return { ...state, view: "list" };
+        case "feed-snapshot":
+            return { ...state, feedEvents: action.events };
+        case "feed-new-event":
+            return { ...state, feedEvents: [...state.feedEvents, action.event] };
     }
 }
 // ─── Feed Event → Issue List + Timeline ───────────────────────────

package/dist/db/migrations.js

@@ -133,6 +133,14 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "pending_merge_prep", "INTEGER NOT NULL DEFAULT 0");
     // Add merge_prep_attempts for retry budget / escalation
     addColumnIfMissing(connection, "issues", "merge_prep_attempts", "INTEGER NOT NULL DEFAULT 0");
+    // Add review_fix_attempts counter
+    addColumnIfMissing(connection, "issues", "review_fix_attempts", "INTEGER NOT NULL DEFAULT 0");
+    // Collapse awaiting_review into pr_open (state normalization)
+    connection.prepare("UPDATE issues SET factory_state = 'pr_open' WHERE factory_state = 'awaiting_review'").run();
+    // Add Linear issue description, priority, estimate
+    addColumnIfMissing(connection, "issues", "description", "TEXT");
+    addColumnIfMissing(connection, "issues", "priority", "INTEGER");
+    addColumnIfMissing(connection, "issues", "estimate", "REAL");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -81,10 +81,22 @@ export class PatchRelayDatabase {
                 sets.push("title = COALESCE(@title, title)");
                 values.title = params.title;
             }
+            if (params.description !== undefined) {
+                sets.push("description = COALESCE(@description, description)");
+                values.description = params.description;
+            }
             if (params.url !== undefined) {
                 sets.push("url = COALESCE(@url, url)");
                 values.url = params.url;
             }
+            if (params.priority !== undefined) {
+                sets.push("priority = @priority");
+                values.priority = params.priority;
+            }
+            if (params.estimate !== undefined) {
+                sets.push("estimate = @estimate");
+                values.estimate = params.estimate;
+            }
             if (params.currentLinearState !== undefined) {
                 sets.push("current_linear_state = COALESCE(@currentLinearState, current_linear_state)");
                 values.currentLinearState = params.currentLinearState;
@@ -149,6 +161,10 @@ export class PatchRelayDatabase {
                 sets.push("queue_repair_attempts = @queueRepairAttempts");
                 values.queueRepairAttempts = params.queueRepairAttempts;
             }
+            if (params.reviewFixAttempts !== undefined) {
+                sets.push("review_fix_attempts = @reviewFixAttempts");
+                values.reviewFixAttempts = params.reviewFixAttempts;
+            }
             if (params.mergePrepAttempts !== undefined) {
                 sets.push("merge_prep_attempts = @mergePrepAttempts");
                 values.mergePrepAttempts = params.mergePrepAttempts;
@@ -162,13 +178,15 @@ export class PatchRelayDatabase {
         else {
             this.connection.prepare(`
         INSERT INTO issues (
-          project_id, linear_issue_id, issue_key, title, url,
+          project_id, linear_issue_id, issue_key, title, description, url,
+          priority, estimate,
           current_linear_state, factory_state, pending_run_type, pending_run_context_json,
           branch_name, worktree_path, thread_id, active_run_id,
           agent_session_id,
           updated_at
         ) VALUES (
-          @projectId, @linearIssueId, @issueKey, @title, @url,
+          @projectId, @linearIssueId, @issueKey, @title, @description, @url,
+          @priority, @estimate,
           @currentLinearState, @factoryState, @pendingRunType, @pendingRunContextJson,
           @branchName, @worktreePath, @threadId, @activeRunId,
           @agentSessionId,
@@ -179,7 +197,10 @@ export class PatchRelayDatabase {
                 linearIssueId: params.linearIssueId,
                 issueKey: params.issueKey ?? null,
                 title: params.title ?? null,
+                description: params.description ?? null,
                 url: params.url ?? null,
+                priority: params.priority ?? null,
+                estimate: params.estimate ?? null,
                 currentLinearState: params.currentLinearState ?? null,
                 factoryState: params.factoryState ?? "delegated",
                 pendingRunType: params.pendingRunType ?? null,
@@ -371,7 +392,10 @@ function mapIssueRow(row) {
         linearIssueId: String(row.linear_issue_id),
         ...(row.issue_key !== null ? { issueKey: String(row.issue_key) } : {}),
         ...(row.title !== null ? { title: String(row.title) } : {}),
+        ...(row.description !== null && row.description !== undefined ? { description: String(row.description) } : {}),
         ...(row.url !== null ? { url: String(row.url) } : {}),
+        ...(row.priority !== null && row.priority !== undefined ? { priority: Number(row.priority) } : {}),
+        ...(row.estimate !== null && row.estimate !== undefined ? { estimate: Number(row.estimate) } : {}),
         ...(row.current_linear_state !== null ? { currentLinearState: String(row.current_linear_state) } : {}),
         factoryState: String(row.factory_state ?? "delegated"),
         ...(row.pending_run_type !== null && row.pending_run_type !== undefined ? { pendingRunType: String(row.pending_run_type) } : {}),
@@ -389,6 +413,7 @@ function mapIssueRow(row) {
         ...(row.pr_check_status !== null && row.pr_check_status !== undefined ? { prCheckStatus: String(row.pr_check_status) } : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
+        reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         mergePrepAttempts: Number(row.merge_prep_attempts ?? 0),
         pendingMergePrep: Boolean(row.pending_merge_prep),
     };

package/dist/factory-state.js

@@ -5,10 +5,12 @@ export const ACTIVE_RUN_STATES = new Set([
     "changes_requested",
     "repairing_queue",
 ]);
-/** Which factory states are terminal (no further transitions possible). */
+/** Which factory states are terminal (no further transitions possible except pr_merged → done). */
 export const TERMINAL_STATES = new Set([
     "done",
     "escalated",
+    "failed",
+    "awaiting_input",
 ]);
 // ─── Semantic guards ─────────────────────────────────────────────
 //

package/dist/github-webhook-handler.js

@@ -158,8 +158,11 @@ export class GitHubWebhookHandler {
                 }
             }
         }
-        // Reset repair counters on new push
-        if (event.triggerEvent === "pr_synchronize") {
+        // Re-read issue after all upserts so reactive run logic sees current state
+        const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        // Reset repair counters on new push — but only when no repair run is active,
+        // since Codex pushes during repair and resetting mid-run would bypass budgets.
+        if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
             this.db.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -167,8 +170,6 @@ export class GitHubWebhookHandler {
                 queueRepairAttempts: 0,
             });
         }
-        // Re-read issue after all upserts so reactive run logic sees current state
-        const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
         this.feed?.publish({
             level: event.triggerEvent.includes("failed") ? "warn" : "info",

package/dist/issue-query-service.js

@@ -79,7 +79,24 @@ export class IssueQueryService {
         if (activeRun?.threadId) {
             liveThread = await this.codex.readThread(activeRun.threadId, true).catch(() => undefined);
         }
-        return { issue, runs, feedEvents, liveThread, activeRunId };
+        return {
+            issue: {
+                ...issue,
+                ...(fullIssue?.description ? { description: fullIssue.description } : {}),
+                ...(fullIssue?.branchName ? { branchName: fullIssue.branchName } : {}),
+                ...(fullIssue?.worktreePath ? { worktreePath: fullIssue.worktreePath } : {}),
+                ...(fullIssue?.prUrl ? { prUrl: fullIssue.prUrl } : {}),
+                ...(fullIssue?.priority != null ? { priority: fullIssue.priority } : {}),
+                ...(fullIssue?.estimate != null ? { estimate: fullIssue.estimate } : {}),
+                ciRepairAttempts: fullIssue?.ciRepairAttempts ?? 0,
+                queueRepairAttempts: fullIssue?.queueRepairAttempts ?? 0,
+                reviewFixAttempts: fullIssue?.reviewFixAttempts ?? 0,
+            },
+            runs,
+            feedEvents,
+            liveThread,
+            activeRunId,
+        };
     }
     async getActiveRunStatus(issueKey) {
         return await this.runStatusProvider.getActiveRunStatus(issueKey);

package/dist/linear-client.js

@@ -14,7 +14,10 @@ export class LinearGraphqlClient {
           id
           identifier
           title
+          description
           url
+          priority
+          estimate
           delegate {
             id
             name
@@ -68,7 +71,10 @@ export class LinearGraphqlClient {
             id
             identifier
             title
+            description
             url
+            priority
+            estimate
             delegate {
               id
               name
@@ -205,7 +211,10 @@ export class LinearGraphqlClient {
             id
             identifier
             title
+            description
             url
+            priority
+            estimate
             state {
               id
               name
@@ -293,7 +302,10 @@ export class LinearGraphqlClient {
             id: issue.id,
             ...(issue.identifier ? { identifier: issue.identifier } : {}),
             ...(issue.title ? { title: issue.title } : {}),
+            ...(issue.description ? { description: issue.description } : {}),
             ...(issue.url ? { url: issue.url } : {}),
+            ...(issue.priority != null ? { priority: issue.priority } : {}),
+            ...(issue.estimate != null ? { estimate: issue.estimate } : {}),
             ...(issue.state?.id ? { stateId: issue.state.id } : {}),
             ...(issue.state?.name ? { stateName: issue.state.name } : {}),
             ...(issue.team?.id ? { teamId: issue.team.id } : {}),

package/dist/linear-session-reporting.js

@@ -13,7 +13,6 @@ function describeNextState(state, prNumber) {
     const prLabel = prNumber ? `PR #${prNumber}` : "the pull request";
     switch (state) {
         case "pr_open":
-        case "awaiting_review":
             return `${prLabel} is ready for review.`;
         case "awaiting_queue":
             return `${prLabel} is approved and back in the merge flow.`;
@@ -149,7 +148,6 @@ export function buildMergePrepEscalationActivity(attempts) {
 }
 export function summarizeIssueStateForLinear(issue) {
     switch (issue.factoryState) {
-        case "awaiting_review":
         case "pr_open":
             return issue.prNumber ? `PR #${issue.prNumber} is awaiting review.` : "Awaiting review.";
         case "awaiting_queue":

package/dist/merge-queue.js

@@ -103,7 +103,6 @@ export class MergeQueue {
                 pendingRunType: "queue_repair",
                 pendingRunContextJson: JSON.stringify({ failureReason: "merge_conflict" }),
                 pendingMergePrep: false,
-                mergePrepAttempts: 0,
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
             this.feed?.publish({

package/dist/run-orchestrator.js

@@ -9,8 +9,9 @@ import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
 import { WorktreeManager } from "./worktree-manager.js";
 import { resolveAuthoritativeLinearStopState } from "./linear-workflow.js";
 import { execCommand } from "./utils.js";
-const DEFAULT_CI_REPAIR_BUDGET = 2;
-const DEFAULT_QUEUE_REPAIR_BUDGET = 2;
+const DEFAULT_CI_REPAIR_BUDGET = 3;
+const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
+const DEFAULT_REVIEW_FIX_BUDGET = 3;
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -114,6 +115,10 @@ export class RunOrchestrator {
             this.escalate(issue, runType, `Queue repair budget exhausted (${DEFAULT_QUEUE_REPAIR_BUDGET} attempts)`);
             return;
         }
+        if (runType === "review_fix" && issue.reviewFixAttempts >= DEFAULT_REVIEW_FIX_BUDGET) {
+            this.escalate(issue, runType, `Review fix budget exhausted (${DEFAULT_REVIEW_FIX_BUDGET} attempts)`);
+            return;
+        }
         // Increment repair counters
         if (runType === "ci_repair") {
             this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, ciRepairAttempts: issue.ciRepairAttempts + 1 });
@@ -121,6 +126,9 @@ export class RunOrchestrator {
         if (runType === "queue_repair") {
             this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, queueRepairAttempts: issue.queueRepairAttempts + 1 });
         }
+        if (runType === "review_fix") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, reviewFixAttempts: issue.reviewFixAttempts + 1 });
+        }
         // Build prompt
         const prompt = buildRunPrompt(issue, runType, project.repoPath, context);
         // Resolve workspace
@@ -296,22 +304,9 @@ export class RunOrchestrator {
         // Complete the run
         const trackedIssue = this.db.issueToTrackedIssue(issue);
         const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
-        // Determine post-run state. When a re-run finds the PR already exists
-        // and makes no changes, no pr_opened webhook arrives — the state would
-        // stay in the active-run state forever. Advance based on PR metadata.
+        // Determine post-run state based on current PR metadata.
         const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
-        let postRunState;
-        if (ACTIVE_RUN_STATES.has(freshIssue.factoryState) && freshIssue.prNumber) {
-            if (freshIssue.prReviewState === "approved") {
-                postRunState = "awaiting_queue";
-            }
-            else if (freshIssue.prState === "merged") {
-                postRunState = "done";
-            }
-            else {
-                postRunState = "awaiting_review";
-            }
-        }
+        const postRunState = resolvePostRunState(freshIssue);
         this.db.transaction(() => {
             this.db.finishRun(run.id, {
                 status: "completed",
@@ -544,6 +539,8 @@ export class RunOrchestrator {
         if (latestTurn?.status === "completed") {
             const trackedIssue = this.db.issueToTrackedIssue(issue);
             const report = buildStageReport(run, trackedIssue, thread, countEventMethods(this.db.listThreadEvents(run.id)));
+            const freshIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
+            const postRunState = resolvePostRunState(freshIssue);
             this.db.transaction(() => {
                 this.db.finishRun(run.id, {
                     status: "completed",
@@ -556,8 +553,13 @@ export class RunOrchestrator {
                     projectId: run.projectId,
                     linearIssueId: run.linearIssueId,
                     activeRunId: null,
+                    ...(postRunState ? { factoryState: postRunState } : {}),
+                    ...(postRunState === "awaiting_queue" ? { pendingMergePrep: true } : {}),
                 });
             });
+            if (postRunState === "awaiting_queue") {
+                this.enqueueIssue(run.projectId, run.linearIssueId);
+            }
         }
     }
     // ─── Internal helpers ─────────────────────────────────────────────
@@ -660,3 +662,17 @@ export class RunOrchestrator {
         throw new Error(`Failed to read thread ${threadId}`);
     }
 }
+/**
+ * Determine post-run factory state from current PR metadata.
+ * Used by both the normal completion path and reconciliation.
+ */
+function resolvePostRunState(issue) {
+    if (ACTIVE_RUN_STATES.has(issue.factoryState) && issue.prNumber) {
+        if (issue.prReviewState === "approved")
+            return "awaiting_queue";
+        if (issue.prState === "merged")
+            return "done";
+        return "pr_open";
+    }
+    return undefined;
+}

package/dist/webhook-handler.js

@@ -155,7 +155,10 @@ export class WebhookHandler {
             linearIssueId: normalizedIssue.id,
             ...(normalizedIssue.identifier ? { issueKey: normalizedIssue.identifier } : {}),
             ...(normalizedIssue.title ? { title: normalizedIssue.title } : {}),
+            ...(normalizedIssue.description ? { description: normalizedIssue.description } : {}),
             ...(normalizedIssue.url ? { url: normalizedIssue.url } : {}),
+            ...(normalizedIssue.priority != null ? { priority: normalizedIssue.priority } : {}),
+            ...(normalizedIssue.estimate != null ? { estimate: normalizedIssue.estimate } : {}),
             ...(normalizedIssue.stateName ? { currentLinearState: normalizedIssue.stateName } : {}),
             ...(pendingRunType ? { pendingRunType, factoryState: "delegated" } : {}),
             ...((pendingRunType || existingIssue?.pendingRunType === "implementation") && pendingRunContextJson

package/dist/webhooks.js

@@ -207,10 +207,16 @@ function extractIssueMetadata(payload) {
     const stateType = getString(stateRecord ?? {}, "type");
     const delegateId = getString(issueRecord, "delegateId") ?? getString(delegateRecord ?? {}, "id");
     const delegateName = getString(delegateRecord ?? {}, "name");
+    const description = getString(issueRecord, "description");
+    const rawPriority = issueRecord.priority;
+    const priority = typeof rawPriority === "number" ? rawPriority : undefined;
+    const rawEstimate = issueRecord.estimate;
+    const estimate = typeof rawEstimate === "number" ? rawEstimate : undefined;
     return {
         id,
         ...(identifier ? { identifier } : {}),
         ...(title ? { title } : {}),
+        ...(description ? { description } : {}),
         ...(url ? { url } : {}),
         ...(teamId ? { teamId } : {}),
         ...(teamKey ? { teamKey } : {}),
@@ -219,6 +225,8 @@ function extractIssueMetadata(payload) {
         ...(stateType ? { stateType } : {}),
         ...(delegateId ? { delegateId } : {}),
         ...(delegateName ? { delegateName } : {}),
+        ...(priority != null ? { priority } : {}),
+        ...(estimate != null ? { estimate } : {}),
         labelNames: extractLabelNames(issueRecord),
     };
 }

package/package.json

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