patchrelay 0.36.19 → 0.37.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.19",
-  "commit": "4022639921ea",
-  "builtAt": "2026-04-10T13:21:18.771Z"
+  "version": "0.37.0",
+  "commit": "e927a73f2d7b",
+  "builtAt": "2026-04-10T13:26:32.780Z"
 }

package/dist/cli/watch/App.js

@@ -1,11 +1,15 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useReducer, useMemo, useCallback, useState } from "react";
-import { Box, Text, useApp, useInput } from "ink";
+import { useReducer, useMemo, useCallback, useEffect, useRef, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
 import { watchReducer, initialWatchState, filterIssues } from "./watch-state.js";
 import { useWatchStream } from "./use-watch-stream.js";
 import { useDetailStream } from "./use-detail-stream.js";
 import { IssueListView } from "./IssueListView.js";
 import { IssueDetailView } from "./IssueDetailView.js";
+import { buildWatchDetailExportText, exportWatchTextToTempFile, findLastAssistantMessage, findLastCommand, findLastCommandOutput, openTextInPager, writeTextToClipboard, } from "./watch-actions.js";
+import { measureRenderedTextRows } from "./layout-measure.js";
+import { PROMPT_COMPOSER_HINT, measurePromptComposerRows } from "./prompt-layout.js";
+import { clearTransientStatus, defaultTimerApi, setPersistentStatus, showTransientStatus } from "./transient-status.js";
 async function postPrompt(baseUrl, issueKey, text, bearerToken) {
     const headers = { "content-type": "application/json" };
     if (bearerToken)
@@ -61,31 +65,53 @@ async function postRetry(baseUrl, issueKey, bearerToken) {
 }
 export function App({ baseUrl, bearerToken, initialIssueKey }) {
     const { exit } = useApp();
+    const { stdout } = useStdout();
     const [state, dispatch] = useReducer(watchReducer, {
         ...initialWatchState,
         ...(initialIssueKey ? { view: "detail", activeDetailKey: 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);
     useWatchStream({ baseUrl, bearerToken, dispatch, active: !frozen });
     useDetailStream({ baseUrl, bearerToken, issueKey: state.activeDetailKey, dispatch, active: !frozen });
     const [promptMode, setPromptMode] = useState(false);
     const [promptBuffer, setPromptBuffer] = useState("");
+    const [promptCursor, setPromptCursor] = useState(0);
+    const [promptHistory, setPromptHistory] = useState([]);
+    const [promptHistoryIndex, setPromptHistoryIndex] = useState(null);
+    const [promptDraftBeforeHistory, setPromptDraftBeforeHistory] = useState("");
+    const [promptStatus, setPromptStatus] = useState(null);
+    const promptStatusController = useRef({ timer: null });
+    const activeIssue = state.issues.find((issue) => issue.issueKey === state.activeDetailKey);
+    const showStatus = useCallback((message) => {
+        showTransientStatus(promptStatusController.current, message, setPromptStatus, defaultTimerApi);
+    }, []);
+    const showPersistentStatus = useCallback((message) => {
+        setPersistentStatus(promptStatusController.current, message, setPromptStatus, defaultTimerApi);
+    }, []);
+    useEffect(() => () => {
+        clearTransientStatus(promptStatusController.current, defaultTimerApi);
+    }, []);
+    const resetPromptComposer = useCallback(() => {
+        setPromptMode(false);
+        setPromptBuffer("");
+        setPromptCursor(0);
+        setPromptHistoryIndex(null);
+        setPromptDraftBeforeHistory("");
+    }, []);
     const handleRetry = useCallback(() => {
         if (!state.activeDetailKey)
             return;
-        setPromptStatus("retrying...");
+        showPersistentStatus("retrying...");
         void postRetry(baseUrl, state.activeDetailKey, bearerToken).then((result) => {
-            setPromptStatus(result.ok ? "retry queued" : `retry failed: ${result.reason ?? "unknown"}`);
-            setTimeout(() => setPromptStatus(null), 3000);
+            showStatus(result.ok ? "retry queued" : `retry failed: ${result.reason ?? "unknown"}`);
         });
-    }, [baseUrl, bearerToken, state.activeDetailKey]);
-    const [promptStatus, setPromptStatus] = useState(null);
+    }, [baseUrl, bearerToken, showPersistentStatus, showStatus, state.activeDetailKey]);
     const handlePromptSubmit = useCallback(() => {
         const text = promptBuffer.trim();
         if (!state.activeDetailKey || !text) {
-            setPromptMode(false);
-            setPromptBuffer("");
+            resetPromptComposer();
             return;
         }
         // Add synthetic userMessage to timeline immediately
@@ -94,36 +120,184 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             method: "item/started",
             params: { item: { id: `prompt-${Date.now()}`, type: "userMessage", status: "completed", text } },
         });
-        setPromptMode(false);
-        setPromptBuffer("");
-        setPromptStatus("sending...");
+        setPromptHistory((history) => {
+            const next = history.at(-1) === text ? history : [...history, text];
+            return next.slice(-20);
+        });
+        resetPromptComposer();
+        showPersistentStatus("sending...");
         void postPrompt(baseUrl, state.activeDetailKey, text, bearerToken).then((result) => {
             if (result.delivered) {
-                setPromptStatus("delivered");
+                showStatus("delivered");
             }
             else if (result.queued) {
-                setPromptStatus("queued for next run");
+                showStatus("queued for next run");
             }
             else if (result.reason) {
-                setPromptStatus(`failed: ${result.reason}`);
+                showStatus(`failed: ${result.reason}`);
             }
-            setTimeout(() => setPromptStatus(null), 3000);
         });
-    }, [baseUrl, bearerToken, state.activeDetailKey, promptBuffer]);
+    }, [baseUrl, bearerToken, dispatch, promptBuffer, resetPromptComposer, showPersistentStatus, showStatus, state.activeDetailKey]);
+    const withActiveIssueExport = useCallback(() => {
+        if (!activeIssue)
+            return null;
+        return {
+            issue: activeIssue,
+            timeline: state.timeline,
+            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,
+        };
+    }, [
+        activeIssue,
+        state.activeRunId,
+        state.activeRunStartedAt,
+        state.detailTab,
+        state.diffSummary,
+        state.issueContext,
+        state.plan,
+        state.rawFeedEvents,
+        state.rawRuns,
+        state.timeline,
+        state.tokenUsage,
+    ]);
+    const handleCopyLastAssistant = useCallback(() => {
+        const text = findLastAssistantMessage(state.timeline);
+        if (!text) {
+            showStatus("no assistant message to copy");
+            return;
+        }
+        showStatus(writeTextToClipboard(text) ? "copied assistant message" : "clipboard unavailable");
+    }, [showStatus, state.timeline]);
+    const handleCopyLastCommand = useCallback(() => {
+        const text = findLastCommand(state.timeline);
+        if (!text) {
+            showStatus("no command to copy");
+            return;
+        }
+        showStatus(writeTextToClipboard(text) ? "copied last command" : "clipboard unavailable");
+    }, [showStatus, state.timeline]);
+    const handleCopyLastCommandOutput = useCallback(() => {
+        const text = findLastCommandOutput(state.timeline);
+        if (!text) {
+            showStatus("no command output to copy");
+            return;
+        }
+        showStatus(writeTextToClipboard(text) ? "copied command output" : "clipboard unavailable");
+    }, [showStatus, state.timeline]);
+    const handleExportTranscript = useCallback(() => {
+        const exportInput = withActiveIssueExport();
+        if (!exportInput)
+            return;
+        const text = buildWatchDetailExportText(exportInput);
+        const filePath = exportWatchTextToTempFile(text, exportInput.issue.issueKey ?? exportInput.issue.projectId);
+        showStatus(`exported transcript: ${filePath}`);
+    }, [showStatus, withActiveIssueExport]);
+    const handleOpenTranscriptInPager = useCallback(() => {
+        const exportInput = withActiveIssueExport();
+        if (!exportInput)
+            return;
+        const text = buildWatchDetailExportText(exportInput);
+        const result = openTextInPager(text);
+        if (result.ok) {
+            showStatus("opened transcript in pager");
+            return;
+        }
+        const filePath = exportWatchTextToTempFile(text, exportInput.issue.issueKey ?? exportInput.issue.projectId);
+        showStatus(`pager failed, exported transcript: ${filePath}`);
+    }, [showStatus, withActiveIssueExport]);
+    const insertPromptText = useCallback((text) => {
+        setPromptBuffer((buffer) => `${buffer.slice(0, promptCursor)}${text}${buffer.slice(promptCursor)}`);
+        setPromptCursor((cursor) => cursor + text.length);
+        setPromptHistoryIndex(null);
+    }, [promptCursor]);
+    const movePromptCursor = useCallback((delta) => {
+        setPromptCursor((cursor) => Math.max(0, Math.min(promptBuffer.length, cursor + delta)));
+    }, [promptBuffer.length]);
+    const recallPromptHistory = useCallback((direction) => {
+        if (promptHistory.length === 0)
+            return;
+        if (direction === "older") {
+            if (promptHistoryIndex === null) {
+                setPromptDraftBeforeHistory(promptBuffer);
+                const nextIndex = promptHistory.length - 1;
+                const next = promptHistory[nextIndex] ?? "";
+                setPromptHistoryIndex(nextIndex);
+                setPromptBuffer(next);
+                setPromptCursor(next.length);
+                return;
+            }
+            const nextIndex = Math.max(0, promptHistoryIndex - 1);
+            const next = promptHistory[nextIndex] ?? "";
+            setPromptHistoryIndex(nextIndex);
+            setPromptBuffer(next);
+            setPromptCursor(next.length);
+            return;
+        }
+        if (promptHistoryIndex === null)
+            return;
+        if (promptHistoryIndex >= promptHistory.length - 1) {
+            setPromptHistoryIndex(null);
+            setPromptBuffer(promptDraftBeforeHistory);
+            setPromptCursor(promptDraftBeforeHistory.length);
+            return;
+        }
+        const nextIndex = promptHistoryIndex + 1;
+        const next = promptHistory[nextIndex] ?? "";
+        setPromptHistoryIndex(nextIndex);
+        setPromptBuffer(next);
+        setPromptCursor(next.length);
+    }, [promptBuffer, promptDraftBeforeHistory, promptHistory, promptHistoryIndex]);
     useInput((input, key) => {
         if (promptMode) {
             if (key.escape) {
-                setPromptMode(false);
-                setPromptBuffer("");
+                resetPromptComposer();
+            }
+            else if (key.ctrl && input === "n") {
+                insertPromptText("\n");
             }
             else if (key.return) {
                 handlePromptSubmit();
             }
-            else if (key.backspace || key.delete) {
-                setPromptBuffer((b) => b.slice(0, -1));
+            else if (key.leftArrow) {
+                movePromptCursor(-1);
+            }
+            else if (key.rightArrow) {
+                movePromptCursor(1);
+            }
+            else if (key.home) {
+                setPromptCursor(0);
+            }
+            else if (key.end) {
+                setPromptCursor(promptBuffer.length);
+            }
+            else if (key.upArrow) {
+                recallPromptHistory("older");
+            }
+            else if (key.downArrow) {
+                recallPromptHistory("newer");
+            }
+            else if (key.backspace) {
+                if (promptCursor > 0) {
+                    setPromptBuffer((buffer) => `${buffer.slice(0, promptCursor - 1)}${buffer.slice(promptCursor)}`);
+                    setPromptCursor((cursor) => Math.max(0, cursor - 1));
+                    setPromptHistoryIndex(null);
+                }
+            }
+            else if (key.delete) {
+                if (promptCursor < promptBuffer.length) {
+                    setPromptBuffer((buffer) => `${buffer.slice(0, promptCursor)}${buffer.slice(promptCursor + 1)}`);
+                    setPromptHistoryIndex(null);
+                }
             }
             else if (input && !key.ctrl && !key.meta) {
-                setPromptBuffer((b) => b + input);
+                insertPromptText(input);
             }
             return;
         }
@@ -164,16 +338,31 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             }
             else if (input === "p") {
                 setPromptMode(true);
+                setPromptCursor(promptBuffer.length);
             }
             else if (input === "s") {
                 if (state.activeDetailKey) {
-                    setPromptStatus("stopping...");
+                    showPersistentStatus("stopping...");
                     void postStop(baseUrl, state.activeDetailKey, bearerToken).then((result) => {
-                        setPromptStatus(result.ok ? "stop sent" : `stop failed: ${result.reason ?? "unknown"}`);
-                        setTimeout(() => setPromptStatus(null), 3000);
+                        showStatus(result.ok ? "stop sent" : `stop failed: ${result.reason ?? "unknown"}`);
                     });
                 }
             }
+            else if (input === "y") {
+                handleCopyLastAssistant();
+            }
+            else if (input === "c") {
+                handleCopyLastCommand();
+            }
+            else if (input === "o") {
+                handleCopyLastCommandOutput();
+            }
+            else if (input === "e") {
+                handleExportTranscript();
+            }
+            else if (input === "v") {
+                handleOpenTranscriptInPager();
+            }
             else if (input === "h") {
                 dispatch({ type: "switch-detail-tab", tab: "history" });
             }
@@ -206,7 +395,17 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             }
         }
     });
-    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: 1 + ((promptMode || promptStatus) ? 1 : 0), onLayoutChange: (viewportRows, contentRows) => {
+    const reservedRows = 1 + (promptMode
+        ? measurePromptComposerRows(promptBuffer, promptCursor, width)
+        : 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) => {
                         dispatch({ type: "detail-layout-updated", viewportRows, contentRows });
-                    } }), promptMode && (_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "prompt> " }), _jsx(Text, { children: promptBuffer }), _jsx(Text, { dimColor: true, children: "_" })] })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : null }));
+                    } }), promptMode && (_jsx(PromptComposer, { buffer: promptBuffer, cursor: promptCursor })), promptStatus && !promptMode && (_jsx(Text, { dimColor: true, children: promptStatus }))] })) : null }));
+}
+function PromptComposer({ buffer, cursor }) {
+    const withCursor = `${buffer.slice(0, cursor)}|${buffer.slice(cursor)}`;
+    const lines = withCursor.split("\n");
+    return (_jsxs(Box, { flexDirection: "column", children: [lines.map((line, index) => (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: index === 0 ? "prompt> " : "        " }), _jsx(Text, { children: line })] }, `prompt-line-${index}`))), _jsx(Text, { dimColor: true, children: PROMPT_COMPOSER_HINT })] }));
 }

package/dist/cli/watch/HelpBar.js

@@ -1,18 +1,27 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-export function HelpBar({ view, follow, detailTab }) {
-    let text;
+export function buildHelpBarText(view, follow, detailTab) {
     if (view === "detail") {
         const tabHint = detailTab === "history" ? "t: timeline" : "h: history";
-        text = [tabHint, "j/k: scroll", "Ctrl-U/Ctrl-D: page", "[ ]: issue", "Home/End: jump", `f: live ${follow ? "on" : "off"}`, "p: prompt", "s: stop", "r: retry"]
+        return [
+            tabHint,
+            "j/k: scroll",
+            "Ctrl-U/Ctrl-D: page",
+            "[ ]: issue",
+            "Home/End: jump",
+            `f: live ${follow ? "on" : "off"}`,
+            "p: prompt",
+            "y/c/o: copy",
+            "v/e: transcript",
+            "s: stop",
+            "r: retry",
+        ]
             .filter(Boolean)
             .join("  ");
     }
-    else if (view === "feed") {
-        text = "Legacy feed view  Esc: back";
-    }
-    else {
-        text = "Enter: detail  Tab: filter";
-    }
+    return "Enter: detail  Tab: filter";
+}
+export function HelpBar({ view, follow, detailTab }) {
+    const text = buildHelpBarText(view, follow, detailTab);
     return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/cli/watch/IssueDetailView.js

@@ -1,19 +1,26 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useEffect, useMemo, useReducer } from "react";
 import { Box, Text, useStdout } from "ink";
-import { HelpBar } from "./HelpBar.js";
+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, }) {
-    const [, tick] = useReducer((value) => value + 1, 0);
     const { stdout } = useStdout();
     const width = Math.max(20, stdout?.columns ?? 80);
     const totalRows = stdout?.rows ?? 24;
-    const footerRows = 1 + (unreadBelow > 0 ? 1 : 0);
+    const footerRows = useMemo(() => {
+        const statusRows = measureRenderedTextRows(buildDetailStatusText({
+            follow,
+            unreadBelow,
+            activeRunStartedAt,
+            connected,
+            lastServerMessageAt,
+        }), width);
+        const helpRows = measureRenderedTextRows(buildHelpBarText("detail", follow, detailTab), width);
+        return statusRows + helpRows;
+    }, [activeRunStartedAt, connected, detailTab, follow, lastServerMessageAt, unreadBelow, width]);
     const viewportRows = Math.max(4, totalRows - reservedRows - footerRows);
-    useEffect(() => {
-        const id = setInterval(tick, 1_000);
-        return () => clearInterval(id);
-    }, []);
     const lines = useMemo(() => {
         if (!issue) {
             return [{ key: "loading", segments: [{ text: "Loading issue…", dimColor: true }] }];
@@ -30,9 +37,6 @@ export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadB
             detailTab,
             rawRuns,
             rawFeedEvents,
-            follow,
-            connected,
-            lastServerMessageAt,
             width,
         });
     }, [
@@ -47,9 +51,6 @@ export function IssueDetailView({ issue, timeline, follow, scrollOffset, unreadB
         detailTab,
         rawRuns,
         rawFeedEvents,
-        follow,
-        connected,
-        lastServerMessageAt,
         width,
     ]);
     useEffect(() => {
@@ -59,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}`))), unreadBelow > 0 && (_jsx(Text, { color: "yellow", children: `${unreadBelow} below · End jumps back to live` })), _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 })] }));
 }
 function RenderedLine({ line }) {
     if (line.segments.length === 0) {
@@ -69,3 +70,20 @@ function RenderedLine({ line }) {
         // eslint-disable-next-line react/no-array-index-key
         , { ...(segment.color ? { color: segment.color } : {}), ...(segment.dimColor ? { dimColor: true } : {}), ...(segment.bold ? { bold: true } : {}), children: segment.text }, `${line.key}-${index}`))) }));
 }
+function DetailStatusStrip({ follow, unreadBelow, activeRunStartedAt, connected, lastServerMessageAt, }) {
+    const [tick, bumpTick] = useReducer((value) => value + 1, 0);
+    useEffect(() => {
+        const id = setInterval(bumpTick, 1_000);
+        return () => clearInterval(id);
+    }, []);
+    const segments = useMemo(() => buildDetailStatusSegments({
+        follow,
+        unreadBelow,
+        activeRunStartedAt,
+        connected,
+        lastServerMessageAt,
+    }), [activeRunStartedAt, connected, follow, lastServerMessageAt, tick, unreadBelow]);
+    return (_jsx(Text, { children: segments.map((segment, index) => (_jsx(Text
+        // eslint-disable-next-line react/no-array-index-key
+        , { ...(segment.color ? { color: segment.color } : {}), ...(segment.dimColor ? { dimColor: true } : {}), ...(segment.bold ? { bold: true } : {}), children: segment.text }, `detail-status-${index}`))) }));
+}

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

@@ -2,7 +2,6 @@ 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 +84,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 +244,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,
@@ -462,12 +451,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": {
@@ -598,10 +581,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/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/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/package.json

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

package/dist/cli/watch/ItemLine.js

@@ -1,80 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-function cleanCommand(raw) {
-    const bashMatch = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+['"](.+?)['"]$/s);
-    if (bashMatch?.[1])
-        return bashMatch[1];
-    const bashMatch2 = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+"(.+?)"$/s);
-    if (bashMatch2?.[1])
-        return bashMatch2[1];
-    return raw;
-}
-function summarizeFileChange(item) {
-    const count = item.changes?.length ?? 0;
-    return `updated ${count} file${count === 1 ? "" : "s"}`;
-}
-function summarizeToolCall(item) {
-    return `used ${item.toolName ?? item.type}`;
-}
-function summarizeText(item) {
-    return (item.text ?? "").replace(/\s+/g, " ").trim();
-}
-function itemPrefix(item) {
-    if (item.type === "commandExecution")
-        return "$ ";
-    return "";
-}
-function formatItemDuration(ms) {
-    if (ms === undefined || ms === null)
-        return "";
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 1)
-        return "";
-    if (seconds < 60)
-        return `  ${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    return `  ${minutes}m`;
-}
-function itemText(item) {
-    switch (item.type) {
-        case "agentMessage":
-        case "plan":
-        case "reasoning":
-            return summarizeText(item);
-        case "commandExecution": {
-            const cmd = cleanCommand(item.command ?? "?");
-            const exit = item.exitCode !== undefined && item.exitCode !== null && item.exitCode !== 0
-                ? `  exit ${item.exitCode}` : "";
-            const dur = formatItemDuration(item.durationMs);
-            return `${cmd}${exit}${dur}`;
-        }
-        case "fileChange":
-            return summarizeFileChange(item);
-        case "mcpToolCall":
-        case "dynamicToolCall": {
-            const dur = formatItemDuration(item.durationMs);
-            return `${summarizeToolCall(item)}${dur}`;
-        }
-        case "userMessage":
-            return `you: ${summarizeText(item)}`;
-        default:
-            return item.text ? summarizeText(item) : item.type;
-    }
-}
-function itemColor(item) {
-    if (item.status === "failed" || item.status === "declined")
-        return "red";
-    if (item.status === "inProgress")
-        return "yellow";
-    if (item.type === "userMessage")
-        return "yellow";
-    return undefined;
-}
-export function ItemLine({ item }) {
-    const text = itemText(item);
-    if (!text) {
-        return _jsx(_Fragment, {});
-    }
-    const color = itemColor(item);
-    return (_jsxs(Box, { flexDirection: "column", gap: 1, children: [_jsxs(Text, { wrap: "wrap", bold: item.type === "agentMessage", ...(color ? { color } : {}), children: [itemPrefix(item), text] }), item.output && item.status === "inProgress" && (_jsx(Box, { paddingLeft: 2, children: _jsx(Text, { dimColor: true, wrap: "wrap", children: item.output.split("\n").filter(Boolean).at(-1) ?? "" }) }))] }));
-}

package/dist/cli/watch/Timeline.js

@@ -1,22 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { Box, Static, Text, useStdout } from "ink";
-import { buildTimelineRows } from "./timeline-presentation.js";
-import { TimelineRow } from "./TimelineRow.js";
-const ACTIVE_TAIL = 8;
-export function Timeline({ entries, follow }) {
-    const { stdout } = useStdout();
-    const rows = stdout?.rows ?? 24;
-    const maxActive = Math.max(ACTIVE_TAIL, rows - 12);
-    const displayRows = useMemo(() => buildTimelineRows(entries), [entries]);
-    // Always cap the rendered entries to prevent OOM/WASM crashes.
-    // In follow mode: older entries go to Static (terminal scrollback).
-    // Without follow: show last maxActive entries only.
-    const splitIndex = Math.max(0, displayRows.length - maxActive);
-    const finalized = follow ? displayRows.slice(0, splitIndex) : [];
-    const active = displayRows.slice(splitIndex);
-    if (displayRows.length === 0) {
-        return _jsx(Text, { dimColor: true, children: "No timeline events yet." });
-    }
-    return (_jsxs(Box, { flexDirection: "column", children: [finalized.length > 0 && (_jsx(Static, { items: finalized, children: (entry) => _jsx(TimelineRow, { entry: entry }, entry.id) })), active.map((entry) => (_jsx(TimelineRow, { entry: entry }, entry.id)))] }));
-}

package/dist/cli/watch/TimelineRow.js

@@ -1,77 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { ItemLine } from "./ItemLine.js";
-function formatDuration(startedAt, endedAt) {
-    const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
-    const seconds = Math.floor(ms / 1000);
-    if (seconds < 60)
-        return `${seconds}s`;
-    const minutes = Math.floor(seconds / 60);
-    const s = seconds % 60;
-    return `${minutes}m ${String(s).padStart(2, "0")}s`;
-}
-const CHECK_SYMBOLS = { passed: "\u2713", failed: "\u2717", pending: "\u25cf" };
-const CHECK_COLORS = { passed: "green", failed: "red", pending: "yellow" };
-const RUN_LABELS = {
-    implementation: "implement",
-    ci_repair: "ci fix",
-    review_fix: "review fix",
-    branch_upkeep: "branch upkeep",
-    queue_repair: "merge fix",
-};
-function runDotColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "failed")
-        return "red";
-    if (status === "released")
-        return "magenta";
-    if (status === "running")
-        return "yellow";
-    return "white";
-}
-function detailColor(detail) {
-    if (detail.tone === "command")
-        return "white";
-    if (detail.tone === "user")
-        return "yellow";
-    return undefined;
-}
-function detailPrefix(detail) {
-    if (detail.tone === "command")
-        return "$ ";
-    return "";
-}
-function FeedRow({ entry }) {
-    const label = entry.feed.status ?? entry.feed.feedKind;
-    const repeatSuffix = entry.repeatCount && entry.repeatCount > 1 ? ` \u00d7${entry.repeatCount}` : "";
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: "cyan", children: "\u25cf" }), _jsx(Text, { color: "cyan", children: ` ${label}` }), _jsx(Text, { dimColor: true, children: `  ${entry.feed.summary}${repeatSuffix}` })] }));
-}
-function RunRow({ entry, }) {
-    const run = entry.run;
-    const dotColor = runDotColor(run.status);
-    const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : undefined;
-    const showItems = entry.items.length > 0;
-    const showDetails = !showItems && entry.details.length > 0;
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: dotColor, children: "\u25cf" }), _jsx(Text, { bold: true, color: "yellow", children: ` ${RUN_LABELS[run.runType] ?? run.runType}` }), _jsx(Text, { bold: true, color: dotColor, children: `  ${run.status}` }), duration ? _jsx(Text, { dimColor: true, children: `  ${duration}` }) : null] }), showItems && entry.items.map((itemEntry, index) => (_jsx(Box, { paddingLeft: 2, children: _jsx(ItemLine, { item: itemEntry.item }) }, `${entry.id}-item-${index}`))), showDetails && entry.details.map((detail, index) => (_jsx(Box, { paddingLeft: 2, children: _jsxs(Text, { wrap: "wrap", ...(detailColor(detail) ? { color: detailColor(detail) } : { dimColor: true }), bold: detail.tone === "message", children: [detailPrefix(detail), detail.text] }) }, `${entry.id}-detail-${index}`)))] }));
-}
-function ItemRow({ entry, }) {
-    return (_jsx(Box, { paddingLeft: 2, children: _jsx(ItemLine, { item: entry.item }) }));
-}
-function CIChecksRow({ entry }) {
-    const ci = entry.ciChecks;
-    const dotColor = CHECK_COLORS[ci.overall] ?? "white";
-    return (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: dotColor, children: "\u25cf" }), _jsx(Text, { color: dotColor, bold: true, children: ` checks` }), _jsx(Text, { children: `  ` }), ci.checks.map((check, i) => (_jsxs(Text, { children: [i > 0 ? _jsx(Text, { children: `  ` }) : null, _jsx(Text, { color: CHECK_COLORS[check.status] ?? "white", children: CHECK_SYMBOLS[check.status] ?? " " }), _jsx(Text, { dimColor: true, children: ` ${check.name}` })] }, `c-${i}`)))] }));
-}
-export function TimelineRow({ entry }) {
-    switch (entry.kind) {
-        case "feed":
-            return _jsx(FeedRow, { entry: entry });
-        case "run":
-            return _jsx(RunRow, { entry: entry });
-        case "item":
-            return _jsx(ItemRow, { entry: entry });
-        case "ci-checks":
-            return _jsx(CIChecksRow, { entry: entry });
-    }
-}