@ilya-lesikov/pi-pi 0.6.0 → 0.7.0

package/extensions/orchestrator/usage-tracker.test.ts

@@ -96,6 +96,7 @@ describe("usage-tracker", () => {
         cacheWriteTokens: 0,
         cacheSupported: false,
         turns: 1,
+        subscription: false,
       },
       "anthropic/claude-opus-4-6": {
         inputTokens: 7,
@@ -104,6 +105,7 @@ describe("usage-tracker", () => {
         cacheWriteTokens: 0,
         cacheSupported: false,
         turns: 1,
+        subscription: false,
       },
     });
   });
@@ -186,6 +188,7 @@ describe("usage-tracker", () => {
         cost: 0.2,
         durationMs: 900,
         toolUses: 3,
+        subscription: false,
       },
     ]);
   });
@@ -226,12 +229,21 @@ describe("usage-tracker", () => {
     expect(tracker.getTotalCost()).toBe(2);
   });
 
-  it("getCacheHitRate calculates ratio", () => {
+  it("getCacheHitRate is cacheRead over processed input (uncached + read + write)", () => {
     const tracker = createUsageTracker();
 
-    tracker.recordTurn("openai/gpt-5", "openai", 30, 0, 10, 0, 0, true);
+    // uncached 30, cacheRead 10, cacheWrite 10 → 10 / (30+10+10) = 0.2
+    tracker.recordTurn("openai/gpt-5", "openai", 30, 0, 10, 10, 0, true);
 
-    expect(tracker.getCacheHitRate()).toBeCloseTo(10 / 40);
+    expect(tracker.getCacheHitRate()).toBeCloseTo(10 / 50);
+  });
+
+  it("getCacheHitRate includes subagent cache tokens", () => {
+    const tracker = createUsageTracker();
+    tracker.recordTurn("openai/gpt-5", "openai", 10, 0, 0, 0, 0, true);
+    tracker.recordSubagentCompletion({ input: 0, output: 0, cacheRead: 30, cacheWrite: 10 } as any);
+    // cacheRead 30 / processed (10 + 30 + 10) = 0.6
+    expect(tracker.getCacheHitRate()).toBeCloseTo(30 / 50);
   });
 
   it("getCacheHitRate returns zero when denominator is zero", () => {
@@ -239,6 +251,22 @@ describe("usage-tracker", () => {
     expect(tracker.getCacheHitRate()).toBe(0);
   });
 
+  it("getTotalProcessedInputTokens sums uncached + cache read + cache write across main and subagents", () => {
+    const tracker = createUsageTracker();
+    tracker.recordTurn("openai/gpt-5", "openai", 10, 0, 20, 5, 0, true);
+    tracker.recordSubagentCompletion({ input: 3, output: 0, cacheRead: 7, cacheWrite: 2 } as any);
+    // main: 10+20+5=35, subagent: 3+7+2=12 → 47
+    expect(tracker.getTotalProcessedInputTokens()).toBe(47);
+  });
+
+  it("getTotalCacheReadTokens and getTotalCacheWriteTokens include subagents", () => {
+    const tracker = createUsageTracker();
+    tracker.recordTurn("openai/gpt-5", "openai", 0, 0, 20, 5, 0, true);
+    tracker.recordSubagentCompletion({ input: 0, output: 0, cacheRead: 7, cacheWrite: 2 } as any);
+    expect(tracker.getTotalCacheReadTokens()).toBe(27);
+    expect(tracker.getTotalCacheWriteTokens()).toBe(7);
+  });
+
   it("isCacheSupported true when any model or subagent has cache", () => {
     const tracker = createUsageTracker();
     expect(tracker.isCacheSupported()).toBe(false);
@@ -382,6 +410,106 @@ describe("usage-tracker", () => {
     expect(roundTrip.subagents).toEqual((mid as any).subagents);
   });
 
+  it("subscription main turns count tokens but contribute zero cost", () => {
+    const tracker = createUsageTracker();
+
+    // Detected via the sub/ model id prefix...
+    tracker.recordTurn("sub/claude-opus-4-6", "anthropic", 100, 50, 10, 5, 1.23, true);
+    // ...or via the subscription provider with a bare id (keyed under sub/).
+    tracker.recordTurn("claude-opus-4-6", "pp-flant-anthropic-sub", 20, 10, 0, 0, 0.5, true);
+
+    expect(tracker.getMainInputTokens()).toBe(120);
+    expect(tracker.getMainOutputTokens()).toBe(60);
+    expect(tracker.getMainCacheReadTokens()).toBe(10);
+    expect(tracker.getMainCost()).toBe(0);
+    expect(tracker.getTotalCost()).toBe(0);
+    expect(tracker.getPerModelUsage()["sub/claude-opus-4-6"]?.subscription).toBe(true);
+  });
+
+  it("provider-detected subscription turns key under sub/ so paid rows stay separate", () => {
+    const tracker = createUsageTracker();
+
+    // Same underlying model id: one paid, one subscription (provider-only).
+    tracker.recordTurn("claude-opus-4-6", "pp-flant-anthropic", 10, 5, 0, 0, 0.4, false);
+    tracker.recordTurn("claude-opus-4-6", "pp-flant-anthropic-sub", 20, 10, 0, 0, 2.0, false);
+
+    const usage = tracker.getPerModelUsage();
+    expect(usage["claude-opus-4-6"]).toMatchObject({ inputTokens: 10, outputTokens: 5, subscription: false });
+    expect(usage["sub/claude-opus-4-6"]).toMatchObject({ inputTokens: 20, outputTokens: 10, subscription: true });
+    expect(tracker.getMainCost()).toBeCloseTo(0.4);
+  });
+
+  it("subscription subagents count tokens but contribute zero cost", () => {
+    const tracker = createUsageTracker();
+
+    tracker.recordSubagentCompletion({ input: 30, output: 15 } as any, 0.9, {
+      description: "Explore", agentType: "explore", modelId: "sub/claude-haiku-4-5",
+    });
+
+    expect(tracker.getSubagentTotals()).toEqual({ inputTokens: 30, outputTokens: 15, cost: 0 });
+    expect(tracker.getSubagentList()[0]?.subscription).toBe(true);
+    expect(tracker.getSubagentList()[0]?.cost).toBe(0);
+  });
+
+  it("mixed paid and subscription session totals only the paid portion", () => {
+    const tracker = createUsageTracker();
+
+    tracker.recordTurn("openai/gpt-5", "openai", 10, 5, 0, 0, 0.4, false);
+    tracker.recordTurn("sub/claude-opus-4-6", "pp-flant-anthropic-sub", 10, 5, 0, 0, 2.0, false);
+    tracker.recordSubagentCompletion({ input: 5, output: 2 } as any, 0.1, { modelId: "openai/gpt-5" });
+    tracker.recordSubagentCompletion({ input: 5, output: 2 } as any, 3.0, { modelId: "sub/claude-haiku-4-5" });
+
+    expect(tracker.getMainCost()).toBeCloseTo(0.4);
+    expect(tracker.getSubagentTotals().cost).toBeCloseTo(0.1);
+    expect(tracker.getTotalCost()).toBeCloseTo(0.5);
+  });
+
+  it("subscription marker survives JSON round-trip and stays paid-only", () => {
+    const source = createUsageTracker();
+    source.recordTurn("sub/claude-opus-4-6", "pp-flant-anthropic-sub", 10, 5, 0, 0, 2.0, true);
+    source.recordSubagentCompletion({ input: 5, output: 2 } as any, 3.0, { modelId: "sub/claude-haiku-4-5" });
+
+    const mid = source.toSummary() as Record<string, unknown>;
+    const restored = createUsageTracker();
+    restored.loadFromSummary(mid);
+
+    const roundTrip = restored.toSummary() as any;
+    expect(restored.getTotalCost()).toBe(0);
+    expect(restored.getPerModelUsage()["sub/claude-opus-4-6"]?.subscription).toBe(true);
+    expect(restored.getSubagentList()[0]?.subscription).toBe(true);
+    expect(roundTrip.totals).toEqual((mid as any).totals);
+    expect(roundTrip.models).toEqual((mid as any).models);
+    expect(roundTrip.subagents).toEqual((mid as any).subagents);
+  });
+
+  it("legacy summaries without subscription field default to non-subscription", () => {
+    const tracker = createUsageTracker();
+    tracker.loadFromSummary({
+      totals: { inputTokens: 10, outputTokens: 5, cost: 1.5, turns: 1 },
+      models: { "openai/gpt-5": { inputTokens: 10, outputTokens: 5, turns: 1 } },
+      subagents: [{ description: "a", agentType: "x", modelId: "m", inputTokens: 3, outputTokens: 1, cost: 0.2 }],
+    });
+
+    expect(tracker.getPerModelUsage()["openai/gpt-5"]?.subscription).toBe(false);
+    expect(tracker.getSubagentList()[0]?.subscription).toBe(false);
+    expect(tracker.getMainCost()).toBe(1.5);
+    expect(tracker.getSubagentTotals().cost).toBeCloseTo(0.2);
+  });
+
+  it("loadFromSummary recovers subscription from sub/ prefix when flag is absent", () => {
+    const tracker = createUsageTracker();
+    tracker.loadFromSummary({
+      totals: { inputTokens: 10, outputTokens: 5, cost: 0, turns: 1 },
+      models: { "sub/claude-opus-4-6": { inputTokens: 10, outputTokens: 5, turns: 1 } },
+      subagents: [{ description: "a", agentType: "x", modelId: "sub/claude-haiku-4-5", inputTokens: 3, outputTokens: 1, cost: 2.5 }],
+    });
+
+    expect(tracker.getPerModelUsage()["sub/claude-opus-4-6"]?.subscription).toBe(true);
+    expect(tracker.getSubagentList()[0]?.subscription).toBe(true);
+    expect(tracker.getSubagentList()[0]?.cost).toBe(0);
+    expect(tracker.getSubagentTotals().cost).toBe(0);
+  });
+
   it("reset clears all state", () => {
     const tracker = createUsageTracker();
     tracker.recordTurn("openai/gpt-5", "openai", 1, 2, 3, 4, 0.2, true);

package/extensions/orchestrator/usage-tracker.ts

@@ -1,6 +1,19 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { SUB_MODEL_PREFIX, SUB_PROVIDER } from "./flant-infra.js";
+
+/**
+ * A usage unit is subscription-routed (flat-rate personal Claude subscription,
+ * not per-token billed) when its main-turn provider is the subscription
+ * provider, or when the registered model id carries the `sub/` prefix. The
+ * prefix is the only signal available for subagents (subagents:completed has no
+ * provider field), so we always check it in addition to the provider.
+ */
+export function isSubscriptionRouted(modelId?: string, provider?: string): boolean {
+  if (provider === SUB_PROVIDER) return true;
+  return typeof modelId === "string" && modelId.startsWith(SUB_MODEL_PREFIX);
+}
 
 export interface ModelUsage {
   inputTokens: number;
@@ -9,6 +22,8 @@ export interface ModelUsage {
   cacheWriteTokens: number;
   cacheSupported: boolean;
   turns: number;
+  /** Flat-rate personal subscription: dollars are excluded from cost totals, tokens are not. */
+  subscription: boolean;
 }
 
 export interface UsageTracker {
@@ -19,6 +34,8 @@ export interface UsageTracker {
   getTotalOutputTokens(): number;
   getTotalCacheReadTokens(): number;
   getTotalCacheWriteTokens(): number;
+  /** Total input the model actually processed: uncached input + cache read + cache write (main + subagents). */
+  getTotalProcessedInputTokens(): number;
   getTotalCost(): number;
   getMainInputTokens(): number;
   getMainOutputTokens(): number;
@@ -46,6 +63,8 @@ export interface SubagentUsage {
   cost: number;
   durationMs: number;
   toolUses: number;
+  /** Flat-rate personal subscription: dollars are excluded from cost totals, tokens are not. */
+  subscription: boolean;
 }
 
 interface TrackerState {
@@ -58,6 +77,8 @@ interface TrackerState {
   totalTurns: number;
   subagentInputTokens: number;
   subagentOutputTokens: number;
+  subagentCacheReadTokens: number;
+  subagentCacheWriteTokens: number;
   subagentCost: number;
   models: Map<string, ModelUsage>;
   subagents: SubagentUsage[];
@@ -89,6 +110,8 @@ function createInitialState(): TrackerState {
     totalTurns: 0,
     subagentInputTokens: 0,
     subagentOutputTokens: 0,
+    subagentCacheReadTokens: 0,
+    subagentCacheWriteTokens: 0,
     subagentCost: 0,
     models: new Map<string, ModelUsage>(),
     subagents: [],
@@ -99,12 +122,15 @@ export function createUsageTracker(): UsageTracker {
   const state = createInitialState();
 
   return {
-    recordTurn(modelId: string, _provider: string, input: number, output: number, cacheRead: number, cacheWrite: number, cost: number, cacheSupported?: boolean): void {
+    recordTurn(modelId: string, provider: string, input: number, output: number, cacheRead: number, cacheWrite: number, cost: number, cacheSupported?: boolean): void {
       const safeInput = toFiniteNumber(input);
       const safeOutput = toFiniteNumber(output);
       const safeCacheRead = toFiniteNumber(cacheRead);
       const safeCacheWrite = toFiniteNumber(cacheWrite);
-      const safeCost = toFiniteNumber(cost);
+      const subscription = isSubscriptionRouted(modelId, provider);
+      // Subscription-routed turns are flat-rate: keep the tokens but exclude the
+      // fictitious per-token dollars so totals stay paid-only by construction.
+      const safeCost = subscription ? 0 : toFiniteNumber(cost);
 
       state.totalInputTokens += safeInput;
       state.totalOutputTokens += safeOutput;
@@ -113,7 +139,11 @@ export function createUsageTracker(): UsageTracker {
       state.totalCost += safeCost;
       state.totalTurns += 1;
 
-      const key = modelId || "unknown-model";
+      // Key subscription turns under the sub/ prefix even when detected only by
+      // provider (bare model id), so a paid and a subscription turn for the same
+      // underlying model never share a row and the paid dollars stay visible.
+      const baseKey = modelId || "unknown-model";
+      const key = subscription && !baseKey.startsWith(SUB_MODEL_PREFIX) ? `${SUB_MODEL_PREFIX}${baseKey}` : baseKey;
       const usage = state.models.get(key) ?? {
         inputTokens: 0,
         outputTokens: 0,
@@ -121,6 +151,7 @@ export function createUsageTracker(): UsageTracker {
         cacheWriteTokens: 0,
         cacheSupported: false,
         turns: 0,
+        subscription: false,
       };
 
       usage.inputTokens += safeInput;
@@ -128,6 +159,7 @@ export function createUsageTracker(): UsageTracker {
       usage.cacheReadTokens += safeCacheRead;
       usage.cacheWriteTokens += safeCacheWrite;
       if (cacheSupported) usage.cacheSupported = true;
+      if (subscription) usage.subscription = true;
       usage.turns += 1;
       state.models.set(key, usage);
     },
@@ -142,12 +174,17 @@ export function createUsageTracker(): UsageTracker {
       const safeTotal = toFiniteNumber(tokens.total);
       const safeCacheRead = toFiniteNumber(tokens.cacheRead);
       const safeCacheWrite = toFiniteNumber(tokens.cacheWrite);
-      const safeCost = toFiniteNumber(tokens.cost ?? cost);
+      // Subagents carry no provider field, so detect subscription routing from
+      // the registered model id prefix. Zero the dollars when subscription.
+      const subscription = isSubscriptionRouted(meta?.modelId);
+      const safeCost = subscription ? 0 : toFiniteNumber(tokens.cost ?? cost);
 
       const effectiveInput = safeInput === 0 && safeOutput === 0 ? safeTotal : safeInput;
 
       state.subagentInputTokens += effectiveInput;
       state.subagentOutputTokens += safeOutput;
+      state.subagentCacheReadTokens += safeCacheRead;
+      state.subagentCacheWriteTokens += safeCacheWrite;
       state.subagentCost += safeCost;
 
       const cacheSupported = typeof tokens.cacheRead === "number" || typeof tokens.cacheWrite === "number";
@@ -164,6 +201,7 @@ export function createUsageTracker(): UsageTracker {
         cost: safeCost,
         durationMs: toFiniteNumber(meta?.durationMs),
         toolUses: toFiniteNumber(meta?.toolUses),
+        subscription,
       });
     },
 
@@ -183,24 +221,33 @@ export function createUsageTracker(): UsageTracker {
         state.subagents = [];
         state.subagentInputTokens = 0;
         state.subagentOutputTokens = 0;
+        state.subagentCacheReadTokens = 0;
+        state.subagentCacheWriteTokens = 0;
         state.subagentCost = 0;
         for (const sa of summary.subagents as Record<string, unknown>[]) {
+          const modelId = typeof sa.modelId === "string" ? sa.modelId : "unknown";
+          // Pre-change summaries lack the flag; recover it from the sub/ prefix
+          // so legacy subscription rows are not restored as paid.
+          const subscription = sa.subscription === true || isSubscriptionRouted(modelId);
           const entry: SubagentUsage = {
             description: typeof sa.description === "string" ? sa.description : "unknown",
             agentType: typeof sa.agentType === "string" ? sa.agentType : "unknown",
-            modelId: typeof sa.modelId === "string" ? sa.modelId : "unknown",
+            modelId,
             inputTokens: toFiniteNumber(sa.inputTokens),
             outputTokens: toFiniteNumber(sa.outputTokens),
             cacheReadTokens: toFiniteNumber(sa.cacheReadTokens),
             cacheWriteTokens: toFiniteNumber(sa.cacheWriteTokens),
             cacheSupported: sa.cacheSupported === true,
-            cost: toFiniteNumber(sa.cost),
+            cost: subscription ? 0 : toFiniteNumber(sa.cost),
             durationMs: toFiniteNumber(sa.durationMs),
             toolUses: toFiniteNumber(sa.toolUses),
+            subscription,
           };
           state.subagents.push(entry);
           state.subagentInputTokens += entry.inputTokens;
           state.subagentOutputTokens += entry.outputTokens;
+          state.subagentCacheReadTokens += entry.cacheReadTokens;
+          state.subagentCacheWriteTokens += entry.cacheWriteTokens;
           state.subagentCost += entry.cost;
         }
       }
@@ -213,6 +260,7 @@ export function createUsageTracker(): UsageTracker {
             cacheWriteTokens: toFiniteNumber(usage.cacheWriteTokens),
             cacheSupported: (usage as any).cacheSupported === true,
             turns: toFiniteNumber(usage.turns),
+            subscription: (usage as any).subscription === true || isSubscriptionRouted(modelId),
           });
         }
       }
@@ -230,11 +278,22 @@ export function createUsageTracker(): UsageTracker {
     },
 
     getTotalCacheReadTokens(): number {
-      return state.totalCacheReadTokens;
+      return state.totalCacheReadTokens + state.subagentCacheReadTokens;
     },
 
     getTotalCacheWriteTokens(): number {
-      return state.totalCacheWriteTokens;
+      return state.totalCacheWriteTokens + state.subagentCacheWriteTokens;
+    },
+
+    getTotalProcessedInputTokens(): number {
+      return (
+        state.totalInputTokens +
+        state.subagentInputTokens +
+        state.totalCacheReadTokens +
+        state.subagentCacheReadTokens +
+        state.totalCacheWriteTokens +
+        state.subagentCacheWriteTokens
+      );
     },
 
     getTotalCost(): number {
@@ -262,9 +321,11 @@ export function createUsageTracker(): UsageTracker {
     },
 
     getCacheHitRate(): number {
-      const totalInput = state.totalInputTokens + state.subagentInputTokens;
-      const totalCacheRead = state.totalCacheReadTokens;
-      const denominator = totalCacheRead + totalInput;
+      const totalCacheRead = state.totalCacheReadTokens + state.subagentCacheReadTokens;
+      // Session-wide, token-weighted average: cache reads over all processed
+      // input (uncached input + cache read + cache write). Including cache
+      // writes keeps first-touch (uncached) content from inflating the rate.
+      const denominator = this.getTotalProcessedInputTokens();
       if (denominator <= 0) return 0;
       return totalCacheRead / denominator;
     },
@@ -324,6 +385,8 @@ export function createUsageTracker(): UsageTracker {
       state.totalTurns = 0;
       state.subagentInputTokens = 0;
       state.subagentOutputTokens = 0;
+      state.subagentCacheReadTokens = 0;
+      state.subagentCacheWriteTokens = 0;
       state.subagentCost = 0;
       state.models.clear();
       state.subagents = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ilya-lesikov/pi-pi",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Pi-Pi Coding Agent: based on Pi Coding Agent, but twice as good",
   "keywords": [
     "pi-package",