@nijaru/pi-provider-compaction 0.0.9 → 0.0.10

package/README.md

@@ -14,7 +14,9 @@ Pi has replacement provider registration, not composable middleware. This extens
 - **Existing static legacy `streamSimple` registrations:** the original callback and configuration are retained. This includes `pi-fast-mode`'s Codex registration.
 - **Built-in and composed providers:** the existing provider object's full and simple streaming methods are leased separately, without re-registering the provider or rebuilding auth/catalog configuration. Each original method retains its receiver. Cleanup restores only still-owned methods; replacing the provider revokes observation until it is reacquired.
 
-Sessions sharing a model runtime share observation dispatchers, not their captured histories. Releasing one session's lease leaves the others active; the final lease restores the original provider.
+Sessions sharing a model runtime share observation dispatchers, not their captured histories. Leases are scoped to the provider/API dispatch path, including models.json APIs that bypass a native base. Releasing one session's lease leaves the others active; the final lease restores the original provider.
+
+With the current `pi-peak-hours` companion, the same dispatcher applies request-scoped pricing before terminal usage reaches consumers or cache evidence. This covers foreground responses, warming, portable/native compaction and branch summaries without stacking competing provider wrappers. The SDK's header-record identity establishes ownership for summaries with independent routing IDs; no header content is read, copied or changed. Unknown ownership stays unadjusted. Prices remain estimates, not invoices.
 
 For an eligible request, protocol selection is automatic:
 
@@ -63,7 +65,7 @@ Request-only suffix additions, deletions, redactions and reordering can survive
 
 ## Safety and persistence
 
-Version 3 stores the portable summary, native output, usage, route identity and validated prefix metadata in one compaction entry. Both generation requests contribute to usage accounting. Raw credentials, complete auth headers and request snapshots are never persisted.
+Version 3 stores the portable summary, native output, usage, route identity and validated prefix metadata in one compaction entry. Both generation requests contribute to usage accounting, including reported native usage when checkpoint validation fails. Raw credentials, complete auth headers and request snapshots are never persisted.
 
 Native eligibility is deliberately **session-local and short-lived**. Restart, reload, SDK disposal, resume, fork, tree navigation, model changes, covered-history edits, and relevant prompt/tool/route changes revoke it. A credential refresh may conservatively revoke it too. Persisted native metadata alone is not authority to replay hidden content under a new runtime's privacy policy.
 
@@ -75,7 +77,7 @@ Legacy v1/v2 whole-history checkpoints remain inspectable but are never reinterp
 
 ## Diagnose portable fallback
 
-Run `/provider-compaction-status` to see observer/capture eligibility, estimated cache lifetime, the last selected path, elapsed time, reported input/cache/output tokens, and catalog-priced cost. Optional outcome notifications show measured usage after a committed compaction; hypothetical savings are not presented as measured. Failed/cancelled expiry attempts remain visible in runtime status; if no checkpoint is saved, their usage cannot be attached to compaction totals through Pi's extension API. Portable fallback also appends a `pi-provider-compaction:diagnostic` session entry containing only a fixed reason string. It is not included in model context. Diagnostics never include request content, credentials, or backend error text.
+Run `/provider-compaction-status` to see observer/capture eligibility, estimated cache lifetime, the last selected path, elapsed time, reported input/cache/output tokens, and estimated cost (including available companion corrections). Optional outcome notifications show measured usage after a committed compaction; hypothetical savings are not presented as measured. Failed/cancelled expiry attempts remain visible in runtime status; if no checkpoint is saved, their usage cannot be attached to compaction totals through Pi's extension API. Portable fallback also appends a `pi-provider-compaction:diagnostic` session entry containing only a fixed reason string. It is not included in model context. Diagnostics never include request content, credentials, or backend error text.
 
 These diagnostics require the extension to be loaded when the attempt happens; they cannot explain earlier compactions retroactively. A committed native checkpoint does not by itself prove that a later request replayed it.
 
@@ -100,7 +102,7 @@ pi --extension ./dist/index.js
 
 The manifest loads the built `dist/index.js`, including a bundled stateless Responses serializer validator; source or host dependency changes require a rebuild. `bun run check` rebuilds first and tests the artifact against Pi's actual host serializer, including function-call history replayed as grammar tools. Keep global installation disabled while testing. Publishing and global activation are separate approval steps.
 
-Tests include real Pi 1.4.0 runner/adapter fixtures for all three protocols, repeated prefix compaction, transformed suffix preservation, unchanged fallback, grammar tools, strict defaults, tool IDs, images, prompt updates, cross-model thinking and mid-conversation effort changes. Set `PI_COMPACTOR_FIXTURE_PATH` to a `pi-compactor` entrypoint to check SDK flag precedence and real idle-expiry transactions in both extension orders. Cached-summary fixtures also exercise built-in DeepSeek/Xiaomi dispatch, Anthropic Messages, late tool output, truncated-output fallback and measured usage. The optional installed-fast-mode fixture (`PI_FAST_MODE_FIXTURE_PATH`) checks actual `pi-fast-mode` composition across `/reload`; it creates an isolated fast-mode configuration.
+Tests include real Pi 1.4.0 runner/adapter fixtures for all three protocols, repeated prefix compaction, transformed suffix preservation, unchanged fallback, grammar tools, strict defaults, tool IDs, images, prompt updates, cross-model thinking and mid-conversation effort changes. Set `PI_COMPACTOR_FIXTURE_PATH` to a `pi-compactor` entrypoint to check SDK flag precedence and real idle-expiry transactions in both extension orders. Cached-summary fixtures also exercise built-in DeepSeek/Xiaomi dispatch, Anthropic Messages, late tool output, truncated-output fallback and measured usage. The optional installed-fast-mode fixture (`PI_FAST_MODE_FIXTURE_PATH`) checks actual `pi-fast-mode` composition across `/reload`; it creates an isolated fast-mode configuration. `PI_PEAK_HOURS_FIXTURE_PATH` adds request-wide pricing checks in both extension orders, including warming, branch summaries, mixed-API dispatch and composition with `/fast`.
 
 Authenticated cached-summary smoke tests use synthetic history, including a value beyond the ordinary tool-result excerpt, and check continuation:
 

package/dist/index.js

@@ -16,7 +16,6 @@ var COMPACTION_MODEL_FLAG = "compaction-model";
 var PROJECT_POLICY = "compaction-policy.json";
 var AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
 var MAX_POLICY_BYTES = 64 * 1024;
-var MAX_MODEL_SELECTORS = 8;
 var MAX_SELECTOR_LENGTH = 512;
 function normalizeSelector(value) {
   if (typeof value !== "string")
@@ -26,23 +25,14 @@ function normalizeSelector(value) {
     return;
   return selector;
 }
-function parsePolicySelectors(value) {
+function policyHasSelectors(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return;
   if (!("models" in value) || !Array.isArray(value.models))
     return;
-  const selectors = [];
-  for (const model of value.models) {
-    const selector = normalizeSelector(model);
-    if (selector === undefined || selectors.includes(selector))
-      continue;
-    selectors.push(selector);
-    if (selectors.length === MAX_MODEL_SELECTORS)
-      break;
-  }
-  return selectors;
+  return value.models.some((model) => normalizeSelector(model) !== undefined);
 }
-function readPolicySelectors(configPath) {
+function readPolicySelection(configPath) {
   let fd;
   try {
     fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
@@ -59,7 +49,7 @@ function readPolicySelectors(configPath) {
     }
     if (bytesRead > MAX_POLICY_BYTES)
       return;
-    return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
+    return policyHasSelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")));
   } catch {
     return;
   } finally {
@@ -141,9 +131,9 @@ function resolveCompactionModelPolicy(pi, ctx, argv = process.argv.slice(2)) {
   }
   candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
   for (const candidate of candidates) {
-    const selectors = readPolicySelectors(candidate.path);
-    if (selectors !== undefined) {
-      return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
+    const hasSelectors = readPolicySelection(candidate.path);
+    if (hasSelectors !== undefined) {
+      return hasSelectors ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
     }
   }
   return { hasSelectors: false };
@@ -1170,7 +1160,7 @@ async function collectProviderUsage(stream, signal) {
     if (signal.aborted)
       throw new DOMException("Compaction aborted", "AbortError");
     if (event.type === "error")
-      throw new Error(event.error.errorMessage ?? "Native compaction provider request failed");
+      throw new NativeCompactionValidationError("Native compaction provider stream failed", event.error.usage);
     if (event.type === "done")
       usage = event.message.usage;
   }
@@ -1216,14 +1206,15 @@ async function requestResponsesCompact(request) {
       if (!response.ok)
         return response;
       const parsed = await readJsonBounded(response, request.signal);
+      if (!isObject(parsed))
+        throw new Error("Responses Compact returned a non-object response");
+      const completion = syntheticCompletion(parsed, preparedPayload);
       try {
-        if (!isObject(parsed))
-          throw new Error("Responses Compact returned a non-object response");
-        compacted = { response: parsed, output: validateCompactedOutput(parsed) };
+        compacted = validateCompactedOutput(parsed);
       } catch (error) {
-        throw new NativeCompactionValidationError(error instanceof Error ? error.message : String(error));
+        bridgeError = new NativeCompactionValidationError(error instanceof Error ? error.message : String(error));
       }
-      return syntheticCompletion(parsed, preparedPayload);
+      return completion;
     } catch (error) {
       bridgeError = error;
       return errorResponse(error);
@@ -1238,6 +1229,7 @@ async function requestResponsesCompact(request) {
     transport: "sse",
     cacheRetention: "none",
     maxRetries: 0,
+    sessionId: request.sessionId,
     fetch: bridgeFetch,
     onPayload: (payload) => {
       assertCurrent(request);
@@ -1251,7 +1243,7 @@ async function requestResponsesCompact(request) {
   });
   const usage = await collectProviderUsage(stream, request.signal).catch((error) => {
     if (bridgeError)
-      throw bridgeError;
+      throw new NativeCompactionValidationError("Native compaction transport or validation failed", error instanceof NativeCompactionValidationError ? error.usage : undefined);
     throw error;
   });
   if (bridgeError instanceof NativeCompactionValidationError)
@@ -1260,7 +1252,7 @@ async function requestResponsesCompact(request) {
     throw bridgeError;
   if (!compacted || dispatches !== 1)
     throw new Error("Responses Compact did not complete exactly one request");
-  return { output: compacted.output, usage };
+  return { output: compacted, usage };
 }
 async function collectCompactionSse(stream, signal) {
   const reader = stream.getReader();
@@ -1405,6 +1397,7 @@ async function requestRemoteV2(request) {
     transport: "sse",
     cacheRetention: "none",
     maxRetries: 0,
+    sessionId: request.sessionId,
     fetch: inspectedFetch,
     onPayload: (payload) => {
       assertCurrent(request);
@@ -1419,10 +1412,10 @@ async function requestRemoteV2(request) {
   try {
     const usage = await collectProviderUsage(stream, request.signal);
     if (!sentInput || inspections.length !== 1)
-      throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+      throw new NativeCompactionValidationError(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`, usage);
     const inspection = await inspections[0];
     if ("error" in inspection)
-      throw inspection.error;
+      throw new NativeCompactionValidationError("Remote V2 checkpoint validation failed", usage);
     return { output: buildRemoteV2History(sentInput, inspection.result.item), usage };
   } finally {
     controller.abort();
@@ -1825,17 +1818,26 @@ async function cachedSummary(request, context, preparation, instructions, signal
 }
 
 // provider.ts
+import { createAssistantMessageEventStream } from "@earendil-works/pi-ai";
+var USAGE_OWNERS = Symbol.for("@nijaru/pi-provider-compaction/usage-owners");
+var usageGlobal = globalThis;
+var usageOwners = usageGlobal[USAGE_OWNERS] ??= new WeakMap;
+function bindUsageHeaders(headers, sessionId) {
+  usageOwners.set(headers, sessionId);
+}
 var STREAM_OBSERVER = Symbol.for("@nijaru/pi-provider-compaction/stream-observer");
 function observedStream(model, context, options, observe, dispatch) {
+  const headerOwner = options?.headers ? usageOwners.get(options.headers) : undefined;
+  const scope = { sessionId: headerOwner ?? options?.sessionId };
   let handler;
   try {
-    handler = observe(model, context, options ?? {});
+    handler = observe(model, context, options ?? {}, scope);
   } catch {
     return dispatch(options);
   }
   if (!handler)
     return dispatch(options);
-  const stream = dispatch({
+  const run = () => dispatch({
     ...options,
     ...handler.cacheRetention === undefined ? {} : { cacheRetention: handler.cacheRetention },
     onPayload: async (payload, requestModel) => {
@@ -1848,14 +1850,64 @@ function observedStream(model, context, options, observe, dispatch) {
       }
     }
   });
+  const stream = run();
+  if (handler.priceUsage)
+    return pricedStream(stream, model, handler);
   if (handler.complete)
     stream.result().then(handler.complete).catch(() => {});
   return stream;
 }
+function pricedStream(stream, model, handler) {
+  const out = createAssistantMessageEventStream();
+  (async () => {
+    let final;
+    let partial;
+    try {
+      for await (const event of stream) {
+        if ("partial" in event)
+          partial = event.partial;
+        if (event.type === "done" || event.type === "error") {
+          final = event.type === "done" ? event.message : event.error;
+          try {
+            handler.priceUsage?.(final);
+          } catch {}
+          try {
+            handler.complete?.(final);
+          } catch {}
+        }
+        out.push(event);
+      }
+      if (final) {
+        out.end(final);
+        return;
+      }
+    } catch {}
+    const message = {
+      ...partial ?? {
+        role: "assistant",
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        content: [],
+        timestamp: Date.now(),
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } }
+      },
+      stopReason: "error",
+      errorMessage: "Provider stream ended before a terminal event"
+    };
+    try {
+      handler.priceUsage?.(message);
+    } catch {}
+    out.push({ type: "error", reason: "error", error: message });
+    out.end(message);
+  })();
+  return out;
+}
 function observerLeases(provider, owned, restore) {
   const leases = new Map;
   let closed = false;
-  const active = (token) => !closed && leases.get(token)?.current() === true && owned();
+  const live = (token) => !closed && leases.has(token);
+  const active = (token) => live(token) && leases.get(token)?.current() === true && owned();
   const release = () => {
     if (closed)
       return;
@@ -1874,6 +1926,10 @@ function observerLeases(provider, owned, restore) {
           continue;
         handlers.push(Object.assign((payload) => active(token) ? handler(payload) : payload, {
           cacheRetention: handler.cacheRetention,
+          priceUsage: handler.priceUsage ? (message) => {
+            if (live(token))
+              handler.priceUsage(message);
+          } : undefined,
           complete: handler.complete ? (message) => {
             if (active(token))
               handler.complete(message);
@@ -1894,6 +1950,13 @@ function observerLeases(provider, owned, restore) {
       return payload;
     }, {
       cacheRetention: [...handlers].reverse().find((handler) => handler.cacheRetention !== undefined)?.cacheRetention,
+      priceUsage: handlers.some((handler) => handler.priceUsage) ? (message) => {
+        for (const handler of handlers) {
+          try {
+            handler.priceUsage?.(message);
+          } catch {}
+        }
+      } : undefined,
       complete: handlers.some((handler) => handler.complete) ? (message) => {
         for (const handler of handlers) {
           try {
@@ -1918,7 +1981,7 @@ function observerLeases(provider, owned, restore) {
     }
   };
 }
-var LEASE_TABLES = Symbol.for("@nijaru/pi-provider-compaction/observer-leases-v1");
+var LEASE_TABLES = Symbol.for("@nijaru/pi-provider-compaction/observer-leases-v2");
 var shared = globalThis;
 var { effectiveLeases, effectiveRestores, nativeLeases, legacyLeases } = shared[LEASE_TABLES] ??= {
   effectiveLeases: new WeakMap,
@@ -1994,13 +2057,21 @@ function installObserver(pi, ctx, observe) {
     return;
   const registry = ctx.modelRegistry;
   const id = model.provider;
+  const observeApi = (requestModel, ...args) => requestModel.api === model.api ? observe(requestModel, ...args) : undefined;
+  const tagged = (lease) => lease ? Object.assign(lease, { api: model.api }) : undefined;
+  const effective = () => {
+    const base = registry.getProvider(id);
+    if (!base?.getModels().some((entry) => entry.api === model.api))
+      return;
+    return tagged(leaseEffectiveProvider(base, () => registry.getProvider(id), observeApi));
+  };
   const native = registry.getRegisteredNativeProvider(id);
   if (native) {
     if (typeof native.getModels !== "function" || !native.getModels().some((entry) => entry.api === model.api))
-      return;
+      return effective();
     const existing = nativeLeases.get(native);
     if (existing)
-      return existing.add(observe);
+      return tagged(existing.add(observeApi));
     const leases = observerLeases(id, () => registry.getRegisteredNativeProvider(id) === wrapper, () => {
       if (registry.getRegisteredNativeProvider(id) === wrapper)
         registry.registerProvider(native);
@@ -2009,15 +2080,15 @@ function installObserver(pi, ctx, observe) {
     const wrapper = decorateProvider(native, leases.observe);
     nativeLeases.set(wrapper, leases);
     pi.registerProvider(wrapper);
-    return leases.add(observe);
+    return tagged(leases.add(observeApi));
   }
   const original = registry.getRegisteredProviderConfig(id);
   if (!original?.streamSimple || original.refreshModels || original.oauth?.modifyModels || original.api !== model.api) {
-    return leaseEffectiveProvider(registry.getProvider(id), () => registry.getProvider(id), observe);
+    return effective();
   }
   const existing = legacyLeases.get(original.streamSimple);
   if (existing)
-    return existing.add(observe);
+    return tagged(existing.add(observeApi));
   const delegate = original.streamSimple.bind(original);
   const owned = () => registry.getRegisteredProviderConfig(id)?.streamSimple === wrapper && !registry.getRegisteredNativeProvider(id);
   const leases = observerLeases(id, owned, () => {
@@ -2032,7 +2103,62 @@ function installObserver(pi, ctx, observe) {
   Object.defineProperty(wrapper, STREAM_OBSERVER, { value: { delegate: original.streamSimple, release: leases.release } });
   legacyLeases.set(wrapper, leases);
   pi.registerProvider(id, { ...original, streamSimple: wrapper });
-  return leases.add(observe);
+  return tagged(leases.add(observeApi));
+}
+
+// usage-observer.ts
+var REQUEST = "pi-provider-compaction:observe-usage";
+var READY = "pi-provider-compaction:usage-observer-ready";
+function serveUsageObservers(pi, current) {
+  const leases = new Set;
+  const remove = pi.events.on(REQUEST, (value) => {
+    const request = value;
+    const owner = current();
+    if (!owner || !request || request.handled || !request.context || !request.model || typeof request.priceFor !== "function" || typeof request.respond !== "function")
+      return;
+    try {
+      if (request.context.modelRegistry !== owner.modelRegistry || request.context.sessionManager.getSessionId() !== owner.sessionManager.getSessionId())
+        return;
+      request.handled = true;
+      const sessionId = owner.sessionManager.getSessionId();
+      const installed = installObserver(pi, { model: request.model, modelRegistry: owner.modelRegistry }, (model, _context, _options, scope) => {
+        const price = request.priceFor({ provider: model.provider, id: model.id });
+        return Object.assign((payload) => payload, { priceUsage: (message) => {
+          if (scope.sessionId === sessionId)
+            price(message.timestamp, message.usage);
+        } });
+      });
+      if (!installed) {
+        request.respond(undefined);
+        return;
+      }
+      const lease = {
+        provider: installed.provider,
+        api: installed.api,
+        isInstalled: () => installed.isInstalled(),
+        remove() {
+          leases.delete(lease);
+          installed.remove();
+        }
+      };
+      leases.add(lease);
+      request.respond(lease);
+    } catch {}
+  });
+  return {
+    ready(context) {
+      pi.events.emit(READY, { context });
+    },
+    clear() {
+      for (const lease of leases)
+        lease.remove();
+    },
+    dispose() {
+      remove();
+      for (const lease of leases)
+        lease.remove();
+    }
+  };
 }
 
 // index.ts
@@ -2136,9 +2262,10 @@ function pi_provider_compaction_default(pi) {
   const routeDigest = (value) => createHmac("sha256", secret).update(JSON.stringify(value)).digest("hex");
   let runtimeId = randomUUID2();
   let ctx;
+  let usageObservers = serveUsageObservers(pi, () => ctx);
   let snapshot;
   let cache;
-  let summarizing = false;
+  let compactionRequest = false;
   let expiryAttempt;
   let lastOutcome;
   let active;
@@ -2168,7 +2295,7 @@ Observer: ${observer?.isInstalled() ? "installed" : "unavailable for current reg
 Capture: ${captureStatus}
 Cache: ${state.reason}; ${remaining}
 Last attempt: ${compactionStatus}${lastOutcome ? `
-Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usage.input}, cache read ${usage.cacheRead}, write ${usage.cacheWrite}, output ${usage.output}; catalog cost $${usage.cost.total.toFixed(6)}` : "; usage unavailable"}${lastOutcome.reason ? `; ${lastOutcome.reason}` : ""}` : ""}`, "info");
+Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usage.input}, cache read ${usage.cacheRead}, write ${usage.cacheWrite}, output ${usage.output}; estimated cost $${usage.cost.total.toFixed(6)}` : "; usage unavailable"}${lastOutcome.reason ? `; ${lastOutcome.reason}` : ""}` : ""}`, "info");
     }
   });
   const invalidate = () => {
@@ -2182,6 +2309,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     captureStatus = "invalidated by lifecycle/history/policy change";
   };
   const retire = () => {
+    usageObservers.clear();
     invalidate();
     const installed = observer;
     observer = undefined;
@@ -2191,6 +2319,10 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     installed?.remove();
     lastOutcome = undefined;
   };
+  pi.on("before_provider_headers", (event, context) => {
+    bindUsageHeaders(event.headers, context.sessionManager.getSessionId());
+    usageObservers.ready(context);
+  });
   const generic = (context) => resolveCompactionModelPolicy(pi, context).hasSelectors;
   const route = (model, options) => routeDigest({ model, apiKey: options.apiKey, headers: options.headers, env: options.env });
   const unchanged = (branch, length, hash) => branch.length >= length && digest(branch.slice(0, length)) === hash && !branch.slice(length).some((entry) => entry.type === "context_edit");
@@ -2262,7 +2394,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     }
     if (options.sessionId !== manager.getSessionId())
       return;
-    if (summarizing)
+    if (compactionRequest)
       return;
     if (!supportsNativeCompaction(model) && !supportsCachedSummary(model)) {
       captureRejected("unsupported API");
@@ -2398,7 +2530,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
   };
   const install = (context) => {
     ctx = context;
-    if (observer?.provider === context.model?.provider && observer?.isInstalled())
+    if (observer?.provider === context.model?.provider && observer?.api === context.model?.api && observer?.isInstalled())
       return;
     if (observer) {
       invalidate();
@@ -2412,11 +2544,16 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
   };
   pi.on("session_start", (_event, context) => {
     retire();
+    usageObservers.dispose();
+    usageObservers = serveUsageObservers(pi, () => ctx);
     install(context);
+    usageObservers.ready(context);
     const sessionId = context.sessionManager.getSessionId();
     unregisterCleanup = registerSessionResourceCleanup((disposedId) => {
-      if (disposedId === undefined || disposedId === sessionId)
+      if (disposedId === undefined || disposedId === sessionId) {
         retire();
+        usageObservers.dispose();
+      }
     });
     const latest = latestCompaction(context.sessionManager.getBranch());
     if (latest?.summary === NATIVE_COMPACTION_SUMMARY)
@@ -2424,15 +2561,20 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
   });
   pi.on("before_agent_start", (_event, context) => {
     install(context);
+    usageObservers.ready(context);
   });
   pi.on("model_select", (_event, context) => {
     invalidate();
     install(context);
+    usageObservers.ready(context);
   });
   pi.on("session_tree", () => {
     invalidate();
   });
-  pi.on("session_shutdown", retire);
+  pi.on("session_shutdown", () => {
+    retire();
+    usageObservers.dispose();
+  });
   const removeInvalidation = pi.events.on("pi-provider-compaction:invalidate", invalidate);
   pi.on("session_shutdown", () => {
     if (typeof removeInvalidation === "function")
@@ -2489,7 +2631,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     let summaryReason;
     if (cached) {
       compactionStatus = "generating cached portable summary";
-      summarizing = true;
+      compactionRequest = true;
       try {
         const result = await cachedSummary(cached, context, event.preparation, event.customInstructions, event.signal, current);
         portable = result.result;
@@ -2498,7 +2640,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
         if (portable)
           summaryPath = "cached";
       } finally {
-        summarizing = false;
+        compactionRequest = false;
       }
       if (!current())
         return cancelled(attemptedUsage);
@@ -2539,27 +2681,35 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
         return outcome(summaryPath, portable, "native auth changed");
       }
       compactionStatus = "requesting native checkpoint";
-      const native = await requestProviderCompaction({
-        provider: capture.provider,
-        model: capture.model,
-        context: capture.prepared.context,
-        input,
-        preparedPayload: capture.prepared.payload,
-        protocol,
-        apiKey: capture.options.apiKey,
-        headers: capture.options.headers,
-        env: capture.options.env,
-        signal: event.signal,
-        isCurrent: current,
-        fetch: capture.options.fetch,
-        ...capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }
-      });
+      let native;
+      compactionRequest = true;
+      try {
+        native = await requestProviderCompaction({
+          provider: capture.provider,
+          model: capture.model,
+          context: capture.prepared.context,
+          input,
+          preparedPayload: capture.prepared.payload,
+          protocol,
+          apiKey: capture.options.apiKey,
+          headers: capture.options.headers,
+          env: capture.options.env,
+          signal: event.signal,
+          isCurrent: current,
+          fetch: capture.options.fetch,
+          sessionId: source.sessionId,
+          ...capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }
+        });
+      } finally {
+        compactionRequest = false;
+      }
       if (!current())
         return cancelled(combineUsage(native.usage, portable.usage));
       const finalAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
       if (!current())
         return cancelled(combineUsage(native.usage, portable.usage));
       if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) {
+        portable.usage = combineUsage(native.usage, portable.usage);
         fallback("auth changed after native generation");
         return outcome(summaryPath, portable, "native auth changed");
       }
@@ -2602,7 +2752,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
       fallback("another handler supplied the committed result");
     if (owned) {
       if (configuration().outcomeNotifications && lastOutcome)
-        context.ui.notify(`Compacted via ${lastOutcome.path} in ${(lastOutcome.elapsedMs / 1000).toFixed(1)}s${lastOutcome.usage ? `; cache read ${lastOutcome.usage.cacheRead}, write ${lastOutcome.usage.cacheWrite}; catalog cost $${lastOutcome.usage.cost.total.toFixed(6)}` : ""}`, "info");
+        context.ui.notify(`Compacted via ${lastOutcome.path} in ${(lastOutcome.elapsedMs / 1000).toFixed(1)}s${lastOutcome.usage ? `; cache read ${lastOutcome.usage.cacheRead}, write ${lastOutcome.usage.cacheWrite}; estimated cost $${lastOutcome.usage.cost.total.toFixed(6)}` : ""}`, "info");
     } else
       lastOutcome = { path: "Pi/other handler", elapsedMs: 0, usage: event.compactionEntry.usage, reason: compactionStatus };
     if (fallbackReason)

package/index.ts

@@ -4,7 +4,8 @@ import { normalizeContext, registerSessionResourceCleanup, type Model, type Prov
 import { compact, convertToLlm, type ExtensionAPI, type ExtensionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { resolveCompactionModelPolicy } from "./policy";
 import { cacheConfig, cachedSummary, captureCachedRequest, finishCachedRequest, requestCacheState, sameCachedPrompt, supportsCachedSummary, withFileTracking, type CachedRequest } from "./cached-summary";
-import { installObserver, type InstalledObserver, type ObserveRequest } from "./provider";
+import { bindUsageHeaders, installObserver, type InstalledObserver, type ObserveRequest } from "./provider";
+import { serveUsageObservers } from "./usage-observer";
 import { capturePreparedRequest, equal, requestPolicy, selectCoveredPrefix, substituteSummary, summarySlot, type PreparedRequest } from "./replay";
 import { isObject, NativeCompactionValidationError, requestProviderCompaction, resolveNativeProtocol, supportsResponsesApi, validateCompactedOutput, type NativeProtocol, type ResponseItem } from "./protocol";
 
@@ -161,9 +162,10 @@ export default function (pi: ExtensionAPI): void {
 	const routeDigest = (value: unknown) => createHmac("sha256", secret).update(JSON.stringify(value)).digest("hex");
 	let runtimeId = randomUUID();
 	let ctx: ExtensionContext | undefined;
+	let usageObservers = serveUsageObservers(pi, () => ctx);
 	let snapshot: Captured | undefined;
 	let cache: CachedRequest | undefined;
-	let summarizing = false;
+	let compactionRequest = false;
 	let expiryAttempt: ExpiryAttempt | undefined;
 	let lastOutcome: { path: string; elapsedMs: number; usage?: Usage; reason?: string } | undefined;
 	let active: Active | undefined;
@@ -183,11 +185,12 @@ export default function (pi: ExtensionAPI): void {
 			const state = cacheState(context);
 			const remaining = state.expiresAt === undefined ? "unknown lifetime" : `estimated ${Math.max(0, Math.ceil((state.expiresAt - Date.now()) / 1000))}s remaining (model declaration; best effort)`;
 			const usage = lastOutcome?.usage;
-			context.ui.notify(`Provider compaction\nObserver: ${observer?.isInstalled() ? "installed" : "unavailable for current registration"}\nCapture: ${captureStatus}\nCache: ${state.reason}; ${remaining}\nLast attempt: ${compactionStatus}${lastOutcome ? `\nOutcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usage.input}, cache read ${usage.cacheRead}, write ${usage.cacheWrite}, output ${usage.output}; catalog cost $${usage.cost.total.toFixed(6)}` : "; usage unavailable"}${lastOutcome.reason ? `; ${lastOutcome.reason}` : ""}` : ""}`, "info");
+			context.ui.notify(`Provider compaction\nObserver: ${observer?.isInstalled() ? "installed" : "unavailable for current registration"}\nCapture: ${captureStatus}\nCache: ${state.reason}; ${remaining}\nLast attempt: ${compactionStatus}${lastOutcome ? `\nOutcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usage.input}, cache read ${usage.cacheRead}, write ${usage.cacheWrite}, output ${usage.output}; estimated cost $${usage.cost.total.toFixed(6)}` : "; usage unavailable"}${lastOutcome.reason ? `; ${lastOutcome.reason}` : ""}` : ""}`, "info");
 		},
 	});
 	const invalidate = () => { generation++; runtimeId = randomUUID(); snapshot = undefined; cache = undefined; active = undefined; pending = undefined; expiryAttempt = undefined; captureStatus = "invalidated by lifecycle/history/policy change"; };
 	const retire = () => {
+		usageObservers.clear();
 		invalidate();
 		const installed = observer;
 		observer = undefined; ctx = undefined;
@@ -195,6 +198,12 @@ export default function (pi: ExtensionAPI): void {
 		installed?.remove();
 		lastOutcome = undefined;
 	};
+	pi.on("before_provider_headers", (event, context) => {
+		bindUsageHeaders(event.headers, context.sessionManager.getSessionId());
+		// Lazy API loading or catalog refresh can recompose effective providers
+		// between auxiliary calls that have no before_agent_start boundary.
+		usageObservers.ready(context);
+	});
 	const generic = (context: ExtensionContext) => resolveCompactionModelPolicy(pi, context).hasSelectors;
 	const route = (model: Model<any>, options: ProviderStreamOptions | SimpleStreamOptions) => routeDigest({ model, apiKey: options.apiKey, headers: options.headers, env: options.env });
 	const unchanged = (branch: readonly SessionEntry[], length: number, hash: string) => branch.length >= length && digest(branch.slice(0, length)) === hash && !branch.slice(length).some((entry) => entry.type === "context_edit");
@@ -250,7 +259,7 @@ export default function (pi: ExtensionAPI): void {
 			return;
 		}
 		if (options.sessionId !== manager.getSessionId()) return;
-		if (summarizing) return;
+		if (compactionRequest) return;
 		if (!supportsNativeCompaction(model) && !supportsCachedSummary(model)) { captureRejected("unsupported API"); return; }
 		if (!options.onPayload) {
 			// The portable-summary request re-enters this observer without a payload
@@ -346,27 +355,31 @@ export default function (pi: ExtensionAPI): void {
 
 	const install = (context: ExtensionContext) => {
 		ctx = context;
-		if (observer?.provider === context.model?.provider && observer?.isInstalled()) return;
+		if (observer?.provider === context.model?.provider && observer?.api === context.model?.api && observer?.isInstalled()) return;
 		if (observer) { invalidate(); observer.remove(); observer = undefined; }
 		if (!supportsNativeCompaction(context.model) && !supportsCachedSummary(context.model)) return;
 		observer = installObserver(pi, context, observe);
 		captureStatus = observer ? "awaiting prepared request" : "unsupported provider registration";
 	};
 	pi.on("session_start", (_event, context) => {
-		retire(); install(context);
+		retire();
+		usageObservers.dispose();
+		usageObservers = serveUsageObservers(pi, () => ctx);
+		install(context);
+		usageObservers.ready(context);
 		const sessionId = context.sessionManager.getSessionId();
 		// AgentSession.dispose() cleans session resources even without emitting
 		// session_shutdown. The captured registry keeps owned cleanup usable.
 		unregisterCleanup = registerSessionResourceCleanup((disposedId) => {
-			if (disposedId === undefined || disposedId === sessionId) retire();
+			if (disposedId === undefined || disposedId === sessionId) { retire(); usageObservers.dispose(); }
 		});
 		const latest = latestCompaction(context.sessionManager.getBranch());
 		if (latest?.summary === NATIVE_COMPACTION_SUMMARY) context.ui.notify("Legacy native compaction has no portable summary. Native replay is disabled; recover from earlier history or start a new session.", "warning");
 	});
-	pi.on("before_agent_start", (_event, context) => { install(context); });
-	pi.on("model_select", (_event, context) => { invalidate(); install(context); });
+	pi.on("before_agent_start", (_event, context) => { install(context); usageObservers.ready(context); });
+	pi.on("model_select", (_event, context) => { invalidate(); install(context); usageObservers.ready(context); });
 	pi.on("session_tree", () => { invalidate(); });
-	pi.on("session_shutdown", retire);
+	pi.on("session_shutdown", () => { retire(); usageObservers.dispose(); });
 	// Privacy-policy owners must invalidate before changing a policy that can affect
 	// hidden covered history. Arbitrary dynamic privacy compositions are unsupported.
 	const removeInvalidation = pi.events.on("pi-provider-compaction:invalidate", invalidate);
@@ -419,14 +432,14 @@ export default function (pi: ExtensionAPI): void {
 		let summaryReason: string | undefined;
 		if (cached) {
 			compactionStatus = "generating cached portable summary";
-			summarizing = true;
+			compactionRequest = true;
 			try {
 				const result = await cachedSummary(cached, context, event.preparation, event.customInstructions, event.signal, current);
 				portable = result.result;
 				attemptedUsage = result.usage;
 				summaryReason = result.reason;
 				if (portable) summaryPath = "cached";
-			} finally { summarizing = false; }
+			} finally { compactionRequest = false; }
 			if (!current()) return cancelled(attemptedUsage);
 		}
 		if (!portable) {
@@ -458,17 +471,27 @@ export default function (pi: ExtensionAPI): void {
 			if (!current()) return cancelled(portable.usage);
 			if (!freshAuth.ok || routeDigest(freshAuth) !== capture.authHash) { fallback("auth changed after portable generation"); return outcome(summaryPath, portable, "native auth changed"); }
 			compactionStatus = "requesting native checkpoint";
-			const native = await requestProviderCompaction({
-				provider: capture.provider, model: capture.model, context: capture.prepared.context,
-				input, preparedPayload: capture.prepared.payload, protocol,
-				apiKey: capture.options.apiKey, headers: capture.options.headers, env: capture.options.env,
-				signal: event.signal, isCurrent: current, fetch: capture.options.fetch,
-				...(capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }),
-			});
+			let native: Awaited<ReturnType<typeof requestProviderCompaction>>;
+			compactionRequest = true;
+			try {
+				native = await requestProviderCompaction({
+					provider: capture.provider, model: capture.model, context: capture.prepared.context,
+					input, preparedPayload: capture.prepared.payload, protocol,
+					apiKey: capture.options.apiKey, headers: capture.options.headers, env: capture.options.env,
+					signal: event.signal, isCurrent: current, fetch: capture.options.fetch, sessionId: source.sessionId,
+					...(capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }),
+				});
+			} finally { compactionRequest = false; }
 			if (!current()) return cancelled(combineUsage(native.usage, portable.usage));
 			const finalAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
 			if (!current()) return cancelled(combineUsage(native.usage, portable.usage));
-			if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) { fallback("auth changed after native generation"); return outcome(summaryPath, portable, "native auth changed"); }
+			if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) {
+				// The checkpoint is no longer safe to commit, but both requests
+				// completed and their known usage still belongs in the session.
+				portable.usage = combineUsage(native.usage, portable.usage);
+				fallback("auth changed after native generation");
+				return outcome(summaryPath, portable, "native auth changed");
+			}
 			const details: NativeCompactionDetails = {
 				...(isObject(portable.details) ? portable.details : {}),
 				type: NATIVE_COMPACTION_TYPE, version: 3, provider: capture.model.provider, api: capture.model.api, model: capture.model.id,
@@ -494,7 +517,7 @@ export default function (pi: ExtensionAPI): void {
 		else if (owned) compactionStatus = `${lastOutcome!.path} portable summary committed`;
 		else fallback("another handler supplied the committed result");
 		if (owned) {
-			if (configuration().outcomeNotifications && lastOutcome) context.ui.notify(`Compacted via ${lastOutcome.path} in ${(lastOutcome.elapsedMs / 1000).toFixed(1)}s${lastOutcome.usage ? `; cache read ${lastOutcome.usage.cacheRead}, write ${lastOutcome.usage.cacheWrite}; catalog cost $${lastOutcome.usage.cost.total.toFixed(6)}` : ""}`, "info");
+			if (configuration().outcomeNotifications && lastOutcome) context.ui.notify(`Compacted via ${lastOutcome.path} in ${(lastOutcome.elapsedMs / 1000).toFixed(1)}s${lastOutcome.usage ? `; cache read ${lastOutcome.usage.cacheRead}, write ${lastOutcome.usage.cacheWrite}; estimated cost $${lastOutcome.usage.cost.total.toFixed(6)}` : ""}`, "info");
 		} else lastOutcome = { path: "Pi/other handler", elapsedMs: 0, usage: event.compactionEntry.usage, reason: compactionStatus };
 		// Only static diagnostics are persisted, never request/auth data or error text.
 		if (fallbackReason) pi.appendEntry("pi-provider-compaction:diagnostic", { status: `portable: ${fallbackReason}` });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-provider-compaction",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "type": "module",
   "description": "Provider-native context compaction adapters for Pi",
   "keywords": [
@@ -29,7 +29,7 @@
     "build": "bun run build.ts",
     "prepack": "bun run build",
     "test": "bun test",
-    "lint": "oxlint build.ts index.ts protocol.ts policy.ts provider.ts replay.ts cached-summary.ts tests/",
+    "lint": "oxlint build.ts index.ts protocol.ts policy.ts provider.ts usage-observer.ts replay.ts cached-summary.ts tests/",
     "typecheck": "tsc --noEmit",
     "check": "bun run build && bun test && bun run lint && tsc --noEmit"
   },
@@ -39,6 +39,7 @@
     "protocol.ts",
     "policy.ts",
     "provider.ts",
+    "usage-observer.ts",
     "replay.ts",
     "cached-summary.ts",
     "README.md",

package/policy.ts

@@ -20,7 +20,6 @@ export const COMPACTION_MODEL_FLAG = "compaction-model";
 const PROJECT_POLICY = "compaction-policy.json";
 const AGENT_DIR_OVERRIDE = "PI_COMPACTOR_AGENT_DIR";
 const MAX_POLICY_BYTES = 64 * 1024;
-const MAX_MODEL_SELECTORS = 8;
 const MAX_SELECTOR_LENGTH = 512;
 
 type PolicyContext = Pick<ExtensionContext, "cwd" | "isProjectTrusted"> & {
@@ -43,21 +42,15 @@ function normalizeSelector(value: unknown): string | undefined {
 	return selector;
 }
 
-function parsePolicySelectors(value: unknown): string[] | undefined {
+function policyHasSelectors(value: unknown): boolean | undefined {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
 	if (!("models" in value) || !Array.isArray(value.models)) return undefined;
-
-	const selectors: string[] = [];
-	for (const model of value.models) {
-		const selector = normalizeSelector(model);
-		if (selector === undefined || selectors.includes(selector)) continue;
-		selectors.push(selector);
-		if (selectors.length === MAX_MODEL_SELECTORS) break;
-	}
-	return selectors;
+	// This extension only decides precedence. The companion owns the actual
+	// selector list, including deduplication and its model-attempt limit.
+	return value.models.some(model => normalizeSelector(model) !== undefined);
 }
 
-function readPolicySelectors(configPath: string): string[] | undefined {
+function readPolicySelection(configPath: string): boolean | undefined {
 	let fd: number | undefined;
 	try {
 		fd = openSync(configPath, fsConstants.O_RDONLY | fsConstants.O_NONBLOCK);
@@ -74,7 +67,7 @@ function readPolicySelectors(configPath: string): string[] | undefined {
 			bytesRead += count;
 		}
 		if (bytesRead > MAX_POLICY_BYTES) return undefined;
-		return parsePolicySelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")) as unknown);
+		return policyHasSelectors(JSON.parse(buffer.subarray(0, bytesRead).toString("utf8")) as unknown);
 	} catch {
 		// A malformed or unreadable policy must not prevent native compaction.
 		return undefined;
@@ -177,11 +170,11 @@ export function resolveCompactionModelPolicy(
 	candidates.push({ path: join(agentDir, PROJECT_POLICY), source: "agent-policy" });
 
 	for (const candidate of candidates) {
-		const selectors = readPolicySelectors(candidate.path);
+		const hasSelectors = readPolicySelection(candidate.path);
 		// A readable policy stops the search: an empty models list is an
 		// explicit choice to use no generic compaction model.
-		if (selectors !== undefined) {
-			return selectors.length > 0 ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
+		if (hasSelectors !== undefined) {
+			return hasSelectors ? { hasSelectors: true, source: candidate.source } : { hasSelectors: false };
 		}
 	}
 	return { hasSelectors: false };

package/protocol.ts

@@ -208,7 +208,7 @@ async function collectProviderUsage(stream: AssistantMessageEventStream, signal:
 	let usage: Usage | undefined;
 	for await (const event of stream) {
 		if (signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
-		if (event.type === "error") throw new Error(event.error.errorMessage ?? "Native compaction provider request failed");
+		if (event.type === "error") throw new NativeCompactionValidationError("Native compaction provider stream failed", event.error.usage);
 		if (event.type === "done") usage = event.message.usage;
 	}
 	if (!usage) throw new Error("Native compaction provider stream ended without usage");
@@ -227,6 +227,7 @@ interface TransportRequest {
 	env?: Record<string, string>;
 	/** Cost-relevant request option captured with the original request. */
 	serviceTier?: string;
+	sessionId?: string;
 	signal: AbortSignal;
 	/** Revalidate request ownership after asynchronous provider preparation. */
 	isCurrent?: () => boolean;
@@ -252,7 +253,7 @@ export interface TransportResponse {
 
 async function requestResponsesCompact(request: TransportRequest): Promise<TransportResponse> {
 	let preparedPayload: JsonObject | undefined;
-	let compacted: { response: JsonObject; output: ResponseItem[] } | undefined;
+	let compacted: ResponseItem[] | undefined;
 	let bridgeError: unknown;
 	let dispatches = 0;
 	const baseFetch = request.fetch ?? globalThis.fetch;
@@ -274,13 +275,13 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 			});
 			if (!response.ok) return response;
 			const parsed = await readJsonBounded(response, request.signal);
-			try {
-				if (!isObject(parsed)) throw new Error("Responses Compact returned a non-object response");
-				compacted = { response: parsed, output: validateCompactedOutput(parsed) };
-			} catch (error) {
-				throw new NativeCompactionValidationError(error instanceof Error ? error.message : String(error));
-			}
-			return syntheticCompletion(parsed, preparedPayload);
+			if (!isObject(parsed)) throw new Error("Responses Compact returned a non-object response");
+			// Let the SDK normalize and price reported usage even when the returned
+			// checkpoint is invalid. A synthetic HTTP error would discard that bill.
+			const completion = syntheticCompletion(parsed, preparedPayload);
+			try { compacted = validateCompactedOutput(parsed); }
+			catch (error) { bridgeError = new NativeCompactionValidationError(error instanceof Error ? error.message : String(error)); }
+			return completion;
 		} catch (error) {
 			bridgeError = error;
 			return errorResponse(error);
@@ -296,6 +297,7 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 		transport: "sse",
 		cacheRetention: "none",
 		maxRetries: 0,
+		sessionId: request.sessionId,
 		fetch: bridgeFetch,
 		onPayload: (payload: unknown) => {
 			assertCurrent(request);
@@ -307,13 +309,13 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 	});
 
 	const usage = await collectProviderUsage(stream, request.signal).catch((error) => {
-		if (bridgeError) throw bridgeError;
+		if (bridgeError) throw new NativeCompactionValidationError("Native compaction transport or validation failed", error instanceof NativeCompactionValidationError ? error.usage : undefined);
 		throw error;
 	});
 	if (bridgeError instanceof NativeCompactionValidationError) throw new NativeCompactionValidationError(bridgeError.message, usage);
 	if (bridgeError) throw bridgeError;
 	if (!compacted || dispatches !== 1) throw new Error("Responses Compact did not complete exactly one request");
-	return { output: compacted.output, usage };
+	return { output: compacted, usage };
 }
 
 interface CollectedSse {
@@ -438,6 +440,7 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 		transport: "sse",
 		cacheRetention: "none",
 		maxRetries: 0,
+		sessionId: request.sessionId,
 		fetch: inspectedFetch,
 		onPayload: (payload: unknown) => {
 			assertCurrent(request);
@@ -449,9 +452,9 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 	});
 	try {
 		const usage = await collectProviderUsage(stream, request.signal);
-		if (!sentInput || inspections.length !== 1) throw new Error(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`);
+		if (!sentInput || inspections.length !== 1) throw new NativeCompactionValidationError(`Remote V2 observed ${inspections.length} successful provider responses; expected exactly one`, usage);
 		const inspection = await inspections[0]!;
-		if ("error" in inspection) throw inspection.error;
+		if ("error" in inspection) throw new NativeCompactionValidationError("Remote V2 checkpoint validation failed", usage);
 		return { output: buildRemoteV2History(sentInput, inspection.result.item), usage };
 	} finally {
 		controller.abort();

package/provider.ts

@@ -1,14 +1,27 @@
-import type { AssistantMessage, AssistantMessageEventStream, CacheRetention, Provider, StreamOptions, Model, TranscriptContext } from "@earendil-works/pi-ai";
+import { createAssistantMessageEventStream, type AssistantMessage, type AssistantMessageEventStream, type CacheRetention, type Provider, type StreamOptions, type Model, type TranscriptContext } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+interface UsageScope { sessionId?: string; }
+const USAGE_OWNERS = Symbol.for("@nijaru/pi-provider-compaction/usage-owners");
+const usageGlobal = globalThis as typeof globalThis & { [USAGE_OWNERS]?: WeakMap<object, string> };
+const usageOwners = usageGlobal[USAGE_OWNERS] ??= new WeakMap<object, string>();
+
+/** Associate the SDK-owned header record without reading or changing any headers. */
+export function bindUsageHeaders(headers: object, sessionId: string): void {
+	usageOwners.set(headers, sessionId);
+}
 
 export type PayloadObserver = ((payload: unknown) => unknown | Promise<unknown>) & {
 	complete?: (message: AssistantMessage) => void;
+	/** Adjust only usage before any completion observer or consumer sees it. */
+	priceUsage?: (message: AssistantMessage) => void;
 	cacheRetention?: CacheRetention;
 };
-export type ObserveRequest = (model: Model<any>, context: TranscriptContext, options: StreamOptions) => PayloadObserver | undefined;
+export type ObserveRequest = (model: Model<any>, context: TranscriptContext, options: StreamOptions, scope: UsageScope) => PayloadObserver | undefined;
 
 export interface InstalledObserver {
 	provider: string;
+	/** installObserver leases one dispatch API; lower-level leases can be unscoped. */
+	api?: string;
 	isInstalled(): boolean;
 	remove(): void;
 }
@@ -18,11 +31,13 @@ export interface InstalledObserver {
 export const STREAM_OBSERVER = Symbol.for("@nijaru/pi-provider-compaction/stream-observer");
 
 function observedStream<T extends StreamOptions>(model: Model<any>, context: TranscriptContext, options: T | undefined, observe: ObserveRequest, dispatch: (options: T | undefined) => AssistantMessageEventStream): AssistantMessageEventStream {
+	const headerOwner = options?.headers ? usageOwners.get(options.headers) : undefined;
+	const scope: UsageScope = { sessionId: headerOwner ?? options?.sessionId };
 	let handler: ReturnType<ObserveRequest>;
-	try { handler = observe(model, context, options ?? {}); }
+	try { handler = observe(model, context, options ?? {}, scope); }
 	catch { return dispatch(options); } // An expired optional observer must not veto dispatch.
 	if (!handler) return dispatch(options);
-	const stream = dispatch({
+	const run = () => dispatch({
 		...options,
 		...(handler.cacheRetention === undefined ? {} : { cacheRetention: handler.cacheRetention }),
 		onPayload: async (payload: unknown, requestModel: Model<any>) => {
@@ -32,16 +47,52 @@ function observedStream<T extends StreamOptions>(model: Model<any>, context: Tra
 			try { return await handler(prepared); } catch { return prepared; }
 		},
 	} as T);
-	// result() observes completion without consuming the public event iterator.
+	const stream = run();
+	if (handler.priceUsage) return pricedStream(stream, model, handler);
+	// Pure capture remains transparent, including the original stream identity.
 	if (handler.complete) void stream.result().then(handler.complete).catch(() => {});
 	return stream;
 }
 
+/** Pricing must precede both terminal-event delivery and result() resolution. */
+function pricedStream(stream: AssistantMessageEventStream, model: Model<any>, handler: PayloadObserver): AssistantMessageEventStream {
+	const out = createAssistantMessageEventStream();
+	void (async () => {
+		let final: AssistantMessage | undefined;
+		let partial: AssistantMessage | undefined;
+		try {
+			for await (const event of stream) {
+				if ("partial" in event) partial = event.partial;
+				if (event.type === "done" || event.type === "error") {
+					final = event.type === "done" ? event.message : event.error;
+					try { handler.priceUsage?.(final); } catch { /* Optional estimates never veto completion. */ }
+					try { handler.complete?.(final); } catch { /* Capture failure never vetoes completion. */ }
+				}
+				out.push(event);
+			}
+			if (final) { out.end(final); return; }
+		} catch { /* Malformed plugin streams still need a terminal outcome. */ }
+		const message: AssistantMessage = {
+			...(partial ?? {
+				role: "assistant", api: model.api, provider: model.provider, model: model.id,
+				content: [], timestamp: Date.now(),
+				usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
+			}),
+			stopReason: "error", errorMessage: "Provider stream ended before a terminal event",
+		};
+		try { handler.priceUsage?.(message); } catch { /* Preserve the known usage on pricing failure. */ }
+		out.push({ type: "error", reason: "error", error: message });
+		out.end(message);
+	})();
+	return out;
+}
+
 /** One dispatch layer, with session-local selection and no released lease history. */
 function observerLeases(provider: string, owned: () => boolean, restore: () => void) {
 	const leases = new Map<symbol, { observe: ObserveRequest; current: () => boolean }>();
 	let closed = false;
-	const active = (token: symbol) => !closed && leases.get(token)?.current() === true && owned();
+	const live = (token: symbol) => !closed && leases.has(token);
+	const active = (token: symbol) => live(token) && leases.get(token)?.current() === true && owned();
 	const release = () => {
 		if (closed) return;
 		closed = true;
@@ -57,6 +108,10 @@ function observerLeases(provider: string, owned: () => boolean, restore: () => v
 				if (!handler) continue;
 				handlers.push(Object.assign((payload: unknown) => active(token) ? handler(payload) : payload, {
 					cacheRetention: handler.cacheRetention,
+					// A catalog/API recomposition may detach a provider after dispatch.
+					// Its in-flight bill still uses the sampled policy; explicit lease
+					// removal/disposal, unlike recomposition, revokes that callback.
+					priceUsage: handler.priceUsage ? (message: AssistantMessage) => { if (live(token)) handler.priceUsage!(message); } : undefined,
 					complete: handler.complete ? (message: AssistantMessage) => { if (active(token)) handler.complete!(message); } : undefined,
 				}));
 			} catch { /* A failed optional observer must not disable the other sessions. */ }
@@ -72,6 +127,11 @@ function observerLeases(provider: string, owned: () => boolean, restore: () => v
 			return payload;
 		}, {
 			cacheRetention: [...handlers].reverse().find((handler) => handler.cacheRetention !== undefined)?.cacheRetention,
+			priceUsage: handlers.some((handler) => handler.priceUsage) ? (message: AssistantMessage) => {
+				for (const handler of handlers) {
+					try { handler.priceUsage?.(message); } catch { /* Isolate independent pricing owners. */ }
+				}
+			} : undefined,
 			complete: handlers.some((handler) => handler.complete) ? (message: AssistantMessage) => {
 				for (const handler of handlers) {
 					try { handler.complete?.(message); } catch { /* Isolate optional completion observers too. */ }
@@ -95,7 +155,7 @@ function observerLeases(provider: string, owned: () => boolean, restore: () => v
 type ObserverLeases = ReturnType<typeof observerLeases>;
 // Pi's uncached module loader can instantiate this extension separately for
 // sessions sharing one model runtime. Weak ownership must span those instances.
-const LEASE_TABLES = Symbol.for("@nijaru/pi-provider-compaction/observer-leases-v1");
+const LEASE_TABLES = Symbol.for("@nijaru/pi-provider-compaction/observer-leases-v2");
 interface LeaseTables {
 	effectiveLeases: WeakMap<Provider, { owned(): boolean; leases: ObserverLeases }>;
 	effectiveRestores: WeakMap<Function, { base: Provider; restore(): void }>;
@@ -168,20 +228,27 @@ export function leaseEffectiveProvider(base: Provider | undefined, current: () =
 	* delegate their original callback (including /fast). Never register an effective
 	* composed provider as a native base: that loses model headers and freezes config.
 	*/
-export function installObserver(pi: ExtensionAPI, ctx: ExtensionContext, observe: ObserveRequest): InstalledObserver | undefined {
+export function installObserver(pi: ExtensionAPI, ctx: Pick<ExtensionContext, "model" | "modelRegistry">, observe: ObserveRequest): InstalledObserver | undefined {
 	const model = ctx.model;
 	if (!model) return;
 	const registry = ctx.modelRegistry;
 	const id = model.provider;
+	const observeApi: ObserveRequest = (requestModel, ...args) => requestModel.api === model.api ? observe(requestModel, ...args) : undefined;
+	const tagged = (lease: InstalledObserver | undefined) => lease ? Object.assign(lease, { api: model.api }) : undefined;
+	const effective = () => {
+		const base = registry.getProvider(id);
+		if (!base?.getModels().some((entry) => entry.api === model.api)) return;
+		return tagged(leaseEffectiveProvider(base, () => registry.getProvider(id), observeApi));
+	};
 	const native = registry.getRegisteredNativeProvider(id);
 	if (native) {
 		// Pi composes a native base only when its catalog serves the active API.
 		// Otherwise the request goes to the global API provider and bypasses this
 		// wrapper; claiming an observer there would report native compaction as
 		// installed while never capturing anything.
-		if (typeof native.getModels !== "function" || !native.getModels().some((entry) => entry.api === model.api)) return;
+		if (typeof native.getModels !== "function" || !native.getModels().some((entry) => entry.api === model.api)) return effective();
 		const existing = nativeLeases.get(native);
-		if (existing) return existing.add(observe);
+		if (existing) return tagged(existing.add(observeApi));
 		const leases = observerLeases(id, () => registry.getRegisteredNativeProvider(id) === wrapper, () => {
 			// Keep cleanup usable after bare SDK disposal invalidates the extension API.
 			if (registry.getRegisteredNativeProvider(id) === wrapper) registry.registerProvider(native);
@@ -190,7 +257,7 @@ export function installObserver(pi: ExtensionAPI, ctx: ExtensionContext, observe
 		const wrapper = decorateProvider(native, leases.observe);
 		nativeLeases.set(wrapper, leases);
 		pi.registerProvider(wrapper);
-		return leases.add(observe);
+		return tagged(leases.add(observeApi));
 	}
 	const original = registry.getRegisteredProviderConfig(id);
 	// Refresh callbacks own mutable catalog state inside the composer. Replacing
@@ -198,12 +265,12 @@ export function installObserver(pi: ExtensionAPI, ctx: ExtensionContext, observe
 	if (!original?.streamSimple || original.refreshModels || original.oauth?.modifyModels || original.api !== model.api) {
 		// Lease the effective object's methods, NOT its registry slot. Re-registering
 		// a composed provider freezes catalogs and loses overlay/header semantics.
-		return leaseEffectiveProvider(registry.getProvider(id), () => registry.getProvider(id), observe);
+		return effective();
 	}
 	// An injected legacy streamSimple overlay would also intercept full stream()
 	// calls and change reasoning semantics. Only decorate an existing stream owner.
 	const existing = legacyLeases.get(original.streamSimple);
-	if (existing) return existing.add(observe);
+	if (existing) return tagged(existing.add(observeApi));
 	const delegate = original.streamSimple.bind(original);
 	const owned = () => registry.getRegisteredProviderConfig(id)?.streamSimple === wrapper && !registry.getRegisteredNativeProvider(id);
 	const leases = observerLeases(id, owned, () => {
@@ -219,5 +286,5 @@ export function installObserver(pi: ExtensionAPI, ctx: ExtensionContext, observe
 	Object.defineProperty(wrapper, STREAM_OBSERVER, { value: { delegate: original.streamSimple, release: leases.release } });
 	legacyLeases.set(wrapper, leases);
 	pi.registerProvider(id, { ...original, streamSimple: wrapper });
-	return leases.add(observe);
+	return tagged(leases.add(observeApi));
 }

package/usage-observer.ts

@@ -0,0 +1,52 @@
+import type { Usage } from "@earendil-works/pi-ai";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { installObserver, type InstalledObserver } from "./provider";
+
+const REQUEST = "pi-provider-compaction:observe-usage";
+const READY = "pi-provider-compaction:usage-observer-ready";
+type ModelKey = { provider: string; id: string };
+type PriceUsage = (timestamp: number, usage: Usage) => void;
+interface UsageRequest {
+	context: ExtensionContext;
+	model: NonNullable<ExtensionContext["model"]>;
+	priceFor(model: ModelKey): PriceUsage;
+	respond(observer: InstalledObserver | undefined): void;
+	handled?: boolean;
+}
+
+/** Share the existing stream owner, rather than stacking competing pricing wrappers. */
+export function serveUsageObservers(pi: ExtensionAPI, current: () => ExtensionContext | undefined) {
+	const leases = new Set<InstalledObserver>();
+	const remove = pi.events.on(REQUEST, (value) => {
+		const request = value as Partial<UsageRequest> | undefined;
+		const owner = current();
+		if (!owner || !request || request.handled || !request.context || !request.model || typeof request.priceFor !== "function" || typeof request.respond !== "function") return;
+		try {
+			if (request.context.modelRegistry !== owner.modelRegistry || request.context.sessionManager.getSessionId() !== owner.sessionManager.getSessionId()) return;
+			request.handled = true;
+			const sessionId = owner.sessionManager.getSessionId();
+			const installed = installObserver(pi, { model: request.model, modelRegistry: owner.modelRegistry }, (model, _context, _options, scope) => {
+				// The SDK header event identifies the owner even when a branch
+				// summary has an independent routing id. Sample policy at dispatch.
+				const price = request.priceFor!({ provider: model.provider, id: model.id });
+				return Object.assign((payload: unknown) => payload, { priceUsage: (message: { timestamp: number; usage: Usage }) => {
+					if (scope.sessionId === sessionId) price(message.timestamp, message.usage);
+				} });
+			});
+			if (!installed) { request.respond(undefined); return; }
+			const lease: InstalledObserver = {
+				provider: installed.provider,
+				api: installed.api,
+				isInstalled: () => installed.isInstalled(),
+				remove() { leases.delete(lease); installed.remove(); },
+			};
+			leases.add(lease);
+			request.respond(lease);
+		} catch { /* Optional cost estimates must not veto a provider request. */ }
+	});
+	return {
+		ready(context: ExtensionContext) { pi.events.emit(READY, { context }); },
+		clear() { for (const lease of leases) lease.remove(); },
+		dispose() { remove(); for (const lease of leases) lease.remove(); },
+	};
+}