@nanobpm/nano-workforce 0.210.0 → 0.210.2

package/CHANGELOG.md

@@ -1,3 +1,15 @@
+## [0.210.2](https://github.com/nanobpm/nano-workforce/compare/v0.210.1...v0.210.2) (2026-11-14)
+
+### Bug Fixes
+
+* **tracking:** merged PRs no longer derive 'abandoned' when their run was terminated ([#960](https://github.com/nanobpm/nano-workforce/issues/960)) ([56f0ff4](https://github.com/nanobpm/nano-workforce/commit/56f0ff4c4a3a0d8a3cf68745b1f7b9bf539987da)), closes [nano-bpm#1579](https://github.com/nanobpm/nano-bpm/issues/1579) [#959](https://github.com/nanobpm/nano-workforce/issues/959)
+
+## [0.210.1](https://github.com/nanobpm/nano-workforce/compare/v0.210.0...v0.210.1) (2026-11-12)
+
+### Bug Fixes
+
+* **merge:** same-named check-runs from different events are different gates ([#957](https://github.com/nanobpm/nano-workforce/issues/957)) ([e2c4e96](https://github.com/nanobpm/nano-workforce/commit/e2c4e966b566ce8b4bdc19e84bceb130909a981c)), closes [#348](https://github.com/nanobpm/nano-workforce/issues/348) [camunda/console-api-js#17](https://github.com/camunda/console-api-js/issues/17) [#348](https://github.com/nanobpm/nano-workforce/issues/348) [#955](https://github.com/nanobpm/nano-workforce/issues/955) [#955](https://github.com/nanobpm/nano-workforce/issues/955) [#951](https://github.com/nanobpm/nano-workforce/issues/951) [#955](https://github.com/nanobpm/nano-workforce/issues/955)
+
 ## [0.210.0](https://github.com/nanobpm/nano-workforce/compare/v0.209.1...v0.210.0) (2026-11-12)
 
 ### Features

package/app/abandon.test.ts

@@ -134,6 +134,37 @@ test("abandonStatusForToken derives abandoned from the row status", async () =>
   assertEquals(await abandonStatusForToken(data, "nope"), undefined);
 });
 
+test("abandonStatusForToken aborts a MERGED PR whose owning run was terminated (owner_terminated)", async () => {
+  // derived_status reports a landed PR as `merged` even when its run was terminated (#959), so the
+  // cancellation signal rides the separate owner_terminated column — terminating a redundant
+  // post-merge round must still tell its agent to stop.
+  const data = memData();
+  await data.table("pull_requests", "pr_key").insert({
+    pr_key: "o/r#4",
+    abandon_token: "landed-term",
+    status: "merged",
+    merged_at: "t",
+    owner_terminated: 1,
+  });
+  await data.table("pull_requests", "pr_key").insert({
+    pr_key: "o/r#5",
+    abandon_token: "landed-live",
+    status: "merged",
+    merged_at: "t",
+    owner_terminated: null,
+  });
+  assertEquals(await abandonStatusForToken(data, "landed-term"), {
+    prKey: "o/r#4",
+    status: "merged",
+    abandoned: true,
+  });
+  assertEquals(await abandonStatusForToken(data, "landed-live"), {
+    prKey: "o/r#5",
+    status: "merged",
+    abandoned: false,
+  });
+});
+
 test("abandonStatusForToken fails CLOSED on a non-string derived status", async () => {
   // A malformed/missing derived_status must never be reported as `abandoned:false`
   // (that would let a cancelled run proceed with irreversible side effects). It throws

package/app/abandon.ts

@@ -24,12 +24,15 @@
 import type { DataLayer } from "@nanobpm/urban";
 import { publicBaseUrl } from "./blackboard.ts";
 import { trackingTargetFor } from "./instanceTracking.ts";
+import { OWNER_TERMINATED_COLUMN } from "./prTrackingReadModel.ts";
 
 /** The one derived-status value meaning a PR is terminally abandoned — the run must not be worked on
  * further. Two disjoint producers surface a row here, and both are non-completion terminals that must
  * stop a servicing agent:
  *   1. an explicit **cancel** of a live convergence/merge run (Urban's cancel primitive terminates
- *      the instance; the `instanceTracking` `onTerminated.set` edge derives `abandoned` on read), and
+ *      the instance; the `instanceTracking` `onTerminated.set` edge derives `abandoned` on read) —
+ *      but ONLY when the PR did NOT land: the merge-aware derivation (app/prTrackingReadModel.ts,
+ *      issue #959) folds a terminated-but-MERGED PR to `merged`, never `abandoned`, and
  *   2. **`abandonClosedPr`** reconciling a wave-member PR that was **closed on GitHub without
  *      merging** (#352) — for both `pull_requests` and its `plan_tasks` — by writing the base row.
  * Convergence/merge terminal states `converged`/`merged` are NOT abandonment. In either abandoned
@@ -116,7 +119,10 @@ export async function abandonStatusForToken(
     );
   }
   const status = rawStatus;
-  return { prKey: row.pr_key, status, abandoned: isAbandoned(status) };
+  // `derived_status` reports a landed PR as `merged` even when its run was terminated (issue #959),
+  // so termination is read from its own column: a terminated owner ALWAYS aborts the agent.
+  const ownerTerminated = Boolean(row[OWNER_TERMINATED_COLUMN]);
+  return { prKey: row.pr_key, status, abandoned: isAbandoned(status) || ownerTerminated };
 }
 
 /** The instruction block appended (verbatim, via `appendPrompt`) to each side-effecting agent's

package/app/behindBaseRemedy.test.ts

@@ -16,7 +16,7 @@ function st(over: Partial<PrState> = {}): PrState {
     failingCheckNames: ["build"],
     presentCheckNames: ["build"],
     pendingCheckNames: [],
-    checkConclusions: { build: "FAILURE" },
+    checkGateConclusions: { build: ["FAILURE"] },
     totalChecks: 1,
     isDraft: false,
     headRefOid: "head1",

package/app/conformance.test.ts

@@ -126,6 +126,23 @@ test("hasDeliveredImplementation: true iff at least one PR landed", async () =>
   assert(hasDeliveredImplementation(await gatherConformance(data, PLAN)));
 });
 
+// Issue #959: a PR that MERGED but whose loop was terminated afterwards (operator cancel, out-of-band
+// merge reconcile, restart cleanup) derived `abandoned` off the `onTerminated` edge — and conformance
+// then refused to count it as landed. The merge-aware derivation folds it to `merged` (merged_at set),
+// so a merged-then-terminated PR IS landed. Model the terminated divergence by seeding the base row at
+// its frozen transient (`converging`) WITH `merged_at` set: the tracking view must report `merged`.
+test("hasDeliveredImplementation: a merged-then-terminated PR (frozen base + merged_at) counts as landed (#959)", async () => {
+  const { data, stores } = memData();
+  seedPlan(stores);
+  seedTask(stores, { id: 1, task_index: 0, task_id: "t1", status: "opened", pr_key: "acme/widgets#10" });
+  // Base status frozen at the in-flight transient, but the PR landed (merged_at set) before termination.
+  stores["pull_requests"] = [{ pr_key: "acme/widgets#10", status: "converging", merged_at: "2026-11-01T00:00:00Z" }];
+  assertEquals(await hasDeliveredImplementationForPlan(data, PLAN), true);
+  const d = await gatherConformance(data, PLAN);
+  assertEquals(hasDeliveredImplementation(d), true);
+  assertEquals(d.slices.find((s) => s.taskId === "t1")?.landed, true);
+});
+
 test("hasDeliveredImplementationForPlan: matches the digest without a blackboard scan", async () => {
   const { data, stores } = memData();
   seedPlan(stores);

package/app/failingChecksSupersede.test.ts

@@ -12,7 +12,7 @@
 
 import { test } from "node:test";
 import { assert, assertEquals } from "#test-assert";
-import { allCheckNames, failingCheckNames, latestRunPerCheck } from "./github.ts";
+import { allCheckNames, applyRollupEvents, checkConclusions, checkGateConclusions, failingCheckNames, latestRunPerCheck } from "./github.ts";
 
 test("a CANCELLED run superseded by a newer green run on the same head does not count as failing", () => {
   const rollup = [
@@ -91,3 +91,290 @@ test("legacy StatusContext (state + context) supersession is handled by createdA
   ];
   assertEquals(failingCheckNames(rollup), [], "a superseded legacy status context is not a failing gate");
 });
+
+// ── Issue #955: same display name, DIFFERENT triggering events — not the same gate ──────────────
+//
+// One workflow file with both `pull_request` and `push` jobs named `build` puts TWO runs named
+// `build` on the same head SHA. They are different gates: the ruleset / branch-protection required
+// context gates the `pull_request` run, so a red PR `build` must never be collapsed away by a newer
+// green push `build` (camunda/console-api-js#17: the collapse hid the red required check, the merge
+// loop classified `waiting`, and `senior:fix-ci` never ran).
+
+test("#955: a red pull_request `build` is not collapsed away by a newer green push `build`", () => {
+  const rollup = [
+    // The required gate: PR-event run, failed (biome check on CHANGELOG.md), completed 00:41:34Z.
+    { name: "build", event: "pull_request", conclusion: "FAILURE", startedAt: "2026-11-12T00:30:00Z", completedAt: "2026-11-12T00:41:34Z" },
+    // A different gate sharing the display name: push-event run, green, completed 4s later.
+    { name: "build", event: "push", conclusion: "SUCCESS", startedAt: "2026-11-12T00:41:30Z", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  assertEquals(
+    failingCheckNames(rollup),
+    ["build"],
+    "the red required pull_request run must survive the collapse — a green push job must not satisfy it",
+  );
+  assertEquals(
+    checkConclusions(rollup).build,
+    "FAILURE",
+    "the gate's conclusion is the red pull_request run's, so requiredChecksVerdict sees the failure",
+  );
+});
+
+test("#955: the #348 collapse still holds WITHIN one event — a cancelled rerun of the same job collapses", () => {
+  const rollup = [
+    { name: "build", event: "pull_request", conclusion: "CANCELLED", startedAt: "2026-11-12T00:30:00Z", completedAt: "2026-11-12T00:31:00Z" },
+    { name: "build", event: "pull_request", conclusion: "SUCCESS", startedAt: "2026-11-12T00:32:00Z", completedAt: "2026-11-12T00:35:00Z" },
+  ];
+  assertEquals(failingCheckNames(rollup), [], "a CANCELLED rerun of the SAME workflow/event still collapses to the newest run");
+  assertEquals(checkConclusions(rollup).build, "SUCCESS");
+});
+
+test("#955: a green pull_request run does not mask a red push run of the same name (symmetric)", () => {
+  const rollup = [
+    { name: "build", event: "pull_request", conclusion: "SUCCESS", startedAt: "2026-11-12T00:41:30Z", completedAt: "2026-11-12T00:41:38Z" },
+    { name: "build", event: "push", conclusion: "FAILURE", startedAt: "2026-11-12T00:30:00Z", completedAt: "2026-11-12T00:41:34Z" },
+  ];
+  assertEquals(failingCheckNames(rollup), ["build"], "any non-superseded failed run of the name fails the gate");
+});
+
+test("#955: distinct events keep both runs in latestRunPerCheck (one per gate, not one per name)", () => {
+  const rollup = [
+    { name: "build", event: "pull_request", conclusion: "FAILURE", completedAt: "2026-11-12T00:41:34Z" },
+    { name: "build", event: "push", conclusion: "SUCCESS", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  const latest = latestRunPerCheck(rollup);
+  assertEquals(latest.length, 2, "two different gates sharing a name must both survive");
+});
+
+test("#955: runs without event identity keep the pre-#955 name-only collapse (legacy shapes unchanged)", () => {
+  // A rollup whose entries carry no `event` (older gh, a StatusContext-only head) collapses exactly
+  // as before: same name → newest run wins.
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", completedAt: "2026-11-12T00:41:34Z" },
+    { name: "build", conclusion: "SUCCESS", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  assertEquals(failingCheckNames(rollup), [], "no event identity → the name-only #348 collapse is unchanged");
+  assertEquals(latestRunPerCheck(rollup).length, 1);
+});
+
+test("#955: allCheckNames still reports the display name once when events differ", () => {
+  const rollup = [
+    { name: "build", event: "pull_request", conclusion: "FAILURE", completedAt: "2026-11-12T00:41:34Z" },
+    { name: "build", event: "push", conclusion: "SUCCESS", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  assertEquals(allCheckNames(rollup), ["build"], "presence is by required-context name, not per (name, event) pair");
+});
+
+// ── PR #957 review: the gate key must be an unambiguous tuple ────────────────────────────────────
+//
+// A bare `name + event` concatenation lets two DIFFERENT identities collide: `name:"build",
+// event:"push"` and an event-less `context:"buildpush"` both produce `"buildpush"`, so a newer green
+// entry could discard an unrelated red check (and the known-event bucket could merge with the
+// unknown-event one). The key is length-prefixed (`${name.length}:${name}${event}`) so no
+// `(name, event)` pair aliases a different pair or a name-only key.
+
+test("#957: an eventful `build`+`push` never collides with an event-less `buildpush` context", () => {
+  const rollup = [
+    // The event-less legacy StatusContext whose context string happens to equal the concatenation.
+    { context: "buildpush", state: "FAILURE", createdAt: "2026-11-12T00:41:34Z" },
+    // A different gate: a CheckRun named `build` triggered by `push`, green, newer.
+    { name: "build", event: "push", conclusion: "SUCCESS", status: "COMPLETED", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  const latest = latestRunPerCheck(rollup);
+  assertEquals(latest.length, 2, "distinct identities must not collapse into one gate");
+  assertEquals(
+    failingCheckNames(rollup),
+    ["buildpush"],
+    "the event-less red `buildpush` survives — the green `build`+`push` run must not discard it",
+  );
+});
+
+test("#957: a known-event gate never merges with the unknown-event bucket of the same name", () => {
+  // Same display name, one run event-ful, one event-less: these are different gates, so both survive.
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", completedAt: "2026-11-12T00:41:34Z" }, // event-less (legacy)
+    { name: "build", event: "push", conclusion: "SUCCESS", status: "COMPLETED", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  assertEquals(latestRunPerCheck(rollup).length, 2, "known-event and unknown-event runs of one name stay separate");
+  assertEquals(failingCheckNames(rollup), ["build"], "the event-less red run is not shadowed by the eventful green one");
+});
+
+// ── PR #957 review: the real transport must populate `event` ─────────────────────────────────────
+//
+// The `gh pr view --json statusCheckRollup` exporter omits `event` (cli/cli `api/export_pr.go`), so
+// `fetchPrState` enriches the rollup from GraphQL `CheckRun.checkSuite.workflowRun.event` before
+// grouping. `applyRollupEvents` is the pure mapping; these cover the transport normalisation path.
+
+test("#957: applyRollupEvents stamps each CheckRun's triggering event so the collapse separates events", () => {
+  // What `gh pr view --json statusCheckRollup` actually returns: NO `event` field on either run.
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", status: "COMPLETED", startedAt: "2026-11-12T00:30:00Z", completedAt: "2026-11-12T00:41:34Z" },
+    { name: "build", conclusion: "SUCCESS", status: "COMPLETED", startedAt: "2026-11-12T00:41:30Z", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  // Without enrichment the name-only fallback collapses the red run away (the #955 hole).
+  assertEquals(failingCheckNames(rollup), [], "pre-enrichment: the newer green run hides the red one");
+  // The GraphQL `statusCheckRollup.contexts` nodes for the same head, joined by (name, startedAt).
+  const nodes = [
+    { __typename: "CheckRun", databaseId: 1001, name: "build", startedAt: "2026-11-12T00:30:00Z", checkSuite: { workflowRun: { event: "pull_request" } } },
+    { __typename: "CheckRun", databaseId: 1002, name: "build", startedAt: "2026-11-12T00:41:30Z", checkSuite: { workflowRun: { event: "push" } } },
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, "pull_request");
+  assertEquals(rollup[0].databaseId, 1001);
+  assertEquals(rollup[1].event, "push");
+  assertEquals(rollup[1].databaseId, 1002);
+  assertEquals(
+    failingCheckNames(rollup),
+    ["build"],
+    "post-enrichment: the red pull_request run survives — #955 is actually fixed on the real transport",
+  );
+});
+
+test("#957: applyRollupEvents leaves a StatusContext / misaligned / unreadable node event-less", () => {
+  const rollup = [
+    { context: "ci/legacy", state: "SUCCESS", createdAt: "2026-11-12T00:41:34Z" }, // a StatusContext
+    { name: "build", conclusion: "SUCCESS", status: "COMPLETED", startedAt: "2026-11-12T00:41:30Z", completedAt: "2026-11-12T00:41:38Z" },
+    { name: "test", conclusion: "SUCCESS", status: "COMPLETED", startedAt: "2026-11-12T00:41:31Z", completedAt: "2026-11-12T00:41:39Z" },
+  ];
+  const nodes = [
+    { __typename: "StatusContext", context: "ci/legacy" }, // no event on this type
+    { __typename: "CheckRun", name: "DIFFERENT", startedAt: "2026-11-12T00:41:30Z", checkSuite: { workflowRun: { event: "push" } } }, // misaligned name
+    { __typename: "CheckRun", name: "test", startedAt: "2026-11-12T00:41:31Z", checkSuite: { workflowRun: { event: null } } }, // unreadable run
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, undefined, "a StatusContext never gains an event");
+  assertEquals(rollup[1].event, undefined, "a misaligned node is not stamped blindly");
+  assertEquals(rollup[2].event, undefined, "a null/absent event leaves the entry event-less");
+});
+
+// ── PR #957 review round 3: the join is by run identity, never array position ────────────────────
+//
+// The `gh pr view` read and the GraphQL contexts read are two SEPARATE GitHub calls that can observe
+// different runs or heads, so index `i` in one is not reliably run `i` in the other. A positional
+// join can stamp one run's event onto another (the name guard cannot catch it for duplicate `build`
+// names), re-creating the cross-event collapse #955 fixed. The join keys on `(name, startedAt)` and
+// stamps only an exact 1:1 bucket match.
+
+test("#957: applyRollupEvents joins by run identity, not position — a reordered read stamps the right runs", () => {
+  // The GraphQL read returns the two same-named runs in the OPPOSITE order from the CLI rollup.
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", status: "COMPLETED", startedAt: "2026-11-12T00:30:00Z", completedAt: "2026-11-12T00:41:34Z" },
+    { name: "build", conclusion: "SUCCESS", status: "COMPLETED", startedAt: "2026-11-12T00:41:30Z", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  const nodes = [
+    // Reversed order vs the rollup: a positional join would stamp push onto the red run.
+    { __typename: "CheckRun", databaseId: 1002, name: "build", startedAt: "2026-11-12T00:41:30Z", checkSuite: { workflowRun: { event: "push" } } },
+    { __typename: "CheckRun", databaseId: 1001, name: "build", startedAt: "2026-11-12T00:30:00Z", checkSuite: { workflowRun: { event: "pull_request" } } },
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, "pull_request", "the red run keeps ITS event despite the reorder");
+  assertEquals(rollup[1].event, "push", "the green run keeps ITS event despite the reorder");
+  assertEquals(failingCheckNames(rollup), ["build"], "no cross-run stamp → the red pull_request run survives");
+});
+
+test("#957: applyRollupEvents stamps nothing when the two reads observed different run sets", () => {
+  // A rerun landed between the `gh pr view` read and the GraphQL read: the GraphQL side has an
+  // EXTRA `build` run at the SAME start instant (a cancelled/re-run pair re-queued together), so the
+  // node bucket (2) out-sizes the rollup bucket (1) and stamping anything would risk a cross-run stamp.
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", status: "COMPLETED", startedAt: "2026-11-12T00:30:00Z", completedAt: "2026-11-12T00:41:34Z" },
+  ];
+  const nodes = [
+    { __typename: "CheckRun", databaseId: 1001, name: "build", startedAt: "2026-11-12T00:30:00Z", checkSuite: { workflowRun: { event: "pull_request" } } },
+    { __typename: "CheckRun", databaseId: 1003, name: "build", startedAt: "2026-11-12T00:30:00Z", checkSuite: { workflowRun: { event: "push" } } },
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, undefined, "a bucket-size mismatch (the reads disagree) stamps nothing");
+});
+
+// ── PR #957 review round 3: the gate key is encoded for EVERY entry, event-less included ─────────
+//
+// Encoding only the known-event bucket leaves the two key spaces overlapping: `name:"build",
+// event:"push"` produces `5:buildpush`, and an event-less `context:"5:buildpush"` ALSO produces
+// `5:buildpush`, so a newer green entry could still discard an unrelated red check. Every entry —
+// event-less ones included — is encoded as the same length-prefixed tuple.
+
+test("#957: an eventful `build`+`push` never collides with an event-less `5:buildpush` context", () => {
+  const rollup = [
+    // An event-less legacy StatusContext whose context string equals the ENCODED tuple of the other gate.
+    { context: "5:buildpush", state: "FAILURE", createdAt: "2026-11-12T00:41:34Z" },
+    // A different gate: a CheckRun named `build` triggered by `push`, green, newer.
+    { name: "build", event: "push", conclusion: "SUCCESS", status: "COMPLETED", completedAt: "2026-11-12T00:41:38Z" },
+  ];
+  const latest = latestRunPerCheck(rollup);
+  assertEquals(latest.length, 2, "the encoded event-less key never aliases an eventful gate");
+  assertEquals(
+    failingCheckNames(rollup),
+    ["5:buildpush"],
+    "the red event-less `5:buildpush` survives — encoding every entry closes the cross-bucket hole",
+  );
+});
+
+// ── PR #957 review round 3: a prototype-free dictionary for arbitrary check names ────────────────
+//
+// A check can legitimately be named `constructor`, `toString`, or `__proto__`; on a plain `{}` those
+// resolve to an INHERITED property, so `out[name] ?? []` returns a function/object and `.push`
+// throws — aborting `fetchPrState` / readiness parsing for that PR. The dictionary is
+// prototype-free (`Object.create(null)`), so every check name is a safe own-key.
+
+test("#957: checkGateConclusions survives a check named `constructor` / `toString` / `__proto__`", () => {
+  const rollup = [
+    { name: "constructor", conclusion: "FAILURE", status: "COMPLETED", completedAt: "2026-11-12T00:41:34Z" },
+    { name: "toString", conclusion: "SUCCESS", status: "COMPLETED", completedAt: "2026-11-12T00:41:35Z" },
+    { name: "__proto__", conclusion: "SUCCESS", status: "COMPLETED", completedAt: "2026-11-12T00:41:36Z" },
+  ];
+  const gates = checkGateConclusions(rollup);
+  assertEquals(gates.constructor, ["FAILURE"], "an inherited-property name is a safe own-key");
+  assertEquals(gates.toString, ["SUCCESS"]);
+  assertEquals(gates.__proto__, ["SUCCESS"]);
+  assertEquals(failingCheckNames(rollup), ["constructor"], "and the failure is still reported, not crashed");
+});
+
+// ── PR #957 review round 4: never assign events by position inside a multi-run bucket ────────────
+
+test("#957: same (name, startedAt) runs reordered between reads are joined by detailsUrl, not position", () => {
+  const t = "2026-11-12T00:30:00Z";
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", status: "COMPLETED", startedAt: t, completedAt: "2026-11-12T00:41:34Z", detailsUrl: "https://github.com/o/r/actions/runs/1/job/11" },
+    { name: "build", conclusion: "SUCCESS", status: "COMPLETED", startedAt: t, completedAt: "2026-11-12T00:41:38Z", detailsUrl: "https://github.com/o/r/actions/runs/2/job/22" },
+  ];
+  const nodes = [
+    { __typename: "CheckRun", databaseId: 22, name: "build", startedAt: t, detailsUrl: "https://github.com/o/r/actions/runs/2/job/22", checkSuite: { workflowRun: { event: "push" } } },
+    { __typename: "CheckRun", databaseId: 11, name: "build", startedAt: t, detailsUrl: "https://github.com/o/r/actions/runs/1/job/11", checkSuite: { workflowRun: { event: "pull_request" } } },
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, "pull_request");
+  assertEquals(rollup[0].databaseId, 11);
+  assertEquals(rollup[1].event, "push");
+  assertEquals(rollup[1].databaseId, 22);
+  assertEquals(failingCheckNames(rollup), ["build"]);
+});
+
+test("#957: a mixed-event multi-run bucket without a joinable URL stamps nothing (no positional swap)", () => {
+  const t = "2026-11-12T00:30:00Z";
+  const rollup = [
+    { name: "build", conclusion: "FAILURE", status: "COMPLETED", startedAt: t },
+    { name: "build", conclusion: "SUCCESS", status: "COMPLETED", startedAt: t },
+  ];
+  const nodes = [
+    { __typename: "CheckRun", name: "build", startedAt: t, checkSuite: { workflowRun: { event: "push" } } },
+    { __typename: "CheckRun", name: "build", startedAt: t, checkSuite: { workflowRun: { event: "pull_request" } } },
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, undefined);
+  assertEquals(rollup[1].event, undefined);
+});
+
+test("#957: a same-event multi-run bucket is stamped order-independently", () => {
+  const t = "2026-11-12T00:30:00Z";
+  const rollup = [
+    { name: "build", conclusion: "CANCELLED", status: "COMPLETED", startedAt: t },
+    { name: "build", conclusion: "SUCCESS", status: "COMPLETED", startedAt: t },
+  ];
+  const nodes = [
+    { __typename: "CheckRun", name: "build", startedAt: t, checkSuite: { workflowRun: { event: "pull_request" } } },
+    { __typename: "CheckRun", name: "build", startedAt: t, checkSuite: { workflowRun: { event: "pull_request" } } },
+  ];
+  applyRollupEvents(rollup, nodes);
+  assertEquals(rollup[0].event, "pull_request");
+  assertEquals(rollup[1].event, "pull_request");
+});