patchrelay 0.36.19 → 0.37.1

package/dist/cli/watch/detail-rows.js

@@ -1,8 +1,8 @@
+import { hasOpenPr } from "../../pr-state.js";
 import { buildStateHistory } from "./history-builder.js";
 import { buildTimelineRows } from "./timeline-presentation.js";
 import { planStepColor, planStepSymbol } from "./plan-helpers.js";
 import { progressBar } from "./format-utils.js";
-import { describePatchRelayFreshness } from "./freshness.js";
 import { hasDisplayPrBlocker, isApprovedReviewState, isAwaitingReviewState, isChangesRequestedReviewState, isRereviewNeeded, prChecksFact, } from "./pr-status.js";
 import { renderRichTextLines, renderTextLines } from "./render-rich-text.js";
 const SESSION_DISPLAY = {
@@ -85,20 +85,10 @@ function buildHeaderLines(input, width) {
         headerSegments.push({ text: "  ", dimColor: true });
         headerSegments.push(...joinFactSegments(facts));
     }
-    if (input.activeRunStartedAt) {
-        headerSegments.push({ text: "  ", dimColor: true });
-        headerSegments.push({ text: elapsedLabel(input.activeRunStartedAt), dimColor: true });
-    }
     if (meta.length > 0) {
         headerSegments.push({ text: "  ", dimColor: true });
         headerSegments.push({ text: meta.join("  "), dimColor: true });
     }
-    headerSegments.push({ text: "  ", dimColor: true });
-    headerSegments.push(...freshnessSegments(input.connected, input.lastServerMessageAt));
-    if (input.follow) {
-        headerSegments.push({ text: "  " });
-        headerSegments.push({ text: "live", color: "yellow", bold: true });
-    }
     const lines = renderTextLines(segmentsToText(headerSegments), {
         key: "detail-header",
         width,
@@ -255,7 +245,7 @@ function renderTimelineItemLines(key, item, width, indent) {
                     ? { color: "white" }
                     : { dimColor: item.type !== "commandExecution" },
     });
-    if (item.output && item.status === "inProgress") {
+    if (item.output && item.type === "commandExecution") {
         lines.push(...renderTextLines(lastNonEmptyLine(item.output), {
             key: `${key}-output`,
             width,
@@ -407,7 +397,7 @@ function buildFactSegments(issue, issueContext) {
         facts.push([{ text: "re-review needed", color: "yellow" }]);
     else if (isChangesRequestedReviewState(issue.prReviewState))
         facts.push([{ text: "changes requested", color: "yellow" }]);
-    else if (issue.prNumber !== undefined
+    else if (hasOpenPr(issue.prNumber, issue.prState)
         && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && issue.factoryState === "pr_open")))
         facts.push([{ text: "awaiting review", color: "yellow" }]);
     if (issue.factoryState === "awaiting_queue")
@@ -462,12 +452,6 @@ function formatDuration(startedAt, endedAt) {
 function formatTime(iso) {
     return new Date(iso).toLocaleTimeString("en-GB", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
 }
-function elapsedLabel(startedAt) {
-    const elapsed = Math.max(0, Math.floor((Date.now() - new Date(startedAt).getTime()) / 1000));
-    const minutes = Math.floor(elapsed / 60);
-    const seconds = elapsed % 60;
-    return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
-}
 function itemSummary(item) {
     switch (item.type) {
         case "commandExecution": {
@@ -520,7 +504,7 @@ function effectiveState(issue) {
         return "blocked";
     if (issue.sessionState === "waiting_input")
         return "awaiting_input";
-    if (issue.prNumber !== undefined)
+    if (hasOpenPr(issue.prNumber, issue.prState))
         return issue.factoryState;
     if (issue.readyForExecution && !issue.activeRunType && !hasDisplayPrBlocker(issue))
         return "ready";
@@ -563,7 +547,7 @@ function blockerText(issue, issueContext) {
         return "Awaiting re-review after requested changes";
     if (isChangesRequestedReviewState(issue.prReviewState))
         return "Review changes requested";
-    if (issue.prNumber !== undefined && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && effectiveState(issue) !== "done"))) {
+    if (hasOpenPr(issue.prNumber, issue.prState) && (isAwaitingReviewState(issue.prReviewState) || (!issue.prReviewState && effectiveState(issue) !== "done"))) {
         return "Awaiting review";
     }
     return null;
@@ -598,10 +582,6 @@ function feedGlyph(status) {
         return "✓";
     return "●";
 }
-function freshnessSegments(connected, lastServerMessageAt) {
-    const freshness = describePatchRelayFreshness(connected, lastServerMessageAt);
-    return [{ text: freshness.label, color: freshness.color, bold: true }];
-}
 function blankLine(key) {
     return { key, segments: [] };
 }

package/dist/cli/watch/detail-status.js

@@ -0,0 +1,38 @@
+import { describePatchRelayFreshness } from "./freshness.js";
+export function buildDetailStatusSegments(input, now = Date.now()) {
+    const groups = [];
+    groups.push(input.follow
+        ? [{ text: "live edge", color: "green", bold: true }]
+        : [{ text: "anchored review", color: "yellow", bold: true }]);
+    if (input.unreadBelow > 0) {
+        groups.push([{ text: `${input.unreadBelow} new below`, color: "yellow", bold: true }]);
+    }
+    if (input.activeRunStartedAt) {
+        groups.push([{ text: `run ${formatElapsed(input.activeRunStartedAt, now)}`, dimColor: true }]);
+    }
+    const freshness = describePatchRelayFreshness(input.connected, input.lastServerMessageAt, now);
+    groups.push([{ text: freshness.label, color: freshness.color, bold: true }]);
+    return joinGroups(groups);
+}
+export function buildDetailStatusText(input, now = Date.now()) {
+    return buildDetailStatusSegments(input, now).map((segment) => segment.text).join("");
+}
+function formatElapsed(startedAt, now) {
+    const startedMs = Date.parse(startedAt);
+    if (!Number.isFinite(startedMs))
+        return "0m 00s";
+    const elapsed = Math.max(0, Math.floor((now - startedMs) / 1000));
+    const minutes = Math.floor(elapsed / 60);
+    const seconds = elapsed % 60;
+    return `${minutes}m ${String(seconds).padStart(2, "0")}s`;
+}
+function joinGroups(groups) {
+    const segments = [];
+    for (const [index, group] of groups.entries()) {
+        if (index > 0) {
+            segments.push({ text: "  ", dimColor: true });
+        }
+        segments.push(...group);
+    }
+    return segments;
+}

package/dist/cli/watch/layout-measure.js

@@ -0,0 +1,7 @@
+import { renderTextLines } from "./render-rich-text.js";
+export function measureRenderedTextRows(text, width) {
+    return renderTextLines(text, {
+        key: "measure",
+        width,
+    }).length;
+}

package/dist/cli/watch/pr-status.js

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "../../pr-state.js";
 function isPassingCheckStatus(status) {
     return status === "passed" || status === "success";
 }
@@ -72,7 +73,7 @@ export function prChecksFact(issue) {
     return undefined;
 }
 export function hasDisplayPrBlocker(issue) {
-    if (issue.prNumber === undefined || issue.activeRunType) {
+    if (!hasOpenPr(issue.prNumber, issue.prState) || issue.activeRunType) {
         return false;
     }
     if (issue.factoryState === "pr_open" || issue.factoryState === "awaiting_queue" || issue.factoryState === "repairing_queue") {

package/dist/cli/watch/prompt-layout.js

@@ -0,0 +1,14 @@
+import { measureRenderedTextRows } from "./layout-measure.js";
+export const PROMPT_COMPOSER_HINT = "Enter: send  Ctrl-N: newline  Up/Down: history  Esc: cancel";
+export function buildPromptComposerDisplayLines(buffer, cursor) {
+    const withCursor = `${buffer.slice(0, cursor)}|${buffer.slice(cursor)}`;
+    const contentLines = withCursor.split("\n");
+    return [
+        ...contentLines.map((line, index) => `${index === 0 ? "prompt> " : "        "}${line}`),
+        PROMPT_COMPOSER_HINT,
+    ];
+}
+export function measurePromptComposerRows(buffer, cursor, width) {
+    return buildPromptComposerDisplayLines(buffer, cursor)
+        .reduce((count, line) => count + measureRenderedTextRows(line, width), 0);
+}

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

@@ -1,3 +1,4 @@
+import { hasOpenPr } from "../../pr-state.js";
 const STATE_LABELS = {
     delegated: "delegated",
     implementing: "implementing",
@@ -163,9 +164,12 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
         });
     }
     if (issue.prNumber !== undefined) {
+        const prLabel = hasOpenPr(issue.prNumber, issue.prState)
+            ? `Tracked PR: #${issue.prNumber}`
+            : `Tracked PR: #${issue.prNumber}${issue.prState ? ` (${issue.prState})` : ""}`;
         observations.push({
             tone: "info",
-            text: `Tracked PR: #${issue.prNumber}${issue.prReviewState ? ` (${issue.prReviewState})` : ""}`,
+            text: `${prLabel}${issue.prReviewState ? ` (${issue.prReviewState})` : ""}`,
         });
     }
     return observations.slice(0, 3);

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

@@ -2,6 +2,7 @@ import { getThreadTurns } from "../../codex-thread-utils.js";
 // ─── Build Timeline from Rehydration Data ─────────────────────────
 export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId) {
     const entries = [];
+    const activeRun = activeRunId ? runs.find((run) => run.id === activeRunId) : undefined;
     // 1. Add run boundaries and items from reports
     for (const run of runs) {
         entries.push({
@@ -32,22 +33,28 @@ export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activ
     }
     // 2. Items from live thread (active run)
     if (liveThread && activeRunId) {
-        entries.push(...itemsFromThread(activeRunId, liveThread));
+        entries.push(...itemsFromThread(activeRunId, liveThread, activeRun?.startedAt));
     }
     // 3. Feed events → feed entries + CI check aggregation
     entries.push(...feedEventsToEntries(feedEvents));
     // 4. Sort by timestamp, then by entry order for stability
-    entries.sort((a, b) => {
-        const cmp = a.at.localeCompare(b.at);
-        if (cmp !== 0)
-            return cmp;
-        // Within same timestamp: run-start before items, items before run-end
-        const kindCmp = kindOrder(a.kind) - kindOrder(b.kind);
-        if (kindCmp !== 0)
-            return kindCmp;
-        return a.id.localeCompare(b.id);
+    return sortTimelineEntries(entries);
+}
+export function reconcileTimelineFromRehydration(previousTimeline, runs, feedEvents, liveThread, activeRunId) {
+    const rehydrated = buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId);
+    if (previousTimeline.length === 0) {
+        return rehydrated;
+    }
+    const previousById = new Map(previousTimeline.map((entry) => [entry.id, entry]));
+    const rehydratedIds = new Set(rehydrated.map((entry) => entry.id));
+    const liveUserMessages = collectUserMessageCounts(rehydrated, activeRunId);
+    const merged = rehydrated.map((entry) => mergeTimelineEntry(previousById.get(entry.id), entry));
+    const carriedForward = previousTimeline.filter((entry) => {
+        if (rehydratedIds.has(entry.id))
+            return false;
+        return shouldCarryForwardEntry(entry, activeRunId, liveUserMessages);
     });
-    return entries;
+    return sortTimelineEntries([...merged, ...carriedForward]);
 }
 function kindOrder(kind) {
     switch (kind) {
@@ -131,27 +138,37 @@ function syntheticTimestamp(startMs, endMs, index, total) {
     return new Date(startMs + fraction * (endMs - startMs)).toISOString();
 }
 // ─── Items from Live Thread ───────────────────────────────────────
-function itemsFromThread(runId, thread) {
+function itemsFromThread(runId, thread, runStartedAt) {
     const entries = [];
+    let itemIndex = 0;
     for (const turn of getThreadTurns(thread)) {
         for (const item of turn.items) {
             entries.push({
                 id: `live-${item.id}`,
-                at: new Date().toISOString(), // live items don't have timestamps; they'll sort to the end
+                at: liveItemTimestamp(runStartedAt, itemIndex),
                 kind: "item",
                 runId,
                 item: materializeItem(item),
             });
+            itemIndex += 1;
         }
     }
     return entries;
 }
+const LIVE_ITEM_FALLBACK_START_MS = Date.UTC(9999, 0, 1, 0, 0, 0, 0);
+function liveItemTimestamp(runStartedAt, itemIndex) {
+    const baseMs = runStartedAt ? Date.parse(runStartedAt) : LIVE_ITEM_FALLBACK_START_MS;
+    const stableBaseMs = Number.isFinite(baseMs) ? baseMs : LIVE_ITEM_FALLBACK_START_MS;
+    return new Date(stableBaseMs + itemIndex).toISOString();
+}
 function materializeItem(item) {
     const r = item;
     const id = String(r.id ?? "unknown");
     const type = String(r.type ?? "unknown");
     const base = { id, type, status: "completed" };
     switch (type) {
+        case "userMessage":
+            return { ...base, text: extractUserMessageText(r.content) };
         case "agentMessage":
             return { ...base, text: String(r.text ?? "") };
         case "commandExecution":
@@ -340,16 +357,150 @@ function mergeDefinedItemFields(base, patch) {
         ...base,
         id: patch.id,
         type: patch.type,
-        status: patch.status,
-        ...(patch.text !== undefined ? { text: patch.text } : {}),
+        status: preferredItemStatus(base.status, patch.status),
+        ...(mergePreferredString(base.text, patch.text) !== undefined ? { text: mergePreferredString(base.text, patch.text) } : {}),
         ...(patch.command !== undefined ? { command: patch.command } : {}),
-        ...(patch.output !== undefined ? { output: patch.output } : {}),
+        ...(mergePreferredString(base.output, patch.output) !== undefined ? { output: mergePreferredString(base.output, patch.output) } : {}),
         ...(patch.exitCode !== undefined ? { exitCode: patch.exitCode } : {}),
-        ...(patch.durationMs !== undefined ? { durationMs: patch.durationMs } : {}),
-        ...(patch.changes !== undefined ? { changes: patch.changes } : {}),
+        ...(patch.durationMs !== undefined || base.durationMs !== undefined
+            ? { durationMs: preferredNumber(base.durationMs, patch.durationMs) }
+            : {}),
+        ...(patch.changes !== undefined || base.changes !== undefined
+            ? { changes: preferredChanges(base.changes, patch.changes) }
+            : {}),
         ...(patch.toolName !== undefined ? { toolName: patch.toolName } : {}),
     };
 }
+function mergeTimelineEntry(existing, incoming) {
+    if (!existing || existing.kind !== incoming.kind) {
+        return incoming;
+    }
+    switch (incoming.kind) {
+        case "item":
+            return {
+                ...incoming,
+                at: existing.at,
+                ...(existing.runId !== undefined && incoming.runId === undefined ? { runId: existing.runId } : {}),
+                item: incoming.item && existing.item ? mergeDefinedItemFields(existing.item, incoming.item) : incoming.item,
+            };
+        case "run-start":
+        case "run-end":
+            return {
+                ...incoming,
+                at: existing.at,
+                run: existing.run && incoming.run ? { ...existing.run, ...incoming.run } : incoming.run,
+            };
+        case "feed":
+            return {
+                ...incoming,
+                at: existing.at,
+                feed: existing.feed && incoming.feed ? { ...existing.feed, ...incoming.feed } : incoming.feed,
+            };
+        case "ci-checks":
+            return {
+                ...incoming,
+                at: existing.at,
+                ciChecks: incoming.ciChecks ?? existing.ciChecks,
+            };
+    }
+}
+function shouldCarryForwardEntry(entry, activeRunId, liveUserMessages) {
+    if (entry.kind !== "item" || entry.runId !== activeRunId) {
+        return false;
+    }
+    if (entry.item?.id.startsWith("prompt-") === true) {
+        const text = normalizePromptText(entry.item.text);
+        return !text || !consumeUserMessageMatch(liveUserMessages, text);
+    }
+    return entry.item?.status === "inProgress";
+}
+function sortTimelineEntries(entries) {
+    return [...entries].sort((a, b) => {
+        const cmp = a.at.localeCompare(b.at);
+        if (cmp !== 0)
+            return cmp;
+        // Within same timestamp: run-start before items, items before run-end
+        const kindCmp = kindOrder(a.kind) - kindOrder(b.kind);
+        if (kindCmp !== 0)
+            return kindCmp;
+        return a.id.localeCompare(b.id);
+    });
+}
+function preferredItemStatus(existing, incoming) {
+    return itemStatusRank(incoming) >= itemStatusRank(existing) ? incoming : existing;
+}
+function itemStatusRank(status) {
+    switch (status) {
+        case "failed":
+        case "completed":
+        case "declined":
+            return 2;
+        case "inProgress":
+            return 1;
+        default:
+            return 0;
+    }
+}
+function mergePreferredString(existing, incoming) {
+    if (incoming === undefined)
+        return existing;
+    if (existing === undefined)
+        return incoming;
+    return incoming.length >= existing.length ? incoming : existing;
+}
+function preferredNumber(existing, incoming) {
+    return incoming ?? existing;
+}
+function preferredChanges(existing, incoming) {
+    if (incoming === undefined)
+        return existing;
+    if (existing === undefined)
+        return incoming;
+    return incoming.length >= existing.length ? incoming : existing;
+}
+function collectUserMessageCounts(entries, activeRunId) {
+    const texts = new Map();
+    for (const entry of entries) {
+        if (entry.kind !== "item" || entry.runId !== activeRunId || entry.item?.type !== "userMessage") {
+            continue;
+        }
+        const text = normalizePromptText(entry.item.text);
+        if (text) {
+            texts.set(text, (texts.get(text) ?? 0) + 1);
+        }
+    }
+    return texts;
+}
+function consumeUserMessageMatch(messages, text) {
+    const count = messages.get(text) ?? 0;
+    if (count <= 0) {
+        return false;
+    }
+    if (count === 1) {
+        messages.delete(text);
+    }
+    else {
+        messages.set(text, count - 1);
+    }
+    return true;
+}
+function normalizePromptText(text) {
+    const normalized = text?.trim();
+    return normalized && normalized.length > 0 ? normalized : null;
+}
+function extractUserMessageText(content) {
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .map((entry) => {
+        if (!entry || typeof entry !== "object")
+            return undefined;
+        const value = entry.text;
+        return typeof value === "string" ? value : undefined;
+    })
+        .filter((value) => Boolean(value))
+        .join("\n\n");
+}
 // ─── Feed Events to Timeline Entries ──────────────────────────────
 function feedEventsToEntries(feedEvents) {
     const entries = [];

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

@@ -76,6 +76,7 @@ function buildCompactTimelineRows(entries) {
     }
     for (const run of runs.values()) {
         const status = resolveCompactRunStatus(run.run, run.items);
+        const verboseItems = status === "running" ? selectVerboseItems(run.items) : run.items;
         rows.push({
             id: run.id,
             kind: "run",
@@ -83,7 +84,7 @@ function buildCompactTimelineRows(entries) {
             finalized: status !== "running",
             run: { ...run.run, status, ...(run.endedAt ? { endedAt: run.endedAt } : {}) },
             details: summarizeRunDetails(run.items),
-            items: run.items.map((item) => ({ at: run.at, item })),
+            items: verboseItems.map((item) => ({ at: run.at, item })),
         });
     }
     rows.sort((left, right) => {
@@ -167,6 +168,25 @@ function summarizeRunDetails(items) {
     }
     return dedupeDetails(details).slice(0, 3);
 }
+function selectVerboseItems(items) {
+    const latestAssistantMessage = findLatest(items, (item) => item.type === "agentMessage" && Boolean(item.text?.trim()));
+    const latestUserMessage = !latestAssistantMessage
+        ? findLatest(items, (item) => item.type === "userMessage" && Boolean(item.text?.trim()))
+        : undefined;
+    const activeCommand = findLatest(items, (item) => item.type === "commandExecution" && item.status === "inProgress");
+    const latestCommandWithOutput = findLatest(items, (item) => item.type === "commandExecution" && Boolean(item.output?.trim()));
+    const latestCommand = activeCommand
+        ?? latestCommandWithOutput
+        ?? findLatest(items, (item) => item.type === "commandExecution" && Boolean(item.command?.trim()));
+    const latestFileChange = findLatest(items, (item) => item.type === "fileChange" && Array.isArray(item.changes) && item.changes.length > 0);
+    const latestToolCall = !latestFileChange
+        ? findLatest(items, (item) => item.type === "mcpToolCall" || item.type === "dynamicToolCall")
+        : undefined;
+    const selectedIds = new Set([latestUserMessage, latestAssistantMessage, latestCommand, latestFileChange, latestToolCall]
+        .filter((item) => Boolean(item))
+        .map((item) => item.id));
+    return items.filter((item) => selectedIds.has(item.id));
+}
 function summarizeNarrative(input) {
     const normalized = input
         .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")

package/dist/cli/watch/transient-status.js

@@ -0,0 +1,28 @@
+export const defaultTimerApi = {
+    setTimeout(callback, delayMs) {
+        return setTimeout(callback, delayMs);
+    },
+    clearTimeout(timer) {
+        clearTimeout(timer);
+    },
+};
+export function showTransientStatus(controller, message, setStatus, timers, delayMs = 3_000) {
+    setStatus(message);
+    if (controller.timer !== null) {
+        timers.clearTimeout(controller.timer);
+    }
+    controller.timer = timers.setTimeout(() => {
+        controller.timer = null;
+        setStatus(null);
+    }, delayMs);
+}
+export function setPersistentStatus(controller, message, setStatus, timers) {
+    clearTransientStatus(controller, timers);
+    setStatus(message);
+}
+export function clearTransientStatus(controller, timers) {
+    if (controller.timer !== null) {
+        timers.clearTimeout(controller.timer);
+        controller.timer = null;
+    }
+}

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

@@ -0,0 +1,76 @@
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { buildDetailLines } from "./detail-rows.js";
+import { lineToPlainText } from "./render-rich-text.js";
+export function findLastAssistantMessage(timeline) {
+    return findLastItemField(timeline, (entry) => entry.item?.type === "agentMessage", "text");
+}
+export function findLastCommand(timeline) {
+    return findLastItemField(timeline, (entry) => entry.item?.type === "commandExecution", "command");
+}
+export function findLastCommandOutput(timeline) {
+    return findLastItemField(timeline, (entry) => entry.item?.type === "commandExecution" && Boolean(entry.item?.output?.trim()), "output");
+}
+export function buildWatchDetailExportText(input) {
+    const lines = buildDetailLines({
+        ...input,
+        width: input.width ?? 100,
+    });
+    return `${lines.map(lineToPlainText).join("\n").trimEnd()}\n`;
+}
+export function writeTextToClipboard(text, stream = process.stderr) {
+    if (!stream.isTTY || text.length === 0) {
+        return false;
+    }
+    const encoded = Buffer.from(text, "utf8").toString("base64");
+    stream.write(`\u001b]52;c;${encoded}\u0007`);
+    return true;
+}
+export function exportWatchTextToTempFile(text, issueKey) {
+    const directory = mkdtempSync(join(tmpdir(), "patchrelay-watch-"));
+    const safeIssueKey = issueKey.replace(/[^a-zA-Z0-9._-]+/g, "-");
+    const filePath = join(directory, `${safeIssueKey || "issue"}-transcript.txt`);
+    writeFileSync(filePath, text, "utf8");
+    return filePath;
+}
+export function openTextInPager(text, stream = process.stderr) {
+    if (!stream.isTTY) {
+        return { ok: false, reason: "interactive TTY required" };
+    }
+    const streamWithFd = stream;
+    if (typeof streamWithFd.fd !== "number") {
+        return { ok: false, reason: "TTY stream fd unavailable" };
+    }
+    const pagerCommand = process.env.PAGER?.trim() || "less -R";
+    stream.write("\u001b[?1049l");
+    try {
+        const result = spawnSync("/bin/sh", ["-lc", pagerCommand], {
+            input: text,
+            stdio: ["pipe", streamWithFd.fd, streamWithFd.fd],
+        });
+        if (result.error) {
+            return { ok: false, reason: result.error.message };
+        }
+        if (typeof result.status === "number" && result.status !== 0) {
+            return { ok: false, reason: `${pagerCommand} exited with status ${result.status}` };
+        }
+        return { ok: true };
+    }
+    finally {
+        stream.write("\u001b[?1049h\u001b[2J\u001b[H");
+    }
+}
+function findLastItemField(timeline, predicate, field) {
+    for (let index = timeline.length - 1; index >= 0; index -= 1) {
+        const entry = timeline[index];
+        if (!predicate(entry))
+            continue;
+        const value = entry.item?.[field];
+        if (typeof value === "string" && value.trim().length > 0) {
+            return value;
+        }
+    }
+    return null;
+}

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

@@ -1,8 +1,7 @@
-import { buildTimelineFromRehydration, appendFeedToTimeline, appendCodexItemToTimeline, completeCodexItemInTimeline, appendDeltaToTimelineItem, } from "./timeline-builder.js";
+import { reconcileTimelineFromRehydration, appendFeedToTimeline, appendCodexItemToTimeline, completeCodexItemInTimeline, appendDeltaToTimelineItem, } from "./timeline-builder.js";
 // ─── Array size caps (prevent OOM) ───────────────────────────────
 const MAX_TIMELINE_ENTRIES = 2000;
 const MAX_RAW_FEED_EVENTS = 2000;
-const MAX_FEED_EVENTS = 1000;
 function capArray(arr, max) {
     return arr.length > max ? arr.slice(arr.length - max) : arr;
 }
@@ -32,7 +31,6 @@ export const initialWatchState = {
     filter: "non-done",
     follow: true,
     ...DETAIL_INITIAL,
-    feedEvents: [],
 };
 const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
 function effectiveSessionState(issue) {
@@ -216,7 +214,7 @@ export function watchReducer(state, action) {
                 };
             }
         case "timeline-rehydrate": {
-            const timeline = buildTimelineFromRehydration(action.runs, action.feedEvents, action.liveThread, action.activeRunId);
+            const timeline = reconcileTimelineFromRehydration(state.timeline, action.runs, action.feedEvents, action.liveThread, action.activeRunId);
             const activeRun = action.runs.find((r) => r.id === action.activeRunId);
             return {
                 ...state,
@@ -243,14 +241,6 @@ export function watchReducer(state, action) {
                     ...state,
                     ...detailStateForPosition(state, maxDetailScrollOffset(state.detailContentRows, state.detailViewportRows), true),
                 };
-        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: capArray([...state.feedEvents, action.event], MAX_FEED_EVENTS) };
         case "switch-detail-tab":
             return { ...state, follow: true, ...DETAIL_INITIAL, detailTab: action.tab };
         default:

package/dist/factory-state.js

@@ -30,7 +30,7 @@ const TRANSITION_RULES = [
     // pr_closed during an active run is suppressed — Codex may reopen.
     // Without a guard match, the event produces no transition (undefined).
     { event: "pr_closed",
-        guard: (_, ctx) => ctx.activeRunId === undefined,
+        guard: (s, ctx) => ctx.activeRunId === undefined && !TERMINAL_STATES.has(s),
         to: "failed" },
     // ── PR lifecycle ───────────────────────────────────────────────
     { event: "pr_opened",