patchrelay 0.25.2 → 0.25.4

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.25.2",
-  "commit": "9b4ed34e9645",
-  "builtAt": "2026-03-26T19:10:03.366Z"
+  "version": "0.25.4",
+  "commit": "b0b9d22851d4",
+  "builtAt": "2026-03-26T20:41:12.209Z"
 }

package/dist/cli/watch/App.js

@@ -177,6 +177,9 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             else if (input === "t") {
                 dispatch({ type: "switch-detail-tab", tab: "timeline" });
             }
+            else if (input === "v") {
+                dispatch({ type: "toggle-timeline-mode" });
+            }
             else if (input === "j" || key.downArrow) {
                 dispatch({ type: "detail-navigate", direction: "next", filtered });
             }
@@ -190,5 +193,5 @@ 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, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, 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 }), 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 }))] })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, allIssues: state.issues, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : state.view === "detail" ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, activeRunId: state.activeRunId, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext, detailTab: state.detailTab, timelineMode: state.timelineMode, rawRuns: state.rawRuns, rawFeedEvents: state.rawFeedEvents }), 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 }))] })) : (_jsx(FeedView, { events: state.feedEvents, connected: state.connected })) }));
 }

package/dist/cli/watch/HelpBar.js

@@ -5,11 +5,14 @@ const HELP_TEXT = {
     detail: "",
     feed: "Esc: list  q: quit",
 };
-export function HelpBar({ view, follow, detailTab }) {
+export function HelpBar({ view, follow, detailTab, timelineMode }) {
     let text;
     if (view === "detail") {
         const tabHint = detailTab === "history" ? "t: timeline" : "h: history";
-        text = `${tabHint}  j/k: prev/next  Esc: list  f: follow ${follow ? "on" : "off"}  p: prompt  s: stop  r: retry  q: quit`;
+        const timelineHint = detailTab === "timeline" ? `v: ${timelineMode === "verbose" ? "compact" : "verbose"}` : undefined;
+        text = [tabHint, timelineHint, "j/k: prev/next", "Esc: list", `f: follow ${follow ? "on" : "off"}`, "p: prompt", "s: stop", "r: retry", "q: quit"]
+            .filter(Boolean)
+            .join("  ");
     }
     else {
         text = HELP_TEXT[view];

package/dist/cli/watch/IssueDetailView.js

@@ -24,9 +24,9 @@ function ElapsedTime({ startedAt }) {
     const seconds = elapsed % 60;
     return _jsxs(Text, { dimColor: true, children: [minutes, "m ", String(seconds).padStart(2, "0"), "s"] });
 }
-export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, rawRuns, rawFeedEvents, }) {
+export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, timelineMode, rawRuns, rawFeedEvents, }) {
     if (!issue) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode })] }));
     }
     const key = issue.issueKey ?? issue.projectId;
     const meta = [];
@@ -37,5 +37,5 @@ export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, a
     if (issueContext?.runCount)
         meta.push(`${issueContext.runCount} runs`);
     const history = useMemo(() => buildStateHistory(rawRuns, rawFeedEvents, issue.factoryState, activeRunId), [rawRuns, rawFeedEvents, issue.factoryState, activeRunId]);
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), follow && _jsx(Text, { color: "yellow", children: "follow" })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`))) })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow }) })] })) : (_jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { bold: true, children: key }), _jsx(Text, { color: "cyan", children: issue.factoryState }), issue.activeRunType && _jsx(Text, { color: "yellow", children: issue.activeRunType }), issue.prNumber !== undefined && _jsxs(Text, { dimColor: true, children: ["#", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt }), meta.length > 0 && _jsx(Text, { dimColor: true, children: meta.join("  ") }), detailTab === "timeline" && _jsx(Text, { dimColor: true, children: timelineMode }), follow && _jsx(Text, { color: "yellow", children: "follow" })] }), issue.title && _jsx(Text, { children: issue.title }), detailTab === "timeline" ? (_jsxs(_Fragment, { children: [plan && plan.length > 0 && (_jsx(Box, { flexDirection: "column", marginTop: 1, children: plan.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsxs(Text, { color: planStepColor(entry.status), children: ["[", planStepSymbol(entry.status), "]"] }), _jsx(Text, { children: entry.step })] }, `plan-${i}`))) })), _jsx(Box, { marginTop: 1, flexDirection: "column", children: _jsx(Timeline, { entries: timeline, follow: follow, mode: timelineMode }) })] })) : (_jsx(StateHistoryView, { history: history, plan: plan, activeRunId: activeRunId })), _jsx(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab, timelineMode: timelineMode }) })] }));
 }

package/dist/cli/watch/ItemLine.js

@@ -1,92 +1,66 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-const STATUS_SYMBOL = {
-    completed: "\u2713",
-    failed: "\u2717",
-    declined: "\u2717",
-    inProgress: "\u25cf",
-};
-function statusChar(status) {
-    return STATUS_SYMBOL[status] ?? " ";
-}
-function statusColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "failed" || status === "declined")
-        return "red";
-    if (status === "inProgress")
-        return "yellow";
-    return "white";
-}
 function truncate(text, max) {
-    const line = text.replace(/\n/g, " ").trim();
-    return line.length > max ? `${line.slice(0, max - 3)}...` : line;
-}
-function renderAgentMessage(item) {
-    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "message: " }), _jsx(Text, { wrap: "wrap", children: item.text ?? "" })] }));
+    const line = text.replace(/\s+/g, " ").trim();
+    return line.length > max ? `${line.slice(0, Math.max(0, max - 3))}...` : line;
 }
 function cleanCommand(raw) {
-    // Strip /bin/bash -lc '...' wrapper — show the inner command
     const bashMatch = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+['"](.+?)['"]$/s);
     if (bashMatch?.[1])
         return bashMatch[1];
-    // Strip /bin/bash -lc "..." (double quotes)
     const bashMatch2 = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+"(.+?)"$/s);
     if (bashMatch2?.[1])
         return bashMatch2[1];
     return raw;
 }
-function renderCommand(item) {
-    const cmd = cleanCommand(item.command ?? "?");
-    const exitCode = item.exitCode;
-    const exitLabel = exitCode !== undefined && exitCode !== 0 ? ` exit:${exitCode}` : "";
-    const duration = item.durationMs !== undefined ? ` ${(item.durationMs / 1000).toFixed(1)}s` : "";
-    const suffix = `${exitLabel}${duration}`;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { dimColor: true, children: "$ " }), _jsx(Text, { children: cmd }), exitLabel && _jsx(Text, { color: "red", children: exitLabel }), !exitLabel && suffix && _jsx(Text, { dimColor: true, children: suffix })] }), item.output && item.status === "inProgress" && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  ", item.output.split("\n").filter(Boolean).at(-1) ?? ""] }))] }));
-}
-function renderFileChange(item) {
+function summarizeFileChange(item) {
     const count = item.changes?.length ?? 0;
-    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "files: " }), _jsxs(Text, { children: [count, " change", count !== 1 ? "s" : ""] })] }));
+    return `updated ${count} file${count === 1 ? "" : "s"}`;
 }
-function renderToolCall(item) {
-    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "tool: " }), _jsx(Text, { children: item.toolName ?? item.type })] }));
+function summarizeToolCall(item) {
+    return `used ${item.toolName ?? item.type}`;
 }
-function renderPlan(item) {
-    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "plan: " }), _jsx(Text, { children: truncate(item.text ?? "", 120) })] }));
+function summarizeText(item) {
+    return truncate(item.text ?? "", 160);
 }
-function renderDefault(item) {
-    return (_jsxs(Text, { dimColor: true, children: [item.type, item.text ? `: ${truncate(item.text, 80)}` : ""] }));
+function itemPrefix(item) {
+    if (item.type === "commandExecution")
+        return "$ ";
+    return "";
 }
-export function ItemLine({ item, isLast }) {
-    const prefix = isLast ? "\u2514" : "\u251c";
-    let content;
+function itemText(item) {
     switch (item.type) {
         case "agentMessage":
-            content = renderAgentMessage(item);
-            break;
+        case "plan":
+        case "reasoning":
+            return summarizeText(item);
         case "commandExecution":
-            content = renderCommand(item);
-            break;
+            return truncate(cleanCommand(item.command ?? "?"), 140);
         case "fileChange":
-            content = renderFileChange(item);
-            break;
+            return summarizeFileChange(item);
         case "mcpToolCall":
         case "dynamicToolCall":
-            content = renderToolCall(item);
-            break;
-        case "plan":
-            content = renderPlan(item);
-            break;
-        case "userMessage": {
-            const userText = item.text?.trim();
-            if (!userText)
-                return _jsx(_Fragment, {});
-            content = (_jsxs(Text, { children: [_jsx(Text, { color: "yellow", children: "you: " }), _jsx(Text, { wrap: "wrap", children: userText })] }));
-            break;
-        }
+            return summarizeToolCall(item);
+        case "userMessage":
+            return `you: ${summarizeText(item)}`;
         default:
-            content = renderDefault(item);
-            break;
+            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, {});
     }
-    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [prefix, " "] }), _jsxs(Text, { color: statusColor(item.status), children: [statusChar(item.status), " "] }), content] }));
+    const color = itemColor(item);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { wrap: "wrap", ...(color ? { color } : {}), children: [itemPrefix(item), text] }), item.output && item.status === "inProgress" && (_jsx(Text, { dimColor: true, wrap: "truncate-end", children: truncate(item.output.split("\n").filter(Boolean).at(-1) ?? "", 120) }))] }));
 }

package/dist/cli/watch/Timeline.js

@@ -1,29 +1,24 @@
 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;
-function isFinalized(entry) {
-    if (entry.kind === "item" && entry.item?.status === "inProgress")
-        return false;
-    if (entry.kind === "run-start")
-        return false; // keep run-start in active area until run ends
-    return true;
-}
-export function Timeline({ entries, follow }) {
+export function Timeline({ entries, follow, mode }) {
     const { stdout } = useStdout();
     const rows = stdout?.rows ?? 24;
     const maxActive = Math.max(ACTIVE_TAIL, rows - 12);
+    const displayRows = useMemo(() => buildTimelineRows(entries, mode), [entries, mode]);
     // Split: finalized entries go to Static (terminal scrollback), active entries re-render
     const splitIndex = useMemo(() => {
         if (!follow)
             return 0; // follow OFF: everything in active area (re-renders)
         // Find the boundary: keep the last maxActive entries in the active area
-        return Math.max(0, entries.length - maxActive);
-    }, [entries.length, follow, maxActive]);
-    const finalized = entries.slice(0, splitIndex);
-    const active = entries.slice(splitIndex);
-    if (entries.length === 0) {
+        return Math.max(0, displayRows.length - maxActive);
+    }, [displayRows.length, follow, maxActive]);
+    const finalized = 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

@@ -11,7 +11,7 @@ function formatDuration(startedAt, endedAt) {
         return `${seconds}s`;
     const minutes = Math.floor(seconds / 60);
     const s = seconds % 60;
-    return `${minutes}m${s > 0 ? ` ${s}s` : ""}`;
+    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" };
@@ -21,34 +21,62 @@ const RUN_LABELS = {
     review_fix: "review fix",
     queue_repair: "merge fix",
 };
-function FeedRow({ entry }) {
-    const feed = entry.feed;
-    const label = feed.status ?? feed.feedKind;
-    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { color: "cyan", children: label.padEnd(14) }), _jsxs(Text, { children: [" ", feed.summary] })] }));
+function runStatusColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "failed")
+        return "red";
+    if (status === "released")
+        return "magenta";
+    if (status === "running")
+        return "yellow";
+    return "white";
 }
-function RunStartRow({ entry }) {
-    const run = entry.run;
-    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { bold: true, color: "yellow", children: (RUN_LABELS[run.runType] ?? run.runType).padEnd(14) }), _jsx(Text, { bold: true, children: " started" })] }));
+function runStatusLabel(status) {
+    if (status === "running")
+        return "running";
+    if (status === "released")
+        return "released";
+    return status;
+}
+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;
+    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { color: "cyan", children: label.padEnd(12) }), _jsxs(Text, { children: [" ", entry.feed.summary] })] }));
 }
-function RunEndRow({ entry }) {
+function RunRow({ entry }) {
     const run = entry.run;
-    const color = run.status === "completed" ? "green" : "red";
-    const dur = run.endedAt ? ` ${formatDuration(run.startedAt, run.endedAt)}` : "";
-    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { bold: true, color: color, children: (RUN_LABELS[run.runType] ?? run.runType).padEnd(14) }), _jsxs(Text, { bold: true, color: color, children: [" ", run.status] }), dur ? _jsx(Text, { dimColor: true, children: dur }) : null] }));
+    const color = runStatusColor(run.status);
+    const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : undefined;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { bold: true, color: "yellow", children: (RUN_LABELS[run.runType] ?? run.runType).padEnd(12) }), _jsxs(Text, { color: color, children: [" ", runStatusLabel(run.status)] }), duration ? _jsx(Text, { dimColor: true, children: ` ${duration}` }) : null] }), entry.details.map((detail, index) => (_jsxs(Box, { paddingLeft: 6, children: [_jsx(Text, { dimColor: true, children: "  " }), _jsxs(Text, { wrap: "wrap", ...(detailColor(detail) ? { color: detailColor(detail) } : {}), children: [detailPrefix(detail), detail.text] })] }, `${entry.id}-detail-${index}`)))] }));
 }
 function ItemRow({ entry }) {
-    return (_jsx(Box, { paddingLeft: 2, children: _jsx(ItemLine, { item: entry.item, isLast: false }) }));
+    return (_jsx(Box, { paddingLeft: 6, children: _jsx(ItemLine, { item: entry.item }) }));
 }
 function CIChecksRow({ entry }) {
     const ci = entry.ciChecks;
-    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { color: CHECK_COLORS[ci.overall] ?? "white", children: "checks".padEnd(14) }), _jsx(Text, { children: " " }), ci.checks.map((check, i) => (_jsxs(Text, { children: [_jsx(Text, { color: CHECK_COLORS[check.status] ?? "white", children: CHECK_SYMBOLS[check.status] ?? " " }), _jsxs(Text, { dimColor: true, children: [check.name, " "] })] }, `c-${i}`)))] }));
+    return (_jsxs(Box, { children: [_jsxs(Text, { dimColor: true, children: [formatTime(entry.at), " "] }), _jsx(Text, { color: CHECK_COLORS[ci.overall] ?? "white", children: "checks".padEnd(12) }), _jsx(Text, { children: " " }), ci.checks.map((check, i) => (_jsxs(Text, { children: [_jsx(Text, { color: CHECK_COLORS[check.status] ?? "white", children: CHECK_SYMBOLS[check.status] ?? " " }), _jsxs(Text, { dimColor: true, children: [check.name, " "] })] }, `c-${i}`)))] }));
 }
 export function TimelineRow({ entry }) {
     switch (entry.kind) {
-        case "feed": return _jsx(FeedRow, { entry: entry });
-        case "run-start": return _jsx(RunStartRow, { entry: entry });
-        case "run-end": return _jsx(RunEndRow, { entry: entry });
-        case "item": return _jsx(ItemRow, { entry: entry });
-        case "ci-checks": return _jsx(CIChecksRow, { entry: entry });
+        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 });
     }
 }

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

@@ -19,9 +19,14 @@ export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activ
                 run: { runType: run.runType, status: run.status, startedAt: run.startedAt, endedAt: run.endedAt },
             });
         }
-        // Items from completed run reports
-        if (run.report && run.id !== activeRunId) {
-            entries.push(...itemsFromReport(run.id, run.report, run.startedAt, run.endedAt));
+        // Items from completed run event history, with report fallback
+        if (run.id !== activeRunId) {
+            if (run.events && run.events.length > 0) {
+                entries.push(...itemsFromThreadEvents(run.id, run.events));
+            }
+            else if (run.report) {
+                entries.push(...itemsFromReport(run.id, run.report, run.startedAt, run.endedAt));
+            }
         }
     }
     // 2. Items from live thread (active run)
@@ -36,7 +41,10 @@ export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activ
         if (cmp !== 0)
             return cmp;
         // Within same timestamp: run-start before items, items before run-end
-        return kindOrder(a.kind) - kindOrder(b.kind);
+        const kindCmp = kindOrder(a.kind) - kindOrder(b.kind);
+        if (kindCmp !== 0)
+            return kindCmp;
+        return a.id.localeCompare(b.id);
     });
     return entries;
 }
@@ -178,6 +186,169 @@ function materializeItem(item) {
             return base;
     }
 }
+function itemsFromThreadEvents(runId, events) {
+    const entries = [];
+    for (const event of events) {
+        const params = event.parsedEvent;
+        if (!params)
+            continue;
+        switch (event.method) {
+            case "item/started": {
+                const item = materializeNotificationItem(params.item);
+                if (!item)
+                    break;
+                entries.push({
+                    id: `event-${event.id}-item-${item.id}`,
+                    at: event.createdAt,
+                    kind: "item",
+                    runId,
+                    item,
+                });
+                break;
+            }
+            case "item/completed": {
+                const item = materializeNotificationItem(params.item);
+                if (!item)
+                    break;
+                const existing = findTimelineItem(entries, item.id);
+                if (existing) {
+                    existing.item = mergeDefinedItemFields(existing.item, item);
+                }
+                else {
+                    entries.push({
+                        id: `event-${event.id}-item-${item.id}`,
+                        at: event.createdAt,
+                        kind: "item",
+                        runId,
+                        item,
+                    });
+                }
+                break;
+            }
+            case "item/agentMessage/delta":
+            case "item/plan/delta":
+            case "item/reasoning/summaryTextDelta": {
+                const itemId = typeof params.itemId === "string" ? params.itemId : undefined;
+                const delta = typeof params.delta === "string" ? params.delta : undefined;
+                if (!itemId || !delta)
+                    break;
+                const existing = findTimelineItem(entries, itemId);
+                const target = existing ?? createReplayPlaceholder(entries, runId, event.createdAt, event.id, itemId, inferItemTypeFromDeltaMethod(event.method));
+                target.item = {
+                    ...target.item,
+                    text: `${target.item?.text ?? ""}${delta}`,
+                };
+                break;
+            }
+            case "item/commandExecution/outputDelta": {
+                const itemId = typeof params.itemId === "string" ? params.itemId : undefined;
+                const delta = typeof params.delta === "string" ? params.delta : undefined;
+                if (!itemId || !delta)
+                    break;
+                const existing = findTimelineItem(entries, itemId);
+                const target = existing ?? createReplayPlaceholder(entries, runId, event.createdAt, event.id, itemId, "commandExecution");
+                target.item = {
+                    ...target.item,
+                    output: `${target.item?.output ?? ""}${delta}`,
+                };
+                break;
+            }
+        }
+    }
+    return entries;
+}
+function findTimelineItem(entries, itemId) {
+    for (let i = entries.length - 1; i >= 0; i -= 1) {
+        const entry = entries[i];
+        if (entry.kind === "item" && entry.item?.id === itemId) {
+            return entry;
+        }
+    }
+    return undefined;
+}
+function createReplayPlaceholder(entries, runId, at, eventId, itemId, type) {
+    const entry = {
+        id: `event-${eventId}-item-${itemId}`,
+        at,
+        kind: "item",
+        runId,
+        item: { id: itemId, type, status: "inProgress" },
+    };
+    entries.push(entry);
+    return entry;
+}
+function inferItemTypeFromDeltaMethod(method) {
+    switch (method) {
+        case "item/agentMessage/delta":
+            return "agentMessage";
+        case "item/plan/delta":
+            return "plan";
+        case "item/reasoning/summaryTextDelta":
+            return "reasoning";
+        default:
+            return "unknown";
+    }
+}
+function materializeNotificationItem(raw) {
+    if (!raw || typeof raw !== "object")
+        return undefined;
+    const itemObj = raw;
+    const id = typeof itemObj.id === "string" ? itemObj.id : undefined;
+    const type = typeof itemObj.type === "string" ? itemObj.type : "unknown";
+    if (!id)
+        return undefined;
+    const item = {
+        id,
+        type,
+        status: typeof itemObj.status === "string" ? itemObj.status : "inProgress",
+    };
+    if ((type === "agentMessage" || type === "userMessage" || type === "plan") && typeof itemObj.text === "string") {
+        item.text = itemObj.text;
+    }
+    if (type === "reasoning") {
+        if (Array.isArray(itemObj.summary)) {
+            item.text = itemObj.summary.join("\n");
+        }
+        else if (typeof itemObj.text === "string") {
+            item.text = itemObj.text;
+        }
+    }
+    if (type === "commandExecution") {
+        const cmd = itemObj.command;
+        item.command = Array.isArray(cmd) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
+        if (typeof itemObj.aggregatedOutput === "string")
+            item.output = itemObj.aggregatedOutput;
+    }
+    if (type === "fileChange" && Array.isArray(itemObj.changes)) {
+        item.changes = itemObj.changes;
+    }
+    if (type === "mcpToolCall") {
+        item.toolName = `${String(itemObj.server ?? "")}/${String(itemObj.tool ?? "")}`;
+    }
+    if (type === "dynamicToolCall" && typeof itemObj.tool === "string") {
+        item.toolName = itemObj.tool;
+    }
+    if (typeof itemObj.exitCode === "number")
+        item.exitCode = itemObj.exitCode;
+    if (typeof itemObj.durationMs === "number")
+        item.durationMs = itemObj.durationMs;
+    return item;
+}
+function mergeDefinedItemFields(base, patch) {
+    return {
+        ...base,
+        id: patch.id,
+        type: patch.type,
+        status: patch.status,
+        ...(patch.text !== undefined ? { text: patch.text } : {}),
+        ...(patch.command !== undefined ? { command: patch.command } : {}),
+        ...(patch.output !== undefined ? { output: patch.output } : {}),
+        ...(patch.exitCode !== undefined ? { exitCode: patch.exitCode } : {}),
+        ...(patch.durationMs !== undefined ? { durationMs: patch.durationMs } : {}),
+        ...(patch.changes !== undefined ? { changes: patch.changes } : {}),
+        ...(patch.toolName !== undefined ? { toolName: patch.toolName } : {}),
+    };
+}
 // ─── Feed Events to Timeline Entries ──────────────────────────────
 function feedEventsToEntries(feedEvents) {
     const entries = [];

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

@@ -0,0 +1,289 @@
+export function buildTimelineRows(entries, mode) {
+    return mode === "compact" ? buildCompactTimelineRows(entries) : buildVerboseTimelineRows(entries);
+}
+function buildVerboseTimelineRows(entries) {
+    return entries.flatMap((entry) => {
+        switch (entry.kind) {
+            case "run-start":
+                return [{
+                        id: entry.id,
+                        kind: "run",
+                        at: entry.at,
+                        finalized: false,
+                        run: entry.run,
+                        details: [],
+                    }];
+            case "run-end":
+                return [{
+                        id: entry.id,
+                        kind: "run",
+                        at: entry.at,
+                        finalized: true,
+                        run: entry.run,
+                        details: [],
+                    }];
+            case "feed":
+                return [{
+                        id: entry.id,
+                        kind: "feed",
+                        at: entry.at,
+                        finalized: true,
+                        feed: entry.feed,
+                    }];
+            case "ci-checks":
+                return [{
+                        id: entry.id,
+                        kind: "ci-checks",
+                        at: entry.at,
+                        finalized: true,
+                        ciChecks: entry.ciChecks,
+                    }];
+            case "item":
+                return [{
+                        id: entry.id,
+                        kind: "item",
+                        at: entry.at,
+                        finalized: entry.item?.status !== "inProgress",
+                        item: entry.item,
+                    }];
+        }
+    });
+}
+function buildCompactTimelineRows(entries) {
+    const rows = [];
+    const runs = new Map();
+    for (const entry of entries) {
+        if (entry.kind === "run-start" && entry.runId !== undefined) {
+            const existing = runs.get(entry.runId);
+            if (!existing) {
+                const run = { ...entry.run };
+                runs.set(entry.runId, {
+                    id: `run-${entry.runId}`,
+                    at: run.startedAt,
+                    run,
+                    items: [],
+                    endedAt: run.endedAt,
+                });
+            }
+            continue;
+        }
+        if (entry.kind === "run-end" && entry.runId !== undefined) {
+            const existing = runs.get(entry.runId);
+            if (existing) {
+                existing.run = { ...entry.run };
+                existing.endedAt = entry.run?.endedAt;
+            }
+            else {
+                const run = { ...entry.run };
+                runs.set(entry.runId, {
+                    id: `run-${entry.runId}`,
+                    at: run.startedAt,
+                    run,
+                    items: [],
+                    endedAt: run.endedAt,
+                });
+            }
+            continue;
+        }
+        if (entry.kind === "item" && entry.runId !== undefined && runs.has(entry.runId)) {
+            runs.get(entry.runId).items.push(entry.item);
+            continue;
+        }
+        if (entry.kind === "feed" && shouldHideFeedInCompact(entry.feed)) {
+            continue;
+        }
+        if (entry.kind === "feed") {
+            rows.push({
+                id: entry.id,
+                kind: "feed",
+                at: entry.at,
+                finalized: true,
+                feed: entry.feed,
+            });
+            continue;
+        }
+        if (entry.kind === "ci-checks") {
+            rows.push({
+                id: entry.id,
+                kind: "ci-checks",
+                at: entry.at,
+                finalized: true,
+                ciChecks: entry.ciChecks,
+            });
+            continue;
+        }
+        if (entry.kind === "item") {
+            rows.push({
+                id: entry.id,
+                kind: "item",
+                at: entry.at,
+                finalized: entry.item?.status !== "inProgress",
+                item: entry.item,
+            });
+        }
+    }
+    for (const run of runs.values()) {
+        const status = resolveCompactRunStatus(run.run, run.items);
+        rows.push({
+            id: run.id,
+            kind: "run",
+            at: run.at,
+            finalized: status !== "running",
+            run: { ...run.run, status, ...(run.endedAt ? { endedAt: run.endedAt } : {}) },
+            details: summarizeRunDetails(run.items, status),
+        });
+    }
+    rows.sort((left, right) => {
+        const cmp = left.at.localeCompare(right.at);
+        if (cmp !== 0)
+            return cmp;
+        const kindCmp = rowKindOrder(left.kind) - rowKindOrder(right.kind);
+        if (kindCmp !== 0)
+            return kindCmp;
+        return left.id.localeCompare(right.id);
+    });
+    return rows;
+}
+function shouldHideFeedInCompact(feed) {
+    if (feed.feedKind === "stage" && feed.status === "starting") {
+        return true;
+    }
+    if (feed.feedKind === "turn" && (feed.status === "completed" || feed.status === "failed")) {
+        return true;
+    }
+    return false;
+}
+function resolveCompactRunStatus(run, items) {
+    if (run.endedAt || run.status === "completed" || run.status === "failed" || run.status === "released") {
+        return run.status;
+    }
+    if (items.some((item) => item.status === "inProgress")) {
+        return "running";
+    }
+    return run.status === "queued" ? "queued" : "running";
+}
+function summarizeRunDetails(items, status) {
+    const details = [];
+    const latestAgentMessage = findLatest(items, (item) => item.type === "agentMessage" && Boolean(item.text?.trim()));
+    const latestUserMessage = findLatest(items, (item) => item.type === "userMessage" && Boolean(item.text?.trim()));
+    const activeCommand = findLatest(items, (item) => item.type === "commandExecution" && item.status === "inProgress");
+    const latestCommand = activeCommand ?? 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);
+    if (latestUserMessage && !latestAgentMessage) {
+        details.push({
+            tone: "user",
+            text: `you: ${summarizeNarrative(latestUserMessage.text ?? "", 120)}`,
+        });
+    }
+    if (latestAgentMessage) {
+        details.push({
+            tone: "message",
+            text: summarizeNarrative(latestAgentMessage.text ?? "", status === "running" ? 140 : 180),
+        });
+    }
+    if (latestCommand?.command) {
+        details.push({
+            tone: "command",
+            text: cleanCommand(latestCommand.command),
+        });
+    }
+    if (latestFileChange?.changes?.length) {
+        details.push({
+            tone: "meta",
+            text: summarizeFileChanges(latestFileChange.changes),
+        });
+    }
+    else {
+        const tools = summarizeToolCalls(items);
+        if (tools) {
+            details.push({
+                tone: "meta",
+                text: tools,
+            });
+        }
+    }
+    return dedupeDetails(details).slice(0, 3);
+}
+function summarizeNarrative(input, max) {
+    const normalized = input
+        .replace(/\[([^\]]+)\]\([^)]+\)/g, "$1")
+        .replace(/`([^`]+)`/g, "$1")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!normalized)
+        return "";
+    const sentence = normalized.match(/^(.+?[.!?])(?:\s|$)/)?.[1] ?? normalized;
+    return truncate(sentence, max);
+}
+function summarizeFileChanges(changes) {
+    const files = Array.from(new Set(changes
+        .map((change) => {
+        if (!change || typeof change !== "object")
+            return undefined;
+        const path = change.path;
+        return typeof path === "string" && path.trim() ? path : undefined;
+    })
+        .filter((path) => Boolean(path))));
+    if (files.length === 0) {
+        return `updated ${changes.length} file${changes.length === 1 ? "" : "s"}`;
+    }
+    const names = files.map((path) => path.split("/").at(-1) ?? path);
+    const preview = names.slice(0, 3).join(", ");
+    const remainder = names.length > 3 ? ` +${names.length - 3}` : "";
+    return `updated ${files.length} file${files.length === 1 ? "" : "s"}: ${preview}${remainder}`;
+}
+function summarizeToolCalls(items) {
+    const names = Array.from(new Set(items
+        .filter((item) => item.type === "mcpToolCall" || item.type === "dynamicToolCall")
+        .map((item) => item.toolName)
+        .filter((name) => Boolean(name))));
+    if (names.length === 0)
+        return undefined;
+    const preview = names.slice(0, 2).join(", ");
+    const remainder = names.length > 2 ? ` +${names.length - 2}` : "";
+    return `used ${names.length} tool${names.length === 1 ? "" : "s"}: ${preview}${remainder}`;
+}
+function dedupeDetails(details) {
+    const seen = new Set();
+    return details.filter((detail) => {
+        const key = `${detail.tone}:${detail.text.toLowerCase()}`;
+        if (!detail.text.trim() || seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+function findLatest(items, predicate) {
+    for (let i = items.length - 1; i >= 0; i -= 1) {
+        const item = items[i];
+        if (predicate(item)) {
+            return item;
+        }
+    }
+    return undefined;
+}
+function rowKindOrder(kind) {
+    switch (kind) {
+        case "run":
+            return 0;
+        case "feed":
+            return 1;
+        case "ci-checks":
+            return 2;
+        case "item":
+            return 3;
+    }
+}
+function truncate(text, max) {
+    return text.length > max ? `${text.slice(0, Math.max(0, max - 3))}...` : text;
+}
+function cleanCommand(raw) {
+    const bashMatch = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+['"](.+?)['"]$/s);
+    if (bashMatch?.[1])
+        return truncate(bashMatch[1], 120);
+    const bashMatch2 = raw.match(/^\/bin\/(?:ba)?sh\s+-\w*c\s+"(.+?)"$/s);
+    if (bashMatch2?.[1])
+        return truncate(bashMatch2[1], 120);
+    return truncate(raw, 120);
+}

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

@@ -36,6 +36,7 @@ async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
             startedAt: r.startedAt,
             endedAt: r.endedAt,
             threadId: r.threadId,
+            ...(r.events ? { events: r.events } : {}),
             ...(r.report ? { report: r.report } : {}),
         }));
         let issueContext = null;

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

@@ -8,6 +8,7 @@ function capArray(arr, max) {
 }
 const DETAIL_INITIAL = {
     detailTab: "timeline",
+    timelineMode: "compact",
     timeline: [],
     rawRuns: [],
     rawFeedEvents: [],
@@ -129,6 +130,8 @@ export function watchReducer(state, action) {
             return { ...state, feedEvents: capArray([...state.feedEvents, action.event], MAX_FEED_EVENTS) };
         case "switch-detail-tab":
             return { ...state, detailTab: action.tab };
+        case "toggle-timeline-mode":
+            return { ...state, timelineMode: state.timelineMode === "compact" ? "verbose" : "compact" };
     }
 }
 // ─── Feed Event → Issue List + Timeline ───────────────────────────

package/dist/issue-query-service.js

@@ -70,6 +70,12 @@ export class IssueQueryService {
             startedAt: run.startedAt,
             endedAt: run.endedAt,
             threadId: run.threadId,
+            events: this.db.listThreadEvents(run.id).map((event) => ({
+                id: event.id,
+                method: event.method,
+                createdAt: event.createdAt,
+                parsedEvent: safeJsonParse(event.eventJson),
+            })),
             ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
         }));
         const feedEvents = this.db.operatorFeed.list({ issueKey, limit: 500 });

package/dist/webhook-handler.js

@@ -305,6 +305,13 @@ export class WebhookHandler {
         }
         if (!triggerEventAllowed(project, normalized.triggerEvent))
             return;
+        // Ignore PatchRelay's own comments to prevent self-triggering feedback loops.
+        // When a run completes, PatchRelay posts an activity to Linear, which fires a
+        // commentCreated webhook back — without this guard that re-enqueues a new run.
+        const installation = this.db.linearInstallations.getLinearInstallationForProject(project.id);
+        if (installation?.actorId && normalized.actor?.id === installation.actorId) {
+            return;
+        }
         const issue = this.db.getIssue(project.id, normalized.issue.id);
         if (!issue)
             return;

package/package.json

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