@saccolabs/pi-claude-cli 0.4.8 → 0.4.10

package/index.ts

@@ -16,6 +16,7 @@ import {
 } from "./src/process-manager.js";
 import { getCustomToolDefs, writeMcpConfig } from "./src/mcp-config.js";
 import { rewriteOverflowMessage } from "./src/overflow.js";
+import { buildRateLimitPayload, rateLimitIdentity } from "./src/rate-limit.js";
 
 // Kill all active Claude subprocesses on process exit to prevent orphans
 process.on("exit", killAllProcesses);
@@ -40,21 +41,18 @@ let lastRateLimitJson: string | undefined;
 function publishRateLimit(info: Record<string, unknown>): void {
   const setStatus = uiContext?.ui?.setStatus;
   if (typeof setStatus !== "function") return;
-  const payload = JSON.stringify({
-    status: info.status,
-    resetsAt: info.resetsAt,
-    rateLimitType: info.rateLimitType,
-    overageStatus: info.overageStatus,
-    isUsingOverage: info.isUsingOverage === true,
-    observedAt: Math.floor(Date.now() / 1000),
-  });
+  const payload = buildRateLimitPayload(info);
   // Push only on change: the event repeats every turn, and a status that
   // rewrites itself constantly is noise for whatever renders it.
-  const withoutObservedAt = payload.replace(/,"observedAt":\d+/, "");
-  if (withoutObservedAt === lastRateLimitJson) return;
-  lastRateLimitJson = withoutObservedAt;
+  const identity = rateLimitIdentity(payload);
+  if (identity === lastRateLimitJson) return;
+  lastRateLimitJson = identity;
   try {
-    setStatus.call(uiContext!.ui, RATE_LIMIT_STATUS_KEY, payload);
+    setStatus.call(
+      uiContext!.ui,
+      RATE_LIMIT_STATUS_KEY,
+      JSON.stringify(payload),
+    );
   } catch {
     /* never break a turn over a status push */
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saccolabs/pi-claude-cli",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Pi coding agent extension that routes LLM calls through the Claude Code CLI",
   "main": "index.ts",
   "keywords": [

package/src/event-bridge.ts

@@ -131,9 +131,35 @@ export function createEventBridge(
     cache_creation_input_tokens: 0,
   };
   let cycleUsage: ClaudeUsage = {};
+  /**
+   * Context size of the most recent cycle — what the model actually saw on
+   * its last call, which is NOT the episode's summed usage.
+   *
+   * pi reads `usage.totalTokens` as the conversation's context size
+   * (`calculateContextTokens` in pi's compaction module short-circuits on it)
+   * and uses it for both the context gauge and the auto-compaction trigger.
+   * Every cycle re-sends the same cached prefix, so summing cycles counts
+   * that prefix once per cycle: a captured 3-cycle episode sums to 82,174
+   * while the model's real context never exceeded 28,243. The host then
+   * showed 41% of a 200k window instead of 14%, and a long enough turn
+   * crossed pi's compaction threshold at a fraction of true occupancy.
+   *
+   * So the four component figures stay cumulative — they are what gets
+   * billed — and `totalTokens` carries the last cycle's context instead.
+   */
+  let lastCycleContext = 0;
   /** Tool ids already surfaced as markers (envelope arrives once per block). */
   const markedToolIds = new Set<string>();
 
+  /** Prompt size of one cycle: everything the model read, excluding output. */
+  function contextOf(usage: ClaudeUsage): number {
+    return (
+      (usage.input_tokens ?? 0) +
+      (usage.cache_read_input_tokens ?? 0) +
+      (usage.cache_creation_input_tokens ?? 0)
+    );
+  }
+
   function recomputeUsage(): void {
     output.usage.input =
       cumulativeUsage.input_tokens + (cycleUsage.input_tokens ?? 0);
@@ -145,11 +171,18 @@ export function createEventBridge(
     output.usage.cacheWrite =
       cumulativeUsage.cache_creation_input_tokens +
       (cycleUsage.cache_creation_input_tokens ?? 0);
+    // Latch the newest cycle we have numbers for. `applyResult` clears
+    // cycleUsage, so a zero here means "no fresher figure", never "empty
+    // context" — the last latched value must survive.
+    const cycleContext = contextOf(cycleUsage);
+    if (cycleContext > 0) lastCycleContext = cycleContext;
     output.usage.totalTokens =
-      output.usage.input +
-      output.usage.output +
-      output.usage.cacheRead +
-      output.usage.cacheWrite;
+      lastCycleContext > 0
+        ? lastCycleContext
+        : output.usage.input +
+          output.usage.output +
+          output.usage.cacheRead +
+          output.usage.cacheWrite;
     calculateCost(model, output.usage);
   }
 

package/src/rate-limit.ts

@@ -0,0 +1,64 @@
+/**
+ * Account rate-limit state, shaped for the host's status channel.
+ *
+ * The CLI emits a `rate_limit_event` per turn describing ONE window: the first
+ * one whose warning threshold has been crossed, walking
+ * `5h -> 7d -> 7d_oi -> overage`. So the reported window is the binding
+ * constraint, not an arbitrary pick — and there is no way to see all four at
+ * once from this stream. A front-end that wants "which limit will stop me, how
+ * close am I, and when does it reset" has everything it needs; one that wants
+ * a full dashboard does not, and should not pretend otherwise.
+ *
+ * Kept pure and separate from `index.ts` so the payload contract is testable
+ * without a pi runtime.
+ */
+
+/** What the host receives under the `claude-rate-limit` status key. */
+export interface RateLimitPayload {
+  status: unknown;
+  resetsAt: unknown;
+  rateLimitType: unknown;
+  overageStatus: unknown;
+  isUsingOverage: boolean;
+  /** Fraction of the window consumed: 1.01 means 101%, i.e. over. */
+  utilization: number | null;
+  /** Which warning step tripped, when one has. */
+  surpassedThreshold: number | null;
+  observedAt: number;
+}
+
+function num(value: unknown): number | null {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+export function buildRateLimitPayload(
+  info: Record<string, unknown>,
+  nowSeconds: number = Math.floor(Date.now() / 1000),
+): RateLimitPayload {
+  return {
+    status: info.status,
+    resetsAt: info.resetsAt,
+    rateLimitType: info.rateLimitType,
+    overageStatus: info.overageStatus,
+    isUsingOverage: info.isUsingOverage === true,
+    // The CLI has always sent these two; dropping them left front-ends able to
+    // say WHICH limit was in play and when it resets, but never how close it
+    // was — so a user could not watch themselves approach a wall, only hit it.
+    utilization: num(info.utilization),
+    surpassedThreshold: num(info.surpassedThreshold),
+    observedAt: nowSeconds,
+  };
+}
+
+/**
+ * Identity of a payload ignoring `observedAt`, for change detection.
+ *
+ * The event repeats every turn with a fresh timestamp; pushing that verbatim
+ * would rewrite the host's status constantly and make anything rendering it
+ * flicker. Comparing everything EXCEPT the timestamp is what makes the push
+ * "on change" rather than "on turn".
+ */
+export function rateLimitIdentity(payload: RateLimitPayload): string {
+  const { observedAt: _observedAt, ...rest } = payload;
+  return JSON.stringify(rest);
+}