@nijaru/pi-provider-compaction 0.0.9 → 0.0.11

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;
@@ -2147,30 +2274,10 @@ function pi_provider_compaction_default(pi) {
   let unregisterCleanup;
   let generation = 0;
   let requestSequence = 0;
-  let captureStatus = "no request observed";
-  let compactionStatus = "not attempted in this runtime";
   let fallbackReason;
-  const captureRejected = (reason) => {
-    captureStatus = reason;
-  };
   const fallback = (reason) => {
     fallbackReason = reason;
-    compactionStatus = `portable: ${reason}`;
   };
-  pi.registerCommand("provider-compaction-status", {
-    description: "Show cache/native eligibility and measured compaction usage",
-    handler: async (_args, context) => {
-      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
-Observer: ${observer?.isInstalled() ? "installed" : "unavailable for current registration"}
-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");
-    }
-  });
   const invalidate = () => {
     generation++;
     runtimeId = randomUUID2();
@@ -2179,9 +2286,9 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     active = undefined;
     pending = undefined;
     expiryAttempt = undefined;
-    captureStatus = "invalidated by lifecycle/history/policy change";
   };
   const retire = () => {
+    usageObservers.clear();
     invalidate();
     const installed = observer;
     observer = undefined;
@@ -2191,6 +2298,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,25 +2373,14 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     }
     if (options.sessionId !== manager.getSessionId())
       return;
-    if (summarizing)
-      return;
-    if (!supportsNativeCompaction(model) && !supportsCachedSummary(model)) {
-      captureRejected("unsupported API");
+    if (compactionRequest)
       return;
-    }
-    if (!options.onPayload) {
-      if (captureStatus !== "eligible prepared request captured")
-        captureRejected("no payload callback");
+    if (!supportsNativeCompaction(model) && !supportsCachedSummary(model))
       return;
-    }
-    if (generic(owner)) {
-      captureRejected("generic compaction model takes precedence");
+    if (!options.onPayload || generic(owner))
       return;
-    }
-    if (!supportedRouteOptions(model, options)) {
-      captureRejected("unsupported route overrides");
+    if (!supportedRouteOptions(model, options))
       return;
-    }
     const ticket = generation;
     const startedAt = Date.now();
     const sequence = ++requestSequence;
@@ -2311,14 +2411,11 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
       if (!auth.ok || generic(owner) || auth.apiKey !== options.apiKey || (auth.baseUrl ?? model.baseUrl) !== model.baseUrl || !equal(normalizedHeaders(auth.headers), normalizedHeaders(options.headers)) || !equal(auth.env ?? {}, options.env ?? {})) {
         active = undefined;
         cache = undefined;
-        captureRejected("resolved auth/route differs from prepared request, or generic policy changed");
         return payload;
       }
       const provider = owner.modelRegistry.getProvider(model.provider);
-      if (!provider) {
-        captureRejected("provider unavailable");
+      if (!provider)
         return payload;
-      }
       const routeHash = route(model, options);
       if (config.cachedSummaries && supportsCachedSummary(model)) {
         const warming = options.maxTokens === 1 && cache && cache.authHash === routeDigest(auth) && sameCachedPrompt(cache.payload, payload) && equal(cache.context, context);
@@ -2337,11 +2434,9 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
         if (!warming)
           cache = undefined;
       }
-      if (!supportsNativeCompaction(model)) {
-        captureStatus = candidate ? "eligible cached request captured" : "cached request ineligible";
+      if (!supportsNativeCompaction(model))
         return payload;
-      }
-      const prepared = capturePreparedRequest(model, context, canonical, payload, captureRejected);
+      const prepared = capturePreparedRequest(model, context, canonical, payload);
       if (!prepared) {
         active = undefined;
         return payload;
@@ -2370,7 +2465,6 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
           active = undefined;
       } else
         active = undefined;
-      captureStatus = "eligible prepared request captured";
       snapshot = {
         prepared,
         model: structuredClone(model),
@@ -2398,7 +2492,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();
@@ -2408,15 +2502,19 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     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();
+    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,23 +2522,28 @@ 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")
       removeInvalidation();
   });
   pi.on("session_before_compact", async (event, context) => {
-    const began = Date.now();
-    compactionStatus = "preparing compaction";
+    const began = Date.now(), ticket = generation;
+    const sessionId = context.sessionManager.getSessionId();
     fallbackReason = undefined;
     const attempt = expiryAttempt;
     const capture = snapshot;
@@ -2449,7 +2552,12 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     cache = undefined;
     pending = undefined;
     const cancelled = (usage, reason = "compaction ownership or input changed") => {
-      lastOutcome = { path: attempt ? "expiry cancelled" : "cancelled", elapsedMs: Date.now() - began, usage, reason };
+      if (usage && ticket === generation && ctx) {
+        try {
+          if (ctx.sessionManager.getSessionId() === sessionId)
+            pi.appendEntry("pi-provider-compaction:diagnostic", { status: `${attempt ? "expiry cancelled" : "cancelled"}: ${reason}`, usage });
+        } catch {}
+      }
       return { cancel: true };
     };
     const reject = (reason) => {
@@ -2463,7 +2571,6 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     }
     if (!capture && !cached || !context.model || generic(context) || event.signal.aborted)
       return reject("no eligible snapshot, explicit model override, or aborted attempt");
-    const ticket = generation;
     const branch = context.sessionManager.getBranch();
     const branchHash = digest(branch);
     const source = cached ?? capture;
@@ -2488,8 +2595,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     let summaryPath = "standard";
     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 +2604,7 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
         if (portable)
           summaryPath = "cached";
       } finally {
-        summarizing = false;
+        compactionRequest = false;
       }
       if (!current())
         return cancelled(attemptedUsage);
@@ -2508,7 +2614,6 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
         return cancelled(attemptedUsage, summaryReason ?? "warm cache unavailable");
       if (!input && !attemptedUsage)
         return reject(summaryReason ?? fallbackReason ?? "native coverage unavailable");
-      compactionStatus = "generating portable summary";
       try {
         portable = await compact(event.preparation, source.model, auth.apiKey, auth.headers, event.customInstructions, event.signal, context.thinkingLevel, source.provider.streamSimple.bind(source.provider), auth.env, undefined, undefined, source.sessionId);
         portable = withFileTracking(portable, event.preparation);
@@ -2527,7 +2632,6 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
       return { compaction: result };
     };
     if (!capture || !protocol || !input) {
-      compactionStatus = `${summaryPath} portable summary prepared`;
       return outcome(summaryPath, portable, summaryReason);
     }
     try {
@@ -2538,28 +2642,35 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
         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;
+      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");
       }
@@ -2592,19 +2703,12 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
   pi.on("session_compact", (event, context) => {
     const recorded = isObject(event.compactionEntry.details) ? event.compactionEntry.details.providerCompaction : undefined;
     const owned = isObject(recorded) && equal(recorded, lastOutcome);
-    if (readNativeCompactionDetails(event.compactionEntry.details)?.version === 3)
-      compactionStatus = "native checkpoint committed";
-    else if (fallbackReason)
-      compactionStatus = `portable: ${fallbackReason}`;
-    else if (owned)
-      compactionStatus = `${lastOutcome.path} portable summary committed`;
-    else
+    if (!owned && !fallbackReason && readNativeCompactionDetails(event.compactionEntry.details)?.version !== 3)
       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");
-    } else
-      lastOutcome = { path: "Pi/other handler", elapsedMs: 0, usage: event.compactionEntry.usage, reason: compactionStatus };
+        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");
+    }
     if (fallbackReason)
       pi.appendEntry("pi-provider-compaction:diagnostic", { status: `portable: ${fallbackReason}` });
     active = undefined;
@@ -2633,7 +2737,6 @@ Outcome: ${lastOutcome.path}, ${lastOutcome.elapsedMs}ms${usage ? `; input ${usa
     pending = undefined;
     snapshot = undefined;
     cache = undefined;
-    compactionStatus = "compaction failed or cancelled";
   });
 }
 export {