patchrelay 0.23.5 → 0.24.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.23.5",
-  "commit": "65abb29863f7",
-  "builtAt": "2026-03-26T16:08:25.878Z"
+  "version": "0.24.0",
+  "commit": "1bc0f4083571",
+  "builtAt": "2026-03-26T16:28:13.654Z"
 }

package/dist/cli/watch/App.js

@@ -171,6 +171,12 @@ export function App({ baseUrl, bearerToken, initialIssueKey }) {
                     });
                 }
             }
+            else if (input === "h") {
+                dispatch({ type: "switch-detail-tab", tab: "history" });
+            }
+            else if (input === "t") {
+                dispatch({ type: "switch-detail-tab", tab: "timeline" });
+            }
             else if (input === "j" || key.downArrow) {
                 dispatch({ type: "detail-navigate", direction: "next", filtered });
             }
@@ -184,5 +190,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, tokenUsage: state.tokenUsage, diffSummary: state.diffSummary, plan: state.plan, issueContext: state.issueContext }), 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, 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,9 +5,14 @@ const HELP_TEXT = {
     detail: "",
     feed: "Esc: list  q: quit",
 };
-export function HelpBar({ view, follow }) {
-    const text = view === "detail"
-        ? `j/k: prev/next  Esc: list  f: follow ${follow ? "on" : "off"}  p: prompt  s: stop  r: retry  q: quit`
-        : HELP_TEXT[view];
+export function HelpBar({ view, follow, detailTab }) {
+    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`;
+    }
+    else {
+        text = HELP_TEXT[view];
+    }
     return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: text }) }));
 }

package/dist/cli/watch/IssueDetailView.js

@@ -1,8 +1,11 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
-import { useEffect, useReducer } from "react";
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useMemo, useReducer } from "react";
 import { Box, Text } from "ink";
 import { Timeline } from "./Timeline.js";
+import { StateHistoryView } from "./StateHistoryView.js";
+import { buildStateHistory } from "./history-builder.js";
 import { HelpBar } from "./HelpBar.js";
+import { planStepSymbol, planStepColor } from "./plan-helpers.js";
 function formatTokens(n) {
     if (n >= 1_000_000)
         return `${(n / 1_000_000).toFixed(1)}M`;
@@ -21,23 +24,9 @@ function ElapsedTime({ startedAt }) {
     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 planStepColor(status) {
-    if (status === "completed")
-        return "green";
-    if (status === "inProgress")
-        return "yellow";
-    return "white";
-}
-export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, tokenUsage, diffSummary, plan, issueContext, }) {
+export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, activeRunId, tokenUsage, diffSummary, plan, issueContext, detailTab, rawRuns, rawFeedEvents, }) {
     if (!issue) {
-        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow })] }));
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "red", children: "Issue not found." }), _jsx(HelpBar, { view: "detail", follow: follow, detailTab: detailTab })] }));
     }
     const key = issue.issueKey ?? issue.projectId;
     const meta = [];
@@ -47,5 +36,6 @@ export function IssueDetailView({ issue, timeline, follow, activeRunStartedAt, t
         meta.push(`${diffSummary.filesChanged}f +${diffSummary.linesAdded} -${diffSummary.linesRemoved}`);
     if (issueContext?.runCount)
         meta.push(`${issueContext.runCount} runs`);
-    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 }), 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(Box, { marginTop: 1, children: _jsx(HelpBar, { view: "detail", follow: follow }) })] }));
+    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 }) })] }));
 }

package/dist/cli/watch/StateHistoryView.js

@@ -0,0 +1,96 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Box, Text } from "ink";
+import { planStepSymbol, planStepColor } from "./plan-helpers.js";
+// ─── Formatting helpers ──────────────────────────────────────────
+function formatTime(iso) {
+    return new Date(iso).toLocaleTimeString("en-GB", { hour12: false, hour: "2-digit", minute: "2-digit", second: "2-digit" });
+}
+function formatDuration(startedAt, endedAt) {
+    const ms = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+    const seconds = Math.floor(ms / 1000);
+    if (seconds < 60)
+        return `${seconds}s`;
+    const minutes = Math.floor(seconds / 60);
+    const s = seconds % 60;
+    return `${minutes}m${s > 0 ? `${String(s).padStart(2, "0")}s` : ""}`;
+}
+const RUN_LABELS = {
+    implementation: "implementation",
+    ci_repair: "ci repair",
+    review_fix: "review fix",
+    queue_repair: "queue repair",
+};
+function runStatusSymbol(status) {
+    if (status === "completed")
+        return "\u2713";
+    if (status === "failed")
+        return "\u2717";
+    if (status === "running")
+        return "\u25b8";
+    return " ";
+}
+function runStatusColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "failed")
+        return "red";
+    if (status === "running")
+        return "yellow";
+    return "white";
+}
+const STATE_LABELS = {
+    delegated: "delegated",
+    preparing: "preparing",
+    implementing: "implementing",
+    pr_open: "pr open",
+    changes_requested: "changes requested",
+    repairing_ci: "repairing ci",
+    awaiting_queue: "awaiting queue",
+    repairing_queue: "repairing queue",
+    awaiting_input: "awaiting input",
+    escalated: "escalated",
+    done: "done",
+    failed: "failed",
+};
+// ─── Sub-components ──────────────────────────────────────────────
+function RunLine({ run, index }) {
+    const label = RUN_LABELS[run.runType] ?? run.runType;
+    const dur = run.endedAt
+        ? formatDuration(run.startedAt, run.endedAt)
+        : undefined;
+    const isActive = run.status === "running";
+    return (_jsxs(Box, { children: [_jsxs(Text, { color: runStatusColor(run.status), children: [runStatusSymbol(run.status), " "] }), _jsxs(Text, { dimColor: true, children: ["run #", index + 1, " "] }), _jsxs(Text, { children: ["(", label, ")"] }), dur && _jsxs(Text, { dimColor: true, children: [" ", dur] }), isActive && _jsx(Text, { dimColor: true, children: " ..." })] }));
+}
+function PlanSteps({ plan }) {
+    return (_jsx(Box, { flexDirection: "column", paddingLeft: 2, 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}`))) }));
+}
+function SideTripBlock({ trip, runOffset, isLast, }) {
+    const stateLabel = STATE_LABELS[trip.state] ?? trip.state;
+    const hasReturn = trip.returnedAt && trip.returnState !== trip.state;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " \u2502  \u250c " }), _jsx(Text, { color: "magenta", bold: true, children: stateLabel }), _jsxs(Text, { dimColor: true, children: ["  ", formatTime(trip.enteredAt)] })] }), trip.reason && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " \u2502  \u2502 " }), _jsx(Text, { dimColor: true, children: trip.reason })] })), trip.runs.map((run, ri) => (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " \u2502  \u2502 " }), _jsx(RunLine, { run: run, index: runOffset + ri })] }, `st-run-${run.id}`))), hasReturn ? (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " \u2502  \u2514\u2192 " }), _jsx(Text, { children: STATE_LABELS[trip.returnState] ?? trip.returnState }), trip.returnedAt && _jsxs(Text, { dimColor: true, children: ["  ", formatTime(trip.returnedAt)] })] })) : (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: " \u2502  \u2514\u2500" }), _jsx(Text, { dimColor: true, children: " (active)" })] })), !isLast && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: " \u2502" }) }))] }));
+}
+function MainPathNode({ node, isLast, runOffset, plan, activeRunId, }) {
+    const stateLabel = STATE_LABELS[node.state] ?? node.state;
+    const marker = node.isCurrent ? "\u25c9" : "\u25cb";
+    const stateColor = node.isCurrent ? "green" : "white";
+    const hasActiveRun = node.runs.some((r) => r.id === activeRunId);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { color: stateColor, bold: node.isCurrent, children: [" ", marker, " "] }), _jsx(Text, { color: stateColor, bold: node.isCurrent, children: stateLabel }), _jsxs(Text, { dimColor: true, children: ["  ", formatTime(node.enteredAt)] })] }), node.reason && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: isLast && node.sideTrips.length === 0 ? "   " : " \u2502 " }), _jsx(Text, { dimColor: true, children: node.reason })] })), node.runs.map((run, ri) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: isLast && node.sideTrips.length === 0 ? "   " : " \u2502 " }), _jsx(RunLine, { run: run, index: runOffset + ri })] }), run.id === activeRunId && plan && plan.length > 0 && (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: isLast ? "   " : " \u2502 " }), _jsx(PlanSteps, { plan: plan })] }))] }, `run-${run.id}`))), node.sideTrips.length > 0 && (_jsx(Box, { flexDirection: "column", children: node.sideTrips.map((trip, ti) => {
+                    // Count runs before this side-trip for numbering
+                    const priorSideTripRuns = node.sideTrips.slice(0, ti).reduce((acc, st) => acc + st.runs.length, 0);
+                    const tripRunOffset = runOffset + node.runs.length + priorSideTripRuns;
+                    return (_jsx(SideTripBlock, { trip: trip, runOffset: tripRunOffset, isLast: ti === node.sideTrips.length - 1 }, `trip-${ti}`));
+                }) })), !isLast && (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: " \u2502" }) }))] }));
+}
+// ─── Main component ──────────────────────────────────────────────
+export function StateHistoryView({ history, plan, activeRunId }) {
+    if (history.length === 0) {
+        return (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: "No state history available." }) }));
+    }
+    // Compute global run numbering (sequential across all nodes)
+    let runCounter = 0;
+    return (_jsx(Box, { flexDirection: "column", marginTop: 1, children: history.map((node, i) => {
+            const offset = runCounter;
+            runCounter += node.runs.length + node.sideTrips.reduce((acc, st) => acc + st.runs.length, 0);
+            return (_jsx(MainPathNode, { node: node, isLast: i === history.length - 1, runOffset: offset, plan: plan, activeRunId: activeRunId }, `node-${i}`));
+        }) }));
+}

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

@@ -0,0 +1,204 @@
+// ─── Constants ───────────────────────────────────────────────────
+const SIDE_TRIP_STATES = new Set(["changes_requested", "repairing_ci", "repairing_queue"]);
+const RUN_TYPE_TO_STATE = {
+    implementation: "implementing",
+    ci_repair: "repairing_ci",
+    review_fix: "changes_requested",
+    queue_repair: "repairing_queue",
+};
+function extractTransitions(feedEvents) {
+    const transitions = [];
+    for (const event of feedEvents) {
+        if (!event.stage)
+            continue;
+        let state;
+        let reason;
+        if (event.kind === "stage") {
+            if (event.status === "starting") {
+                // stage field is runType, map to factory state
+                state = RUN_TYPE_TO_STATE[event.stage] ?? event.stage;
+                reason = event.summary;
+            }
+            else if (event.status === "reconciled" || event.status === "retry" || event.status === "queued") {
+                state = event.stage;
+                reason = event.summary;
+            }
+        }
+        else if (event.kind === "github") {
+            // stage field is the factory state AFTER the transition
+            state = event.stage;
+            reason = event.summary;
+        }
+        if (state) {
+            // Deduplicate consecutive identical states
+            if (transitions.length > 0 && transitions[transitions.length - 1].state === state) {
+                continue;
+            }
+            transitions.push({ state, at: event.at, reason });
+        }
+    }
+    return transitions;
+}
+// ─── Run matching ────────────────────────────────────────────────
+function buildRunQueue(runs) {
+    // Group runs by their corresponding factory state, preserving chronological order.
+    // Each call to consumeNextRun() pops from the front.
+    const map = new Map();
+    for (const run of runs) {
+        const state = RUN_TYPE_TO_STATE[run.runType] ?? run.runType;
+        const info = {
+            id: run.id,
+            runType: run.runType,
+            status: run.status,
+            startedAt: run.startedAt,
+            endedAt: run.endedAt,
+        };
+        const list = map.get(state);
+        if (list) {
+            list.push(info);
+        }
+        else {
+            map.set(state, [info]);
+        }
+    }
+    return map;
+}
+// ─── Tree builder ────────────────────────────────────────────────
+export function buildStateHistory(runs, feedEvents, currentFactoryState, activeRunId) {
+    const transitions = extractTransitions(feedEvents);
+    const runQueue = buildRunQueue(runs);
+    function consumeNextRun(state) {
+        const queue = runQueue.get(state);
+        if (!queue || queue.length === 0)
+            return [];
+        const run = queue.shift();
+        return run ? [run] : [];
+    }
+    // Walk transitions and build nodes
+    const nodes = [];
+    let currentMainNode = null;
+    let currentSideTrip = null;
+    for (let i = 0; i < transitions.length; i++) {
+        const t = transitions[i];
+        const isSideTrip = SIDE_TRIP_STATES.has(t.state);
+        if (isSideTrip) {
+            // Start or continue a side-trip
+            if (currentSideTrip) {
+                // Close previous side-trip first (nested side-trip is rare but handle it)
+                closeSideTrip(currentMainNode, currentSideTrip, t.state, t.at);
+            }
+            currentSideTrip = {
+                state: t.state,
+                enteredAt: t.at,
+                reason: t.reason,
+                returnState: "",
+                runs: [],
+            };
+        }
+        else {
+            // Main-path state
+            if (currentSideTrip && currentMainNode) {
+                // Close the active side-trip — we're returning to the main path
+                // Consume runs for the side-trip state now
+                currentSideTrip.runs = consumeNextRun(currentSideTrip.state);
+                currentSideTrip.returnState = t.state;
+                currentSideTrip.returnedAt = t.at;
+                currentMainNode.sideTrips.push(currentSideTrip);
+                currentSideTrip = null;
+            }
+            // Skip duplicate main-path nodes if returning to the same state (e.g., pr_open → changes_requested → pr_open)
+            if (currentMainNode && currentMainNode.state === t.state) {
+                // Same main-path state revisited — don't create a new node
+                continue;
+            }
+            currentMainNode = {
+                state: t.state,
+                enteredAt: t.at,
+                reason: t.reason,
+                isCurrent: false,
+                runs: consumeNextRun(t.state),
+                sideTrips: [],
+            };
+            nodes.push(currentMainNode);
+        }
+    }
+    // If we ended in a side-trip (e.g., currently repairing_ci), close it
+    if (currentSideTrip && currentMainNode) {
+        currentSideTrip.runs = consumeNextRun(currentSideTrip.state);
+        currentSideTrip.returnState = currentFactoryState;
+        currentMainNode.sideTrips.push(currentSideTrip);
+    }
+    // Handle edge case: no transitions extracted but we have runs
+    if (nodes.length === 0 && runs.length > 0) {
+        // Seed with delegated state from earliest run
+        const earliest = runs[0];
+        nodes.push({
+            state: "delegated",
+            enteredAt: earliest.startedAt,
+            isCurrent: currentFactoryState === "delegated",
+            runs: [],
+            sideTrips: [],
+        });
+        const implState = RUN_TYPE_TO_STATE[earliest.runType] ?? "implementing";
+        nodes.push({
+            state: implState,
+            enteredAt: earliest.startedAt,
+            isCurrent: currentFactoryState === implState,
+            runs: consumeNextRun(implState),
+            sideTrips: [],
+        });
+    }
+    // Mark the current state
+    markCurrent(nodes, currentFactoryState);
+    // Mark active run
+    if (activeRunId !== null) {
+        markActiveRun(nodes, activeRunId);
+    }
+    return nodes;
+}
+function closeSideTrip(mainNode, sideTrip, returnState, returnedAt) {
+    if (!mainNode)
+        return;
+    sideTrip.returnState = returnState;
+    sideTrip.returnedAt = returnedAt;
+    mainNode.sideTrips.push(sideTrip);
+}
+function markCurrent(nodes, currentState) {
+    // If current state is a side-trip state, mark the last main node as current
+    // (the side-trip is "in progress" from that main node)
+    if (SIDE_TRIP_STATES.has(currentState)) {
+        if (nodes.length > 0) {
+            nodes[nodes.length - 1].isCurrent = true;
+        }
+        return;
+    }
+    // Find the last node matching the current state
+    for (let i = nodes.length - 1; i >= 0; i--) {
+        if (nodes[i].state === currentState) {
+            nodes[i].isCurrent = true;
+            return;
+        }
+    }
+    // Fallback: mark the last node
+    if (nodes.length > 0) {
+        nodes[nodes.length - 1].isCurrent = true;
+    }
+}
+function markActiveRun(nodes, activeRunId) {
+    for (const node of nodes) {
+        for (const run of node.runs) {
+            if (run.id === activeRunId) {
+                run.status = "running";
+                return;
+            }
+        }
+        for (const trip of node.sideTrips) {
+            for (const run of trip.runs) {
+                if (run.id === activeRunId) {
+                    run.status = "running";
+                    return;
+                }
+            }
+        }
+    }
+}

package/dist/cli/watch/plan-helpers.js

@@ -0,0 +1,14 @@
+export function planStepSymbol(status) {
+    if (status === "completed")
+        return "\u2713";
+    if (status === "inProgress")
+        return "\u25b8";
+    return " ";
+}
+export function planStepColor(status) {
+    if (status === "completed")
+        return "green";
+    if (status === "inProgress")
+        return "yellow";
+    return "white";
+}

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

@@ -1,6 +1,9 @@
 import { buildTimelineFromRehydration, appendFeedToTimeline, appendCodexItemToTimeline, completeCodexItemInTimeline, appendDeltaToTimelineItem, } from "./timeline-builder.js";
 const DETAIL_INITIAL = {
+    detailTab: "timeline",
     timeline: [],
+    rawRuns: [],
+    rawFeedEvents: [],
     activeRunId: null,
     activeRunStartedAt: null,
     tokenUsage: null,
@@ -96,6 +99,8 @@ export function watchReducer(state, action) {
             return {
                 ...state,
                 timeline,
+                rawRuns: action.runs,
+                rawFeedEvents: action.feedEvents,
                 activeRunId: action.activeRunId,
                 activeRunStartedAt: activeRun?.startedAt ?? null,
                 issueContext: action.issueContext,
@@ -115,6 +120,8 @@ export function watchReducer(state, action) {
             return { ...state, feedEvents: action.events };
         case "feed-new-event":
             return { ...state, feedEvents: [...state.feedEvents, action.event] };
+        case "switch-detail-tab":
+            return { ...state, detailTab: action.tab };
     }
 }
 // ─── Feed Event → Issue List + Timeline ───────────────────────────
@@ -147,11 +154,15 @@ function applyFeedEvent(state, event) {
     }
     issue.updatedAt = event.at;
     updated[index] = issue;
-    // Append to timeline if this event matches the active detail issue
-    const timeline = state.view === "detail" && state.activeDetailKey === event.issueKey
+    // Append to timeline and raw feed events if this event matches the active detail issue
+    const isActiveDetail = state.view === "detail" && state.activeDetailKey === event.issueKey;
+    const timeline = isActiveDetail
         ? appendFeedToTimeline(state.timeline, event)
         : state.timeline;
-    return { ...state, issues: updated, timeline };
+    const rawFeedEvents = isActiveDetail
+        ? [...state.rawFeedEvents, event]
+        : state.rawFeedEvents;
+    return { ...state, issues: updated, timeline, rawFeedEvents };
 }
 // ─── Codex Notification → Timeline + Metadata ─────────────────────
 function applyCodexNotification(state, method, params) {

package/package.json

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