patchrelay 0.23.4 → 0.24.0

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.23.4",
-  "commit": "650e9c85fdcf",
-  "builtAt": "2026-03-26T13:49:43.718Z"
+  "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/dist/db/migrations.js

@@ -141,6 +141,9 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "description", "TEXT");
     addColumnIfMissing(connection, "issues", "priority", "INTEGER");
     addColumnIfMissing(connection, "issues", "estimate", "REAL");
+    // Zombie/stale recovery backoff
+    addColumnIfMissing(connection, "issues", "zombie_recovery_attempts", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(connection, "issues", "last_zombie_recovery_at", "TEXT");
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -173,6 +173,14 @@ export class PatchRelayDatabase {
                 sets.push("pending_merge_prep = @pendingMergePrep");
                 values.pendingMergePrep = params.pendingMergePrep ? 1 : 0;
             }
+            if (params.zombieRecoveryAttempts !== undefined) {
+                sets.push("zombie_recovery_attempts = @zombieRecoveryAttempts");
+                values.zombieRecoveryAttempts = params.zombieRecoveryAttempts;
+            }
+            if (params.lastZombieRecoveryAt !== undefined) {
+                sets.push("last_zombie_recovery_at = @lastZombieRecoveryAt");
+                values.lastZombieRecoveryAt = params.lastZombieRecoveryAt;
+            }
             this.connection.prepare(`UPDATE issues SET ${sets.join(", ")} WHERE project_id = @projectId AND linear_issue_id = @linearIssueId`).run(values);
         }
         else {
@@ -424,6 +432,8 @@ function mapIssueRow(row) {
         reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         mergePrepAttempts: Number(row.merge_prep_attempts ?? 0),
         pendingMergePrep: Boolean(row.pending_merge_prep),
+        zombieRecoveryAttempts: Number(row.zombie_recovery_attempts ?? 0),
+        ...(row.last_zombie_recovery_at !== null && row.last_zombie_recovery_at !== undefined ? { lastZombieRecoveryAt: String(row.last_zombie_recovery_at) } : {}),
     };
 }
 function mapRunRow(row) {

package/dist/github-webhook-handler.js

@@ -1,4 +1,4 @@
-import { resolveFactoryStateFromGitHub } from "./factory-state.js";
+import { resolveFactoryStateFromGitHub, TERMINAL_STATES } from "./factory-state.js";
 import { normalizeGitHubWebhook, verifyGitHubWebhookSignature } from "./github-webhooks.js";
 import { buildAgentSessionPlanForIssue } from "./agent-session-plan.js";
 import { buildAgentSessionExternalUrls } from "./agent-session-presentation.js";
@@ -202,6 +202,10 @@ export class GitHubWebhookHandler {
         // Don't trigger if there's already an active run
         if (issue.activeRunId !== undefined)
             return;
+        // Don't trigger on terminal issues — late-arriving webhooks (e.g.
+        // merge_group_failed after pr_merged) must not resurrect done issues.
+        if (TERMINAL_STATES.has(issue.factoryState))
+            return;
         if (event.triggerEvent === "check_failed" && issue.prState === "open") {
             this.db.upsertIssue({
                 projectId: issue.projectId,

package/dist/run-orchestrator.js

@@ -1,6 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { ACTIVE_RUN_STATES } from "./factory-state.js";
+import { ACTIVE_RUN_STATES, TERMINAL_STATES } from "./factory-state.js";
 import { buildHookEnv, runProjectHook } from "./hook-runner.js";
 import { buildAgentSessionPlanForIssue, } from "./agent-session-plan.js";
 import { buildStageReport, countEventMethods, extractTurnId, resolveRunCompletionStatus, summarizeCurrentThread, } from "./run-reporting.js";
@@ -12,6 +12,8 @@ import { execCommand } from "./utils.js";
 const DEFAULT_CI_REPAIR_BUDGET = 3;
 const DEFAULT_QUEUE_REPAIR_BUDGET = 3;
 const DEFAULT_REVIEW_FIX_BUDGET = 3;
+const DEFAULT_ZOMBIE_RECOVERY_BUDGET = 5;
+const ZOMBIE_RECOVERY_BASE_DELAY_MS = 15_000; // 15s, 30s, 60s, 120s, 240s
 function slugify(value) {
     return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
 }
@@ -191,7 +193,10 @@ export class RunOrchestrator {
             // Freshen the worktree: fetch + rebase onto latest base branch.
             // This prevents branch contamination when local main has drifted
             // and avoids scope-bundling review rejections from stale commits.
-            await this.freshenWorktree(worktreePath, project, issue);
+            // Skip for queue_repair — its entire purpose is to resolve rebase conflicts.
+            if (runType !== "queue_repair") {
+                await this.freshenWorktree(worktreePath, project, issue);
+            }
             // Run prepare-worktree hook
             const hookEnv = buildHookEnv(issue.issueKey ?? issue.linearIssueId, branchName, runType, worktreePath);
             const prepareResult = await runProjectHook(project.repoPath, "prepare-worktree", { cwd: worktreePath, env: hookEnv });
@@ -244,6 +249,15 @@ export class RunOrchestrator {
             throw error;
         }
         this.db.updateRunThread(run.id, { threadId, turnId });
+        // Reset zombie recovery counter — this run started successfully
+        if (issue.zombieRecoveryAttempts > 0) {
+            this.db.upsertIssue({
+                projectId: item.projectId,
+                linearIssueId: item.issueId,
+                zombieRecoveryAttempts: 0,
+                lastZombieRecoveryAt: null,
+            });
+        }
         this.logger.info({ issueKey: issue.issueKey, runType, threadId, turnId }, `Started ${runType} run`);
         // Emit Linear activity + plan
         const freshIssue = this.db.getIssue(item.projectId, item.issueId) ?? issue;
@@ -286,11 +300,14 @@ export class RunOrchestrator {
         // Rebase onto latest base
         const rebaseResult = await execCommand(gitBin, ["-C", worktreePath, "rebase", `origin/${baseBranch}`], { timeoutMs: 120_000 });
         if (rebaseResult.exitCode !== 0) {
-            // Abort the failed rebase and restore state
+            // Abort the failed rebase and restore state — then let the agent run
+            // proceed. The agent can resolve the conflict itself (the workflow
+            // prompt tells it to rebase and handle conflicts).
             await execCommand(gitBin, ["-C", worktreePath, "rebase", "--abort"], { timeoutMs: 10_000 });
             if (didStash)
                 await execCommand(gitBin, ["-C", worktreePath, "stash", "pop"], { timeoutMs: 10_000 });
-            throw new Error(`Pre-run rebase onto origin/${baseBranch} failed with conflicts — escalate or resolve manually`);
+            this.logger.warn({ issueKey: issue.issueKey, baseBranch }, "Pre-run freshen: rebase conflict, agent will resolve");
+            return;
         }
         // Push the rebased branch (force-with-lease to protect against concurrent pushes)
         const pushResult = await execCommand(gitBin, ["-C", worktreePath, "push", "--force-with-lease"], { timeoutMs: 60_000 });
@@ -563,26 +580,91 @@ export class RunOrchestrator {
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
         }
     }
+    /**
+     * After a zombie/stale run is cleared, decide whether to re-enqueue
+     * or escalate. Checks: PR already merged → done; budget exhausted →
+     * escalate; backoff delay not elapsed → skip.
+     */
+    recoverOrEscalate(issue, runType, reason) {
+        // Re-read issue after the run was cleared (activeRunId is now null)
+        const fresh = this.db.getIssue(issue.projectId, issue.linearIssueId);
+        if (!fresh)
+            return;
+        // If PR already merged, transition to done — no retry needed
+        if (fresh.prState === "merged") {
+            this.db.upsertIssue({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                factoryState: "done",
+                zombieRecoveryAttempts: 0,
+                lastZombieRecoveryAt: null,
+            });
+            this.logger.info({ issueKey: fresh.issueKey, reason }, "Recovery: PR already merged — transitioning to done");
+            return;
+        }
+        // Budget check
+        const attempts = fresh.zombieRecoveryAttempts + 1;
+        if (attempts > DEFAULT_ZOMBIE_RECOVERY_BUDGET) {
+            this.db.upsertIssue({
+                projectId: fresh.projectId,
+                linearIssueId: fresh.linearIssueId,
+                factoryState: "escalated",
+            });
+            this.logger.warn({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: budget exhausted — escalating");
+            this.feed?.publish({
+                level: "error",
+                kind: "workflow",
+                issueKey: fresh.issueKey,
+                projectId: fresh.projectId,
+                stage: "escalated",
+                status: "budget_exhausted",
+                summary: `${reason} recovery failed after ${DEFAULT_ZOMBIE_RECOVERY_BUDGET} attempts`,
+            });
+            return;
+        }
+        // Exponential backoff — skip if delay hasn't elapsed
+        if (fresh.lastZombieRecoveryAt) {
+            const elapsed = Date.now() - new Date(fresh.lastZombieRecoveryAt).getTime();
+            const delay = ZOMBIE_RECOVERY_BASE_DELAY_MS * Math.pow(2, fresh.zombieRecoveryAttempts);
+            if (elapsed < delay) {
+                this.logger.debug({ issueKey: fresh.issueKey, attempts: fresh.zombieRecoveryAttempts, delay, elapsed }, "Recovery: backoff not elapsed, skipping");
+                return;
+            }
+        }
+        // Re-enqueue with backoff tracking
+        this.db.upsertIssue({
+            projectId: fresh.projectId,
+            linearIssueId: fresh.linearIssueId,
+            pendingRunType: runType,
+            pendingRunContextJson: null,
+            zombieRecoveryAttempts: attempts,
+            lastZombieRecoveryAt: new Date().toISOString(),
+        });
+        this.enqueueIssue(fresh.projectId, fresh.linearIssueId);
+        this.logger.info({ issueKey: fresh.issueKey, attempts, reason }, "Recovery: re-enqueued with backoff");
+    }
     async reconcileRun(run) {
         const issue = this.db.getIssue(run.projectId, run.linearIssueId);
         if (!issue)
             return;
+        // If the issue reached a terminal state while this run was active
+        // (e.g. pr_merged processed, DB manually edited), just release the run.
+        if (TERMINAL_STATES.has(issue.factoryState)) {
+            this.db.transaction(() => {
+                this.db.finishRun(run.id, { status: "released", failureReason: "Issue reached terminal state during active run" });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
+            });
+            this.logger.info({ issueKey: issue.issueKey, runId: run.id, factoryState: issue.factoryState }, "Reconciliation: released run on terminal issue");
+            return;
+        }
         // Zombie run: claimed in DB but Codex never started (no thread).
-        // This happens when the service crashes between claiming the run
-        // and starting the Codex turn. Re-enqueue instead of failing.
         if (!run.threadId) {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread) — clearing and re-enqueueing");
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType }, "Zombie run detected (no thread)");
             this.db.transaction(() => {
                 this.db.finishRun(run.id, { status: "failed", failureReason: "Zombie: never started (no thread after restart)" });
-                this.db.upsertIssue({
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    pendingRunType: run.runType,
-                    pendingRunContextJson: null,
-                });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.recoverOrEscalate(issue, run.runType, "zombie");
             return;
         }
         // Read Codex state — thread may not exist after app-server restart.
@@ -591,18 +673,12 @@ export class RunOrchestrator {
             thread = await this.readThreadWithRetry(run.threadId);
         }
         catch {
-            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation — clearing and re-enqueueing");
+            this.logger.warn({ issueKey: issue.issueKey, runId: run.id, runType: run.runType, threadId: run.threadId }, "Stale thread during reconciliation");
             this.db.transaction(() => {
                 this.db.finishRun(run.id, { status: "failed", failureReason: "Stale thread after restart" });
-                this.db.upsertIssue({
-                    projectId: run.projectId,
-                    linearIssueId: run.linearIssueId,
-                    activeRunId: null,
-                    pendingRunType: run.runType,
-                    pendingRunContextJson: null,
-                });
+                this.db.upsertIssue({ projectId: run.projectId, linearIssueId: run.linearIssueId, activeRunId: null });
             });
-            this.enqueueIssue(run.projectId, run.linearIssueId);
+            this.recoverOrEscalate(issue, run.runType, "stale_thread");
             return;
         }
         // Check Linear state (non-fatal — token refresh may fail)

package/dist/worktree-manager.js

@@ -12,7 +12,13 @@ export class WorktreeManager {
             return;
         }
         await ensureDir(path.dirname(worktreePath));
-        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "HEAD"], {
+        // Fetch latest main so the branch forks from a clean, up-to-date base.
+        // This prevents branch contamination when local HEAD has drifted.
+        // freshenWorktree in run-orchestrator acts as a secondary safety net.
+        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", "main"], {
+            timeoutMs: 60_000,
+        });
+        await execCommand(this.config.runner.gitBin, ["-C", repoPath, "worktree", "add", "--force", "-B", branchName, worktreePath, "origin/main"], {
             timeoutMs: 120_000,
         });
     }

package/package.json

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