patchrelay 0.35.11 → 0.35.12

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

@@ -16,9 +16,6 @@ const PR_LOOP_STATES = ["changes_requested", "repairing_ci"];
 const QUEUE_LOOP_STATES = ["repairing_queue"];
 const EXIT_STATES = ["awaiting_input", "escalated", "failed"];
 const QUEUE_EVENT_STATUSES = new Set([
-    "queue_label_requested",
-    "queue_label_applied",
-    "queue_label_failed",
     "queue_repair_queued",
     "pr_merged",
 ]);
@@ -61,12 +58,6 @@ function latestQueueObservationEvent(feedEvents) {
 }
 function describeObservationEvent(event) {
     switch (event.status) {
-        case "queue_label_requested":
-            return { tone: "info", text: event.summary };
-        case "queue_label_applied":
-            return { tone: "success", text: event.summary };
-        case "queue_label_failed":
-            return { tone: "warn", text: event.summary };
         case "queue_repair_queued":
             return { tone: "warn", text: event.summary };
         case "pr_merged":
@@ -82,10 +73,10 @@ function describeObservationEvent(event) {
                 const active = event.status === "starting";
                 return {
                     tone: active ? "warn" : "info",
-                    text: active ? "PatchRelay is actively running queue repair." : event.summary,
+                    text: active ? "PatchRelay is actively running queue repair." : `Observed queue signal: ${event.summary}`,
                 };
             }
-            return { tone: "info", text: event.summary };
+            return { tone: "info", text: `Observed signal: ${event.summary}` };
     }
 }
 export function buildPatchRelayStateGraph(history, currentFactoryState) {
@@ -99,19 +90,23 @@ export function buildPatchRelayStateGraph(history, currentFactoryState) {
 }
 export function buildPatchRelayQueueObservations(issue, feedEvents) {
     const observations = [];
-    switch (issue.factoryState) {
-        case "awaiting_queue":
+    switch (issue.sessionState) {
+        case "waiting_input":
+            observations.push({
+                tone: "warn",
+                text: issue.waitingReason ?? "PatchRelay is waiting for input before continuing.",
+            });
+            break;
+        case "running":
             observations.push({
                 tone: "info",
-                text: "PatchRelay has finished branch work and is waiting for external queue progress.",
+                text: "PatchRelay is actively working this session.",
             });
             break;
-        case "repairing_queue":
+        case "idle":
             observations.push({
-                tone: issue.activeRunType === "queue_repair" ? "warn" : "info",
-                text: issue.activeRunType === "queue_repair"
-                    ? "PatchRelay is actively repairing a queue eviction."
-                    : "PatchRelay is preparing or waiting to resume queue repair.",
+                tone: "info",
+                text: "PatchRelay is idle for this issue.",
             });
             break;
         case "done":
@@ -120,12 +115,42 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
                 text: "PatchRelay is complete because GitHub reports the PR has merged.",
             });
             break;
-        default:
+        case "failed":
             observations.push({
-                tone: "info",
-                text: "Queue hand-off has not started yet; PatchRelay still owns the issue workflow.",
+                tone: "warn",
+                text: "PatchRelay needs human help to recover this session.",
             });
             break;
+        default:
+            switch (issue.factoryState) {
+                case "awaiting_queue":
+                    observations.push({
+                        tone: "info",
+                        text: "PatchRelay has finished active work and is waiting for downstream merge flow.",
+                    });
+                    break;
+                case "repairing_queue":
+                    observations.push({
+                        tone: issue.activeRunType === "queue_repair" ? "warn" : "info",
+                        text: issue.activeRunType === "queue_repair"
+                            ? "PatchRelay is actively repairing a queue eviction."
+                            : "PatchRelay is preparing or waiting to resume queue repair.",
+                    });
+                    break;
+                case "done":
+                    observations.push({
+                        tone: "success",
+                        text: "PatchRelay is complete because GitHub reports the PR has merged.",
+                    });
+                    break;
+                default:
+                    observations.push({
+                        tone: "info",
+                        text: "PatchRelay is tracking this issue.",
+                    });
+                    break;
+            }
+            break;
     }
     const latestEvent = latestQueueObservationEvent(feedEvents);
     if (latestEvent) {
@@ -134,7 +159,7 @@ export function buildPatchRelayQueueObservations(issue, feedEvents) {
     else if (issue.factoryState === "awaiting_queue") {
         observations.push({
             tone: "info",
-            text: "No external queue signal has been observed yet.",
+            text: "No downstream queue signal has been observed yet.",
         });
     }
     if (issue.prNumber !== undefined) {

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

@@ -1,3 +1,4 @@
+import { getThreadTurns } from "../../codex-thread-utils.js";
 // ─── Build Timeline from Rehydration Data ─────────────────────────
 export function buildTimelineFromRehydration(runs, feedEvents, liveThread, activeRunId) {
     const entries = [];
@@ -132,7 +133,7 @@ function syntheticTimestamp(startMs, endMs, index, total) {
 // ─── Items from Live Thread ───────────────────────────────────────
 function itemsFromThread(runId, thread) {
     const entries = [];
-    for (const turn of thread.turns) {
+    for (const turn of getThreadTurns(thread)) {
         for (const item of turn.items) {
             entries.push({
                 id: `live-${item.id}`,

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

@@ -14,11 +14,12 @@ export function useDetailStream(options) {
         if (bearerToken) {
             headers.authorization = `Bearer ${bearerToken}`;
         }
-        // Rehydrate from timeline endpoint
         void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
-        // Stream codex notifications + feed events via filtered SSE
-        void streamEvents(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        const intervalId = setInterval(() => {
+            void rehydrate(baseUrl, issueKey, headers, abortController.signal, dispatch);
+        }, 3000);
         return () => {
+            clearInterval(intervalId);
             abortController.abort();
         };
     }, [options.issueKey, options.active]);
@@ -26,117 +27,22 @@ export function useDetailStream(options) {
 // ─── Rehydration ──────────────────────────────────────────────────
 async function rehydrate(baseUrl, issueKey, headers, signal, dispatch) {
     try {
-        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}/timeline`, baseUrl);
+        const url = new URL(`/api/issues/${encodeURIComponent(issueKey)}`, baseUrl);
         const response = await fetch(url, { headers: { ...headers, accept: "application/json" }, signal });
         if (!response.ok)
             return;
         const data = await response.json();
-        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.events ? { events: r.events } : {}),
-            ...(r.report ? { report: r.report } : {}),
-        }));
-        let issueContext = null;
-        if (data.issue) {
-            const i = data.issue;
-            issueContext = {
-                description: typeof i.description === "string" ? i.description : undefined,
-                currentLinearState: typeof i.currentLinearState === "string" ? i.currentLinearState : undefined,
-                issueUrl: typeof i.issueUrl === "string" ? i.issueUrl : undefined,
-                worktreePath: typeof i.worktreePath === "string" ? i.worktreePath : undefined,
-                branchName: typeof i.branchName === "string" ? i.branchName : undefined,
-                prUrl: typeof i.prUrl === "string" ? i.prUrl : undefined,
-                priority: typeof i.priority === "number" ? i.priority : undefined,
-                estimate: typeof i.estimate === "number" ? i.estimate : undefined,
-                ciRepairAttempts: typeof i.ciRepairAttempts === "number" ? i.ciRepairAttempts : 0,
-                queueRepairAttempts: typeof i.queueRepairAttempts === "number" ? i.queueRepairAttempts : 0,
-                reviewFixAttempts: typeof i.reviewFixAttempts === "number" ? i.reviewFixAttempts : 0,
-                latestFailureSource: typeof i.latestFailureSource === "string" ? i.latestFailureSource : undefined,
-                latestFailureHeadSha: typeof i.latestFailureHeadSha === "string" ? i.latestFailureHeadSha : undefined,
-                latestFailureCheckName: typeof i.latestFailureCheckName === "string" ? i.latestFailureCheckName : undefined,
-                latestFailureStepName: typeof i.latestFailureStepName === "string" ? i.latestFailureStepName : undefined,
-                latestFailureSummary: typeof i.latestFailureSummary === "string" ? i.latestFailureSummary : undefined,
-                runCount: runs.length,
-            };
-        }
         dispatch({
             type: "timeline-rehydrate",
-            runs,
-            feedEvents: data.feedEvents ?? [],
+            runs: Array.isArray(data.runs) ? data.runs : [],
+            feedEvents: [],
             liveThread: data.liveThread ?? null,
-            activeRunId: data.activeRunId ?? null,
-            issueContext,
+            activeRunId: data.activeRun?.id ?? null,
+            activeRunStartedAt: data.activeRun?.startedAt ?? null,
+            issueContext: data.issueContext ?? null,
         });
     }
     catch {
         // Rehydration is best-effort
     }
 }
-// ─── Live SSE Stream ──────────────────────────────────────────────
-async function streamEvents(baseUrl, issueKey, baseHeaders, signal, dispatch) {
-    try {
-        const url = new URL("/api/watch", baseUrl);
-        url.searchParams.set("issue", issueKey);
-        const headers = { ...baseHeaders, accept: "text/event-stream" };
-        const response = await fetch(url, { headers, signal });
-        if (!response.ok || !response.body)
-            return;
-        const reader = response.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        let eventType = "";
-        let dataLines = [];
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            let newlineIndex = buffer.indexOf("\n");
-            while (newlineIndex !== -1) {
-                const rawLine = buffer.slice(0, newlineIndex);
-                buffer = buffer.slice(newlineIndex + 1);
-                const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-                if (!line) {
-                    if (dataLines.length > 0) {
-                        processEvent(dispatch, eventType, dataLines.join("\n"));
-                        dataLines = [];
-                        eventType = "";
-                    }
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                if (line.startsWith(":")) {
-                    newlineIndex = buffer.indexOf("\n");
-                    continue;
-                }
-                if (line.startsWith("event:")) {
-                    eventType = line.slice(6).trim();
-                }
-                else if (line.startsWith("data:")) {
-                    dataLines.push(line.slice(5).trimStart());
-                }
-                newlineIndex = buffer.indexOf("\n");
-            }
-        }
-    }
-    catch {
-        // Stream ended or aborted
-    }
-}
-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 handled by the main watch stream
-    }
-    catch {
-        // Ignore parse errors
-    }
-}

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

@@ -5,127 +5,36 @@ export function useWatchStream(options) {
     useEffect(() => {
         if (options.active === false)
             return;
-        let abortController = new AbortController();
-        let reconnectTimeout;
-        let attempt = 0;
+        const abortController = new AbortController();
         const fetchIssueSnapshot = async () => {
             const { baseUrl, bearerToken, dispatch } = optionsRef.current;
             const headers = { accept: "application/json" };
             if (bearerToken) {
                 headers.authorization = `Bearer ${bearerToken}`;
             }
-            const response = await fetch(new URL("/api/watch/issues", baseUrl), { headers });
+            const response = await fetch(new URL("/api/issues", baseUrl), { headers, signal: abortController.signal });
             if (!response.ok) {
                 throw new Error(`Issue snapshot failed: ${response.status}`);
             }
             const payload = await response.json();
+            dispatch({ type: "connected" });
             dispatch({ type: "issues-snapshot", issues: Array.isArray(payload.issues) ? payload.issues : [], receivedAt: Date.now() });
         };
-        const connect = () => {
-            abortController = new AbortController();
-            const { baseUrl, bearerToken, issueFilter, dispatch } = optionsRef.current;
-            const url = new URL("/api/watch", baseUrl);
-            if (issueFilter) {
-                url.searchParams.set("issue", issueFilter);
+        void fetchIssueSnapshot().catch(() => {
+            if (!abortController.signal.aborted) {
+                optionsRef.current.dispatch({ type: "disconnected" });
             }
-            const headers = { accept: "text/event-stream" };
-            if (bearerToken) {
-                headers.authorization = `Bearer ${bearerToken}`;
-            }
-            void fetch(url, { headers, signal: abortController.signal })
-                .then(async (response) => {
-                if (!response.ok || !response.body) {
-                    throw new Error(`Watch stream failed: ${response.status}`);
-                }
-                dispatch({ type: "connected" });
-                attempt = 0;
-                try {
-                    await fetchIssueSnapshot();
-                }
-                catch {
-                    // Keep the stream alive even if the snapshot endpoint temporarily fails.
-                }
-                const reader = response.body.getReader();
-                const decoder = new TextDecoder();
-                let buffer = "";
-                let eventType = "";
-                let dataLines = [];
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
-                    buffer += decoder.decode(value, { stream: true });
-                    let newlineIndex = buffer.indexOf("\n");
-                    while (newlineIndex !== -1) {
-                        const rawLine = buffer.slice(0, newlineIndex);
-                        buffer = buffer.slice(newlineIndex + 1);
-                        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
-                        if (!line) {
-                            if (dataLines.length > 0) {
-                                processEvent(dispatch, eventType, dataLines.join("\n"));
-                                dataLines = [];
-                                eventType = "";
-                            }
-                            newlineIndex = buffer.indexOf("\n");
-                            continue;
-                        }
-                        if (line.startsWith(":")) {
-                            if (line.includes("keepalive")) {
-                                dispatch({ type: "stream-heartbeat", receivedAt: Date.now() });
-                            }
-                            newlineIndex = buffer.indexOf("\n");
-                            continue;
-                        }
-                        if (line.startsWith("event:")) {
-                            eventType = line.slice(6).trim();
-                        }
-                        else if (line.startsWith("data:")) {
-                            dataLines.push(line.slice(5).trimStart());
-                        }
-                        newlineIndex = buffer.indexOf("\n");
-                    }
+        });
+        const snapshotInterval = setInterval(() => {
+            void fetchIssueSnapshot().catch(() => {
+                if (!abortController.signal.aborted) {
+                    optionsRef.current.dispatch({ type: "disconnected" });
                 }
-            })
-                .catch((error) => {
-                if (abortController.signal.aborted)
-                    return;
-                const _msg = error instanceof Error ? error.message : String(error);
-            })
-                .finally(() => {
-                if (abortController.signal.aborted)
-                    return;
-                dispatch({ type: "disconnected" });
-                attempt = Math.min(attempt + 1, 5);
-                const delay = Math.min(2000 * Math.pow(2, attempt), 30000);
-                reconnectTimeout = setTimeout(connect, delay);
             });
-        };
-        connect();
-        void fetchIssueSnapshot().catch(() => undefined);
-        const snapshotInterval = setInterval(() => {
-            void fetchIssueSnapshot().catch(() => undefined);
         }, 5000);
         return () => {
             abortController.abort();
-            if (reconnectTimeout !== undefined) {
-                clearTimeout(reconnectTimeout);
-            }
             clearInterval(snapshotInterval);
         };
     }, [options.active]);
 }
-function processEvent(dispatch, eventType, data) {
-    try {
-        if (eventType === "issues") {
-            const issues = JSON.parse(data);
-            dispatch({ type: "issues-snapshot", issues, receivedAt: Date.now() });
-        }
-        else if (eventType === "feed") {
-            const event = JSON.parse(data);
-            dispatch({ type: "feed-event", event, receivedAt: Date.now() });
-        }
-    }
-    catch {
-        // Ignore parse errors from malformed events
-    }
-}

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

@@ -31,6 +31,9 @@ export const initialWatchState = {
     feedEvents: [],
 };
 const TERMINAL_FACTORY_STATES = new Set(["done", "failed"]);
+function effectiveSessionState(issue) {
+    return issue.sessionState ?? (TERMINAL_FACTORY_STATES.has(issue.factoryState) ? issue.factoryState : undefined);
+}
 export function filterIssues(issues, filter) {
     switch (filter) {
         case "all":
@@ -38,7 +41,10 @@ export function filterIssues(issues, filter) {
         case "active":
             return issues.filter((i) => i.activeRunType !== undefined);
         case "non-done":
-            return issues.filter((i) => !TERMINAL_FACTORY_STATES.has(i.factoryState));
+            return issues.filter((i) => {
+                const sessionState = effectiveSessionState(i);
+                return sessionState !== "done" && sessionState !== "failed" && !TERMINAL_FACTORY_STATES.has(i.factoryState);
+            });
     }
 }
 const DONE_STATES = new Set(["done"]);
@@ -50,15 +56,18 @@ export function computeAggregates(issues) {
     let done = 0;
     let failed = 0;
     for (const issue of issues) {
+        const sessionState = effectiveSessionState(issue);
+        const isDone = sessionState === "done" || DONE_STATES.has(issue.factoryState);
+        const isFailed = sessionState === "failed" || FAILED_STATES.has(issue.factoryState);
         if (issue.activeRunType)
             active++;
         if (!issue.activeRunType && issue.blockedByCount > 0)
             blocked++;
-        if (!issue.activeRunType && issue.readyForExecution)
+        if (!issue.activeRunType && issue.readyForExecution && !isDone && !isFailed)
             ready++;
-        if (DONE_STATES.has(issue.factoryState))
+        if (isDone)
             done++;
-        if (FAILED_STATES.has(issue.factoryState))
+        if (isFailed)
             failed++;
     }
     return { active, blocked, ready, done, failed, total: issues.length };
@@ -119,7 +128,7 @@ export function watchReducer(state, action) {
                 rawRuns: action.runs,
                 rawFeedEvents: action.feedEvents,
                 activeRunId: action.activeRunId,
-                activeRunStartedAt: activeRun?.startedAt ?? null,
+                activeRunStartedAt: action.activeRunStartedAt ?? activeRun?.startedAt ?? null,
                 issueContext: action.issueContext,
             };
         }
@@ -145,57 +154,16 @@ export function watchReducer(state, action) {
 }
 // ─── Feed Event → Issue List + Timeline ───────────────────────────
 function applyFeedEvent(state, event, receivedAt) {
-    if (!event.issueKey) {
-        return { ...state, lastServerMessageAt: receivedAt };
-    }
-    const index = state.issues.findIndex((issue) => issue.issueKey === event.issueKey);
-    if (index === -1) {
-        return { ...state, lastServerMessageAt: receivedAt };
-    }
-    const updated = [...state.issues];
-    const issue = { ...updated[index] };
-    if (event.kind === "stage" && event.stage) {
-        issue.factoryState = event.stage;
-    }
-    if (event.kind === "stage" && event.status === "starting" && event.stage) {
-        issue.activeRunType = event.stage;
-    }
-    if (event.kind === "turn") {
-        if (event.status === "completed" || event.status === "failed") {
-            issue.activeRunType = undefined;
-            issue.latestRunStatus = event.status;
-        }
-    }
-    if (event.kind === "github" && event.status) {
-        if (event.status === "check_passed" || event.status === "check_failed") {
-            issue.prCheckStatus = event.status === "check_passed" ? "passed" : "failed";
-        }
-        if (event.status === "ci_repair_queued") {
-            issue.factoryState = "repairing_ci";
-            issue.statusNote = event.detail ?? event.summary;
-        }
-        if (event.status === "queue_repair_queued") {
-            issue.factoryState = "repairing_queue";
-            issue.statusNote = event.detail ?? event.summary;
-        }
-        if (event.status === "repair_deduped" || event.status === "branch_not_advanced") {
-            issue.statusNote = event.summary;
-        }
-    }
-    if ((event.kind === "turn" || event.kind === "github") && event.status === "branch_not_advanced") {
-        issue.statusNote = event.summary;
-    }
-    issue.updatedAt = event.at;
-    updated[index] = issue;
-    // 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 isActiveDetail = Boolean(event.issueKey)
+        && state.view === "detail"
+        && state.activeDetailKey === event.issueKey;
     const timeline = isActiveDetail
         ? capArray(appendFeedToTimeline(state.timeline, event), MAX_TIMELINE_ENTRIES)
         : state.timeline;
     const rawFeedEvents = isActiveDetail
         ? capArray([...state.rawFeedEvents, event], MAX_RAW_FEED_EVENTS)
         : state.rawFeedEvents;
-    return { ...state, lastServerMessageAt: receivedAt, issues: updated, timeline, rawFeedEvents };
+    return { ...state, lastServerMessageAt: receivedAt, timeline, rawFeedEvents };
 }
 // ─── Codex Notification → Timeline + Metadata ─────────────────────
 function applyCodexNotification(state, method, params) {

package/dist/codex-thread-utils.js

@@ -0,0 +1,3 @@
+export function getThreadTurns(thread) {
+    return Array.isArray(thread?.turns) ? thread.turns : [];
+}