@codizelabs/agent-rewake 0.4.0 → 0.6.0

package/dist/hosts/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "rewake",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Continues this session when your usage limit resets, and sends messages you schedule into it.",
   "author": {
     "name": "Codize Labs",

package/dist/hosts/claude-code/hooks/logic.js

@@ -76,6 +76,104 @@ export function blockingKind(rateLimits, now) {
   )?.kind;
 }
 
+// ---- Warnings before a limit: Claude Code's own usage figures, no network, no sign-in.
+
+/** Percent used at which a window is warned about, lowest first. */
+const WARN_AT = [80, 95];
+/** Samples kept per window, and the least time they must span before a pace is trusted. */
+const SAMPLE_CAP = 12;
+const MIN_SPAN_MS = 10 * MINUTE;
+/** Only readings this recent give the pace. */
+const RECENT_MS = HOUR;
+/** A pace warning comes when the projected limit is this near. */
+const PACE_HORIZON_MS = 45 * MINUTE;
+/** Two reset times closer than this are the same window (the figures can differ by a moment). */
+const SAME_WINDOW_MS = 30 * MINUTE;
+
+/**
+ * Milliseconds until the window reaches 100, from its samples ({ t, p }: time, percent used), or
+ * undefined when the pace is unknown: the figure has not moved since the newest sample (so idle
+ * time never counts as a pace), fewer than two samples from the last hour, those less than 10
+ * minutes apart, or no rise.
+ */
+export function timeToLimit(samples, now) {
+  const recent = samples.filter((s) => s.t >= now - RECENT_MS);
+  const first = recent[0];
+  const last = recent.at(-1);
+  if (!first || !last || last.t !== now || last.t - first.t < MIN_SPAN_MS) return undefined;
+  const rate = (last.p - first.p) / (last.t - first.t);
+  return rate > 0 ? (100 - last.p) / rate : undefined;
+}
+
+/** The estimate as a range of whole minutes in fives, about 0.7x to 1.4x: [20, 40]. */
+export function paceRange(ms) {
+  const five = (x) => Math.max(5, Math.round(x / (5 * MINUTE)) * 5);
+  const lo = five(ms * 0.7);
+  return [lo, Math.max(lo + 5, five(ms * 1.4))];
+}
+
+/**
+ * One window's reading, given what was kept for it (`prev`: { resetsAt, samples, high, pace },
+ * or undefined). Returns undefined when there is nothing to track (a spending cap, no reset ahead,
+ * a full window: the limit flow takes over), else { next, level?, pace? }: the state to keep, the
+ * threshold newly crossed (only the highest if it jumped past both) and the pace range to warn
+ * with. A threshold is warned once per window, the pace once per window and never together with
+ * a threshold (it waits for the next reading).
+ */
+export function usageStep(prev, w, now) {
+  const reset = typeof w.resetsAt === "string" ? Date.parse(w.resetsAt) : Number.NaN;
+  const p = w.percentUsed;
+  if (BILLING_KINDS.has(w.kind) || !Number.isFinite(reset) || reset <= now) return undefined;
+  if (!(p >= 0 && p < 100)) return undefined;
+  const same = prev && Math.abs(prev.resetsAt - reset) < SAME_WINDOW_MS;
+  const base = same ? prev : { resetsAt: reset, samples: [], high: 0, pace: false };
+  const last = base.samples.at(-1);
+  const samples =
+    last?.p === p ? base.samples : [...(last && p < last.p ? [] : base.samples), { t: now, p }];
+  const kept = samples.slice(-SAMPLE_CAP);
+  const level = WARN_AT.filter((l) => p >= l && l > base.high).pop();
+  const ms = level === undefined && !base.pace ? timeToLimit(kept, now) : undefined;
+  const pace =
+    ms !== undefined && ms <= PACE_HORIZON_MS && now + ms < reset ? paceRange(ms) : undefined;
+  return {
+    next: {
+      resetsAt: reset, // the latest, so a slowly drifting time can't make the window look new
+      samples: kept,
+      high: level ?? base.high,
+      pace: base.pace || pace !== undefined,
+    },
+    level,
+    pace,
+  };
+}
+
+/** "5-hour limit", "7-day limit", "7-day opus limit", "some kind limit". */
+export function limitName(kind) {
+  const m = /^seven_day_(.+)$/.exec(kind);
+  const name =
+    kind === "five_hour"
+      ? "5-hour"
+      : kind === "seven_day"
+        ? "7-day"
+        : m
+          ? `7-day ${m[1].replace(/_/g, " ")}`
+          : String(kind).replace(/_/g, " ");
+  return `${name} limit`;
+}
+
+/** `reset` is the reset time as words: "at 3:00 AM today", "on Friday at 9:00 AM". */
+export function levelText(kind, percent, reset) {
+  const head = `${limitName(kind)}: ${Math.floor(percent)}% used, as of Claude Code's last reply. It resets ${reset}.`;
+  // Compacting is a model call too, so it is only hinted at below 95%.
+  return percent >= 95
+    ? `${head} A good moment to wrap up or save what you are doing.`
+    : `${head} If you are in the middle of a task, /compact now can make the rest last longer (compacting also uses some).`;
+}
+
+export function paceText(kind, [lo, hi], reset) {
+  return `At this pace you reach the ${limitName(kind)} in about ${lo} to ${hi} minutes, before it resets ${reset}.`;
+}
+
 /**
  * Claude Code's own panels, by `CLAUDE_CODE_ENTRYPOINT`: the VS Code extension (also in Cursor and
  * other VS Code builds) and the desktop app. They run Claude Code through the Agent SDK, so the

package/dist/hosts/claude-code/hooks/register.js

@@ -13,6 +13,10 @@
 //                        offered (not answered) | armed | sent
 //                 claim: { by, at }, the process sending the armed continue right now
 //   sched:<id>    [{ at, text }]
+//   usage:<dir>   { <kind>: { resetsAt, samples: [{ t, p }], high, pace } }, what the warnings
+//                 before a limit have said. The figures are the account's, not the session's, so
+//                 the key is the config dir (CLAUDE_CONFIG_DIR, which is one sign-in): a restart or
+//                 another session of the same account doesn't repeat a warning.
 // A copy of each limit record (no message text) goes to Rewake's shared state folder, so
 // `agent-rewake doctor` and the schedules page can show it, and so Rewake can continue the session
 // headless if Claude Code closes before the limit is answered (it adds `open`, the Claude Code
@@ -34,6 +38,7 @@ import {
   helpText,
   holdArgv,
   LINUX_MAINS,
+  levelText,
   limitOf,
   MAX_REARMS,
   MAX_REHITS,
@@ -42,6 +47,7 @@ import {
   mustAsk,
   nativeLikely,
   notHere,
+  paceText,
   parseCommand,
   parseProcess,
   parseProgram,
@@ -54,6 +60,7 @@ import {
   sessionVars,
   splitWhen,
   surfaceOf,
+  usageStep,
   WAITING_EXPIRES_MS,
   WAKE_HORIZON_MS,
   WAKE_PROBE,
@@ -106,6 +113,10 @@ const ME = Math.random().toString(36).slice(2);
 const CLAIM_MS = 5 * MINUTE;
 /** Rewake's keep-awake setting: "plugged-in" (default), "always" or "never". */
 let keepAwake = "plugged-in";
+/** Rewake's usage-warnings setting: "on" (default) or "off". */
+let usageWarnings = "on";
+/** CLAUDE_CONFIG_DIR, which names the account's warnings in $.store ("" for the default). */
+let configDir = "";
 /** { kind, pid, program }: Claude Code's PID and the hold program (macOS, Linux with systemd-inhibit, Windows); null where there is none. */
 let wakeTarget;
 /** The running hold: { key, stream }. */
@@ -131,6 +142,8 @@ async function loadConfig($) {
       if (["on", "off", "ask"].includes(settings.newThreads)) sharedAuto = settings.newThreads;
       if (["plugged-in", "always", "never"].includes(settings.keepAwake))
         keepAwake = settings.keepAwake;
+      if (settings.usageWarnings === "on" || settings.usageWarnings === "off")
+        usageWarnings = settings.usageWarnings;
     } catch {
       // No settings saved yet: the default clock.
     }
@@ -146,7 +159,7 @@ async function loadSessionInfo($) {
   // SETTINGS_VARS and KEY_VARS; a test in Rewake's repository compares them with these).
   const read = (get) => get.catch(() => undefined);
   const values = {
-    CLAUDE_CONFIG_DIR: await read($.env.get("CLAUDE_CONFIG_DIR")),
+    CLAUDE_CONFIG_DIR: configDir, // read once, at session start
     CLAUDE_CODE_PROJECT_DIR_NAME: await read($.env.get("CLAUDE_CODE_PROJECT_DIR_NAME")),
     ANTHROPIC_BASE_URL: await read($.env.get("ANTHROPIC_BASE_URL")),
     ANTHROPIC_MODEL: await read($.env.get("ANTHROPIC_MODEL")),
@@ -494,6 +507,26 @@ async function onMeasure($, rateLimits) {
   );
 }
 
+/** Toasts at 80% and 95% of a usage window, and when the pace would reach the limit soon. */
+async function warnUsage($, rateLimits) {
+  if (usageWarnings === "off" || !personAtPrompt({ isInteractive, entrypoint })) return;
+  const now = await $.clock.now();
+  const key = `usage:${configDir}`;
+  const state = (await $.store.get(key)) ?? {};
+  const toasts = [];
+  for (const w of rateLimits ?? []) {
+    const step = w && usageStep(state[w.kind], w, now);
+    if (!step) continue;
+    state[w.kind] = step.next;
+    const reset = atWhen(step.next.resetsAt, now);
+    if (step.level !== undefined) toasts.push(levelText(w.kind, w.percentUsed, reset));
+    else if (step.pace) toasts.push(paceText(w.kind, step.pace, reset));
+  }
+  // Saved before showing: a failure while showing must not make the same warning come back.
+  await $.store.set(key, state);
+  for (const text of toasts) $.ui.toast(text);
+}
+
 async function onNotification($, e) {
   const id = e.session_id;
   const ep = await $.store.get(limitKey(id));
@@ -859,6 +892,7 @@ export function register(on) {
     isInteractive = e.isInteractive;
     sessionCwd = e.cwd;
     entrypoint = await $.env.get("CLAUDE_CODE_ENTRYPOINT").catch(() => undefined);
+    configDir = (await $.env.get("CLAUDE_CONFIG_DIR").catch(() => undefined)) ?? "";
     inert = Boolean(await $.env.get("AGENT_REWAKE_FIRE").catch(() => undefined));
     if (inert) return next(e);
     surface = surfaceOf({ surface: e.surface, entrypoint });
@@ -905,7 +939,10 @@ export function register(on) {
   }).catch(passOn);
 
   on("session.measure", ($, e, next) => {
-    if (!inert && e.changed.includes("rateLimits")) void onMeasure($, e.rateLimits);
+    if (!inert && e.changed.includes("rateLimits")) {
+      void onMeasure($, e.rateLimits);
+      void warnUsage($, e.rateLimits).catch(() => undefined);
+    }
     return next(e);
   }).catch(passOn);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codizelabs/agent-rewake",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Auto-resume Claude Code, Codex, Gemini CLI, GitHub Copilot, Grok or any Zed agent when its usage limit resets, in the same session, and schedule messages into your agent threads.",
   "keywords": [
     "zed",