eve-hub 0.10.0 → 0.10.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.10.2
+
+### Patch Changes
+
+- Dash plan: main's pass makes one model call that reads every thread waiting on the human (an @-mention or a pending request) and orders the real asks into chunks, the way a person triaging by hand would; the hub stores each plan as a new row.
+
+## 0.10.1
+
+### Patch Changes
+
+- The kit's hub client can store a Dash plan (`dashPlan`); the hub checks it and keeps it as the newest.
+
 ## 0.10.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",

package/schedules/dash-decisions.mjs

@@ -0,0 +1,21 @@
+// The human's standing decisions (the workspace's memory/*.md), as one text for the plan's facts
+// about them. Read where the schedule runs; a workspace that isn't there is logged and the plan
+// goes without, so it never fails the pass.
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { activeEntries, entryText, MEMORY_DIR, readMemory } from "../memory.mjs";
+import { findWorkspaceRoot } from "../workspace.mjs";
+
+export function standingDecisions({ root = null, log = console } = {}) {
+  try {
+    const dir = root ?? findWorkspaceRoot();
+    if (!dir) throw new Error("no workspace root");
+    if (!existsSync(join(dir, MEMORY_DIR))) throw new Error(`no ${MEMORY_DIR}/ in ${dir}`);
+    const { entries, errors } = readMemory(dir);
+    for (const e of errors) log?.warn?.(`dash plan: memory: ${e}`);
+    return activeEntries(entries).map((e) => entryText(e)).join("\n");
+  } catch (err) {
+    log?.warn?.(`dash plan: no standing decisions: ${err?.message ?? err}`);
+    return "";
+  }
+}

package/schedules/dash-pass.mjs

@@ -16,10 +16,14 @@
 // whose full check has run classifies threads and nothing else; a cron fire
 // is always the first run of its slot. If the stamp can't be written, the
 // full check is skipped. A pass over an unchanged hub makes no model call.
+// The plan (runPlan, ./dash-plan.mjs) comes last, once per slot: one model call that reads every
+// waiting thread when the plan is missing or what it was made from changed (a new ask, a pin, a
+// defer, a new day); none otherwise. It runs last because it is the slow call.
 // The parts run one after another (they share the schedule's state); a
 // failure in one never stops the others.
 import { classifyPass, runClassify } from "./dash-classify.mjs";
 import { runDash } from "./dash-run.mjs";
+import { runPlan } from "./dash-plan.mjs";
 import { runTracks } from "./track-summaries.mjs";
 
 const SLOT_MIN = 8;
@@ -29,8 +33,8 @@ const slotOf = (ms) => {
   return (min - ((min % 60) % SLOT_MIN)) * 60_000;
 };
 
-/** @param {any} hub @param {{ classify?: (target: any, snap: any) => Promise<any>, summarize?: (prompt: string) => Promise<string>, probe?: any, log?: any, now?: number }} [opts] */
-export async function runPass(hub, { classify, summarize, probe, log = console, now = Date.now() } = {}) {
+/** @param {any} hub @param {{ classify?: (target: any, snap: any) => Promise<any>, summarize?: (prompt: string) => Promise<string>, plan?: (prompt: string) => Promise<string>, decisions?: string, probe?: any, log?: any, now?: number }} [opts] */
+export async function runPass(hub, { classify, summarize, plan, decisions, probe, log = console, now = Date.now() } = {}) {
   const part = (name, run) => run().catch((err) => log?.warn?.(`dash pass: ${name} failed: ${err?.message ?? err}`));
   const { state } = await hub.loadVersioned("dash");
   const full = (state?.pass?.fullAt ?? 0) < slotOf(now);
@@ -42,8 +46,10 @@ export async function runPass(hub, { classify, summarize, probe, log = console,
     log?.warn?.(`dash pass: full check skipped, its stamp wasn't saved: ${err?.message ?? err}`);
     return;
   }
-  await part("PRs", () => runDash(hub, { ...(probe ? { probe } : {}), log }));
+  let sizes = {};
+  await part("PRs", async () => { sizes = (await runDash(hub, { ...(probe ? { probe } : {}), log })).sizes ?? {}; });
   await part("tracks", () => runTracks(hub, { summarize, log }));
+  await part("plan", () => runPlan(hub, { generate: plan, decisions, sizes, now, log }));
 }
 
 // One pass at a time in this process (classifyPass), a dispatch that comes

package/schedules/dash-plan-schema.mjs

@@ -0,0 +1,14 @@
+// The shape of a Dash plan as the planner must return it (generateText `output`). The hub's check is
+// the wire's DashPlanIn (packages/wire/src/routes.ts); test/dash-plan.test.mjs fails if the two differ.
+// `notAsks` is the planner's own: threads it judged not to wait on the human, never sent to the hub.
+import * as z from "zod";
+
+export const VERBS = ["Land", "Answer", "Pick", "Look", "Review", "Read", "Write"];
+const Row = z.object({ id: z.string().min(1), title: z.string().min(1).max(120), verb: z.enum(VERBS), minutes: z.int().min(0).max(600), consent: z.boolean() });
+export const PlanBody = z.object({
+  line: z.string().min(1).max(240),
+  chunks: z.array(z.object({ title: z.string().min(1).max(120), why: z.string().min(1).max(240), rows: z.array(Row).min(1) })).max(40),
+  later: z.object({ line: z.string().min(1).max(240), rows: z.array(Row) }).nullable(),
+  moved: z.array(z.object({ ask: z.string().min(1), reason: z.string().min(1).max(240) })),
+});
+export const PlanOut = PlanBody.extend({ notAsks: z.array(z.object({ id: z.string().min(1), why: z.string() })) });

package/schedules/dash-plan.mjs

@@ -0,0 +1,248 @@
+// The Dash plan of main's dash pass (dash.ts): one model call reads every thread that waits on the
+// human, in full, and orders the real asks the way a person triaging by hand would. Code only
+// gathers facts (what the bots said, how big the PRs are, what is stacked on what, what the human
+// answered last, standing decisions); the model judges what is an ask, the chunks, the order and the
+// voice. The hub stores the result (POST /api/dash/plan) as a new row; it is never overwritten.
+// Design: docs/plans/dash-triage-brief.md.
+//
+// A plan is made when it is missing, a new ask appeared, the human pinned or deferred something,
+// or the local day changed. Answering an ask doesn't make one: the answered row drops out in the
+// app. The previous plan goes into the prompt as a fact, so the list stands still between visits.
+//
+// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the tests and replay (plain
+// node) import the same module.
+import { said, clip } from "./thread-brief.mjs";
+import { VERBS } from "./dash-plan-schema.mjs";
+
+export const PLAN_MODEL = "anthropic/claude-opus-5.5";
+export const PLAN_TIMEOUT_MS = 240_000;
+const MS_DAY = 86_400_000;
+const PRS_PER_CARD = 6;
+export const LINE_MAX = 90;
+
+const humanOf = (snap) => snap?.humans?.[0]?.name ?? "me";
+const isHuman = (m, human) => m.author === human || m.authorKind === "human";
+const at = (m) => Date.parse(m?.at ?? "") || 0;
+export const trackOf = (t) => t?.tags?.path ?? t?.trackId ?? t?.tags?.project ?? "unfiled";
+export const repoOf = (t) => {
+  const pr = Object.values(t?.work?.bots ?? {}).map((b) => b?.pr).find(Boolean);
+  const m = typeof pr === "string" ? pr.match(/^([\w.-]+\/[\w.-]+)#\d+$/) : null;
+  return m ? m[1] : null;
+};
+const words = (s) => (String(s).match(/\S+/g) ?? []).length;
+const ago = (ms) => {
+  const m = Math.max(0, ms) / 60_000;
+  return m < 2 ? "now" : m < 60 ? `${Math.round(m)}m` : m < 2880 ? `${Math.round(m / 60)}h` : `${Math.round(m / 1440)}d`;
+};
+
+/** A verdict post's open questions, each with its options and who picked which: what the human still has to answer. */
+const decisionsOf = (m) => (m.decisions ?? []).map((d) => `\n  decision: ${d.question} Options: ${(d.options ?? []).map((o) => o.label + (o.pickedBy ? ` (picked by ${o.pickedBy})` : "")).join(" | ")}`).join("");
+
+const requestsOf = (snap, id) => Object.values(snap?.requests ?? {}).filter((r) => r.threadId === id && (r.status ?? "pending") === "pending");
+
+/** The first message of the ask a thread has now: a bot @-mentioned the human after their last message. */
+const askingMessage = (ms, human) => {
+  const after = ms.slice(ms.findLastIndex((m) => isHuman(m, human)) + 1);
+  return after.find((m) => !isHuman(m, human) && (m.mentions ?? []).includes(human)) ?? null;
+};
+
+/** The threads that wait on the human: the plan's candidates. A pending request (a tool approval, a question) is an ask. */
+export function waitingThreads(snap) {
+  const human = humanOf(snap);
+  return Object.values(snap?.threads ?? {}).filter((t) => {
+    if (t.archived || t.schedule || (t.kind && t.kind !== "thread") || snap?.dash?.entries?.[t.id]?.deferred) return false;
+    return !!askingMessage((t.messages ?? []).filter(said), human) || requestsOf(snap, t.id).length > 0;
+  });
+}
+
+/** One key per ask: the asking message, or the request. A new ask in a thread that was planned is a new key. */
+const askKeys = (snap) => {
+  const human = humanOf(snap);
+  return waitingThreads(snap).flatMap((t) => {
+    const m = askingMessage((t.messages ?? []).filter(said), human);
+    return [...(m ? [`${t.id}@${m.id}`] : []), ...requestsOf(snap, t.id).map((r) => `${t.id}@${r.id}`)];
+  }).sort();
+};
+
+// --- facts --------------------------------------------------------------------------------
+
+const PR_URL = /github\.com\/([\w.-]+\/[\w.-]+)\/pull\/(\d+)/g;
+
+/**
+ * One card per waiting thread, facts only. `sizes` is each PR's title and diff size as GitHub last said (dash-run.mjs).
+ * @param {any} snap @param {{ now?: number, sizes?: Record<string, { title: string, add: number, del: number, files: number }> }} [opts]
+ */
+export function planCards(snap, { now = Date.now(), sizes = {} } = {}) {
+  const human = humanOf(snap);
+  const threads = waitingThreads(snap);
+  const all = Object.values(snap?.threads ?? {});
+  return threads.map((t) => {
+    const ms = (t.messages ?? []).filter(said);
+    const after = ms.slice(ms.findLastIndex((m) => isHuman(m, human)) + 1).filter((m) => !isHuman(m, human));
+    const text = [...after.map((m) => `[${m.author}] ${m.text}${decisionsOf(m)}`), ...requestsOf(snap, t.id).map((r) => `[${r.agent}, waiting on a request] ${r.prompt}`)].join("\n\n");
+    const refs = new Map();
+    for (const m of ms.slice(-10)) for (const x of String(m.text).matchAll(PR_URL)) refs.set(`${x[1]}#${x[2]}`, [x[1], x[2]]);
+    const prs = [...refs.values()].slice(0, PRS_PER_CARD).map(([r, n]) => ({ number: Number(n), ...sizes[`${r}#${n}`] })).filter((p) => p.files != null);
+    const nums = prs.map((p) => p.number);
+    const mentioned = all.filter((o) => o.id !== t.id && (o.messages ?? []).some((m) => now - at(m) < 48 * 3_600_000 && at(m) < now && (String(m.text).includes(t.id) || nums.some((n) => new RegExp(`(?:pull/|#)${n}\\b`).test(String(m.text)))))).map((o) => o.id);
+    return {
+      id: t.id,
+      title: t.title ?? t.id,
+      context: `${trackOf(t)} | ${repoOf(t) ?? "no repo"}`,
+      askText: text.slice(-2500),
+      askWords: words(text),
+      prs,
+      waitingSince: after[0]?.at ?? null,
+      waitingAge: after[0] ? ago(now - at(after[0])) : "",
+      threadsMentioningThis: mentioned,
+    };
+  });
+}
+
+/** What the human is like right now, as facts; `decisions` is the text of their standing decisions. */
+export function aboutHuman(snap, { now = Date.now(), decisions = "" } = {}) {
+  const human = humanOf(snap);
+  const tz = snap?.dash?.about?.tz || "UTC";
+  const hour = new Intl.DateTimeFormat("en-US", { hour: "numeric", hourCycle: "h23", timeZone: tz });
+  const hist = Array(24).fill(0);
+  const mine = [];
+  for (const t of Object.values(snap?.threads ?? {})) for (const m of t.messages ?? []) {
+    if (!said(m) || !isHuman(m, human) || at(m) >= now) continue;
+    mine.push({ id: t.id, title: t.title ?? t.id, at: at(m) });
+    if (now - at(m) < 14 * MS_DAY) hist[Number(hour.format(at(m)))]++;
+  }
+  mine.sort((a, b) => a.at - b.at);
+  const last = mine.at(-1);
+  const same = mine.filter((x, i) => i && mine[i - 1].id === x.id).length;
+  const recent = new Map();
+  for (const x of [...mine].reverse()) if (!recent.has(x.id) && recent.size < 5) recent.set(x.id, { id: x.id, title: x.title, minutesAgo: Math.round((now - x.at) / 60_000) });
+  return {
+    justAnswered: last ? { id: last.id, title: last.title, minutesAgo: Math.round((now - last.at) / 60_000) } : null,
+    shareOfMessagesInTheSameThreadAsThePreviousOne: mine.length > 1 ? Number((same / (mine.length - 1)).toFixed(2)) : null,
+    localTime: new Intl.DateTimeFormat("en-US", { timeZone: tz, weekday: "long", hour: "numeric", minute: "2-digit" }).format(now),
+    messagesByLocalHourLast14Days: hist,
+    mostRecentThreads: [...recent.values()],
+    profile: snap?.dash?.about?.profile ? clip(String(snap.dash.about.profile), 3000) : null,
+    standingDecisions: clip(decisions, 40_000),
+  };
+}
+
+// --- re-plan ------------------------------------------------------------------------------
+
+const localDay = (now, tz) => {
+  try { return new Intl.DateTimeFormat("en-CA", { timeZone: tz || "UTC" }).format(now); } catch { return new Date(now).toISOString().slice(0, 10); }
+};
+
+/** What a plan was made from: the asks (the asking message or request of each waiting thread), pins, defers and the local day (the next pass compares it). */
+export function planBasis(snap, now = Date.now()) {
+  const human = humanOf(snap);
+  const deferred = Object.entries(snap?.dash?.entries ?? {}).filter(([, e]) => e.deferred).map(([id]) => id).sort();
+  return JSON.stringify({
+    asks: askKeys(snap),
+    pins: [...(snap?.pins?.[human] ?? [])].sort(),
+    deferred,
+    day: localDay(now, snap?.dash?.about?.tz),
+  });
+}
+
+/** Why a new plan is needed, or null. An ask that was answered is not a reason. */
+export function replanReason(snap, now = Date.now()) {
+  const prev = snap?.dash?.plan;
+  if (!prev) return "no plan yet";
+  let was;
+  try { was = JSON.parse(prev.basis); } catch { return "the last plan's basis is unreadable"; }
+  const next = JSON.parse(planBasis(snap, now));
+  if (was.day !== next.day) return "a new day";
+  const fresh = next.asks.find((id) => !(was.asks ?? []).includes(id));
+  if (fresh) return `a new ask: ${fresh}`;
+  if (JSON.stringify(was.pins) !== JSON.stringify(next.pins)) return "a pin changed";
+  if (JSON.stringify(was.deferred) !== JSON.stringify(next.deferred)) return "a defer changed";
+  return null;
+}
+
+// --- the call -----------------------------------------------------------------------------
+
+const planned = (p) => [...p.chunks.flatMap((c) => c.rows), ...(p.later?.rows ?? [])];
+
+export function planPrompt(cards, about, { human = "me", prev = null, now = Date.now() } = {}) {
+  const open = new Set(cards.map((c) => c.id));
+  const was = prev ? [...prev.chunks.flatMap((c) => c.rows.map((r) => ({ id: r.id, chunk: c.title }))), ...(prev.later?.rows ?? []).map((r) => ({ id: r.id, chunk: "later" }))].filter((r) => open.has(r.id)) : null;
+  return [
+    `You are main, ${human}'s chief of staff, triaging ${human}'s open threads by hand, exactly as ${human} would if they read every one in full. The cards below are threads where a bot said something after ${human}'s last message.`,
+    `For each card decide: is something actually waiting on ${human} (a question, a decision, an approval, a look, a sign-off only they can give), or not (a status report, a bot-to-bot handoff, already settled, or waiting on someone else)? Judge from the text of the ask, not from tags.`,
+    `Then order every real ask into chunks the way a careful person would work through them: what matters most and what is blocking others first; keep the same track and repo together so ${human} switches context as little as possible; weigh how taxing each one is (how much to read, diff size, how many decisions). Each card's \`context\` is its track and repo: neighbours with different contexts are a context switch. The rule: never come back to a track. All asks of one track sit next to each other in the order (chunks first, then later), in one chunk or neighbouring ones; within a track, put quick yeses first and deep reads last. The track of the thread they answered last (justAnswered) goes first, and that thread, if something waits there, is its first row: the share of their messages that stay in the previous message's thread is in the facts. A track whose asks can wait goes to "later" as a whole, not a piece of it. The thread ${human} answered last (justAnswered) is the context they already have loaded. Quick yeses that unblock bots go early; deep reads get their own chunk. Put asks that can genuinely wait into "later".`,
+    was ? [`The previous plan, in order (move a row only when a fact changed, and say why in "moved"):`, ...was.map((r) => `- ${r.id} (${r.chunk})`)].join("\n") : "There is no previous plan: \"moved\" is empty.",
+    `Facts about ${human}, including their standing decisions (what they have already settled and what they care about); now is ${new Date(now).toISOString()}:\n${JSON.stringify(about)}`,
+    `Rules for the output:`,
+    `- Row titles are plain words a person would say ("Land the hub-check segfault fix"), never leading with PR numbers or jargon, at most 60 characters.`,
+    `- Each chunk has "title" and "why": one plain sentence saying why it sits at that position.`,
+    `- "minutes" is a whole number: an honest estimate of the effort for that row.`,
+    `- "verb" is one of ${VERBS.join(", ")}.`,
+    `- "consent" is true only when the ask is a pure yes/no approval with nothing to read (already reviewed, green).`,
+    `- "line" (top level) and "later.line": one short line each in main's voice, dry and cheeky on routine work, never on anything risky. You may tease the oldest waiting ask with its real age. Each is one short sentence of at most ${LINE_MAX} characters, with no semicolon and no counts. Titles and "why" are never jokes.`,
+    `- "moved": each row whose place changed since the previous plan, with a one-sentence reason (empty when there is no previous plan).`,
+    `- Every card id appears exactly once across notAsks, chunks and later. Use only ids from the cards. No empty or placeholder entries.`,
+    `"later" is null when nothing can wait.`,
+    `Cards:\n${JSON.stringify(cards)}`,
+  ].join("\n\n");
+}
+
+/**
+ * The rules a plan must meet beyond its shape (the schema checks the shape): every card once, only real ids, a
+ * track's asks together, voice lines short. Throws an Error naming what is wrong; returns the plan (with the planner's `notAsks`).
+ */
+export function checkPlan(raw, cards) {
+  const long = [raw.line, raw.later?.line].find((l) => typeof l === "string" && l.length > LINE_MAX);
+  if (long) throw new Error(`a voice line is ${long.length} characters; keep each to one sentence of at most ${LINE_MAX}`);
+  const ids = new Set(cards.map((c) => c.id));
+  const seen = [...raw.notAsks.map((x) => x.id), ...planned(raw).map((r) => r.id)];
+  const unknown = seen.filter((id) => !ids.has(id));
+  if (unknown.length) throw new Error(`the plan names threads that aren't cards: ${unknown.slice(0, 5).join(", ")}`);
+  const twice = seen.filter((id, i) => seen.indexOf(id) !== i);
+  if (twice.length) throw new Error(`the plan places ${twice.slice(0, 5).join(", ")} twice`);
+  const missing = [...ids].filter((id) => !seen.includes(id));
+  if (missing.length) throw new Error(`the plan leaves out ${missing.slice(0, 5).join(", ")}`);
+  const trackOfCard = new Map(cards.map((c) => [c.id, String(c.context).split(" | ")[0]]));
+  const visits = planned(raw).map((r) => trackOfCard.get(r.id)).filter((t, i, a) => t !== a[i - 1]);
+  const back = visits.find((t, i) => visits.indexOf(t) !== i);
+  if (back) throw new Error(`the plan comes back to track ${back} after another track's asks; put all of a track's asks together`);
+  return { ...raw, later: raw.later?.rows.length ? raw.later : null, moved: raw.moved.filter((m) => ids.has(m.ask)) };
+}
+
+/**
+ * The model's plan for these cards, with one repair round when its answer breaks a rule.
+ * `generate(prompt)` is the model's answer as an object of the plan's schema (dash-plan-schema.mjs PlanOut).
+ */
+export async function makePlan(generate, cards, about, options) {
+  const prompt = planPrompt(cards, about, options);
+  const first = await generate(prompt);
+  try {
+    return checkPlan(first, cards);
+  } catch (err) {
+    return checkPlan(await generate(`${prompt}\n\nYour previous answer:\n${JSON.stringify(first)}\n\nIt breaks a rule: ${err.message}. Return the corrected full plan.`), cards);
+  }
+}
+
+/**
+ * One plan step. Returns { planned: id|null, reason }.
+ * @param {any} hub @param {{ generate?: (prompt: string) => Promise<any>, decisions?: string, sizes?: any, now?: number, log?: any, snap?: any }} [opts]
+ */
+export async function runPlan(hub, { generate, decisions = "", sizes = {}, now = Date.now(), log = console, snap = null } = {}) {
+  if (!generate) return { planned: null, reason: "no model" };
+  const s = snap ?? (await hub.snapshot());
+  const reason = replanReason(s, now);
+  if (!reason) return { planned: null, reason: "plan is current" };
+  if (!waitingThreads(s).length) return { planned: null, reason: "nothing waits on the human" };
+  let plan;
+  try {
+    const { notAsks, ...body } = await makePlan(generate, planCards(s, { now, sizes }), aboutHuman(s, { now, decisions }), { human: humanOf(s), prev: s?.dash?.plan ?? null, now });
+    plan = body;
+  } catch (err) {
+    log?.warn?.(`dash plan: skipped, ${err?.message ?? err}`);
+    return { planned: null, reason: String(err?.message ?? err) };
+  }
+  if (!plan.chunks.length && !plan.later) return { planned: null, reason: "no asks" };
+  const { id } = await hub.dashPlan(planBasis(s, now), plan);
+  log?.log?.(`dash plan: ${id} (${reason}): ${plan.chunks.length} chunks, ${planned(plan).length} rows`);
+  return { planned: id, reason };
+}

package/schedules/dash-rules.mjs

@@ -285,6 +285,7 @@ const prOf = (n) => ({
   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(),
@@ -325,7 +326,7 @@ export function prsFromSearch(data) {
 }
 
 // The probe's query: the human's open PRs, plus `refs` ("owner/repo#12") by name.
-const PR_FIELDS = "number title url headRefOid isDraft state merged mergeable reviewDecision repository { nameWithOwner } commits(last: 1) { nodes { commit { statusCheckRollup { state } } } }";
+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.

package/schedules/dash-run.mjs

@@ -67,10 +67,12 @@ const hashOf = (text) => createHash("sha256").update(text).digest("base64url").s
 const plural = (n) => `${n} PR${n === 1 ? "" : "s"}`;
 
 // One tick. `probe(query)` -> the GraphQL answer (rejects on failure).
-// Returns { ok }: false when the PRs couldn't be fetched at all.
+// 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 = (q) => withRetry(() => ghGraphql(q)), 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)));
@@ -85,6 +87,7 @@ export async function runDash(hub, { probe = (q) => withRetry(() => ghGraphql(q)
       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 ? ", …" : ""}`;
@@ -103,5 +106,5 @@ export async function runDash(hub, { probe = (q) => withRetry(() => ghGraphql(q)
     return { posts: text ? [text] : [], state: changed ? { ...state, ...(saved?.pass ? { pass: saved.pass } : {}) } : saved, changed };
   }, { now });
   if (ok) await hub.dashChecked(prFacts);
-  return { ok };
+  return { ok, sizes };
 }

package/schedules/dash.js

@@ -7,10 +7,13 @@
 // ./dash-pass.mjs.
 import { defineSchedule } from "eve/schedules";
 import * as eveAi from "eve/ai";
-import { generateText } from "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";
 // eve 0.80 renamed `evaluate` to `decide`. The Mac bots run 0.81; the hosted bots' eve build is a
 // 0.69-based branch with `evaluate` only, and a named import of the missing one fails that build.
@@ -19,6 +22,7 @@ export default defineSchedule({
     cron: "*/8 * * * *",
     async run() {
         const hub = createHub();
-        await hub.track("dash", () => dashPass(hub, { classify: modelClassify({ evaluate }), summarize: modelSummarize({ generateText }) }));
+        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 }), summarize: modelSummarize({ generateText }), plan, decisions: standingDecisions() }));
     },
 });

package/schedules/hub.d.mts

@@ -18,6 +18,7 @@ export type Hub = {
   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 }): Hub;

package/schedules/hub.mjs

@@ -72,6 +72,8 @@ export function createHub({ base = registryBase(), agent = "main", fetchImpl = f
     // File an unfiled thread into a track (the classifier's pick), as a bot:
     // the hub refuses a thread that's already filed and doesn't lock it.
     fileThread: (threadId, path) => must(`/api/threads/${encodeURIComponent(threadId)}/track`, { method: "POST", body: JSON.stringify({ by: agent, path }) }),
+    // The plan main's pass made (wire DashPlanIn, checked in hosted-hub/src/domain/dash.mjs normalizePlan); the hub keeps it as the newest.
+    dashPlan: (basis, plan) => must("/api/dash/plan", { method: "POST", body: JSON.stringify({ by: agent, basis, plan }) }),
     // `notice` ({ schedule, text, clientId? }): posted in that schedule's
     // thread in the same write as the entries, or neither is kept.
     dashEntries: (entries, remove = [], notice = null) => must("/api/dash/entries", { method: "POST", body: JSON.stringify({ by: agent, entries, remove, ...(notice ? { notice } : {}) }) }),