patchrelay 0.42.0 → 0.44.0

package/config/patchrelay.example.json

@@ -1,5 +1,12 @@
 {
   "server": {
     "public_base_url": "https://patchrelay.example.com"
+  },
+  "runner": {
+    "git_bin": "git",
+    "codex": {
+      "model": "gpt-5.3-codex-spark",
+      "reasoning_effort": "high"
+    }
   }
 }

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.42.0",
-  "commit": "ad4fbfa6efc4",
-  "builtAt": "2026-04-14T14:44:46.179Z"
+  "version": "0.44.0",
+  "commit": "969e4e3e58e7",
+  "builtAt": "2026-04-16T14:04:18.962Z"
 }

package/dist/cli/watch/App.js

@@ -73,6 +73,7 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
     const filtered = useMemo(() => filterIssues(state.issues, state.filter), [state.issues, state.filter]);
     const [frozen, setFrozen] = useState(false);
     const width = Math.max(20, stdout?.columns ?? 80);
+    const compact = width < 90;
     useWatchStream({ baseUrl, bearerToken, dispatch, active: !frozen });
     useDetailStream({ baseUrl, bearerToken, issueKey: state.activeDetailKey, dispatch, active: !frozen });
     const [promptMode, setPromptMode] = useState(false);
@@ -400,7 +401,7 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
         : promptStatus
             ? measureRenderedTextRows(promptStatus, width)
             : 0);
-    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt, filter: state.filter, totalCount: state.issues.length, frozen: frozen })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [state.activeDetailKey && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Issues" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { bold: true, children: state.activeDetailKey }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { dimColor: true, children: state.detailTab === "timeline" ? "Timeline" : "History" })] })), _jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, scrollOffset: state.detailScrollOffset, unreadBelow: state.detailUnreadBelow, activeRunStartedAt: state.activeRunStartedAt, activeRunId: state.activeRunId, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, detailTab: state.detailTab, rawRuns: state.rawRuns, rawFeedEvents: state.rawFeedEvents, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt, reservedRows: reservedRows, onLayoutChange: (viewportRows, contentRows) => {
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt, filter: state.filter, totalCount: state.issues.length, frozen: frozen, compact: compact })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [state.activeDetailKey && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "Issues" }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { bold: true, children: state.activeDetailKey }), _jsx(Text, { dimColor: true, children: " \u203A " }), _jsx(Text, { dimColor: true, children: state.detailTab === "timeline" ? "Timeline" : "History" })] })), _jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, scrollOffset: state.detailScrollOffset, unreadBelow: state.detailUnreadBelow, activeRunStartedAt: state.activeRunStartedAt, activeRunId: state.activeRunId, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, detailTab: state.detailTab, rawRuns: state.rawRuns, rawFeedEvents: state.rawFeedEvents, connected: state.connected, lastServerMessageAt: state.lastServerMessageAt, compact: compact, reservedRows: reservedRows, onLayoutChange: (viewportRows, contentRows) => {
                         dispatch({ type: "detail-layout-updated", viewportRows, contentRows });
                     } }), promptMode && (_jsx(PromptComposer, { buffer: promptBuffer, cursor: promptCursor })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : null }));
 }

package/dist/cli/watch/HelpBar.js

@@ -1,8 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-export function buildHelpBarText(view, follow, detailTab) {
+export function buildHelpBarText(view, follow, detailTab, compact = false) {
     if (view === "detail") {
         const tabHint = detailTab === "history" ? "t: timeline" : "h: history";
+        if (compact) {
+            return "j/k: scroll  f: live  p: prompt  y/c/o: copy  r: retry  s: stop  esc: list  q: quit";
+        }
         return [
             tabHint,
             "j/k: scroll",
@@ -19,9 +22,12 @@ export function buildHelpBarText(view, follow, detailTab) {
             .filter(Boolean)
             .join("  ");
     }
+    if (compact) {
+        return "Enter: detail  Tab: filter  x: pause  q: quit";
+    }
     return "Enter: detail  Tab: filter";
 }
-export function HelpBar({ view, follow, detailTab }) {
-    const text = buildHelpBarText(view, follow, detailTab);
+export function HelpBar({ view, follow, detailTab, compact = false }) {
+    const text = buildHelpBarText(view, follow, detailTab, compact);
     return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/cli/watch/IssueDetailView.js

@@ -5,7 +5,7 @@ import { HelpBar, buildHelpBarText } from "./HelpBar.js";
 import { buildDetailLines } from "./detail-rows.js";
 import { buildDetailStatusSegments, buildDetailStatusText } from "./detail-status.js";
 import { measureRenderedTextRows } from "./layout-measure.js";
-export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadBelow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, rawRuns, rawFeedEvents, connected, lastServerMessageAt, reservedRows = 0, onLayoutChange, }) {
+export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadBelow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, rawRuns, rawFeedEvents, connected, lastServerMessageAt, reservedRows = 0, compact = false, onLayoutChange, }) {
     const { stdout } = useStdout();
     const width = Math.max(20, stdout?.columns ?? 80);
     const totalRows = stdout?.rows ?? 24;
@@ -17,9 +17,9 @@ export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadB
             connected,
             lastServerMessageAt,
         }), width);
-        const helpRows = measureRenderedTextRows(buildHelpBarText("detail", follow, detailTab), width);
+        const helpRows = measureRenderedTextRows(buildHelpBarText("detail", follow, detailTab, compact), width);
         return statusRows + helpRows;
-    }, [activeRunStartedAt, connected, detailTab, follow, lastServerMessageAt, unreadBelow, width]);
+    }, [activeRunStartedAt, connected, detailTab, follow, lastServerMessageAt, unreadBelow, width, compact]);
     const viewportRows = Math.max(4, totalRows - reservedRows - footerRows);
     const lines = useMemo(() => {
         if (!issue) {
@@ -60,7 +60,7 @@ export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadB
     const start = Math.min(scrollOffset, maxOffset);
     const visibleLines = lines.slice(start, start + viewportRows);
     const fillerCount = Math.max(0, viewportRows - visibleLines.length);
-    return (_jsxs(Box, { flexDirection: "column", children: [visibleLines.map((line) => (_jsx(RenderedLine, { line: line }, line.key))), Array.from({ length: fillerCount }, (_, index) => (_jsx(Text, { children: " " }, `detail-fill-${index}`))), _jsx(DetailStatusStrip, { follow: follow, unreadBelow: unreadBelow, activeRunStartedAt: activeRunStartedAt, connected: connected, lastServerMessageAt: lastServerMessageAt }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [visibleLines.map((line) => (_jsx(RenderedLine, { line: line }, line.key))), Array.from({ length: fillerCount }, (_, index) => (_jsx(Text, { children: " " }, `detail-fill-${index}`))), _jsx(DetailStatusStrip, { follow: follow, unreadBelow: unreadBelow, activeRunStartedAt: activeRunStartedAt, connected: connected, lastServerMessageAt: lastServerMessageAt }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, compact: compact })] }));
 }
 function RenderedLine({ line }) {
     if (line.segments.length === 0) {

package/dist/cli/watch/IssueListView.js

@@ -1,4 +1,4 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useReducer } from "react";
 import { Box, Text, useStdout } from "ink";
 import { IssueRow, estimateIssueRowHeight } from "./IssueRow.js";
@@ -6,11 +6,11 @@ import { StatusBar } from "./StatusBar.js";
 import { HelpBar } from "./HelpBar.js";
 const FIXED_COLS = 8;
 const CHROME_ROWS = 4;
-export function computeVisibleWindow(issues, selectedIndex, maxRows, cols, titleWidth) {
+export function computeVisibleWindow(issues, selectedIndex, maxRows, cols, titleWidth, compact) {
     if (issues.length === 0)
         return { start: 0, end: 0 };
     const clampedSelected = Math.max(0, Math.min(selectedIndex, issues.length - 1));
-    const heights = issues.map((issue, index) => estimateIssueRowHeight(issue, index === clampedSelected, cols, titleWidth));
+    const heights = issues.map((issue, index) => estimateIssueRowHeight(issue, index === clampedSelected, cols, titleWidth, compact));
     let start = clampedSelected;
     let end = clampedSelected + 1;
     let usedRows = heights[clampedSelected] ?? 1;
@@ -34,12 +34,12 @@ export function computeVisibleWindow(issues, selectedIndex, maxRows, cols, title
     }
     return { start, end };
 }
-export function IssueListView({ issues, allIssues, selectedIndex, connected, lastServerMessageAt, filter, totalCount, frozen, }) {
+export function IssueListView({ issues, allIssues, selectedIndex, connected, lastServerMessageAt, filter, totalCount, frozen, compact = false, }) {
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const rows = stdout?.rows ?? 24;
-    const titleWidth = Math.max(0, cols - FIXED_COLS);
-    const maxVisibleRows = Math.max(1, rows - CHROME_ROWS);
+    const titleWidth = Math.max(0, cols - (compact ? 24 : FIXED_COLS));
+    const maxVisibleRows = Math.max(1, rows - (compact ? 3 : CHROME_ROWS));
     // Periodic refresh for elapsed times
     const [, tick] = useReducer((c) => c + 1, 0);
     useEffect(() => {
@@ -48,9 +48,9 @@ export function IssueListView({ issues, allIssues, selectedIndex, connected, las
         const id = setInterval(tick, 5000);
         return () => clearInterval(id);
     }, [frozen]);
-    const { start: startIndex, end: endIndex } = computeVisibleWindow(issues, selectedIndex, maxVisibleRows, cols, titleWidth);
+    const { start: startIndex, end: endIndex } = computeVisibleWindow(issues, selectedIndex, maxVisibleRows, cols, titleWidth, compact);
     const visible = issues.slice(startIndex, endIndex);
     const hiddenAbove = startIndex;
     const hiddenBelow = Math.max(0, issues.length - endIndex);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { issues: issues, totalCount: totalCount, filter: filter, connected: connected, lastServerMessageAt: lastServerMessageAt, allIssues: allIssues, frozen: frozen ?? false }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No issues match the current filter." })) : (_jsxs(_Fragment, { children: [hiddenAbove > 0 && _jsxs(Text, { dimColor: true, children: ["  ", hiddenAbove, " more above"] }), visible.map((issue, i) => (_jsx(IssueRow, { issue: issue, selected: startIndex + i === selectedIndex, titleWidth: titleWidth }, issue.issueKey ?? `${issue.projectId}-${startIndex + i}`))), hiddenBelow > 0 && _jsxs(Text, { dimColor: true, children: ["  ", hiddenBelow, " more below"] })] })) }), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "list" }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { issues: issues, totalCount: totalCount, filter: filter, connected: connected, lastServerMessageAt: lastServerMessageAt, allIssues: allIssues, frozen: frozen ?? false, compact: compact }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: issues.length === 0 ? (_jsx(Text, { dimColor: true, children: "No issues match the current filter." })) : (_jsxs(_Fragment, { children: [hiddenAbove > 0 && _jsx(Text, { dimColor: true, children: compact ? `↑${hiddenAbove}` : `  ${hiddenAbove} more above` }), visible.map((issue, i) => (_jsx(IssueRow, { issue: issue, selected: startIndex + i === selectedIndex, titleWidth: titleWidth, compact: compact }, issue.issueKey ?? `${issue.projectId}-${startIndex + i}`))), hiddenBelow > 0 && _jsx(Text, { dimColor: true, children: compact ? `↓${hiddenBelow}` : `  ${hiddenBelow} more below` })] })) }), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "list", compact: compact }) })] }));
 }

package/dist/cli/watch/IssueRow.js

@@ -67,7 +67,7 @@ function stageLabel(issue) {
     }
 }
 // ─── Context facts (what matters right now) ─────────────────────
-function buildFacts(issue, selected) {
+function buildFacts(issue, selected, compact = false) {
     const facts = [];
     const rereviewNeeded = isRereviewNeeded(issue);
     // PR number
@@ -112,7 +112,7 @@ function buildFacts(issue, selected) {
     if (issue.blockedByCount > 0) {
         facts.push({ text: `waiting on ${issue.blockedByKeys.join(", ")}`, color: "yellow" });
     }
-    return facts;
+    return compact ? facts.slice(0, 3) : facts;
 }
 // ─── What's blocking progress ───────────────────────────────────
 function blockerText(issue) {
@@ -153,34 +153,40 @@ function blockerText(issue) {
     return null;
 }
 // ─── Render ─────────────────────────────────────────────────────
-export function IssueRow({ issue, selected, titleWidth }) {
+export function IssueRow({ issue, selected, titleWidth, compact = false, }) {
     const key = issue.issueKey ?? issue.projectId;
     const tw = titleWidth ?? 60;
     const title = issue.title ? truncate(issue.title, tw) : "";
-    const detail = selected ? summarizeIssueStatusNote(issue.statusNote) : undefined;
     const session = sessionDisplay(issue);
-    const facts = buildFacts(issue, selected);
-    const blocker = selected ? blockerText(issue) : null;
+    const facts = buildFacts(issue, selected, compact);
+    const blocker = compact || !selected ? null : blockerText(issue);
+    const detail = compact || !selected ? undefined : summarizeIssueStatusNote(issue.statusNote);
     const isTerminal = TERMINAL_STATES.has(effectiveState(issue));
     // Terminal issues: compact single line
     if (isTerminal && !selected) {
         return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " " }), _jsx(Text, { dimColor: true, children: ` ${key}` }), _jsx(Text, { dimColor: true, children: `  ${relativeTime(issue.updatedAt).padStart(4)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: session.color, children: session.label })] }));
     }
+    if (compact) {
+        return (_jsxs(Box, { children: [_jsx(Text, { color: selected ? "blueBright" : "gray", children: selected ? "\u25b8" : " " }), _jsx(Text, { bold: true, children: ` ${key}` }), _jsx(Text, { dimColor: true, children: `  ${relativeTime(issue.updatedAt).padStart(4)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: session.color, children: session.label }), facts.length > 0 && _jsx(Text, { dimColor: true, children: ` · ` }), facts.map((fact, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { dimColor: true, children: ` ` }) : null, _jsx(Text, { color: fact.color ?? "white", dimColor: !fact.color, children: fact.text })] }, i)))] }));
+    }
     return (_jsxs(Box, { flexDirection: "column", marginBottom: detail ? 1 : 0, children: [_jsxs(Box, { children: [_jsx(Text, { color: selected ? "blueBright" : "gray", children: selected ? "\u25b8" : " " }), _jsx(Text, { bold: true, children: ` ${key}` }), _jsx(Text, { dimColor: true, children: `  ${relativeTime(issue.updatedAt).padStart(4)}` }), _jsx(Text, { children: `  ` }), _jsx(Text, { color: session.color, children: session.label }), facts.length > 0 && (_jsx(Text, { dimColor: true, children: ` \u00b7 ` })), facts.map((fact, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { dimColor: true, children: ` \u00b7 ` }) : null, _jsx(Text, { color: fact.color ?? "white", dimColor: !fact.color, children: fact.text })] }, i)))] }), title ? (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, children: title }) })) : null, blocker ? (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { color: "yellow", children: blocker }) })) : null, detail ? (_jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: detail }) })) : null, selected && issue.factoryState && issue.sessionState ? (_jsx(Box, { paddingLeft: 4, children: _jsx(Text, { dimColor: true, children: `Debug stage: ${stageLabel(issue)}` }) })) : null] }));
 }
-export function estimateIssueRowHeight(issue, selected, cols, titleWidth) {
+export function estimateIssueRowHeight(issue, selected, cols, titleWidth, compact = false) {
     const width = Math.max(20, cols);
     const key = issue.issueKey ?? issue.projectId;
     const tw = titleWidth ?? 60;
     const title = issue.title ? truncate(issue.title, tw) : "";
-    const detail = selected ? summarizeIssueStatusNote(issue.statusNote) : undefined;
+    const detail = compact || !selected ? undefined : summarizeIssueStatusNote(issue.statusNote);
     const session = sessionDisplay(issue);
-    const facts = buildFacts(issue, selected);
-    const blocker = selected ? blockerText(issue) : null;
+    const facts = buildFacts(issue, selected, compact);
+    const blocker = compact || !selected ? null : blockerText(issue);
     const isTerminal = TERMINAL_STATES.has(effectiveState(issue));
     if (isTerminal && !selected) {
         return 1;
     }
+    if (compact) {
+        return 1;
+    }
     const line1Parts = [
         `${selected ? "\u25b8" : " "} ${key}`,
         relativeTime(issue.updatedAt).padStart(4),

package/dist/cli/watch/StatusBar.js

@@ -8,7 +8,7 @@ const FILTER_LABELS = {
     "active": "active",
     "non-done": "in progress",
 };
-export function StatusBar({ issues, totalCount, filter, connected, lastServerMessageAt, allIssues, frozen, }) {
+export function StatusBar({ issues, totalCount, filter, connected, lastServerMessageAt, allIssues, frozen, compact = false, }) {
     const showing = filter === "all" ? `${totalCount} issues` : `${issues.length}/${totalCount} issues`;
     const aggregateSource = filter === "all" ? allIssues : issues;
     const agg = computeAggregates(aggregateSource);
@@ -17,5 +17,19 @@ export function StatusBar({ issues, totalCount, filter, connected, lastServerMes
     const intervention = aggregateSource.filter((i) => i.sessionState === "failed" || i.factoryState === "failed" || i.factoryState === "escalated").length;
     const running = aggregateSource.filter((i) => i.sessionState === "running").length;
     const idle = aggregateSource.filter((i) => i.sessionState === "idle").length;
+    if (compact) {
+        const compactParts = [
+            withPr > 0 ? `p${withPr}` : null,
+            running > 0 ? `r${running}` : null,
+            waitingInput > 0 ? `w${waitingInput}` : null,
+            intervention > 0 ? `x${intervention}` : null,
+            agg.blocked > 0 ? `b${agg.blocked}` : null,
+            agg.ready > 0 ? `q${agg.ready}` : null,
+            agg.failed > 0 ? `f${agg.failed}` : null,
+            agg.done > 0 ? `d${agg.done}` : null,
+            frozen ? "frozen" : null,
+        ].filter(Boolean);
+        return (_jsxs(Box, { justifyContent: "space-between", children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { bold: true, children: "patchrelay" }), _jsx(Text, { dimColor: true, children: showing }), _jsxs(Text, { dimColor: true, children: ["[", FILTER_LABELS[filter][0], "]"] }), compactParts.length > 0 ? _jsx(Text, { dimColor: true, children: compactParts.join(" ") }) : null] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
+    }
     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: "|" }), running > 0 && _jsxs(Text, { color: "cyan", children: [running, " running"] }), idle > 0 && _jsxs(Text, { color: "blueBright", children: [idle, " idle"] }), agg.ready > 0 && _jsxs(Text, { color: "blueBright", children: [agg.ready, " ready"] }), agg.blocked > 0 && _jsxs(Text, { color: "yellow", children: [agg.blocked, " blocked"] }), withPr > 0 && _jsxs(Text, { dimColor: true, children: [withPr, " PRs"] }), waitingInput > 0 && _jsxs(Text, { color: "yellow", children: [waitingInput, " needs input"] }), intervention > 0 && _jsxs(Text, { color: "red", children: [intervention, " needs help"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] }), frozen && _jsx(Text, { color: "magenta", children: "frozen" })] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
 }

package/dist/codex-app-server.js

@@ -43,6 +43,16 @@ export class CodexAppServerClient extends EventEmitter {
         this.logger = logger;
         this.spawnProcess = spawnProcess;
     }
+    /**
+     * Update runtime codex settings used by future thread/thread-fork calls.
+     * This allows service config changes to take effect without restarting.
+     */
+    setRuntimeConfig(config) {
+        this.config = {
+            ...this.config,
+            ...config,
+        };
+    }
     isStarted() {
         return this.started;
     }
@@ -149,6 +159,7 @@ export class CodexAppServerClient extends EventEmitter {
             serviceName: this.config.serviceName ?? "patchrelay",
             model: this.config.model ?? null,
             modelProvider: this.config.modelProvider ?? null,
+            reasoningEffort: this.config.reasoningEffort ?? null,
             baseInstructions: this.config.baseInstructions ?? null,
             developerInstructions: this.config.developerInstructions ?? null,
             experimentalRawEvents: this.config.experimentalRawEvents ?? false,
@@ -164,6 +175,7 @@ export class CodexAppServerClient extends EventEmitter {
             sandbox: this.config.sandboxMode,
             model: this.config.model ?? null,
             modelProvider: this.config.modelProvider ?? null,
+            reasoningEffort: this.config.reasoningEffort ?? null,
             baseInstructions: this.config.baseInstructions ?? null,
             developerInstructions: this.config.developerInstructions ?? null,
         };
@@ -181,6 +193,7 @@ export class CodexAppServerClient extends EventEmitter {
             sandbox: overrides?.sandboxMode ?? this.config.sandboxMode,
             model: overrides?.model ?? this.config.model ?? null,
             modelProvider: overrides?.modelProvider ?? this.config.modelProvider ?? null,
+            reasoningEffort: overrides?.reasoningEffort ?? this.config.reasoningEffort ?? null,
             baseInstructions: overrides?.baseInstructions ?? this.config.baseInstructions ?? null,
             developerInstructions: overrides?.developerInstructions ?? this.config.developerInstructions ?? null,
         };

package/dist/config.js

@@ -138,6 +138,7 @@ const configSchema = z.object({
             request_timeout_ms: z.number().int().positive().default(30000),
             model: z.string().optional(),
             model_provider: z.string().optional(),
+            reasoning_effort: z.enum(["low", "medium", "high"]).optional(),
             service_name: z.string().default("patchrelay"),
             base_instructions: z.string().optional(),
             developer_instructions: z.string().optional(),
@@ -544,6 +545,7 @@ export function loadConfig(configPath = process.env.PATCHRELAY_CONFIG ?? getDefa
                 requestTimeoutMs: parsed.runner.codex.request_timeout_ms,
                 ...(parsed.runner.codex.model ? { model: parsed.runner.codex.model } : {}),
                 ...(parsed.runner.codex.model_provider ? { modelProvider: parsed.runner.codex.model_provider } : {}),
+                ...(parsed.runner.codex.reasoning_effort ? { reasoningEffort: parsed.runner.codex.reasoning_effort } : {}),
                 ...(parsed.runner.codex.service_name ? { serviceName: parsed.runner.codex.service_name } : {}),
                 ...(parsed.runner.codex.base_instructions ? { baseInstructions: parsed.runner.codex.base_instructions } : {}),
                 ...(parsed.runner.codex.developer_instructions

package/dist/db/issue-store.js

@@ -192,6 +192,10 @@ export class IssueStore {
                 sets.push("last_attempted_failure_signature = @lastAttemptedFailureSignature");
                 values.lastAttemptedFailureSignature = params.lastAttemptedFailureSignature;
             }
+            if (params.lastAttemptedFailureAt !== undefined) {
+                sets.push("last_attempted_failure_at = @lastAttemptedFailureAt");
+                values.lastAttemptedFailureAt = params.lastAttemptedFailureAt;
+            }
             if (params.ciRepairAttempts !== undefined) {
                 sets.push("ci_repair_attempts = @ciRepairAttempts");
                 values.ciRepairAttempts = params.ciRepairAttempts;
@@ -226,7 +230,7 @@ export class IssueStore {
           last_github_failure_source, last_github_failure_head_sha, last_github_failure_signature, last_github_failure_check_name, last_github_failure_check_url, last_github_failure_context_json, last_github_failure_at,
           last_github_ci_snapshot_head_sha, last_github_ci_snapshot_gate_check_name, last_github_ci_snapshot_gate_check_status, last_github_ci_snapshot_json, last_github_ci_snapshot_settled_at,
           last_queue_signal_at, last_queue_incident_json,
-          last_attempted_failure_head_sha, last_attempted_failure_signature,
+          last_attempted_failure_head_sha, last_attempted_failure_signature, last_attempted_failure_at,
           ci_repair_attempts, queue_repair_attempts, review_fix_attempts, zombie_recovery_attempts, last_zombie_recovery_at,
           updated_at
         ) VALUES (
@@ -239,7 +243,7 @@ export class IssueStore {
           @lastGitHubFailureSource, @lastGitHubFailureHeadSha, @lastGitHubFailureSignature, @lastGitHubFailureCheckName, @lastGitHubFailureCheckUrl, @lastGitHubFailureContextJson, @lastGitHubFailureAt,
           @lastGitHubCiSnapshotHeadSha, @lastGitHubCiSnapshotGateCheckName, @lastGitHubCiSnapshotGateCheckStatus, @lastGitHubCiSnapshotJson, @lastGitHubCiSnapshotSettledAt,
           @lastQueueSignalAt, @lastQueueIncidentJson,
-          @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature,
+          @lastAttemptedFailureHeadSha, @lastAttemptedFailureSignature, @lastAttemptedFailureAt,
           @ciRepairAttempts, @queueRepairAttempts, @reviewFixAttempts, @zombieRecoveryAttempts, @lastZombieRecoveryAt,
           @now
         )
@@ -290,6 +294,7 @@ export class IssueStore {
                 lastQueueIncidentJson: params.lastQueueIncidentJson ?? null,
                 lastAttemptedFailureHeadSha: params.lastAttemptedFailureHeadSha ?? null,
                 lastAttemptedFailureSignature: params.lastAttemptedFailureSignature ?? null,
+                lastAttemptedFailureAt: params.lastAttemptedFailureAt ?? null,
                 ciRepairAttempts: params.ciRepairAttempts ?? 0,
                 queueRepairAttempts: params.queueRepairAttempts ?? 0,
                 reviewFixAttempts: params.reviewFixAttempts ?? 0,
@@ -556,6 +561,9 @@ export function mapIssueRow(row) {
         ...(row.last_attempted_failure_signature !== null && row.last_attempted_failure_signature !== undefined
             ? { lastAttemptedFailureSignature: String(row.last_attempted_failure_signature) }
             : {}),
+        ...(row.last_attempted_failure_at !== null && row.last_attempted_failure_at !== undefined
+            ? { lastAttemptedFailureAt: String(row.last_attempted_failure_at) }
+            : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),

package/dist/db/migrations.js

@@ -293,6 +293,7 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "last_queue_incident_json", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_head_sha", "TEXT");
     addColumnIfMissing(connection, "issues", "last_attempted_failure_signature", "TEXT");
+    addColumnIfMissing(connection, "issues", "last_attempted_failure_at", "TEXT");
     removeRetiredIssueColumnsIfPresent(connection);
 }
 function addColumnIfMissing(connection, table, column, definition) {
@@ -359,6 +360,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         last_queue_incident_json TEXT,
         last_attempted_failure_head_sha TEXT,
         last_attempted_failure_signature TEXT,
+        last_attempted_failure_at TEXT,
         ci_repair_attempts INTEGER NOT NULL DEFAULT 0,
         queue_repair_attempts INTEGER NOT NULL DEFAULT 0,
         review_fix_attempts INTEGER NOT NULL DEFAULT 0,
@@ -416,6 +418,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         last_queue_incident_json,
         last_attempted_failure_head_sha,
         last_attempted_failure_signature,
+        last_attempted_failure_at,
         ci_repair_attempts,
         queue_repair_attempts,
         review_fix_attempts,
@@ -471,6 +474,7 @@ function removeRetiredIssueColumnsIfPresent(connection) {
         last_queue_incident_json,
         last_attempted_failure_head_sha,
         last_attempted_failure_signature,
+        last_attempted_failure_at,
         COALESCE(ci_repair_attempts, 0),
         COALESCE(queue_repair_attempts, 0),
         COALESCE(review_fix_attempts, 0),

package/dist/github-webhook-state-projector.js

@@ -80,6 +80,7 @@ export async function projectGitHubWebhookState(deps, issue, event, project, lin
             lastQueueIncidentJson: null,
             lastAttemptedFailureHeadSha: null,
             lastAttemptedFailureSignature: null,
+            lastAttemptedFailureAt: null,
         });
     }
     deps.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
@@ -240,6 +241,7 @@ async function updateGitHubFailureProvenance(deps, issue, event, project, failur
             lastQueueIncidentJson: null,
             lastAttemptedFailureHeadSha: null,
             lastAttemptedFailureSignature: null,
+            lastAttemptedFailureAt: null,
         });
     }
 }

package/dist/idle-reconciliation.js

@@ -50,8 +50,19 @@ function isDuplicateRepairAttempt(issue, context) {
         : typeof context?.headSha === "string" ? context.headSha : undefined;
     if (!signature)
         return false;
-    return issue.lastAttemptedFailureSignature === signature
-        && (headSha === undefined || issue.lastAttemptedFailureHeadSha === headSha);
+    if (issue.lastAttemptedFailureSignature !== signature)
+        return false;
+    if (headSha !== undefined && issue.lastAttemptedFailureHeadSha !== headSha)
+        return false;
+    // A signature+headSha match alone isn't enough: for queue evictions the PR head
+    // doesn't advance (we haven't pushed) and the steward's check name is constant,
+    // so a fresh incident after main advances looks identical. Treat the attempt as
+    // stale if a newer failure has been observed since it was recorded.
+    if (issue.lastAttemptedFailureAt && issue.lastGitHubFailureAt
+        && issue.lastGitHubFailureAt > issue.lastAttemptedFailureAt) {
+        return false;
+    }
+    return true;
 }
 function buildFailureContext(issue) {
     const storedFailureContext = parseGitHubFailureContext(issue.lastGitHubFailureContextJson);
@@ -196,6 +207,7 @@ export class IdleIssueReconciler {
                     lastQueueIncidentJson: null,
                     lastAttemptedFailureHeadSha: null,
                     lastAttemptedFailureSignature: null,
+                    lastAttemptedFailureAt: null,
                 }
                 : {}),
         });

package/dist/index.js

@@ -38,7 +38,7 @@ async function main() {
     db.runMigrations();
     const codex = new CodexAppServerClient(config.runner.codex, logger);
     const linearProvider = new DatabaseBackedLinearClientProvider(config, db, logger);
-    const service = new PatchRelayService(config, db, codex, linearProvider, logger);
+    const service = new PatchRelayService(config, db, codex, linearProvider, logger, configPath);
     await service.start();
     const app = await buildHttpServer(config, service, logger);
     try {

package/dist/interrupted-run-recovery.js

@@ -90,6 +90,7 @@ export class InterruptedRunRecovery {
                     linearIssueId: issue.linearIssueId,
                     lastAttemptedFailureHeadSha: null,
                     lastAttemptedFailureSignature: null,
+                    lastAttemptedFailureAt: null,
                 });
             }
             return true;

package/dist/issue-session-lease-service.js

@@ -14,10 +14,10 @@ export class IssueSessionLeaseService {
         this.readThreadWithRetry = readThreadWithRetry;
     }
     hasLocalLease(projectId, linearIssueId) {
-        return this.activeSessionLeases.has(this.issueSessionLeaseKey(projectId, linearIssueId));
+        return this.getValidatedLocalLeaseId(projectId, linearIssueId) !== undefined;
     }
     getHeldLease(projectId, linearIssueId) {
-        const leaseId = this.activeSessionLeases.get(this.issueSessionLeaseKey(projectId, linearIssueId));
+        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
         if (!leaseId)
             return undefined;
         return { projectId, linearIssueId, leaseId };
@@ -133,10 +133,21 @@ export class IssueSessionLeaseService {
     }
     release(projectId, linearIssueId) {
         const key = this.issueSessionLeaseKey(projectId, linearIssueId);
-        const leaseId = this.activeSessionLeases.get(key);
+        const leaseId = this.getValidatedLocalLeaseId(projectId, linearIssueId);
         this.db.issueSessions.releaseIssueSessionLease(projectId, linearIssueId, leaseId);
         this.activeSessionLeases.delete(key);
     }
+    getValidatedLocalLeaseId(projectId, linearIssueId) {
+        const key = this.issueSessionLeaseKey(projectId, linearIssueId);
+        const leaseId = this.activeSessionLeases.get(key);
+        if (!leaseId)
+            return undefined;
+        if (this.db.issueSessions.hasActiveIssueSessionLease(projectId, linearIssueId, leaseId)) {
+            return leaseId;
+        }
+        this.activeSessionLeases.delete(key);
+        return undefined;
+    }
     issueSessionLeaseKey(projectId, linearIssueId) {
         return `${projectId}:${linearIssueId}`;
     }

package/dist/linear-workflow-state-sync.js

@@ -1,4 +1,4 @@
-import { resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
+import { resolvePreferredQueuedLinearState, resolvePreferredCompletedLinearState, resolvePreferredDeployingLinearState, resolvePreferredHumanNeededLinearState, resolvePreferredImplementingLinearState, resolvePreferredReviewLinearState, resolvePreferredReviewingLinearState, } from "./linear-workflow.js";
 import { isCompletedLinearState } from "./pr-state.js";
 import { hasTrustedNoPrCompletion } from "./trusted-no-pr-completion.js";
 export async function syncActiveWorkflowState(params) {
@@ -72,10 +72,15 @@ function resolveDesiredActiveWorkflowState(issue, trackedIssue, options, liveIss
         || trackedIssue?.sessionState === "waiting_input" || trackedIssue?.sessionState === "failed") {
         return resolvePreferredHumanNeededLinearState(liveIssue);
     }
+    const blocked = (trackedIssue?.blockedByCount ?? 0) > 0;
+    const pausedNoPrWork = issue.prNumber === undefined && (!issue.delegatedToPatchRelay || blocked);
+    if (pausedNoPrWork) {
+        return resolvePreferredQueuedLinearState(liveIssue);
+    }
     const activelyWorking = issue.delegatedToPatchRelay !== false && (issue.activeRunId !== undefined
         || options?.activeRunType !== undefined
         || trackedIssue?.sessionState === "running"
-        || issue.factoryState === "delegated"
+        || (issue.factoryState === "delegated" && !blocked && trackedIssue?.readyForExecution !== false)
         || issue.factoryState === "implementing"
         || issue.factoryState === "changes_requested"
         || issue.factoryState === "repairing_ci"

package/dist/linear-workflow.js

@@ -24,6 +24,16 @@ export function resolvePreferredStartedLinearState(issue) {
     });
     return preferred?.name ?? startedStates[0]?.name;
 }
+export function resolvePreferredQueuedLinearState(issue) {
+    return resolvePreferredLinearState(issue, {
+        names: ["backlog", "start", "todo", "to do", "planned", "ready"],
+        types: ["backlog", "unstarted"],
+        fallback: issue.workflowStates.find((state) => {
+            const normalizedType = normalizeLinearState(state.type);
+            return normalizedType === "backlog" || normalizedType === "unstarted";
+        })?.name,
+    });
+}
 export function resolvePreferredImplementingLinearState(issue) {
     return resolvePreferredLinearState(issue, {
         names: ["implementing", "in progress", "in-progress", "started", "doing"],

package/dist/no-pr-completion-check.js

@@ -188,6 +188,7 @@ export async function handleNoPrCompletionCheck(params) {
                 lastQueueIncidentJson: null,
                 lastAttemptedFailureHeadSha: null,
                 lastAttemptedFailureSignature: null,
+                lastAttemptedFailureAt: null,
             });
             return true;
         });

package/dist/reactive-run-policy.js

@@ -23,6 +23,13 @@ export class ReactiveRunPolicy {
                 return undefined;
             if (!snapshot.headSha || snapshot.headSha !== issue.lastGitHubFailureHeadSha)
                 return undefined;
+            // For queue repairs, the agent's no-op is legitimate when the incident has
+            // already self-resolved: GitHub reports the PR as mergeable, so there is no
+            // conflict left to push. Only flag as failed when the merge state is still
+            // DIRTY after the run — then the agent really did miss the fix.
+            if (run.runType === "queue_repair" && !isDirtyMergeStateStatus(snapshot.pr.mergeStateStatus)) {
+                return undefined;
+            }
             return `Repair finished but PR #${issue.prNumber} is still on failing head ${issue.lastGitHubFailureHeadSha.slice(0, 8)}`;
         }
         catch (error) {
@@ -99,6 +106,7 @@ export class ReactiveRunPolicy {
                         lastQueueIncidentJson: null,
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
+                        lastAttemptedFailureAt: null,
                         lastGitHubCiSnapshotHeadSha: snapshot.headSha ?? null,
                         lastGitHubCiSnapshotGateCheckName: snapshot.gateCheckName,
                         lastGitHubCiSnapshotGateCheckStatus: "pending",

package/dist/run-finalizer.js

@@ -168,6 +168,7 @@ export class RunFinalizer {
                         lastQueueIncidentJson: null,
                         lastAttemptedFailureHeadSha: null,
                         lastAttemptedFailureSignature: null,
+                        lastAttemptedFailureAt: null,
                     }
                     : {})),
             });

package/dist/run-launcher.js

@@ -101,6 +101,7 @@ export class RunLauncher {
                     ? {
                         lastAttemptedFailureSignature: failureSignature,
                         lastAttemptedFailureHeadSha: failureHeadSha ?? null,
+                        lastAttemptedFailureAt: new Date().toISOString(),
                     }
                     : {}),
             });

package/dist/run-orchestrator.js

@@ -16,6 +16,7 @@ import { RunReconciler } from "./run-reconciler.js";
 import { RunRecoveryService } from "./run-recovery-service.js";
 import { RunWakePlanner } from "./run-wake-planner.js";
 import { getRemainingZombieRecoveryDelayMs } from "./zombie-recovery.js";
+import { loadConfig } from "./config.js";
 function lowerCaseFirst(value) {
     return value ? `${value.slice(0, 1).toLowerCase()}${value.slice(1)}` : value;
 }
@@ -37,6 +38,7 @@ export class RunOrchestrator {
     enqueueIssue;
     logger;
     feed;
+    configPath;
     worktreeManager;
     /** Tracks last probe-failure feed event per issue to avoid spamming the operator feed. */
     queueHealthMonitor;
@@ -54,6 +56,7 @@ export class RunOrchestrator {
     runNotificationHandler;
     runReconciler;
     mergedLinearCompletionReconciler;
+    codexRuntimeConfig;
     threadPorts = {
         readThreadWithRetry: (threadId, maxRetries) => this.readThreadWithRetry(threadId, maxRetries),
     };
@@ -70,7 +73,7 @@ export class RunOrchestrator {
     };
     activeSessionLeases;
     botIdentity;
-    constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
+    constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed, configPath) {
         this.config = config;
         this.db = db;
         this.codex = codex;
@@ -78,7 +81,9 @@ export class RunOrchestrator {
         this.enqueueIssue = enqueueIssue;
         this.logger = logger;
         this.feed = feed;
+        this.configPath = configPath;
         this.worktreeManager = new WorktreeManager(config);
+        this.codexRuntimeConfig = config.runner.codex;
         this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         this.leaseService = new IssueSessionLeaseService(db, logger, this.workerId, this.threadPorts.readThreadWithRetry);
         this.activeSessionLeases = this.leaseService.activeSessionLeases;
@@ -100,6 +105,27 @@ export class RunOrchestrator {
             enqueueIssue: (projectId, issueId) => this.enqueueIssue(projectId, issueId),
         }, logger, feed);
     }
+    async refreshCodexRuntimeConfig() {
+        if (!this.configPath) {
+            return;
+        }
+        try {
+            const freshConfig = loadConfig(this.configPath, { profile: "service" });
+            if (this.codexRuntimeConfig.model === freshConfig.runner.codex.model &&
+                this.codexRuntimeConfig.modelProvider === freshConfig.runner.codex.modelProvider &&
+                this.codexRuntimeConfig.reasoningEffort === freshConfig.runner.codex.reasoningEffort) {
+                return;
+            }
+            this.codexRuntimeConfig = freshConfig.runner.codex;
+            this.codex.setRuntimeConfig(this.codexRuntimeConfig);
+        }
+        catch (error) {
+            this.logger.warn({
+                error: error instanceof Error ? error.message : String(error),
+                configPath: this.configPath,
+            }, "Failed to reload patchrelay runtime config before run; using previous codex configuration");
+        }
+    }
     resolveRunWake(issue) {
         return this.runWakePlanner.resolveRunWake(issue);
     }
@@ -111,6 +137,7 @@ export class RunOrchestrator {
     }
     // ─── Run ────────────────────────────────────────────────────────
     async run(item) {
+        await this.refreshCodexRuntimeConfig();
         const project = this.config.projects.find((p) => p.id === item.projectId);
         if (!project)
             return;

package/dist/service-startup-recovery.js

@@ -38,7 +38,7 @@ export class ServiceStartupRecovery {
         }
     }
     async recoverDelegatedIssueStateFromLinear() {
-        for (const issue of this.db.issues.listIssuesWithAgentSessions()) {
+        for (const issue of this.db.issues.listIssues()) {
             if (issue.factoryState === "done" || issue.activeRunId !== undefined) {
                 continue;
             }
@@ -87,7 +87,13 @@ export class ServiceStartupRecovery {
             const unresolvedBlockers = this.db.issues.countUnresolvedBlockers(issue.projectId, issue.linearIssueId);
             const latestRun = this.db.runs.getLatestRunForIssue(issue.projectId, issue.linearIssueId);
             const shouldRecoverPausedLocalWork = delegated
-                && isResumablePausedLocalWork({ issue, latestRun })
+                && isResumablePausedLocalWork({
+                    issue: {
+                        ...issue,
+                        delegatedToPatchRelay: delegated,
+                    },
+                    latestRun,
+                })
                 && this.db.issueSessions.peekIssueSessionWake(issue.projectId, issue.linearIssueId) === undefined;
             const updated = this.db.issues.upsertIssue({
                 projectId: issue.projectId,

package/dist/service.js

@@ -17,6 +17,7 @@ export class PatchRelayService {
     db;
     codex;
     logger;
+    configPath;
     linearProvider;
     orchestrator;
     githubAppTokenManager;
@@ -29,17 +30,18 @@ export class PatchRelayService {
     issueActions;
     startupRecovery;
     trackedIssueListQuery;
-    constructor(config, db, codex, linearProvider, logger) {
+    constructor(config, db, codex, linearProvider, logger, configPath) {
         this.config = config;
         this.db = db;
         this.codex = codex;
         this.logger = logger;
+        this.configPath = configPath;
         this.linearProvider = toLinearClientProvider(linearProvider);
         this.feed = new OperatorEventFeed(db.operatorFeed);
         let enqueueIssue = () => {
             throw new Error("Service runtime enqueueIssue is not initialized");
         };
-        this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
+        this.orchestrator = new RunOrchestrator(config, db, codex, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed, this.configPath);
         this.webhookHandler = new WebhookHandler(config, db, this.linearProvider, codex, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, this.feed);
         this.githubWebhookHandler = new GitHubWebhookHandler(config, db, this.linearProvider, (projectId, issueId) => enqueueIssue(projectId, issueId), logger, codex, this.feed);
         const runtime = new ServiceRuntime(codex, logger, this.orchestrator, { listIssuesReadyForExecution: () => db.listIssuesReadyForExecution() }, this.webhookHandler, {

package/dist/webhook-handler.js

@@ -1,4 +1,5 @@
 import { deriveIssueStatusNote } from "./status-note.js";
+import { LinearSessionSync } from "./linear-session-sync.js";
 import { trustedActorAllowed } from "./project-resolution.js";
 import { normalizeWebhook } from "./webhooks.js";
 import { InstallationWebhookHandler } from "./webhook-installation-handler.js";
@@ -25,6 +26,7 @@ export class WebhookHandler {
     desiredStageRecorder;
     contextLoader;
     dependencyReadinessHandler;
+    linearSync;
     constructor(config, db, linearProvider, codex, enqueueIssue, logger, feed) {
         this.config = config;
         this.db = db;
@@ -39,6 +41,7 @@ export class WebhookHandler {
         this.agentSessionHandler = new AgentSessionHandler(config, db, linearProvider, codex, logger, feed);
         this.desiredStageRecorder = new DesiredStageRecorder(db, linearProvider, feed);
         this.contextLoader = new WebhookContextLoader(config, linearProvider);
+        this.linearSync = new LinearSessionSync(config, db, linearProvider, logger, feed);
         this.dependencyReadinessHandler = new DependencyReadinessHandler(db, (projectId, issueId) => this.peekPendingSessionWakeRunType(projectId, issueId));
     }
     async processWebhookEvent(webhookEventId) {
@@ -114,6 +117,9 @@ export class WebhookHandler {
             });
             const trackedIssue = result.issue;
             const newlyReadyDependents = this.dependencyReadinessHandler.reconcile(project.id, issue.id);
+            const syncTargets = new Set(shouldSyncLinearStateAfterWebhook(hydrated.triggerEvent)
+                ? [issue.id, ...newlyReadyDependents]
+                : newlyReadyDependents);
             // Handle issue removal: release active runs, mark as failed.
             if (hydrated.triggerEvent === "issueRemoved") {
                 await this.issueRemovalHandler.handle({
@@ -172,6 +178,13 @@ export class WebhookHandler {
                     detail: `All blockers are now done for ${dependent?.issueKey ?? dependentIssueId}.`,
                 });
             }
+            for (const issueId of syncTargets) {
+                const syncIssue = this.db.getIssue(project.id, issueId);
+                if (!syncIssue) {
+                    continue;
+                }
+                await this.linearSync.syncSession(syncIssue);
+            }
         }
         catch (error) {
             this.db.webhookEvents.markWebhookProcessed(webhookEventId, "failed");
@@ -233,3 +246,10 @@ export class WebhookHandler {
         return Boolean(statusNote?.endsWith("?"));
     }
 }
+function shouldSyncLinearStateAfterWebhook(triggerEvent) {
+    return triggerEvent !== "agentSessionCreated"
+        && triggerEvent !== "agentPrompted"
+        && triggerEvent !== "commentCreated"
+        && triggerEvent !== "commentUpdated"
+        && triggerEvent !== "commentRemoved";
+}

package/package.json

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