eve-hub 0.16.21 → 0.16.22

package/schedules/dash-rules.mjs

@@ -1,347 +0,0 @@
-// The decisions behind main's dash schedule (schedules/dash.ts), pure: each
-// takes the registry's /api/state snapshot (`snap`), the schedule's saved
-// state and the time. No I/O here; schedules/hub.mjs does that.
-//
-// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the
-// tests (plain node) import the same module.
-
-const parse = (iso) => {
-  const ms = Date.parse(iso ?? "");
-  return Number.isFinite(ms) ? ms : null;
-};
-const link = (thread) => `[${String(thread?.title ?? thread?.id ?? "?").replace(/[[\]]/g, "")}](${thread?.id})`;
-import { said, lastSaid } from "./thread-brief.mjs";
-import { coordinatorOf } from "../workspace.mjs";
-
-// ---------------------------------------------------------------------------
-// dash: what changed since the last scan that could put something on the
-// human's Dash (hosted-hub/src/domain/dash.mjs), with no model call. Four parts, each kept
-// exactly (by id, not time) in the saved state:
-//   p  the human's PRs: CI, review, draft, merge conflicts, open/merged/closed,
-//      and every PR a Dash item waits on, whoever wrote it. A PR that leaves
-//      the search's page while still open stays tracked (asked by name) until
-//      it merges or closes. { "owner/repo": { "12": packed } }
-//   n  threads with a pending request to the human (a question or an
-//      approval a bot asked for). { threadId: "w:" + the pending request
-//      ids }. A bot's `waiting` status alone isn't one: it also means
-//      waiting on its own tasks. A thread that waits on the human in what was said is
-//      the classifier's call (the Dash model's verdict, see asksNotice in
-//      ./dash-classify.mjs), not this scan's. While a bot works there the
-//      previous entry is kept, so a request made meanwhile posts once the
-//      thread settles.
-//   d  each Dash item's thread once it settles (nobody working): its last
-//      message, so main hears when a thread it listed moved on. An item new
-//      since the last scan is compared with what was said after main added
-//      it (item.addedAt).
-//   w  Dash items whose waitingOn is met: the PR merged (or closed) or went
-//      green, the thread got a message, the date passed. { threadId: reason }
-// The saved state is all four plus their hash; a notice goes out only when
-// one of them says something new (the hash changes on any change, so the
-// state is saved then even when there's nothing to say, e.g. a bot started).
-// The schedule-state cap is 256 KB (registry/server.mjs): about 2,000 PRs or
-// 8,000 asking threads. Over it, PR titles go first; past that the commit is
-// refused, nothing posts and the sidebar shows the Dash stale.
-const prUrl = (key) => {
-  const m = key.match(/^([^/]+\/[^#]+)#(\d+)$/);
-  return m ? `https://github.com/${m[1]}/pull/${m[2]}` : "";
-};
-const short = (pr) => ({ t: String(pr.title ?? "").replace(/\s+/g, " ").trim().slice(0, 40), d: !!pr.draft, c: pr.ci ?? "none", r: pr.review ?? "none", ...(pr.mergeable ? { m: pr.mergeable } : {}) });
-// A PR is packed as "c r d m x title": one-letter codes, `-` for none.
-const CODES = {
-  c: { success: "s", failure: "f", pending: "p", error: "e", expected: "x", none: "-" },
-  r: { approved: "a", changes_requested: "c", review_required: "r", none: "-" },
-  m: { mergeable: "m", conflicting: "c" },
-  x: { merged: "m", closed: "c" },
-};
-const DECODE = Object.fromEntries(Object.entries(CODES).map(([f, map]) => [f, Object.fromEntries(Object.entries(map).map(([k, v]) => [v, k]))]));
-const enc = (f, v) => (v == null ? "-" : CODES[f][v] ?? (String(v).replace(/\s+/g, "_") || "-"));
-const dec = (f, v) => DECODE[f][v] ?? v;
-export const packPr = (s, title = true) => `${enc("c", s.c)} ${enc("r", s.r)} ${s.d ? 1 : 0} ${enc("m", s.m)} ${enc("x", s.x)}${title && s.t ? ` ${s.t}` : ""}`;
-export function unpackPr(v) {
-  if (v && typeof v === "object") return v; // saved before packing
-  const [c, r, d, m, x, ...t] = String(v).split(" ");
-  return { c: dec("c", c), r: dec("r", r), d: d === "1", ...(m !== "-" ? { m: dec("m", m) } : {}), ...(x !== "-" ? { x: dec("x", x) } : {}), t: t.join(" ") };
-}
-// { "owner/repo": { "12": v } } <-> { "owner/repo#12": v }; flat keys are the older form.
-const flatPrs = (p) => {
-  const out = {};
-  for (const [k, v] of Object.entries(p ?? {})) {
-    if (k.includes("#")) out[k] = v;
-    else for (const [n, x] of Object.entries(v ?? {})) out[`${k}#${n}`] = x;
-  }
-  return out;
-};
-const nestPrs = (flat) => {
-  const out = {};
-  for (const [key, v] of Object.entries(flat)) {
-    const i = key.lastIndexOf("#");
-    (out[key.slice(0, i)] ??= {})[key.slice(i + 1)] = v;
-  }
-  return out;
-};
-// A saved dash state's PRs, unpacked: { "owner/repo#12": { c, r, d, m?, x?, t } }.
-export const dashPrs = (state) => Object.fromEntries(Object.entries(flatPrs(state?.p ?? state?.snapshot)).map(([k, v]) => [k, unpackPr(v)]));
-export const DASH_STATE_MAX = 256 * 1024;
-
-// The PR part. `prev`: the saved `p`; `prs`: [{ key, title, url, draft, ci,
-// review, mergeable?, state? }] from the probe, or null when the probe failed
-// (GitHub down, gh logged out): then every PR keeps what was last known and
-// nothing is said of any. `keep`: keys tracked even once merged or closed
-// (what Dash items wait on); `skip`: keys the probe couldn't answer this time
-// (their alias failed for a reason other than gone), kept as last known.
-// Returns the lines, `snapshot` (the new `p`), `seen` (unpacked, for waitMet)
-// and `untitled()`.
-export function dashDiff(prev, prs, keep = new Set(), skip = new Set()) {
-  const before = dashPrs({ p: prev });
-  const seen = {};
-  const lines = [];
-  const pack = (title) => nestPrs(Object.fromEntries(Object.entries(seen).map(([k, s]) => [k, packPr(s, title)])));
-  if (prs == null) {
-    Object.assign(seen, before);
-    return { lines, seen, snapshot: pack(true), untitled: () => pack(false) };
-  }
-  const label = (key, s) => `[${key}](${s.u ?? prUrl(key)})${s.t ? ` ${s.t}` : ""}`;
-  const got = new Map();
-  for (const pr of prs) if (!got.has(pr.key) || pr.state) got.set(pr.key, pr); // the alias answer has state; search's doesn't need it
-  for (const [key, pr] of got) {
-    const was = before[key];
-    // Skipped before anything is read: GraphQL can answer a PR whose failed
-    // field came back null (commits: null reads as CI none), so a skipped
-    // PR's node is never trusted. It keeps what was last known, or stays
-    // untracked, and nothing is said of it.
-    if (skip.has(key)) {
-      if (was) seen[key] = was;
-      continue;
-    }
-    const s = short(pr);
-    const shown = { ...s, u: pr.url, t: String(pr.title ?? "").slice(0, 60) };
-    // GitHub answers UNKNOWN while it computes mergeability: keep what we knew.
-    if (s.m === "unknown" && was?.m) s.m = was.m;
-    if (s.m === "unknown") delete s.m;
-    const closed = pr.state === "merged" || pr.state === "closed";
-    if (closed) {
-      if (was && !was.x) lines.push(`${pr.state}: ${label(key, shown)}`);
-      if (keep.has(key)) seen[key] = { ...s, x: pr.state };
-      continue;
-    }
-    seen[key] = s;
-    if (!was) {
-      lines.push(`new: ${label(key, shown)} (CI ${s.c}, review ${s.r}${s.d ? ", draft" : ""}${s.m === "conflicting" ? ", merge conflicts" : ""})`);
-      continue;
-    }
-    const changes = [];
-    if (was.x) changes.push("reopened");
-    if (was.c !== s.c) changes.push(`CI ${was.c} → ${s.c}`);
-    if (was.r !== s.r) changes.push(`review ${was.r} → ${s.r}`);
-    if (was.d !== s.d) changes.push(s.d ? "back to draft" : "ready for review");
-    if (was.m && s.m && was.m !== s.m) changes.push(s.m === "conflicting" ? "merge conflicts" : "conflicts resolved");
-    if (!was.m && s.m === "conflicting") changes.push("merge conflicts");
-    if (changes.length) lines.push(`${label(key, shown)}: ${changes.join(", ")}`);
-  }
-  // Tracked and not answered at all (deleted, access lost, or the probe's
-  // alias failed): told once, then dropped.
-  for (const [key, s] of Object.entries(before)) {
-    if (got.has(key)) continue;
-    if (skip.has(key)) seen[key] = s;
-    else if (!s.x) lines.push(`closed or merged: ${label(key, s)}`);
-  }
-  return { lines, seen, snapshot: pack(true), untitled: () => pack(false) };
-}
-
-const excerpt = (text, n = 100) => {
-  const t = String(text ?? "").replace(/\s+/g, " ").trim();
-  return t.length > n ? `${t.slice(0, n - 1)}…` : t;
-};
-
-// Threads with a pending request to the human: [{ id, sig, working }]. `sig` names the wait exactly: "w:" + the thread's
-// pending request ids.
-function asking(snap) {
-  const pending = {};
-  for (const r of Object.values(snap?.requests ?? {})) if (r.status === "pending" && r.threadId) (pending[r.threadId] ??= []).push(r.id);
-  const out = [];
-  for (const t of Object.values(snap?.threads ?? {})) {
-    if (t.archived || t.schedule || t.kind === "dm") continue; // the sidebar's Dash lists threads, not DMs
-    const status = Object.values(t.status ?? {});
-    const working = status.includes("working");
-    if (pending[t.id]?.length) out.push({ id: t.id, sig: `w:${(pending[t.id] ?? []).sort().join(",")}`, working });
-  }
-  return out;
-}
-
-// A Dash item's wait, met or not: the reason, or null. A PR wait is met when
-// it merges or closes, or (waitingOn.for "green") when its CI passes.
-function waitMet(item, snap, prs, nowMs) {
-  const w = item.waitingOn;
-  if (!w) return null;
-  if (w.pr) {
-    const s = prs[w.pr];
-    if (s?.x) return `${w.pr} ${s.x}`;
-    if (w.for === "green" && s?.c === "success") return `${w.pr} is green`;
-  }
-  if (w.thread) {
-    const t = snap?.threads?.[w.thread];
-    const since = parse(w.since) ?? 0;
-    const coordinator = coordinatorOf(snap?.agents);
-    const m = t && [...(t.messages ?? [])].reverse().find((x) => said(x) && x.author !== coordinator && (parse(x.at) ?? 0) > since);
-    if (m) return `${link(t)} got a message from ${m.author}`;
-  }
-  if (w.until && (parse(w.until) ?? Infinity) <= nowMs) return `${w.until.slice(0, 16).replace("T", " ")} passed`;
-  return null;
-}
-
-// The PRs the probe must ask about by name: what Dash items wait on, and
-// every PR tracked last time (so a merge is told apart from a close, and one
-// off the search's page is still watched).
-export function dashWatchList(snap, saved) {
-  const waited = new Set((snap?.dash?.items ?? []).map((i) => i.waitingOn?.pr).filter(Boolean));
-  const tracked = Object.keys(flatPrs(saved?.p ?? saved?.snapshot));
-  // The PRs a thread's latest review is about (entry.package.pr): asked in the same query so the
-  // Ready rule reads their head and CI, but not tracked, so their changes never post.
-  const reviewed = Object.values(snap?.dash?.entries ?? {}).map((e) => e.package?.pr).filter(Boolean);
-  return { keep: waited, refs: [...new Set([...waited, ...tracked, ...reviewed])], reviewed: new Set(reviewed) };
-}
-
-// `prs` null: the probe failed, PRs keep what was last known (dashDiff).
-// `skip`: PR keys whose own alias failed this time.
-export function dashScan(snap, saved, prs, nowMs, hashOf, skip = new Set()) {
-  const { keep } = dashWatchList(snap, saved);
-  const pr = dashDiff(saved?.p ?? saved?.snapshot ?? null, prs, keep, skip);
-  const lines = [...pr.lines];
-  const threads = snap?.threads ?? {};
-  const items = snap?.dash?.items ?? [];
-  const coordinator = coordinatorOf(snap?.agents);
-  const legacy = saved && saved.na !== undefined; // the short-lived time-based form: start over
-
-  // Asks, by identity. A thread a bot is working in keeps its previous entry
-  // (or none), so an ask made meanwhile is judged, and posted, once it settles.
-  // Only request waits ("w:"): asks read from messages (a message id, the
-  // older form) are the classifier's now, dropped without a notice.
-  const wasN = legacy ? {} : Object.fromEntries(Object.entries(saved?.n ?? {}).filter(([, sig]) => String(sig).startsWith("w:")));
-  const n = {};
-  const askingNow = new Set();
-  for (const a of asking(snap)) {
-    if (a.working) {
-      if (wasN[a.id] !== undefined) n[a.id] = wasN[a.id];
-      continue;
-    }
-    n[a.id] = a.sig;
-    askingNow.add(a.id);
-    if (wasN[a.id] === a.sig) continue;
-    const t = threads[a.id];
-    lines.push(`asks you: ${link(t)}, a bot is waiting on your answer or approval`);
-  }
-  // A thread that asked and no longer does keeps no entry, unless a bot is
-  // working there: then it's judged when it settles.
-  for (const [id, sig] of Object.entries(wasN)) if (n[id] === undefined && Object.values(threads[id]?.status ?? {}).includes("working")) n[id] = sig;
-  const noLonger = new Set();
-  const shown = new Map(items.map((i) => [i.threadId, i]));
-  for (const id of Object.keys(wasN)) if (!n[id] && shown.get(id)?.ball === "you" && threads[id]) {
-      noLonger.add(id);
-      lines.push(`no longer asking you: ${link(threads[id])}`);
-    }
-
-  const d = {};
-  for (const item of items) {
-    const t = threads[item.threadId];
-    if (!t) continue;
-    const working = Object.values(t.status ?? {}).includes("working");
-    let was = legacy ? undefined : saved?.d?.[item.threadId];
-    // An item new since the last scan: its baseline is the thread as the coordinator
-    // saw it when adding it, so anything said since (by anyone else) counts.
-    if (was === undefined && saved && item.addedAt) {
-      const since = parse(item.addedAt) ?? Infinity;
-      was = (t.messages ?? []).some((x) => said(x) && x.author !== coordinator && (parse(x.at) ?? 0) > since) ? "~" : undefined;
-    }
-    // Working: judged once it settles. A thread first seen working is marked
-    // "~", so its first settled message counts as moving on.
-    if (working) {
-      d[item.threadId] = was ?? "~";
-      continue;
-    }
-    const m = lastSaid(t);
-    d[item.threadId] = t.archived ? "archived" : (m?.id ?? "-");
-    if (was === undefined || was === d[item.threadId]) continue;
-    if (t.archived) lines.push(`archived: ${link(t)} is still on the Dash`);
-    else if (m && !askingNow.has(item.threadId) && !noLonger.has(item.threadId) && m.author !== coordinator) lines.push(`moved on: ${link(t)} (${item.ball}), ${m.author}: "${excerpt(m.text, 80)}"`);
-  }
-
-  const w = {};
-  for (const item of items) {
-    const reason = waitMet(item, snap, pr.seen, nowMs);
-    if (!reason) continue;
-    w[item.threadId] = reason;
-    if (saved?.w?.[item.threadId] !== reason) lines.push(`wait met: ${link(threads[item.threadId] ?? { id: item.threadId })}, ${reason}`);
-  }
-
-  // PR titles only label notices: dropped first if the state nears the cap.
-  let parts = { p: pr.snapshot, n, d, w };
-  if (Buffer.byteLength(JSON.stringify(parts)) > DASH_STATE_MAX - 1024) parts = { ...parts, p: pr.untitled() };
-  const hash = hashOf(JSON.stringify(parts));
-  const state = { ...parts, hash };
-  return { lines, state, changed: hash !== saved?.hash };
-}
-
-// The probe's GraphQL answer -> dashDiff's `prs`: the search's open PRs and
-// each PR asked about by name (aliases p0, p1, …: repository.pullRequest).
-const prOf = (n) => ({
-  key: `${n.repository?.nameWithOwner ?? "?"}#${n.number}`,
-  title: n.title,
-  url: n.url,
-  head: n.headRefOid ?? null,
-  ...(Number.isInteger(n.changedFiles) ? { size: { add: n.additions, del: n.deletions, files: n.changedFiles } } : {}),
-  draft: !!n.isDraft,
-  ci: String(n.commits?.nodes?.[0]?.commit?.statusCheckRollup?.state ?? "none").toLowerCase(),
-  review: String(n.reviewDecision ?? "none").toLowerCase(),
-  ...(n.mergeable ? { mergeable: String(n.mergeable).toLowerCase() } : {}),
-  ...(n.state ? { state: n.merged || n.state === "MERGED" ? "merged" : String(n.state).toLowerCase() } : {}),
-});
-
-// The PR keys whose answer failed, wholly or in part, for a reason other
-// than the PR or repo being gone. GraphQL errors carry the path: an alias
-// ("p3", dashQuery's order of `refs`) or a search node ("search", "nodes", 4).
-// NOT_FOUND / FORBIDDEN mean gone or no access (told closed, then dropped);
-// anything else (a timeout, an internal error) is a failed fetch, skipped,
-// even when the node came back with only the failed field nulled.
-const GONE = new Set(["NOT_FOUND", "FORBIDDEN"]);
-export function failedRefs(data, refs = []) {
-  const asked = refs.filter((ref) => REF.test(ref)); // dashQuery's aliases, in order
-  const nodes = data?.data?.search?.nodes ?? [];
-  const out = new Set();
-  for (const e of data?.errors ?? []) {
-    if (GONE.has(e?.type)) continue;
-    const path = e?.path ?? [];
-    const m = /^p(\d+)$/.exec(String(path[0] ?? ""));
-    if (m && asked[Number(m[1])]) out.add(asked[Number(m[1])]);
-    else if (path[0] === "search" && path[1] === "nodes" && Number.isInteger(path[2])) {
-      const n = nodes[path[2]];
-      if (n?.number && n.repository?.nameWithOwner) out.add(`${n.repository.nameWithOwner}#${n.number}`);
-    }
-  }
-  return out;
-}
-
-export function prsFromSearch(data) {
-  const nodes = data?.data?.search?.nodes ?? [];
-  const named = Object.entries(data?.data ?? {})
-    .filter(([k]) => /^p\d+$/.test(k))
-    .map(([, v]) => v?.pullRequest);
-  return [...nodes, ...named].filter((n) => n && n.number).map(prOf);
-}
-
-// The probe's query: the human's open PRs, plus `refs` ("owner/repo#12") by name.
-const PR_FIELDS = "number title url headRefOid additions deletions changedFiles isDraft state merged mergeable reviewDecision repository { nameWithOwner } commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }";
-const REF = /^([\w.-]+)\/([\w.-]+)#(\d+)$/;
-// GitHub gives up on a GraphQL request after ~10 s (502/504); a chunk of 40
-// names takes ~4 s.
-export const REFS_PER_QUERY = 40;
-export function dashQuery(refs = []) {
-  const named = refs
-    .map((ref) => ref.match(REF))
-    .filter(Boolean)
-    .map(([, owner, name, number], i) => `  p${i}: repository(owner: "${owner}", name: "${name}") { pullRequest(number: ${number}) { ...F } }`);
-  return `query {
-  search(query: "is:pr is:open author:@me archived:false sort:updated-desc", type: ISSUE, first: 50) { nodes { ...F } }
-${named.join("\n")}
-}
-fragment F on PullRequest { ${PR_FIELDS} }`;
-}

package/schedules/dash-run.mjs

@@ -1,167 +0,0 @@
-// One tick of main's dash schedule (schedules/dash.ts): the GitHub probe and
-// the run around it. A failed GitHub call never fails the tick: the probe is
-// retried once on a 5xx or a timeout, and if it still fails every PR keeps
-// what was last known (nothing said of any), threads and waits are still
-// scanned and posted, and the post carries a one-line note of what was
-// skipped. Only then is the Dash's checkedAt left alone, so the sidebar shows
-// the Dash stale while GitHub stays unreachable (no token, offline).
-//
-// The probe is one GraphQL query over HTTPS, as the workspace human: the
-// search is `author:@me`, so it needs their own user token, never an App's.
-// A hosted hub's function has no `gh`, so it asks Vercel Connect for the
-// token the bots' `git__gh` gets (github-connector.mjs); a local hub asks
-// `gh auth token`. The token goes in the request header and nowhere else.
-//
-// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the
-// tests (plain node) import the same module.
-import { execFile } from "node:child_process";
-import { createHash } from "node:crypto";
-import { NoValidTokenError, UserAuthorizationRequiredError, getToken } from "@vercel/connect";
-import { GITHUB_CONNECTOR, rosterSubject } from "../github-connector.mjs";
-import { runOnce } from "./hub.mjs";
-import { coordinatorOf } from "../workspace.mjs";
-import { REFS_PER_QUERY, dashPrs, dashQuery, dashScan, dashWatchList, failedRefs, prsFromSearch } from "./dash-rules.mjs";
-
-// The hub gives a schedule 60 s (registry/server.mjs
-// SCHEDULE_DISPATCH_TIMEOUT_MS): two 20 s tries and the registry calls fit.
-export const GH_TIMEOUT_MS = 20_000;
-export const GH_RETRY_DELAY_MS = 1_000;
-// The token comes first, once a tick, and leaves the two tries their 20 s.
-export const TOKEN_TIMEOUT_MS = 5_000;
-export const GITHUB_GRAPHQL_URL = "https://api.github.com/graphql";
-
-// A failure worth one more try: GitHub's 5xx, or no answer in time.
-export const retryable = (err) => !!(err?.timedOut || /HTTP 5\d\d|timed? ?out|ETIMEDOUT|ECONNRESET|unexpected EOF/i.test(String(err?.message ?? "")));
-
-// What a failure is called in the tick's note: "gh 504", "gh timeout", "GitHub approval needed", …
-export function ghReason(err) {
-  if (err instanceof UserAuthorizationRequiredError || err instanceof NoValidTokenError) return "GitHub approval needed";
-  const msg = String(err?.message ?? "");
-  const http = msg.match(/HTTP (\d{3})/);
-  if (http) return `gh ${http[1]}`;
-  if (err?.timedOut || /timed? ?out|ETIMEDOUT/i.test(msg)) return "gh timeout";
-  if (err?.code === "ENOENT") return "gh not installed";
-  if (/auth|logged in|gh auth login/i.test(msg)) return "gh not logged in";
-  return "gh failed";
-}
-
-const timedOut = (what) => Object.assign(new Error(`gh: ${what} timed out`), { timedOut: true });
-
-// The workspace human's GitHub user token. Hosted: Vercel Connect's, for the
-// subject `git__gh` resolves (`roster:<human>`); its errors pass through, so
-// a missing approval reads as one. Local: `gh auth token`.
-export function githubToken(human, { hosted = Boolean(process.env.VERCEL), connect = getToken, bin = "gh", timeoutMs = TOKEN_TIMEOUT_MS } = {}) {
-  if (hosted) {
-    if (!human) return Promise.reject(new Error("gh: the hub names no human to ask GitHub as"));
-    let timer;
-    const deadline = new Promise((_, reject) => { timer = setTimeout(() => reject(timedOut("Vercel Connect")), timeoutMs); });
-    return Promise.race([connect(GITHUB_CONNECTOR, { subject: rosterSubject(human) }), deadline]).finally(() => clearTimeout(timer));
-  }
-  return new Promise((resolve, reject) => {
-    execFile(bin, ["auth", "token"], { timeout: timeoutMs }, (error, stdout, stderr) => {
-      const token = String(stdout ?? "").trim();
-      if (!error && token) return resolve(token);
-      const err = new Error(`gh: ${String(stderr || error?.message || "no token").trim().replace(/^gh: /, "").slice(0, 300)}`);
-      if (error?.killed || error?.signal) err.timedOut = true;
-      if (error?.code === "ENOENT") err.code = "ENOENT";
-      reject(err);
-    });
-  });
-}
-
-// One GraphQL query: the parsed answer, or an Error ("gh: HTTP 502: …", or
-// `timedOut` set when GitHub didn't answer in time). A PR asked about by name
-// that's gone fails only its own alias and the rest of the answer is good, so
-// any answer with the search in it counts.
-export async function ghGraphql(query, { token, timeoutMs = GH_TIMEOUT_MS, fetchImpl = fetch } = {}) {
-  let res;
-  let text;
-  try {
-    res = await fetchImpl(GITHUB_GRAPHQL_URL, {
-      method: "POST",
-      headers: { authorization: `bearer ${token}`, "content-type": "application/json", "user-agent": "eve-hub-dash" },
-      body: JSON.stringify({ query }),
-      signal: AbortSignal.timeout(timeoutMs),
-    });
-    text = await res.text();
-  } catch (cause) {
-    if (cause?.name === "TimeoutError" || cause?.name === "AbortError") throw timedOut("GitHub");
-    throw new Error(`gh: ${String(cause?.message ?? cause).slice(0, 200)}${cause?.cause?.code ? ` (${cause.cause.code})` : ""}`);
-  }
-  let body = null;
-  try {
-    body = JSON.parse(text);
-  } catch {}
-  if (body?.data?.search) return body;
-  const why = String(body?.errors?.[0]?.message ?? body?.message ?? text ?? "").trim() || "no answer";
-  throw new Error(`gh: ${res.ok ? "" : `HTTP ${res.status}: `}${why.slice(0, 300)}`);
-}
-
-// The tick's probe: the token asked for once (again only after it failed), each query retried once.
-export function githubProbe(tokenOf, { delayMs = GH_RETRY_DELAY_MS, fetchImpl = fetch, timeoutMs = GH_TIMEOUT_MS } = {}) {
-  let token = null;
-  const once = () => (token ??= tokenOf().catch((err) => {
-    token = null;
-    throw err;
-  }));
-  return (query) => withRetry(async () => ghGraphql(query, { token: await once(), fetchImpl, timeoutMs }), { delayMs });
-}
-
-// `call` retried once (after `delayMs`) when it fails in a way worth retrying.
-export async function withRetry(call, { delayMs = GH_RETRY_DELAY_MS } = {}) {
-  try {
-    return await call();
-  } catch (err) {
-    if (!retryable(err)) throw err;
-    await new Promise((r) => setTimeout(r, delayMs));
-    return call();
-  }
-}
-
-const hashOf = (text) => createHash("sha256").update(text).digest("base64url").slice(0, 22);
-const plural = (n) => `${n} PR${n === 1 ? "" : "s"}`;
-
-// One tick. `probe(query)` -> the GraphQL answer (rejects on failure); by default GitHub's, as the snapshot's human
-// (`token(human)`: githubToken).
-// Returns { ok, sizes }: ok is false when the PRs couldn't be fetched at all; sizes is each PR's title and
-// diff size ("owner/repo#12" -> { title, add, del, files }) as GitHub said this tick, for the plan's cards.
-export async function runDash(hub, { probe, token = githubToken, now = Date.now(), log = console } = {}) {
-  let ok = true;
-  let prFacts = {};
-  const sizes = {};
-  await runOnce(hub, "dash", async (snap, saved, at) => {
-    const { refs, reviewed, keep: waited } = dashWatchList(snap, saved);
-    const tracked = new Set(Object.keys(dashPrs(saved)));
-    const ask = probe ?? githubProbe(() => token(snap?.humans?.[0]?.name));
-    const facts = {};
-    let prs = null;
-    let skip = new Set();
-    let note = null;
-    try {
-      const chunks = [];
-      for (let i = 0; i < Math.max(refs.length, 1); i += REFS_PER_QUERY) chunks.push(refs.slice(i, i + REFS_PER_QUERY));
-      const answers = await Promise.all(chunks.map((c) => ask(dashQuery(c))));
-      const found = answers.flatMap(prsFromSearch);
-      const searched = new Set(answers.flatMap((a) => prsFromSearch({ data: { search: a?.data?.search } })).map((p) => p.key));
-      prs = found.filter((p) => !reviewed.has(p.key) || searched.has(p.key) || tracked.has(p.key) || waited.has(p.key));
-      for (const p of found) if (p.size) sizes[p.key] = { title: p.title, ...p.size };
-      for (const p of found) if (reviewed.has(p.key)) facts[p.key] = { head: p.head ?? null, ci: p.ci };
-      skip = new Set(answers.flatMap((a, i) => [...failedRefs(a, chunks[i])]));
-      if (skip.size) note = `${plural(skip.size)} skipped: GitHub couldn't answer for ${[...skip].slice(0, 3).join(", ")}${skip.size > 3 ? ", …" : ""}`;
-    } catch (err) {
-      ok = false;
-      const known = Object.keys(dashPrs(saved)).length;
-      note = `${known ? `${plural(known)} skipped` : "PRs skipped"}: ${ghReason(err)}`;
-      log?.warn?.(`dash: PRs skipped this tick: ${err?.message ?? err}`);
-    }
-    prFacts = facts;
-    const { lines, state, changed } = dashScan(snap, saved, prs, at, hashOf, skip);
-    // The note rides on a post that's going out anyway: a skip alone doesn't
-    // wake main (a lasting outage shows as the Dash going stale).
-    const body = lines.length ? (lines.length === 1 ? lines[0] : `${lines.length} changes\n${lines.map((l) => `- ${l}`).join("\n")}`) : null;
-    const text = body ? `@${coordinatorOf(snap?.agents)} dash: ${body}${note ? `\n(${note})` : ""}` : null;
-    return { posts: text ? [text] : [], state: changed ? { ...state, ...(saved?.pass ? { pass: saved.pass } : {}) } : saved, changed };
-  }, { now });
-  if (ok) await hub.dashChecked(prFacts);
-  return { ok, sizes };
-}

package/schedules/dash.d.ts

@@ -1,11 +0,0 @@
-export declare function dashSchedule({ decisions }: {
-    decisions: () => string;
-}): {
-    cron: string;
-    run(): Promise<void>;
-};
-declare const _default: {
-    cron: string;
-    run(): Promise<void>;
-};
-export default _default;

package/schedules/dash.js

@@ -1,30 +0,0 @@
-// main's dash schedule: every 8 minutes, and off-cron as soon as a bot's turn
-// ends (the hub fires it, so a question shows on the sidebar within seconds),
-// the one pass behind the Dash: the human's PRs, a model call per thread
-// whose facts changed (openai/gpt-6-luna-decisions through eve`s `decide`,
-// eve's gateway credentials) and a model call per track with news
-// (anthropic/claude-sonnet-5.5 through the AI SDK). The pass: runPass in
-// ./dash-pass.mjs. `decisions` gives the human's standing decisions for the plan: read from the
-// workspace's memory/ on the hub's machine (the default export), embedded at build time on a
-// hosted main, whose function has no workspace files (prepare.mjs writes that stub).
-import { defineSchedule } from "eve/schedules";
-import { decide } from "eve/ai";
-import { generateText, Output } from "ai";
-import { createHub } from "./hub.mjs";
-import { modelClassify } from "./dash-classify.mjs";
-import { dashPass } from "./dash-pass.mjs";
-import { PLAN_MODEL, PLAN_TIMEOUT_MS } from "./dash-plan.mjs";
-import { PlanOut } from "./dash-plan-schema.mjs";
-import { standingDecisions } from "./dash-decisions.mjs";
-import { modelSummarize } from "./track-summaries.mjs";
-export function dashSchedule({ decisions }) {
-    return defineSchedule({
-        cron: "*/8 * * * *",
-        async run() {
-            const hub = createHub();
-            const plan = async (prompt) => (await generateText({ model: PLAN_MODEL, prompt, output: Output.object({ schema: PlanOut }), maxRetries: 1, abortSignal: AbortSignal.timeout(PLAN_TIMEOUT_MS) })).output;
-            await hub.track("dash", () => dashPass(hub, { classify: modelClassify({ evaluate: decide }), summarize: modelSummarize({ generateText }), plan, decisions: decisions() }));
-        },
-    });
-}
-export default dashSchedule({ decisions: () => standingDecisions() });

package/schedules/hub.d.mts

@@ -1,28 +0,0 @@
-// Types for hub.mjs: main's schedules' client of the hub's HTTP API. Bodies
-// the schedules only pass through are `unknown`.
-import type { DashEntries } from '../../../hosted-hub/src/domain/dash.mjs';
-
-type Notice = { schedule: string; text: string; clientId?: string };
-type Post = { text: string; clientId?: string };
-type Ok = { ok: true };
-export type Hub = {
-  snapshot(): Promise<Record<string, unknown>>;
-  roster(): Promise<unknown>;
-  load(id: string): Promise<unknown>;
-  loadVersioned(id: string): Promise<{ state: unknown; savedAt: string | null; paused: boolean }>;
-  save(id: string, state: unknown): Promise<unknown>;
-  commit(id: string, withState: { state?: unknown }, posts: Post[]): Promise<unknown>;
-  post(id: string, text: string, key?: string): Promise<unknown>;
-  track<T>(id: string, fn: () => Promise<T>): Promise<T | undefined>;
-  dashChecked(prFacts?: Record<string, { head: string | null; ci: string }>): Promise<Ok & { checkedAt: string }>;
-  setSummary(path: string, text: string): Promise<unknown>;
-  dashClassified(): Promise<Ok & { classifiedAt: string }>;
-  fileThread(threadId: string, path: string): Promise<unknown>;
-  dashPlan(basis: string, plan: object): Promise<Ok & { id: string }>;
-  dashEntries(entries: object[], remove?: string[], notice?: Notice | null): Promise<Ok & { entries: DashEntries }>;
-};
-export function createHub(options?: { base?: string; agent?: string; fetchImpl?: typeof fetch; log?: Pick<Console, "log"> }): Hub;
-export const POST_MAX_BYTES: number;
-export const POSTS_PER_COMMIT: number;
-export function toPosts(notices: string[]): string[];
-export function runOnce(hub: Hub, id: string, decide: (snap: Record<string, unknown> | null, saved: unknown, now: number) => unknown, options?: { now?: number; snapshot?: boolean }): Promise<{ posts: Post[]; state: unknown }>;