eve-hub 0.16.20 → 0.16.22

package/channels/eve-roster-user.js

@@ -7,6 +7,8 @@ import { isHubRequest } from "../hub-oidc.mjs";
 // a local-dev request, or one from the hub (a deployed bot, see hub-oidc.mjs). Resolving it as a user lets user-scoped
 // connections (open_pull_request's OAuth) key tokens to the configured human;
 // `localDev()` alone is not a user, so eve fails them with principal_required.
+// eve serves `GET /eve/v1/info` only to operator principals; the hub reads it as this user to learn the bot's
+// schedules and tools (hosted-hub readDeployment), so a request that passed the hub check may read it too.
 const dev = localDev();
 async function rosterUser(req) {
     const user = req.headers.get("x-roster-user");
@@ -14,7 +16,7 @@ async function rosterUser(req) {
         return null;
     if (!(await dev(req)) && !(await isHubRequest(req, getVercelOidcToken)))
         return null;
-    return { authenticator: "roster", principalId: `roster:${user}`, principalType: "user", attributes: {} };
+    return { authenticator: "roster", principalId: `roster:${user}`, principalType: "user", attributes: {}, allowAgentInfo: true };
 }
 // No turnPolicy: eve's default steers a message into the running turn at its
 // next step. The registry sends turnPolicy "queue" for a bot's message, so it

package/github-connector.mjs

@@ -1,9 +1,3 @@
 // The Vercel Connect connector that holds the workspace human's GitHub token (the eve-hub-github
-// App). The bots' `git__gh` (prepare.mjs) and main's dash pass (schedules/dash-run.mjs) ask it for
-// the same subject, so both act as the human. Its own module so a schedule can import it without
-// prepare.mjs's build-time imports.
+// App). The bots' `git__gh` (prepare.mjs) asks it for the human's token, so they act as the human.
 export const GITHUB_CONNECTOR = "github/eve-hub-github";
-
-// The subject eve's connections resolve for a hub turn (channels/eve-roster-user.ts: principal
-// `roster:<human>`, authenticator `roster`, no issuer of its own, so eve uses the authenticator).
-export const rosterSubject = (human) => ({ type: "user", id: `roster:${human}`, issuer: "roster" });

package/kit-modules.json

@@ -9,7 +9,6 @@
   "memory/bot",
   "memory/team",
   "memory/workspace",
-  "schedules/dash",
   "schedules/prune",
   "schedules/wake",
   "skills/fanout",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.16.20",
+  "version": "0.16.22",
   "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/prepare.mjs

@@ -11,8 +11,7 @@
 //   is the host's fails the build, and the build never writes a sandbox;
 // - the kit extension, host-only workers and kit stubs are dropped, the
 //   Vercel Kit connection is wired in, every bot of a build from a repo gets eve's git extension, and the
-//   workspace's memory and each bot's team architecture are embedded in the bots' memory providers, and main's
-//   standing decisions in its dash schedule (a function has no workspace cwd);
+//   workspace's memory and each bot's team architecture are embedded in the bots' memory providers, (a function has no workspace cwd);
 // - /hub/manifest: the roster and the commit sha the deployment was built
 //   from, for the hub to sync from: a custom channel on main, routed in
 //   vercel.mjs. From the hub, as on each bot's eve channel (hub-oidc.mjs).
@@ -24,7 +23,7 @@ import KIT_MODULES from "./kit-modules.json" with { type: "json" };
 import { applyKit, readBotFiles, syncKit } from "./sync-kit.mjs";
 export { DEPLOYED_KIT_FILES };
 import { deploymentFacts, hostedContext } from "./execution-context.mjs";
-import { activeEntries, botDomains, domainFolders, entryText, readBotMemory, readMemory, validateMemory } from "./memory.mjs";
+import { botDomains, domainFolders, readBotMemory, readMemory, validateMemory } from "./memory.mjs";
 import { agentRunsOn, coordinatorOf, readWorkspaceFile, removeWorkspaceAgent } from "./workspace.mjs";
 import { architectureText } from "./team.mjs";
 import { sandboxReady } from "./sandbox-migrate.mjs";
@@ -165,16 +164,6 @@ const recall = () => teamRecall(text);
 export default defineMemory({ namespace: "hub-team-memory", scope: "workspace", provider: defineMemoryProvider({ recall: { "turn.started": recall } }) });
 `;
 
-// A hosted main's dash schedule: the standing decisions main's turns recall, embedded at build
-// time for the Dash plan, since a function has no memory/ to read. It replaces only the kit's
-// re-export; a workspace's own dash schedule (.ts or another source for the slot) stays.
-const DASH_SCHEDULE_FILE = join("schedules", "dash.ts");
-const isKitDashSchedule = (bot) => existsSync(join(bot, DASH_SCHEDULE_FILE)) && isKitReexport(readFileSync(join(bot, DASH_SCHEDULE_FILE), "utf8"), "schedules/dash");
-export const dashScheduleStub = (entries) => `import { dashSchedule } from "eve-hub/schedules/dash";
-const decisions = ${JSON.stringify(activeEntries(entries).map((e) => entryText(e)).join("\n"))};
-export default dashSchedule({ decisions: () => decisions });
-`;
-
 // Replaces the kit's execution-context stub (the local page) with the hosted
 // page, for a bot the definition says is hosted. Its removed-tools list is read
 // from the bot's folder as pruned.
@@ -245,7 +234,6 @@ export function prepareDeployment(dir) {
     const botDir = join(dir, "agents", name);
     const { entries } = readMemory(dir, { folders: domainFolders(botDomains(dir, botDir)) });
     writeFileSync(join(bot, "memory", "workspace.ts"), memoryProvider("workspace", entries, "Standing decision", "workspace"));
-    if (name === coordinator && isKitDashSchedule(bot)) writeFileSync(join(bot, DASH_SCHEDULE_FILE), dashScheduleStub(entries));
     // A folder the roster doesn't list has no place in the team, and a function can't read the file the stub would.
     if (definition.agents.some((a) => a.name === name)) writeFileSync(join(bot, "memory", "team.ts"), teamProvider(architectureText(definition.data, name)));
     else rmSync(join(bot, "memory", "team.ts"), { force: true });

package/stubs.mjs

@@ -42,7 +42,6 @@ export const MAIN_KIT_FILES = {
   "tools/dash_update.ts": ["Set Dash entries: importance, lane, reason and deferred per thread."],
   "tools/apply_tags.ts": ["Retag threads, merge or rename tags: applies a staged proposal or a new batch directly."],
   // Handler schedules: the hub fires them from its minute clock (registry/schedules.mjs).
-  "schedules/dash.ts": ["When a bot's turn ends (fired by the hub), and every 8 minutes: the human's PRs, a Dash entry for each thread that changed, and a new summary for each track with news."],
   "schedules/prune.ts": ["Every 10 minutes: one prune pass over what archived or deleted threads leave on disk: worktrees, scratch, their-only uploads, idle bots' traces and workflow runs; unsaved work kept as refs/bundles."],
 };
 
@@ -54,10 +53,8 @@ export const MAIN_KIT_FILES = {
 // the kit's bash (HostSandbox's root, the daemon's env; eve's own bash runs
 // instead), the browser and the screenshot path of view_image,
 // restart_hub (the hub's own code), memory (the workspace's files), and main's prune schedule (it cleans the hub machine's disk).
-// main's dash schedule stays: off the hub's machine it has no PR data (its lookup runs `gh`).
 export const DEPLOYED_KIT_FILES = new Set([
   "channels/eve.ts",
-  "schedules/dash.ts",
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",
   ...["react", "show", "fetch_upload", "update_thread", "list_threads", "read_thread", "post_message"].map((t) => `tools/${t}.ts`),

package/templates/execution-context-hosted-main.md

@@ -1,3 +1,2 @@
 - **Team.** `create_agent` takes `runsOn` (`hosted` or `local`) and commits the new bot to the workspace repository; it joins with the next deployment, and a `local` bot then runs on the owner's Mac. `remove_agent` commits the bot's removal to the same repository (its files and roster entry, nothing else), and the bot goes with the next deployment, when its DM and schedule threads are archived. If nobody on the team covers the work well, ask the human before going on.
 - **Memory.** Add an entry as your Memory section says, by committing the file to the workspace repository (see Changing it above). With no repository, write nothing and tell the human to link one first.
-- **Schedules.** Your `dash` schedule runs every 8 minutes: it classifies the threads that changed into the Dash and rewrites track summaries that have news, without PR data (a function has no `gh`).

package/templates/execution-context-local-main.md

@@ -1,6 +1,3 @@
 - **Team.** `create_agent` adds a bot to the workspace; if nobody on the team covers the work well, create a specialist (name, model, role, instructions), then route to it. Give planners and reviewers `preset: "read-only"` so they can't edit files. `remove_agent` removes a bot from the team and shuts it down (name); use it when the human asks. It can't remove you (the coordinator) or humans.
 - **Memory.** A new memory entry ships in the next workspace sync PR; each bot recalls it on its next turn, as a `Standing decision <id>:` or `Your standing decision <id>:` message.
-- **Summaries.** Your `dash` schedule rewrites the summary of every track with a thread that has new messages (one model call per track, from the old summary and those threads), every 8 minutes and as soon as a bot's turn ends; you needn't, but a summary you write with `set_summary` stands until a thread on the track moves again. `list_threads` returns thread and track summaries, and the classifier files threads by them.
-- **Classifier.** Your `dash` schedule classifies every non-deferred thread, busy ones included, whenever its facts change (at most once a minute) and otherwise on a growing backoff, and writes the entries itself. It reads the thread; whether it waits on the human is the model's call. You don't rewrite the Dash on each tick.
-- **Ticks.** The same schedule also scans PRs, threads where a bot asks the human, and Dash threads that moved on, and posts in your `dash` schedule thread (`sch-<your name>-dash`) only when something changed. On a tick, fix only what the classifier got wrong with `dash_update` (fields you leave out keep their value): change a `lane` (with its `reason`) the classifier got wrong, raise `importance` for what matters more given the human's role, set `deferred: true` for work the human parked, `remove` an entry that no longer applies. Often nothing needs changing. Don't reply in the tick thread beyond a one-line note, and mention nobody.
-- **Unfiled paths.** The classifier files unfiled threads onto an existing path in their project. When none fits, one notice gives every unfiled thread in that project alongside every path in use. Read their briefs and put each on a listed path where one fits, or a new `project/feature` path, with `update_thread` (`threadId` and `path` only, including threads you aren't in). Merge near-duplicates with `move_path`. Never move a human-locked path.
+- **Summaries.** A track summary you write with `set_summary` stands until you write another. `list_threads` returns thread and track summaries.

package/tools/dash_update.js

@@ -3,8 +3,7 @@ import { z } from "zod";
 import { registryFetch } from "../registry-fetch.mjs";
 // main only (the registry refuses other bots). Writes Dash entries
 // (hosted-hub/src/domain/dash.mjs): importance / lane / reason / deferred on existing,
-// non-archived threads, merged field by field (POST /api/dash/entries). The
-// dash schedule classifies idle threads on its own; this is for corrections.
+// non-archived threads, merged field by field (POST /api/dash/entries).
 const entry = z.object({
     threadId: z.string().describe("The thread this entry is about (an open thread, not a DM)."),
     importance: z.enum(["high", "normal", "low"]).optional().describe("How much this matters given the human's role. Required for a thread with no entry yet."),
@@ -16,7 +15,7 @@ const entry = z.object({
     deferred: z.boolean().optional().describe("true: on the backburner, hidden from the Dash and not classified again until set back to false."),
 });
 export default defineTool({
-    description: "Set Dash entries: per thread, its importance (high|normal|low), lane (needs-you|running|fyi) with its reason, and deferred (backburner). Fields you leave out keep their value. The dash schedule classifies idle threads by itself; use this to correct an entry, defer a thread, or add one it hasn't reached. `remove` drops entries. ",
+    description: "Set Dash entries: per thread, its importance (high|normal|low), lane (needs-you|running|fyi) with its reason, and deferred (backburner). Fields you leave out keep their value. Use it to set or correct an entry, or to defer a thread. `remove` drops entries. ",
     inputSchema: z.object({ entries: z.array(entry).max(200).default([]), remove: z.array(z.string()).optional() }),
     async execute({ entries, remove }, ctx) {
         const res = await registryFetch(`/api/dash/entries`, {

package/schedules/dash-classify.mjs

@@ -1,367 +0,0 @@
-// The threads part of main's dash pass (schedules/dash-pass.mjs): gives
-// every open thread, busy or idle, a Dash entry (hosted-hub/src/domain/dash.mjs: importance,
-// lane, reason) and writes them back through POST /api/dash/entries.
-//
-//   targets   open threads (not DMs, schedule threads or archived) that aren't
-//             deferred and are due. A thread is due when its basis changed
-//             since its entry was written; a busy thread's basis ends with
-//             its facts' key (./lane-facts.mjs), which moves when it goes
-//             quiet for another pass, not while its bot keeps working. An
-//             unchanged hub costs nothing.
-//   classify  (target, snap) -> { threadId, importance, lane, reason } or null, all
-//             targets at once, each written as soon as it's decided.
-//             modelClassify: one evaluation per thread on the AI Gateway
-//             (openai/gpt-6-luna-decisions), two choice questions: the
-//             thread's state (each state is one lane) and its importance. The
-//             reason line is quoted from facts by ./lane-facts.mjs. Its
-//             answer is the classification. No model, a failed call or an
-//             invalid answer writes nothing for that thread, so it's tried
-//             again next tick, and the pass doesn't stamp classifiedAt.
-//   file      a thread with an empty or project-only tags.path is a
-//             target even when its basis hasn't changed, and its evaluation
-//             carries a third choice: any path in use in its project, or
-//             `new`. A path pick files the thread (hub.fileThread); `new`
-//             goes to main in sch-main-dash, since `evaluate` can't write a
-//             path title. A filed thread is never asked again.
-//
-// 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 { coordinatorOf } from "../workspace.mjs";
-import { lastSaid, said, threadBrief, briefText } from "./thread-brief.mjs";
-import { busyBasis, factsText, laneFacts, factsKey, paragraphs, reasonLine } from "./lane-facts.mjs";
-
-export { threadBrief, briefText } from "./thread-brief.mjs";
-
-export const CLASSIFY_MAX = 30;
-
-const open = (t) => !!t && t.kind === "thread" && !t.schedule && !String(t.id).startsWith("sch-") && !t.archived;
-const working = (t) => Object.values(t?.status ?? {}).includes("working");
-
-// What a classification was made from: the last message, the live status
-// class (waiting / working / idle) and the project and issue type tags. The entry
-// keeps it (entry.basis); a thread is classified again once it differs. Kept
-// in step with hosted-hub/src/domain/dash.mjs classifyBasis (test/dash-entries.test.mjs).
-// The input version (hosted-hub/src/domain/dash.mjs BASIS_VERSION): bumped when what the
-// model reads changes, so every entry made from the older input is
-// classified once more, then stays quiet.
-export const BASIS_VERSION = "v:lanes1";
-export function classifyBasis(t) {
-  const st = Object.values(t?.status ?? {});
-  const live = st.includes("waiting") ? "waiting" : st.includes("working") ? "working" : "idle";
-  // The newest status post (t.work, see the hub's lib/work-status.mjs), only
-  // once a bot has posted one, so bases from before statuses existed stay valid.
-  const reported = Object.values(t?.work?.bots ?? {}).map((b) => b?.messageId ?? "").sort().at(-1);
-  return [lastSaid(t)?.id ?? "", live, t?.tags?.project ?? "", (t?.tags?.issueType ?? t?.tags?.domain) ?? "", ...(reported ? [reported] : []), BASIS_VERSION].join("|");
-}
-
-// Paths come from the snapshot's legacy view; all depths in use are choices.
-const filed = (t) => (t?.tags?.path ?? "").includes("/");
-export const askPath = (t) => open(t) && !filed(t) && !t?.tags?.locked?.includes("path");
-export const NEW_PATH = "new";
-export function pathsInProject(t, snap) {
-  const project = t.tags?.project ?? t.tags?.path?.split("/")[0] ?? "";
-  return Object.values(snap?.tracks ?? {})
-    .filter((u) => u.projectId === project)
-    .map((u) => ({ id: u.id, title: u.title, summary: u.summary?.text ?? snap?.pathSummaries?.[u.id]?.text ?? "", count: Object.values(snap?.threads ?? {}).filter((x) => open(x) && (x.tags?.path === u.id || x.tags?.path?.startsWith(u.id + "/"))).length }))
-    .sort((a, b) => a.id.localeCompare(b.id));
-}
-export function pathQuestion(paths) {
-  if (!paths.length) return null;
-  const criteria = Object.fromEntries(paths.map((u) => [u.id, `Path ${u.id}: "${u.title}". ${u.summary} Open threads: ${u.count}.`]));
-  criteria[NEW_PATH] = "No listed path fits this work, even read broadly; the coordinator must name a new path.";
-  return { type: "choice", instructions: "Which path covers this thread's work? Paths group threads by feature or effort at any depth. A bug, polish or follow-up belongs to its area's existing path. Prefer an existing path where it fits; choose new only when none fits.", criteria };
-}
-
-// Which paragraph holds the ask the human would answer: the row quotes the one
-// the model points at, word for word, so code never guesses where it is. The
-// candidates are the paragraphs of the bot messages in the brief that @-mention
-// the human; the model is asked only when there are two or more (the API wants
-// two choices). The choices are labelled p0, p1, …: the gateway fails on
-// labels like `thr_0m7l#3`, not on how many there are.
-export function askCandidates(t, brief) {
-  const ids = new Set([...(brief?.earlier ?? []), ...(brief?.recent ?? [])].map((l) => l.id));
-  return (t?.messages ?? [])
-    .filter((m) => ids.has(m.id) && said(m) && m.authorKind !== "human" && m.author !== brief.human && ((m.mentions ?? []).includes(brief.human) || String(m.text).includes(`@${brief.human}`)))
-    .flatMap((m) => paragraphs(m.text).map((text) => ({ author: m.author, text })))
-    .map((c, i) => ({ id: `p${i}`, ...c }));
-}
-export function askQuestion(candidates) {
-  const criteria = Object.fromEntries(candidates.map((c) => [c.id, `${c.author}: ${c.text.slice(0, 160)}`]));
-  return { type: "choice", instructions: "Which of these paragraphs holds what the human is asked to answer, decide or do? Pick the paragraph a person reading the thread would point to as the ask. If none asks them anything, pick the newest.", criteria };
-}
-
-// The threads to (re)classify this pass, at most `max`: those the Dash needs
-// (no entry, or the thread moved on) first, newest change first, so the
-// thread whose turn just ended (what fired this pass) is selected under the
-// cap whatever the backlog, and a thread whose answers keep failing sinks behind
-// fresh ones instead of holding the front; later passes drain the rest. Then those
-// asked only for a path, least recently classified first, so threads still
-// waiting on main's filing take turns and never crowd out the Dash.
-export function classifyTargets(snap, { max = CLASSIFY_MAX, now = Date.now() } = {}) {
-  const entries = snap?.dash?.entries ?? {};
-  const out = [];
-  const pathOnly = [];
-  for (const t of Object.values(snap?.threads ?? {})) {
-    if (!open(t)) continue;
-    const e = entries[t.id];
-    if (e?.deferred) continue;
-    const last = lastSaid(t);
-    if (!last) continue;
-    const facts = laneFacts(t, snap, now);
-    const base = classifyBasis(t);
-    const busy = working(t);
-    const basis = busy ? busyBasis(base, factsKey(facts)) : base;
-    const look = { due: !e || e.basis !== basis, basis };
-    const path = askPath(t);
-    if (!look.due && !path) continue;
-    (look.due ? out : pathOnly).push({ id: t.id, title: t.title, tags: t.tags ?? {}, status: t.status ?? {}, last, brief: threadBrief(t, snap), facts, basis: look.basis, entry: e ?? null, paths: path ? pathsInProject(t, snap) : null });
-  }
-  const at = (x) => String(x ?? "");
-  out.sort((a, b) => at(b.last.at).localeCompare(at(a.last.at)));
-  pathOnly.sort((a, b) => at(a.entry?.updatedAt).localeCompare(at(b.entry?.updatedAt)) || at(a.last.at).localeCompare(at(b.last.at)));
-  return [...out, ...pathOnly].slice(0, max);
-}
-
-// --- the model -------------------------------------------------------------
-// openai/gpt-6-luna-decisions on the AI Gateway, through an AI SDK
-// `evaluate` (eve/ai's `decide`): the schedule passes eve's; tests pass a
-// mock.
-export const DECISION_MODEL = "openai/gpt-6-luna-decisions";
-
-// What the thread is doing for the human, as one pick. Each state is one lane
-// (the entry's `lane`); `ready` isn't here, the hub derives it from the reviewer's
-// ship verdict on the PR's current head (entriesOf, hosted-hub/src/domain/dash.mjs).
-export const STATES = {
-  "asks-you": "needs-you",
-  stuck: "running", // a stall is a bot's to steer; it shows on the thread's own row, not as the human's task
-  dropped: "needs-you",
-  running: "running",
-  settled: "fyi",
-};
-
-export const QUESTIONS = {
-  state: {
-    type: "choice",
-    instructions: "What is this thread doing for the human right now? Read the whole brief and the live facts. Be strict: the human's attention is scarce, so a thread belongs in front of them only when something specific is theirs to do right now, and every other thread is running or settled. Read from the newest message back to the latest ask to the human; that is the only candidate. A bot that mentions the human, reports progress, says work is done or ready, or asks another bot for something is not asking the human; a request to confirm, approve or land something is.",
-    criteria: {
-      "asks-you": "The thread's last substantive message to or about the human is a bot putting an explicit question, a choice between options, a decision, or a request to confirm, approve or land something to the human, including an approval they give outside the thread such as a GitHub review (a proposal the thread says waits on their confirmation counts), and it is still open: the human's reply closes it only when that reply answers or decides it (a question back keeps it open), and a later bot message closes it only when it carries on that same work or answers its own question. Bot-to-bot messages about anything else (status, cleanup, handoffs) don't close it, however many follow. If you can't point at the exact ask and the human is its only possible answerer, it's not this.",
-      stuck: "A bot's turn is live but going nowhere that more waiting won't fix: no tool activity for far longer than that kind of work normally pauses (a bot thinking or writing between calls for a few minutes is normal), the same call or file repeated over and over (once or twice is normal work), a call far longer than its kind normally takes, or a restart that left the turn silent. A CI watch, a build, a test run, subagents out or a task_wait that is long but making sense is not stuck.",
-      dropped: "No bot is working, nothing is open with the human, and work was left hanging: a bot said it would do or report something next and didn't (the turn ended without finishing what it announced), or a bot was handed work by another bot and nobody picked it up.",
-      running: "A bot's turn is live, working or waiting on something that will end by itself (CI, a build, subagents, another bot). The human has nothing to do. Never pick this when every bot is idle.",
-      settled: "Nothing specific waits on the human and nobody is working: whatever was asked of them is settled, or the work is done, reported or landed.",
-    },
-  },
-  importance: {
-    type: "choice",
-    instructions: "How much does this thread matter compared with the human's other work?",
-    criteria: {
-      high: "Core product work, a release, or something many other tasks depend on",
-      normal: "Ordinary feature or fix work",
-      low: "A side experiment, polish, chores or a nice-to-have",
-    },
-  },
-};
-
-// The evaluation's `state`: what the thread is, then its brief
-// (./thread-brief.mjs), the same block main's new-path notice carries.
-export function threadState(t, snap) {
-  const brief = t.brief ?? threadBrief(t, snap);
-  const status = Object.entries(t.status ?? {}).map(([b, s]) => `${b}: ${s}`).join(", ") || "all idle";
-  return [
-    `A chat thread between a human (${brief.human}) and AI bots that work for them. A message addresses whoever it @-mentions; a bot addressing another bot asks nothing of ${brief.human}.`,
-    `Bot status now: ${status}`,
-    ...(t.facts ? [`Live facts:`, factsText(t.facts)] : []),
-    briefText(brief),
-  ].join("\n");
-}
-
-// One evaluation; returns { state, importance } when both answers are valid
-// choices, else null, plus `path` (a path id or `new`) for an unfiled
-// thread: `new` without a call when the project has no open paths, and left
-// out when that answer alone is invalid. Throws when the call fails.
-export async function decideThread(t, snap, { evaluate, model = DECISION_MODEL, timeoutMs = 20000 }) {
-  const uq = t.paths ? pathQuestion(t.paths) : null;
-  const asks = askCandidates(snap?.threads?.[t.id], t.brief ?? threadBrief(t, snap));
-  const questions = { ...QUESTIONS, ...(asks.length > 1 ? { ask: askQuestion(asks) } : {}), ...(uq ? { path: uq } : {}) };
-  const r = await evaluate({ model, state: threadState(t, snap), questions, maxRetries: 1, signal: AbortSignal.timeout(timeoutMs) });
-  const out = {};
-  for (const [name, q] of Object.entries(questions)) {
-    const a = r?.answers?.[name];
-    const ok = a?.type === "choice" && Object.hasOwn(q.criteria, a.choice);
-    if (ok) out[name] = a.choice;
-    else if (name !== "path" && name !== "ask") return null;
-  }
-  if (t.paths && !uq) out.path = NEW_PATH;
-  if (asks.length === 1) out.ask = asks[0].text;
-  else if (out.ask) out.ask = asks.find((c) => c.id === out.ask).text;
-  return out;
-}
-
-// The schedule's classifier, one thread: the model's answer as is
-// ({ threadId, importance, lane, reason, path? }), or null when there's no
-// `evaluate`, the call failed or the answer is invalid (no entry for it).
-/** @param {{ evaluate?: (options: any) => Promise<any>, log?: any, model?: string, timeoutMs?: number }} [options] */
-export function modelClassify({ evaluate, log = console, ...opts } = {}) {
-  return async (t, snap) => {
-    if (!evaluate) return null;
-    const a = await decideThread(t, snap, { evaluate, ...opts }).catch((err) => (log?.warn?.(`dash: decide ${t.id} failed, skipped: ${err?.message ?? err}`), undefined));
-    if (a === null) log?.warn?.(`dash: decide ${t.id}: invalid answer, skipped`);
-    if (!a) return null;
-    const { state, ask, ...rest } = a;
-    return { threadId: t.id, ...rest, lane: STATES[state], reason: reasonLine(state, t.brief, t.facts, ask) };
-  };
-}
-
-// Every unfiled thread main should file, in the given projects: open, a
-// project, no path, not filed or unfiled by hand. Working threads too: the
-// grouping is done once, over the whole project.
-export function unfiledIn(snap, projects) {
-  return Object.values(snap?.threads ?? {})
-    .filter((t) => open(t) && askPath(t) && projects.has(t.tags?.project ?? ""))
-    .sort((a, b) => String(a.createdAt ?? "").localeCompare(String(b.createdAt ?? "")));
-}
-
-// The notice main gets when a thread needs a new path: every unfiled thread
-// in that thread's project (unfiledIn), each with its brief, and the project's open paths with their threads. main
-// groups them all at once, creates a path per feature and files them.
-export function newPathNotice(threads, snap) {
-  const byProject = new Map();
-  for (const t of threads) byProject.set(t.tags?.project ?? "", [...(byProject.get(t.tags?.project ?? "") ?? []), t]);
-  const brief = (t) => [`- ${t.id}`, ...briefText(threadBrief(t, snap)).split("\n").map((l) => `  ${l}`)];
-  return [
-    `@${coordinatorOf(snap?.agents)}, these are every unfiled thread in each project. Group each project's work in one go from its briefs, using read_thread when needed. Put each thread on a listed path where one fits, or on a new project/feature path, with update_thread (threadId and path only, including threads you aren't in). Merge near-duplicate paths with move_path. Never move a human-locked path.`,
-    ...[...byProject].flatMap(([p, ts]) => {
-      const paths = pathsInProject(ts[0], snap);
-      return [
-        "",
-        `## ${p}`,
-        ...(paths.length ? ["Paths in use:", ...paths.map((u) => `- ${u.id} "${u.title}" (${u.count} open threads)${u.summary ? `: ${u.summary}` : ""}`)] : ["No paths in use yet."]),
-        `Unfiled (${ts.length}):`,
-        ...ts.flatMap(brief),
-      ];
-    }),
-  ].join("\n");
-}
-
-// The "asks you" notice: a thread whose lane changed to needs-you (its reason
-// says why), or from needs-you or ready (waiting on the human's sign-off) to
-// anything else. The model's pick decides; nothing here reads the messages. (A
-// pending request is posted by the rule scan, dash-rules.mjs.)
-const asking = (lane) => lane === "needs-you" || lane === "ready";
-// The notice for `e`, the new entry of target `t`, or null: committed with
-// it in one write (hub.dashEntries), so a verdict and its notice are kept
-// together or not at all, and a failed write is judged afresh next pass
-// against the entry as it still is.
-export function asksNotice(e, t, coordinator) {
-  const was = t.entry?.lane;
-  if (was === e.lane || (asking(was) && asking(e.lane))) return null;
-  const link = `[${String(t.title ?? t.id).replace(/[[\]]/g, "")}](${t.id})`;
-  const line = asking(e.lane) ? `needs you: ${link}, ${e.reason}` : asking(was) ? `no longer asking you: ${link}` : null;
-  if (!line) return null;
-  const key = `asks-${createHash("sha256").update(`${e.threadId}:${e.lane}:${e.basis}`).digest("hex").slice(0, 32)}`;
-  return { schedule: "dash", text: `@${coordinator} dash: ${line}`, clientId: key };
-}
-
-// The `new` answers of a pass go to main in one notice per project (deduped
-// by the set of threads): not just these, every unfiled thread in their
-// projects, so main groups a project once instead of 30 at a time. Which
-// threads are unfiled is read from the hub now, after this pass's filing,
-// not from the pass's snapshot: another pass may have filed some meanwhile.
-// A failed read or post is logged; the threads are still unfiled, so they're
-// asked again.
-async function noticeNewPaths(hub, fresh, log) {
-  if (!fresh.length || !hub.post) return;
-  let snap;
-  try {
-    snap = await hub.snapshot();
-  } catch (err) {
-    return log?.warn?.(`dash: new-path notice skipped, no snapshot: ${err?.message ?? err}`);
-  }
-  const all = unfiledIn(snap, new Set(fresh.map((t) => t.tags?.project ?? "")));
-  for (const project of new Set(all.map((t) => t.tags?.project ?? ""))) {
-    const threads = all.filter((t) => (t.tags?.project ?? "") === project);
-    const key = `paths-new-${createHash("sha256").update(threads.map((t) => t.id).sort().join(",")).digest("hex").slice(0, 32)}`;
-    await hub.post("dash", newPathNotice(threads, snap), key).catch((err) => log?.warn?.(`dash: new-path notice failed: ${err?.message ?? err}`));
-  }
-}
-
-// One classifier pass. Every target is decided at once, and each is written
-// (with its "asks you" notice) the moment its answer is in, so a thread's
-// entry never waits on another thread's call: the pass takes as long as its
-// slowest call (decideThread's timeoutMs), whatever the backlog, and the
-// thread whose turn just ended shows within its own call. Path picks are
-// filed after the pass (`filing`, see filePaths), outside it. Each entry
-// carries the basis its target was classified from, so a thread that moved
-// on meanwhile is looked at again next pass. The entry's reason is the lane's
-// one-line why, replaced with every classification.
-// Importance a human set (entry.importanceBy) is never sent. classifiedAt is
-// stamped when there was nothing to do or every target was written; a
-// skipped target or a failed write leaves it, so "never classified" and
-// "checked" stay distinct. Returns { written, filing }: `filing` settles when
-// the pass's path maintenance has (the schedule doesn't wait for it).
-/** @param {any} hub @param {{ classify?: (target: any, snap: any) => Promise<any>, max?: number, snap?: any, log?: any }} [opts] */
-export async function runClassify(hub, { classify = async () => null, max = CLASSIFY_MAX, snap = null, log = console } = {}) {
-  const s = snap ?? (await hub.snapshot());
-  const targets = classifyTargets(s, { max });
-  const humans = new Set((s?.humans ?? []).map((h) => h.name));
-  if (targets.length) log?.log?.(`dash: classifying ${targets.length} thread${targets.length === 1 ? "" : "s"}: ${targets.map((t) => t.id).join(", ")}`);
-  const picks = [];
-  const one = async (t) => {
-    const d = await classify(t, s);
-    if (!d) return 0;
-    if (d.path) picks.push([t, d.path]);
-    const own = humans.has(t.entry?.importanceBy);
-    const entry = { threadId: t.id, ...(own || d.importance === undefined ? {} : { importance: d.importance }), lane: d.lane, reason: d.reason, basis: t.basis };
-    const notice = asksNotice(entry, t, coordinatorOf(s?.agents));
-    try {
-      await (notice ? hub.dashEntries([entry], [], notice) : hub.dashEntries([entry]));
-      return 1;
-    } catch (err) {
-      log?.warn?.(`dash: classify write for ${t.id} failed: ${err?.message ?? err}`);
-      return 0;
-    }
-  };
-  const written = (await Promise.all(targets.map(one))).reduce((a, b) => a + b, 0);
-  if (written === targets.length) await hub.dashClassified?.().catch((err) => log?.warn?.(`dash: classifiedAt not stamped: ${err?.message ?? err}`));
-  return { written, filing: filePaths(hub, picks, log) };
-}
-
-// Path maintenance after a pass, never part of it: the pass is over when its
-// entries are written and classifiedAt stamped, so the next one (a fresh
-// question) never waits on a filing request. Files each path pick, then sends the pass's `new` answers.
-// Never rejects; a failure is logged and the thread, still unfiled, is
-// asked again. A pass that starts meanwhile may ask the same thread again:
-// a second filing is refused (already filed), and the notice reads the hub's
-// state when it's built, so it never names a thread filed meanwhile.
-async function filePaths(hub, picks, log) {
-  await Promise.all(picks.filter(([, path]) => path !== NEW_PATH).map(([t, path]) => hub.fileThread?.(t.id, path).catch((err) => log?.warn?.(`dash: file ${t.id} into ${path} failed: ${err?.message ?? err}`))));
-  await noticeNewPaths(hub, picks.filter(([, path]) => path === NEW_PATH).map(([t]) => t), log);
-}
-
-// One pass at a time in this bot process, and none lost: the schedule runs
-// its pass through this. The hub can't know when a pass ends (a dispatch it
-// gave up on keeps running in eve; aborting the request doesn't stop it),
-// so the process that runs passes is the one that serializes them. A
-// dispatch that arrives during a pass returns at once and asks that pass for
-// one more round when it ends, which reads a fresh snapshot. The flag lives
-// on globalThis, which eve keeps across dispatches, and goes with the process.
-const RUNNING = Symbol.for("hub.dash.classify.running");
-/** @param {() => Promise<unknown>} pass */
-export async function classifyPass(pass) {
-  const g = /** @type {any} */ (globalThis);
-  if (g[RUNNING]) {
-    g[RUNNING].again = true;
-    return;
-  }
-  const run = (g[RUNNING] = { again: true });
-  try {
-    while (run.again) {
-      run.again = false;
-      await pass();
-    }
-  } finally {
-    g[RUNNING] = undefined;
-  }
-}

package/schedules/dash-decisions.mjs

@@ -1,21 +0,0 @@
-// 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

@@ -1,57 +0,0 @@
-// The one check behind main's Dash (schedules/dash.ts), every 8 minutes and
-// again as soon as a bot's turn ends (registry/server.mjs, schedules.runSoon):
-//
-//   threads  runClassify (./dash-classify.mjs): one model call per thread whose
-//            facts changed since its entry was written, busy or idle; none for a
-//            thread that hasn't changed. Every run.
-//   PRs      runDash (./dash-run.mjs): one chunked GitHub query for the human's
-//            PRs, what Dash items wait on and the PRs reviews are about. No model.
-//   tracks   runTracks (./track-summaries.mjs): one model call per track with a
-//            thread that has news; none for a track whose threads haven't moved.
-//
-// The PRs and the tracks run once per cron slot (*/8: the minute rounded down
-// to a multiple of 8): when the pass's last full attempt (pass.fullAt in the
-// schedule's state, written before the GitHub call, so an outage doesn't
-// reopen the gate) is older than the current slot. A turn end inside a slot
-// 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;
-// */8 restarts every hour: :56 is followed by :00.
-const slotOf = (ms) => {
-  const min = Math.floor(ms / 60_000);
-  return (min - ((min % 60) % SLOT_MIN)) * 60_000;
-};
-
-/** @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);
-  await part("threads", () => runClassify(hub, { classify, log }));
-  if (!full) return;
-  try {
-    await hub.commit("dash", { state: { ...state, pass: { ...state?.pass, fullAt: now } } }, []);
-  } catch (err) {
-    log?.warn?.(`dash pass: full check skipped, its stamp wasn't saved: ${err?.message ?? err}`);
-    return;
-  }
-  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
-// in meanwhile asks for one more round when it ends.
-export const dashPass = (hub, options) => classifyPass(() => runPass(hub, options));

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() })) });