patchrelay 0.17.1 → 0.19.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.17.1",
-  "commit": "ff6a8d2fcbef",
-  "builtAt": "2026-03-25T14:45:25.511Z"
+  "version": "0.19.0",
+  "commit": "0172365b885d",
+  "builtAt": "2026-03-25T20:06:12.646Z"
 }

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/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/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/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/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/migrations.js

@@ -137,6 +137,10 @@ export function runPatchRelayMigrations(connection) {
     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;
@@ -166,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,
@@ -183,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,
@@ -229,9 +246,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);
     }
@@ -375,7 +396,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) } : {}),

package/dist/github-webhook-handler.js

@@ -182,10 +182,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 +198,7 @@ export class GitHubWebhookHandler {
                 pendingRunContextJson: JSON.stringify({
                     checkName: event.checkName,
                     checkUrl: event.checkUrl,
+                    checkClass: resolveCheckClass(event.checkName, project),
                 }),
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
@@ -281,3 +283,12 @@ export class GitHubWebhookHandler {
         }
     }
 }
+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/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/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/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.1",
+  "version": "0.19.0",
   "license": "MIT",
   "type": "module",
   "repository": {