@inetafrica/open-claudia 2.6.14 → 2.6.15

package/.env.example

@@ -21,6 +21,12 @@ CLAUDE_MODEL=claude-fable-5
 CURSOR_PATH=
 CODEX_PATH=
 AUTO_COMPACT_TOKENS=280000
+USAGE_ALERT_CONTEXT_TOKENS=120000
+USAGE_ALERT_RATE_MULTIPLIER=1.75
+USAGE_ALERT_BASELINE_TURNS=20
+USAGE_ALERT_MIN_BASELINE_TURNS=6
+USAGE_ALERT_COOLDOWN_MS=1800000
+MEMORY_RECALL_MAX_CHARS=9000
 PROJECT_TRANSCRIPTS=true
 TRANSCRIPT_MAX_ENTRY_CHARS=12000
 TRANSCRIPTS_DIR=

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## v2.6.15
+- **Tokenomics guardrails.** The Usage dashboard now shows the latest context-token count, recent baseline, current rate multiplier, and active alert policy above the existing per-version/token trend charts. Completed turns already logged to `~/.open-claudia/usage-history.jsonl`; the dashboard now uses that history to make regressions visible immediately after `/upgrade`.
+- **Hard memory recall budget.** Auto-recalled packs/entities now share a total `MEMORY_RECALL_MAX_CHARS` budget (default `9000`) after relevance filtering. Matched memory beyond the budget is omitted with a short pointer to inspect packs/entities manually, so long-term memory remains available without silently bloating every turn.
+- **Token usage alerts.** After each completed real turn, Open Claudia compares the new context-token count against an absolute ceiling (`USAGE_ALERT_CONTEXT_TOKENS`, default `120000`) and the recent baseline rate (`USAGE_ALERT_RATE_MULTIPLIER`, default `1.75x`). If either trips, the bot posts a concise chat alert with the current version/model, measured context, baseline, and reason. `USAGE_ALERT_COOLDOWN_MS` prevents repeated noise. Set either threshold to `off` to disable that side.
+- **Dashboard-tunable thresholds.** The web Settings page can edit `MEMORY_RECALL_MAX_CHARS`, `USAGE_ALERT_CONTEXT_TOKENS`, `USAGE_ALERT_RATE_MULTIPLIER`, `USAGE_ALERT_BASELINE_TURNS`, `USAGE_ALERT_MIN_BASELINE_TURNS`, and `USAGE_ALERT_COOLDOWN_MS`; restart the bot after saving so the runner picks up the new policy.
+
 ## v2.6.10
 - **Sessions: wakeups join the live conversation instead of forking it.** A scheduled wakeup/cron captured the channel's `sessionId` at schedule time and resumed that *frozen* id when it fired — but every run writes its result id back to the shared `state.lastSessionId`, and a home-conversation compaction mints a brand-new id. So a pending wakeup carrying a pre-compaction id would yank the channel's live pointer onto a dead thread, and the user's next typed message landed on the stale session. Multiple concurrent wakeups froze different ids and forked the channel into parallel sessions. Fix (`core/scheduler.js`): a wakeup now resumes the channel's live `state.lastSessionId` (already ownership-guarded in the runner); the frozen `job.sessionId` is used only as a cold-start fallback when there is no live pointer. Wakeups scheduled after upgrade join the current context; already-pending wakeups still carry their old id until they fire.
 

package/README.md

@@ -407,6 +407,10 @@ All stored in `~/.open-claudia/`:
 | `CLAUDE_CODE_OAUTH_TOKEN` | No | OAuth token for non-interactive Claude runs (set via `/use_oauth_token`) |
 | `CLAUDE_MODEL` | No | Default Claude model |
 | `AUTO_COMPACT_TOKENS` | No | Auto-compact threshold in tokens (also settable via `/compactwindow`) |
+| `USAGE_ALERT_CONTEXT_TOKENS` | No | Alert when one completed turn's context tokens exceed this ceiling (default `120000`, `off` disables) |
+| `USAGE_ALERT_RATE_MULTIPLIER` | No | Alert when the latest context-token rate exceeds the recent baseline by this multiple (default `1.75`, `off` disables) |
+| `USAGE_ALERT_BASELINE_TURNS` / `USAGE_ALERT_MIN_BASELINE_TURNS` / `USAGE_ALERT_COOLDOWN_MS` | No | Tune token-rate baseline size, minimum sample size, and alert cooldown |
+| `MEMORY_RECALL_MAX_CHARS` | No | Hard cap for auto-injected pack/entity memory per turn (default `9000`, `off` disables auto recall injection) |
 | `PROJECT_TRANSCRIPTS` | No | Enable redacted project transcripts (default `true`) |
 | `TRANSCRIPT_MAX_ENTRY_CHARS` | No | Max chars per transcript entry (default `12000`) |
 | `TRANSCRIPTS_DIR` / `PACKS_DIR` / `ENTITIES_DIR` | No | Override storage directories |

package/core/runner.js

@@ -9,7 +9,7 @@ const { spawn, execFileSync } = require("child_process");
 const {
   CLAUDE_PATH, DEFAULT_CLAUDE_MODEL, resolvedCursorPath, resolvedCodexPath,
   AUTO_COMPACT_TOKENS, MIN_COMPACT_INTERVAL_MS, MAX_PROCESS_TIMEOUT, COMPACT_SUMMARY_TIMEOUT, botSubprocessEnv,
-  CONFIG_DIR,
+  CONFIG_DIR, config,
 } = require("./config");
 const { currentState, saveState, recordSession, userOwnsClaudeSession } = require("./state");
 const { chatContext, currentChannelId, currentAdapter } = require("./context");
@@ -28,21 +28,31 @@ const skillsLib = require("./skills");
 const packsLib = require("./packs");
 const entitiesLib = require("./entities");
 const packReview = require("./pack-review");
-const { appendUsageRecord } = require("./usage-log");
+const {
+  appendUsageRecord,
+  loadUsageHistory,
+  usageAlertPolicy,
+  evaluateUsageAlert,
+} = require("./usage-log");
 
 const PKG_VERSION = require("../package.json").version;
 
 // One JSONL record per completed user turn (real turns only — compaction
 // summary/seed and sub-agent capture runs are excluded). Powers the web
 // dashboard's per-version tokenomics graphs.
-function logTurnUsage(state, usage, costUsd) {
-  if (!usage) return;
+function fmtTokens(n) {
+  n = Math.round(n || 0);
+  return n >= 1000 ? `${(n / 1000).toFixed(1)}k` : String(n);
+}
+
+function logTurnUsage(state, usage, costUsd, announce) {
+  if (!usage) return null;
   const backend = state.settings?.backend || "claude";
   const input = usage.input_tokens || 0;
   const cacheRead = usage.cache_read_input_tokens || usage.cached_input_tokens || 0;
   const cacheCreation = usage.cache_creation_input_tokens || 0;
   const output = usage.output_tokens || 0;
-  appendUsageRecord({
+  const record = {
     ts: new Date().toISOString(),
     version: PKG_VERSION,
     backend,
@@ -55,7 +65,28 @@ function logTurnUsage(state, usage, costUsd) {
     cacheCreationTokens: cacheCreation,
     contextTokens: input + cacheRead + cacheCreation,
     costUsd: typeof costUsd === "number" ? costUsd : 0,
-  });
+  };
+  const previousRecords = loadUsageHistory();
+  appendUsageRecord(record);
+
+  const policy = usageAlertPolicy(config);
+  const lastAlertAt = state.usageAlertLastAt || 0;
+  const result = evaluateUsageAlert(previousRecords, record, policy, lastAlertAt);
+  if (result.alert) {
+    state.usageAlertLastAt = Date.now();
+    if (announce) {
+      const baseline = result.trend?.baselineAvgContextTokens || 0;
+      const rate = result.trend?.latestRate || 0;
+      announce([
+        "Token usage alert:",
+        `Context this turn: ${fmtTokens(record.contextTokens)}`,
+        baseline ? `Recent baseline: ${fmtTokens(baseline)} (${rate.toFixed(2)}x)` : null,
+        `Version/model: v${record.version} / ${record.model || record.backend}`,
+        `Reason: ${result.reasons.join("; ")}`,
+      ].filter(Boolean).join("\n")).catch(() => {});
+    }
+  }
+  return record;
 }
 
 function telegramHtmlOpts(extra = {}) {
@@ -846,7 +877,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
         u.outputTokens += output;
         u.cacheReadTokens += cached;
         u.lastInputTokens = input + cached;
-        logTurnUsage(state, evt.usage, 0);
+        logTurnUsage(state, evt.usage, 0, (text) => chatContext.run(store, () => send(text)));
         saveState();
       }
       if (evt.type === "result" && evt.session_id) {
@@ -864,7 +895,7 @@ async function runClaude(prompt, cwd, replyToMsgId, opts = {}) {
             (evt.usage.cache_creation_input_tokens || 0);
           // Codex already logged this turn at turn.completed — don't double-count.
           if (settings.backend !== "codex") {
-            logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0);
+            logTurnUsage(state, evt.usage, typeof evt.total_cost_usd === "number" ? evt.total_cost_usd : 0, (text) => chatContext.run(store, () => send(text)));
           }
         }
         if (typeof evt.total_cost_usd === "number") state.sessionUsage.costUsd += evt.total_cost_usd;

package/core/system-prompt.js

@@ -4,7 +4,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, WHISPER_CLI, FFMPEG } = require("./config");
+const { SOUL_FILE, CRONS_FILE, VAULT_FILE, FILES_DIR, BOT_DIR, WHISPER_CLI, FFMPEG, config } = require("./config");
 const CONFIG_DIR = require("../config-dir");
 const { currentState } = require("./state");
 const { currentAdapter, currentChannelId } = require("./context");
@@ -284,6 +284,38 @@ function buildDynamicContextBlock() {
 // it's in the conversation the model keeps it until compaction.
 const packsInjectedFor = new Map(); // `${adapterId}:${channelId}:${dir}` -> `${sessionId}:${updated}`
 const PACK_INJECT_MAX_CHARS = 4000;
+const DEFAULT_MEMORY_RECALL_MAX_CHARS = 9000;
+
+function intSetting(key, fallback) {
+  const raw = config[key] ?? process.env[key];
+  if (raw === undefined || raw === null || raw === "") return fallback;
+  if (/^(off|false|disabled)$/i.test(String(raw).trim())) return 0;
+  const n = parseInt(String(raw).replace(/_/g, ""), 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function memoryRecallBudget() {
+  return {
+    maxChars: intSetting("MEMORY_RECALL_MAX_CHARS", DEFAULT_MEMORY_RECALL_MAX_CHARS),
+    usedChars: 0,
+    omitted: 0,
+  };
+}
+
+function tryUseRecallBudget(budget, text) {
+  if (!budget) return true;
+  if (budget.maxChars <= 0) {
+    budget.omitted += 1;
+    return false;
+  }
+  const n = String(text || "").length;
+  if (budget.usedChars + n > budget.maxChars) {
+    budget.omitted += 1;
+    return false;
+  }
+  budget.usedChars += n;
+  return true;
+}
 
 // What the last promptWithDynamicContext call freshly injected (not the
 // deduped repeats) — consumed by the runner to announce recalls in chat,
@@ -317,7 +349,7 @@ function formatPackForContext(pack, packsLib) {
   return clip(parts.join("\n\n"), PACK_INJECT_MAX_CHARS);
 }
 
-function buildPackBlock(matches) {
+function buildPackBlock(matches, budget) {
   try {
     const packsLib = require("./packs");
     if (matches.length === 0) return "";
@@ -339,9 +371,11 @@ function buildPackBlock(matches) {
       // as the task tree), so the pack survives compaction without paying
       // to re-stamp an anchor on every intervening turn.
       if (packsInjectedFor.get(key) === stamp) continue;
+      const block = formatPackForContext(pack, packsLib);
+      if (!tryUseRecallBudget(budget, block)) continue;
       packsInjectedFor.set(key, stamp);
       lastInjected.packs.push(pack.name || m.dir);
-      blocks.push(formatPackForContext(pack, packsLib));
+      blocks.push(block);
     }
     if (used.length > 0) setImmediate(() => { try { packsLib.touchUsed(used); } catch (e) {} });
     if (blocks.length === 0) return "";
@@ -368,7 +402,7 @@ function formatEntityForContext(ent) {
   return clip(parts.join("\n\n"), ENTITY_INJECT_MAX_CHARS);
 }
 
-function buildEntityBlock(matches) {
+function buildEntityBlock(matches, budget) {
   try {
     const entitiesLib = require("./entities");
     if (matches.length === 0) return "";
@@ -385,9 +419,11 @@ function buildEntityBlock(matches) {
       const key = `${adapter?.id || "?"}:${channelId || "?"}:${m.slug}`;
       const stamp = `${sess}:${ent.updated}`;
       if (entitiesInjectedFor.get(key) === stamp) continue;
+      const block = formatEntityForContext(ent);
+      if (!tryUseRecallBudget(budget, block)) continue;
       entitiesInjectedFor.set(key, stamp);
       lastInjected.entities.push(ent.name || m.slug);
-      blocks.push(formatEntityForContext(ent));
+      blocks.push(block);
     }
     if (seen.length > 0) setImmediate(() => { try { entitiesLib.touchSeen(seen); } catch (e) {} });
     if (blocks.length === 0) return "";
@@ -515,7 +551,13 @@ async function promptWithDynamicContext(prompt) {
     packMatches = packMatches.slice(0, 3);
     entityMatches = entityMatches.slice(0, 4);
     logRecall(userText, candPacks, candEntities, packMatches, entityMatches);
-    return `${buildDynamicContextBlock()}${buildPackBlock(packMatches)}${buildEntityBlock(entityMatches)}\n\nCurrent user request:\n${prompt}`;
+    const budget = memoryRecallBudget();
+    const packBlock = buildPackBlock(packMatches, budget);
+    const entityBlock = buildEntityBlock(entityMatches, budget);
+    const budgetNote = budget.omitted > 0
+      ? `\n\n## Memory budget\n${budget.omitted} matched memory item${budget.omitted === 1 ? " was" : "s were"} omitted to keep this turn under the recall budget (${budget.maxChars} chars). Use \`open-claudia pack show <dir>\`, \`entity show <slug>\`, or transcript search if deeper context is needed.`
+      : "";
+    return `${buildDynamicContextBlock()}${packBlock}${entityBlock}${budgetNote}\n\nCurrent user request:\n${prompt}`;
   } catch (e) {
     return prompt;
   }

package/core/usage-log.js

@@ -14,4 +14,97 @@ function appendUsageRecord(record) {
   } catch (e) {}
 }
 
-module.exports = { appendUsageRecord, USAGE_HISTORY_FILE };
+function loadUsageHistory() {
+  let raw;
+  try { raw = fs.readFileSync(USAGE_HISTORY_FILE, "utf-8"); } catch (e) { return []; }
+  const out = [];
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try { out.push(JSON.parse(t)); } catch (e) {}
+  }
+  return out;
+}
+
+function intEnv(env, key, fallback) {
+  const raw = env[key] ?? process.env[key];
+  if (raw === undefined || raw === null || raw === "") return fallback;
+  if (/^(off|false|disabled)$/i.test(String(raw).trim())) return 0;
+  const n = parseInt(String(raw).replace(/_/g, ""), 10);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function floatEnv(env, key, fallback) {
+  const raw = env[key] ?? process.env[key];
+  if (raw === undefined || raw === null || raw === "") return fallback;
+  if (/^(off|false|disabled)$/i.test(String(raw).trim())) return 0;
+  const n = parseFloat(String(raw));
+  return Number.isFinite(n) ? n : fallback;
+}
+
+function usageAlertPolicy(env = {}) {
+  const absoluteContextTokens = intEnv(env, "USAGE_ALERT_CONTEXT_TOKENS", 120000);
+  const rateMultiplier = floatEnv(env, "USAGE_ALERT_RATE_MULTIPLIER", 1.75);
+  return {
+    enabled: absoluteContextTokens > 0 || rateMultiplier > 0,
+    absoluteContextTokens,
+    rateMultiplier,
+    baselineTurns: intEnv(env, "USAGE_ALERT_BASELINE_TURNS", 20),
+    minBaselineTurns: intEnv(env, "USAGE_ALERT_MIN_BASELINE_TURNS", 6),
+    cooldownMs: intEnv(env, "USAGE_ALERT_COOLDOWN_MS", 30 * 60 * 1000),
+  };
+}
+
+function avg(nums) {
+  if (!nums.length) return 0;
+  return nums.reduce((a, b) => a + b, 0) / nums.length;
+}
+
+function usageTrend(records, policy = usageAlertPolicy()) {
+  const usable = records.filter((r) => Number.isFinite(r.contextTokens));
+  const latest = usable[usable.length - 1] || null;
+  const previous = usable.slice(0, -1);
+  const baselineRecords = previous.slice(-Math.max(1, policy.baselineTurns || 20));
+  const baselineAvgContextTokens = avg(baselineRecords.map((r) => r.contextTokens || 0));
+  const latestRate = baselineAvgContextTokens && latest
+    ? latest.contextTokens / baselineAvgContextTokens
+    : 0;
+  return {
+    latest,
+    baselineTurns: baselineRecords.length,
+    baselineAvgContextTokens,
+    latestRate,
+  };
+}
+
+function evaluateUsageAlert(previousRecords, record, policy = usageAlertPolicy(), lastAlertAt = 0) {
+  if (!policy.enabled || !record) return { alert: false };
+  const now = Date.now();
+  if (lastAlertAt && policy.cooldownMs > 0 && now - lastAlertAt < policy.cooldownMs) {
+    return { alert: false, suppressed: true };
+  }
+  const contextTokens = record.contextTokens || 0;
+  const combined = [...previousRecords, record];
+  const trend = usageTrend(combined, policy);
+  const reasons = [];
+  if (policy.absoluteContextTokens > 0 && contextTokens >= policy.absoluteContextTokens) {
+    reasons.push(`context ${contextTokens} >= ${policy.absoluteContextTokens}`);
+  }
+  if (
+    policy.rateMultiplier > 0 &&
+    trend.baselineTurns >= policy.minBaselineTurns &&
+    trend.latestRate >= policy.rateMultiplier
+  ) {
+    reasons.push(`rate ${trend.latestRate.toFixed(2)}x recent baseline`);
+  }
+  return { alert: reasons.length > 0, reasons, trend };
+}
+
+module.exports = {
+  appendUsageRecord,
+  loadUsageHistory,
+  usageAlertPolicy,
+  usageTrend,
+  evaluateUsageAlert,
+  USAGE_HISTORY_FILE,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@inetafrica/open-claudia",
-  "version": "2.6.14",
+  "version": "2.6.15",
   "description": "Your always-on AI coding assistant — Claude Code, Cursor Agent, and OpenAI Codex via Telegram or Kazee Chat",
   "main": "bot.js",
   "bin": {

package/web.js

@@ -5,6 +5,11 @@ const crypto = require("crypto");
 const https = require("https");
 const CONFIG_DIR = require("./config-dir");
 const Vault = require("./vault");
+const {
+  loadUsageHistory,
+  usageAlertPolicy,
+  usageTrend,
+} = require("./core/usage-log");
 
 const ENV_FILE = path.join(CONFIG_DIR, ".env");
 const AUTH_FILE = path.join(CONFIG_DIR, "auth.json");
@@ -12,7 +17,6 @@ const SOUL_FILE = path.join(CONFIG_DIR, "soul.md");
 const CRONS_FILE = path.join(CONFIG_DIR, "crons.json");
 const SESSIONS_FILE = path.join(CONFIG_DIR, "sessions.json");
 const WEB_PASSWORD_FILE = path.join(CONFIG_DIR, ".web-password");
-const USAGE_HISTORY_FILE = path.join(CONFIG_DIR, "usage-history.jsonl");
 const PORT = parseInt(process.env.WEB_PORT || "8080", 10);
 
 // ── Password management ────────────────────────────────────────────
@@ -181,18 +185,6 @@ function isConfigured() {
   return fs.existsSync(ENV_FILE);
 }
 
-function loadUsageHistory() {
-  let raw;
-  try { raw = fs.readFileSync(USAGE_HISTORY_FILE, "utf-8"); } catch (e) { return []; }
-  const out = [];
-  for (const line of raw.split("\n")) {
-    const t = line.trim();
-    if (!t) continue;
-    try { out.push(JSON.parse(t)); } catch (e) {}
-  }
-  return out;
-}
-
 // Group usage records by a key (version / model) and return per-group
 // averages so the dashboard can compare tokenomics across versions.
 function aggregateUsage(records, keyName) {
@@ -340,7 +332,13 @@ async function handleAPI(req, res, body) {
 
   // Update config (whitelist safe keys only)
   if (url === "/api/config" && req.method === "POST") {
-    const SAFE_KEYS = new Set(["WORKSPACE", "CLAUDE_PATH", "WHISPER_CLI", "FFMPEG", "WHISPER_MODEL"]);
+    const SAFE_KEYS = new Set([
+      "WORKSPACE", "CLAUDE_PATH", "WHISPER_CLI", "FFMPEG", "WHISPER_MODEL",
+      "MEMORY_RECALL_MAX_CHARS",
+      "USAGE_ALERT_CONTEXT_TOKENS", "USAGE_ALERT_RATE_MULTIPLIER",
+      "USAGE_ALERT_BASELINE_TURNS", "USAGE_ALERT_MIN_BASELINE_TURNS",
+      "USAGE_ALERT_COOLDOWN_MS",
+    ]);
     const updates = JSON.parse(body);
     const env = loadEnv();
     for (const [key, value] of Object.entries(updates)) {
@@ -434,11 +432,17 @@ async function handleAPI(req, res, body) {
   if (url === "/api/usage") {
     const records = loadUsageHistory();
     const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf-8"));
+    const env = loadEnv();
+    const alertPolicy = usageAlertPolicy(env);
+    const trend = usageTrend(records, alertPolicy);
     const series = records.slice(-500).map((r) => ({
       ts: r.ts,
       version: r.version || "?",
       contextTokens: r.contextTokens || 0,
       outputTokens: r.outputTokens || 0,
+      inputTokens: r.inputTokens || 0,
+      cacheReadTokens: r.cacheReadTokens || 0,
+      cacheCreationTokens: r.cacheCreationTokens || 0,
     }));
     res.writeHead(200, { "Content-Type": "application/json" });
     return res.end(JSON.stringify({
@@ -446,6 +450,8 @@ async function handleAPI(req, res, body) {
       totalRecords: records.length,
       byVersion: aggregateUsage(records, "version"),
       byModel: aggregateUsage(records, "model"),
+      alertPolicy,
+      trend,
       series,
     }));
   }
@@ -520,6 +526,12 @@ function getHTML() {
   .msg.ok { background: #052e16; color: #22c55e; }
   .msg.err { background: #2a0a0a; color: #dc2626; }
   .hidden { display: none; }
+  .metric-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(150px, 1fr)); gap: 12px; margin-top: 12px; }
+  .metric { background: #0f0f0f; border: 1px solid #262626; border-radius: 8px; padding: 12px; }
+  .metric .label { color: #888; font-size: 12px; margin-bottom: 6px; }
+  .metric .value { color: #fff; font-size: 22px; font-weight: 650; }
+  .metric.warn .value { color: #f97316; }
+  .policy { color:#aaa; font-size:13px; line-height:1.5; margin-top:12px; }
   table.usage-table { width: 100%; border-collapse: collapse; font-size: 13px; }
   table.usage-table th, table.usage-table td { text-align: left; padding: 8px 6px; border-bottom: 1px solid #222; white-space: nowrap; }
   table.usage-table th { color: #888; font-weight: 500; }
@@ -652,10 +664,24 @@ async function loadTab() {
       el.innerHTML = '<div class="card"><h2>Token Usage</h2><p style="color:#888">No usage recorded yet. Send a few messages and check back — each turn is logged with the running version.</p></div>';
       return;
     }
+    const latestCtx = u.trend && u.trend.latest ? u.trend.latest.contextTokens : 0;
+    const baselineCtx = u.trend ? u.trend.baselineAvgContextTokens : 0;
+    const latestRate = u.trend ? u.trend.latestRate : 0;
+    const rateWarn = u.alertPolicy && u.alertPolicy.rateMultiplier > 0 && latestRate >= u.alertPolicy.rateMultiplier;
     el.innerHTML =
+      '<div class="card">' +
+        '<h2>Token Rate</h2>' +
+        '<p style="color:#888;font-size:13px;">Current: v' + u.currentVersion + ' · ' + u.totalRecords + ' turns logged</p>' +
+        '<div class="metric-grid">' +
+          '<div class="metric"><div class="label">Latest context</div><div class="value">' + fmtK(latestCtx) + '</div></div>' +
+          '<div class="metric"><div class="label">Recent baseline</div><div class="value">' + fmtK(baselineCtx) + '</div></div>' +
+          '<div class="metric ' + (rateWarn ? 'warn' : '') + '"><div class="label">Current rate</div><div class="value">' + fmtRate(latestRate) + '</div></div>' +
+        '</div>' +
+        usagePolicyHTML(u.alertPolicy, u.trend) +
+      '</div>' +
       '<div class="card">' +
         '<h2>Avg context tokens / turn — by version</h2>' +
-        '<p style="color:#888;font-size:13px;margin-bottom:12px;">Lower is better. Current: v' + u.currentVersion + ' · ' + u.totalRecords + ' turns logged</p>' +
+        '<p style="color:#888;font-size:13px;margin-bottom:12px;">Lower is better. Compare this after each /upgrade.</p>' +
         '<canvas id="chart-version" height="150"></canvas>' +
       '</div>' +
       '<div class="card">' +
@@ -763,7 +789,13 @@ async function loadTab() {
       </div>\`;
     const config = await api("/api/config");
     if (!config) return;
-    const safe = ["WORKSPACE", "CLAUDE_PATH", "WHISPER_CLI", "FFMPEG", "WHISPER_MODEL"];
+    const safe = [
+      "WORKSPACE", "CLAUDE_PATH", "WHISPER_CLI", "FFMPEG", "WHISPER_MODEL",
+      "MEMORY_RECALL_MAX_CHARS",
+      "USAGE_ALERT_CONTEXT_TOKENS", "USAGE_ALERT_RATE_MULTIPLIER",
+      "USAGE_ALERT_BASELINE_TURNS", "USAGE_ALERT_MIN_BASELINE_TURNS",
+      "USAGE_ALERT_COOLDOWN_MS",
+    ];
     $("#config-fields").innerHTML = safe.map(k => \`
       <div class="form-group"><label>\${k}</label><input id="cfg-\${k}" value="\${config[k] || ""}"></div>
     \`).join("");
@@ -771,6 +803,22 @@ async function loadTab() {
 }
 
 function fmtK(n) { n = Math.round(n || 0); return n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n); }
+function fmtRate(n) { return n ? n.toFixed(2) + "x" : "—"; }
+
+function usagePolicyHTML(policy, trend) {
+  if (!policy || !policy.enabled) {
+    return '<div class="policy">Alerts disabled. Set USAGE_ALERT_CONTEXT_TOKENS or USAGE_ALERT_RATE_MULTIPLIER to enable them.</div>';
+  }
+  const parts = [];
+  if (policy.absoluteContextTokens > 0) parts.push('absolute ceiling ' + fmtK(policy.absoluteContextTokens));
+  if (policy.rateMultiplier > 0) {
+    parts.push('rate ceiling ' + policy.rateMultiplier + 'x after ' + policy.minBaselineTurns + ' baseline turns');
+  }
+  const baseline = trend && trend.baselineTurns ? trend.baselineTurns : 0;
+  return '<div class="policy">Alert policy: ' + parts.join(' · ') +
+    ' · cooldown ' + Math.round((policy.cooldownMs || 0) / 60000) + ' min' +
+    ' · baseline sample ' + baseline + '/' + policy.baselineTurns + ' turns</div>';
+}
 
 function usageTableHTML(rows, keyName) {
   if (!rows || !rows.length) return '<p style="color:#888">No data.</p>';