eve-hub 0.16.21 → 0.16.23

package/schedules/dash-plan-schema.mjs

@@ -1,17 +0,0 @@
-// 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(),
-  why: z.string().min(1).max(160).optional(), park: z.iso.date().nullable().optional(),
-});
-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), track: z.string().min(1).max(160).optional(), since: z.string().min(1).max(160).optional(), 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

@@ -1,332 +0,0 @@
-// 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.
-//
-// Parking: a row may carry `park`, a local day. The first plan step on or after it defers that
-// thread through the Dash entries, the way the human's own defer does, and stores the plan without
-// the row. The day changing already makes a plan step, so parking needs no timer of its own.
-//
-// 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;
-// The wire's PLAN_BASIS_MAX (SetDashPlan.basis); test/dash-plan.test.mjs keeps the two equal.
-export const PLAN_BASIS_MAX = 100_000;
-
-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 threadAskKeys = (snap, t, human = humanOf(snap)) => {
-  const m = askingMessage((t.messages ?? []).filter(said), human);
-  return [...(m ? [`${t.id}@${m.id}`] : []), ...requestsOf(snap, t.id).map((r) => `${t.id}@${r.id}`)];
-};
-const askKeys = (snap) => waitingThreads(snap).flatMap((t) => threadAskKeys(snap, t)).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,
-    };
-  });
-}
-
-/**
- * One fact per track that has a card: when the human last posted anywhere in it, and which of its threads
- * have moved since then, so a chunk's `since` can say what changed there.
- * @param {any} snap @param {{ id: string }[]} cards @param {{ now?: number }} [opts]
- */
-export function trackFacts(snap, cards, { now = Date.now() } = {}) {
-  const human = humanOf(snap);
-  const wanted = new Set(cards.map((c) => trackOf(snap?.threads?.[c.id])));
-  const by = new Map([...wanted].map((track) => [track, { lastHuman: 0, threads: [] }]));
-  for (const t of Object.values(snap?.threads ?? {})) {
-    const f = by.get(trackOf(t));
-    if (!f || t.archived || (t.kind && t.kind !== "thread")) continue;
-    const ms = (t.messages ?? []).filter((m) => said(m) && at(m) < now);
-    f.lastHuman = Math.max(f.lastHuman, ...ms.filter((m) => isHuman(m, human)).map(at));
-    f.threads.push({ t, ms });
-  }
-  return [...by].map(([track, f]) => {
-    const summary = snap?.tracks?.[track]?.summary?.text ?? snap?.pathSummaries?.[track]?.text;
-    const moved = f.threads.map(({ t, ms }) => ({ t, fresh: ms.filter((m) => at(m) > f.lastHuman) })).filter((x) => x.fresh.length);
-    return {
-      track,
-      summary: summary ? clip(String(summary), 1500) : null,
-      humanLastPostedHere: f.lastHuman ? ago(now - f.lastHuman) : "never",
-      movedSince: moved.map(({ t, fresh }) => ({ id: t.id, title: t.title ?? t.id, newMessages: fresh.length, latest: `[${fresh.at(-1).author}] ${clip(String(fresh.at(-1).text), 300)}` })),
-    };
-  });
-}
-
-/** 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),
-    today: localDay(now, tz),
-    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(), tracks = [] } = {}) {
-  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 the coordinator, ${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 the way a careful person would work through them, as a chief of staff briefing ${human}: one chunk per track, so ${human} switches context as little as possible. Each card's \`context\` is its track and repo. Put first what matters most and what is blocking others; weigh how taxing each one is (how much to read, diff size, how many decisions). The rule: never come back to a track. All asks of one track sit in its one chunk, or all in "later"; 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. Quick yeses that unblock bots go early.`,
-    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)}`,
-    `Facts about each track with an ask: its summary, when ${human} last posted anywhere in it, and the threads that moved since then:\n${JSON.stringify(tracks)}`,
-    `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 is one track (code fills in its "track" from the cards). "title" names the track's work in plain words. "why" is one plain sentence saying why it sits at that position.`,
-    `- Each chunk's "since": one plain sentence, at most 160 characters, saying what changed in that track since ${human} last posted in it (the track facts), e.g. "The reviewer passed the fix and CI went green."`,
-    `- Each row's "why": one plain sentence, at most 160 characters, saying what ${human} has to decide or do and which option the asking bot picked, e.g. "The reviewer passed it and the builder recommends landing now."`,
-    `- Each row's "park": for an ask that has waited 5 days or more (its waitingSince), a day after today (YYYY-MM-DD, today is ${about?.today ?? "in the facts"}) when it gets set aside if still unanswered, usually tomorrow; null for every other row.`,
-    `- "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) says plainly what changed overall since ${human} last looked, and "later.line" says plainly why those can wait. Each is one short sentence of at most ${LINE_MAX} characters, with no semicolon and no counts.`,
-    `- "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
- * one chunk per track, lines short, park days after today. Throws an Error naming what is wrong; returns the plan
- * (with the planner's `notAsks`), each chunk's `track` set from its cards.
- */
-export function checkPlan(raw, cards, { today = null } = {}) {
-  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 mixed = raw.chunks.find((c) => new Set(c.rows.map((r) => trackOfCard.get(r.id))).size > 1);
-  if (mixed) throw new Error(`chunk "${mixed.title}" mixes tracks ${[...new Set(mixed.rows.map((r) => trackOfCard.get(r.id)))].join(", ")}; make one chunk per track`);
-  const chunkTracks = raw.chunks.map((c) => trackOfCard.get(c.rows[0].id));
-  const split = chunkTracks.find((t, i) => chunkTracks.indexOf(t) !== i) ?? (raw.later?.rows ?? []).map((r) => trackOfCard.get(r.id)).find((t) => chunkTracks.includes(t));
-  if (split) throw new Error(`track ${split} is split across chunks or between a chunk and "later"; put all of a track's asks in one chunk or all in "later"`);
-  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`);
-  const early = today && planned(raw).find((r) => r.park && r.park <= today);
-  if (early) throw new Error(`${early.id} parks on ${early.park}, which isn't after today (${today}); park on a later day or set park to null`);
-  return { ...raw, chunks: raw.chunks.map((c) => ({ ...c, track: trackOfCard.get(c.rows[0].id) })), 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 check = (raw) => checkPlan(raw, cards, { today: about?.today ?? null });
-  const first = await generate(prompt);
-  try {
-    return check(first);
-  } catch (err) {
-    return check(await generate(`${prompt}\n\nYour previous answer:\n${JSON.stringify(first)}\n\nIt breaks a rule: ${err.message}. Return the corrected full plan.`));
-  }
-}
-
-/**
- * Defers each thread of the stored plan whose park day has come and that still waits on the asks that plan saw (a new
- * ask since then is the next plan's to judge), then stores that plan
- * without those rows (same basis, so the defer change still makes a fresh plan). Returns the ids it parked.
- */
-export async function parkDue(hub, snap, now = Date.now()) {
-  const prev = snap?.dash?.plan;
-  if (!prev) return [];
-  let was;
-  try { was = new Set(JSON.parse(prev.basis).asks ?? []); } catch { return []; }
-  const today = localDay(now, snap?.dash?.about?.tz);
-  const sameAsk = new Set(waitingThreads(snap).filter((t) => threadAskKeys(snap, t).every((k) => was.has(k))).map((t) => t.id));
-  const due = new Set(planned(prev).filter((r) => r.park && r.park <= today && sameAsk.has(r.id)).map((r) => r.id));
-  if (!due.size) return [];
-  await hub.dashEntries([...due].map((threadId) => ({ threadId, deferred: true })));
-  const keep = (rows) => rows.filter((r) => !due.has(r.id));
-  const laterRows = keep(prev.later?.rows ?? []);
-  await hub.dashPlan(prev.basis, {
-    line: prev.line,
-    chunks: prev.chunks.map((c) => ({ ...c, rows: keep(c.rows) })).filter((c) => c.rows.length),
-    later: laterRows.length ? { line: prev.later.line, rows: laterRows } : null,
-    moved: prev.moved.filter((m) => !due.has(m.ask)),
-  });
-  return [...due];
-}
-
-/**
- * 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" };
-  let s = snap ?? (await hub.snapshot());
-  const parked = await parkDue(hub, s, now);
-  if (parked.length) {
-    log?.log?.(`dash plan: parked ${parked.join(", ")}`);
-    s = 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" };
-  const basis = planBasis(s, now);
-  if (basis.length > PLAN_BASIS_MAX) {
-    const why = `${JSON.parse(basis).asks.length} asks exceed the plan basis limit`;
-    log?.warn?.(`dash plan: skipped, ${why}`);
-    return { planned: null, reason: why };
-  }
-  let plan;
-  try {
-    const cards = planCards(s, { now, sizes });
-    const { notAsks, ...body } = await makePlan(generate, cards, aboutHuman(s, { now, decisions }), { human: humanOf(s), prev: s?.dash?.plan ?? null, now, tracks: trackFacts(s, cards, { 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(basis, plan);
-  log?.log?.(`dash plan: ${id} (${reason}): ${plan.chunks.length} chunks, ${planned(plan).length} rows`);
-  return { planned: id, reason };
-}