eve-hub 0.16.9 → 0.16.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.16.9",
+  "version": "0.16.11",
   "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-plan-schema.mjs

@@ -4,10 +4,13 @@
 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() });
+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), rows: z.array(Row).min(1) })).max(40),
+  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) })),
 });

package/schedules/dash-plan.mjs

@@ -9,6 +9,10 @@
 // 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";
@@ -56,13 +60,11 @@ export function waitingThreads(snap) {
 }
 
 /** 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();
+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 --------------------------------------------------------------------------------
 
@@ -99,6 +101,34 @@ export function planCards(snap, { now = Date.now(), sizes = {} } = {}) {
   });
 }
 
+/**
+ * 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);
@@ -120,6 +150,7 @@ export function aboutHuman(snap, { now = Date.now(), decisions = "" } = {}) {
     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,
@@ -164,22 +195,26 @@ export function replanReason(snap, now = Date.now()) {
 
 const planned = (p) => [...p.chunks.flatMap((c) => c.rows), ...(p.later?.rows ?? [])];
 
-export function planPrompt(cards, about, { human = "me", prev = null, now = Date.now() } = {}) {
+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 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".`,
+    `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 has "title" and "why": one plain sentence saying why it sits at that position.`,
+    `- 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) 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.`,
+    `- "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.`,
@@ -189,9 +224,10 @@ export function planPrompt(cards, about, { human = "me", prev = null, now = Date
 
 /**
  * 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`).
+ * 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) {
+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));
@@ -203,10 +239,17 @@ export function checkPlan(raw, cards) {
   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`);
-  return { ...raw, later: raw.later?.rows.length ? raw.later : null, moved: raw.moved.filter((m) => ids.has(m.ask)) };
+  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)) };
 }
 
 /**
@@ -215,27 +258,60 @@ export function checkPlan(raw, cards) {
  */
 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 checkPlan(first, cards);
+    return check(first);
   } 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);
+    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" };
-  const s = snap ?? (await hub.snapshot());
+  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" };
   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 });
+    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}`);