@bridge_gpt/mcp-server 0.2.39 → 0.2.41

package/build/conduct-epic/pr-state.js

@@ -8,9 +8,13 @@
  * `conductor/epic-runtime.ts#parsePrBindingFromGhJson` fails closed on any
  * non-`OPEN` state, which is correct for binding a merge action and exactly
  * wrong here, and importing it would pull the whole v1 runtime along. So this
- * module parses the same `gh pr view` payload with a different, terminal-state-
- * preserving contract, while REUSING the shared mergeability normalizer so a
- * conflict is classified identically everywhere.
+ * module parses `gh` PR records with a different, terminal-state-preserving
+ * contract, while REUSING the shared mergeability normalizer so a conflict is
+ * classified identically everywhere.
+ *
+ * The probe reads `gh pr list --head <branch>`, whose output is an ARRAY, and
+ * selects one record from it. `gh pr view` was replaced because it cannot
+ * express "no pull request" as anything but a non-zero exit (BAPI-825/B1).
  *
  * **Worktree discovery.** `/review-and-start` names branches
  * `feature/<KEY>-<slug>` and the loop cannot know the slug. When
@@ -24,8 +28,24 @@
  */
 import { isPrMergeConflict, parseGhPrMergeabilityFields } from "../conductor/github-mergeability.js";
 import { runGhCommand } from "../conductor/pr-discovery.js";
-/** The `gh pr view --json` field list the status contract fixes. */
+/**
+ * The `--json` field list the status contract fixes.
+ *
+ * Passed to `gh pr list` (BAPI-825/B1), which returns an ARRAY of records with
+ * exactly these keys. The name is retained because it is the published contract
+ * identifier and is asserted by name in the tests; only the subcommand changed.
+ */
 export const CONDUCT_EPIC_GH_PR_VIEW_FIELDS = "number,state,headRefOid,mergeable,mergeStateStatus,baseRefName,updatedAt";
+/**
+ * How many candidate pull requests the probe asks `gh` for.
+ *
+ * More than one, deliberately: a branch routinely carries a closed pull request
+ * plus a reopened one, and `--limit 1` would hand back whichever `gh` ordered
+ * first rather than letting {@link selectConductEpicPrState} prefer the OPEN
+ * one. Bounded so a branch with a long pull-request history cannot turn one
+ * probe into an unbounded read.
+ */
+export const CONDUCT_EPIC_GH_PR_LIST_LIMIT = 20;
 /** The accepted GitHub PR states. Terminal states are RETAINED, not filtered. */
 export const CONDUCT_EPIC_PR_STATES = ["OPEN", "MERGED", "CLOSED"];
 function isRecord(value) {
@@ -75,14 +95,57 @@ export function conductEpicPrHasConflict(pr) {
     return isPrMergeConflict({ mergeable: pr.mergeable, mergeStateStatus: pr.merge_state });
 }
 /**
- * Run `gh pr view <branch> --json …` and normalize the result.
+ * Choose the one pull request the loop acts on from `gh`'s candidate list.
+ *
+ * An OPEN pull request always wins: it is the only one any action row can
+ * advance, and a stale closed sibling must never displace it. Among terminal
+ * candidates the most recently updated wins, because that is the one whose
+ * MERGED or CLOSED state describes the branch's current reality.
+ *
+ * Deterministic when timestamps tie or are unavailable: a valid `updated_at`
+ * outranks an absent one, and source order breaks any remaining tie. A probe
+ * that returned a different pull request run-to-run for identical input would
+ * make every downstream row unreproducible.
+ */
+export function selectConductEpicPrState(candidates) {
+    if (candidates.length === 0)
+        return null;
+    const open = candidates.find((pr) => pr.state === "OPEN");
+    if (open)
+        return open;
+    let best = candidates[0];
+    for (const candidate of candidates.slice(1)) {
+        const bestAt = Date.parse(best.updated_at ?? "");
+        const candidateAt = Date.parse(candidate.updated_at ?? "");
+        const bestUsable = Number.isFinite(bestAt);
+        const candidateUsable = Number.isFinite(candidateAt);
+        // Strictly greater, so an equal timestamp keeps the earlier record and
+        // source order remains the final tie-breaker.
+        if (candidateUsable && (!bestUsable || candidateAt > bestAt))
+            best = candidate;
+    }
+    return best;
+}
+/**
+ * Run `gh pr list --head <branch> --state all --json …` and normalize the result.
  *
  * Nothing throws. The three outcomes are kept strictly apart:
  *
- * - **`ok`** — `gh` succeeded and returned a parseable PR record.
- * - **`none`** — `gh` SUCCEEDED and returned nothing. Confirmed absence.
+ * - **`ok`** — `gh` succeeded and returned at least one parseable PR record.
+ * - **`none`** — `gh` SUCCEEDED and returned an empty array. Confirmed absence.
  * - **`error`** — `gh` could not be run, exited non-zero, or returned output
- *   that is not a valid PR record. Unavailable evidence, not absence.
+ *   that is not a valid PR array. Unavailable evidence, not absence.
+ *
+ * **`gh pr list`, not `gh pr view` (BAPI-825/B1).** `gh pr view <branch>` prints
+ * `no pull requests found for branch "…"` to stderr and **exits 1** when the
+ * branch has no pull request, and `runGhCommand` discards stderr, so every
+ * pre-PR tick produced `{ok: false, stdout: ""}`. Under BAPI-814/B2's correct
+ * rule that a non-zero exit is a failed probe, `none` became unreachable in
+ * production: the loop saw `pr: null` PLUS a `probe_errors` entry on every tick
+ * before a worker opened its pull request, so the "no PR yet" rows could never
+ * fire and a worker that died early parked at the three-hour hard deadline
+ * instead of getting its one-hour respawn. `gh pr list` exits 0 with `[]`,
+ * which makes absence expressible without weakening the failure rule.
  *
  * Every `error` reason is a fixed bounded string chosen here. The raw output is
  * never included — a `gh` failure message can echo a URL, a token hint, or the
@@ -92,33 +155,43 @@ export async function discoverConductEpicPrState(branch, options = {}) {
     const runGh = options.runGh ?? runGhCommand;
     let result;
     try {
-        result = await runGh(["pr", "view", branch, "--json", CONDUCT_EPIC_GH_PR_VIEW_FIELDS], {
-            cwd: options.cwd,
-        });
+        result = await runGh([
+            "pr",
+            "list",
+            "--head",
+            branch,
+            "--state",
+            "all",
+            "--json",
+            CONDUCT_EPIC_GH_PR_VIEW_FIELDS,
+            "--limit",
+            String(CONDUCT_EPIC_GH_PR_LIST_LIMIT),
+        ], { cwd: options.cwd });
     }
     catch {
         return { kind: "error", reason: "the gh command could not be run" };
     }
     // A non-zero `gh` exit is a FAILED PROBE, never "no PR" (BAPI-814/B2).
     //
-    // `gh` exits non-zero both when the branch genuinely has no pull request and
-    // when it is unauthenticated, rate-limited, or offline, and this module
-    // deliberately does not parse its stderr to tell those apart. Reporting the
-    // ambiguity as absence is the dangerous half of that choice: the loop reads a
-    // GitHub outage as "no PR yet" and keeps waiting on a pull request it can no
-    // longer see. Reporting it as a failed probe is the safe half — the status
-    // contract turns that into `pr: null` PLUS a `probe_errors` entry, which the
-    // command treats as unavailable evidence rather than a negative result.
+    // `gh pr list` exits non-zero only when it could not answer — unauthenticated,
+    // rate-limited, offline, not a repository. Absence is now expressed as a
+    // successful `[]`, so nothing legitimate is lost by keeping this strict: the
+    // status contract turns an error into `pr: null` PLUS a `probe_errors` entry,
+    // which the command treats as unavailable evidence rather than a negative
+    // result.
     //
     // The reason is a FIXED string. `gh`'s own output can echo a URL, a token
     // hint, or the repository layout, so none of it is interpolated here.
     if (!result.ok)
         return { kind: "error", reason: "the gh command failed" };
-    // A SUCCESSFUL command with empty output is genuine absence: `gh` ran, looked,
-    // and found nothing. That stays distinct from the failure above.
+    // Empty stdout from a SUCCESSFUL `--json` run is malformed, not absence: the
+    // documented answer for "no pull requests" is the two bytes `[]`. Silence is
+    // a shape this command should never produce, and reading it as a confirmed
+    // negative is precisely the inference this module refuses to make.
     const raw = typeof result.stdout === "string" ? result.stdout.trim() : "";
-    if (raw.length === 0)
-        return { kind: "none" };
+    if (raw.length === 0) {
+        return { kind: "error", reason: "gh returned no output for a --json query" };
+    }
     let parsed;
     try {
         parsed = JSON.parse(raw);
@@ -126,7 +199,23 @@ export async function discoverConductEpicPrState(branch, options = {}) {
     catch {
         return { kind: "error", reason: "gh returned output that is not valid JSON" };
     }
-    const pr = parseConductEpicPrState(parsed);
+    if (!Array.isArray(parsed)) {
+        return { kind: "error", reason: "gh returned a PR list in an unexpected shape" };
+    }
+    // A successful, well-formed empty list is the ONLY confirmed absence.
+    if (parsed.length === 0)
+        return { kind: "none" };
+    const records = [];
+    for (const entry of parsed) {
+        const pr = parseConductEpicPrState(entry);
+        // An unusable record is a shape error, never silently dropped: discarding
+        // it could empty the list and turn a real pull request into "no PR".
+        if (pr === null) {
+            return { kind: "error", reason: "gh returned a PR record in an unexpected shape" };
+        }
+        records.push(pr);
+    }
+    const pr = selectConductEpicPrState(records);
     if (pr === null)
         return { kind: "error", reason: "gh returned a PR record in an unexpected shape" };
     return { kind: "ok", pr };