patchrelay 0.16.0 → 0.17.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.16.0",
-  "commit": "396ce21398c4",
-  "builtAt": "2026-03-25T12:29:18.014Z"
+  "version": "0.17.0",
+  "commit": "972d51f6e0da",
+  "builtAt": "2026-03-25T12:55:22.635Z"
 }

package/dist/cli/watch/App.js

@@ -64,5 +64,5 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
             }
         }
     });
-    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : (_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), thread: state.thread, report: state.report, follow: state.follow, feedEntries: state.detailFeed })) }));
+    return (_jsx(Box, { flexDirection: "column", children: state.view === "list" ? (_jsx(IssueListView, { issues: filtered, selectedIndex: state.selectedIndex, connected: state.connected, filter: state.filter, totalCount: state.issues.length })) : (_jsx(IssueDetailView, { issue: state.issues.find((i) => i.issueKey === state.activeDetailKey), timeline: state.timeline, follow: state.follow, activeRunStartedAt: state.activeRunStartedAt, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan })) }));
 }

package/dist/cli/watch/IssueDetailView.js

@@ -1,12 +1,8 @@
-import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useReducer } from "react";
 import { Box, Text } from "ink";
-import { ThreadView } from "./ThreadView.js";
-import { FeedTimeline } from "./FeedTimeline.js";
+import { Timeline } from "./Timeline.js";
 import { HelpBar } from "./HelpBar.js";
-function truncate(text, max) {
-    const line = text.replace(/\n/g, " ").trim();
-    return line.length > max ? `${line.slice(0, max - 3)}...` : line;
-}
 function formatTokens(n) {
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;
@@ -14,16 +10,35 @@ function formatTokens(n) {
         return `${(n / 1_000).toFixed(1)}k`;
     return String(n);
 }
-function ThreadStatusBar({ thread, follow }) {
-    return (_jsxs(Box, { gap: 2, children: [thread.tokenUsage && (_jsxs(Text, { dimColor: true, children: ["tokens: ", formatTokens(thread.tokenUsage.inputTokens), " in / ", formatTokens(thread.tokenUsage.outputTokens), " out"] })), thread.diffSummary && thread.diffSummary.filesChanged > 0 && (_jsxs(Text, { dimColor: true, children: ["diff: ", thread.diffSummary.filesChanged, " file", thread.diffSummary.filesChanged !== 1 ? "s" : "", " ", "+", thread.diffSummary.linesAdded, " -", thread.diffSummary.linesRemoved] })), follow && _jsx(Text, { color: "yellow", children: "follow" })] }));
+function ElapsedTime({ startedAt }) {
+    const [, tick] = useReducer((c) => c + 1, 0);
+    useEffect(() => {
+        const id = setInterval(tick, 1000);
+        return () => clearInterval(id);
+    }, []);
+    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 _jsxs(Text, { dimColor: true, children: [minutes, "m ", String(seconds).padStart(2, "0"), "s"] });
+}
+function planStepSymbol(status) {
+    if (status === "completed")
+        return "\u2713";
+    if (status === "inProgress")
+        return "\u25b8";
+    return " ";
 }
-function ReportView({ report }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsx(Text, { dimColor: true, children: "Latest run:" }), _jsx(Text, { bold: true, children: report.runType }), _jsx(Text, { color: report.status === "completed" ? "green" : "red", children: report.status })] }), report.summary && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Summary:" }), _jsx(Text, { wrap: "wrap", children: truncate(report.summary, 300) })] })), report.commands.length > 0 && (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { bold: true, children: ["Commands (", report.commands.length, "):"] }), report.commands.slice(-10).map((cmd, i) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { color: cmd.exitCode === 0 ? "green" : cmd.exitCode !== undefined ? "red" : "white", children: cmd.exitCode === 0 ? "\u2713" : cmd.exitCode !== undefined ? "\u2717" : " " }), _jsx(Text, { dimColor: true, children: "$ " }), _jsx(Text, { children: truncate(cmd.command, 60) }), cmd.durationMs !== undefined && _jsxs(Text, { dimColor: true, children: [" ", (cmd.durationMs / 1000).toFixed(1), "s"] })] }, `cmd-${i}`)))] })), _jsxs(Box, { marginTop: 1, gap: 2, children: [report.fileChanges > 0 && _jsxs(Text, { dimColor: true, children: [report.fileChanges, " file change", report.fileChanges !== 1 ? "s" : ""] }), report.toolCalls > 0 && _jsxs(Text, { dimColor: true, children: [report.toolCalls, " tool call", report.toolCalls !== 1 ? "s" : ""] }), report.assistantMessages.length > 0 && _jsxs(Text, { dimColor: true, children: [report.assistantMessages.length, " message", report.assistantMessages.length !== 1 ? "s" : ""] })] })] }));
+function planStepColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "inProgress")
+        return "yellow";
+    return "white";
 }
-export function IssueDetailView({ issue, thread, report, follow, feedEntries }) {
+export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, tokenUsage, diffSummary, plan, }) {
     if (!issue) {
         return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
     }
     const key = issue.issueKey ?? issue.projectId;
-    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: ["PR #", issue.prNumber] })] }), issue.title && _jsx(Text, { dimColor: true, children: issue.title }), thread && _jsx(ThreadStatusBar, { thread: thread, follow: follow }), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), thread ? (_jsx(ThreadView, { thread: thread, follow: follow })) : report ? (_jsx(ReportView, { report: report })) : (_jsx(Text, { dimColor: true, children: "Loading..." })), feedEntries.length > 0 && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(Text, { bold: true, dimColor: true, children: "Events:" }), _jsx(FeedTimeline, { entries: feedEntries, maxEntries: follow ? 5 : undefined })] })), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
+    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: ["PR #", issue.prNumber] }), activeRunStartedAt && _jsx(ElapsedTime, { startedAt: activeRunStartedAt })] }), issue.title && _jsx(Text, { dimColor: true, children: issue.title }), _jsxs(Box, { gap: 2, children: [tokenUsage && (_jsxs(Text, { dimColor: true, children: ["tokens: ", formatTokens(tokenUsage.inputTokens), " in / ", formatTokens(tokenUsage.outputTokens), " out"] })), diffSummary && diffSummary.filesChanged > 0 && (_jsxs(Text, { dimColor: true, children: ["diff: ", diffSummary.filesChanged, " file", diffSummary.filesChanged !== 1 ? "s" : "", " ", "+", diffSummary.linesAdded, " -", diffSummary.linesRemoved] })), follow && _jsx(Text, { color: "yellow", children: "follow" })] }), plan && plan.length > 0 && (_jsx(Box, { flexDirection: "column", 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(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(Timeline, { entries: timeline, follow: follow }), _jsx(Text, { dimColor: true, children: "─".repeat(72) }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
 }

package/dist/cli/watch/Timeline.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { TimelineRow } from "./TimelineRow.js";
+const FOLLOW_TAIL_SIZE = 20;
+export function Timeline({ entries, follow }) {
+    const visible = follow && entries.length > FOLLOW_TAIL_SIZE
+        ? entries.slice(-FOLLOW_TAIL_SIZE)
+        : entries;
+    const skipped = entries.length - visible.length;
+    if (entries.length === 0) {
+        return _jsx(Text, { dimColor: true, children: "No timeline events yet." });
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [skipped > 0 && _jsxs(Text, { dimColor: true, children: ["  ... ", skipped, " earlier events"] }), visible.map((entry) => (_jsx(TimelineRow, { entry: entry }, entry.id)))] }));
+}

package/dist/cli/watch/TimelineRow.js

@@ -0,0 +1,62 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { ItemLine } from "./ItemLine.js";
+function formatTime(iso) {
+    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false });
+}
+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 remainingSeconds = seconds % 60;
+    return `${minutes}m ${remainingSeconds}s`;
+}
+const CHECK_SYMBOLS = {
+    passed: "\u2713",
+    failed: "\u2717",
+    pending: "\u25cf",
+};
+const CHECK_COLORS = {
+    passed: "green",
+    failed: "red",
+    pending: "yellow",
+};
+function FeedRow({ entry }) {
+    const feed = entry.feed;
+    const statusLabel = feed.status ?? feed.feedKind;
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { color: "cyan", children: statusLabel.padEnd(16) }), _jsx(Text, { children: feed.summary })] }));
+}
+function RunStartRow({ entry }) {
+    const run = entry.run;
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: "yellow", children: run.runType.padEnd(16) }), _jsx(Text, { bold: true, children: "run started" })] }));
+}
+function RunEndRow({ entry }) {
+    const run = entry.run;
+    const color = run.status === "completed" ? "green" : "red";
+    const duration = run.endedAt ? formatDuration(run.startedAt, run.endedAt) : "";
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { bold: true, color: color, children: run.runType.padEnd(16) }), _jsx(Text, { bold: true, color: color, children: run.status }), duration ? _jsxs(Text, { dimColor: true, children: ["(", duration, ")"] }) : null] }));
+}
+function ItemRow({ entry }) {
+    const item = entry.item;
+    return (_jsx(Box, { paddingLeft: 2, children: _jsx(ItemLine, { item: item, isLast: false }) }));
+}
+function CIChecksRow({ entry }) {
+    const ci = entry.ciChecks;
+    return (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { color: CHECK_COLORS[ci.overall] ?? "white", children: "ci_checks".padEnd(16) }), 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, "  "] })] }, `check-${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 });
+    }
+}

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

@@ -0,0 +1,363 @@
+// ─── Build Timeline from Rehydration Data ─────────────────────────
+export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId) {
+    const entries = [];
+    // 1. Add run boundaries and items from reports
+    for (const run of runs) {
+        entries.push({
+            id: `run-start-${run.id}`,
+            at: run.startedAt,
+            kind: "run-start",
+            runId: run.id,
+            run: { runType: run.runType, status: run.status, startedAt: run.startedAt, endedAt: run.endedAt },
+        });
+        if (run.endedAt) {
+            entries.push({
+                id: `run-end-${run.id}`,
+                at: run.endedAt,
+                kind: "run-end",
+                runId: run.id,
+                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));
+        }
+    }
+    // 2. Items from live thread (active run)
+    if (liveThread && activeRunId) {
+        entries.push(...itemsFromThread(activeRunId, liveThread));
+    }
+    // 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
+        return kindOrder(a.kind) - kindOrder(b.kind);
+    });
+    return entries;
+}
+function kindOrder(kind) {
+    switch (kind) {
+        case "run-start": return 0;
+        case "feed": return 1;
+        case "ci-checks": return 2;
+        case "item": return 3;
+        case "run-end": return 4;
+    }
+}
+// ─── Items from Report ────────────────────────────────────────────
+function itemsFromReport(runId, report, startedAt, endedAt) {
+    const entries = [];
+    const start = new Date(startedAt).getTime();
+    const end = endedAt ? new Date(endedAt).getTime() : start + 60000;
+    let idx = 0;
+    const total = report.commands.length + report.assistantMessages.length + report.toolCalls.length;
+    for (const msg of report.assistantMessages) {
+        entries.push({
+            id: `report-${runId}-msg-${idx}`,
+            at: syntheticTimestamp(start, end, idx, total),
+            kind: "item",
+            runId,
+            item: { id: `report-${runId}-msg-${idx}`, type: "agentMessage", status: "completed", text: msg },
+        });
+        idx++;
+    }
+    for (const cmd of report.commands) {
+        entries.push({
+            id: `report-${runId}-cmd-${idx}`,
+            at: syntheticTimestamp(start, end, idx, total),
+            kind: "item",
+            runId,
+            item: {
+                id: `report-${runId}-cmd-${idx}`,
+                type: "commandExecution",
+                status: "completed",
+                command: cmd.command,
+                ...(typeof cmd.exitCode === "number" ? { exitCode: cmd.exitCode } : {}),
+                ...(typeof cmd.durationMs === "number" ? { durationMs: cmd.durationMs } : {}),
+            },
+        });
+        idx++;
+    }
+    for (const tool of report.toolCalls) {
+        entries.push({
+            id: `report-${runId}-tool-${idx}`,
+            at: syntheticTimestamp(start, end, idx, total),
+            kind: "item",
+            runId,
+            item: {
+                id: `report-${runId}-tool-${idx}`,
+                type: tool.type === "mcp" ? "mcpToolCall" : "dynamicToolCall",
+                status: "completed",
+                toolName: tool.name,
+                ...(typeof tool.durationMs === "number" ? { durationMs: tool.durationMs } : {}),
+            },
+        });
+        idx++;
+    }
+    if (report.fileChanges.length > 0) {
+        entries.push({
+            id: `report-${runId}-files`,
+            at: syntheticTimestamp(start, end, idx, total),
+            kind: "item",
+            runId,
+            item: {
+                id: `report-${runId}-files`,
+                type: "fileChange",
+                status: "completed",
+                changes: report.fileChanges,
+            },
+        });
+    }
+    return entries;
+}
+function syntheticTimestamp(startMs, endMs, index, total) {
+    if (total <= 1)
+        return new Date(startMs).toISOString();
+    const fraction = index / (total - 1);
+    return new Date(startMs + fraction * (endMs - startMs)).toISOString();
+}
+// ─── Items from Live Thread ───────────────────────────────────────
+function itemsFromThread(runId, thread) {
+    const entries = [];
+    for (const turn of thread.turns) {
+        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
+                kind: "item",
+                runId,
+                item: materializeItem(item),
+            });
+        }
+    }
+    return entries;
+}
+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 "agentMessage":
+            return { ...base, text: String(r.text ?? "") };
+        case "commandExecution":
+            return {
+                ...base,
+                command: String(r.command ?? ""),
+                status: String(r.status ?? "completed"),
+                ...(typeof r.exitCode === "number" ? { exitCode: r.exitCode } : {}),
+                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
+                ...(typeof r.aggregatedOutput === "string" ? { output: r.aggregatedOutput } : {}),
+            };
+        case "fileChange":
+            return { ...base, status: String(r.status ?? "completed"), changes: Array.isArray(r.changes) ? r.changes : [] };
+        case "mcpToolCall":
+            return {
+                ...base,
+                status: String(r.status ?? "completed"),
+                toolName: `${String(r.server ?? "")}/${String(r.tool ?? "")}`,
+                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
+            };
+        case "dynamicToolCall":
+            return {
+                ...base,
+                status: String(r.status ?? "completed"),
+                toolName: String(r.tool ?? ""),
+                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
+            };
+        case "plan":
+            return { ...base, text: String(r.text ?? "") };
+        case "reasoning":
+            return { ...base, text: Array.isArray(r.summary) ? r.summary.join("\n") : "" };
+        default:
+            return base;
+    }
+}
+// ─── Feed Events to Timeline Entries ──────────────────────────────
+function feedEventsToEntries(feedEvents) {
+    const entries = [];
+    const ciAggregator = new CICheckAggregator();
+    for (const event of feedEvents) {
+        // GitHub check events get aggregated
+        if (event.kind === "github" && (event.status === "check_passed" || event.status === "check_failed") && event.detail) {
+            const ciEntry = ciAggregator.add(event);
+            if (ciEntry) {
+                // Replace the last ci-checks entry if it was updated
+                const lastIdx = entries.findLastIndex((e) => e.kind === "ci-checks" && e.id === ciEntry.id);
+                if (lastIdx >= 0) {
+                    entries[lastIdx] = ciEntry;
+                }
+                else {
+                    entries.push(ciEntry);
+                }
+            }
+            continue;
+        }
+        entries.push({
+            id: `feed-${event.id}`,
+            at: event.at,
+            kind: "feed",
+            feed: {
+                feedKind: event.kind,
+                ...(event.status ? { status: event.status } : {}),
+                summary: event.summary,
+                ...(event.detail ? { detail: event.detail } : {}),
+            },
+        });
+    }
+    return entries;
+}
+// ─── CI Check Aggregation ─────────────────────────────────────────
+const CI_CHECK_WINDOW_MS = 60_000;
+class CICheckAggregator {
+    currentGroup = null;
+    groupCounter = 0;
+    add(event) {
+        const name = event.detail ?? "unknown";
+        const status = event.status === "check_passed" ? "passed" : "failed";
+        const eventMs = new Date(event.at).getTime();
+        if (this.currentGroup && eventMs - this.currentGroup.windowStart < CI_CHECK_WINDOW_MS) {
+            this.currentGroup.checks.set(name, status);
+            return this.toEntry();
+        }
+        this.groupCounter++;
+        this.currentGroup = {
+            id: `ci-checks-${this.groupCounter}`,
+            at: event.at,
+            checks: new Map([[name, status]]),
+            windowStart: eventMs,
+        };
+        return this.toEntry();
+    }
+    toEntry() {
+        const group = this.currentGroup;
+        const checks = [...group.checks.entries()].map(([name, status]) => ({ name, status }));
+        const overall = checks.every((c) => c.status === "passed") ? "passed"
+            : checks.some((c) => c.status === "failed") ? "failed"
+                : "pending";
+        return {
+            id: group.id,
+            at: group.at,
+            kind: "ci-checks",
+            ciChecks: { checks, overall },
+        };
+    }
+}
+// ─── Live Append Helpers ──────────────────────────────────────────
+export function appendFeedToTimeline(timeline, event) {
+    // GitHub check events: aggregate into existing ci-checks entry
+    if (event.kind === "github" && (event.status === "check_passed" || event.status === "check_failed") && event.detail) {
+        return aggregateCICheckIntoTimeline(timeline, event);
+    }
+    return [...timeline, {
+            id: `feed-${event.id}`,
+            at: event.at,
+            kind: "feed",
+            feed: {
+                feedKind: event.kind,
+                ...(event.status ? { status: event.status } : {}),
+                summary: event.summary,
+                ...(event.detail ? { detail: event.detail } : {}),
+            },
+        }];
+}
+function aggregateCICheckIntoTimeline(timeline, event) {
+    const name = event.detail ?? "unknown";
+    const status = event.status === "check_passed" ? "passed" : "failed";
+    const eventMs = new Date(event.at).getTime();
+    // Find the most recent ci-checks entry within the window
+    for (let i = timeline.length - 1; i >= 0; i--) {
+        const entry = timeline[i];
+        if (entry.kind === "ci-checks" && entry.ciChecks) {
+            const entryMs = new Date(entry.at).getTime();
+            if (eventMs - entryMs < CI_CHECK_WINDOW_MS) {
+                const updatedChecks = [...entry.ciChecks.checks.filter((c) => c.name !== name), { name, status }];
+                const overall = updatedChecks.every((c) => c.status === "passed") ? "passed"
+                    : updatedChecks.some((c) => c.status === "failed") ? "failed"
+                        : "pending";
+                const updated = [...timeline];
+                updated[i] = { ...entry, ciChecks: { checks: updatedChecks, overall } };
+                return updated;
+            }
+            break;
+        }
+    }
+    // No recent ci-checks entry; create new one
+    return [...timeline, {
+            id: `ci-checks-live-${event.id}`,
+            at: event.at,
+            kind: "ci-checks",
+            ciChecks: { checks: [{ name, status }], overall: status },
+        }];
+}
+export function appendCodexItemToTimeline(timeline, params, activeRunId) {
+    const itemObj = params.item;
+    if (!itemObj)
+        return timeline;
+    const id = typeof itemObj.id === "string" ? itemObj.id : "unknown";
+    const type = typeof itemObj.type === "string" ? itemObj.type : "unknown";
+    const status = typeof itemObj.status === "string" ? itemObj.status : "inProgress";
+    const item = { id, type, status };
+    if (type === "agentMessage" && 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 (type === "mcpToolCall") {
+        item.toolName = `${String(itemObj.server ?? "")}/${String(itemObj.tool ?? "")}`;
+    }
+    if (type === "dynamicToolCall") {
+        item.toolName = typeof itemObj.tool === "string" ? itemObj.tool : undefined;
+    }
+    return [...timeline, {
+            id: `live-${id}`,
+            at: new Date().toISOString(),
+            kind: "item",
+            runId: activeRunId ?? undefined,
+            item,
+        }];
+}
+export function completeCodexItemInTimeline(timeline, params) {
+    const itemObj = params.item;
+    if (!itemObj)
+        return timeline;
+    const id = typeof itemObj.id === "string" ? itemObj.id : undefined;
+    if (!id)
+        return timeline;
+    const status = typeof itemObj.status === "string" ? itemObj.status : "completed";
+    const exitCode = typeof itemObj.exitCode === "number" ? itemObj.exitCode : undefined;
+    const durationMs = typeof itemObj.durationMs === "number" ? itemObj.durationMs : undefined;
+    const text = typeof itemObj.text === "string" ? itemObj.text : undefined;
+    const changes = Array.isArray(itemObj.changes) ? itemObj.changes : undefined;
+    return timeline.map((entry) => {
+        if (entry.kind !== "item" || entry.item?.id !== id)
+            return entry;
+        return {
+            ...entry,
+            item: {
+                ...entry.item,
+                status,
+                ...(exitCode !== undefined ? { exitCode } : {}),
+                ...(durationMs !== undefined ? { durationMs } : {}),
+                ...(text !== undefined ? { text } : {}),
+                ...(changes !== undefined ? { changes } : {}),
+            },
+        };
+    });
+}
+export function appendDeltaToTimelineItem(timeline, itemId, field, delta) {
+    return timeline.map((entry) => {
+        if (entry.kind !== "item" || entry.item?.id !== itemId)
+            return entry;
+        return {
+            ...entry,
+            item: { ...entry.item, [field]: (entry.item[field] ?? "") + delta },
+        };
+    });
+}

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

@@ -8,70 +8,50 @@ export function useDetailStream(options) {
             return;
         const abortController = new AbortController();
         const { baseUrl, bearerToken, dispatch } = optionsRef.current;
-        const headers = { accept: "application/json" };
+        const headers = {};
         if (bearerToken) {
             headers.authorization = `Bearer ${bearerToken}`;
         }
-        // Rehydrate from thread/read via /api/issues/:key/live
+        // Rehydrate from timeline endpoint
         void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
-        // Stream codex notifications via filtered SSE
-        void streamCodexEvents(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        // Stream codex notifications + feed events via filtered SSE
+        void streamEvents(baseUrl, issueKey, headers, abortController.signal, dispatch);
         return () => {
             abortController.abort();
         };
     }, [options.issueKey]);
 }
+// ─── Rehydration ──────────────────────────────────────────────────
 async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
     try {
-        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/live`, baseUrl);
-        const response = await fetch(url, { headers, signal });
-        if (!response.ok)
-            return;
-        const data = await response.json();
-        const threadData = data.thread;
-        if (threadData) {
-            dispatch({ type: "thread-snapshot", thread: materializeThread(threadData) });
-            return;
-        }
-        // No active thread — fall back to latest run report
-        await rehydrateFromReport(baseUrl, issueKey, headers, signal, dispatch);
-    }
-    catch {
-        // Rehydration is best-effort — SSE stream will provide updates
-    }
-}
-async function rehydrateFromReport(baseUrl, issueKey, headers, signal, dispatch) {
-    try {
-        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/report`, baseUrl);
-        const response = await fetch(url, { headers, signal });
+        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/timeline`, baseUrl);
+        const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
         if (!response.ok)
             return;
         const data = await response.json();
-        const latest = data.runs?.[0];
-        if (!latest)
-            return;
-        const report = {
-            runType: latest.run.runType,
-            status: latest.run.status,
-            summary: typeof latest.summary?.latestAssistantMessage === "string"
-                ? latest.summary.latestAssistantMessage
-                : latest.report?.assistantMessages.at(-1),
-            commands: latest.report?.commands.map((c) => ({
-                command: c.command,
-                ...(typeof c.exitCode === "number" ? { exitCode: c.exitCode } : {}),
-                ...(typeof c.durationMs === "number" ? { durationMs: c.durationMs } : {}),
-            })) ?? [],
-            fileChanges: latest.report?.fileChanges.length ?? 0,
-            toolCalls: latest.report?.toolCalls.length ?? 0,
-            assistantMessages: latest.report?.assistantMessages ?? [],
-        };
-        dispatch({ type: "report-snapshot", report });
+        const runs = (data.runs ?? []).map((r) => ({
+            id: r.id,
+            runType: r.runType,
+            status: r.status,
+            startedAt: r.startedAt,
+            endedAt: r.endedAt,
+            threadId: r.threadId,
+            ...(r.report ? { report: r.report } : {}),
+        }));
+        dispatch({
+            type: "timeline-rehydrate",
+            runs,
+            feedEvents: data.feedEvents ?? [],
+            liveThread: data.liveThread ?? null,
+            activeRunId: data.activeRunId ?? null,
+        });
     }
     catch {
-        // Report fetch is best-effort
+        // Rehydration is best-effort
     }
 }
-async function streamCodexEvents(baseUrl, issueKey, baseHeaders, signal, dispatch) {
+// ─── Live SSE Stream ──────────────────────────────────────────────
+async function streamEvents(baseUrl, issueKey, baseHeaders, signal, dispatch) {
     try {
         const url = new URL("/api/watch", baseUrl);
         url.searchParams.set("issue", issueKey);
@@ -96,7 +76,7 @@ async function streamCodexEvents(baseUrl, issueKey, baseHeaders, signal, dispatc
                 const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
                 if (!line) {
                     if (dataLines.length > 0) {
-                        processDetailEvent(dispatch, eventType, dataLines.join("\n"));
+                        processEvent(dispatch, eventType, dataLines.join("\n"));
                         dataLines = [];
                         eventType = "";
                     }
@@ -121,73 +101,15 @@ async function streamCodexEvents(baseUrl, issueKey, baseHeaders, signal, dispatc
         // Stream ended or aborted
     }
 }
-function processDetailEvent(dispatch, eventType, data) {
+function processEvent(dispatch, eventType, data) {
     try {
         if (eventType === "codex") {
             const parsed = JSON.parse(data);
             dispatch({ type: "codex-notification", method: parsed.method, params: parsed.params });
         }
-        // Feed events are already handled by the main watch stream
+        // Feed events are handled by the main watch stream
     }
     catch {
         // Ignore parse errors
     }
 }
-// ─── Thread Materialization from thread/read ──────────────────────
-function materializeThread(summary) {
-    return {
-        threadId: summary.id,
-        status: summary.status,
-        turns: summary.turns.map(materializeTurn),
-    };
-}
-function materializeTurn(turn) {
-    return {
-        id: turn.id,
-        status: turn.status,
-        items: turn.items.map(materializeItem),
-    };
-}
-function materializeItem(item) {
-    // CodexThreadItem has an index-signature catch-all that defeats narrowing.
-    // Access fields via Record<string, unknown> and coerce explicitly.
-    const r = item;
-    const id = String(r.id ?? "unknown");
-    const type = String(r.type ?? "unknown");
-    const base = { id, type, status: "completed" };
-    switch (type) {
-        case "agentMessage":
-            return { ...base, text: String(r.text ?? "") };
-        case "commandExecution":
-            return {
-                ...base,
-                command: String(r.command ?? ""),
-                status: String(r.status ?? "completed"),
-                ...(typeof r.exitCode === "number" ? { exitCode: r.exitCode } : {}),
-                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
-                ...(typeof r.aggregatedOutput === "string" ? { output: r.aggregatedOutput } : {}),
-            };
-        case "fileChange":
-            return { ...base, status: String(r.status ?? "completed"), changes: Array.isArray(r.changes) ? r.changes : [] };
-        case "mcpToolCall":
-            return {
-                ...base,
-                status: String(r.status ?? "completed"),
-                toolName: `${String(r.server ?? "")}/${String(r.tool ?? "")}`,
-                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
-            };
-        case "dynamicToolCall":
-            return {
-                ...base,
-                status: String(r.status ?? "completed"),
-                toolName: String(r.tool ?? ""),
-                ...(typeof r.durationMs === "number" ? { durationMs: r.durationMs } : {}),
-            };
-        case "plan":
-            return { ...base, text: String(r.text ?? "") };
-        case "reasoning":
-            return { ...base, text: Array.isArray(r.summary) ? r.summary.join("\n") : "" };
-        default:
-            return base;
-    }
-}

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

@@ -1,14 +1,21 @@
+import { buildTimelineFromRehydration, appendFeedToTimeline, appendCodexItemToTimeline, completeCodexItemInTimeline, appendDeltaToTimelineItem, } from "./timeline-builder.js";
+const DETAIL_INITIAL = {
+    timeline: [],
+    activeRunId: null,
+    activeRunStartedAt: null,
+    tokenUsage: null,
+    diffSummary: null,
+    plan: null,
+};
 export const initialWatchState = {
     connected: false,
     issues: [],
     selectedIndex: 0,
     view: "list",
     activeDetailKey: null,
-    thread: null,
-    report: null,
     filter: "non-done",
     follow: true,
-    detailFeed: [],
+    ...DETAIL_INITIAL,
 };
 const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
 export function filterIssues(issues, filter) {
@@ -28,6 +35,7 @@ function nextFilter(filter) {
         case "all": return "non-done";
     }
 }
+// ─── Reducer ──────────────────────────────────────────────────────
 export function watchReducer(state, action) {
     switch (action.type) {
         case "connected":
@@ -48,13 +56,19 @@ export function watchReducer(state, action) {
                 selectedIndex: Math.max(0, Math.min(action.index, state.issues.length - 1)),
             };
         case "enter-detail":
-            return { ...state, view: "detail", activeDetailKey: action.issueKey, thread: null, report: null, detailFeed: [] };
+            return { ...state, view: "detail", activeDetailKey: action.issueKey, ...DETAIL_INITIAL };
         case "exit-detail":
-            return { ...state, view: "list", activeDetailKey: null, thread: null, report: null, detailFeed: [] };
-        case "thread-snapshot":
-            return { ...state, thread: action.thread };
-        case "report-snapshot":
-            return { ...state, report: action.report };
+            return { ...state, view: "list", activeDetailKey: null, ...DETAIL_INITIAL };
+        case "timeline-rehydrate": {
+            const timeline = buildTimelineFromRehydration(action.runs, action.feedEvents, action.liveThread, action.activeRunId);
+            const activeRun = action.runs.find((r) => r.id === action.activeRunId);
+            return {
+                ...state,
+                timeline,
+                activeRunId: action.activeRunId,
+                activeRunStartedAt: activeRun?.startedAt ?? null,
+            };
+        }
         case "codex-notification":
             return applyCodexNotification(state, action.method, action.params);
         case "cycle-filter":
@@ -63,7 +77,7 @@ export function watchReducer(state, action) {
             return { ...state, follow: !state.follow };
     }
 }
-// ─── Feed Event Application ───────────────────────────────────────
+// ─── Feed Event → Issue List + Timeline ───────────────────────────
 function applyFeedEvent(state, event) {
     if (!event.issueKey) {
         return state;
@@ -93,103 +107,52 @@ function applyFeedEvent(state, event) {
     }
     issue.updatedAt = event.at;
     updated[index] = issue;
-    // Append to detail feed if this event matches the active detail issue
-    const detailFeed = state.view === "detail" && state.activeDetailKey === event.issueKey
-        ? [...state.detailFeed, {
-                at: event.at,
-                kind: event.kind,
-                summary: event.summary,
-                ...(event.status ? { status: event.status } : {}),
-                ...(event.detail ? { detail: event.detail } : {}),
-            }]
-        : state.detailFeed;
-    return { ...state, issues: updated, detailFeed };
+    // Append to timeline if this event matches the active detail issue
+    const timeline = state.view === "detail" && state.activeDetailKey === event.issueKey
+        ? appendFeedToTimeline(state.timeline, event)
+        : state.timeline;
+    return { ...state, issues: updated, timeline };
 }
-// ─── Codex Notification Application ───────────────────────────────
+// ─── Codex Notification → Timeline + Metadata ─────────────────────
 function applyCodexNotification(state, method, params) {
-    if (!state.thread) {
-        // No thread loaded yet — only turn/started can bootstrap one
-        if (method === "turn/started") {
-            return bootstrapThreadFromTurnStarted(state, params);
-        }
-        return state;
-    }
     switch (method) {
-        case "turn/started":
-            return withThread(state, addTurn(state.thread, params));
-        case "turn/completed":
-            return withThread(state, completeTurn(state.thread, params));
-        case "turn/plan/updated":
-            return withThread(state, updatePlan(state.thread, params));
-        case "turn/diff/updated":
-            return withThread(state, updateDiff(state.thread, params));
         case "item/started":
-            return withThread(state, addItem(state.thread, params));
+            return { ...state, timeline: appendCodexItemToTimeline(state.timeline, params, state.activeRunId) };
         case "item/completed":
-            return withThread(state, completeItem(state.thread, params));
+            return { ...state, timeline: completeCodexItemInTimeline(state.timeline, params) };
         case "item/agentMessage/delta":
-            return withThread(state, appendItemText(state.thread, params));
-        case "item/commandExecution/outputDelta":
-            return withThread(state, appendItemOutput(state.thread, params));
         case "item/plan/delta":
-            return withThread(state, appendItemText(state.thread, params));
-        case "item/reasoning/summaryTextDelta":
-            return withThread(state, appendItemText(state.thread, params));
-        case "thread/status/changed":
-            return withThread(state, updateThreadStatus(state.thread, params));
+        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)
+                return state;
+            return { ...state, timeline: appendDeltaToTimelineItem(state.timeline, itemId, "text", delta) };
+        }
+        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)
+                return state;
+            return { ...state, timeline: appendDeltaToTimelineItem(state.timeline, itemId, "output", delta) };
+        }
+        case "turn/plan/updated":
+            return applyPlanUpdate(state, params);
+        case "turn/diff/updated":
+            return applyDiffUpdate(state, params);
         case "thread/tokenUsage/updated":
-            return withThread(state, updateTokenUsage(state.thread, params));
+            return applyTokenUsageUpdate(state, params);
         default:
             return state;
     }
 }
-function withThread(state, thread) {
-    return { ...state, thread };
-}
-function bootstrapThreadFromTurnStarted(state, params) {
-    const turnObj = params.turn;
-    const threadId = typeof params.threadId === "string" ? params.threadId : "unknown";
-    const turnId = typeof turnObj?.id === "string" ? turnObj.id : "unknown";
-    return {
-        ...state,
-        thread: {
-            threadId,
-            status: "active",
-            turns: [{ id: turnId, status: "inProgress", items: [] }],
-        },
-    };
-}
-// ─── Turn Handlers ────────────────────────────────────────────────
-function addTurn(thread, params) {
-    const turnObj = params.turn;
-    const turnId = typeof turnObj?.id === "string" ? turnObj.id : "unknown";
-    const existing = thread.turns.find((t) => t.id === turnId);
-    if (existing) {
-        return thread;
-    }
-    return {
-        ...thread,
-        status: "active",
-        turns: [...thread.turns, { id: turnId, status: "inProgress", items: [] }],
-    };
-}
-function completeTurn(thread, params) {
-    const turnObj = params.turn;
-    const turnId = typeof turnObj?.id === "string" ? turnObj.id : undefined;
-    const status = typeof turnObj?.status === "string" ? turnObj.status : "completed";
-    if (!turnId)
-        return thread;
-    return {
-        ...thread,
-        turns: thread.turns.map((t) => t.id === turnId ? { ...t, status } : t),
-    };
-}
-function updatePlan(thread, params) {
+// ─── Metadata Handlers (header, not timeline) ─────────────────────
+function applyPlanUpdate(state, params) {
     const plan = params.plan;
     if (!Array.isArray(plan))
-        return thread;
+        return state;
     return {
-        ...thread,
+        ...state,
         plan: plan.map((entry) => {
             const e = entry;
             return {
@@ -199,9 +162,11 @@ function updatePlan(thread, params) {
         }),
     };
 }
-function updateDiff(thread, params) {
+function applyDiffUpdate(state, params) {
     const diff = typeof params.diff === "string" ? params.diff : undefined;
-    return { ...thread, diff, diffSummary: diff ? parseDiffSummary(diff) : undefined };
+    if (!diff)
+        return state;
+    return { ...state, diffSummary: parseDiffSummary(diff) };
 }
 function parseDiffSummary(diff) {
     const files = new Set();
@@ -220,109 +185,13 @@ function parseDiffSummary(diff) {
     }
     return { filesChanged: files.size, linesAdded: added, linesRemoved: removed };
 }
-function updateTokenUsage(thread, params) {
+function applyTokenUsageUpdate(state, params) {
     const usage = params.usage;
     if (!usage)
-        return thread;
+        return state;
     const inputTokens = typeof usage.inputTokens === "number" ? usage.inputTokens
         : typeof usage.input_tokens === "number" ? usage.input_tokens : 0;
     const outputTokens = typeof usage.outputTokens === "number" ? usage.outputTokens
         : typeof usage.output_tokens === "number" ? usage.output_tokens : 0;
-    return { ...thread, tokenUsage: { inputTokens, outputTokens } };
-}
-function updateThreadStatus(thread, params) {
-    const statusObj = params.status;
-    const statusType = typeof statusObj?.type === "string" ? statusObj.type : undefined;
-    if (!statusType)
-        return thread;
-    return { ...thread, status: statusType };
-}
-// ─── Item Handlers ────────────────────────────────────────────────
-function getLatestTurn(thread) {
-    return thread.turns[thread.turns.length - 1];
-}
-function updateLatestTurn(thread, updater) {
-    const last = getLatestTurn(thread);
-    if (!last)
-        return thread;
-    return {
-        ...thread,
-        turns: [...thread.turns.slice(0, -1), updater(last)],
-    };
-}
-function addItem(thread, params) {
-    const itemObj = params.item;
-    if (!itemObj)
-        return thread;
-    const id = typeof itemObj.id === "string" ? itemObj.id : "unknown";
-    const type = typeof itemObj.type === "string" ? itemObj.type : "unknown";
-    const status = typeof itemObj.status === "string" ? itemObj.status : "inProgress";
-    const item = { id, type, status };
-    if (type === "agentMessage" && 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 (type === "mcpToolCall") {
-        const server = typeof itemObj.server === "string" ? itemObj.server : "";
-        const tool = typeof itemObj.tool === "string" ? itemObj.tool : "";
-        item.toolName = `${server}/${tool}`;
-    }
-    if (type === "dynamicToolCall") {
-        item.toolName = typeof itemObj.tool === "string" ? itemObj.tool : undefined;
-    }
-    return updateLatestTurn(thread, (turn) => ({
-        ...turn,
-        items: [...turn.items, item],
-    }));
-}
-function completeItem(thread, params) {
-    const itemObj = params.item;
-    if (!itemObj)
-        return thread;
-    const id = typeof itemObj.id === "string" ? itemObj.id : undefined;
-    if (!id)
-        return thread;
-    const status = typeof itemObj.status === "string" ? itemObj.status : "completed";
-    const exitCode = typeof itemObj.exitCode === "number" ? itemObj.exitCode : undefined;
-    const durationMs = typeof itemObj.durationMs === "number" ? itemObj.durationMs : undefined;
-    const text = typeof itemObj.text === "string" ? itemObj.text : undefined;
-    const changes = Array.isArray(itemObj.changes) ? itemObj.changes : undefined;
-    return updateLatestTurn(thread, (turn) => ({
-        ...turn,
-        items: turn.items.map((item) => {
-            if (item.id !== id)
-                return item;
-            return {
-                ...item,
-                status,
-                ...(exitCode !== undefined ? { exitCode } : {}),
-                ...(durationMs !== undefined ? { durationMs } : {}),
-                ...(text !== undefined ? { text } : {}),
-                ...(changes !== undefined ? { changes } : {}),
-            };
-        }),
-    }));
-}
-function appendItemText(thread, params) {
-    const itemId = typeof params.itemId === "string" ? params.itemId : undefined;
-    const delta = typeof params.delta === "string" ? params.delta : undefined;
-    if (!itemId || !delta)
-        return thread;
-    return updateLatestTurn(thread, (turn) => ({
-        ...turn,
-        items: turn.items.map((item) => item.id === itemId ? { ...item, text: (item.text ?? "") + delta } : item),
-    }));
-}
-function appendItemOutput(thread, params) {
-    const itemId = typeof params.itemId === "string" ? params.itemId : undefined;
-    const delta = typeof params.delta === "string" ? params.delta : undefined;
-    if (!itemId || !delta)
-        return thread;
-    return updateLatestTurn(thread, (turn) => ({
-        ...turn,
-        items: turn.items.map((item) => item.id === itemId ? { ...item, output: (item.output ?? "") + delta } : item),
-    }));
+    return { ...state, tokenUsage: { inputTokens, outputTokens } };
 }

package/dist/http.js

@@ -259,6 +259,14 @@ export async function buildHttpServer(config, service, logger) {
             }
             return reply.send({ ok: true, ...result });
         });
+        app.get("/api/issues/:issueKey/timeline", async (request, reply) => {
+            const issueKey = request.params.issueKey;
+            const result = await service.getIssueTimeline(issueKey);
+            if (!result) {
+                return reply.code(404).send({ ok: false, reason: "issue_not_found" });
+            }
+            return reply.send({ ok: true, ...result });
+        });
         app.get("/api/issues/:issueKey/live", async (request, reply) => {
             const issueKey = request.params.issueKey;
             const result = await service.getActiveRunStatus(issueKey);

package/dist/issue-query-service.js

@@ -58,6 +58,29 @@ export class IssueQueryService {
             })),
         };
     }
+    async getIssueTimeline(issueKey) {
+        const issue = this.db.getTrackedIssueByKey(issueKey);
+        if (!issue)
+            return undefined;
+        const fullIssue = this.db.getIssueByKey(issueKey);
+        const runs = this.db.listRunsForIssue(issue.projectId, issue.linearIssueId).map((run) => ({
+            id: run.id,
+            runType: run.runType,
+            status: run.status,
+            startedAt: run.startedAt,
+            endedAt: run.endedAt,
+            threadId: run.threadId,
+            ...(run.reportJson ? { report: JSON.parse(run.reportJson) } : {}),
+        }));
+        const feedEvents = this.db.operatorFeed.list({ issueKey, limit: 500 });
+        let liveThread = undefined;
+        const activeRunId = fullIssue?.activeRunId;
+        const activeRun = activeRunId !== undefined ? runs.find((r) => r.id === activeRunId) : undefined;
+        if (activeRun?.threadId) {
+            liveThread = await this.codex.readThread(activeRun.threadId, true).catch(() => undefined);
+        }
+        return { issue, runs, feedEvents, liveThread, activeRunId };
+    }
     async getActiveRunStatus(issueKey) {
         return await this.runStatusProvider.getActiveRunStatus(issueKey);
     }

package/dist/run-orchestrator.js

@@ -72,6 +72,7 @@ function buildRunPrompt(issue, runType, repoPath, context) {
     }
     return lines.join("\n");
 }
+const PROGRESS_THROTTLE_MS = 10_000;
 export class RunOrchestrator {
     config;
     db;
@@ -81,6 +82,7 @@ export class RunOrchestrator {
     logger;
     feed;
     worktreeManager;
+    progressThrottle = new Map();
     botIdentity;
     constructor(config, db, codex, linearProvider, enqueueIssue, logger, feed) {
         this.config = config;
@@ -253,6 +255,8 @@ export class RunOrchestrator {
                 eventJson: JSON.stringify(notification.params),
             });
         }
+        // Emit ephemeral progress activity to Linear for notable in-flight events
+        this.maybeEmitProgressActivity(notification, run);
         if (notification.method !== "turn/completed")
             return;
         const thread = await this.readThreadWithRetry(threadId);
@@ -286,6 +290,7 @@ export class RunOrchestrator {
             const failedIssue = this.db.getIssue(run.projectId, run.linearIssueId) ?? issue;
             void this.emitLinearActivity(failedIssue, buildRunFailureActivity(run.runType));
             void this.syncLinearSession(failedIssue, { activeRunType: run.runType });
+            this.progressThrottle.delete(run.id);
             return;
         }
         // Complete the run
@@ -347,6 +352,45 @@ export class RunOrchestrator {
             ...(updatedIssue.prNumber !== undefined ? { prNumber: updatedIssue.prNumber } : {}),
         }));
         void this.syncLinearSession(updatedIssue);
+        this.progressThrottle.delete(run.id);
+    }
+    // ─── In-flight progress ──────────────────────────────────────────
+    maybeEmitProgressActivity(notification, run) {
+        const activity = this.resolveProgressActivity(notification);
+        if (!activity)
+            return;
+        const now = Date.now();
+        const lastEmit = this.progressThrottle.get(run.id) ?? 0;
+        if (now - lastEmit < PROGRESS_THROTTLE_MS)
+            return;
+        this.progressThrottle.set(run.id, now);
+        const issue = this.db.getIssue(run.projectId, run.linearIssueId);
+        if (issue) {
+            void this.emitLinearActivity(issue, activity, { ephemeral: true });
+        }
+    }
+    resolveProgressActivity(notification) {
+        if (notification.method === "item/started") {
+            const item = notification.params.item;
+            if (!item)
+                return undefined;
+            const type = typeof item.type === "string" ? item.type : undefined;
+            if (type === "commandExecution") {
+                const cmd = item.command;
+                const cmdStr = Array.isArray(cmd) ? cmd.join(" ") : typeof cmd === "string" ? cmd : undefined;
+                return { type: "action", action: "Running", parameter: cmdStr?.slice(0, 120) ?? "command" };
+            }
+            if (type === "mcpToolCall") {
+                const server = typeof item.server === "string" ? item.server : "";
+                const tool = typeof item.tool === "string" ? item.tool : "";
+                return { type: "action", action: "Using", parameter: `${server}/${tool}` };
+            }
+            if (type === "dynamicToolCall") {
+                const tool = typeof item.tool === "string" ? item.tool : "tool";
+                return { type: "action", action: "Using", parameter: tool };
+            }
+        }
+        return undefined;
     }
     // ─── Active status for query ──────────────────────────────────────
     async getActiveRunStatus(issueKey) {

package/dist/service.js

@@ -289,6 +289,9 @@ export class PatchRelayService {
     async getIssueReport(issueKey) {
         return await this.queryService.getIssueReport(issueKey);
     }
+    async getIssueTimeline(issueKey) {
+        return await this.queryService.getIssueTimeline(issueKey);
+    }
     async getRunEvents(issueKey, runId) {
         return await this.queryService.getRunEvents(issueKey, runId);
     }

package/package.json

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

package/dist/cli/watch/FeedTimeline.js

@@ -1,23 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-const KIND_COLORS = {
-    stage: "cyan",
-    turn: "yellow",
-    github: "green",
-    webhook: "blue",
-    workflow: "magenta",
-    hook: "white",
-};
-function kindColor(kind) {
-    return KIND_COLORS[kind] ?? "white";
-}
-function formatTime(iso) {
-    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false });
-}
-export function FeedTimeline({ entries, maxEntries }) {
-    const visible = maxEntries ? entries.slice(-maxEntries) : entries;
-    if (visible.length === 0) {
-        return _jsx(Text, { dimColor: true, children: "No events yet." });
-    }
-    return (_jsx(Box, { flexDirection: "column", children: visible.map((entry, i) => (_jsxs(Box, { gap: 1, children: [_jsx(Text, { dimColor: true, children: formatTime(entry.at) }), _jsx(Text, { color: kindColor(entry.kind), children: (entry.status ?? entry.kind).padEnd(15) }), _jsx(Text, { children: entry.summary })] }, `feed-${i}`))) }));
-}

package/dist/cli/watch/ThreadView.js

@@ -1,26 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { TurnSection } from "./TurnSection.js";
-function planStepSymbol(status) {
-    if (status === "completed")
-        return "\u2713";
-    if (status === "inProgress")
-        return "\u25b8";
-    return " ";
-}
-function planStepColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "inProgress")
-        return "yellow";
-    return "white";
-}
-export function ThreadView({ thread, follow }) {
-    const visibleTurns = follow && thread.turns.length > 1
-        ? thread.turns.slice(-1)
-        : thread.turns;
-    const turnOffset = follow && thread.turns.length > 1
-        ? thread.turns.length - 1
-        : 0;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 2, children: [_jsxs(Text, { dimColor: true, children: ["Thread: ", thread.threadId.slice(0, 16)] }), _jsxs(Text, { dimColor: true, children: ["Status: ", thread.status] }), _jsxs(Text, { dimColor: true, children: ["Turns: ", thread.turns.length] })] }), thread.plan && thread.plan.length > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "Plan:" }), thread.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, { flexDirection: "column", marginTop: 1, children: visibleTurns.map((turn, i) => (_jsx(TurnSection, { turn: turn, index: i + turnOffset, follow: follow }, turn.id))) })] }));
-}

package/dist/cli/watch/TurnSection.js

@@ -1,20 +0,0 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { Box, Text } from "ink";
-import { ItemLine } from "./ItemLine.js";
-function turnStatusColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "failed" || status === "interrupted")
-        return "red";
-    if (status === "inProgress")
-        return "yellow";
-    return "white";
-}
-const FOLLOW_TAIL_SIZE = 8;
-export function TurnSection({ turn, index, follow }) {
-    const items = follow && turn.items.length > FOLLOW_TAIL_SIZE
-        ? turn.items.slice(-FOLLOW_TAIL_SIZE)
-        : turn.items;
-    const skipped = turn.items.length - items.length;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { gap: 1, children: [_jsxs(Text, { bold: true, children: ["Turn #", index + 1] }), _jsx(Text, { color: turnStatusColor(turn.status), children: turn.status }), _jsxs(Text, { dimColor: true, children: ["(", turn.items.length, " items)"] })] }), skipped > 0 && _jsxs(Text, { dimColor: true, children: ["  ... ", skipped, " earlier items"] }), items.map((item, i) => (_jsx(ItemLine, { item: item, isLast: i === items.length - 1 }, item.id)))] }));
-}