patchrelay 0.16.0 → 0.17.1

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/db/migrations.js

@@ -133,6 +133,10 @@ export function runPatchRelayMigrations(connection) {
     addColumnIfMissing(connection, "issues", "pending_merge_prep", "INTEGER NOT NULL DEFAULT 0");
     // Add merge_prep_attempts for retry budget / escalation
     addColumnIfMissing(connection, "issues", "merge_prep_attempts", "INTEGER NOT NULL DEFAULT 0");
+    // Add review_fix_attempts counter
+    addColumnIfMissing(connection, "issues", "review_fix_attempts", "INTEGER NOT NULL DEFAULT 0");
+    // Collapse awaiting_review into pr_open (state normalization)
+    connection.prepare("UPDATE issues SET factory_state = 'pr_open' WHERE factory_state = 'awaiting_review'").run();
 }
 function addColumnIfMissing(connection, table, column, definition) {
     const cols = connection.prepare(`PRAGMA table_info(${table})`).all();

package/dist/db.js

@@ -149,6 +149,10 @@ export class PatchRelayDatabase {
                 sets.push("queue_repair_attempts = @queueRepairAttempts");
                 values.queueRepairAttempts = params.queueRepairAttempts;
             }
+            if (params.reviewFixAttempts !== undefined) {
+                sets.push("review_fix_attempts = @reviewFixAttempts");
+                values.reviewFixAttempts = params.reviewFixAttempts;
+            }
             if (params.mergePrepAttempts !== undefined) {
                 sets.push("merge_prep_attempts = @mergePrepAttempts");
                 values.mergePrepAttempts = params.mergePrepAttempts;
@@ -389,6 +393,7 @@ function mapIssueRow(row) {
         ...(row.pr_check_status !== null && row.pr_check_status !== undefined ? { prCheckStatus: String(row.pr_check_status) } : {}),
         ciRepairAttempts: Number(row.ci_repair_attempts ?? 0),
         queueRepairAttempts: Number(row.queue_repair_attempts ?? 0),
+        reviewFixAttempts: Number(row.review_fix_attempts ?? 0),
         mergePrepAttempts: Number(row.merge_prep_attempts ?? 0),
         pendingMergePrep: Boolean(row.pending_merge_prep),
     };

package/dist/factory-state.js

@@ -5,10 +5,12 @@ export const ACTIVE_RUN_STATES = new Set([
     "changes_requested",
     "repairing_queue",
 ]);
-/** Which factory states are terminal (no further transitions possible). */
+/** Which factory states are terminal (no further transitions possible except pr_merged → done). */
 export const TERMINAL_STATES = new Set([
     "done",
     "escalated",
+    "failed",
+    "awaiting_input",
 ]);
 // ─── Semantic guards ─────────────────────────────────────────────
 //

package/dist/github-webhook-handler.js

@@ -158,8 +158,11 @@ export class GitHubWebhookHandler {
                 }
             }
         }
-        // Reset repair counters on new push
-        if (event.triggerEvent === "pr_synchronize") {
+        // Re-read issue after all upserts so reactive run logic sees current state
+        const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
+        // Reset repair counters on new push — but only when no repair run is active,
+        // since Codex pushes during repair and resetting mid-run would bypass budgets.
+        if (event.triggerEvent === "pr_synchronize" && !freshIssue.activeRunId) {
             this.db.upsertIssue({
                 projectId: issue.projectId,
                 linearIssueId: issue.linearIssueId,
@@ -167,8 +170,6 @@ export class GitHubWebhookHandler {
                 queueRepairAttempts: 0,
             });
         }
-        // Re-read issue after all upserts so reactive run logic sees current state
-        const freshIssue = this.db.getIssue(issue.projectId, issue.linearIssueId) ?? issue;
         this.logger.info({ issueKey: issue.issueKey, branchName: event.branchName, triggerEvent: event.triggerEvent, prNumber: event.prNumber }, "GitHub webhook: updated issue PR state");
         this.feed?.publish({
             level: event.triggerEvent.includes("failed") ? "warn" : "info",

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/linear-session-reporting.js

@@ -13,7 +13,6 @@ function describeNextState(state, prNumber) {
     const prLabel = prNumber ? `PR #${prNumber}` : "the pull request";
     switch (state) {
         case "pr_open":
-        case "awaiting_review":
             return `${prLabel} is ready for review.`;
         case "awaiting_queue":
             return `${prLabel} is approved and back in the merge flow.`;
@@ -149,7 +148,6 @@ export function buildMergePrepEscalationActivity(attempts) {
 }
 export function summarizeIssueStateForLinear(issue) {
     switch (issue.factoryState) {
-        case "awaiting_review":
         case "pr_open":
             return issue.prNumber ? `PR #${issue.prNumber} is awaiting review.` : "Awaiting review.";
         case "awaiting_queue":

package/dist/merge-queue.js

@@ -103,7 +103,6 @@ export class MergeQueue {
                 pendingRunType: "queue_repair",
                 pendingRunContextJson: JSON.stringify({ failureReason: "merge_conflict" }),
                 pendingMergePrep: false,
-                mergePrepAttempts: 0,
             });
             this.enqueueIssue(issue.projectId, issue.linearIssueId);
             this.feed?.publish({