Say a pull request nobody checks as a delivery held, owned by mesh-delivery (hq issue 347)

The confirmation review asked for the delivery domain's own vocabulary
instead of a provider standing. A gitea health check would need a `tools`
list (turning gitea's tools into seat verbs), a check of another kind
beside it, and would hold the forge's own deliveries at the first-node
gate; so the delivery's owner says it, with the word it already has.

- gitea_open_pulls (gitea): every open pull request from the forge itself,
  with what its base requires and the statuses its head has.
- mesh-delivery asks it every five minutes and keeps its own first-seen
  time per head (the forge's update time moves on every comment). A head
  on a base requiring mesh/merge-gate OR mesh/repo-check (hq requires only
  the second) with neither for ten minutes is a `stalled` line in state
  `unannounced`, which the controller raises as delivery.<id>.stalled (D14);
  H2 has nothing to close. Once announced it is a delivery of its own.
- The gitea-side watcher and its provider standing are gone.

modules/gitea/README.md

@@ -13,12 +13,11 @@ Every new head of an open pull request is announced as `pull.updated`, once, and
   retargeting a pull request moves its own update time and not its repository's, and a pull request opened more
   than a minute after its push was never announced (issue 347); and every repository on a sweep, every ten
   minutes, or when the search fails.
-- **A pull request nobody checks is said.** Every five minutes the forge itself is asked for every open pull
-  request; one whose base requires `mesh/merge-gate` and whose head has had no such status for ten minutes is
-  said as this forge failing *the merge check of `<owner>/<repo>#<n>`* (`provisioner.failing`, class
-  `unannounced`), which the controller keeps as a condition (ADR 0224), said again each pass while it lasts, and
-  recovered when a check arrives or the pull request closes. What is said is kept in `pulls-unannounced.json`
-  beside the announcer's record, so a restart recovers what it said.
+- **A pull request nobody checks is said — by the delivery's owner, not here.** `gitea_open_pulls` answers every
+  open pull request from the forge itself, with the statuses its base requires and the ones its head has. The
+  `mesh-delivery` module asks it every five minutes, and a head on a base requiring `mesh/merge-gate` or
+  `mesh/repo-check` with neither for ten minutes since it first saw it so is a delivery held past its bound
+  (`delivery.<id>.stalled`, state `unannounced`), which the controller raises like any other (issue 347).
 - **How to see it work.** A pull request opened more than a minute after its branch was pushed — this fix's own
   was one, and the announcer it fixes never saw it — has `mesh/merge-gate` pending within a pass of the next sweep
   at the latest, and `mesh-controller.conditions` names none for it.

modules/gitea/client.ts

@@ -54,6 +54,20 @@ export interface GiteaPull {
   body?: string;
 }
 
+/** An open pull request with what its base requires and what its head has: what gitea_open_pulls answers. */
+export interface OpenPull {
+  owner: string;
+  repo: string;
+  number: number;
+  base: string;
+  head_sha: string;
+  html_url?: string;
+  /** The contexts the base branch's protection requires; none when it requires none, or cannot be read. */
+  required: string[];
+  /** The contexts the head has a status of, in any state. */
+  statuses: string[];
+}
+
 /** A commit status, as the forge keeps it: what a pull request shows beside its head commit. */
 export interface CommitStatus {
   state: "pending" | "success" | "error" | "failure" | "warning";
@@ -280,6 +294,26 @@ export class GiteaClient {
     return out;
   }
 
+  /** **Every open pull request, from the forge itself** (novox/hq issue 347): with what its base's protection
+   *  requires and the contexts its head has a status of, in any state. What mesh-delivery reads to say a pull
+   *  request the mesh was never asked to check; asked of the forge, never of what the announcer remembers, so a
+   *  fault in the announcer cannot hide itself. Reads only. */
+  async openPulls(): Promise<OpenPull[]> {
+    const out: OpenPull[] = [];
+    const rules = new Map<string, BranchProtection[] | undefined>();
+    for (const found of await this.searchOpenPulls()) {
+      const full = `${found.owner}/${found.name}`;
+      const pull = await this.getPullRequest(found.owner, found.name, found.number);
+      if (pull.state !== "open" || !pull.head_sha) continue;
+      if (!rules.has(full)) rules.set(full, await this.branchProtections(found.owner, found.name).catch(() => undefined));
+      const rule = rules.get(full)?.find((p) => (p.rule_name ?? p.branch_name) === (pull.base || "main"));
+      const statuses = Object.keys(await this.commitStatuses(found.owner, found.name, pull.head_sha));
+      out.push({ owner: found.owner, repo: found.name, number: pull.number, base: pull.base ?? "", head_sha: pull.head_sha,
+        html_url: pull.html_url, required: rule?.enable_status_check ? (rule.status_check_contexts ?? []) : [], statuses });
+    }
+    return out;
+  }
+
   async getPullRequest(owner: string, repo: string, index: number): Promise<GiteaPull> {
     indexOf(index);
     return GiteaClient.mapPull(await this.request<any>(`/repos/${owner}/${repo}/pulls/${index}`));

modules/gitea/index.ts

@@ -28,7 +28,7 @@
 import { emit, on } from "@novox/mesh-sdk/events";
 import { GiteaClient, movedSince } from "./client.js";
 import { CHECK_CONTEXT, REPO_CHECK_CONTEXT, commentFor, headsToAnnounce, statusesFor, type Announced, type Checked,
-  type RepoCheckFacts, reposToLook, unannounced, type OpenPull } from "./pulls.js";
+  type RepoCheckFacts, reposToLook } from "./pulls.js";
 
 // Without a way to a token — configured, or mintable with the admin account (token.ts) — there is
 // nothing to watch; log and stay quiet rather than crash the runtime. With one, the first poll mints
@@ -290,68 +290,6 @@ async function pollPulls(client: GiteaClient): Promise<void> {
   lastPullLook = began;
 }
 
-// **An open pull request nobody checks is said** (novox/hq issue 347). One whose base requires the merge check and
-// whose head has had none for ten minutes was announced by nobody — the fault this watcher exists for, which went
-// unseen while the pull request could not merge. Said as this forge failing the merge check, the provider standing
-// the controller keeps as a condition (ADR 0224) and says to the operator; said again every pass while it lasts, and
-// recovered when a check arrives or the pull request is no longer open. Asked of the forge itself, never of what
-// the announcer remembers, so a fault in the announcer cannot hide itself.
-const unannouncedRecord = process.env.MESH_GITEA_STATE_DIR ? join(process.env.MESH_GITEA_STATE_DIR, "pulls-unannounced.json") : null;
-let failing: Record<string, string> = {};
-if (unannouncedRecord && existsSync(unannouncedRecord)) {
-  try {
-    failing = (JSON.parse(readFileSync(unannouncedRecord, "utf8")) as { failing: Record<string, string> }).failing ?? {};
-  } catch {
-    // Unreadable is no record: a pull request still unchecked is said again at once.
-  }
-}
-function keepFailing(): void {
-  if (!unannouncedRecord) return;
-  mkdirSync(join(unannouncedRecord, ".."), { recursive: true });
-  const tmp = unannouncedRecord + ".tmp";
-  writeFileSync(tmp, JSON.stringify({ failing }));
-  renameSync(tmp, unannouncedRecord);
-}
-const consumerOf = (key: string) => `the merge check of ${key}`;
-async function watchUnannounced(client: GiteaClient): Promise<void> {
-  const open: OpenPull[] = [];
-  const rules = new Map<string, Awaited<ReturnType<GiteaClient["branchProtections"]>> | undefined>();
-  for (const found of await client.searchOpenPulls()) {
-    const full = `${found.owner}/${found.name}`;
-    const pull = await client.getPullRequest(found.owner, found.name, found.number);
-    if (pull.state !== "open" || !pull.head_sha) continue;
-    if (!rules.has(full)) rules.set(full, await client.branchProtections(found.owner, found.name).catch(() => undefined));
-    const rule = rules.get(full)?.find((p) => (p.rule_name ?? p.branch_name) === (pull.base || "main"));
-    const statuses = Object.keys(await client.commitStatuses(found.owner, found.name, pull.head_sha));
-    open.push({ key: `${full}#${pull.number}`, base: pull.base ?? "", head_sha: pull.head_sha, updated_at: pull.updated_at,
-      statuses, required: rule?.enable_status_check ? (rule.status_check_contexts ?? []) : [] });
-  }
-  const now = Date.now();
-  const unchecked = new Map(unannounced(open, now).map((p) => [p.key, p] as const));
-  const node = process.env.MESH_NODE ?? "";
-  for (const [key, p] of unchecked) {
-    const since = failing[key] ?? p.updated_at ?? new Date(now).toISOString();
-    await emit("provisioner.failing", {
-      provider: "git", "provider-node": node, consumer: consumerOf(key), node: "", class: "unannounced",
-      error: `${key} is open on ${p.base}, which requires ${CHECK_CONTEXT}, and its head ${p.head_sha.slice(0, 12)} has had no ` +
-        `merge check for ${Math.round((now - Date.parse(p.updated_at ?? since)) / 60_000)} minutes: the mesh was never asked to check it`,
-      since, attempts: 1,
-    });
-    if (!failing[key]) console.error(`[gitea] ${key} has had no merge check for ten minutes: said to the mesh`);
-    failing[key] = since;
-  }
-  for (const key of Object.keys(failing)) {
-    if (unchecked.has(key)) continue;
-    await emit("provisioner.recovered", {
-      provider: "git", "provider-node": node, consumer: consumerOf(key), node: "", since: failing[key], attempts: 0,
-      why: "it has a merge check, or is no longer open",
-    });
-    console.log(`[gitea] ${key} has a merge check now, or is no longer open`);
-    delete failing[key];
-  }
-  keepFailing();
-}
-
 // **The verdict, set where the pull request shows it.** Every verdict is the head commit's status; one
 // that is not a pass also leaves the check's own account as a comment, so the reason is read where the
 // change is reviewed. An error — the check could not run — is the forge's `error`, never a success.
@@ -425,7 +363,6 @@ if (gitea) {
   tick(() => pollRepos(client), 60_000);
   tick(() => pollMerged(client), 30_000);
   tick(() => pollPulls(client), 30_000);
-  tick(() => watchUnannounced(client), 5 * 60_000);
   await on("mesh-controller.checked", (event) => setVerdict(client, event));
   console.log("[gitea] watching for new repositories and merged pull requests");
 }

modules/gitea/pulls.ts

@@ -113,31 +113,6 @@ export function reposToLook(repos: GiteaRepo[], floor: string, pulls: PullSeen[]
   return repos.filter((r) => moved.has(r.full_name));
 }
 
-/** How long a head may go without a merge check before it is said: the announcer's passes are half a minute
- *  apart and the check is asked at once, so ten minutes is a fault, never a queue. */
-export const UNANNOUNCED_AFTER_MS = 10 * 60_000;
-
-/** An open pull request as the watcher of announcements reads it. */
-export interface OpenPull {
-  /** `owner/repo#number`. */
-  key: string;
-  base: string;
-  head_sha: string;
-  /** When its head last moved, or it was opened or retargeted. */
-  updated_at?: string;
-  /** The status contexts its head has, any state. */
-  statuses: string[];
-  /** The contexts its base branch's protection requires. */
-  required: string[];
-}
-
-/** The open pull requests whose base requires the merge check and whose head has had none for ten minutes
- *  (novox/hq issue 347): announced by nobody, checked by nothing, and blocked from merging with no word why. */
-export function unannounced(pulls: OpenPull[], now: number, after = UNANNOUNCED_AFTER_MS): OpenPull[] {
-  return pulls.filter((p) => p.required.includes(CHECK_CONTEXT) && !p.statuses.includes(CHECK_CONTEXT) &&
-    !!p.updated_at && now - Date.parse(p.updated_at) >= after);
-}
-
 // **A required status is success or it blocks** (novox/hq issue 293). The forge combines `warning` as a
 // failure, and a branch whose protection requires mesh/merge-gate or mesh/repo-check — with no
 // administrator override — will not merge past one. So the controller's `warning`, a note and never a

modules/gitea/test/announcing.test.ts

@@ -28,17 +28,47 @@ test("a pull request opened after the margin is looked at, by its own update tim
   assert.deepEqual(reposToLook(repos, "", [], false).length, 2, "the first pass looks at every repository");
 });
 
-test("an open pull request on a protected branch with no merge check for ten minutes is said, and nothing else", async () => {
-  const { unannounced } = await import("../pulls.ts");
-  const now = Date.parse("2026-10-09T10:30:00Z");
-  const pull = {
-    key: "novox/mesh-sdk#14", base: "main", head_sha: "bfe82315f42c", updated_at: "2026-10-09T10:12:00Z",
-    statuses: [] as string[], required: ["mesh/merge-gate", "mesh/repo-check"],
-  };
-  assert.deepEqual(unannounced([pull], now).map((p) => p.key), ["novox/mesh-sdk#14"]);
-  assert.deepEqual(unannounced([{ ...pull, statuses: ["mesh/merge-gate"] }], now), [], "a head with a merge check");
-  assert.deepEqual(unannounced([{ ...pull, required: [] }], now), [], "a branch that requires no merge check");
-  assert.deepEqual(unannounced([{ ...pull, updated_at: "2026-10-09T10:25:00Z" }], now), [], "a head five minutes old");
+test("every open pull request is read with what its base requires and what its head has (gitea_open_pulls)", async () => {
+  const { GiteaClient } = await import("../client.ts");
+  const asked: string[] = [];
+  const server = createServer((req, res) => {
+    asked.push(req.url ?? "");
+    const url = req.url ?? "";
+    const send = (v: unknown) => res.end(JSON.stringify(v));
+    if (url.startsWith("/api/v1/repos/issues/search")) {
+      return send(url.includes("page=1") ? [
+        { number: 243, repository: { owner: "novox", name: "hq", full_name: "novox/hq" }, updated_at: "2026-10-09T11:00:00Z" },
+        { number: 14, repository: { owner: "novox", name: "mesh-sdk", full_name: "novox/mesh-sdk" } },
+      ] : []);
+    }
+    if (url.startsWith("/api/v1/repos/novox/hq/pulls/243")) {
+      return send({ number: 243, state: "open", base: { ref: "main" }, head: { ref: "x", sha: "aaa111" }, html_url: "h" });
+    }
+    if (url.startsWith("/api/v1/repos/novox/mesh-sdk/pulls/14")) {
+      return send({ number: 14, state: "open", base: { ref: "main" }, head: { ref: "y", sha: "bbb222" }, html_url: "s" });
+    }
+    if (url.startsWith("/api/v1/repos/novox/hq/branch_protections")) {
+      return send([{ rule_name: "main", enable_status_check: true, status_check_contexts: ["mesh/repo-check"] }]);
+    }
+    if (url.startsWith("/api/v1/repos/novox/mesh-sdk/branch_protections")) {
+      return send([{ rule_name: "main", enable_status_check: true, status_check_contexts: ["mesh/merge-gate", "mesh/repo-check"] }]);
+    }
+    if (url.includes("/commits/aaa111/status")) return send({ statuses: [] });
+    if (url.includes("/commits/bbb222/status")) return send({ statuses: [{ context: "mesh/merge-gate", status: "pending" }] });
+    res.statusCode = 404;
+    res.end("{}");
+  });
+  await new Promise<void>((r) => server.listen(0, r));
+  const client = new GiteaClient(`http://127.0.0.1:${(server.address() as any).port}`, "t");
+  try {
+    const open = await client.openPulls();
+    assert.deepEqual(open.map((p) => [p.owner, p.repo, p.number, p.base, p.head_sha, p.required, p.statuses]), [
+      ["novox", "hq", 243, "main", "aaa111", ["mesh/repo-check"], []],
+      ["novox", "mesh-sdk", 14, "main", "bbb222", ["mesh/merge-gate", "mesh/repo-check"], ["mesh/merge-gate"]],
+    ]);
+  } finally {
+    server.close();
+  }
 });
 
 test("a pull request or issue number that is not one is refused before the forge is asked", async () => {

modules/gitea/test/token.test.ts

@@ -411,7 +411,7 @@ test("the tools register once there is a way to a token, and the first call mint
       "gitea_list_branches",
       "gitea_delete_branch",
       "gitea_branch_protection_get", "gitea_branch_protection_set",
-      "gitea_note_append", "gitea_delivery_view", "gitea_commit_statuses", "gitea_contains", "gitea_commit_status",
+      "gitea_note_append", "gitea_delivery_view", "gitea_commit_statuses", "gitea_open_pulls", "gitea_contains", "gitea_commit_status",
       "gitea_list_labels", "gitea_create_label",
       "gitea_api",
     ],

modules/gitea/tools/index.ts

@@ -492,6 +492,12 @@ export function getGiteaTools(gitea: GiteaClient): ToolDefinition[] {
           merge: mergeableUnder(base, rule, statuses, unreadable) };
       },
     },
+    {
+      name: "gitea_open_pulls",
+      description: "Every open pull request of every repository, from the forge itself: its head, its base, the statuses the base's protection requires and the ones its head has, in any state. What mesh-delivery reads to say a pull request the mesh was never asked to check (novox/hq issue 347). Reads only.",
+      input: {},
+      run: async () => ({ pulls: await gitea.openPulls() }),
+    },
     {
       name: "gitea_contains",
       description: "Whether a commit is contained in another — an ancestor of it, or the same — from the forge's compare of the two: what mesh-delivery reads before it says a held merge is covered by a later one (novox/hq ADR 0270). Commits only, by sha or the start of one. Reads only.",