eve-hub 0.16.21 → 0.16.22

package/schedules/hub.mjs

@@ -1,164 +0,0 @@
-// The coordinator's schedules talk to the registry over its HTTP API
-// (ROSTER_REGISTRY_URL): a handler's own output (`to()`) never reaches the
-// hub, so they read /api/state and post into their schedule's thread
-// (sch-<coordinator>-<id>) as "system", which wakes whoever the text @-mentions.
-//
-// Plain JS on purpose: the schedules (TypeScript, bundled by eve) and the
-// tests (plain node) import the same module.
-import { createHash } from "node:crypto";
-import { registryBase, registryFetch } from "../registry-fetch.mjs";
-import { coordinatorOf } from "../workspace.mjs";
-
-export function createHub({ base = registryBase(), agent, fetchImpl = fetch, log = console } = {}) {
-  const call = async (path, init = {}) => {
-    const res = await registryFetch(path, { ...init, headers: { "content-type": "application/json", ...(init.headers ?? {}) } }, { base, fetchImpl, deadlineMs: 10_000 });
-    const text = await res.text();
-    let body = null;
-    try {
-      body = text ? JSON.parse(text) : null;
-    } catch {}
-    return { status: res.status, ok: res.ok, body: body ?? text };
-  };
-  const must = async (path, init) => {
-    const r = await call(path, init);
-    if (!r.ok) throw new Error(`${init?.method ?? "GET"} ${path}: ${r.status} ${typeof r.body === "string" ? r.body : JSON.stringify(r.body)}`.slice(0, 400));
-    return r.body;
-  };
-  // The run the hub is following for this process's handler (`track`), so a commit says which run it belongs to.
-  let run = null;
-  // The schedules run as the coordinator; with no `agent` given, its name is read once from the hub's roster.
-  let named = agent ? Promise.resolve(agent) : null;
-  const who = () => (named ??= must("/api/state").then((s) => coordinatorOf(s?.agents)));
-  const threadOf = async (id) => `sch-${await who()}-${id.replaceAll("/", ".")}`;
-  const statePath = async (id) => `/api/schedules/${encodeURIComponent(await who())}/${id.split("/").map(encodeURIComponent).join("/")}/state`;
-  return {
-    snapshot: () => must("/api/state"),
-    roster: () => must("/api/roster"),
-    load: async (id) => (await must(await statePath(id)))?.state ?? null,
-    // The state and when it was saved (the version a run decided on).
-    loadVersioned: async (id) => {
-      const body = await must(await statePath(id));
-      return { state: body?.state ?? null, savedAt: body?.savedAt ?? null, paused: body?.paused === true };
-    },
-    save: async (id, state) => must(await statePath(id), { method: "PUT", body: JSON.stringify({ state }) }),
-    // Save `state` (if given: { state }) and post `posts` in one step.
-    commit: async (id, withState, posts) => must(await statePath(id), { method: "PUT", body: JSON.stringify({ ...withState, posts, ...(run?.id === id ? { run: run.run } : {}) }) }),
-    // One dispatch of the schedule `id`: the hub is told it started (it answers with the run's id and whether the
-    // schedule is paused, which skips `fn`) and how it ended, so the hub's run history is what the handler did. A hub
-    // that doesn't keep run history (the local one) answers 404 to the start, and `fn` runs untracked.
-    track: async (id, fn) => {
-      const runs = `${(await statePath(id)).slice(0, -"/state".length)}/runs`;
-      const started = await call(runs, { method: "POST", body: "{}" }).catch(() => null);
-      if (!started?.ok) return fn();
-      if (started.body.paused) {
-        log.log(`schedule ${await who()}/${id} skipped: paused`);
-        return;
-      }
-      run = { id, run: started.body.run };
-      const end = (error) => call(`${runs}/${encodeURIComponent(run.run)}/end`, { method: "POST", body: JSON.stringify(error ? { error: error.slice(0, 2000) } : {}) }).catch(() => null);
-      try {
-        const result = await fn();
-        await end();
-        return result;
-      } catch (error) {
-        await end(String(error?.message ?? error) || "the run failed");
-        throw error;
-      } finally {
-        run = null;
-      }
-    },
-    // A one-off post outside a run (runOnce commits through `commit`).
-    post: async (id, text, key) => must(`/api/threads/${encodeURIComponent(await threadOf(id))}/messages`, { method: "POST", body: JSON.stringify({ author: "system", text, ...(key ? { clientId: key } : {}) }) }),
-    // The Dash was scanned now (hosted-hub/src/domain/dash.mjs checkedAt), changed or not.
-    // `prFacts` ({ "owner/repo#12": { head, ci } }): what the scan's GitHub query said of the PRs reviews are about.
-    dashChecked: async (prFacts = {}) => must("/api/dash/checked", { method: "POST", body: JSON.stringify({ by: await who(), prFacts }) }),
-    // A track's summary (set_summary's endpoint, as main).
-    setSummary: async (path, text) => must("/api/summaries", { method: "POST", body: JSON.stringify({ by: await who(), scope: `path:${path}`, text }) }),
-    // A classifier pass finished (hosted-hub/src/domain/dash.mjs classifiedAt).
-    dashClassified: async () => must("/api/dash/classified", { method: "POST", body: JSON.stringify({ by: await who() }) }),
-    // Dash entries from the classifier (hosted-hub/src/domain/dash.mjs), merged per field.
-    // 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: async (threadId, path) => must(`/api/threads/${encodeURIComponent(threadId)}/track`, { method: "POST", body: JSON.stringify({ by: await who(), 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: async (basis, plan) => must("/api/dash/plan", { method: "POST", body: JSON.stringify({ by: await who(), basis, plan }) }),
-    // `notice` ({ schedule, text, clientId? }): posted in that schedule's
-    // thread in the same write as the entries, or neither is kept.
-    dashEntries: async (entries, remove = [], notice = null) => must("/api/dash/entries", { method: "POST", body: JSON.stringify({ by: await who(), entries, remove, ...(notice ? { notice } : {}) }) }),
-  };
-}
-
-// What the hub takes in one commit: up to POSTS_PER_COMMIT posts of up to
-// POST_MAX_BYTES each (server.mjs SCHEDULE_POSTS_MAX / SCHEDULE_POST_MAX).
-export const POST_MAX_BYTES = 16 * 1024;
-export const POSTS_PER_COMMIT = 20;
-
-const size = (text) => Buffer.byteLength(text);
-
-// Split a text into pieces of at most `max` bytes, at line ends where it
-// can, never inside a character.
-function split(text, max) {
-  const out = [];
-  let rest = text;
-  while (size(rest) > max) {
-    let cut = rest.slice(0, max); // at most max chars, maybe more bytes
-    while (size(cut) > max) cut = cut.slice(0, Math.max(1, Math.floor(cut.length * 0.9)));
-    if (/[\uD800-\uDBFF]$/.test(cut)) cut = cut.slice(0, -1); // not between a surrogate pair
-    const nl = cut.lastIndexOf("\n");
-    if (nl > cut.length / 2) cut = cut.slice(0, nl + 1);
-    out.push(cut);
-    rest = rest.slice(cut.length);
-  }
-  if (rest) out.push(rest);
-  return out;
-}
-
-// The run's notices as posts the hub takes, nothing dropped: a notice too
-// long for one post goes out in labelled parts; small ones are packed
-// together only when there are more than fit in one commit.
-export function toPosts(notices) {
-  const parts = [];
-  for (const text of notices) {
-    if (size(text) <= POST_MAX_BYTES) {
-      parts.push(text);
-      continue;
-    }
-    const pieces = split(text, POST_MAX_BYTES - 32);
-    pieces.forEach((piece, i) => parts.push(`${piece}\n(part ${i + 1}/${pieces.length})`));
-  }
-  if (parts.length <= POSTS_PER_COMMIT) return parts;
-  const packed = [];
-  for (const part of parts) {
-    const last = packed.length - 1;
-    if (last >= 0 && size(packed[last]) + 2 + size(part) <= POST_MAX_BYTES) packed[last] += `\n\n${part}`;
-    else packed.push(part);
-  }
-  return packed;
-}
-
-// One run of a schedule: load its state, decide, then commit. A commit is
-// one request the hub applies whole or not at all (PUT .../state
-// { state, posts }: the state and the posts land together in one durable
-// write, or neither does). More posts than one commit takes go first, in
-// commits of their own; the state rides on the last. Each post carries a
-// key made from the state it was decided on and its text, so if a run
-// fails part-way the next one, deciding again from that same state, sends
-// the same keys and the hub skips the posts it already has. Nothing is
-// lost and nothing posted twice. `decide(snap, saved, now)` ->
-// { posts: [text], state, changed }; `snapshot: false` skips reading
-// /api/state (decide gets null). A paused schedule (the state's `paused`)
-// decides and commits nothing.
-export async function runOnce(hub, id, decide, { now = Date.now(), snapshot = true } = {}) {
-  const [snap, loaded] = await Promise.all([snapshot ? hub.snapshot() : null, hub.loadVersioned(id)]);
-  const saved = loaded.state;
-  if (loaded.paused) return { posts: [], state: saved };
-  const { posts = [], state, changed } = await decide(snap, saved, now);
-  const texts = toPosts(posts.filter((t) => typeof t === "string" && t.trim()));
-  if (!changed && !texts.length) return { posts: [], state: saved };
-  const base = loaded.savedAt ?? "-";
-  const keyed = texts.map((text, i) => ({ text, clientId: `sch:${id}:${createHash("sha256").update(`${base}\0${i}\0${text}`).digest("base64url").slice(0, 32)}` }));
-  for (let at = 0; at + POSTS_PER_COMMIT < keyed.length; at += POSTS_PER_COMMIT) await hub.commit(id, {}, keyed.slice(at, at + POSTS_PER_COMMIT));
-  const tail = keyed.slice(Math.max(0, Math.ceil(keyed.length / POSTS_PER_COMMIT) - 1) * POSTS_PER_COMMIT);
-  await hub.commit(id, changed ? { state } : {}, tail);
-  return { posts: texts, state: changed ? state : saved };
-}

package/schedules/lane-facts.mjs

@@ -1,136 +0,0 @@
-// The facts the lane classifier reads about a thread, and the one-line reason
-// each answer is shown with. Code only gathers facts (counts, durations, the
-// exact call a turn is in); whether a thread is stuck, waiting on the human or
-// fine is the model's call (dash-classify.mjs), never a threshold here.
-//
-// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the tests
-// (plain node) import the same module.
-
-import { createHash } from "node:crypto";
-import { said, flat, clip } from "./thread-brief.mjs";
-
-const MIN = 60_000;
-const minutes = (from, now) => Math.max(0, Math.floor((now - from) / MIN));
-const at = (m) => Date.parse(m?.at ?? "") || 0;
-// eve 0.85 names it eve__task_wait; turns recorded before the move say task_wait.
-const isWait = (x) => x.name === "eve__task_wait" || x.name === "task_wait";
-const isHuman = (m, human) => m.author === human || m.authorKind === "human";
-
-// A busy thread's quiet time is read in steps of one pass (the schedule's
-// cron, 8 minutes): a thread quiet for another pass is a new fact to judge,
-// a bot that keeps working is not.
-export const PASS_MIN = 8;
-
-// The facts of one thread at `now`. `snap.live` holds each bot's live turn
-// (key `threadId:agent`); `t.suspect` is the hub's mark on a turn that went
-// silent when its bot's server restarted.
-export function laneFacts(t, snap, now = Date.now()) {
-  const human = snap?.humans?.[0]?.name ?? "me";
-  const ms = (t?.messages ?? []).filter(said);
-  const lastBot = [...ms].reverse().find((m) => !isHuman(m, human));
-  const lastHuman = [...ms].reverse().find((m) => isHuman(m, human));
-  const turns = Object.entries(t?.status ?? {})
-    .filter(([, s]) => s === "working")
-    .map(([agent]) => turnFacts(agent, snap?.live?.[`${t.id}:${agent}`], now));
-  const askAt = ms.findLastIndex((m) => !isHuman(m, human) && (m.mentions ?? []).includes(human));
-  return {
-    // The newest bot message that @-mentions the human, in messages back from the newest, and whether the human posted after it.
-    askBack: askAt < 0 ? null : ms.length - 1 - askAt,
-    humanPostedSinceAsk: askAt >= 0 && ms.slice(askAt + 1).some((m) => isHuman(m, human)),
-    // Minutes since the newest message, when it is a bot's and @-mentions a bot: a handoff.
-    handoffMin: ms.at(-1) && !isHuman(ms.at(-1), human) && (ms.at(-1).mentions ?? []).some((n) => n !== human) ? minutes(at(ms.at(-1)), now) : null,
-    botSilentMin: lastBot ? minutes(at(lastBot), now) : null,
-    sinceHuman: lastHuman ? ms.length - 1 - ms.lastIndexOf(lastHuman) : ms.length,
-    rounds: (t?.messages ?? []).filter((m) => m.statusFrom === "reviewing" && (m.status === "working" || m.status === "planning")).length,
-    lastBy: ms.at(-1) ? { author: ms.at(-1).author, human: isHuman(ms.at(-1), human), toHuman: (ms.at(-1).mentions ?? []).includes(human) } : null,
-    restarted: !!t?.suspect && turns.length > 0,
-    turns,
-  };
-}
-
-function turnFacts(agent, turn, now) {
-  const tools = turn?.tools ?? [];
-  const swarm = Object.values(turn?.swarm ?? {});
-  const running = [...tools].reverse().find((x) => x.status === "running" && !isWait(x) && x.name !== "researcher");
-  const wait = tools.find((x) => isWait(x) && x.status === "running");
-  const counts = new Map();
-  for (const x of tools) if (!isWait(x)) counts.set(`${x.name} ${flat(x.input)}`, (counts.get(`${x.name} ${flat(x.input)}`) ?? 0) + 1);
-  return {
-    agent,
-    turnMin: turn?.startedAt ? minutes(turn.startedAt, now) : null,
-    quietMin: turn?.startedAt ? minutes(Math.max(turn.startedAt, ...tools.map((x) => x.endedAt ?? x.startedAt ?? 0)), now) : null,
-    toolCalls: tools.filter((x) => !isWait(x)).length,
-    current: running ? { call: clip(`${running.name === "bash" ? "$" : running.name} ${flat(running.input)}`.trim(), 90), min: running.startedAt ? minutes(running.startedAt, now) : null } : null,
-    waitingMin: wait?.startedAt ? minutes(wait.startedAt, now) : wait ? 0 : null,
-    subagentsOut: swarm.filter((d) => d.status === "working").length,
-    subagents: swarm.length,
-    repeats: [...counts].filter(([, n]) => n > 1).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([call, n]) => ({ call: clip(call, 90), n })),
-  };
-}
-
-// The facts as lines for the model. Minutes since a bot posted (botSilentMin)
-// is shown only on a dropped row; handoffMin only when nobody is working and the
-// newest message hands work to a bot: how long a handoff sat is the whole
-// question there. Anywhere else a minutes figure only drifted, and a drifting number flipped close
-// calls (thr_0r2r read asks-you at 12 min and 2000, settled at 1127).
-export function factsText(f) {
-  const lines = [
-    `Messages since the human's last post: ${f.sinceHuman}`,
-    ...(f.lastBy ? [`Newest message: from ${f.lastBy.author}${f.lastBy.human ? " (the human)" : ""}${f.lastBy.toHuman ? ", @-mentions the human" : ""}`] : []),
-    ...(f.askBack == null ? [] : [`Newest bot message that @-mentions the human: ${f.askBack === 0 ? "the newest message" : `${f.askBack} messages back`}; the human ${f.humanPostedSinceAsk ? "has posted since" : "has not posted since"}`]),
-    ...(f.turns?.length || f.handoffMin == null ? [] : [`Nobody is working here, and the newest message went to a bot ${f.handoffMin} minutes ago.`]),
-    `Fix/review rounds so far (reviews sent back to work): ${f.rounds}`,
-    ...(f.restarted ? ["A bot's server restarted and its turn went silent."] : []),
-  ];
-  for (const x of f.turns) {
-    lines.push(`${x.agent}'s turn: running ${x.turnMin ?? "?"} min, ${x.toolCalls} tool calls, no tool activity for ${x.quietMin ?? "?"} min`);
-    if (x.current) lines.push(`  current call: ${x.current.call}${x.current.min == null ? "" : ` (${x.current.min} min in)`}`);
-    if (x.waitingMin != null) lines.push(`  parked in task_wait for ${x.waitingMin} min`);
-    if (x.subagents) lines.push(`  subagents: ${x.subagentsOut} of ${x.subagents} out`);
-    for (const r of x.repeats) lines.push(`  repeated ${r.n} times of ${x.toolCalls} calls this turn: ${r.call}`);
-  }
-  return lines.join("\n");
-}
-
-// What changing means for a busy thread: the turns working in it, the
-// subagents out, a parked wait, the worst repeat count, rounds, a restart, and
-// how many passes it has been quiet. A bot moving from one call to the next
-// changes none of these, so a thread that is making progress costs nothing;
-// one that has gone quiet is looked at again every pass.
-export const factsKey = (f) =>
-  createHash("sha256")
-    .update(JSON.stringify([f.rounds, f.restarted, f.turns.map((x) => [x.agent, x.subagentsOut, x.waitingMin != null, x.repeats[0]?.n ?? 0, x.quietMin == null ? null : Math.floor(x.quietMin / PASS_MIN)])]))
-    .digest("hex")
-    .slice(0, 8);
-
-// A busy thread's basis: what classifyBasis reads, then its facts' key. Due
-// when it differs from the one its entry was made from.
-export const busyBasis = (base, key) => `${base}|f:${key}`;
-
-// --- the reason line -----------------------------------------------------
-// Each state the model can pick (dash-classify.mjs STATES) has a template over
-// facts and the thread's own words; the model picks the state, code quotes.
-
-const REASON_MAX = 400;
-// A message's paragraphs as written (links as their labels), without the ones
-// that are only a rule or markers.
-export const paragraphs = (text) => String(text ?? "").split(/\n\s*\n/).map(flat).filter((p) => /[\p{L}\p{N}]/u.test(p));
-// `label: “text”`, or just the label when the thread has no such message yet.
-const labelled = (label, text) => (text ? `${label}: “${text}”` : label);
-
-// `brief` is the thread's brief (thread-brief.mjs): its last messages, each
-// { id, author, human, text }; `ask` is the paragraph the model picked as the
-// ask (askQuestion), else the newest bot message.
-export function reasonLine(state, brief, f, ask = null) {
-  const lastBot = [...(brief?.recent ?? [])].reverse().find((l) => !l.human);
-  const x = f.turns[0];
-  const doing = x?.current ? `${x.current.call}${x.current.min == null ? "" : `, ${x.current.min} min in`}` : x?.subagentsOut ? `${x.subagentsOut} of ${x.subagents} subagents out` : x?.waitingMin != null ? `waiting on its tasks ${x.waitingMin} min` : x ? "thinking" : null;
-  const line = {
-    "asks-you": () => labelled("asks you", ask ?? lastBot?.text),
-    stuck: () => `possibly stuck: ${doing ?? "silent"}${!x?.current && x?.quietMin ? `, no tool activity ${x.quietMin} min` : ""}${x?.repeats?.length ? `, repeated ${x.repeats[0].n}×` : ""}`,
-    dropped: () => `${labelled("stopped without finishing", lastBot?.text)}${f.botSilentMin == null ? "" : ` (${f.botSilentMin} min ago)`}`,
-    running: () => (x ? `${x.agent}: ${doing}` : "waiting on something that ends by itself"),
-    settled: () => labelled("nothing waiting on you", lastBot?.text),
-  }[state];
-  return clip(line ? line() : "", REASON_MAX);
-}

package/schedules/thread-brief.mjs

@@ -1,110 +0,0 @@
-// One factual brief of a thread, built once and read by every part of main's
-// dash schedule that judges a thread: the Dash model call (its delay, which
-// also drives the "asks you" notice, and its track pick) and main's
-// new-track notice (dash-classify.mjs). It states what was said and posted;
-// it never decides what's answered or open. The model reading it does.
-//
-// The brief: title and tags, the opening message, the phase and each bot's
-// latest status post, open requests to the human, the earlier messages to
-// or from the human (every message that @-mentions them and every one they
-// wrote, oldest first, the newest kept when over budget), and the last
-// messages, whole: an ask often sits at the end of a long handoff. The
-// earlier part is capped by length, not by count.
-//
-// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the
-// tests (plain node) import the same module.
-
-// A message someone said: not a hub event or a system line.
-export const said = (m) => m && m.authorKind !== "event" && !m.event && m.author !== "system";
-export const lastSaid = (t) => {
-  const ms = t?.messages ?? [];
-  for (let i = ms.length - 1; i >= 0; i--) if (said(ms[i])) return ms[i];
-  return null;
-};
-
-export const plain = (text) => String(text ?? "").replace(/```[\s\S]*?```/g, " ").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/[`*_#>|]/g, "").replace(/\s+/g, " ").trim();
-// Message text for the brief: one line, link labels without their targets,
-// otherwise as written (code and markdown kept: "#256" is a PR).
-export const flat = (text) => String(text ?? "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/\s+/g, " ").trim();
-export const clip = (text, n) => (text.length > n ? `${text.slice(0, n - 1)}…` : text);
-// Head and tail: a long message's ask usually sits at its start or its end.
-export const squeeze = (text, n) => {
-  if (text.length <= n) return text;
-  const head = Math.ceil((n - 3) / 2);
-  return `${text.slice(0, head)} … ${text.slice(text.length - (n - 3 - head))}`;
-};
-
-export const BRIEF = {
-  opening: 600, // the opening message, when it isn't among the last
-  message: 700, // each earlier message
-  recent: 5, // the last messages, always in, whole
-  earlier: 2400, // the earlier messages to or from the human, in total
-  report: 200, // each bot's status summary
-};
-
-const humanOf = (snap) => snap?.humans?.[0]?.name ?? "me";
-const isHuman = (m, human) => m.author === human || m.authorKind === "human";
-const line = (m, human, n = Infinity) => ({ id: m.id, author: m.author, human: isHuman(m, human), text: squeeze(flat(m.text), n) });
-
-// The brief as data. `snap` gives the human's name and pending requests.
-export function threadBrief(t, snap, limits = BRIEF) {
-  const human = humanOf(snap);
-  const ms = (t?.messages ?? []).filter(said);
-  const recent = ms.slice(-limits.recent);
-  const before = ms.slice(1, ms.length - recent.length);
-  const earlier = [];
-  let used = 0;
-  for (let i = before.length - 1; i >= 0; i--) {
-    const m = before[i];
-    if (!isHuman(m, human) && !(m.mentions ?? []).includes(human)) continue;
-    const l = line(m, human, limits.message);
-    used += l.text.length;
-    if (used > limits.earlier) break;
-    earlier.unshift(l);
-  }
-  return {
-    human,
-    title: t?.title ?? t?.id,
-    project: t?.tags?.project ?? null,
-    path: t?.tags?.path ?? null,
-    issueType: t?.tags?.issueType ?? t?.tags?.domain ?? null,
-    // The thread's stored summary (set_summary), when main wrote one.
-    summary: t?.summary?.text ? { text: clip(flat(t.summary.text), limits.summary ?? 600), by: t.summary.by ?? null } : null,
-    opening: ms.length > limits.recent ? line(ms[0], human, limits.opening) : null,
-    phase: t?.work?.phase ?? null,
-    reports: Object.entries(t?.work?.bots ?? {}).map(([bot, s]) => ({ bot, summary: clip(flat(s?.summary), limits.report), pr: s?.pr ?? null, sha: s?.sha ? String(s.sha).slice(0, 8) : null })),
-    requests: Object.values(snap?.requests ?? {})
-      .filter((r) => r?.threadId === t?.id && r.status === "pending")
-      .map((r) => ({ agent: r.agent ?? "a bot", kind: r.kind ?? "request" })),
-    earlier,
-    omitted: before.length - earlier.length,
-    recent: recent.map((m) => line(m, human)),
-  };
-}
-
-const who = (l) => `${l.author}${l.human ? " (human)" : ""}`;
-
-// The brief as text: the same block for every reader.
-// "domain" is the label the classifier was measured with (scripts/lane-replay.mjs: "issue type" for the
-// same value cost it two asks and the stall); keep it until a replay says otherwise.
-export function briefText(b) {
-  return [
-    `Title: ${b.title}`,
-    `Project: ${b.project ?? "none"}${b.path && b.path !== b.project ? ` · path: ${b.path}` : ""} · domain: ${b.issueType ?? "none"}`,
-    ...(b.summary ? [`Summary${b.summary.by ? ` (by ${b.summary.by})` : ""}: ${b.summary.text}`] : []),
-    ...(b.opening ? [`Opening message, ${who(b.opening)}: ${b.opening.text}`] : []),
-    ...(b.phase ? [`Phase the bots reported: ${b.phase}`, ...b.reports.map((r) => `- ${r.bot}: ${r.summary}${r.pr ? ` (PR ${r.pr}${r.sha ? ` @ ${r.sha}` : ""})` : ""}`)] : []),
-    `Open requests to ${b.human}: ${b.requests.map((r) => `${r.agent} (${r.kind})`).join(", ") || "none"}`,
-    ...(b.earlier.length ? [`Earlier messages that @-mention ${b.human} or are by ${b.human}, oldest first:`, ...b.earlier.map((l) => `- ${who(l)}: ${l.text}`)] : []),
-    ...(b.omitted ? [`(${b.omitted} other earlier messages not shown)`] : []),
-    ...(b.recent.length ? ["Last messages, oldest first:", ...b.recent.map((l) => `- ${who(l)}: ${l.text}`)] : []),
-  ].join("\n");
-}
-
-// A thread already in a track, as one line of that track's description
-// (the track question's criteria, main's notice): its title and opening.
-export const MEMBER_CHARS = 200;
-export const memberLine = (t) => {
-  const first = (t?.messages ?? []).find(said);
-  return `"${t?.title ?? t?.id}"${first ? `: ${clip(plain(first.text), MEMBER_CHARS)}` : ""}`;
-};

package/schedules/track-summaries.mjs

@@ -1,108 +0,0 @@
-// The track summaries of main's dash pass (schedules/dash.ts): every open
-// track (a path below its project, web/checkout; registry: snap.tracks keyed
-// by path) has a free-form summary the human reads above its threads. A pass
-// gives each track with a thread that has messages newer than the last pass
-// that covered it (pass.trackMarks in the dash schedule's state: thread id -> newest message covered) one
-// model call: the track's old summary and those threads' briefs in, the new
-// summary out. Code only gathers facts; the model decides what the summary
-// needs. A call that fails keeps its marks, so the track is asked again next
-// pass.
-//
-// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the
-// tests (plain node) import the same module.
-import { runOnce } from "./hub.mjs";
-import { said, briefText, threadBrief } from "./thread-brief.mjs";
-
-// A track chat is main's own conversation with the human; it doesn't move the track.
-const counted = (t) => !!t && t.kind === "thread" && !t.chatFor;
-const pathOf = (t) => t.tags?.path ?? t.trackId ?? null;
-
-// Every filed thread on an open track, as facts; and of those, the ones with
-// a message newer than their mark. A thread without a mark (a first run, or
-// filed onto an open track since) has never been covered, so all of it is
-// news. A summary's write time isn't a mark: it doesn't say which threads'
-// messages the summary covered. Newest first within a track.
-export function tracksFacts(snap, marks = {}) {
-  const tracks = snap?.tracks ?? {};
-  const all = [];
-  for (const t of Object.values(snap?.threads ?? {})) {
-    if (!counted(t)) continue;
-    const track = tracks[pathOf(t)];
-    if (track && track.open !== false) all.push({ id: t.id, track: track.id, archived: !!t.archived, lastAt: (t.messages ?? []).filter(said).at(-1)?.at ?? null });
-  }
-  const wake = all.filter((f) => f.lastAt && f.lastAt > (marks[f.id] ?? ""));
-  wake.sort((a, b) => a.track.localeCompare(b.track) || String(b.lastAt).localeCompare(String(a.lastAt)));
-  return { all, wake };
-}
-
-export const TRACK_MODEL = "anthropic/claude-sonnet-5.5";
-// Tracks asked per pass and threads shown per track; the rest wait for the next pass.
-export const TRACKS_PER_PASS = 8;
-export const THREADS_PER_TRACK = 6;
-export const SUMMARY_MAX = 1500;
-
-// The call for one track: its old summary, then each changed thread's brief
-// and where the Dash put it.
-export function trackPrompt(track, wake, snap) {
-  const entries = snap?.dash?.entries ?? {};
-  const oldSummary = track.summary?.text ?? snap?.pathSummaries?.[track.id]?.text;
-  const threads = wake.slice(0, THREADS_PER_TRACK).map((f) => {
-    const t = snap.threads[f.id];
-    const e = entries[f.id];
-    return [`### ${f.id}${f.archived ? " (archived)" : ""}`, ...(e?.lane ? [`Dash: ${e.lane}${e.reason ? `, ${e.reason}` : ""}`] : []), briefText(threadBrief(t, snap))].join("\n");
-  });
-  return [
-    `You keep the summary of one track of work current. A track groups the threads (chats between ${snap?.humans?.[0]?.name ?? "the human"} and AI bots) of one feature. The human reads the summary above the track's threads: a short markdown note of what's up in that feature (what's moving, what's blocked or waiting on them, what just landed), written for them.`,
-    `Track: ${track.title ?? track.id} (${track.id})`,
-    oldSummary ? `Current summary:\n${oldSummary}` : "There is no summary yet.",
-    `Threads with news since the summary was last written:`,
-    ...threads,
-    `Write the whole new summary: keep what is still right, fold in the news, drop what is stale. Answer with the summary only, no preamble, at most ${SUMMARY_MAX} characters.`,
-  ].join("\n\n");
-}
-
-// One pass. State: the dash schedule's own, pass.trackMarks in it: per thread on an open track, the newest message
-// a summary was written for. Saved only when a mark moved. `summarize(prompt)`
-// -> the summary text; `hub.setSummary(path, text)` stores it. A track with no
-// summarize, a failed call or an empty answer keeps its marks.
-// -> { written, wake }
-/** @param {any} hub @param {{ summarize?: (prompt: string) => Promise<string>, log?: any }} [opts] */
-export async function runTracks(hub, { summarize, log = console } = {}) {
-  let written = 0;
-  let wake = [];
-  await runOnce(hub, "dash", async (snap, saved) => {
-    const had = saved?.pass?.trackMarks ?? {};
-    const facts = tracksFacts(snap, had);
-    wake = facts.wake;
-    const marks = { ...had, ...Object.fromEntries(facts.all.filter((f) => !f.lastAt).map((f) => [f.id, ""])) };
-    const byTrack = Map.groupBy(wake, (f) => f.track);
-    const todo = [...byTrack].slice(0, TRACKS_PER_PASS);
-    await Promise.all(
-      todo.map(async ([id, ws]) => {
-        try {
-          const text = (await summarize?.(trackPrompt(snap.tracks[id], ws, snap)))?.trim();
-          if (!text) return;
-          await hub.setSummary(id, text.slice(0, SUMMARY_MAX));
-          for (const f of ws.slice(0, THREADS_PER_TRACK)) marks[f.id] = f.lastAt;
-          written++;
-        } catch (err) {
-          log?.warn?.(`tracks: summary for ${id} failed, asked again next pass: ${err?.message ?? err}`);
-        }
-      }),
-    );
-    const changed = JSON.stringify(marks) !== JSON.stringify(had);
-    return { posts: [], state: { ...saved, pass: { ...saved?.pass, trackMarks: marks } }, changed };
-  });
-  return { written, wake };
-}
-
-// The schedule's summarizer: one text generation per track. Throws on a
-// failed call (runTracks keeps the marks).
-/** @param {{ generateText?: (options: any) => Promise<{ text: string }>, model?: string, timeoutMs?: number }} [options] */
-export function modelSummarize({ generateText, model = TRACK_MODEL, timeoutMs = 60_000 } = {}) {
-  return async (prompt) => {
-    if (!generateText) return "";
-    const r = await generateText({ model, prompt, maxRetries: 1, abortSignal: AbortSignal.timeout(timeoutMs) });
-    return r.text;
-  };
-}