claude-usage-limits 1.26.0 → 1.39.1

package/skills/usage-limits/scripts/stop.js

@@ -71,14 +71,14 @@ function bindingFromCollect(collected, now) {
 function armAtCompletion(now, hookInput, sessionId) {
   let state;
   try {
-    state = relay.read();
+    state = (relay.reapLost(Date.now()), relay.read());
   } catch (err) {
     return null;
   }
   const config = relay.settings(state);
   if (!config.enabled || config.armOn !== 'completion') return null;
   // Already carrying this session forward: nothing to decide.
-  if (state.armed && state.armed.id === sessionId) return null;
+  if (relay.armedFor(state, sessionId)) return null;
 
   const transcript = hookInput && hookInput.transcript_path ? hookInput.transcript_path : null;
   const work = relay.detectWork(transcript, {});

package/skills/usage-limits/scripts/tally.js

@@ -188,6 +188,14 @@ function update(all, sessionId, transcriptPath, now, options) {
     subagentFiles(transcriptPath, sessionId).map((file) => ({ file, sidechain: true }))
   );
 
+  // Each subagent transcript is priced at the model its own records name. One
+  // that names none is priced at this session's model: the newest main-thread
+  // turn read here, or failing that the tail of the session transcript, read
+  // only if a record actually asks.
+  let mainModel = null;
+  const readParent = usage.sessionModelReader(transcriptPath);
+  const sessionModel = () => mainModel || readParent();
+
   for (const entry of files) {
     const key = path.resolve(entry.file);
     const read = readNewLines(entry.file, session.cursors[key]);
@@ -197,8 +205,9 @@ function update(all, sessionId, transcriptPath, now, options) {
         session.prompts += 1;
         continue;
       }
-      const event = usage.eventFrom(line, seen, project);
+      const event = usage.eventFrom(line, seen, project, entry.sidechain ? sessionModel : null);
       if (!event || event.rejected) continue;
+      if (!entry.sidechain && !event.sidechain && event.model) mainModel = event.model;
       apply(session, event, entry.sidechain || Boolean(event.sidechain), delta);
     }
     session.cursors[key] = read.next;

package/skills/usage-limits/scripts/usage.js

@@ -386,7 +386,14 @@ function tokenParts(usage) {
 }
 
 // One transcript line to an event, or null if it is not a billable turn.
-function eventFrom(line, seen, project) {
+//
+// Priced at the model the line itself names. A subagent's transcript names its
+// own model on every assistant record - a Sonnet agent under a Fable session
+// says claude-sonnet-5 - and that, not the session's model, is what its tokens
+// cost. `fallbackModel` is only for a record that names none: a string, or a
+// function called at most once so the parent transcript is read only when a
+// record actually needs it.
+function eventFrom(line, seen, project, fallbackModel) {
   if (line.indexOf('"assistant"') === -1 || line.indexOf('"usage"') === -1) return null;
   let entry;
   try {
@@ -442,15 +449,20 @@ function eventFrom(line, seen, project) {
   }
 
   const parts = tokenParts(entry.message.usage);
+  let model = typeof entry.message.model === 'string' ? entry.message.model : '';
+  if (!model && fallbackModel) {
+    const assumed = typeof fallbackModel === 'function' ? fallbackModel() : fallbackModel;
+    if (typeof assumed === 'string') model = assumed;
+  }
   return {
     at,
     // Carried on the event so the scan cache can dedup across files without
     // re-parsing them: a resumed or forked session repeats earlier turns, and
     // a cached file is never read again to find that out.
     dedupId: id === '|' ? null : id,
-    model: entry.message.model || '',
+    model,
     effort: entry.effort || null,
-    cost: costOf(entry.message.usage, entry.message.model),
+    cost: costOf(entry.message.usage, model),
     tokens: tokensOf(entry.message.usage),
     parts,
     // What the model was shown on this call: everything except what it wrote.
@@ -631,8 +643,11 @@ function claudeTranscriptFiles(since) {
         // A session's subagents write their transcripts under
         // <project>/<session id>/subagents/. Same budget, different file, and
         // for a long time an Explore or Plan agent's whole spend went unseen.
+        // The directory is named for the session, and the session's own
+        // transcript sits beside it: that is the model a subagent record
+        // falls back to when it names none of its own.
         for (const file of subagentTranscripts(path.join(full, entry.name, 'subagents'), since)) {
-          files.push({ file, project: dir.name });
+          files.push({ file, project: dir.name, parent: path.join(full, entry.name + '.jsonl') });
         }
         continue;
       }
@@ -725,7 +740,34 @@ function liveEffort(sessionId) {
 // slot on the machine - which on 2026-09-08 was a 19-hour-old Opus session,
 // shown over a Fable one.
 function liveModel(sessionId) {
-  const found = sessionTranscriptFile(sessionId);
+  return modelFromTail(sessionTranscriptFile(sessionId));
+}
+
+// The same answer for a transcript named by path rather than by session id.
+function transcriptModel(file) {
+  let stat;
+  try {
+    stat = fs.statSync(file);
+  } catch (err) {
+    return null;
+  }
+  return modelFromTail({ file, at: stat.mtimeMs, size: stat.size });
+}
+
+// The fallback a subagent record without a model is priced at: the parent
+// session's model, looked up once and only when asked for.
+function sessionModelReader(parentTranscript) {
+  let resolved;
+  return () => {
+    if (resolved === undefined) {
+      const seen = transcriptModel(parentTranscript);
+      resolved = seen && seen.model ? seen.model : null;
+    }
+    return resolved;
+  };
+}
+
+function modelFromTail(found) {
   if (!found) return null;
   const from = Math.max(0, found.size - EFFORT_TAIL_BYTES);
   const text = readSlice(found.file, from, found.size).toString('utf8');
@@ -933,13 +975,13 @@ function unpackEvent(row, project) {
 // the offset has to be a byte count: a transcript is full of characters that
 // are more than one byte, and counting them as one would drift the offset and
 // silently drop turns. A trailing partial line is left unconsumed.
-function parseSlice(buffer, project, baseOffset) {
+function parseSlice(buffer, project, baseOffset, fallbackModel) {
   const events = [];
   let start = 0;
   let consumed = 0;
   for (let i = 0; i < buffer.length; i += 1) {
     if (buffer[i] !== 0x0a) continue;
-    const event = eventFrom(buffer.toString('utf8', start, i), null, project);
+    const event = eventFrom(buffer.toString('utf8', start, i), null, project, fallbackModel);
     if (event) events.push(event);
     start = i + 1;
     consumed = start;
@@ -974,7 +1016,15 @@ function eventsForFile(entry, cache, keepFrom) {
   }
 
   const from = usable ? cached.offset : 0;
-  const parsed = parseSlice(readSlice(entry.file, from, stat.size), entry.project, from);
+  // A subagent record that names no model is priced at its session's model,
+  // read from the tail of the parent transcript - and read only if such a
+  // record turns up, which on 14,778 cached rows here it never has.
+  const parsed = parseSlice(
+    readSlice(entry.file, from, stat.size),
+    entry.project,
+    from,
+    entry.parent ? sessionModelReader(entry.parent) : null
+  );
   const rows = (usable ? cached.rows : [])
     .concat(parsed.events.map(packEvent))
     .filter((row) => row[1] >= keepFrom);
@@ -1074,18 +1124,32 @@ async function readClaudeEvents(since, options) {
     if (changed) writeScanCache(cache);
   }
 
-  const seen = new Set();
+  // One event per message id, and it is the LAST line that carries it.
+  //
+  // A message that streams several content blocks is written as several
+  // lines sharing one message id, each with a usage block, and in subagent
+  // transcripts only the last has the final output count: measured on
+  // 2026-09-21 across 179 agent files, 1,991 of 2,504 such groups ran like
+  // [1, 1, 202], so keeping the first block priced a 202-token answer at one
+  // token. Main transcripts repeat the same figure on every line (1,811
+  // groups, all identical), so for them this is the same answer either way.
+  const seen = new Map();
   const events = [];
   for (const held of collected) {
     for (const row of held.rows) {
       if (row[1] < since) continue;
       const id = row[0] === ROW_TURN ? row[13] : '';
+      const event = unpackEvent(row, held.project);
+      if (!event) continue;
       if (id) {
-        if (seen.has(id)) continue;
-        seen.add(id);
+        const index = seen.get(id);
+        if (index !== undefined) {
+          events[index] = event;
+          continue;
+        }
+        seen.set(id, events.length);
       }
-      const event = unpackEvent(row, held.project);
-      if (event) events.push(event);
+      events.push(event);
     }
   }
 
@@ -2636,16 +2700,20 @@ function limitWindows(utilization) {
 // So: the bucket keys first, the `limits` array for anything they did not
 // cover, real labels on both, corrections applied, and the same applies-flag
 // every other reader makes its decisions from.
-function snapshotWindows(collected, now, codexHome) {
+function snapshotWindows(collected, now, codexHome, extraModels) {
   const utilization = collected && collected.utilization;
   if (!utilization) return [];
   const at = Number.isFinite(now) ? now : Date.now();
   // No transcripts here on purpose - that is the cost being avoided - so the
   // setting is the only thing that says which model is running. It is enough
   // to keep a weekly for a model this agent is not using out of a worst-of.
+  // A caller that knows what the session is actually running - the pulse reads
+  // it off the transcript tail - adds it, so a /model switch the setting never
+  // heard about cannot suppress the window being spent.
   const families = familiesInUse(null, null, [
     collected.settings && collected.settings.model,
     process.env.ANTHROPIC_MODEL,
+    ...(Array.isArray(extraModels) ? extraModels : []),
   ]);
   const specs = collected.windowSpecs && collected.windowSpecs.length ? collected.windowSpecs : WINDOWS;
   const byKey = new Map();
@@ -2777,6 +2845,23 @@ function accountUuid() {
     : null;
 }
 
+// Per window key, the percentage each account source reports and which one
+// the report is using: { five_hour: { cache: 14, live: 20, used: 'live' } }.
+// Null unless both sources have the window.
+function sourcePercents(cache, fresh, used) {
+  if (!cache || !cache.utilization || typeof cache.utilization !== 'object') return null;
+  if (!fresh || !fresh.utilization || typeof fresh.utilization !== 'object') return null;
+  const out = {};
+  for (const key of Object.keys(cache.utilization)) {
+    const a = cache.utilization[key];
+    const b = fresh.utilization[key];
+    if (a && b && typeof a.utilization === 'number' && typeof b.utilization === 'number') {
+      out[key] = { cache: a.utilization, live: b.utilization, used };
+    }
+  }
+  return Object.keys(out).length ? out : null;
+}
+
 function collectClaude(now) {
   const account = readJson(accountFile()) || {};
   const settings = readJson(path.join(configDir(), 'settings.json')) || {};
@@ -2790,6 +2875,12 @@ function collectClaude(now) {
   const snapshot = useLive ? fresh : cache;
   const utilization = snapshot && snapshot.utilization ? snapshot.utilization : null;
   const plan = detectPlan(oauth);
+  // The reading that was not chosen, kept beside the one that was, so a
+  // window can be described by both when they disagree. A live file for
+  // another account or from a clock that is ahead is not a second reading of
+  // this account and is left out, by the same rule that keeps it from being
+  // preferred.
+  const comparable = fresh && preferLive(null, fresh, oauth.accountUuid, now) ? fresh : null;
 
   return {
     now,
@@ -2803,6 +2894,7 @@ function collectClaude(now) {
     snapshotAgeMs: snapshot && snapshot.fetchedAtMs ? now - snapshot.fetchedAtMs : null,
     snapshotFetchedAt: snapshot && snapshot.fetchedAtMs ? snapshot.fetchedAtMs : null,
     snapshotSource: utilization ? (useLive ? 'live' : 'cache') : null,
+    sources: sourcePercents(cache, comparable, useLive ? 'live' : 'cache'),
     utilization,
     settings: {
       model: settings.model || 'default',
@@ -3141,6 +3233,11 @@ async function report(now, options) {
     // exists.
     calibrated.planChanged ? new Map() : rejections
   );
+  // Both account readings ride on the window, so whatever describes it can
+  // name them when they disagree.
+  if (base.sources) {
+    for (const window of windows) if (base.sources[window.key]) window.sources = base.sources[window.key];
+  }
 
   // Which of those windows this agent can actually spend into. Everything that
   // ranks or warns about a window reads the answer off the window itself.
@@ -4180,6 +4277,8 @@ module.exports = {
   sessionTranscriptFile,
   liveEffort,
   liveModel,
+  transcriptModel,
+  sessionModelReader,
   EFFORT_TAIL_BYTES,
   scanFile,
   readScanCache,