@tenonhq/dovetail-dashboard 0.0.30 → 0.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tenonhq/dovetail-dashboard",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "description": "Update Set Dashboard for Dovetail",
   "main": "server.js",
   "scripts": {

package/public/claude-plans.css

@@ -1312,6 +1312,49 @@
   background: color-mix(in srgb, var(--accent-fg) 20%, transparent);
 }
 
+/* Merged-PR filter toggle + per-row PR state dots */
+.cp-rail-filters {
+  padding: 8px 0 4px;
+}
+.cp-pr-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 4px 12px;
+  background: var(--surface);
+  color: var(--fg);
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  font-family: inherit;
+  font-size: 12px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.12s ease, border-color 0.12s ease, color 0.12s ease;
+}
+.cp-pr-toggle:hover {
+  background: color-mix(in srgb, var(--accent) 10%, var(--surface));
+  border-color: var(--accent);
+}
+.cp-pr-toggle--active {
+  background: var(--accent);
+  color: var(--accent-fg);
+  border-color: var(--accent);
+}
+
+.cp-pr-dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  flex: 0 0 auto;
+  margin: 0 4px;
+  background: var(--fg-muted);
+}
+.cp-pr-dot--merged { background: var(--success-700); }
+.cp-pr-dot--open { background: var(--warning-700); }
+.cp-pr-dot--closed { background: var(--danger); }
+.cp-pr-dot--unknown { background: var(--fg-muted); }
+
 /* ===========================================================================
  * v2 — Stage Map, Questions tab, Dispatch dialog (Phase E)
  * Lightweight additions on top of the existing token system.

package/public/claude-plans.html

@@ -84,6 +84,15 @@
           hidden
         >×</button>
       </div>
+      <div class="cp-rail-filters">
+        <button
+          type="button"
+          class="cp-pr-toggle"
+          id="cp-merged-toggle"
+          aria-pressed="false"
+          title="Show only plans whose linked PR is merged"
+        >Merged PRs only</button>
+      </div>
       <div class="cp-rail-empty" id="cp-rail-empty">
         Waiting for plans. Run <code>push_plan</code> from a Claude Code
         session to populate this list.

package/public/claude-plans.js

@@ -37,7 +37,9 @@
     selectedSlug: null,
     activeTab: "plan",
     query: "",              // lowercased search query; "" means show all
-    topicFilter: null       // active topic label, null = no topic filter
+    topicFilter: null,      // active topic label, null = no topic filter
+    prStatus: new Map(),    // pr_url -> { state, merged } (live from gh, lazy)
+    mergedOnly: false       // when true, show only plans with a merged PR
   };
 
   var els = {
@@ -68,9 +70,37 @@
     topicsCloud: document.getElementById("cp-topics-cloud"),
     topicsCount: document.getElementById("cp-topics-count"),
     topicsEmpty: document.getElementById("cp-topics-empty"),
-    topicsClear: document.getElementById("cp-topics-clear")
+    topicsClear: document.getElementById("cp-topics-clear"),
+    mergedToggle: document.getElementById("cp-merged-toggle")
   };
 
+  // Merged === true only when gh resolved the plan's PR as MERGED.
+  function planPrMerged(plan) {
+    if (!plan.pr_url) return false;
+    var st = state.prStatus.get(plan.pr_url);
+    return !!(st && st.merged);
+  }
+
+  function planMatchesPr(plan) {
+    if (!state.mergedOnly) return true;
+    return planPrMerged(plan);
+  }
+
+  // A small colored dot in the rail row reflecting the PR's merge state.
+  // Rendered only when the plan links a PR and gh has returned a status.
+  function prDotMarkup(plan) {
+    if (!plan.pr_url) return "";
+    var st = state.prStatus.get(plan.pr_url);
+    if (!st) return "";
+    var cls = "cp-pr-dot";
+    if (st.merged) cls += " cp-pr-dot--merged";
+    else if (st.state === "OPEN") cls += " cp-pr-dot--open";
+    else if (st.state === "CLOSED") cls += " cp-pr-dot--closed";
+    else cls += " cp-pr-dot--unknown";
+    var label = st.merged ? "merged" : (st.state || "unknown").toLowerCase();
+    return '<span class="' + cls + '" title="PR ' + label + '"></span>';
+  }
+
   function planMatchesTopic(plan, topic) {
     if (!topic) return true;
     var cats = plan.categories;
@@ -118,9 +148,9 @@
     var q = state.query;
     var topic = state.topicFilter;
     var all = allPlansSorted();
-    if (!q && !topic) return all;
+    if (!q && !topic && !state.mergedOnly) return all;
     return all.filter(function (p) {
-      return planMatchesQuery(p, q) && planMatchesTopic(p, topic);
+      return planMatchesQuery(p, q) && planMatchesTopic(p, topic) && planMatchesPr(p);
     });
   }
 
@@ -431,7 +461,7 @@
     renderTopics();
     var plans = sortedPlans();
     var totalPlans = state.plans.size;
-    var isFiltering = !!state.query || !!state.topicFilter;
+    var isFiltering = !!state.query || !!state.topicFilter || state.mergedOnly;
     els.count.textContent = isFiltering
       ? plans.length + " / " + totalPlans
       : String(totalPlans);
@@ -444,6 +474,7 @@
           var pieces = [];
           if (state.query) pieces.push('"' + state.query + '"');
           if (state.topicFilter) pieces.push("topic “" + state.topicFilter + "”");
+          if (state.mergedOnly) pieces.push("merged PRs only");
           els.railNoMatchQ.textContent = pieces.join(" + ");
         }
       } else {
@@ -464,6 +495,7 @@
       li.innerHTML =
         '<div class="cp-list-row">' +
         '  <span class="cp-list-title"></span>' +
+        prDotMarkup(plan) +
         '  <span class="cp-status-pill cp-status-' + plan.status + '">' + plan.status + '</span>' +
         '</div>' +
         '<div class="cp-list-meta">' +
@@ -1154,6 +1186,41 @@
       });
   }
 
+  var prStatusDebounce = null;
+
+  // Resolve live PR merge state from the server (which shells out to gh) and
+  // rerender so dots + the merged filter reflect reality. Best-effort: any
+  // failure leaves prStatus as-is and the toggle simply matches nothing.
+  function loadPrStatus() {
+    return fetch("/api/claude-plans/pr-status")
+      .then(function (r) { return r.json(); })
+      .then(function (data) {
+        var statuses = data && data.statuses ? data.statuses : {};
+        Object.keys(statuses).forEach(function (url) {
+          state.prStatus.set(url, statuses[url]);
+        });
+        renderRail();
+      })
+      .catch(function (err) {
+        console.warn("[claude-plans] failed to load PR status:", err);
+      });
+  }
+
+  function schedulePrStatusRefresh() {
+    if (prStatusDebounce) clearTimeout(prStatusDebounce);
+    prStatusDebounce = setTimeout(loadPrStatus, 500);
+  }
+
+  function setupMergedToggle() {
+    if (!els.mergedToggle) return;
+    els.mergedToggle.addEventListener("click", function () {
+      state.mergedOnly = !state.mergedOnly;
+      els.mergedToggle.setAttribute("aria-pressed", state.mergedOnly ? "true" : "false");
+      els.mergedToggle.classList.toggle("cp-pr-toggle--active", state.mergedOnly);
+      renderRail();
+    });
+  }
+
   async function loadInitial() {
     try {
       var res = await fetch("/api/claude-plans");
@@ -1185,6 +1252,7 @@
         .catch(function () { /* ignore */ });
     }));
     renderRail();
+    loadPrStatus();
     if (!state.selectedSlug) {
       var paramSlug = new URLSearchParams(window.location.search).get("plan");
       var sorted = sortedPlans();
@@ -1198,7 +1266,10 @@
   function startStream() {
     var es = new EventSource("/api/claude-plans/stream");
     es.addEventListener("plan:upsert", function (e) {
-      try { upsertPlan(JSON.parse(e.data).plan); } catch (_) {}
+      try {
+        upsertPlan(JSON.parse(e.data).plan);
+        schedulePrStatusRefresh();
+      } catch (_) {}
     });
     es.addEventListener("plan:delete", function (e) {
       try { removePlan(JSON.parse(e.data).slug); } catch (_) {}
@@ -1262,6 +1333,7 @@
     setupTheme();
     setupSearch();
     setupTopics();
+    setupMergedToggle();
     setActiveTab("plan");
     loadLintsBadge();
     loadInitial().then(startStream);

package/public/prompt-lints.css

@@ -21,6 +21,148 @@
   font-size: 12px;
 }
 
+/* ─── Filter toolbar ──────────────────────────────────────────────────────── */
+
+.pl-filters {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 16px;
+  margin-bottom: 14px;
+}
+
+.pl-filter-group {
+  display: inline-flex;
+  flex-wrap: wrap;
+  align-items: center;
+  gap: 6px;
+}
+
+.pl-filter-group:empty {
+  display: none;
+}
+
+/* Segmented control (status) */
+.pl-seg {
+  padding: 4px 12px;
+  background: var(--surface);
+  color: var(--fg);
+  border: 1px solid var(--border);
+  font-family: inherit;
+  font-size: 13px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.12s ease, border-color 0.12s ease, color 0.12s ease;
+}
+.pl-seg:first-child { border-radius: 999px 0 0 999px; }
+.pl-seg:last-child { border-radius: 0 999px 999px 0; }
+.pl-seg + .pl-seg { border-left: none; }
+.pl-seg:hover {
+  background: color-mix(in srgb, var(--accent) 10%, var(--surface));
+}
+.pl-seg--active {
+  background: var(--accent);
+  color: var(--accent-fg);
+  border-color: var(--accent);
+}
+
+/* Toggle chips (score buckets, sources) */
+.pl-chip {
+  display: inline-flex;
+  align-items: baseline;
+  gap: 6px;
+  padding: 4px 10px;
+  background: var(--surface);
+  color: var(--fg);
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  font-family: inherit;
+  font-size: 13px;
+  font-weight: 500;
+  cursor: pointer;
+  transition: background 0.12s ease, border-color 0.12s ease, color 0.12s ease;
+}
+.pl-chip:hover {
+  background: color-mix(in srgb, var(--accent) 10%, var(--surface));
+  border-color: var(--accent);
+}
+.pl-chip--active {
+  background: var(--accent);
+  color: var(--accent-fg);
+  border-color: var(--accent);
+}
+.pl-chip-count {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 18px;
+  padding: 0 5px;
+  background: color-mix(in srgb, currentColor 12%, transparent);
+  border-radius: 999px;
+  font-size: 10px;
+  font-weight: 700;
+}
+
+.pl-search {
+  position: relative;
+  display: inline-flex;
+  align-items: center;
+  margin-left: auto;
+}
+.pl-search-input {
+  width: 220px;
+  padding: 5px 28px 5px 10px;
+  background: var(--surface);
+  color: var(--fg);
+  border: 1px solid var(--border);
+  border-radius: 999px;
+  font-family: inherit;
+  font-size: 13px;
+}
+.pl-search-input::placeholder { color: var(--fg-muted); }
+.pl-search-input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+.pl-search-input::-webkit-search-cancel-button { -webkit-appearance: none; }
+.pl-search-clear {
+  position: absolute;
+  right: 8px;
+  background: none;
+  border: none;
+  color: var(--fg-muted);
+  font-size: 16px;
+  line-height: 1;
+  cursor: pointer;
+}
+.pl-search-clear:hover { color: var(--fg); }
+
+/* Status badges */
+.pl-status {
+  display: inline-block;
+  border-radius: 999px;
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 600;
+  white-space: nowrap;
+}
+.pl-status--needs {
+  background: color-mix(in srgb, var(--danger) 14%, transparent);
+  color: var(--danger);
+}
+.pl-status--good {
+  background: color-mix(in srgb, var(--success-700) 14%, transparent);
+  color: var(--success-700);
+}
+
+.pl-no-match {
+  padding: 40px 20px;
+  text-align: center;
+  color: var(--fg-muted);
+  border: 1px dashed var(--border);
+  border-radius: 8px;
+}
+
 .pl-summary {
   color: var(--fg-subtle);
   font-size: 13px;

package/public/prompt-lints.html

@@ -42,15 +42,41 @@
       Turn-0 prompt-lint observations recorded by the <code>UserPromptSubmit</code> hook and
       <code>push_lint_event</code>. Newest first. Updates live.
     </div>
+    <div class="pl-filters" id="pl-filters">
+      <div class="pl-filter-group" role="group" aria-label="Status">
+        <button type="button" class="pl-seg pl-seg--active" data-status="all">All</button>
+        <button type="button" class="pl-seg" data-status="needs-improvement">Needs improvement</button>
+        <button type="button" class="pl-seg" data-status="good">Good</button>
+      </div>
+      <div class="pl-filter-group" role="group" aria-label="Score">
+        <button type="button" class="pl-chip" data-bucket="low">Low &lt;40</button>
+        <button type="button" class="pl-chip" data-bucket="mid">Mid 40&ndash;69</button>
+        <button type="button" class="pl-chip" data-bucket="high">High &ge;70</button>
+      </div>
+      <div class="pl-filter-group" id="pl-sources" role="group" aria-label="Source"></div>
+      <div class="pl-search">
+        <input
+          type="search"
+          class="pl-search-input"
+          id="pl-search-input"
+          placeholder="Search excerpt / tags&hellip;"
+          autocomplete="off"
+          spellcheck="false"
+        />
+        <button class="pl-search-clear" id="pl-search-clear" aria-label="Clear search" hidden>&times;</button>
+      </div>
+    </div>
     <div class="pl-summary" id="pl-summary"></div>
     <div class="pl-empty" id="pl-empty">
       No lint events yet. Low-scoring prompts will appear here as you work.
     </div>
+    <div class="pl-no-match" id="pl-no-match" hidden>No events match the current filters.</div>
     <table class="pl-table" id="pl-table" hidden>
       <thead>
         <tr>
           <th>When</th>
           <th>Score</th>
+          <th>Status</th>
           <th>Missing tags</th>
           <th>Source</th>
           <th>Prompt excerpt</th>

package/public/prompt-lints.js

@@ -6,12 +6,22 @@
 
   var events = new Map(); // id -> event
 
+  // Active filters. status: "all" | "needs-improvement" | "good".
+  // buckets: map of "low"/"mid"/"high" -> true (multi-select, empty = all).
+  // source: a single source string, or null = all. query: lowercased substring.
+  var filters = { status: "all", buckets: {}, source: null, query: "" };
+
   var els = {
     tbody: document.getElementById("pl-tbody"),
     table: document.getElementById("pl-table"),
     empty: document.getElementById("pl-empty"),
+    noMatch: document.getElementById("pl-no-match"),
     summary: document.getElementById("pl-summary"),
-    storage: document.getElementById("cp-storage")
+    storage: document.getElementById("cp-storage"),
+    filters: document.getElementById("pl-filters"),
+    sources: document.getElementById("pl-sources"),
+    searchInput: document.getElementById("pl-search-input"),
+    searchClear: document.getElementById("pl-search-clear")
   };
 
   // Bound the initial load — the global lint log is append-only and can grow
@@ -32,6 +42,38 @@
     return "pl-score-high";
   }
 
+  function scoreBucket(score) {
+    if (typeof score !== "number") return null;
+    if (score < 40) return "low";
+    if (score < 70) return "mid";
+    return "high";
+  }
+
+  // Classify an event as "needs-improvement" / "good" / "unknown". Prefer the
+  // hook's outcome ("nag" = under-specified, "format" = strong); fall back to
+  // score-vs-threshold for legacy events recorded before outcome existed.
+  function lintStatus(e) {
+    if (e.outcome === "nag") return "needs-improvement";
+    if (e.outcome === "format") return "good";
+    if (typeof e.score !== "number") return "unknown";
+    var threshold = typeof e.threshold === "number" ? e.threshold : 50;
+    if (e.score < threshold) return "needs-improvement";
+    if (e.score >= 70) return "good";
+    return "unknown";
+  }
+
+  function matchesFilters(e) {
+    if (filters.status !== "all" && lintStatus(e) !== filters.status) return false;
+    var activeBuckets = Object.keys(filters.buckets);
+    if (activeBuckets.length && filters.buckets[scoreBucket(e.score)] !== true) return false;
+    if (filters.source !== null && (e.source || "") !== filters.source) return false;
+    if (filters.query) {
+      var hay = ((e.prompt_excerpt || "") + " " + (e.missing || []).join(" ")).toLowerCase();
+      if (hay.indexOf(filters.query) === -1) return false;
+    }
+    return true;
+  }
+
   function sorted() {
     return Array.from(events.values()).sort(function (a, b) {
       var c = (b.timestamp || "").localeCompare(a.timestamp || "");
@@ -40,6 +82,10 @@
     });
   }
 
+  function filtered() {
+    return sorted().filter(matchesFilters);
+  }
+
   function renderTagCells(missing) {
     var td = document.createElement("td");
     td.className = "pl-missing";
@@ -71,6 +117,17 @@
     if (typeof e.threshold === "number") score.title = "threshold " + e.threshold + "%";
     tr.appendChild(score);
 
+    var statusCell = document.createElement("td");
+    var status = lintStatus(e);
+    if (status === "needs-improvement") {
+      statusCell.innerHTML = '<span class="pl-status pl-status--needs">Needs work</span>';
+    } else if (status === "good") {
+      statusCell.innerHTML = '<span class="pl-status pl-status--good">Good</span>';
+    } else {
+      statusCell.textContent = "—";
+    }
+    tr.appendChild(statusCell);
+
     tr.appendChild(renderTagCells(e.missing));
 
     var source = document.createElement("td");
@@ -87,23 +144,131 @@
     return tr;
   }
 
+  function isFiltering() {
+    return (
+      filters.status !== "all" ||
+      Object.keys(filters.buckets).length > 0 ||
+      filters.source !== null ||
+      !!filters.query
+    );
+  }
+
   function render(newId) {
-    var list = sorted();
+    var total = events.size;
+    var list = filtered();
     els.tbody.innerHTML = "";
-    if (!list.length) {
+
+    if (!total) {
       els.empty.hidden = false;
+      els.noMatch.hidden = true;
       els.table.hidden = true;
       els.summary.textContent = "";
       return;
     }
+
     els.empty.hidden = true;
+
+    if (!list.length) {
+      els.noMatch.hidden = false;
+      els.table.hidden = true;
+      els.summary.textContent = "0 of " + total + (total === 1 ? " event" : " events");
+      return;
+    }
+
+    els.noMatch.hidden = true;
     els.table.hidden = false;
     for (var i = 0; i < list.length; i++) {
       els.tbody.appendChild(rowFor(list[i], list[i].id === newId));
     }
-    els.summary.textContent =
-      list.length + (list.length === 1 ? " event" : " events") +
-      (list.length >= PAGE_LIMIT ? " (latest " + PAGE_LIMIT + ")" : "");
+
+    var noun = total === 1 ? " event" : " events";
+    if (isFiltering()) {
+      els.summary.textContent = list.length + " of " + total + noun;
+    } else {
+      els.summary.textContent =
+        total + noun + (total >= PAGE_LIMIT ? " (latest " + PAGE_LIMIT + ")" : "");
+    }
+  }
+
+  /* ─── Filter UI ─────────────────────────────────────────────────────────── */
+
+  function renderSources() {
+    if (!els.sources) return;
+    var counts = {};
+    events.forEach(function (e) {
+      var s = e.source || "—";
+      counts[s] = (counts[s] || 0) + 1;
+    });
+    var labels = Object.keys(counts).sort();
+    els.sources.innerHTML = "";
+    // A lone source carries no signal — hide the group until there's a choice.
+    if (labels.length < 2) return;
+    for (var i = 0; i < labels.length; i++) {
+      els.sources.appendChild(sourceChip(labels[i], counts[labels[i]]));
+    }
+  }
+
+  function sourceChip(label, count) {
+    var value = label === "—" ? "" : label;
+    var chip = document.createElement("button");
+    chip.type = "button";
+    chip.className = "pl-chip" + (filters.source === value ? " pl-chip--active" : "");
+    chip.appendChild(document.createTextNode(label + " "));
+    var c = document.createElement("span");
+    c.className = "pl-chip-count";
+    c.textContent = String(count);
+    chip.appendChild(c);
+    chip.addEventListener("click", function () {
+      filters.source = filters.source === value ? null : value;
+      renderSources();
+      render(null);
+    });
+    return chip;
+  }
+
+  function setupFilters() {
+    var segs = els.filters ? els.filters.querySelectorAll(".pl-seg") : [];
+    for (var i = 0; i < segs.length; i++) {
+      (function (btn) {
+        btn.addEventListener("click", function () {
+          filters.status = btn.getAttribute("data-status");
+          for (var j = 0; j < segs.length; j++) {
+            segs[j].classList.toggle("pl-seg--active", segs[j] === btn);
+          }
+          render(null);
+        });
+      })(segs[i]);
+    }
+
+    var buckets = els.filters ? els.filters.querySelectorAll(".pl-chip[data-bucket]") : [];
+    for (var k = 0; k < buckets.length; k++) {
+      (function (btn) {
+        btn.addEventListener("click", function () {
+          var key = btn.getAttribute("data-bucket");
+          if (filters.buckets[key]) delete filters.buckets[key];
+          else filters.buckets[key] = true;
+          btn.classList.toggle("pl-chip--active", !!filters.buckets[key]);
+          render(null);
+        });
+      })(buckets[k]);
+    }
+
+    if (els.searchInput) {
+      els.searchInput.addEventListener("input", function () {
+        filters.query = els.searchInput.value.trim().toLowerCase();
+        if (els.searchClear) els.searchClear.hidden = !els.searchInput.value;
+        render(null);
+      });
+    }
+    if (els.searchClear) {
+      els.searchClear.addEventListener("click", function () {
+        els.searchInput.value = "";
+        filters.query = "";
+        els.searchClear.hidden = true;
+        render(null);
+        els.searchInput.focus();
+      });
+    }
   }
 
   function loadInitial() {
@@ -114,6 +279,7 @@
           if (e && e.id) events.set(e.id, e);
         });
         if (els.storage && data.storage) els.storage.textContent = data.storage;
+        renderSources();
         render(null);
       })
       .catch(function () { render(null); });
@@ -126,6 +292,7 @@
         var data = JSON.parse(msg.data);
         if (data && data.lint && data.lint.id) {
           events.set(data.lint.id, data.lint);
+          renderSources();
           render(data.lint.id);
         }
       } catch (_) {}
@@ -177,6 +344,7 @@
 
   document.addEventListener("DOMContentLoaded", function () {
     setupTheme();
+    setupFilters();
     loadInitial().then(startStream);
   });
 })();

package/server.js

@@ -4,6 +4,7 @@ const axios = require("axios");
 const { wrapper } = require("axios-cookiejar-support");
 const { CookieJar } = require("tough-cookie");
 const fs = require("fs");
+const { execFile } = require("child_process");
 const RateLimit = require("express-rate-limit");
 
 // Everything resolves from CWD — run this from your Dovetail project directory
@@ -1075,6 +1076,100 @@ app.get("/api/claude-plans", function (req, res) {
   }
 });
 
+// Live GitHub merge state for plan-linked PRs. Plans store pr_url but no merge
+// status, so we resolve it on demand via the `gh` CLI (authenticated locally).
+// Results are cached: a MERGED state is terminal and cached forever; anything
+// else is cached briefly so an open PR that later merges is picked up.
+const PR_URL_RE = /^https:\/\/github\.com\/[\w.-]+\/[\w.-]+\/pull\/\d+$/;
+const PR_STATUS_TTL_MS = 60 * 1000;
+const prStatusCache = new Map(); // pr_url -> { state, merged, fetchedAt }
+
+function ghPrState(prUrl) {
+  return new Promise(function (resolve) {
+    execFile(
+      "gh",
+      ["pr", "view", prUrl, "--json", "state,mergedAt"],
+      { timeout: 5000 },
+      function (err, stdout) {
+        if (err) return resolve({ state: "unknown", merged: false });
+        try {
+          const data = JSON.parse(stdout);
+          const state = data.state || "unknown";
+          resolve({ state: state, merged: state === "MERGED" });
+        } catch (e) {
+          resolve({ state: "unknown", merged: false });
+        }
+      }
+    );
+  });
+}
+
+function resolvePrStatus(prUrl) {
+  const cached = prStatusCache.get(prUrl);
+  const now = Date.now();
+  if (cached && (cached.merged || now - cached.fetchedAt < PR_STATUS_TTL_MS)) {
+    return Promise.resolve({ state: cached.state, merged: cached.merged });
+  }
+  return ghPrState(prUrl).then(function (result) {
+    prStatusCache.set(prUrl, {
+      state: result.state,
+      merged: result.merged,
+      fetchedAt: Date.now()
+    });
+    return result;
+  });
+}
+
+// Run promise-returning tasks with bounded concurrency so a large plan set
+// doesn't spawn dozens of `gh` processes at once.
+function mapWithConcurrency(items, limit, worker) {
+  return new Promise(function (resolve) {
+    const results = new Array(items.length);
+    let index = 0;
+    let completed = 0;
+    if (!items.length) return resolve(results);
+    function runNext() {
+      if (index >= items.length) return;
+      const i = index++;
+      Promise.resolve(worker(items[i]))
+        .then(function (r) { results[i] = r; })
+        .catch(function () { results[i] = null; })
+        .then(function () {
+          completed++;
+          if (completed === items.length) resolve(results);
+          else runNext();
+        });
+    }
+    for (let k = 0; k < Math.min(limit, items.length); k++) runNext();
+  });
+}
+
+// Place before "/api/claude-plans/:slug" so Express doesn't treat "pr-status"
+// as a slug. Always resolves to a 200 with whatever statuses we could gather —
+// a missing/unauthenticated `gh` degrades to {} rather than failing the page.
+app.get("/api/claude-plans/pr-status", function (req, res) {
+  try {
+    const urls = [];
+    const seen = {};
+    listClaudePlans().forEach(function (plan) {
+      const url = plan && plan.pr_url;
+      if (typeof url === "string" && PR_URL_RE.test(url) && !seen[url]) {
+        seen[url] = true;
+        urls.push(url);
+      }
+    });
+    mapWithConcurrency(urls, 5, resolvePrStatus).then(function (resolved) {
+      const statuses = {};
+      for (let i = 0; i < urls.length; i++) {
+        if (resolved[i]) statuses[urls[i]] = resolved[i];
+      }
+      res.json({ statuses: statuses });
+    });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
 app.get("/api/claude-plans/stream", function (req, res) {
   res.set({
     "Content-Type": "text/event-stream",