@ilya-lesikov/pi-pi 0.6.0 → 0.8.0

package/extensions/orchestrator/usage-tracker.ts

@@ -1,6 +1,23 @@
 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;
+  if (typeof modelId !== "string") return false;
+  // Accept a bare `sub/<m>` id OR a full provider-prefixed spec
+  // `pp-flant-anthropic-sub/sub/<m>` passed as a single id (the form callers
+  // store/pass without a separate provider field).
+  return modelId.startsWith(SUB_MODEL_PREFIX) || modelId.startsWith(`${SUB_PROVIDER}/`);
+}
 
 export interface ModelUsage {
   inputTokens: number;
@@ -9,6 +26,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 +38,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 +67,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 +81,8 @@ interface TrackerState {
   totalTurns: number;
   subagentInputTokens: number;
   subagentOutputTokens: number;
+  subagentCacheReadTokens: number;
+  subagentCacheWriteTokens: number;
   subagentCost: number;
   models: Map<string, ModelUsage>;
   subagents: SubagentUsage[];
@@ -89,6 +114,8 @@ function createInitialState(): TrackerState {
     totalTurns: 0,
     subagentInputTokens: 0,
     subagentOutputTokens: 0,
+    subagentCacheReadTokens: 0,
+    subagentCacheWriteTokens: 0,
     subagentCost: 0,
     models: new Map<string, ModelUsage>(),
     subagents: [],
@@ -99,12 +126,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 +143,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 +155,7 @@ export function createUsageTracker(): UsageTracker {
         cacheWriteTokens: 0,
         cacheSupported: false,
         turns: 0,
+        subscription: false,
       };
 
       usage.inputTokens += safeInput;
@@ -128,6 +163,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 +178,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 +205,7 @@ export function createUsageTracker(): UsageTracker {
         cost: safeCost,
         durationMs: toFiniteNumber(meta?.durationMs),
         toolUses: toFiniteNumber(meta?.toolUses),
+        subscription,
       });
     },
 
@@ -183,24 +225,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 +264,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 +282,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 +325,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 +389,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/extensions/orchestrator/validate-artifacts.test.ts

@@ -41,6 +41,26 @@ Ship minimal fix.
     expect(result.ok).toBe(true);
   });
 
+  it("accepts a Pattern constraints section", () => {
+    const content = `# Plan
+
+## Scope
+Add a new annotation.
+
+## Checklist
+- [ ] Add annotation — Done when: tests pass
+
+## Pattern constraints
+- Mirror deletePolicies: one typed slice, kebab-case values.
+
+## Blockers
+- none
+`;
+
+    const result = validatePlan(content);
+    expect(result.ok).toBe(true);
+  });
+
   it("accepts multiline Done when continuation", () => {
     const content = `# Plan
 

package/extensions/orchestrator/validate-artifacts.ts

@@ -5,7 +5,7 @@ const USER_REQUEST_ALLOWED_SECTIONS = ["Problem", "Constraints"] as const;
 const RESEARCH_REQUIRED_SECTIONS = ["Affected Code", "Architecture Context", "Constraints & Edge Cases"] as const;
 const RESEARCH_ALLOWED_SECTIONS = ["Affected Code", "Architecture Context", "Constraints & Edge Cases", "Open Questions"] as const;
 const PLAN_REQUIRED_SECTIONS = ["Scope", "Checklist"] as const;
-const PLAN_ALLOWED_SECTIONS = ["Scope", "Checklist", "Blockers"] as const;
+const PLAN_ALLOWED_SECTIONS = ["Scope", "Checklist", "Pattern constraints", "Blockers"] as const;
 const PLACEHOLDER_PATTERNS = /^(?:[-*.…—]|tbd|todo|n\/a|na|none|\.{2,})$/i;
 
 function splitLines(content: string): string[] {
@@ -186,7 +186,7 @@ export function validatePlan(content: string): ValidationResult {
   const errors: string[] = [];
   const h1 = getH1(content);
   const firstHeading = getFirstHeading(content);
-  const expectedSections = formatSectionList(PLAN_REQUIRED_SECTIONS, ["Blockers"]);
+  const expectedSections = formatSectionList(PLAN_REQUIRED_SECTIONS, ["Pattern constraints", "Blockers"]);
 
   if (!firstHeading) {
     errors.push("Missing required heading: # Plan. Expected first heading: # Plan");

package/package.json

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