patchrelay 0.35.0 → 0.35.2

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.35.0",
-  "commit": "e1a5b7d3b9e0",
-  "builtAt": "2026-04-02T21:55:42.542Z"
+  "version": "0.35.2",
+  "commit": "19528baf10d3",
+  "builtAt": "2026-04-03T02:18:23.308Z"
 }

package/dist/cli/watch/FactoryStateGraph.js

@@ -1,31 +1,35 @@
-import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from "ink";
-function statusColor(status) {
-    switch (status) {
-        case "current":
-            return "cyan";
-        case "visited":
-            return "green";
-        case "upcoming":
-            return "gray";
-    }
+const STATE_LABELS = {
+    delegated: "delegated",
+    implementing: "implementing",
+    pr_open: "PR open",
+    awaiting_queue: "merge queue",
+    done: "done",
+    changes_requested: "review fix",
+    repairing_ci: "CI repair",
+    repairing_queue: "queue repair",
+    awaiting_input: "needs input",
+    escalated: "escalated",
+    failed: "failed",
+};
+function displayLabel(state) {
+    return STATE_LABELS[state] ?? state;
 }
-function statusPrefix(status) {
-    switch (status) {
-        case "current":
-            return "*";
-        case "visited":
-            return "+";
-        case "upcoming":
-            return " ";
-    }
-}
-function NodePill({ node }) {
-    return (_jsxs(Text, { color: statusColor(node.status), bold: node.status === "current", children: ["[", statusPrefix(node.status), " ", node.label, "]"] }));
-}
-function NodeRow({ label, nodes, connector = " -> ", }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: label.padEnd(11, " ") }), nodes.map((node, index) => (_jsxs(Box, { children: [index > 0 && _jsx(Text, { dimColor: true, children: connector }), _jsx(NodePill, { node: node })] }, node.state)))] }));
+function NodeRow({ nodes, connector }) {
+    const visible = nodes.filter((n) => connector === " \u2192 " || n.status !== "upcoming");
+    if (visible.length === 0)
+        return _jsx(_Fragment, {});
+    return (_jsx(Box, { gap: 0, children: visible.map((node, i) => {
+            const dot = node.status === "upcoming" ? "\u25cb" : "\u25cf";
+            const color = node.status === "current" ? "cyan"
+                : node.status === "visited" ? "green"
+                    : "gray";
+            return (_jsxs(Box, { gap: 0, children: [i > 0 && _jsx(Text, { dimColor: true, children: connector }), _jsx(Text, { color: color, bold: node.status === "current", children: dot }), _jsx(Text, { color: color, bold: node.status === "current", children: ` ${displayLabel(node.state)}` })] }, node.state));
+        }) }));
 }
 export function FactoryStateGraph({ main, prLoops, queueLoop, exits, }) {
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "State Graph" }), _jsx(NodeRow, { label: "main", nodes: main }), _jsx(NodeRow, { label: "pr loops", nodes: prLoops, connector: "   " }), _jsx(NodeRow, { label: "queue loop", nodes: queueLoop, connector: "   " }), _jsx(NodeRow, { label: "exits", nodes: exits, connector: "   " })] }));
+    const hasLoops = prLoops.some((n) => n.status !== "upcoming") || queueLoop.some((n) => n.status !== "upcoming");
+    const hasExits = exits.some((n) => n.status !== "upcoming");
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(NodeRow, { nodes: main, connector: " \\u2192 " }), hasLoops && (_jsx(Box, { gap: 0, paddingLeft: 2, children: _jsx(NodeRow, { nodes: [...prLoops, ...queueLoop], connector: "  " }) })), hasExits && (_jsx(Box, { gap: 0, paddingLeft: 2, children: _jsx(NodeRow, { nodes: exits, connector: "  " }) }))] }));
 }

package/dist/cli/watch/Timeline.js

@@ -9,12 +9,11 @@ export function Timeline({ entries, follow }) {
     const rows = stdout?.rows ?? 24;
     const maxActive = Math.max(ACTIVE_TAIL, rows - 12);
     const displayRows = useMemo(() => buildTimelineRows(entries), [entries]);
-    const splitIndex = useMemo(() => {
-        if (!follow)
-            return 0;
-        return Math.max(0, displayRows.length - maxActive);
-    }, [displayRows.length, follow, maxActive]);
-    const finalized = displayRows.slice(0, splitIndex);
+    // Always cap the rendered entries to prevent OOM/WASM crashes.
+    // In follow mode: older entries go to Static (terminal scrollback).
+    // Without follow: show last maxActive entries only.
+    const splitIndex = Math.max(0, displayRows.length - maxActive);
+    const finalized = follow ? displayRows.slice(0, splitIndex) : [];
     const active = displayRows.slice(splitIndex);
     if (displayRows.length === 0) {
         return _jsx(Text, { dimColor: true, children: "No timeline events yet." });

package/dist/run-orchestrator.js

@@ -126,6 +126,10 @@ export class RunOrchestrator {
         const issue = this.db.getIssue(item.projectId, item.issueId);
         if (!issue?.pendingRunType || issue.activeRunId !== undefined)
             return;
+        if (issue.prState === "merged") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, pendingRunType: null, factoryState: "done" });
+            return;
+        }
         const runType = issue.pendingRunType;
         const contextJson = issue.pendingRunContextJson;
         const context = contextJson ? JSON.parse(contextJson) : undefined;
@@ -632,15 +636,31 @@ export class RunOrchestrator {
         const hasQueueLabel = pr.labels?.some((l) => l.name === protocol.admissionLabel) ?? false;
         if (!hasQueueLabel)
             return;
-        // Conflict detected — dispatch preemptive queue repair.
-        if (pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING") {
+        // Detect queue issues: either GitHub reports DIRTY, or the steward
+        // eviction check run failed (webhook may have been missed).
+        const isDirty = pr.mergeStateStatus === "DIRTY" || pr.mergeable === "CONFLICTING";
+        let hasEvictionCheckRun = false;
+        if (!isDirty) {
+            // Check for missed eviction webhook by looking for the steward's
+            // check run on the PR head.
+            try {
+                const { stdout: checksOut } = await execCommand("gh", [
+                    "api", `repos/${project.github.repoFullName}/commits/${pr.headRefOid}/check-runs`,
+                    "--jq", `.check_runs[] | select(.name == "${protocol.evictionCheckName}" and .conclusion == "failure") | .name`,
+                ], { timeoutMs: 10_000 });
+                hasEvictionCheckRun = checksOut.trim().length > 0;
+            }
+            catch {
+                // Best-effort check.
+            }
+        }
+        if (isDirty || hasEvictionCheckRun) {
             const headRefOid = pr.headRefOid ?? "unknown";
-            // TODO: include baseSha in signature (headRefOid + baseSha) so that a
-            // main-only advance with the same PR head is recognized as a new conflict.
+            const reason = hasEvictionCheckRun ? "queue_eviction_missed" : "preemptive_conflict";
             const signature = `preemptive_queue_conflict:${headRefOid}`;
             const pendingRunContext = {
                 source: "queue_health_monitor",
-                failureReason: "preemptive_conflict",
+                failureReason: reason,
                 failureHeadSha: headRefOid,
                 failureSignature: signature,
             };
@@ -657,15 +677,17 @@ export class RunOrchestrator {
                 pendingRunType: "queue_repair",
                 pendingRunContext,
             });
-            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid }, "Queue health: merge conflict detected, dispatching preemptive repair");
+            this.logger.info({ issueKey: issue.issueKey, prNumber: issue.prNumber, headRefOid, reason }, "Queue health: queue issue detected, dispatching repair");
             this.feed?.publish({
                 level: "warn",
                 kind: "github",
                 issueKey: issue.issueKey,
                 projectId: issue.projectId,
                 stage: "repairing_queue",
-                status: "queue_health_conflict_detected",
-                summary: `Queue health: merge conflict detected on PR #${issue.prNumber}, dispatching preemptive repair`,
+                status: hasEvictionCheckRun ? "queue_health_eviction_detected" : "queue_health_conflict_detected",
+                summary: hasEvictionCheckRun
+                    ? `Queue health: missed eviction detected on PR #${issue.prNumber}, dispatching repair`
+                    : `Queue health: merge conflict detected on PR #${issue.prNumber}, dispatching preemptive repair`,
             });
         }
     }

package/dist/service.js

@@ -487,6 +487,10 @@ export class PatchRelayService {
             return undefined;
         if (issue.activeRunId)
             return { error: "Issue already has an active run" };
+        if (issue.prState === "merged") {
+            this.db.upsertIssue({ projectId: issue.projectId, linearIssueId: issue.linearIssueId, factoryState: "done" });
+            return { issueKey, runType: "none" };
+        }
         // Infer run type from current state instead of always resetting to implementation
         let runType = "implementation";
         let factoryState = "delegated";

package/package.json

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