@inetafrica/open-claudia 3.5.16 → 3.5.18

package/core/dream.js

@@ -12,6 +12,7 @@
 const fs = require("fs");
 const path = require("path");
 const cron = require("node-cron");
+const { scheduleTolerant } = require("./cron-schedule");
 const { atomicWriteFileSync } = require("./fsutil");
 const { memoryMutationQueue } = require("./memory-mutation-queue");
 
@@ -937,20 +938,40 @@ function writeDreamReport(data) {
 
 // Task-hygiene pass: surface tasks gone cold for the owner to decide on.
 // Flag-and-ask only — tasks are user intent, so dream NEVER edits or deletes
-// them; it just lists the stalest few in the morning report. Reports against
-// the owner's Telegram channel (where the dream summary lands).
+// them; it just lists the stalest few in the morning report. It covers every
+// task list on this bot (tasks.taskLists): task kinds are owner-only, so each
+// list is the owner's, whether it lives in Telegram, a Kazee chat or another
+// channel. (It used to read only the Telegram CHAT_ID list, so an owner who
+// works in Kazee never got a report.) At most STALE_REPORT_MAX task lines in
+// all, shared out across the lists, each naming its list.
 const STALE_REPORT_MAX = Number(process.env.DREAM_STALE_TASK_MAX) || 8;
-function staleTaskReport() {
+function staleTaskReport(opts = {}) {
   try {
     const tasks = require("./tasks");
-    const { CHAT_ID } = require("./config");
-    if (!CHAT_ID) return "";
-    const stale = tasks.staleRoots("telegram", String(CHAT_ID));
-    if (!stale.length) return "";
-    const shown = stale.slice(0, STALE_REPORT_MAX);
-    const lines = shown.map((s) => `   - ${s.content}  (${s.id}) · ${s.idleDays}d idle`);
-    const more = stale.length > shown.length ? `\n   …and ${stale.length - shown.length} more` : "";
-    return `🧹 ${stale.length} task${stale.length === 1 ? "" : "s"} have gone cold (untouched >${tasks.STALE_DAYS}d). Worth closing or reviving?\n${lines.join("\n")}${more}\nClose with \`open-claudia task done <id>\`, or tell me to.`;
+    const lists = tasks.taskLists(opts.dir)
+      .map((list) => ({ ...list, stale: tasks.staleRootsOf(tasks.loadFile(list.file), { now: opts.now }) }))
+      .filter((list) => list.stale.length > 0)
+      .sort((a, b) => b.stale.length - a.stale.length);
+    if (!lists.length) return "";
+    const total = lists.reduce((n, list) => n + list.stale.length, 0);
+    const max = Number.isFinite(opts.max) ? opts.max : STALE_REPORT_MAX;
+    // Round-robin, oldest first within each list, so every list gets a line.
+    const shown = [];
+    for (let i = 0; shown.length < max; i += 1) {
+      const before = shown.length;
+      for (const list of lists) {
+        if (shown.length >= max) break;
+        if (list.stale[i]) shown.push({ list, task: list.stale[i] });
+      }
+      if (shown.length === before) break;
+    }
+    const clip = (text) => (String(text).length > 80 ? `${String(text).slice(0, 79)}…` : String(text));
+    const lines = shown.map(({ list, task }) => `   - [${list.label}] ${clip(task.content)}  (${task.id}) · ${task.idleDays}d idle`);
+    const where = lists.length === 1 ? `in ${lists[0].label}` : `across ${lists.length} task lists`;
+    const more = total > shown.length
+      ? `\n   …and ${total - shown.length} more (${lists.map((list) => `${list.label}: ${list.stale.length}`).join(" · ")})`
+      : "";
+    return `🧹 ${total} task${total === 1 ? "" : "s"} have gone cold (untouched >${tasks.STALE_DAYS}d) ${where}. Worth closing or reviving?\n${lines.join("\n")}${more}\nClose with \`open-claudia task done <id>\` in that chat, or tell me to.`;
   } catch (e) { return ""; }
 }
 
@@ -1566,37 +1587,123 @@ const defaultDreamService = createDreamService();
 const runDream = defaultDreamService.runDream;
 const previewDream = defaultDreamService.previewDream;
 
-// In-bot scheduler: one quiet-hours cron, reporting to the owner's
-// Telegram chat. When the dream summary is on (default) it posts a short
-// note after every run — including the charming "all tidy" line when
-// nothing changed. /dreamsummary off mutes it to console only.
-function initDream(adapters) {
-  if (!enabled()) return;
-  if (!cron.validate(DREAM_CRON)) {
-    console.error(`dream: invalid DREAM_CRON "${DREAM_CRON}" — dream disabled`);
-    return;
+// Where the dream summary goes: DREAM_SUMMARY_TO ("<adapter>:<channelId>") if
+// set; else the owner's primary handle from the people roster when its
+// adapter is loaded (a Kazee user-id handle resolves to the owner's DM); else
+// the Telegram owner chat (CHAT_ID). It used to go only to Telegram, so a
+// Kazee-only owner never saw it. null = nowhere to send.
+async function dreamSummaryTarget(adapters, deps = {}) {
+  const list = adapters || [];
+  const find = (name) => list.find((a) => a.id === name) || list.find((a) => a.type === name) || null;
+  const to = String(deps.summaryTo ?? process.env.DREAM_SUMMARY_TO ?? config.DREAM_SUMMARY_TO ?? "").trim();
+  if (to) {
+    const cut = to.indexOf(":");
+    const adapter = cut > 0 ? find(to.slice(0, cut)) : null;
+    if (adapter && to.slice(cut + 1)) return { adapter, channelId: to.slice(cut + 1), via: "DREAM_SUMMARY_TO" };
+    console.warn(`dream: DREAM_SUMMARY_TO "${to}" names no loaded adapter; using the owner's channel`);
   }
-  cron.schedule(DREAM_CRON, async () => {
-    try {
-      const res = await runDream({ trigger: "cron" });
-      if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return; }
-      console.log(`dream: applied ${res.applied.length} change(s)`);
-      if (!summaryEnabled()) { console.log("dream: summary muted (DREAM_SUMMARY=off)"); return; }
-      if (!res.message) return;
-      const { CHAT_ID } = require("./config");
-      const tg = (adapters || []).find((a) => a.type === "telegram");
-      if (tg && CHAT_ID) await tg.send(CHAT_ID, res.message);
-    } catch (e) {
-      console.error("dream: run failed:", e.message);
+  try {
+    const peopleLib = deps.people || require("./people");
+    const owner = (peopleLib.owners() || [])[0];
+    const handles = owner?.handles || [];
+    const handle = owner?.primaryChannel
+      ? handles.find((h) => h.adapter === owner.primaryChannel.adapter && String(h.channelId) === String(owner.primaryChannel.channelId))
+      : null;
+    const adapter = handle ? find(handle.adapter) : null;
+    if (adapter) {
+      const resolve = deps.resolveHandle || require("./relationship").resolveHandleSendTarget;
+      const target = await resolve(handle);
+      if (target?.channelId) return { adapter, channelId: String(target.channelId), via: "owner primary handle" };
     }
+  } catch (e) { /* fall back to Telegram */ }
+  const chatId = deps.chatId !== undefined ? deps.chatId : require("./config").CHAT_ID;
+  const tg = find("telegram");
+  if (tg && chatId) return { adapter: tg, channelId: String(chatId), via: "TELEGRAM_CHAT_ID" };
+  return null;
+}
+
+// One scheduled dream (cron or catch-up) with its summary.
+async function runScheduledDream(trigger, adapters, deps = {}) {
+  try {
+    const res = await (deps.runDream || runDream)({ trigger });
+    if (res.skipped) { console.log(`dream: skipped — ${res.skipped}`); return res; }
+    console.log(`dream: applied ${(res.applied || []).length} change(s)`);
+    if (!summaryEnabled()) { console.log("dream: summary muted (DREAM_SUMMARY=off)"); return res; }
+    if (!res.message) return res;
+    const target = await dreamSummaryTarget(adapters, deps);
+    if (!target) { console.warn("dream: no channel to send the summary to"); return res; }
+    await target.adapter.send(target.channelId, res.message);
+    return res;
+  } catch (e) {
+    console.error("dream: run failed:", e.message);
+    return { failed: e.message };
+  }
+}
+
+// Catch-up: a dream that has not run for more than DREAM_CATCHUP_HOURS (26 h)
+// runs once now, checked at boot and hourly — a night the bot was down or the
+// cron slot was missed is not lost. At most one catch-up attempt per window
+// (stamped in the dream state, so a failing dream is not retried every hour),
+// and never beside a running dream.
+const DREAM_CATCHUP_MS = (Number(process.env.DREAM_CATCHUP_HOURS) || 26) * 3600000;
+function dreamOverdue(state, nowMs, windowMs = DREAM_CATCHUP_MS) {
+  const last = Date.parse(state?.lastRun || "");
+  if (Number.isFinite(last) && nowMs - last <= windowMs) return false;
+  const tried = Date.parse(state?.lastCatchUpAt || "");
+  return !(Number.isFinite(tried) && nowMs - tried <= windowMs);
+}
+
+function createDreamCatchUp(adapters, deps = {}) {
+  const now = deps.now || Date.now;
+  const readState = deps.readState || readDreamState;
+  const writeState = deps.writeState || writeDreamState;
+  const isDreaming = deps.isDreaming || defaultDreamService.isDreaming;
+  let inFlight = null;
+  return async function catchUp(reason = "check") {
+    if (inFlight || isDreaming()) return { skipped: "a dream is already running" };
+    const state = readState() || {};
+    if (!dreamOverdue(state, now())) return { skipped: "not overdue" };
+    writeState({ ...state, lastCatchUpAt: new Date(now()).toISOString() });
+    console.log(`dream: catch-up (${reason}) — last run ${state.lastRun || "never"}`);
+    inFlight = runScheduledDream("catch-up", adapters, deps);
+    try { return await inFlight; } finally { inFlight = null; }
+  };
+}
+
+// In-bot scheduler: one quiet-hours cron (tolerating a late start up to
+// DREAM_LATE_TOLERANCE_MS, see core/cron-schedule), a boot + hourly catch-up
+// check, and the summary to the owner's channel (dreamSummaryTarget). When the
+// dream summary is on (default) it posts a short note after every run —
+// including the charming "all tidy" line when nothing changed.
+// /dreamsummary off mutes it to console only.
+function initDream(adapters, deps = {}) {
+  if (!enabled()) return null;
+  const cronLib = deps.cron || cron;
+  if (!cronLib.validate(DREAM_CRON)) {
+    console.error(`dream: invalid DREAM_CRON "${DREAM_CRON}" — dream disabled`);
+    return null;
+  }
+  const { DREAM_LATE_TOLERANCE_MS } = require("./config");
+  const toleranceMs = Number.isFinite(deps.toleranceMs) ? deps.toleranceMs : DREAM_LATE_TOLERANCE_MS;
+  const task = scheduleTolerant(DREAM_CRON, () => runScheduledDream("cron", adapters, deps), {
+    cron: cronLib, toleranceMs, noOverlap: true, label: "dream",
   });
-  console.log(`dream: scheduled (${DREAM_CRON}, provider policy tier ${dreamTier()}, effort ${DREAM_EFFORT}, introspect ${introspectEnabled() ? "on" : "off"})`);
+  const catchUp = createDreamCatchUp(adapters, deps);
+  const setTimer = deps.setTimer || setTimeout;
+  const setRepeat = deps.setInterval || setInterval;
+  const boot = setTimer(() => { catchUp("boot").catch(() => {}); }, Number.isFinite(deps.bootDelayMs) ? deps.bootDelayMs : 60000);
+  const hourly = setRepeat(() => { catchUp("hourly").catch(() => {}); }, 3600000);
+  boot?.unref?.();
+  hourly?.unref?.();
+  console.log(`dream: scheduled (${DREAM_CRON}, late tolerance ${Math.round(toleranceMs / 60000)} min, provider policy tier ${dreamTier()}, effort ${DREAM_EFFORT}, introspect ${introspectEnabled() ? "on" : "off"})`);
+  return { task, catchUp };
 }
 
 module.exports = {
   createDreamService, previewDream, runDream, initDream, buildDreamPrompt, parseDream, applyDream, manageAbilityTiers, nestPrefixFamilies, dreamTimeoutMs,
   buildIntrospectionPrompt, parseIntrospection, applyIntrospection, writeDreamReport,
-  summaryDelta, healthOf, mergeClusters, selectDumpDirs, journalBackfillDedupe,
+  summaryDelta, healthOf, mergeClusters, selectDumpDirs, journalBackfillDedupe, staleTaskReport,
+  dreamSummaryTarget, runScheduledDream, dreamOverdue, createDreamCatchUp, DREAM_CATCHUP_MS,
   coRescueEdgesPhase, negativeHebbianPhase, readDreamState, writeDreamState,
   enabled, summaryEnabled, introspectEnabled, selfApplyEnabled, dreamTier,
   DREAM_CRON, DREAM_EFFORT, DREAM_OUTPUT_SCHEMA, INTROSPECTION_OUTPUT_SCHEMA,

package/core/guardrail.js

@@ -59,6 +59,10 @@ const MED_OPENER = /^(?:always|don'?t|do not|make sure|be sure|remember to|prefe
 
 // Junk that pattern-matches a directive but is never a rule.
 const STOP_RULES = new Set(["never mind", "nevermind", "stop it", "never ever", "don't worry", "do not worry"]);
+// Reassurances open like directives but never carry a rule, however they go
+// on: "Don't worry so much about that.", "Never mind, I found it." (the
+// latter would otherwise read as a high-tier never-directive).
+const REASSURANCE = /^(?:don'?t worry|do not worry|never ?mind)\b/i;
 
 function splitSentences(text) {
   return String(text || "")
@@ -92,6 +96,7 @@ function ruleOk(rule) {
   if (!rule || rule.length < MIN_RULE_CHARS) return false;
   const low = rule.toLowerCase();
   if (STOP_RULES.has(low)) return false;
+  if (REASSURANCE.test(rule)) return false;
   if (low.split(/\s+/).length < MIN_RULE_WORDS) return false;
   return true;
 }

package/core/handlers.js

@@ -7,7 +7,7 @@ const path = require("path");
 const cronLib = require("node-cron");
 const { execSync } = require("child_process");
 const {
-  WORKSPACE, FULL_PATH, AUTO_COMPACT_TOKENS, CONFIG_DIR,
+  WORKSPACE, FULL_PATH, CONFIG_DIR,
   config, saveEnvKey,
   CHAT_ID, discoverProviderExecutable, SOUL_FILE,
 } = require("./config");
@@ -38,7 +38,7 @@ const scheduler = require("./scheduler");
 const skillsLib = require("./skills");
 const packsLib = require("./packs");
 const {
-  admitRunContext, runAgent, compactActiveSession, getActiveSessionId, effectiveCompactThreshold,
+  admitRunContext, runAgent, compactActiveSession, getActiveSessionId, effectiveCompactThreshold, defaultCompactTokens,
 } = require("./runner");
 const {
   getClaudeOAuthToken, saveClaudeOAuthToken,
@@ -87,12 +87,25 @@ function cancelledQueueResult(item, reason) {
   };
 }
 
+// A pick-up waiting for a usage limit to reset (core/limit-pickup.js) in
+// the current conversation, dropped by /stop, /new and /end.
+function dropLimitPickup(reason, state = currentState(), laneKey = currentLaneKey(state)) {
+  try { return require("./limit-pickup").cancel(state.userId, laneKey, reason); } catch (_) { return null; }
+}
+
+function pickupDroppedNote(count) {
+  return count === 1
+    ? "I won't pick up your earlier message when the usage limit resets."
+    : `I won't pick up your ${count} earlier messages when the usage limits reset.`;
+}
+
 // Drops every message queued in one lane: each one's caller gets a cancelled
 // result (no hanging promise), and an idle lane loses its typing heartbeat (the
 // chip would stay on, and the lane could never be pruned). Returns the items.
 function dropLaneQueue(lane, reason) {
   if (!lane) return [];
   const queued = lane.messageQueue.splice(0);
+  try { require("./turn-journal").dropQueued(lane.key, queued.map((item) => item?.runContext?.runId).filter(Boolean)); } catch (_) {}
   lane.waitingForSlot = false;
   for (const item of queued) {
     try { item?.disposeCallListener?.(); } catch (_) {}
@@ -592,7 +605,8 @@ register({
     if (!ownerEnv(env)) return;
     await send("Going offline for a quick restart — back in a moment.");
     try { require("./restart-reason").recordExitReason("User /restart command", { code: 0 }); } catch (e) {}
-    setTimeout(() => process.exit(0), 1000);
+    // Running turns get DRAIN_TIMEOUT_S to finish; the rest resume after boot.
+    setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 1000);
   },
 });
 
@@ -854,7 +868,7 @@ register({
       try { require("./boot-health").recordPendingDoctor({ reason: "source overlay upgrade", from: CURRENT_VERSION, to: newVersion }); } catch (e) {}
       try { require("./safe-mode").clearCrashLoop(); } catch (e) {}
       try { require("./restart-reason").recordExitReason(`User /upgrade → v${newVersion} (source refresh)`, { code: 0 }); } catch (e) {}
-      setTimeout(() => process.exit(0), 2000);
+      setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
       return;
     }
     try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) {}
@@ -918,7 +932,7 @@ register({
       await send(`Upgrade failed:\n${errOutput}`);
       return;
     }
-    setTimeout(() => process.exit(0), 2000);
+    setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
   },
 });
 
@@ -982,7 +996,7 @@ register({
       try { require("./boot-health").recordPendingDoctor({ reason: "downgrade overlay", from: CURRENT_VERSION, to: resolved }); } catch (e) {}
       try { safeModeLib.clearCrashLoop(); } catch (e) {}
       try { require("./restart-reason").recordExitReason(`User /downgrade → v${resolved} (source refresh)`, { code: 0 }); } catch (e) {}
-      setTimeout(() => process.exit(0), 2000);
+      setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
       return;
     }
     try { process.chdir(process.env.HOME || require("os").homedir()); } catch (e) {}
@@ -1002,7 +1016,7 @@ register({
       await send(`Downgrade failed:\n${errOutput}`);
       return;
     }
-    setTimeout(() => process.exit(0), 2000);
+    setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 2000);
   },
 });
 
@@ -1020,7 +1034,7 @@ register({
       safeModeLib.requestContinue();
       await send("Override armed: the next boot runs normally even if the substrate is missing (keyword-only memory) and the crash-loop counter resets. Restarting now...");
       try { require("./restart-reason").recordExitReason("User /safemode continue override", { code: 0 }); } catch (e) {}
-      setTimeout(() => process.exit(0), 1500);
+      setTimeout(() => { require("./turn-journal").exitAfterDrain(0); }, 1500);
       return;
     }
     if (safeModeLib.isSafeMode()) {
@@ -1537,6 +1551,7 @@ register({
     if (!requireSession()) return;
     const result = startNewConversation();
     if (!result.ok) return send(`Could not start a new conversation: ${result.error.message}`);
+    dropLimitPickup("/new");
     return send(`Session: ${result.project}\nNew ${result.provider} conversation\n\nSend text, voice, or images.`);
   },
 });
@@ -1575,7 +1590,7 @@ function formatCompactWindow(state) {
   const fmt = (n) => n >= 1000 ? (n / 1000).toFixed(0) + "k" : String(n);
   const cw = state.settings?.compactWindow;
   if (cw === 0) return "off";
-  if (cw == null) return `default (${fmt(AUTO_COMPACT_TOKENS)})`;
+  if (cw == null) return `default (${fmt(defaultCompactTokens(getProjectKey(state)))})`;
   return fmt(cw);
 }
 
@@ -1726,6 +1741,16 @@ function stopLane(state, lane) {
 
 const STOP_DROP_REASON = "Dropped by /stop before it started";
 
+// /stop never silently loses a queued message: each dropped one comes back
+// with a "Run it" button (kept 24 h, core/turn-journal).
+function dropOffer(items) {
+  if (!items || !items.length) return {};
+  try {
+    const keyboard = require("./turn-journal").droppedKeyboard(items);
+    return keyboard ? { keyboard } : {};
+  } catch (_) { return {}; }
+}
+
 // "Dropped 2 queued: "reboot pe2", "and check the…"": what /stop dropped, a
 // few words of each message (the first few in full, then a count).
 function droppedNote(items, kind) {
@@ -1780,11 +1805,17 @@ register({
       const dropped = lanes.flatMap((lane) => dropLaneQueue(lane, STOP_DROP_REASON));
       const stopped = lanes.filter((lane) => stopLane(state, lane)).length;
       const sideStopped = await sideCancellation;
-      if (!stopped && !dropped.length) return send(sideStopped ? "Cancelled side response." : "Nothing running.");
+      let pickups = [];
+      try { pickups = require("./limit-pickup").cancelAllFor(state.userId, "/stop all"); } catch (_) {}
+      if (!stopped && !dropped.length) {
+        if (sideStopped) return send("Cancelled side response.");
+        return send(pickups.length ? pickupDroppedNote(pickups.length) : "Nothing running.");
+      }
       const parts = [];
       if (stopped) parts.push(`Cancelled ${stopped} running conversation${stopped === 1 ? "" : "s"}.`);
       if (dropped.length) parts.push(droppedNote(dropped, stopped ? "queued" : "waiting"));
-      return send(parts.join(" "));
+      if (pickups.length) parts.push(pickupDroppedNote(pickups.length));
+      return send(parts.join(" "), dropOffer(dropped));
     }
     // /stop cancels the CURRENT conversation's turn only (other threads keep
     // running) and drops what was queued in it before the /stop: the person
@@ -1793,16 +1824,19 @@ register({
     const lane = laneFor(state);
     const sideCancellation = sideChatCoordinator.cancel(state.userId, lane.key);
     const dropped = dropLaneQueue(lane, STOP_DROP_REASON);
+    // A pick-up waiting for a usage limit to reset is dropped too.
+    const pickup = dropLimitPickup("/stop", state, lane.key);
+    const pickupNote = pickup ? ` ${pickupDroppedNote(1)}` : "";
     if (stopLane(state, lane)) {
       await sideCancellation;
-      await send(dropped.length ? `Cancelled. ${droppedNote(dropped, "queued")}` : "Cancelled.");
+      await send(`${dropped.length ? `Cancelled. ${droppedNote(dropped, "queued")}` : "Cancelled."}${pickupNote}`, dropOffer(dropped));
     } else if (dropped.length) {
       // Nothing to cancel: the dropped messages were waiting for a slot (or
       // queued behind a turn that is only finishing its tail).
       await sideCancellation;
-      await send(droppedNote(dropped, laneBusy(lane) ? "queued" : "waiting"));
-    } else if (await sideCancellation) await send("Cancelled side response.");
-    else await send("Nothing running.");
+      await send(`${droppedNote(dropped, laneBusy(lane) ? "queued" : "waiting")}${pickupNote}`, dropOffer(dropped));
+    } else if (await sideCancellation) await send(`Cancelled side response.${pickupNote}`);
+    else await send(pickup ? pickupDroppedNote(1) : "Nothing running.");
   },
 });
 
@@ -1855,16 +1889,42 @@ register({
     const state = currentState();
     const result = endCurrentSession({ state });
     if (!result.ok) return send(`Could not end conversation: ${result.error.message}`);
+    dropLimitPickup("/end", state);
     send("Ended. Send anything to start a fresh conversation.");
   },
 });
 
+// Plan limits as last reported (core/usage-limits.js), and this person's
+// pick-up in this conversation if a usage limit stopped a message.
+function planLimitLines(state = currentState()) {
+  const lines = [];
+  try {
+    const limits = require("./usage-limits");
+    const byProvider = new Map();
+    for (const w of limits.knownWindows()) {
+      if (!byProvider.has(w.provider)) byProvider.set(w.provider, []);
+      byProvider.get(w.provider).push(w);
+    }
+    const order = { five_hour: 0, seven_day: 1 };
+    for (const [provider, windows] of byProvider) {
+      const parts = windows
+        .sort((a, b) => (order[a.id] ?? 9) - (order[b.id] ?? 9))
+        .map((w) => `${limits.windowLabel(w.id).replace(/ limit$/, "")} ${Math.round(w.usedPercent)}%${w.resetsAt ? ` (resets ${limits.formatResetTime(w.resetsAt)})` : ""}`);
+      lines.push(`${limits.providerLabel(provider)} plan limits: ${parts.join(" · ")}`);
+    }
+    const pickup = require("./limit-pickup").get(state.userId, currentLaneKey(state));
+    if (pickup) lines.push(`Picking up your stopped message ${limits.whenPhrase(pickup.runAt)} (/stop drops it).`);
+  } catch (_) {}
+  return lines;
+}
+
 register({
   name: "usage", description: "Show token usage & cost for this session",
   handler: async (env) => {
     if (!authorized(env)) return;
     const u = currentState().sessionUsage;
-    if (u.turns === 0) return send("No usage yet in this session.");
+    const limitLines = planLimitLines();
+    if (u.turns === 0) return send(["No usage yet in this session.", ...limitLines].join("\n"));
     const fmt = (n) => n >= 1000 ? (n / 1000).toFixed(1) + "k" : String(n);
     const lines = [
       `*Session usage* (${u.turns} turn${u.turns === 1 ? "" : "s"})`,
@@ -1880,7 +1940,8 @@ register({
     if (u.subagentThreads > 0) {
       lines.push(`Provider sub-agents: ${u.subagentThreads} thread${u.subagentThreads === 1 ? "" : "s"} · ${fmt(u.subagentInputTokens || 0)} in / ${fmt(u.subagentOutputTokens || 0)} out (spawned by the model; not in the totals above)`);
     }
-    if (Number.isFinite(u.quotaUsedPercent)) {
+    if (limitLines.length) lines.push(...limitLines);
+    else if (Number.isFinite(u.quotaUsedPercent)) {
       lines.push(`Plan quota used: ${u.quotaUsedPercent}%${u.quotaResetsAt ? ` (resets ${String(u.quotaResetsAt).slice(0, 16).replace("T", " ")}Z)` : ""}`);
     }
     if (u.lastInputTokens > 200000) {

package/core/lessons.js

@@ -148,8 +148,15 @@ function listLessons() {
 // then most recently reinforced) survive the char budget. Returns "" when
 // there are none, so the system prompt stays clean on a fresh install.
 function loadLessonsBlock() {
+  const out = injectedLessons().map(lessonLine);
+  if (out.length === 0) return "";
+  return out.join("\n");
+}
+
+// The lessons the always-injected block carries, in its order, with meta.
+function injectedLessons() {
   const lessons = readLessons();
-  if (lessons.length === 0) return "";
+  if (lessons.length === 0) return [];
   const meta = reconcileMeta(lessons);
   const ranked = lessons.slice().sort((a, b) => {
     const ma = meta[a.id] || {}, mb = meta[b.id] || {};
@@ -162,11 +169,10 @@ function loadLessonsBlock() {
   for (const l of ranked) {
     const line = lessonLine(l);
     if (used + line.length + 1 > MAX_LESSONS_CHARS) break;
-    out.push(line);
+    out.push({ ...l, ...(meta[l.id] || {}) });
     used += line.length + 1;
   }
-  if (out.length === 0) return "";
-  return out.join("\n");
+  return out;
 }
 
 // Add or reinforce a lesson. Dedupe is by normalized text (id), so the same
@@ -271,7 +277,7 @@ module.exports = {
   LESSONS_FILE, LESSONS_META_FILE,
   MAX_LESSONS, MAX_LESSON_CHARS, MAX_LESSONS_CHARS,
   normalize, lessonId, parseLessons,
-  readLessons, listLessons, loadLessonsBlock,
+  readLessons, listLessons, loadLessonsBlock, injectedLessons, lessonLine,
   readMeta, writeMeta, reconcileMeta,
   addLesson, editLesson, removeLesson, saveLessonsRaw, lessonsExist,
 };