@centralu/darwin-arm64 0.1.0-beta.35 → 0.1.0-beta.36

package/Centralu.app/Contents/Resources/content/host/main.mjs

@@ -43055,7 +43055,7 @@ import { mkdirSync as mkdirSync19, writeSync as writeSync3 } from "node:fs";
 
 // packages/protocol/src/brand.ts
 var APP_NAME = "Centralu";
-var APP_VERSION = "0.1.0-beta.35";
+var APP_VERSION = "0.1.0-beta.36";
 var APP_SLUG = "centralu";
 var CLIENT_INFO = { name: APP_SLUG, title: APP_NAME, version: APP_VERSION };
 var DATA_DIR = ".centralu";
@@ -58787,6 +58787,13 @@ var RequestInput = external_exports.object({
    * when the tool does not say, or the request wrote nothing.
    */
   cacheTtl: external_exports.enum(["5m", "1h"]).optional(),
+  /**
+   * Of `cacheCreationTokens`, what the API said stays cached an hour and five minutes (Claude's `cache_creation` split, #1492):
+   * the two are priced apart (docs/agent-host.md §6.1), so the weighting of writes needs them, not only which one the request had
+   * most of. Absent when the tool did not split its writes; the part that is in neither is priced as a five-minute write.
+   */
+  cacheWrite1hTokens: external_exports.number().optional(),
+  cacheWrite5mTokens: external_exports.number().optional(),
   /** The model that served this request, as the tool reported it (Claude's `message.model`); absent when it does not say (usage history, §6.2) */
   model: external_exports.string().optional()
 });
@@ -58813,7 +58820,13 @@ var CacheSessionStats = external_exports.object({
   cacheCreationTokens: external_exports.number(),
   rebuilds: external_exports.number(),
   /** The rebuilds by their likely cause (`RebuildCause`); absent from a host that predates it */
-  rebuildCauses: external_exports.record(external_exports.string(), external_exports.number()).optional()
+  rebuildCauses: external_exports.record(external_exports.string(), external_exports.number()).optional(),
+  /**
+   * What the rebuilds wrote to the cache, in tokens (#1492): the sum of the cache writes of the requests counted as rebuilds, so the
+   * steady writes every new message needs are not in it. For a tool that does not report writes (Codex) the input it did not read
+   * from the cache stands in. Absent from a host that predates it, and from hours an earlier build stored.
+   */
+  rebuildTokens: external_exports.number().optional()
 });
 var CacheWindowStats = external_exports.object({
   /** `5h`, `today` */
@@ -58830,6 +58843,17 @@ var CacheWindowStats = external_exports.object({
   rebuilds: external_exports.number(),
   /** The rebuilds by their likely cause (`RebuildCause`); absent from a host that predates it */
   rebuildCauses: external_exports.record(external_exports.string(), external_exports.number()).optional(),
+  /** What the rebuilds wrote to the cache, in tokens (`CacheSessionStats.rebuildTokens`) */
+  rebuildTokens: external_exports.number().optional(),
+  /**
+   * What the cache cost in units of an uncached input token (#1492), for the share the writes were of it: the tokens read from the cache
+   * times the price of a read, and the tokens written times the price of a write, each as a ratio to uncached input (Anthropic: read 0.1,
+   * five-minute write 1.25, one-hour write 2; Codex by model, docs/agent-host.md §6.1). No money: the ratios, not the prices. For a tool
+   * that does not report writes (Codex) the write units are those of the input it did not read from the cache. Absent from a host that
+   * predates them.
+   */
+  cacheReadCost: external_exports.number().optional(),
+  cacheWriteCost: external_exports.number().optional(),
   /**
    * The shortest and longest idle time before a rebuild put down to the cache expiring (`expired`, `probably_expired`),
    * in milliseconds; absent when there was none
@@ -59109,14 +59133,33 @@ function readNotifyPolicy(raw) {
 var MIN_AUTO_COMPACT_SHARE = 0.2;
 var MIN_IDLE_COMPACT_SHARE = 0.1;
 var MAX_AUTO_COMPACT_SHARE = 0.95;
-var DEFAULT_AUTO_COMPACT = { controlled: true, share: 0.6, idleShare: 0.3 };
+var MIN_NUDGE_SHARE = 0.1;
+var MAX_NUDGE_SHARE = 0.9;
+var NUDGE_SECOND_GAP = 0.1;
+var NUDGE_MARGIN = 0.05;
+var DEFAULT_AUTO_COMPACT = { controlled: true, share: 0.6, idleShare: 0.3, nudge: true, nudgeFirst: 0.3, nudgeSecond: null };
+var hundredths = (n) => Math.round(n * 100) / 100;
+function nudgeShares(c) {
+  const ceiling = hundredths(c.share - NUDGE_MARGIN);
+  const second = hundredths(c.nudgeSecond ?? c.share - NUDGE_SECOND_GAP);
+  return { first: c.nudgeFirst, second: Math.min(ceiling, Math.max(MIN_NUDGE_SHARE, second)) };
+}
 function readAutoCompact(raw) {
   const out = { ...DEFAULT_AUTO_COMPACT };
   if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return out;
   if ("controlled" in raw && typeof raw.controlled === "boolean") out.controlled = raw.controlled;
   if ("share" in raw && typeof raw.share === "number" && Number.isFinite(raw.share)) out.share = Math.min(MAX_AUTO_COMPACT_SHARE, Math.max(MIN_AUTO_COMPACT_SHARE, raw.share));
   if ("idleShare" in raw && typeof raw.idleShare === "number" && Number.isFinite(raw.idleShare)) out.idleShare = Math.min(MAX_AUTO_COMPACT_SHARE, Math.max(MIN_IDLE_COMPACT_SHARE, raw.idleShare));
-  return out;
+  if ("nudge" in raw && typeof raw.nudge === "boolean") out.nudge = raw.nudge;
+  if ("nudgeFirst" in raw && typeof raw.nudgeFirst === "number" && Number.isFinite(raw.nudgeFirst)) out.nudgeFirst = Math.min(MAX_NUDGE_SHARE, Math.max(MIN_NUDGE_SHARE, raw.nudgeFirst));
+  if ("nudgeSecond" in raw && typeof raw.nudgeSecond === "number" && Number.isFinite(raw.nudgeSecond)) out.nudgeSecond = Math.min(MAX_NUDGE_SHARE, Math.max(MIN_NUDGE_SHARE, raw.nudgeSecond));
+  return settledSecond(out);
+}
+function settledSecond(c) {
+  if (c.nudgeSecond === null) return c;
+  const held3 = Math.min(c.nudgeSecond, hundredths(c.share - NUDGE_MARGIN));
+  const nudgeSecond = held3 > c.nudgeFirst ? held3 : null;
+  return nudgeSecond === c.nudgeSecond ? c : { ...c, nudgeSecond };
 }
 var LineHeight = external_exports.enum(["compact", "normal", "relaxed"]);
 var UiPreferences = external_exports.object({
@@ -59234,7 +59277,11 @@ var UiPreferencesPatch = UiPreferences.partial().extend({
   autoCompact: external_exports.object({
     controlled: external_exports.boolean(),
     share: external_exports.number().min(MIN_AUTO_COMPACT_SHARE).max(MAX_AUTO_COMPACT_SHARE),
-    idleShare: external_exports.number().min(MIN_IDLE_COMPACT_SHARE).max(MAX_AUTO_COMPACT_SHARE)
+    idleShare: external_exports.number().min(MIN_IDLE_COMPACT_SHARE).max(MAX_AUTO_COMPACT_SHARE),
+    nudge: external_exports.boolean(),
+    nudgeFirst: external_exports.number().min(MIN_NUDGE_SHARE).max(MAX_NUDGE_SHARE),
+    /** null: back to the default, below `share` by `NUDGE_SECOND_GAP` */
+    nudgeSecond: external_exports.number().min(MIN_NUDGE_SHARE).max(MAX_NUDGE_SHARE).nullable()
   }).partial().optional()
 });
 var DEFAULT_AGENT_DEPTH = 1;
@@ -59735,7 +59782,8 @@ var NormalizedEvent = external_exports.discriminatedUnion("type", [
     after: external_exports.number().optional(),
     /**
      * Who started it, when the tool says (Claude's `compact_metadata.trigger`): `manual` is a `/compact` (the person's or
-     * Centralu's, #1451), `auto` the tool's own at its threshold. Centralu does not take an `auto` one for its own.
+     * Centralu's, #1451), `auto` the tool's own at its threshold. Centralu does not take an `auto` one for its own. Codex does
+     * not say why; its adapter says `manual` for a compaction inside the compact turn the session started, `auto` otherwise (#1500).
      */
     trigger: external_exports.enum(["manual", "auto"]).optional()
   }),
@@ -65780,12 +65828,12 @@ var HostServer = class _HostServer {
       }
       const { method, params, id: id3 } = frame.data;
       if (bridgeOf !== null) {
-        const refusal = bridgeRefusal(bridgeOf, method, params);
-        if (refusal !== null) return this.sendError(ws2, id3, { code: "internal", message: refusal, retryable: false });
+        const refusal2 = bridgeRefusal(bridgeOf, method, params);
+        if (refusal2 !== null) return this.sendError(ws2, id3, { code: "internal", message: refusal2, retryable: false });
       }
       if (limited) {
-        const refusal = limitedRefusal(method, params);
-        if (refusal?.rights === "asks" && this.opts.onAsk) {
+        const refusal2 = limitedRefusal(method, params);
+        if (refusal2?.rights === "asks" && this.opts.onAsk) {
           try {
             const result = await this.opts.onAsk(method, params, { client: label }, leaving.signal);
             this.sendTo(ws2, JSON.stringify({ kind: "res", id: id3, ok: true, result }));
@@ -65795,9 +65843,9 @@ var HostServer = class _HostServer {
           }
           return;
         }
-        if (refusal !== null) {
-          console.error(`[agent-host] refused ${JSON.stringify(method)} to a connection holding the limited credential (${refusal.rights})`);
-          return this.sendError(ws2, id3, { code: "internal", message: refusal.message, retryable: false, data: { refused: "rights", rights: refusal.rights } });
+        if (refusal2 !== null) {
+          console.error(`[agent-host] refused ${JSON.stringify(method)} to a connection holding the limited credential (${refusal2.rights})`);
+          return this.sendError(ws2, id3, { code: "internal", message: refusal2.message, retryable: false, data: { refused: "rights", rights: refusal2.rights } });
         }
       }
       try {
@@ -102663,8 +102711,8 @@ var InlineViews = class {
       if (this.deps.rt.list().find((a) => a.appId === v.ref.appId && a.projectId === v.ref.projectId)?.status === "failed") {
         refuse3("This app stopped after failing repeatedly. Restart it, then reopen this view");
       }
-      const refusal = await this.refusal(v.ref, v.uri);
-      if (refusal) refuse3(refusal);
+      const refusal2 = await this.refusal(v.ref, v.uri);
+      if (refusal2) refuse3(refusal2);
       if (!v.instanceId) {
         let instanceId;
         try {
@@ -102751,10 +102799,10 @@ var InlineViews = class {
     }
     if (this.disposed) return;
     const base2 = { type: "app_view", sessionId: c.sessionId, callId, appId: c.ref.appId, projectId: c.ref.projectId, tool: c.tool };
-    const refusal = await this.refusal(c.ref, ui2.uri);
-    if (refusal) {
-      this.log(`[apps] ${where2}: view rejected \u2014 ${refusal}`);
-      this.deps.emit({ ...base2, phase: "rejected", reason: refusal });
+    const refusal2 = await this.refusal(c.ref, ui2.uri);
+    if (refusal2) {
+      this.log(`[apps] ${where2}: view rejected \u2014 ${refusal2}`);
+      this.deps.emit({ ...base2, phase: "rejected", reason: refusal2 });
       return;
     }
     let instanceId;
@@ -107134,7 +107182,10 @@ var ORCHESTRATOR_TOOLS = [
       autoCompact: external_exports.object({
         controlled: external_exports.boolean().optional().describe("Whether Centralu sets when agents compact (default on); off, each agent's own settings decide."),
         share: external_exports.number().optional().describe("Share of the model's window to compact at, 0.2 to 0.95 (default 0.6)."),
-        idleShare: external_exports.number().optional().describe("Share over which a session at rest for 10 minutes is compacted by Centralu, 0.1 to 0.95 (default 0.3).")
+        idleShare: external_exports.number().optional().describe("Share over which a session at rest for 10 minutes is compacted by Centralu, 0.1 to 0.95 (default 0.3)."),
+        nudge: external_exports.boolean().optional().describe("Whether Centralu quietly tells a session to call compact_self as its context grows (default on)."),
+        nudgeFirst: external_exports.number().optional().describe("Share of the window for the first notice, 0.1 to 0.9 (default 0.3)."),
+        nudgeSecond: external_exports.number().nullable().optional().describe("Share for the second notice, 0.1 to 0.9 and 5+ points below share; null for the default, 10 points below share.")
       }).strict().optional().describe("When agents compact by themselves.")
     }).strict()
   },
@@ -109159,7 +109210,7 @@ ${machineLine(machine)}` };
 var HOUR_MS = 60 * 6e4;
 var BUCKET_COLUMNS = `hour, session_id AS sessionId, project_id AS projectId, tool, model, machine, requests, input,
   cache_read AS cacheRead, cache_write AS cacheWrite, cache_write_5m AS cacheWrite5m, cache_write_1h AS cacheWrite1h,
-  output, rebuilds, causes`;
+  output, rebuilds, rebuild_tokens AS rebuildTokens, causes`;
 var UsageRecords = class {
   constructor(db) {
     this.db = db;
@@ -109215,14 +109266,14 @@ var UsageRecords = class {
     );
     const upsert = this.db.prepare(
       `INSERT INTO usage_buckets (hour, session_id, project_id, tool, model, machine, requests, input, cache_read, cache_write,
-                                  cache_write_5m, cache_write_1h, output, rebuilds, causes)
+                                  cache_write_5m, cache_write_1h, output, rebuilds, rebuild_tokens, causes)
        VALUES (@hour, @sessionId, @projectId, @tool, @model, @machine, @requests, @input, @cacheRead, @cacheWrite,
-               @cacheWrite5m, @cacheWrite1h, @output, @rebuilds, @causes)
+               @cacheWrite5m, @cacheWrite1h, @output, @rebuilds, @rebuildTokens, @causes)
        ON CONFLICT(hour, session_id, project_id, tool, model, machine) DO UPDATE SET
          requests = requests + excluded.requests, input = input + excluded.input, cache_read = cache_read + excluded.cache_read,
          cache_write = cache_write + excluded.cache_write, cache_write_5m = cache_write_5m + excluded.cache_write_5m,
          cache_write_1h = cache_write_1h + excluded.cache_write_1h, output = output + excluded.output,
-         rebuilds = rebuilds + excluded.rebuilds, causes = excluded.causes`
+         rebuilds = rebuilds + excluded.rebuilds, rebuild_tokens = rebuild_tokens + excluded.rebuild_tokens, causes = excluded.causes`
     );
     this.db.transaction(() => {
       for (const b2 of buckets) {
@@ -113674,7 +113725,10 @@ var UPDATE_CARD = 'Turn on "Automatic updates"? From then on this computer check
 var FOLDED_GROUPS_MAX = 500;
 var SLEEP_CHOICES = 'a whole number of minutes, or "never"';
 function autoCompactText(c) {
-  return c.controlled ? `agents compact at ${Math.round(c.share * 100)}% of the model's window, set by Centralu; a session at rest is compacted over ${Math.round(c.idleShare * 100)}%` : "Centralu does not set when agents compact; each agent's own settings decide";
+  if (!c.controlled) return "Centralu does not set when agents compact; each agent's own settings decide";
+  const n = nudgeShares(c);
+  const nudge = c.nudge ? `a session is told quietly to call compact_self at ${Math.round(n.first * 100)}% and ${Math.round(n.second * 100)}%` : "a session is not told to call compact_self";
+  return `agents compact at ${Math.round(c.share * 100)}% of the model's window, set by Centralu; a session at rest is compacted over ${Math.round(c.idleShare * 100)}%; ${nudge}`;
 }
 var PreferencesFlow = class {
   constructor(host) {
@@ -115442,7 +115496,13 @@ var ProjectConsents = class {
 
 // packages/agent-host/src/sessions/ui-preferences.ts
 var UI_PREFS_KEY = "ui_preferences";
-var IDLE_SHARE_KEY = "autoCompactIdleShare";
+var COMPACT_BESIDE = {
+  idleShare: "autoCompactIdleShare",
+  nudge: "autoCompactNudge",
+  nudgeFirst: "autoCompactNudgeFirst",
+  nudgeSecond: "autoCompactNudgeSecond"
+};
+var COMPACT_BESIDE_FIELDS = ["idleShare", "nudge", "nudgeFirst", "nudgeSecond"];
 var UiPreferenceStore = class {
   constructor(host) {
     this.host = host;
@@ -115479,8 +115539,9 @@ var UiPreferenceStore = class {
     }
     if (this.brokenRow() || "hubAuto" in stored && typeof stored.hubAuto !== "boolean") prefs.hubAuto = false;
     prefs.sessionTools = true;
-    const idle = stored[IDLE_SHARE_KEY];
-    if (typeof idle === "number" && Number.isFinite(idle)) prefs.autoCompact = readAutoCompact({ ...prefs.autoCompact ?? {}, idleShare: idle });
+    const beside = {};
+    for (const field of COMPACT_BESIDE_FIELDS) if (COMPACT_BESIDE[field] in stored) beside[field] = stored[COMPACT_BESIDE[field]];
+    if (Object.keys(beside).length > 0) prefs.autoCompact = readAutoCompact({ ...prefs.autoCompact ?? {}, ...beside });
     return prefs;
   }
   /**
@@ -115495,21 +115556,37 @@ var UiPreferenceStore = class {
     const { notifyPolicy: switches, autoCompact: compact, sessionTools: _alwaysOn, ...rest } = patch;
     const base2 = current.notifyPolicy ?? readNotifyPolicy(this.loadWorkspace()?.notifyPolicy);
     const notifyPolicy = switches ? { ...base2, ...switches } : void 0;
-    const { idleShare, ...compactRest } = compact ?? {};
-    const merged = compact ? { ...readAutoCompact(current.autoCompact), ...compact } : void 0;
-    const autoCompact = Object.keys(compactRest).length > 0 && merged ? { controlled: merged.controlled, share: merged.share } : void 0;
+    const before = readAutoCompact(current.autoCompact);
+    const asked = compact ? { ...before, ...withoutUndefined(compact) } : void 0;
+    if (compact && asked && asked.nudgeSecond !== null && (compact.nudgeSecond != null || compact.nudgeFirst !== void 0)) {
+      const second = Math.round(asked.nudgeSecond * 100);
+      if (asked.nudgeSecond > asked.share - NUDGE_MARGIN + 1e-9) {
+        throw refusal(`The second reminder (${second}%) must be at least ${Math.round(NUDGE_MARGIN * 100)} points below the share agents compact at (${Math.round(asked.share * 100)}%): the tool's own compaction would come first.`);
+      }
+      if (asked.nudgeSecond <= asked.nudgeFirst + 1e-9) {
+        throw refusal(`The second reminder (${second}%) must be above the first (${Math.round(asked.nudgeFirst * 100)}%).`);
+      }
+    }
+    const merged = asked ? readAutoCompact(asked) : void 0;
+    const compactKeys = Object.keys(withoutUndefined(compact ?? {}));
+    const autoCompact = merged && compactKeys.some((k2) => !(k2 in COMPACT_BESIDE)) ? { controlled: merged.controlled, share: merged.share } : void 0;
+    const besides = {};
+    if (compact && merged) {
+      for (const field of COMPACT_BESIDE_FIELDS) if (compact[field] !== void 0 || merged[field] !== before[field]) besides[COMPACT_BESIDE[field]] = merged[field];
+    }
     const written = {
       ...rest,
       ...notifyPolicy ? { notifyPolicy } : {},
       ...autoCompact ? { autoCompact } : {},
-      ...idleShare !== void 0 && merged ? { [IDLE_SHARE_KEY]: merged.idleShare } : {}
+      ...besides
     };
     const stored = this.storedUiPreferences();
     const damaged = this.brokenRow() || "hubAuto" in stored && typeof stored.hubAuto !== "boolean";
     const kept = damaged && patch.hubAuto === void 0 ? { hubAuto: false } : {};
     this.host.store.settings.setAppSetting(UI_PREFS_KEY, JSON.stringify({ ...stored, ...kept, ...written }));
     if (Object.keys(written).length) this.host.emit({ type: "prefs_changed" });
-    const { [IDLE_SHARE_KEY]: _beside, autoCompact: _two, ...shown3 } = written;
+    const { autoCompact: _two, ...shown3 } = written;
+    for (const key of Object.values(COMPACT_BESIDE)) delete shown3[key];
     return { ...current, ...shown3, ...merged ? { autoCompact: merged } : {} };
   }
   /** The stored record as written, every field kept; `{}` for none or for one that is not a JSON object */
@@ -115531,6 +115608,19 @@ var UiPreferenceStore = class {
     return raw !== null && !isObj(parseJson(raw));
   }
 };
+function refusal(message) {
+  return rpcError(message, "refused", { retryable: false, data: { reason: "bad_value" } });
+}
+function withoutUndefined(o) {
+  return {
+    ...o.controlled !== void 0 ? { controlled: o.controlled } : {},
+    ...o.share !== void 0 ? { share: o.share } : {},
+    ...o.idleShare !== void 0 ? { idleShare: o.idleShare } : {},
+    ...o.nudge !== void 0 ? { nudge: o.nudge } : {},
+    ...o.nudgeFirst !== void 0 ? { nudgeFirst: o.nudgeFirst } : {},
+    ...o.nudgeSecond !== void 0 ? { nudgeSecond: o.nudgeSecond } : {}
+  };
+}
 
 // packages/agent-host/src/sessions/session-apps.ts
 var TOOL_LIST_WAIT_MS = 15e3;
@@ -119556,6 +119646,61 @@ var MailDelivery = class {
   }
 };
 
+// packages/agent-host/src/sessions/context-meter.ts
+var ESTIMATE_GAP_MS = 3e3;
+var ContextMeter = class {
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  now;
+  sessions = /* @__PURE__ */ new Map();
+  state(id3) {
+    let s = this.sessions.get(id3);
+    if (!s) this.sessions.set(id3, s = { working: false, estimated: false, readThisTurn: false, owed: false, at: 0 });
+    return s;
+  }
+  /**
+   * Whether a context reading, before it is applied, is the turn before's landing in a turn that has an estimate of its own: then it
+   * must not become the session's figure. Sees the tool's readings only; an estimate is never stale.
+   */
+  stale(e) {
+    if (e.type !== "context_update" || e.exactness === "estimate") return false;
+    const s = this.state(e.sessionId);
+    const late = s.owed;
+    s.owed = false;
+    if (late) return s.working && s.estimated;
+    s.readThisTurn = true;
+    return false;
+  }
+  /**
+   * After an event is applied (`m` is the session as it now is): the estimate it brings, if any, as the event to apply.
+   * `perRequest`: the tool reads the size with every request (Codex sends it right after the request's token count), so the
+   * figure is exact without an estimate, which could only flicker in front of it (#1504 review)
+   */
+  observe(e, m, perRequest = false) {
+    const s = this.state(m.id);
+    if (e.type === "session_deleted") {
+      this.sessions.delete(m.id);
+      return null;
+    }
+    const working = inTurn(m.state);
+    if (working && !s.working) {
+      s.estimated = false;
+      s.readThisTurn = false;
+    }
+    if (s.working && !working) s.owed = !s.readThisTurn;
+    s.working = working;
+    if (perRequest || e.type !== "usage_update" || !e.request || e.request.agent !== void 0) return null;
+    if (!working || s.readThisTurn || !m.context || m.context.window <= 0) return null;
+    const used = Math.min(m.context.window, e.request.inputTokens + e.request.cacheReadTokens + (e.request.cacheCreationTokens ?? 0));
+    const now = this.now();
+    if (used === m.context.used || now - s.at < ESTIMATE_GAP_MS) return null;
+    s.at = now;
+    s.estimated = true;
+    return { type: "context_update", sessionId: m.id, used, window: m.context.window, exactness: "estimate" };
+  }
+};
+
 // packages/agent-host/src/sessions/app-messages.ts
 function appMessageFrame(app2, text2, via = "inline") {
   const body = text2.split(/\r\n|[\n\r\u0085\u2028\u2029]/).map((line) => `> ${line}`).join("\n");
@@ -119616,6 +119761,8 @@ var SessionEvents = class {
     this.host = host;
   }
   host;
+  /** The context figure during a turn, from each request's size (#1492, context-meter.ts) */
+  meter = new ContextMeter();
   /** Receive event -> update metadata -> persist message -> broadcast */
   onEvent(raw, from = null) {
     const e = raw.type === "files_touched" ? this.projectRelative(raw) : raw;
@@ -119636,6 +119783,10 @@ var SessionEvents = class {
       this.host.record.recordSubagentStep(e);
       return;
     }
+    if (e.type === "context_update" && this.meter.stale(e)) {
+      this.host.compactEvent(e, false);
+      return;
+    }
     if (e.type === "settings_changed" && e.by === "tool") {
       this.host.record.recordToolSettings(e);
       return;
@@ -119718,6 +119869,9 @@ var SessionEvents = class {
     if (endedTurn && e.sessionId) this.host.restartPolicy.applyDeferredRestart(e.sessionId);
     if (e.sessionId) this.host.mailEvent(e, endedTurn);
     if (e.sessionId) this.host.compactEvent(e, endedTurn);
+    const meta3 = e.sessionId ? this.host.meta.get(e.sessionId) : void 0;
+    const estimate = meta3 ? this.meter.observe(e, meta3, this.host.contextAtRequest(meta3.id)) : null;
+    if (estimate) this.onEvent(estimate);
     if (e.sessionId && (endedTurn || e.type === "state_change" || e.type === "approval_resolved" || e.type === "question_resolved")) this.host.mailPoke(e.sessionId);
     if (e.type === "background_tasks" && e.sessionId) this.host.restartPolicy.applyDeferredRestart(e.sessionId);
     if (e.type === "background_tasks" && e.sessionId && this.host.children.pausedReports.has(e.sessionId)) this.host.reports.settlePausedReport(e.sessionId);
@@ -119765,7 +119919,7 @@ var SessionEvents = class {
     switch (e.type) {
       case "usage_update": {
         m.usage = e.tokens;
-        const counted = e.request && this.host.cacheLedger.record(m.tool, m.id, e.request);
+        const counted = e.request && this.host.cacheLedger.record(m.tool, m.id, e.request, void 0, m.model);
         if (e.request && counted) this.host.usageRecorder.request({ sessionId: m.id, projectId: m.projectId, tool: m.tool, model: m.model ?? void 0 }, e.request, counted);
         break;
       }
@@ -119774,7 +119928,7 @@ var SessionEvents = class {
         break;
       case "context_update":
         m.context = nextContext(m.context, e);
-        this.host.modelWindows.note(m, e.window, e.model);
+        if (e.exactness !== "estimate") this.host.modelWindows.note(m, e.window, e.model);
         break;
       case "conversation_reset":
         m.context = nextContext(m.context, e);
@@ -120004,6 +120158,8 @@ var SelfCompaction = class {
   /** The size of the last model request of the session's own conversation in the running turn: the size the turn grew to, in both tools */
   lastRequest = /* @__PURE__ */ new Map();
   timer = null;
+  /** `stop()` was called: a late event of a turn that was running is not acted on (it would start the timer or send) */
+  stopped = false;
   now() {
     return (this.host.now ?? Date.now)();
   }
@@ -120028,7 +120184,8 @@ var SelfCompaction = class {
   /** Hears every event of every session. Never throws into the caller's event */
   observe(e, endedTurn) {
     const id3 = e.sessionId;
-    if (!id3) return;
+    if (!id3 || this.stopped) return;
+    if (e.type === "context_update" && e.exactness === "estimate") return;
     if (e.type === "session_deleted") return this.forget(id3);
     const m = this.host.session(id3);
     if (!m) return;
@@ -120064,9 +120221,7 @@ var SelfCompaction = class {
     }
     const live2 = this.pending.get(id3);
     if (e.type === "context_update" && live2 && live2.endedAt !== null) return this.decide(id3, e.used, m.tool);
-    if ((e.type === "approval_resolved" || e.type === "question_resolved") && live2?.held && !busy && !this.cardOpen(id3)) {
-      return this.decide(id3, live2.size ?? m.context?.used ?? 0, m.tool);
-    }
+    if (live2?.held && this.releaseHeld(id3, m)) return;
     if (!endedTurn) return;
     this.markRest(id3);
     if (this.read.has(id3)) this.late.delete(id3);
@@ -120094,6 +120249,24 @@ var SelfCompaction = class {
     if (grew !== null) this.decide(id3, grew, m.tool);
     else this.awaitReading(id3, live2);
   }
+  /**
+   * A request held for a card: judged now if the card is closed and the session at rest, dropped if it has no process any more.
+   * Returns whether it was settled. **Not asked: background work.** The held path goes on `!busy && !cardOpen` even while the session
+   * runs background work, as the rule for every request made in a turn does (the request does not ask whether it runs: waiting for
+   * CI in the background is what it is for, docs/agent-host.md "Compacting at a break"); `sessionIdle`'s rule for the rest compaction is
+   * stricter on purpose, so this is not to be made to match it.
+   */
+  releaseHeld(id3, m) {
+    const req = this.pending.get(id3);
+    if (!req?.held) return false;
+    if (!this.host.running(id3)) {
+      this.settle(id3);
+      return true;
+    }
+    if (inTurn(m.state) || this.cardOpen(id3)) return false;
+    this.decide(id3, req.size ?? m.context?.used ?? 0, m.tool);
+    return true;
+  }
   /** A request whose turn ended with no size: a timer decides it on the reading it has if the tool's own does not come */
   awaitReading(id3, req) {
     req.endedAt = this.now();
@@ -120170,6 +120343,7 @@ var SelfCompaction = class {
     const setting = this.host.setting();
     const sent = [];
     for (const m of this.host.sessions()) {
+      if (this.pending.get(m.id)?.held) this.releaseHeld(m.id, m);
       if (!this.due(m, setting, now)) continue;
       this.fire(m.id, `at rest for ${IDLE_COMPACT_MINUTES} minutes, over ${Math.round(setting.idleShare * 100)}% of the window`, null, m.tool);
       if (this.compacting.has(m.id)) sent.push(m.id);
@@ -120198,10 +120372,12 @@ var SelfCompaction = class {
   /** Starts the sweep. A host that never calls it still serves `compact_self` */
   start() {
     if (this.timer) return;
+    this.stopped = false;
     this.timer = setInterval(() => this.sweepSafely(), SWEEP_MS);
     this.timer.unref?.();
   }
   stop() {
+    this.stopped = true;
     if (this.timer) clearInterval(this.timer);
     this.timer = null;
     for (const t of this.waits.values()) clearTimeout(t);
@@ -120225,6 +120401,102 @@ var SelfCompaction = class {
   }
 };
 
+// packages/agent-host/src/sessions/context-nudges.ts
+var ContextNudges = class {
+  constructor(host) {
+    this.host = host;
+  }
+  host;
+  cycles = /* @__PURE__ */ new Map();
+  stopped = false;
+  /** Hears every event of every session. Never throws into the caller's event */
+  observe(e) {
+    const id3 = e.sessionId;
+    if (!id3 || this.stopped) return;
+    switch (e.type) {
+      case "session_deleted":
+        this.cycles.delete(id3);
+        return;
+      case "conversation_reset":
+        this.cycles.delete(id3);
+        return;
+      case "compaction":
+        if (!e.failed) this.cycles.delete(id3);
+        return;
+      case "usage_update":
+        if (e.request && e.request.agent === void 0) this.requested(id3, e.request.inputTokens + e.request.cacheReadTokens + (e.request.cacheCreationTokens ?? 0));
+        return;
+      default:
+    }
+  }
+  cycle(id3) {
+    let c = this.cycles.get(id3);
+    if (!c) this.cycles.set(id3, c = { told: /* @__PURE__ */ new Set(), waiting: null, size: 0, sending: false });
+    return c;
+  }
+  requested(id3, size) {
+    if (size < COMPACT_FLOOR_TOKENS) return;
+    const setting = this.host.setting();
+    const m = this.host.session(id3);
+    if (!m || !setting.controlled || !setting.nudge || !this.host.hasCompactTool(id3)) return;
+    const window2 = this.host.window(m) ?? m.context?.window ?? 0;
+    if (window2 <= 0) return;
+    const c = this.cycle(id3);
+    c.size = size;
+    const share = size / window2;
+    const { first, second } = nudgeShares(setting);
+    const crossed = ["first", "second"].filter((k2) => !c.told.has(k2) && (k2 === "first" ? first : second) < setting.share && (k2 === "first" ? first : second) <= share);
+    if (crossed.length > 0) {
+      for (const k2 of crossed) c.told.add(k2);
+      c.waiting = crossed.includes("second") ? "second" : "first";
+    }
+    if (c.waiting) this.deliver(id3, c, m, window2, setting);
+  }
+  deliver(id3, c, m, window2, setting) {
+    const which = c.waiting;
+    if (!which || c.sending) return;
+    const percent = Math.round(c.size / window2 * 100);
+    const used = `${Math.round(c.size / 1e3)}k of ${Math.round(window2 / 1e3)}k tokens`;
+    const text2 = which === "second" ? `[Centralu] Your context is now about ${percent}% full (${used}), and the tool compacts it by itself in the middle of work at ${Math.round(setting.share * 100)}%. Call compact_self when the current step is done, at the latest; do not stop what you are doing for it.` : `[Centralu] Your context is now about ${percent}% full (${used}). When this step of the work is done, call compact_self so the next step starts from a summary; do not stop what you are doing for it.`;
+    const failed3 = (err) => {
+      c.waiting = null;
+      console.error(`[compact] ${id3.slice(0, 8)}: could not send the context notice: ${err instanceof Error ? err.message : String(err)}`);
+    };
+    const answered = (took2) => {
+      if (!took2) return;
+      c.waiting = null;
+      this.host.notice(id3, `Centralu told it its context is ${percent}% full: call compact_self when this step is done`);
+    };
+    let took;
+    try {
+      took = this.host.nudge(id3, text2);
+    } catch (err) {
+      failed3(err);
+      return;
+    }
+    if (typeof took === "boolean") {
+      answered(took);
+      return;
+    }
+    c.sending = true;
+    void took.then(
+      (ok) => {
+        c.sending = false;
+        if (!this.stopped && this.cycles.get(id3) === c) answered(ok);
+      },
+      (err) => {
+        c.sending = false;
+        if (!this.stopped && this.cycles.get(id3) === c) failed3(err);
+      }
+    );
+  }
+  /** The host is leaving: nothing is told after this, and nothing waits to be */
+  stop() {
+    this.stopped = true;
+    this.cycles.clear();
+  }
+};
+
 // packages/agent-host/src/adapters/claude/index.ts
 import { tmpdir as tmpdir3 } from "node:os";
 import { mkdtemp as mkdtemp2, readdir as readdir9, rm as rm7, stat as stat8 } from "node:fs/promises";
@@ -122457,8 +122729,14 @@ var CLAUDE_KNOWN_TYPES = /* @__PURE__ */ new Set([
 ]);
 function ttlOf(split2) {
   const c = asObj(split2);
-  if (Number(c.ephemeral_1h_input_tokens ?? 0) > 0) return { cacheTtl: "1h" };
-  if (Number(c.ephemeral_5m_input_tokens ?? 0) > 0) return { cacheTtl: "5m" };
+  const hour = Number(c.ephemeral_1h_input_tokens ?? 0);
+  const five = Number(c.ephemeral_5m_input_tokens ?? 0);
+  const amounts = {
+    ...Number.isFinite(hour) && "ephemeral_1h_input_tokens" in c ? { cacheWrite1hTokens: Math.max(0, hour) } : {},
+    ...Number.isFinite(five) && "ephemeral_5m_input_tokens" in c ? { cacheWrite5mTokens: Math.max(0, five) } : {}
+  };
+  if (hour > 0) return { cacheTtl: "1h", ...amounts };
+  if (five > 0) return { cacheTtl: "5m", ...amounts };
   return {};
 }
 function readingOf(events2) {
@@ -122689,10 +122967,10 @@ var ClaudeStreamNormalizer = class {
     if (subagent) return events2;
     events2 = this.followRetry(type, events2);
     if (type === "result" && this.refusal !== null) {
-      const refusal = this.refusal;
+      const refusal2 = this.refusal;
       this.refusal = null;
       const failed3 = events2.some((e) => e.type === "error");
-      events2 = failed3 ? events2.map((e) => e.type === "error" ? { ...e, error: { ...e.error, message: refusal } } : e) : [{ type: "notice", sessionId: this.sessionId, level: "warning", text: refusal, from: "Claude Code", label: "refusal" }, ...events2];
+      events2 = failed3 ? events2.map((e) => e.type === "error" ? { ...e, error: { ...e.error, message: refusal2 } } : e) : [{ type: "notice", sessionId: this.sessionId, level: "warning", text: refusal2, from: "Claude Code", label: "refusal" }, ...events2];
     }
     if (msg.type === "stream_event") {
       const e = msg.event;
@@ -124154,6 +124432,12 @@ var ClaudeSession = class {
   send(text2, opts) {
     this.sendInput(text2, opts?.id !== void 0 && isUuid(opts.id) ? opts.id : randomUUID24(), void 0, opts?.origin, opts?.quiet);
   }
+  /** A note read with the next message or at the running turn's next tool round, starting nothing (#1492): quiet input, stamped as Centralu's */
+  nudge(text2) {
+    if (this.closed) return false;
+    this.send(text2, { origin: { kind: "channel", server: "centralu" }, quiet: true });
+    return true;
+  }
   /** The inputs the result being handled names (#1377); null when the CLI cannot name them, and outside a result */
   resultInputs = null;
   turnInputs() {
@@ -124456,6 +124740,7 @@ var ClaudeAdapter = class _ClaudeAdapter {
   tool = "claude";
   /** `shouldQuery: false` (sdk.d.ts, measured on the Mac 2026-10-20: no turn, merged into the next message) */
   quietInput = true;
+  cacheBilling = "anthropic";
   /** What Claude Code offers against what this adapter limits (#270) */
   surface = CLAUDE_SURFACE;
   launch;
@@ -126690,7 +126975,7 @@ var CodexSlashCommands = class {
   /** The request a slash command started, or null when the text is a message */
   run(text2) {
     if (text2.trim() === "/compact") {
-      this.host.setBlockingTurn(true);
+      this.host.setBlockingTurn(true, true);
       return this.host.request("thread/compact/start", { threadId: this.host.threadId() }).catch((e) => {
         this.host.setBlockingTurn(false);
         this.host.flushPending();
@@ -127040,8 +127325,9 @@ var CodexSession = class {
       emit: (e) => this.emit(e),
       request: (method, params) => this.client.request(method, params),
       threadId: () => this.threadId,
-      setBlockingTurn: (on2) => {
+      setBlockingTurn: (on2, compact) => {
         this.blockingTurn = on2;
+        this.compactTurn = on2 && compact === true;
       },
       flushPending: () => this.flushPending()
     });
@@ -127144,6 +127430,8 @@ var CodexSession = class {
   inputGroups = /* @__PURE__ */ new Map();
   /** An unsteerable turn (compact/review) is running — we know because we are the ones who started it */
   blockingTurn = false;
+  /** The unsteerable turn is a compaction we started (`/compact`), not a review: a compaction event in it is manual */
+  compactTurn = false;
   /** Messages sent while the thread was still coming up, and those a Stop reclaimed (see `WakingSends`, #168) */
   sends = new WakingSends();
   /** Codex is reconnecting on its own (#168): the `retrying` activity and what it puts back (see `RetryActivity`) */
@@ -127290,6 +127578,7 @@ var CodexSession = class {
     }
     if (n.method === "turn/completed" && this.blockingTurn) {
       this.blockingTurn = false;
+      this.compactTurn = false;
       this.flushPending();
     }
     if (n.method === "thread/settings/updated") {
@@ -127312,7 +127601,8 @@ var CodexSession = class {
   }
   /** A notification of this thread's own, as the events it maps to (`normalizeNotification`), each the way it goes out */
   emitNotification(n) {
-    for (const e of normalizeNotification(this.sessionId, n)) {
+    for (const said of normalizeNotification(this.sessionId, n)) {
+      const e = said.type === "compaction" ? { ...said, trigger: this.compactTurn ? "manual" : "auto" } : said;
       if (e.type === "error" && this.inputReceipts.size) this.interrupt(new Error(e.error.message));
       if (e.type === "message_image" && !e.data && e.path) {
         void imageEventFromDisk(this.sessionId, e.path).then((filled2) => this.emit(filled2));
@@ -127323,7 +127613,8 @@ var CodexSession = class {
       if (e.type === "usage_update") {
         const request = this.requests.take(n.params);
         if (request) {
-          this.emit({ ...e, request });
+          const model = this.shown?.model ?? this.opts.model ?? this.threadSettings?.model ?? null;
+          this.emit({ ...e, request: model ? { ...request, model } : request });
           continue;
         }
       }
@@ -127352,6 +127643,22 @@ var CodexSession = class {
   send(text2) {
     this.sendInput(text2);
   }
+  /**
+   * A note steered into the regular turn that is running, starting nothing (#1492). `turn/start` would do it only while a turn is
+   * running: with none, it starts a turn of its own (Codex sends a request's token count just before `turn/completed`, so a note for
+   * the last request of a turn went out after the turn had ended and ran as a turn nobody asked for, #1504 review), and behind a
+   * compact or review turn it queues the note and runs it as a turn. `turn/steer` names the turn it is for (`expectedTurnId`) and
+   * is refused by Codex when that turn is not the one running, so a note for a turn that has ended starts nothing. The answer says
+   * whether it was taken: a refused note is not told, and waits for a later request of a running turn (`ContextNudges`).
+   */
+  nudge(text2) {
+    const turnId = this.turns.turnId;
+    if (this.closed || !this.started || !this.threadId || turnId === null || this.blockingTurn || this.pendingInputs.length > 0) return false;
+    return this.client.request("turn/steer", { threadId: this.threadId, input: [{ type: "text", text: text2 }], expectedTurnId: turnId }).then(
+      () => true,
+      () => false
+    );
+  }
   sendInput(text2, receipt) {
     const nth = this.sends.issue();
     this.startsInFlight += 1;
@@ -127912,6 +128219,8 @@ var exec5 = promisify6(execFile7);
 var CODEX_VERBOSITIES = ["low", "medium", "high"];
 var CodexAdapter = class {
   tool = "codex";
+  cacheBilling = "openai";
+  contextAtRequest = true;
   /** What Codex offers against what this adapter limits (#270) */
   surface = CODEX_SURFACE;
   descriptor = {
@@ -129416,6 +129725,25 @@ var SessionSettings = class {
   }
 };
 
+// packages/agent-host/src/sessions/cache-cost.ts
+function gptGeneration(model) {
+  const m = /gpt-(\d+)(?:\.(\d+))?/i.exec(model ?? "");
+  return m ? Number(m[1]) + Number(m[2] ?? 0) / 100 : null;
+}
+function cachePrices(billing, model) {
+  if (billing === "anthropic") return { read: 0.1, write5m: 1.25, write1h: 2 };
+  const generation = gptGeneration(model);
+  if (generation === null || generation >= 5.06) return { read: /(^|[^a-z])sol([^a-z]|$)/i.test(model ?? "") ? 0.05 : 0.1, write5m: 1.25, write1h: 1.25 };
+  return { read: 0.1, write5m: 1, write1h: 1 };
+}
+function cacheCost(billing, model, t, reportsWrites) {
+  const price = cachePrices(billing, model);
+  const read = t.read * price.read;
+  if (!reportsWrites) return { read, write: t.input * price.write5m };
+  const hour = Math.min(t.write, Math.max(0, t.write1h ?? 0));
+  return { read, write: hour * price.write1h + (t.write - hour) * price.write5m };
+}
+
 // packages/agent-host/src/sessions/cache-ledger.ts
 var REBUILD_SHARE = 0.5;
 var REBUILD_MIN_TOKENS = 4096;
@@ -129428,12 +129756,21 @@ var TOP_SESSIONS = 3;
 var FIVE_HOURS_MS = 5 * 60 * 6e4;
 var HOUR_MS3 = 60 * 6e4;
 var NOTED = ["cold_start", "new_process", "model_change", "compaction", "thread_restart", "instructions", "launch_settings"];
+function paidTokens(r) {
+  return r.cacheCreationTokens ?? r.inputTokens;
+}
 function isRebuild(r) {
   const total = r.inputTokens + r.cacheReadTokens + (r.cacheCreationTokens ?? 0);
-  const paid = r.cacheCreationTokens ?? r.inputTokens;
+  const paid = paidTokens(r);
   return paid >= REBUILD_MIN_TOKENS && paid >= total * REBUILD_SHARE;
 }
 var CacheLedger = class {
+  /** `billingOf`: whose price ratios a tool's model is billed by (`AgentAdapter.cacheBilling`) */
+  constructor(now = Date.now(), billingOf = () => "anthropic") {
+    this.billingOf = billingOf;
+    this.startedAt = now;
+  }
+  billingOf;
   entries = /* @__PURE__ */ new Map();
   carried = /* @__PURE__ */ new Map();
   /** Tools that have reported a cache write figure at least once (Claude); the others report reads only */
@@ -129442,9 +129779,6 @@ var CacheLedger = class {
   /** What happened in a session since its conversation's last request (`note`), consumed by the next one */
   notes = /* @__PURE__ */ new Map();
   startedAt;
-  constructor(now = Date.now()) {
-    this.startedAt = now;
-  }
   /**
    * Something happened in a session that would make its next request rebuild the cache: the session was created, its
    * process started again, its model changed. Kept until that session's own conversation makes a request.
@@ -129480,14 +129814,22 @@ var CacheLedger = class {
         read: b2.cacheRead,
         write: b2.cacheWrite,
         rebuilds: b2.rebuilds,
+        // A rebuild is at least `REBUILD_MIN_TOKENS`: fewer tokens than that for the rebuilds counted means some were stored before
+        // the figure was (an older build kept adding rebuilds to an hour this one had written), and the sum is not known
+        rebuildTokens: b2.rebuildTokens < b2.rebuilds * REBUILD_MIN_TOKENS ? null : b2.rebuildTokens,
+        // The ratios depend on the tool and the model, which a bucket has one of, so its sums are weighted at once
+        ...this.costOfBucket(b2),
         causes: b2.causes
       });
       if (b2.cacheWrite > 0) this.reportsWrites.add(b2.tool);
       this.startedAt = Math.min(this.startedAt, b2.hour);
     }
   }
-  /** Counts one request. Returns what it counted as, or undefined for a reading that was no request */
-  record(tool, sessionId, r, at2 = Date.now()) {
+  /**
+   * Counts one request. Returns what it counted as, or undefined for a reading that was no request. `model` is the one the session
+   * runs when the request does not say (the Codex price of a read and a write depends on it)
+   */
+  record(tool, sessionId, r, at2 = Date.now(), model) {
     const write = r.cacheCreationTokens ?? 0;
     if (r.inputTokens + r.cacheReadTokens + write <= 0) return void 0;
     if (r.cacheCreationTokens !== void 0) this.reportsWrites.add(tool);
@@ -129497,7 +129839,8 @@ ${r.agent ?? ""}`;
     const notes = r.agent ? void 0 : this.notes.get(sessionId);
     if (!r.agent) this.notes.delete(sessionId);
     const rebuild = isRebuild(r);
-    const entry = { at: at2, sessionId, input: r.inputTokens, read: r.cacheReadTokens, write, rebuild };
+    const cost = cacheCost(this.billingOf(tool), r.model ?? model, { input: r.inputTokens, read: r.cacheReadTokens, write, write1h: r.cacheWrite1hTokens ?? (r.cacheTtl === "1h" ? write : 0) }, r.cacheCreationTokens !== void 0);
+    const entry = { at: at2, sessionId, input: r.inputTokens, read: r.cacheReadTokens, write, rebuild, rebuildTokens: rebuild ? paidTokens(r) : 0, readCost: cost.read, writeCost: cost.write };
     if (rebuild) Object.assign(entry, causeOf(r, lane, notes, at2));
     this.lanes.delete(key);
     const ttlMs = r.cacheTtl ? TTL_MS[r.cacheTtl] : lane?.ttlMs ?? null;
@@ -129512,6 +129855,12 @@ ${r.agent ?? ""}`;
     if (drop > 0) list.splice(0, drop);
     return { rebuild, ...entry.cause ? { cause: entry.cause } : {} };
   }
+  /** A stored bucket's cache cost: the ratios belong to its tool and model, so its sums are weighted at once (`cacheCost`) */
+  costOfBucket(b2) {
+    const billing = this.billingOf(b2.tool);
+    const { read, write } = cacheCost(billing, b2.model, { input: b2.input, read: b2.cacheRead, write: b2.cacheWrite, write1h: b2.cacheWrite1h }, billing === "anthropic" || b2.cacheWrite > 0);
+    return { readCost: read, writeCost: write };
+  }
   /**
    * The last five hours and today (the host's local midnight). `nameOf` names a session; undefined for one that is
    * gone.
@@ -129551,9 +129900,13 @@ function windowOf(list, carried, id3, label, since, writes, nameOf3) {
     cacheCreationTokens: 0,
     rebuilds: 0,
     rebuildCauses: {},
+    rebuildTokens: 0,
+    cacheReadCost: 0,
+    cacheWriteCost: 0,
     sessions: []
   };
   const causes = w.rebuildCauses;
+  const unknownTokens = /* @__PURE__ */ new Set();
   const bySession = /* @__PURE__ */ new Map();
   for (const e of list) {
     if (e.at < since) continue;
@@ -129563,16 +129916,20 @@ function windowOf(list, carried, id3, label, since, writes, nameOf3) {
     w.cacheCreationTokens += e.write;
     let s = bySession.get(e.sessionId);
     if (!s) {
-      s = { sessionId: e.sessionId, name: "", requests: 0, inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, rebuilds: 0, rebuildCauses: {} };
+      s = { sessionId: e.sessionId, name: "", requests: 0, inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, rebuilds: 0, rebuildCauses: {}, rebuildTokens: 0 };
       bySession.set(e.sessionId, s);
     }
     s.requests++;
     s.inputTokens += e.input;
     s.cacheReadTokens += e.read;
     s.cacheCreationTokens += e.write;
+    w.cacheReadCost = (w.cacheReadCost ?? 0) + e.readCost;
+    w.cacheWriteCost = (w.cacheWriteCost ?? 0) + e.writeCost;
     if (!e.rebuild) continue;
     w.rebuilds++;
     s.rebuilds++;
+    w.rebuildTokens = (w.rebuildTokens ?? 0) + e.rebuildTokens;
+    s.rebuildTokens = (s.rebuildTokens ?? 0) + e.rebuildTokens;
     const cause2 = e.cause ?? "unknown";
     causes[cause2] = (causes[cause2] ?? 0) + 1;
     s.rebuildCauses[cause2] = (s.rebuildCauses[cause2] ?? 0) + 1;
@@ -129588,9 +129945,13 @@ function windowOf(list, carried, id3, label, since, writes, nameOf3) {
     w.cacheReadTokens += c.read;
     w.cacheCreationTokens += c.write;
     w.rebuilds += c.rebuilds;
+    if (c.rebuildTokens === null) unknownTokens.add(c.sessionId);
+    else w.rebuildTokens = (w.rebuildTokens ?? 0) + c.rebuildTokens;
+    w.cacheReadCost = (w.cacheReadCost ?? 0) + c.readCost;
+    w.cacheWriteCost = (w.cacheWriteCost ?? 0) + c.writeCost;
     let s = bySession.get(c.sessionId);
     if (!s) {
-      s = { sessionId: c.sessionId, name: "", requests: 0, inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, rebuilds: 0, rebuildCauses: {} };
+      s = { sessionId: c.sessionId, name: "", requests: 0, inputTokens: 0, cacheReadTokens: 0, cacheCreationTokens: 0, rebuilds: 0, rebuildCauses: {}, rebuildTokens: 0 };
       bySession.set(c.sessionId, s);
     }
     s.requests += c.requests;
@@ -129598,12 +129959,15 @@ function windowOf(list, carried, id3, label, since, writes, nameOf3) {
     s.cacheReadTokens += c.read;
     s.cacheCreationTokens += c.write;
     s.rebuilds += c.rebuilds;
+    if (c.rebuildTokens !== null) s.rebuildTokens = (s.rebuildTokens ?? 0) + c.rebuildTokens;
     const ofSession = s.rebuildCauses ??= {};
     for (const [cause2, n] of Object.entries(c.causes)) {
       causes[cause2] = (causes[cause2] ?? 0) + n;
       ofSession[cause2] = (ofSession[cause2] ?? 0) + n;
     }
   }
+  if (unknownTokens.size > 0) delete w.rebuildTokens;
+  for (const id4 of unknownTokens) delete bySession.get(id4)?.rebuildTokens;
   const cost = (s) => writes ? s.cacheCreationTokens : s.inputTokens;
   w.sessions = [...bySession.values()].filter((s) => cost(s) > 0).sort((a, b2) => cost(b2) - cost(a)).slice(0, TOP_SESSIONS).map((s) => ({ ...s, name: nameOf3(s.sessionId) ?? "" }));
   return w;
@@ -129640,7 +130004,7 @@ var UsageRecorder = class {
     if (!b2) {
       this.buckets.set(
         id3,
-        b2 = { hour, sessionId: src.sessionId, projectId, tool: src.tool, model, machine: "", requests: 0, input: 0, cacheRead: 0, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 0, rebuilds: 0, causes: {} }
+        b2 = { hour, sessionId: src.sessionId, projectId, tool: src.tool, model, machine: "", requests: 0, input: 0, cacheRead: 0, cacheWrite: 0, cacheWrite5m: 0, cacheWrite1h: 0, output: 0, rebuilds: 0, rebuildTokens: 0, causes: {} }
       );
     }
     const write = r.cacheCreationTokens ?? 0;
@@ -129648,11 +130012,12 @@ var UsageRecorder = class {
     b2.input += r.inputTokens;
     b2.cacheRead += r.cacheReadTokens;
     b2.cacheWrite += write;
-    if (r.cacheTtl === "5m") b2.cacheWrite5m += write;
-    if (r.cacheTtl === "1h") b2.cacheWrite1h += write;
+    b2.cacheWrite1h += r.cacheWrite1hTokens ?? (r.cacheTtl === "1h" ? write : 0);
+    b2.cacheWrite5m += r.cacheWrite5mTokens ?? (r.cacheTtl === "5m" ? write : 0);
     b2.output += r.outputTokens ?? 0;
     if (counted.rebuild) {
       b2.rebuilds++;
+      b2.rebuildTokens += paidTokens(r);
       const cause2 = counted.cause ?? "unknown";
       b2.causes[cause2] = (b2.causes[cause2] ?? 0) + 1;
     }
@@ -131008,10 +131373,10 @@ var ReaderGate = class {
     return this.storedMinReader() ?? 0;
   }
   refuseIfTooNew() {
-    const refusal = this.tooNew(this.dbPath);
-    if (!refusal) return;
+    const refusal2 = this.tooNew(this.dbPath);
+    if (!refusal2) return;
     this.db.close();
-    throw refusal;
+    throw refusal2;
   }
   /**
    * Why this host cannot open the store, or null. A record above this host refuses (#292). A record that is not a
@@ -133047,6 +133412,27 @@ var StepsV62 = class extends MigrationRange {
             CREATE INDEX IF NOT EXISTS idx_usage_buckets_session ON usage_buckets(session_id);
           `);
         }
+      },
+      {
+        to: 63,
+        breaksOlderReaders: false,
+        /**
+         * What the rebuilds wrote to the cache, per hour bucket (#1492): `usage_buckets.rebuild_tokens`, the sum of the cache writes
+         * of the requests counted in `rebuilds` (for a tool that reports no writes, the input it did not read), so the usage panel can
+         * say "7 rebuilds · 1.0M written" after a restart too. Hours stored before it have 0 with rebuilds counted: they are read as
+         * "not known" rather than as nothing written.
+         *
+         * **Expand only (#292's rule).** A defaulted column. An older host names its columns in every read and insert: it neither
+         * reads this one nor fails on it, and the row it adds or adds to keeps its sum (the upsert never touches the column), which
+         * leaves that hour's rebuilds with fewer tokens than rebuilds, as an hour from before. `IF` because a store from a test's
+         * partial schema has no such table.
+         */
+        run: () => {
+          const cols = this.db.prepare(`PRAGMA table_info(usage_buckets)`).all();
+          if (cols.length > 0 && !cols.some((c) => c.name === "rebuild_tokens")) {
+            this.db.exec(`ALTER TABLE usage_buckets ADD COLUMN rebuild_tokens INTEGER NOT NULL DEFAULT 0`);
+          }
+        }
       }
     ];
   }
@@ -137148,6 +137534,18 @@ var SessionManager = class {
       send: (id3, text2) => this.events.sendCompact(id3, text2),
       notice: (id3, text2) => this.onEvent({ type: "notice", sessionId: id3, level: "info", from: "Centralu", label: "compaction", text: text2 })
     });
+    this.contextNudges = new ContextNudges({
+      session: (id3) => this.meta.get(id3),
+      window: (m) => this.modelWindows.of(m),
+      setting: () => autoCompactOf(this.uiPreferences()),
+      // The two seats that have the tool (tool-seats.ts): an ordinary session and the orchestrator
+      hasCompactTool: (id3) => {
+        const profile = this.toolProfileOf(id3);
+        return profile === "reader" || profile === "orchestrator";
+      },
+      nudge: (id3, text2) => this.handles.get(id3)?.nudge?.(text2) ?? false,
+      notice: (id3, text2) => this.onEvent({ type: "notice", sessionId: id3, level: "info", from: "Centralu", label: "compaction", text: text2 })
+    });
     this.orchestratorSlot = new OrchestratorSlot(this.parts());
     const rawEmit = this.emit;
     this.emit = (full) => {
@@ -137218,7 +137616,7 @@ var SessionManager = class {
    */
   running = /* @__PURE__ */ new Map();
   /** Every model request's cache figures over the last day, per tool (docs/agent-host.md §6.1); read by `usageFor` */
-  cacheLedger = new CacheLedger();
+  cacheLedger = new CacheLedger(Date.now(), (tool) => this.adapters.get(tool)?.cacheBilling ?? "anthropic");
   /** The same requests summed per hour and kept, with the limit windows' readings (docs/agent-host.md §6.2) */
   usageRecorder;
   /** Each model's context window as the tools reported it, for where agents compact (#1376, auto-compact.ts) */
@@ -137281,6 +137679,8 @@ var SessionManager = class {
   updatesAsked;
   /** Compacting at a turn's end: the agent's `compact_self` and a session at rest over the lower share (#1451, self-compaction.ts) */
   selfCompaction;
+  /** The quiet notices that tell a growing session to call `compact_self` (#1492, context-nudges.ts) */
+  contextNudges;
   /** Whether a session of one project may reach another, and the consents remembered for it (project-consents.ts) */
   consents;
   /** The screen's preferences and workspace layout (ui-preferences.ts) */
@@ -137668,6 +138068,7 @@ var SessionManager = class {
   }
   stopSelfCompaction() {
     this.selfCompaction.stop();
+    this.contextNudges.stop();
   }
   /** Starts compacting the sessions at rest over the lower share (#1451); the shutdown plan stops it before the sessions are let go of */
   startSelfCompaction() {
@@ -138531,6 +138932,11 @@ var SessionManager = class {
         } catch (err) {
           console.error(`[compact] ${e.sessionId?.slice(0, 8) ?? "?"}: ${errorMessage(err)}`);
         }
+        try {
+          self2.contextNudges.observe(e);
+        } catch (err) {
+          console.error(`[compact] ${e.sessionId?.slice(0, 8) ?? "?"}: ${errorMessage(err)}`);
+        }
       },
       listAgents: (...a) => self2.delegationFlow.listAgents(...a),
       get agentRuns() {
@@ -138590,6 +138996,10 @@ var SessionManager = class {
         const tool = self2.meta.get(sessionId)?.tool;
         return tool !== void 0 && self2.adapters.get(tool)?.capabilities.midTurnInput === true;
       },
+      contextAtRequest: (sessionId) => {
+        const tool = self2.meta.get(sessionId)?.tool;
+        return tool !== void 0 && self2.adapters.get(tool)?.contextAtRequest === true;
+      },
       get children() {
         return self2.children;
       },
@@ -139176,6 +139586,7 @@ var SessionManager = class {
   async disposeAll() {
     this.usageRecorder.stop();
     this.selfCompaction.stop();
+    this.contextNudges.stop();
     this.sweepingHandles = true;
     try {
       await this.disposeEverything();
@@ -139207,6 +139618,7 @@ var SessionManager = class {
   async detachAll() {
     this.usageRecorder.stop();
     this.selfCompaction.stop();
+    this.contextNudges.stop();
     this.handingOver = true;
     this.leaveHost("Centralu is restarting");
     await Promise.allSettled([...[...this.handles.values()].map((h) => h.detach ? h.detach() : h.dispose()), ...this.merges.mergeChecks]);
@@ -139517,17 +139929,17 @@ var MailService = class {
         }
       }
       const reachable = [];
-      let refusal;
+      let refusal2;
       for (const to of this.recipients(thread.id, caller)) {
         try {
           this.mayWriteOrRefuse(caller, to, thread);
           reachable.push(to);
         } catch (e) {
           if (!(e instanceof Error) || refusalReason(e) === void 0) throw e;
-          refusal ??= e;
+          refusal2 ??= e;
         }
       }
-      if (refusal !== void 0 && reachable.length === 0) throw refusal;
+      if (refusal2 !== void 0 && reachable.length === 0) throw refusal2;
       if (sender.kind === "person") this.records.putParticipantIfAbsent(thread.id, PERSON, "member", now);
       const message = this.insertPost(thread.id, caller, input.kind, body, {}, input, now, input.replyTo, reachable);
       let after = thread;
@@ -150187,7 +150599,7 @@ var handedToken = launch.tokenOnStdin ? await readHandedToken(process.stdin).cat
   console.error(`[agent-host] the launcher did not hand over the token: ${e.message}`);
   process.exit(1);
 }) : launch.token;
-var BUILD = true ? "c20b51b" : "dev";
+var BUILD = true ? "50607f5" : "dev";
 var { values } = parseArgs({
   options: {
     port: { type: "string", default: "5175" },