patchrelay 0.26.0 → 0.29.1

package/dist/cli/watch/IssueDetailView.js

@@ -6,6 +6,11 @@ import { StateHistoryView } from "./StateHistoryView.js";
 import { buildStateHistory } from "./history-builder.js";
 import { HelpBar } from "./HelpBar.js";
 import { planStepSymbol, planStepColor } from "./plan-helpers.js";
+import { progressBar } from "./format-utils.js";
+import { FactoryStateGraph } from "./FactoryStateGraph.js";
+import { QueueObservationView } from "./QueueObservationView.js";
+import { buildPatchRelayQueueObservations, buildPatchRelayStateGraph } from "./state-visualization.js";
+import { FreshnessBadge } from "./FreshnessBadge.js";
 function formatTokens(n) {
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;
@@ -24,7 +29,7 @@ function ElapsedTime({ startedAt }) {
     const seconds = elapsed % 60;
     return _jsxs(Text, { dimColor: true, children: [minutes, "m ", String(seconds).padStart(2, "0"), "s"] });
 }
-export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, timelineMode, rawRuns, rawFeedEvents, }) {
+export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, timelineMode, rawRuns, rawFeedEvents, connected, lastServerMessageAt, }) {
     if (!issue) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode })] }));
     }
@@ -37,5 +42,7 @@ export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, a
     if (issueContext?.runCount)
         meta.push(`${issueContext.runCount} runs`);
     const history = useMemo(() => buildStateHistory(rawRuns, rawFeedEvents, issue.factoryState, activeRunId), [rawRuns, rawFeedEvents, issue.factoryState, activeRunId]);
-    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: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, 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(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
+    const graph = useMemo(() => buildPatchRelayStateGraph(history, issue.factoryState), [history, issue.factoryState]);
+    const queueObservations = useMemo(() => buildPatchRelayQueueObservations(issue, rawFeedEvents), [issue, rawFeedEvents]);
+    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: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: "Plan" }), _jsx(Text, { children: progressBar(plan.filter((s) => s.status === "completed").length, plan.length, 16) }), _jsxs(Text, { dimColor: true, children: [plan.filter((s) => s.status === "completed").length, "/", plan.length] })] }), 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(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsxs(_Fragment, { children: [_jsx(FactoryStateGraph, { main: graph.main, prLoops: graph.prLoops, queueLoop: graph.queueLoop, exits: graph.exits }), _jsx(QueueObservationView, { observations: queueObservations }), _jsx(Box, { marginTop: 1, children: _jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId }) })] })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
 }

package/dist/cli/watch/IssueListView.js

@@ -7,7 +7,7 @@ import { HelpBar } from "./HelpBar.js";
 // selector(2) + key(10) + status(13) + pr(7) + ago(4) + gaps = ~36
 const FIXED_COLS = 40;
 const CHROME_ROWS = 4;
-export function IssueListView({ issues, allIssues, selectedIndex, connected, filter, totalCount }) {
+export function IssueListView({ issues, allIssues, selectedIndex, connected, lastServerMessageAt, filter, totalCount, }) {
     const { stdout } = useStdout();
     const cols = stdout?.columns ?? 80;
     const rows = stdout?.rows ?? 24;
@@ -23,5 +23,5 @@ export function IssueListView({ issues, allIssues, selectedIndex, connected, fil
     const visible = issues.slice(startIndex, startIndex + maxVisible);
     const hiddenAbove = startIndex;
     const hiddenBelow = Math.max(0, issues.length - startIndex - maxVisible);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(StatusBar, { issues: issues, totalCount: totalCount, filter: filter, connected: connected, allIssues: allIssues }), _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 }), _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" }) })] }));
 }

package/dist/cli/watch/IssueRow.js

@@ -2,32 +2,30 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { summarizeIssueStatusNote } from "./issue-status-note.js";
 const STATE_COLORS = {
-    delegated: "blue",
-    preparing: "blue",
-    implementing: "yellow",
+    delegated: "cyan",
+    implementing: "cyan",
     pr_open: "cyan",
-    changes_requested: "magenta",
-    repairing_ci: "magenta",
-    awaiting_queue: "green",
-    repairing_queue: "magenta",
+    changes_requested: "yellow",
+    repairing_ci: "cyan",
+    awaiting_queue: "cyan",
+    repairing_queue: "cyan",
     done: "green",
     failed: "red",
     escalated: "red",
     awaiting_input: "yellow",
 };
 const STATE_SHORT = {
-    delegated: "queued",
-    preparing: "prep",
+    delegated: "delegated",
     implementing: "impl",
     pr_open: "pr open",
     changes_requested: "review fix",
     repairing_ci: "ci fix",
-    awaiting_queue: "merging",
+    awaiting_queue: "await queue",
     repairing_queue: "merge fix",
     done: "done",
     failed: "failed",
     escalated: "escalated",
-    awaiting_input: "paused",
+    awaiting_input: "await input",
 };
 const STATUS_SHORT = {
     running: "\u25b8",

package/dist/cli/watch/QueueObservationView.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+function toneColor(tone) {
+    switch (tone) {
+        case "success":
+            return "green";
+        case "warn":
+            return "yellow";
+        case "info":
+            return "cyan";
+    }
+}
+export function QueueObservationView({ observations }) {
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Queue Observation" }), observations.map((observation, index) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: toneColor(observation.tone), children: "-" }), _jsx(Text, { children: observation.text })] }, `queue-observation-${index}`)))] }));
+}

package/dist/cli/watch/StateHistoryView.js

@@ -40,7 +40,6 @@ function runStatusColor(status) {
 }
 const STATE_LABELS = {
     delegated: "delegated",
-    preparing: "preparing",
     implementing: "implementing",
     pr_open: "pr open",
     changes_requested: "changes requested",

package/dist/cli/watch/StatusBar.js

@@ -1,13 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
 import { computeAggregates } from "./watch-state.js";
+import { FreshnessBadge } from "./FreshnessBadge.js";
 const FILTER_LABELS = {
     "all": "all",
     "active": "active",
     "non-done": "in progress",
 };
-export function StatusBar({ issues, totalCount, filter, connected, allIssues }) {
+export function StatusBar({ issues, totalCount, filter, connected, lastServerMessageAt, allIssues, }) {
     const showing = filter === "all" ? `${totalCount} issues` : `${issues.length}/${totalCount} issues`;
     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" })] }));
+    const withPr = allIssues.filter((i) => i.prNumber !== undefined).length;
+    const awaitingInput = allIssues.filter((i) => i.factoryState === "awaiting_input").length;
+    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: "cyan", children: [agg.active, " active"] }), withPr > 0 && _jsxs(Text, { dimColor: true, children: [withPr, " PRs"] }), awaitingInput > 0 && _jsxs(Text, { color: "yellow", children: [awaitingInput, " awaiting input"] }), agg.done > 0 && _jsxs(Text, { color: "green", children: [agg.done, " done"] }), agg.failed > 0 && _jsxs(Text, { color: "red", children: [agg.failed, " failed"] })] }), _jsx(FreshnessBadge, { connected: connected, lastServerMessageAt: lastServerMessageAt })] }));
 }

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

@@ -36,6 +36,13 @@ export function formatTokens(n) {
         return `${(n / 1_000).toFixed(1)}k`;
     return String(n);
 }
+/** Render a progress bar: ████░░░░ */
+export function progressBar(current, total, width) {
+    if (total <= 0 || width <= 0)
+        return "\u2591".repeat(width);
+    const filled = Math.min(width, Math.round((current / total) * width));
+    return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
 /** Truncate text to max length with ellipsis. Collapses newlines. */
 export function truncate(text, max) {
     const line = text.replace(/\n/g, " ").trim();

package/dist/cli/watch/freshness.js

@@ -0,0 +1,30 @@
+const PATCHRELAY_FRESH_MS = 20_000;
+const PATCHRELAY_STALE_MS = 40_000;
+function formatAge(ms) {
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const rem = seconds % 60;
+    return rem === 0 ? `${minutes}m` : `${minutes}m${String(rem).padStart(2, "0")}s`;
+}
+export function describePatchRelayFreshness(connected, lastServerMessageAt, now = Date.now()) {
+    if (lastServerMessageAt === null) {
+        return {
+            label: connected ? "connecting" : "waiting for first server update",
+            color: connected ? "yellow" : "red",
+        };
+    }
+    const ageMs = Math.max(0, now - lastServerMessageAt);
+    const age = formatAge(ageMs);
+    if (!connected) {
+        return { label: `disconnected · stale ${age}`, color: "red" };
+    }
+    if (ageMs > PATCHRELAY_STALE_MS) {
+        return { label: `stream stalled? last server update ${age} ago`, color: "red" };
+    }
+    if (ageMs > PATCHRELAY_FRESH_MS) {
+        return { label: `quiet ${age} since last server update`, color: "yellow" };
+    }
+    return { label: `fresh ${age}`, color: "green" };
+}

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

@@ -0,0 +1,147 @@
+const STATE_LABELS = {
+    delegated: "delegated",
+    implementing: "implementing",
+    pr_open: "pr_open",
+    changes_requested: "changes_requested",
+    repairing_ci: "repairing_ci",
+    awaiting_queue: "awaiting_queue",
+    repairing_queue: "repairing_queue",
+    awaiting_input: "awaiting_input",
+    escalated: "escalated",
+    done: "done",
+    failed: "failed",
+};
+const MAIN_STATES = ["delegated", "implementing", "pr_open", "awaiting_queue", "done"];
+const PR_LOOP_STATES = ["changes_requested", "repairing_ci"];
+const QUEUE_LOOP_STATES = ["repairing_queue"];
+const EXIT_STATES = ["awaiting_input", "escalated", "failed"];
+const QUEUE_EVENT_STATUSES = new Set([
+    "queue_label_requested",
+    "queue_label_applied",
+    "queue_label_failed",
+    "queue_repair_queued",
+    "pr_merged",
+]);
+function labelForState(state) {
+    return STATE_LABELS[state] ?? state;
+}
+function collectVisitedStates(history, currentFactoryState) {
+    const visited = new Set([currentFactoryState]);
+    for (const node of history) {
+        visited.add(node.state);
+        for (const sideTrip of node.sideTrips) {
+            visited.add(sideTrip.state);
+            visited.add(sideTrip.returnState);
+        }
+    }
+    return visited;
+}
+function buildNodes(states, visited, currentFactoryState) {
+    return states.map((state) => ({
+        state,
+        label: labelForState(state),
+        status: currentFactoryState === state
+            ? "current"
+            : visited.has(state)
+                ? "visited"
+                : "upcoming",
+    }));
+}
+function isQueueCheckFailure(event) {
+    if (event.kind !== "github" || event.status !== "check_failed") {
+        return false;
+    }
+    const haystack = `${event.summary} ${event.detail ?? ""}`;
+    return haystack.includes("merge-steward/queue");
+}
+function latestQueueObservationEvent(feedEvents) {
+    const queueEvents = feedEvents.filter((event) => QUEUE_EVENT_STATUSES.has(event.status ?? "") || isQueueCheckFailure(event)
+        || (event.kind === "stage" && event.stage === "repairing_queue"));
+    return queueEvents[queueEvents.length - 1];
+}
+function describeObservationEvent(event) {
+    switch (event.status) {
+        case "queue_label_requested":
+            return { tone: "info", text: event.summary };
+        case "queue_label_applied":
+            return { tone: "success", text: event.summary };
+        case "queue_label_failed":
+            return { tone: "warn", text: event.summary };
+        case "queue_repair_queued":
+            return { tone: "warn", text: event.summary };
+        case "pr_merged":
+            return { tone: "success", text: "GitHub reports the PR was merged." };
+        default:
+            if (isQueueCheckFailure(event)) {
+                return {
+                    tone: "warn",
+                    text: `External queue reported failure via ${event.detail ?? "merge-steward/queue"}.`,
+                };
+            }
+            if (event.kind === "stage" && event.stage === "repairing_queue") {
+                const active = event.status === "starting";
+                return {
+                    tone: active ? "warn" : "info",
+                    text: active ? "PatchRelay is actively running queue repair." : event.summary,
+                };
+            }
+            return { tone: "info", text: event.summary };
+    }
+}
+export function buildPatchRelayStateGraph(history, currentFactoryState) {
+    const visited = collectVisitedStates(history, currentFactoryState);
+    return {
+        main: buildNodes(MAIN_STATES, visited, currentFactoryState),
+        prLoops: buildNodes(PR_LOOP_STATES, visited, currentFactoryState),
+        queueLoop: buildNodes(QUEUE_LOOP_STATES, visited, currentFactoryState),
+        exits: buildNodes(EXIT_STATES, visited, currentFactoryState),
+    };
+}
+export function buildPatchRelayQueueObservations(issue, feedEvents) {
+    const observations = [];
+    switch (issue.factoryState) {
+        case "awaiting_queue":
+            observations.push({
+                tone: "info",
+                text: "PatchRelay has finished branch work and is waiting for external queue progress.",
+            });
+            break;
+        case "repairing_queue":
+            observations.push({
+                tone: issue.activeRunType === "queue_repair" ? "warn" : "info",
+                text: issue.activeRunType === "queue_repair"
+                    ? "PatchRelay is actively repairing a queue eviction."
+                    : "PatchRelay is preparing or waiting to resume queue repair.",
+            });
+            break;
+        case "done":
+            observations.push({
+                tone: "success",
+                text: "PatchRelay is complete because GitHub reports the PR has merged.",
+            });
+            break;
+        default:
+            observations.push({
+                tone: "info",
+                text: "Queue hand-off has not started yet; PatchRelay still owns the issue workflow.",
+            });
+            break;
+    }
+    const latestEvent = latestQueueObservationEvent(feedEvents);
+    if (latestEvent) {
+        observations.push(describeObservationEvent(latestEvent));
+    }
+    else if (issue.factoryState === "awaiting_queue") {
+        observations.push({
+            tone: "info",
+            text: "No external queue signal has been observed yet.",
+        });
+    }
+    if (issue.prNumber !== undefined) {
+        observations.push({
+            tone: "info",
+            text: `Tracked PR: #${issue.prNumber}${issue.prReviewState ? ` (${issue.prReviewState})` : ""}`,
+        });
+    }
+    return observations.slice(0, 3);
+}

package/dist/cli/watch/theme.js

@@ -1,14 +1,13 @@
 // ─── Factory State Colors ─────────────────────────────────────────
 export const FACTORY_STATE_COLORS = {
-    delegated: "blue",
-    preparing: "blue",
-    implementing: "yellow",
+    delegated: "cyan",
+    implementing: "cyan",
     awaiting_input: "yellow",
     pr_open: "cyan",
-    changes_requested: "magenta",
-    repairing_ci: "magenta",
-    repairing_queue: "magenta",
-    awaiting_queue: "green",
+    changes_requested: "yellow",
+    repairing_ci: "cyan",
+    repairing_queue: "cyan",
+    awaiting_queue: "cyan",
     done: "green",
     failed: "red",
     escalated: "red",

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

@@ -49,6 +49,9 @@ export function useWatchStream(options) {
                             continue;
                         }
                         if (line.startsWith(":")) {
+                            if (line.includes("keepalive")) {
+                                dispatch({ type: "stream-heartbeat", receivedAt: Date.now() });
+                            }
                             newlineIndex = buffer.indexOf("\n");
                             continue;
                         }
@@ -89,11 +92,11 @@ function processEvent(dispatch, eventType, data) {
     try {
         if (eventType === "issues") {
             const issues = JSON.parse(data);
-            dispatch({ type: "issues-snapshot", issues });
+            dispatch({ type: "issues-snapshot", issues, receivedAt: Date.now() });
         }
         else if (eventType === "feed") {
             const event = JSON.parse(data);
-            dispatch({ type: "feed-event", event });
+            dispatch({ type: "feed-event", event, receivedAt: Date.now() });
         }
     }
     catch {

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

@@ -21,6 +21,7 @@ const DETAIL_INITIAL = {
 };
 export const initialWatchState = {
     connected: false,
+    lastServerMessageAt: null,
     issues: [],
     selectedIndex: 0,
     view: "list",
@@ -71,14 +72,17 @@ export function watchReducer(state, action) {
             return { ...state, connected: true };
         case "disconnected":
             return { ...state, connected: false };
+        case "stream-heartbeat":
+            return { ...state, lastServerMessageAt: action.receivedAt };
         case "issues-snapshot":
             return {
                 ...state,
+                lastServerMessageAt: action.receivedAt,
                 issues: action.issues,
                 selectedIndex: Math.min(state.selectedIndex, Math.max(0, action.issues.length - 1)),
             };
         case "feed-event":
-            return applyFeedEvent(state, action.event);
+            return applyFeedEvent(state, action.event, action.receivedAt);
         case "select":
             return {
                 ...state,
@@ -135,13 +139,13 @@ export function watchReducer(state, action) {
     }
 }
 // ─── Feed Event → Issue List + Timeline ───────────────────────────
-function applyFeedEvent(state, event) {
+function applyFeedEvent(state, event, receivedAt) {
     if (!event.issueKey) {
-        return state;
+        return { ...state, lastServerMessageAt: receivedAt };
     }
     const index = state.issues.findIndex((issue) => issue.issueKey === event.issueKey);
     if (index === -1) {
-        return state;
+        return { ...state, lastServerMessageAt: receivedAt };
     }
     const updated = [...state.issues];
     const issue = { ...updated[index] };
@@ -172,7 +176,7 @@ function applyFeedEvent(state, event) {
     const rawFeedEvents = isActiveDetail
         ? capArray([...state.rawFeedEvents, event], MAX_RAW_FEED_EVENTS)
         : state.rawFeedEvents;
-    return { ...state, issues: updated, timeline, rawFeedEvents };
+    return { ...state, lastServerMessageAt: receivedAt, issues: updated, timeline, rawFeedEvents };
 }
 // ─── Codex Notification → Timeline + Metadata ─────────────────────
 function applyCodexNotification(state, method, params) {