patchrelay 0.36.18 → 0.37.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.36.18",
-  "commit": "2d0aa4ca856e",
-  "builtAt": "2026-04-10T12:35:59.590Z"
+  "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);
+}