eve-hub 0.6.70 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.7.1
+
+### Patch Changes
+
+- A subagent's spawn call stays running through the parent's next step until its task settles, so a working card keeps its subagent orbs.
+
+## 0.7.0
+
+### Minor Changes
+
+- main's compact schedule is gone: the hub's sweep compacts a session whose turn ended at 130k+ input tokens. The kit no longer has `schedules/compact` or `hub.compact`.
+
 ## 0.6.70
 
 ### Patch Changes

package/kit-modules.json

@@ -10,7 +10,6 @@
   "memory/bot",
   "memory/team",
   "memory/workspace",
-  "schedules/compact",
   "schedules/dash",
   "schedules/prune",
   "skills/onboarding-profile",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.6.70",
+  "version": "0.7.1",
   "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/hub.d.mts

@@ -14,7 +14,6 @@ export type Hub = {
   commit(id: string, withState: { state?: unknown }, posts: Post[]): Promise<unknown>;
   post(id: string, text: string, key?: string): Promise<unknown>;
   track<T>(id: string, fn: () => Promise<T>): Promise<T | undefined>;
-  compact(threadId: string, bot: string, by: string, report?: { trigger?: string; reportTo?: string }): Promise<{ status: number; ok: boolean; body: unknown }>;
   dashChecked(prFacts?: Record<string, { head: string | null; ci: string }>): Promise<Ok & { checkedAt: string }>;
   setSummary(path: string, text: string): Promise<unknown>;
   dashClassified(): Promise<Ok & { classifiedAt: string }>;

package/schedules/hub.mjs

@@ -61,9 +61,6 @@ export function createHub({ base = registryBase(), agent = "main", fetchImpl = f
     },
     // A one-off post outside a run (runOnce commits through `commit`).
     post: (id, text, key) => must(`/api/threads/${encodeURIComponent(threadOf(id))}/messages`, { method: "POST", body: JSON.stringify({ author: "system", text, ...(key ? { clientId: key } : {}) }) }),
-    // With `report` ({ trigger, reportTo: "<bot>/<schedule>" }) the hub posts
-    // this compaction's report lines into that schedule's thread itself.
-    compact: (threadId, bot, by, report = {}) => call(`/api/threads/${encodeURIComponent(threadId)}/compact`, { method: "POST", body: JSON.stringify({ agent: bot, by, ...report }) }),
     // 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: (prFacts = {}) => must("/api/dash/checked", { method: "POST", body: JSON.stringify({ by: agent, prFacts }) }),

package/stubs.mjs

@@ -38,7 +38,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/compact.ts": ["Every 10 minutes: compacts idle sessions once their prompt cache has gone cold, reported in sch-main-compact."],
   "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."],
 };
@@ -51,12 +50,10 @@ 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 paths of attach_image/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 compact and dash schedules stay: off the hub's machine compact finds no session to compact
-// (hosted sessions carry no last-model-call time), and dash has no PR data (its lookup runs `gh`).
+// 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",
   "hooks/mention-gate.ts",
-  "schedules/compact.ts",
   "schedules/dash.ts",
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",

package/world.mjs

@@ -10925,7 +10925,7 @@ function reduceActivity(turn, { type, data = {} }, at, onCutOff) {
   changed = trackTaskEvent(turn.card, { type, data }, new Date(at).toISOString()) || changed;
   if (changed) turn.taskCard = taskCardView(turn.card);
   if (type === "step.started") {
-    for (const tool of turn.tools) if (tool.status === "running" && tool.step !== void 0 && tool.step <= data.stepIndex) {
+    for (const tool of turn.tools) if (!tool.task && tool.status === "running" && tool.step !== void 0 && tool.step <= data.stepIndex) {
       tool.status = "interrupted";
       changed = true;
     }
@@ -12304,14 +12304,14 @@ function codePointLength(str) {
   const units = str.length;
   if (!highSurrogate.test(str))
     return units;
-  let count2 = units;
+  let count = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count2--;
+      count--;
       i++;
     }
   }
-  return count2;
+  return count;
 }
 function getLengthableOrigin(input2) {
   if (Array.isArray(input2))
@@ -16694,8 +16694,8 @@ function az_default() {
 }
 
 // ../../hosted-hub/node_modules/zod/v4/locales/be.js
-function getBelarusianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getBelarusianPlural(count, one, few, many) {
+  const absCount = Math.abs(count);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -19342,8 +19342,8 @@ function hu_default() {
 }
 
 // ../../hosted-hub/node_modules/zod/v4/locales/hy.js
-function getArmenianPlural(count2, one, many) {
-  return Math.abs(count2) === 1 ? one : many;
+function getArmenianPlural(count, one, many) {
+  return Math.abs(count) === 1 ? one : many;
 }
 function withDefiniteArticle(word) {
   if (!word)
@@ -22081,8 +22081,8 @@ function ro_default() {
 }
 
 // ../../hosted-hub/node_modules/zod/v4/locales/ru.js
-function getRussianPlural(count2, one, few, many) {
-  const absCount = Math.abs(count2);
+function getRussianPlural(count, one, few, many) {
+  const absCount = Math.abs(count);
   const lastDigit = absCount % 10;
   const lastTwoDigits = absCount % 100;
   if (lastTwoDigits >= 11 && lastTwoDigits <= 19) {
@@ -30846,11 +30846,11 @@ var PARTICIPANTS = (thread, except = "''") => `SELECT b.name AS bot FROM bots b,
 var NOT_IN_BEFORE = `NOT EXISTS (SELECT 1 FROM (${PARTICIPANTS("?", "?")}) WHERE bot = ?)`;
 var hasJoins = (threadId2) => !threadId2.startsWith("dm-") && !threadId2.startsWith("sch-");
 function routingStatements(messageId2, threadId2, bots, now, { by, joins }, held = {}, steer = false) {
-  const quiet2 = !joins || !hasJoins(threadId2);
+  const quiet = !joins || !hasJoins(threadId2);
   const fresh = "EXISTS (SELECT 1 FROM messages WHERE id = ?)";
   return [
     ...bots.flatMap((bot) => [
-      ...quiet2 ? [] : eventStatements(
+      ...quiet ? [] : eventStatements(
         threadId2,
         { kind: "join", agent: bot, by, message: messageId2 },
         `@${bot} joined${by !== bot ? ` (added by @${by})` : ""}`,
@@ -31113,44 +31113,30 @@ var MOVES = Object.freeze({
 });
 var VERDICTS = Object.freeze(["ship", "fix-first", "rethink"]);
 
-// ../../hosted-hub/src/domain/cron.mjs
-var MINUTE = 6e4;
-var CATCH_UP_MS = 7 * 24 * 60 * MINUTE;
-
-// ../../hosted-hub/src/store/schedules.ts
-var scheduleThreadId = (agent, id) => `sch-${agent}-${id.replaceAll("/", ".")}`;
-var Info = external_exports.object({ schedules: external_exports.array(external_exports.object({ name: external_exports.string().min(1), cron: external_exports.string().min(1), hasRun: external_exports.boolean() })) });
-
-// ../../hosted-hub/src/domain/compact-report.mjs
-var quiet = (text) => String(text).replace(/@/g, "\uFF20");
-var count = (n) => typeof n === "number" ? n.toLocaleString("en-US") : "?";
-var link = (thread, id) => `[${quiet(String(thread?.title ?? id).replace(/[[\]]/g, ""))}](${id})`;
-var nextTry = (agent) => `next try: after ${quiet(agent)}'s next turn there, once idle 10+ min (or at 40 turns) with its prompt cache gone cold`;
-var compactedLine = (r, thread) => `compacted: ${quiet(r.agent)} on ${link(thread, r.threadId)} \xB7 ${quiet(r.trigger)} \xB7 ${count(r.before)} input tokens before`;
-var afterLine = (r, thread, after) => `after compaction: ${quiet(r.agent)} on ${link(thread, r.threadId)} \xB7 ${count(r.before)} \u2192 ${count(after)} input tokens`;
-var failureLine = (r, thread, reason) => `compact failed: ${quiet(r.agent)} on ${link(thread, r.threadId)} \xB7 ${quiet(r.trigger)} \xB7 ${quiet(reason)}; ${nextTry(r.agent)}`;
-
 // ../../hosted-hub/src/store/compactions.ts
 var ASKED = `(c.attempt_at IS NOT NULL AND c.attempt_at > COALESCE(c.settled_at, 0))`;
 var k = (tokens) => `CAST((${tokens} + 500) / 1000 AS INTEGER) || 'k'`;
 var compactedText = (after) => `'Context compacted' || CASE WHEN c.before_tokens IS NULL THEN ''
   WHEN ${after} IS NULL THEN ' at ' || ${k("c.before_tokens")} || ' input tokens'
   ELSE ': ' || ${k("c.before_tokens")} || ' \u2192 ' || ${k(after)} || ' input tokens' END`;
-function compactionStatements(type, session, event, at, messageId2, report = null) {
+var COMPACT_WINDOW_MS = 10 * 6e4;
+var COMPACTABLE_READ = `SELECT s.id, s.thread_id, s.bot, u.input_tokens FROM usage_steps u JOIN sessions s ON s.id = u.session_id
+  WHERE u.at > ? AND u.at <= ? AND u.input_tokens >= ? AND s.ended_at IS NULL
+    AND (u.at, u.sequence, u.step_index) = (SELECT at, sequence, step_index FROM usage_steps WHERE session_id = u.session_id ORDER BY at DESC, sequence DESC, step_index DESC LIMIT 1)
+    AND NOT EXISTS (SELECT 1 FROM turns t WHERE t.session_id = s.id AND t.status IN ${OPEN_TURN_STATUSES})
+    AND NOT EXISTS (SELECT 1 FROM compactions c WHERE c.session_id = s.id AND MAX(COALESCE(c.completed_at, 0), COALESCE(c.attempt_at, 0)) >= u.at)`;
+function compactionStatements(type, session, event, at, messageId2) {
   const before = `COALESCE(?, (SELECT input_tokens FROM usage_steps WHERE session_id = ? ORDER BY at DESC, sequence DESC, step_index DESC LIMIT 1))`;
   if (type === "compaction.requested")
     return [s(
-      `INSERT INTO compactions (session_id, before_tokens) VALUES (?, ${before}) ON CONFLICT (session_id) DO UPDATE SET before_tokens = excluded.before_tokens,
-        report_phase = CASE WHEN report_phase = 'asked' THEN 'requested' ELSE report_phase END`,
+      `INSERT INTO compactions (session_id, before_tokens) VALUES (?, ${before}) ON CONFLICT (session_id) DO UPDATE SET before_tokens = excluded.before_tokens`,
       session.id,
       typeof event.usageInputTokens === "number" ? event.usageInputTokens : null,
       session.id
     )];
   if (type === "session.waiting")
     return [
-      // eve took the request and went idle with no checkpoint: it kept the history (the reason is in the bot's log). A
-      // session.waiting from before eve took the request (the previous turn's, folded late) is not that: only 'requested' counts.
-      ...reportLine(report, session, at, `${messageId2}:waiting`, (r) => failureLine(...r, `eve ended it without a checkpoint and kept the history (the reason is in ${session.bot}'s log)`), `report_phase = 'requested'`, null),
+      // eve took the request and went idle with no checkpoint: it kept the history (the reason is in the bot's log).
       s("UPDATE compactions SET settled_at = ? WHERE session_id = ? AND attempt_at IS NOT NULL AND attempt_at > COALESCE(settled_at, 0)", at, session.id)
     ];
   return [
@@ -31172,23 +31158,7 @@ function compactionStatements(type, session, event, at, messageId2, report = nul
       session.thread,
       session.bot,
       messageId2
-    ),
-    ...reportLine(report, session, at, `${messageId2}:completed`, (r) => compactedLine(...r), `report_phase IN ('asked', 'requested', 'unanswered')`, "compacted")
-  ];
-}
-var reportThread = (to) => {
-  const [bot, ...id] = to.split("/");
-  return scheduleThreadId(bot, id.join("/"));
-};
-var lineOf = (report, session) => [{ agent: session.bot, threadId: session.thread, trigger: report.trigger, before: report.before }, { title: report.title }];
-function reportLine(report, session, at, id, text, when, next) {
-  if (!report) return [];
-  const thread = reportThread(report.to), rowId = derivedMessageId(id, "report"), has = `EXISTS (SELECT 1 FROM compactions WHERE session_id = ? AND ${when})`;
-  return [
-    s(`INSERT INTO log (thread_id,type,data,at) SELECT ?, 'thread.created', ?, ? WHERE ${has} AND NOT EXISTS (SELECT 1 FROM threads WHERE id = ?)`, thread, JSON.stringify({ threadId: thread }), at, session.id, thread),
-    s(`INSERT OR IGNORE INTO threads (id,title,created_at) SELECT ?, ?, ? WHERE ${has}`, thread, report.to, at, session.id),
-    ...eventStatements(thread, { kind: "compaction-report", agent: session.bot }, text(lineOf(report, session)), at, rowId, { sql: has, args: [session.id] }),
-    s(`UPDATE compactions SET report_phase = ? WHERE session_id = ? AND ${when}`, next, session.id)
+    )
   ];
 }
 function compactedSizeStatements(sessionId2, inputTokens) {
@@ -31199,7 +31169,6 @@ function compactedSizeStatements(sessionId2, inputTokens) {
     s(`UPDATE compactions SET after_tokens = ? WHERE session_id = ? AND ${waiting("")}`, inputTokens, sessionId2)
   ];
 }
-var reportAfterStatements = (report, session, inputTokens, at, id) => reportLine(report, session, at, `${id}:after`, ([r, thread]) => afterLine(r, thread, inputTokens), `report_phase = 'compacted' AND completed_at IS NOT NULL AND after_tokens IS NULL`, null);
 
 // ../../node_modules/.pnpm/zod@4.5.4/node_modules/zod/v4/core/util.js
 var util_exports2 = {};
@@ -31846,14 +31815,14 @@ function codePointLength2(str) {
   const units = str.length;
   if (!highSurrogate2.test(str))
     return units;
-  let count2 = units;
+  let count = units;
   for (let i = 0; i < units - 1; i++) {
     if ((str.charCodeAt(i) & 64512) === 55296 && (str.charCodeAt(i + 1) & 64512) === 56320) {
-      count2--;
+      count--;
       i++;
     }
   }
-  return count2;
+  return count;
 }
 function getLengthableOrigin2(input2) {
   if (Array.isArray(input2))
@@ -37924,9 +37893,7 @@ var FOLD_STATE_SQL = `SELECT * FROM (WITH sess AS (SELECT * FROM sessions WHERE
     (SELECT json_object('person', person, 'names', json(names)) FROM human_notify) AS notify,
     (SELECT json_object('status', t.status, 'id', t.id, 'text', t.reply_text, 'lastStep', json(t.last_step), 'activity', json(t.activity),
       'trigger', ${triggerOf("t")}) FROM turns t WHERE t.session_id = s.id AND t.status IN ${OPEN_TURN_STATUSES}
-      ORDER BY t.started_at DESC LIMIT 1) AS open_turn,
-    (SELECT json_object('to', c.report_to, 'trigger', c.report_trigger, 'before', c.report_before, 'title', (SELECT title FROM threads WHERE id = s.thread_id))
-      FROM compactions c WHERE c.session_id = s.id AND c.report_to IS NOT NULL) AS report
+      ORDER BY t.started_at DESC LIMIT 1) AS open_turn
   FROM sess s LEFT JOIN session_folds f ON f.session_id = s.id)`;
 var TURN_END_SQL = `SELECT * FROM (WITH sess AS (SELECT * FROM sessions WHERE id = ?),
   open_turn AS (SELECT t.id FROM turns t WHERE t.session_id = (SELECT id FROM sess) AND t.status IN ${OPEN_TURN_STATUSES} ORDER BY t.started_at DESC LIMIT 1),
@@ -37958,8 +37925,7 @@ function foldState(row) {
     lastPost: row.last_post == null ? null : String(row.last_post),
     notify: row.notify ? JSON.parse(String(row.notify)) : null,
     foldedIndex: Number(row.folded_index),
-    open: row.open_turn ? JSON.parse(String(row.open_turn)) : null,
-    report: row.report ? JSON.parse(String(row.report)) : null
+    open: row.open_turn ? JSON.parse(String(row.open_turn)) : null
   };
 }
 var REVOKED_TURN = `EXISTS (SELECT 1 FROM turn_deliveries td JOIN deliveries d ON d.id = td.delivery_id
@@ -38017,7 +37983,7 @@ function fold(state, chunks, now = Date.now()) {
         log("request.updated", { requestIds: (data.resolutions ?? []).map((r) => r.requestId) });
       }
       if (event.type === "compaction.requested" || event.type === "compaction.completed" || event.type === "session.waiting")
-        stmts.push(...compactionStatements(event.type, session, data, at, derivedMessageId(session.id, index, eventIndex), state.report));
+        stmts.push(...compactionStatements(event.type, session, data, at, derivedMessageId(session.id, index, eventIndex)));
       if (event.type === "turn.started") {
         if (!data.turnId) throw new Error("turn.started must name eve turnId");
         flush();
@@ -38079,7 +38045,7 @@ function fold(state, chunks, now = Date.now()) {
         case "step.completed": {
           if (data.sequence === void 0 || data.stepIndex === void 0) break;
           stmts.push(s(`${STEP_INSERT} VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, (SELECT step_model FROM sessions WHERE id = ?))`, ...stepValues(session.id, { sequence: data.sequence, stepIndex: data.stepIndex, at: new Date(at).toISOString(), usage: data.usage ?? {} }), open3.id, session.id));
-          if (typeof data.usage?.inputTokens === "number") stmts.push(...reportAfterStatements(state.report, session, data.usage.inputTokens, at, derivedMessageId(session.id, index, eventIndex)), ...compactedSizeStatements(session.id, data.usage.inputTokens));
+          if (typeof data.usage?.inputTokens === "number") stmts.push(...compactedSizeStatements(session.id, data.usage.inputTokens));
           break;
         }
         case "message.appended": {

package/schedules/compact.d.ts

@@ -1,5 +0,0 @@
-declare const _default: {
-    cron: string;
-    run(): Promise<void>;
-};
-export default _default;

package/schedules/compact.js

@@ -1,18 +0,0 @@
-// main's compact schedule: every 10 minutes, compacts idle sessions whose
-// prompt cache has gone cold (last model call past their model's cache TTL
-// + 1 min, measured per model by the hub; a warm one never is) once idle at
-// least 10 min with >= 100k input tokens, or after 40 turns, through the hub
-// (POST /api/threads/:id/compact), which refuses if a
-// turn or a delivery got there first. Reports each compaction, its before →
-// after tokens and any failure in sch-main-compact without tagging anyone,
-// so main is never woken. Rules in ./rules.mjs, the run in ./run-compact.mjs.
-import { defineSchedule } from "eve/schedules";
-import { createHub } from "./hub.mjs";
-import { runCompact } from "./run-compact.mjs";
-export default defineSchedule({
-    cron: "*/10 * * * *",
-    async run() {
-        const hub = createHub();
-        await hub.track("compact", () => runCompact(hub));
-    },
-});

package/schedules/rules.mjs

@@ -1,132 +0,0 @@
-// The decisions behind main's compact schedule (schedules/compact.ts), pure:
-// each takes the registry's /api/state snapshot (`snap`), the schedule's
-// and the time. No I/O here; schedules/hub.mjs does that. The report lines
-// for the compactions themselves are the hub's (hosted-hub/src/domain/compact-report.mjs).
-//
-// Plain JS on purpose: the schedule (TypeScript, bundled by eve) and the
-// tests (plain node) import the same module.
-
-const MIN = 60_000;
-
-const parse = (iso) => {
-  const ms = Date.parse(iso ?? "");
-  return Number.isFinite(ms) ? ms : null;
-};
-const isBusy = (status) => status === "working" || status === "waiting";
-const clock = (ms) => {
-  const s = Math.max(0, Math.floor(ms / 1000));
-  return `${Math.floor(s / 60)}m${String(s % 60).padStart(2, "0")}s`;
-};
-const count = (n) => (typeof n === "number" ? n.toLocaleString("en-US") : "?");
-// The report never tags anyone: an "@" from a title or an error can't
-// become a mention (and wake a bot).
-const quiet = (text) => String(text).replace(/@/g, "＠");
-const link = (threads, id) => `[${quiet(String(threads?.[id]?.title ?? id).replace(/[[\]]/g, ""))}](${id})`;
-
-// ---------------------------------------------------------------------------
-// How long a model's prompt cache stays warm after a model call.
-//
-// The Gateway sends Anthropic models `caching: "auto"` with no `ttl`: 5 min,
-// reset by every read. OpenAI keeps prefixes best-effort, longer (measured
-// warm past 10 min, cold by 30-60). Anything else: assume Anthropic's 5 min.
-// Once a model has `minSamples` observations (the hub's `cacheGaps[model]`:
-// [gapMs, hitRatio] for model calls >= 1 min after the session's previous
-// one), its TTL is measured instead, from the gap buckets with at least
-// `minBucketSamples` samples (the rest say nothing), each warm if its median
-// hit ratio is >= 0.5:
-//   - the cache is warm up to at least the top of the longest warm bucket;
-//   - it has expired by the bottom of the first cold bucket above that (a
-//     shorter-gap miss never overrides a longer-gap hit);
-//   - the provider default, kept within those bounds. So warm samples alone
-//     can extend the TTL but never shorten it: only a cold bucket can.
-// The median, not the mean: a cold call on a long shared prefix (system
-// prompt, tools) still reads part of it.
-export const CACHE_TTL_DEFAULTS = Object.freeze({ anthropic: 5 * MIN, openai: 30 * MIN, unknown: 5 * MIN });
-export const CACHE_GAP_EDGES = Object.freeze([1, 3, 5, 10, 30, 60].map((m) => m * MIN));
-export const CACHE_TTL_OPTIONS = Object.freeze({ minSamples: 20, minBucketSamples: 3, warmRatio: 0.5 });
-
-const providerOf = (modelId) => String(modelId ?? "").split("/")[0];
-export const defaultCacheTtlMs = (modelId, defaults = CACHE_TTL_DEFAULTS) => defaults[providerOf(modelId)] ?? defaults.unknown;
-const median = (xs) => {
-  const s = [...xs].sort((a, b) => a - b);
-  const m = s.length >> 1;
-  return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
-};
-
-// { ttlMs, measured, samples }
-export function cacheTtl(modelId, samples, options = {}) {
-  const { minSamples, minBucketSamples, warmRatio, defaults = CACHE_TTL_DEFAULTS } = { ...CACHE_TTL_OPTIONS, ...options };
-  const fallback = { ttlMs: defaultCacheTtlMs(modelId, defaults), measured: false, samples: samples?.length ?? 0 };
-  if (!Array.isArray(samples) || samples.length < minSamples) return fallback;
-  let warmTop = 0; // warm at least this long
-  const cold = []; // bottoms of the cold buckets
-  for (let i = 0; i < CACHE_GAP_EDGES.length; i++) {
-    const lo = CACHE_GAP_EDGES[i];
-    const hi = CACHE_GAP_EDGES[i + 1] ?? Infinity;
-    const ratios = samples.filter(([gap, ratio]) => gap >= lo && gap < hi && Number.isFinite(ratio)).map(([, ratio]) => ratio);
-    if (ratios.length < minBucketSamples) continue;
-    if (median(ratios) >= warmRatio) warmTop = Math.max(warmTop, Number.isFinite(hi) ? hi : lo);
-    else cold.push(lo);
-  }
-  const coldAbove = cold.filter((lo) => lo >= warmTop);
-  const expiredBy = coldAbove.length ? Math.min(...coldAbove) : Infinity; // cold from here on
-  if (warmTop === 0 && cold.length === 0) return fallback;
-  const ttlMs = Math.min(Math.max(fallback.ttlMs, warmTop), expiredBy);
-  return { ttlMs, measured: true, samples: samples.length };
-}
-
-const span = (ms) => (ms % MIN === 0 ? `${ms / MIN}m` : clock(ms));
-
-// ---------------------------------------------------------------------------
-// Which sessions to compact: only those whose prompt cache has gone cold.
-//
-// eve's compaction call doesn't reuse the session's cached prefix (its own
-// system prompt, no tools, the transcript re-rendered), so it pays full input
-// price warm or cold. A warm session's next turn reads its context at the
-// cached rate, so compacting it costs more than it saves; a cold one's next
-// turn re-writes the whole context anyway, so a smaller one is cheaper.
-//
-// An idle session is compacted only once its latest model call is more than
-// its model's cache TTL (cacheTtl, from the hub's cacheGaps) plus
-// `coldMarginMs` ago (a warm one never is), and either
-//   - it has been idle at least `idleMinMs` and its latest model call was at
-//     least `minTokens` input tokens. Per (bot, thread) session: `lastEventAt`
-//     moves only on that session's own eve events, so another bot working in
-//     the same thread doesn't hold it back; or
-//   - it has had `maxTurns` turns since its last compaction and has been idle
-//     at least `turnsIdleMs`;
-// and it has made a model call since its last compaction, or since the last
-// attempt at one (a failed one isn't retried until the session has moved on;
-// a compacted one doesn't trigger again on later ticks until its next turn).
-// Only bots whose process is up. The hub refuses (409) if a turn or a
-// delivery got there first.
-export const COMPACT_DEFAULTS = Object.freeze({ idleMinMs: 10 * MIN, minTokens: 100_000, maxTurns: 40, turnsIdleMs: 1 * MIN, coldMarginMs: 1 * MIN });
-
-export function compactCandidates(snap, nowMs, options = {}) {
-  const { idleMinMs, minTokens, maxTurns, turnsIdleMs, coldMarginMs, ttl: ttlOptions } = { ...COMPACT_DEFAULTS, ...options };
-  const up = new Map((snap?.agents ?? []).map((a) => [a.name, !a.process || a.process.status === "up"]));
-  const out = [];
-  for (const v of Object.values(snap?.sessions ?? {})) {
-    if (!v.sessionId || !up.get(v.agent) || v.status !== "idle" || v.compacting || v.suspect) continue;
-    const thread = snap.threads?.[v.threadId];
-    if (!thread || thread.archived || isBusy(thread.status?.[v.agent])) continue;
-    const lastStep = parse(v.lastStepAt);
-    const lastTry = Math.max(parse(v.compactedAt) ?? 0, parse(v.compactAttemptAt) ?? 0);
-    if (lastStep === null || lastStep <= lastTry) continue;
-    const { ttlMs } = cacheTtl(v.lastModelId, snap.cacheGaps?.[v.lastModelId], ttlOptions);
-    const sinceStepMs = nowMs - lastStep;
-    if (sinceStepMs < ttlMs + coldMarginMs) continue; // still warm: never compacted
-    const idleMs = nowMs - (parse(v.lastEventAt) ?? nowMs);
-    const cold = `cold: idle ${clock(sinceStepMs)} > ttl ${span(ttlMs)}`;
-    const turns = (v.sessionTurns ?? 0) - (v.turnsAtCompaction ?? 0);
-    let trigger = null;
-    if (idleMs >= idleMinMs && (v.lastInputTokens ?? 0) >= minTokens) trigger = `${cold} · ${Math.round(v.lastInputTokens / 1000)}k tokens`;
-    else if (turns >= maxTurns && idleMs >= turnsIdleMs) trigger = `${cold} · ${turns} turns`;
-    if (trigger) out.push({ threadId: v.threadId, agent: v.agent, sessionId: v.sessionId, trigger, before: v.lastInputTokens ?? null });
-  }
-  return out;
-}
-
-// A failure the hub didn't report itself (it refused before asking eve).
-export const failureLine = (c, threads, reason) =>
-  `compact failed: ${quiet(c.agent)} on ${link(threads, c.threadId)} · ${c.trigger} · ${quiet(reason)}; next try: after ${quiet(c.agent)}'s next turn there, once idle 10+ min (or at 40 turns) with its prompt cache gone cold`;

package/schedules/run-compact.mjs

@@ -1,25 +0,0 @@
-// One run of main's compact schedule (schedules/compact.ts): ask the hub to
-// compact each candidate, with the report going to sch-main-compact. The
-// hub records each attempt durably before it asks eve and posts the
-// report's lines itself (compacted, before → after, failures), so this run
-// keeps no state. Only a refusal the hub didn't report (it never got as far
-// as asking eve) gets a line from here.
-import { compactCandidates, failureLine } from "./rules.mjs";
-
-export async function runCompact(hub, { now = Date.now(), options } = {}) {
-  const snap = await hub.snapshot();
-  const lines = [];
-  for (const c of compactCandidates(snap, now, options)) {
-    let r;
-    try {
-      r = await hub.compact(c.threadId, c.agent, "schedule main/compact", { trigger: c.trigger, reportTo: "main/compact" });
-    } catch (error) {
-      r = { status: 0, body: { error: String(error?.message ?? error) } };
-    }
-    if (r.status === 202 || r.status === 409 || r.body?.reported) continue; // 409: a turn or a delivery got there first
-    const line = failureLine(c, snap.threads, `the hub refused: ${r.status || "unreachable"} ${r.body?.error ?? r.body?.status ?? ""}`.trim());
-    lines.push(line);
-    await hub.post("compact", line).catch(() => {});
-  }
-  return { lines };
-}