@nijaru/pi-provider-compaction 0.0.7 → 0.0.9

package/index.ts

@@ -3,9 +3,10 @@ import type { AgentMessage } from "@earendil-works/pi-agent-core";
 import { normalizeContext, registerSessionResourceCleanup, type Model, type Provider, type ProviderHeaders, type ProviderStreamOptions, type SimpleStreamOptions, type TranscriptContext, type Usage } from "@earendil-works/pi-ai";
 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 { capturePreparedRequest, equal, requestPolicy, selectCoveredPrefix, substituteSummary, summarySlot, type PreparedRequest } from "./replay";
-import { isObject, requestProviderCompaction, resolveNativeProtocol, supportsResponsesApi, validateCompactedOutput, type NativeProtocol, type ResponseItem } from "./protocol";
+import { isObject, NativeCompactionValidationError, requestProviderCompaction, resolveNativeProtocol, supportsResponsesApi, validateCompactedOutput, type NativeProtocol, type ResponseItem } from "./protocol";
 
 export const NATIVE_COMPACTION_TYPE = "pi-provider-compaction/openai-responses";
 export const NATIVE_COMPACTION_VERSION = 3;
@@ -124,7 +125,7 @@ interface Captured {
 	prepared: PreparedRequest;
 	model: Model<any>;
 	provider: Provider;
-	options: ProviderStreamOptions | SimpleStreamOptions;
+	options: (ProviderStreamOptions | SimpleStreamOptions) & { serviceTier?: string };
 	branchLength: number;
 	branchHash: string;
 	routeHash: string;
@@ -134,49 +135,109 @@ interface Captured {
 }
 interface Active {
 	entryId: string;
-	detailsHash: string;
 	summary: string;
 	branchLength: number;
 	branchHash: string;
 	routeHash: string;
 	policyHash: string;
+	/** Model field of the prepared payload; a request hook rewrite invalidates native state. */
+	payloadModel?: string;
+}
+
+interface ExpiryAttempt {
+	sessionId: string;
+	cycle: string;
+	isCurrent(): boolean;
+	signal?: AbortSignal;
 }
 
 export default function (pi: ExtensionAPI): void {
 	// Evidence is deliberately process/session-local. A reload cannot prove unchanged
 	// hook/privacy policy, even if the visible summary text happens to match.
+	// Older hosts in the native adapter's supported range lack getSettings.
+	// Keep their existing native path; cache preferences require that host API.
+	const configuration = () => typeof pi.getSettings === "function" ? cacheConfig(pi.getSettings()) : { cachedSummaries: false, outcomeNotifications: false, cacheRetention: undefined };
 	const secret = randomBytes(32);
 	const routeDigest = (value: unknown) => createHmac("sha256", secret).update(JSON.stringify(value)).digest("hex");
 	let runtimeId = randomUUID();
 	let ctx: ExtensionContext | undefined;
 	let snapshot: Captured | undefined;
+	let cache: CachedRequest | undefined;
+	let summarizing = false;
+	let expiryAttempt: ExpiryAttempt | undefined;
+	let lastOutcome: { path: string; elapsedMs: number; usage?: Usage; reason?: string } | undefined;
 	let active: Active | undefined;
 	let pending: { details: NativeCompactionDetails; capture: Captured; summary: string } | undefined;
 	let observer: InstalledObserver | undefined;
 	let unregisterCleanup: (() => void) | undefined;
 	let generation = 0;
+	let requestSequence = 0;
 	let captureStatus = "no request observed";
 	let compactionStatus = "not attempted in this runtime";
+	let fallbackReason: string | undefined;
 	const captureRejected = (reason: string) => { captureStatus = reason; };
-	const fallback = (reason: string) => { compactionStatus = `portable: ${reason}`; };
+	const fallback = (reason: string) => { fallbackReason = reason; compactionStatus = `portable: ${reason}`; };
 	pi.registerCommand("provider-compaction-status", {
-		description: "Show content-free native compaction eligibility and last attempt",
+		description: "Show cache/native eligibility and measured compaction usage",
 		handler: async (_args, context) => {
-			context.ui.notify(`Provider compaction\nObserver: ${observer?.isInstalled() ? "installed" : "unavailable for current registration"}\nCapture: ${captureStatus}\nLast attempt: ${compactionStatus}`, "info");
+			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");
 		},
 	});
-	const invalidate = () => { generation++; runtimeId = randomUUID(); snapshot = undefined; active = undefined; pending = undefined; captureStatus = "invalidated by lifecycle/history/policy change"; };
+	const invalidate = () => { generation++; runtimeId = randomUUID(); snapshot = undefined; cache = undefined; active = undefined; pending = undefined; expiryAttempt = undefined; captureStatus = "invalidated by lifecycle/history/policy change"; };
 	const retire = () => {
 		invalidate();
 		const installed = observer;
 		observer = undefined; ctx = undefined;
 		unregisterCleanup?.(); unregisterCleanup = undefined;
 		installed?.remove();
+		lastOutcome = undefined;
 	};
 	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");
 
+	const cacheState = (context: ExtensionContext) => {
+		let reason: string | undefined;
+		if (!configuration().cachedSummaries) reason = "cached summaries disabled";
+		else if (generic(context)) reason = "explicit compaction model takes precedence";
+		else if (cache && !observer?.isInstalled()) reason = "request observer no longer owned";
+		else if (cache && (cache.sessionId !== context.sessionManager.getSessionId() || context.model?.id !== cache.model.id || context.model?.provider !== cache.model.provider || context.model?.api !== cache.model.api || context.modelRegistry.getProvider(cache.model.provider) !== cache.provider || !unchanged(context.sessionManager.getBranch(), cache.branchLength, cache.branchHash))) reason = "cache snapshot no longer matches session/model/history";
+		return requestCacheState(cache, reason);
+	};
+	const removeCacheState = pi.events.on("pi-provider-compaction:cache-state", (request) => {
+		if (!isObject(request) || !isObject(request.context) || typeof request.respond !== "function") return;
+		try { request.respond(cacheState(request.context as unknown as ExtensionContext)); } catch { /* Stale requester. */ }
+	});
+	const removeExpiry = pi.events.on("pi-provider-compaction:compact-before-expiry", (request) => {
+		if (!isObject(request) || !isObject(request.context) || typeof request.respond !== "function" || typeof request.run !== "function" || typeof request.isCurrent !== "function") return;
+		const context = request.context as unknown as ExtensionContext;
+		const run = request.run as () => Promise<boolean>;
+		const authorized = request.isCurrent as () => boolean;
+		const execute = async () => {
+			const state = cacheState(context);
+			if (expiryAttempt || !state.available || state.cycle !== request.cycle || state.expiresAt === undefined || Date.now() >= state.expiresAt || !context.isIdle() || context.hasPendingMessages() || !authorized()) return false;
+			const ticket = generation;
+			const attempt: ExpiryAttempt = {
+				sessionId: context.sessionManager.getSessionId(), cycle: state.cycle,
+				isCurrent: () => {
+					try {
+						return expiryAttempt === attempt && generation === ticket &&
+							context.sessionManager.getSessionId() === attempt.sessionId &&
+							!context.hasPendingMessages() && authorized();
+					} catch { return false; }
+				},
+			};
+			expiryAttempt = attempt;
+			try { return await run(); }
+			finally { if (expiryAttempt === attempt) expiryAttempt = undefined; }
+		};
+		request.respond(execute());
+	});
+	pi.on("session_shutdown", () => { removeCacheState(); removeExpiry(); });
+
 	const observe: ObserveRequest = (model, context, options) => {
 		const owner = ctx;
 		if (!owner) return;
@@ -189,26 +250,35 @@ export default function (pi: ExtensionAPI): void {
 			return;
 		}
 		if (options.sessionId !== manager.getSessionId()) return;
-		if (!supportsNativeCompaction(model)) { captureRejected("unsupported API"); return; }
-		if (!options.onPayload) { captureRejected("no payload callback"); return; }
+		if (summarizing) return;
+		if (!supportsNativeCompaction(model) && !supportsCachedSummary(model)) { captureRejected("unsupported API"); return; }
+		if (!options.onPayload) {
+			// The portable-summary request re-enters this observer without a payload
+			// callback. Do not overwrite the main request's capture diagnostic.
+			if (captureStatus !== "eligible prepared request captured") captureRejected("no payload callback");
+			return;
+		}
 		if (generic(owner)) { captureRejected("generic compaction model takes precedence"); return; }
 		// The Azure adapter also accepts API-specific overrides and process-env
 		// fallbacks. Those must not silently select a route absent from our evidence.
 		if (!supportedRouteOptions(model, options)) { captureRejected("unsupported route overrides"); return; }
 		const ticket = generation;
+		const startedAt = Date.now();
+		const sequence = ++requestSequence;
+		const config = configuration();
+		const effectiveOptions = { ...options, ...(config.cacheRetention === undefined ? {} : { cacheRetention: config.cacheRetention }) };
+		let candidate: CachedRequest | undefined;
 		const branch = manager.getBranch();
 		const branchHash = digest(branch);
 		const canonical = transcript(manager.buildSessionProjection().messages);
 		const current = () => {
-			if (generation !== ticket || ctx !== owner || options.signal?.aborted || !supportedRouteOptions(model, options)) return false;
-			try { return digest(owner.sessionManager.getBranch()) === branchHash; }
+			if (sequence !== requestSequence || generation !== ticket || ctx !== owner || options.signal?.aborted || !supportedRouteOptions(model, options)) return false;
+			try { return unchanged(owner.sessionManager.getBranch(), branch.length, branchHash); }
 			catch { retire(); return false; }
 		};
-		return async (payload) => {
+		const handler = async (payload: unknown) => {
 			if (!current()) return payload;
 			snapshot = undefined;
-			const prepared = capturePreparedRequest(model, context, canonical, payload, captureRejected);
-			if (!prepared) { active = undefined; return payload; }
 			const auth = await owner.modelRegistry.getApiKeyAndHeaders(model);
 			if (!current()) return payload;
 			// A registry lookup after payload hooks must describe the credentials used by
@@ -216,17 +286,29 @@ export default function (pi: ExtensionAPI): void {
 			// exact auth correspondence are deliberately ineligible.
 			const normalizedHeaders = (headers: ProviderHeaders | undefined) => Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]).sort(([a], [b]) => String(a).localeCompare(String(b)));
 			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;
+				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"); 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);
+				candidate = warming ? { ...cache!, startedAt, cycle: randomUUID(), usage: undefined, expiresAt: undefined } : captureCachedRequest({
+					model, provider, context, canonical, options: effectiveOptions, startedAt,
+					sessionId: manager.getSessionId(), branchLength: branch.length, branchHash, authHash: routeDigest(auth),
+				}, payload);
+				if (!warming) cache = undefined;
+			}
+			if (!supportsNativeCompaction(model)) { captureStatus = candidate ? "eligible cached request captured" : "cached request ineligible"; return payload; }
+			const prepared = capturePreparedRequest(model, context, canonical, payload, captureRejected);
+			if (!prepared) { active = undefined; return payload; }
 			const policyHash = digest(requestPolicy(model, prepared));
 			const latest = latestCompaction(branch);
+			const payloadModel = isObject(payload) && typeof payload.model === "string" ? payload.model : undefined;
 			let result = payload;
-			if (active && latest?.id === active.entryId && latest.summary === active.summary && digest(latest.details) === active.detailsHash && unchanged(branch, active.branchLength, active.branchHash) && active.routeHash === routeHash && active.policyHash === policyHash) {
+			if (active && latest?.id === active.entryId && latest.summary === active.summary && active.payloadModel === payloadModel && unchanged(branch, active.branchLength, active.branchHash) && active.routeHash === routeHash && active.policyHash === policyHash) {
 				const details = readNativeCompactionDetails(latest.details);
 				const projection = owner.sessionManager.buildSessionProjection();
 				const contribution = projection.entries.find((entry) => entry.sourceEntry.id === latest.id);
@@ -238,25 +320,35 @@ export default function (pi: ExtensionAPI): void {
 						result = replaced;
 						prepared.payload = structuredClone(replaced);
 						prepared.replacement = { index: slot, count: details.output.length };
+						// The actual request contains opaque state, not the captured readable prefix.
+						candidate = undefined; cache = undefined;
 					} else active = undefined;
 				} else active = undefined;
 			} else active = undefined;
 			captureStatus = "eligible prepared request captured";
 			snapshot = {
 				prepared, model: structuredClone(model), provider,
-				options: { apiKey: options.apiKey, headers: structuredClone(options.headers), env: structuredClone(options.env), fetch: options.fetch },
+				options: { apiKey: options.apiKey, headers: structuredClone(options.headers), env: structuredClone(options.env), fetch: options.fetch, ...(typeof (options as { serviceTier?: unknown }).serviceTier === "string" ? { serviceTier: (options as { serviceTier: string }).serviceTier } : {}) },
 				branchLength: branch.length, branchHash, routeHash, authHash: routeDigest(auth), policyHash,
 				sessionId: owner.sessionManager.getSessionId(),
 			};
 			return result;
 		};
+		return Object.assign(handler, {
+			cacheRetention: config.cacheRetention,
+			complete: (message: Parameters<typeof finishCachedRequest>[1]) => {
+				if (!candidate || sequence !== requestSequence || !current()) return;
+				finishCachedRequest(candidate, message);
+				if (candidate.usage) cache = candidate;
+			},
+		});
 	};
 
 	const install = (context: ExtensionContext) => {
 		ctx = context;
 		if (observer?.provider === context.model?.provider && observer?.isInstalled()) return;
 		if (observer) { invalidate(); observer.remove(); observer = undefined; }
-		if (!supportsNativeCompaction(context.model)) return;
+		if (!supportsNativeCompaction(context.model) && !supportsCachedSummary(context.model)) return;
 		observer = installObserver(pi, context, observe);
 		captureStatus = observer ? "awaiting prepared request" : "unsupported provider registration";
 	};
@@ -281,50 +373,102 @@ export default function (pi: ExtensionAPI): void {
 	pi.on("session_shutdown", () => { if (typeof removeInvalidation === "function") removeInvalidation(); });
 
 	pi.on("session_before_compact", async (event, context) => {
+		const began = Date.now();
+		compactionStatus = "preparing compaction";
+		fallbackReason = undefined;
+		const attempt = expiryAttempt;
 		const capture = snapshot;
-		snapshot = undefined; pending = undefined;
-		if (!capture) { fallback(`no eligible snapshot (${captureStatus})`); return; }
-		if (!context.model || generic(context) || event.signal.aborted) { fallback("missing model, generic model override, or aborted attempt"); return; }
-		const protocol = resolveNativeProtocol(context.model);
-		if (!protocol || context.sessionManager.getSessionId() !== capture.sessionId) { fallback("unsupported protocol or changed session"); return; }
+		const cached = cacheState(context).available ? cache : undefined;
+		snapshot = undefined; cache = undefined; pending = undefined;
+		const cancelled = (usage?: Usage, reason = "compaction ownership or input changed") => {
+			lastOutcome = { path: attempt ? "expiry cancelled" : "cancelled", elapsedMs: Date.now() - began, usage, reason };
+			return { cancel: true as const };
+		};
+		const reject = (reason: string) => {
+			fallback(reason);
+			return attempt ? cancelled(undefined, reason) : undefined;
+		};
+		// The provider may run before the companion's handler. Share its live
+		// ownership/input guard instead of paying for work that a later handler cancels.
+		if (attempt) {
+			if (event.reason !== "manual" || !attempt.isCurrent() || !cached || cached.cycle !== attempt.cycle || attempt.signal && attempt.signal !== event.signal) return reject("idle transaction no longer authorized");
+			attempt.signal = event.signal;
+		}
+		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);
-		if (!equal(branch, event.branchEntries) || !unchanged(branch, capture.branchLength, capture.branchHash)) { fallback("history changed since capture"); return; }
-		const projection = context.sessionManager.buildSessionProjection();
-		const boundary = projection.entries.findIndex((entry) => entry.sourceEntry.id === event.preparation.firstKeptEntryId);
-		if (boundary < 0) { fallback("retained boundary missing from projection"); return; }
-		const prefix = transcript(projection.entries.slice(0, boundary).flatMap((entry) => entry.messages));
-		const input = selectCoveredPrefix(capture.model, capture.prepared, prefix, fallback);
-		if (!input) return;
-		const current = () => ticket === generation && !event.signal.aborted && supportedRouteOptions(capture.model, capture.options) && !generic(context) && context.modelRegistry.getProvider(capture.model.provider) === capture.provider && digest(context.sessionManager.getBranch()) === branchHash;
+		const source = cached ?? capture!;
+		if (context.sessionManager.getSessionId() !== source.sessionId || !equal(branch, event.branchEntries) || !unchanged(branch, source.branchLength, source.branchHash)) return reject("history/session changed since capture");
+		const current = () => ticket === generation && !event.signal.aborted && (!attempt || attempt.isCurrent()) && supportedRouteOptions(source.model, source.options) && !generic(context) &&
+			context.model?.id === source.model.id && context.model?.provider === source.model.provider && context.model?.api === source.model.api &&
+			observer?.isInstalled() === true && context.modelRegistry.getProvider(source.model.provider) === source.provider && unchanged(context.sessionManager.getBranch(), branch.length, branchHash);
 		const auth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
-		if (!current()) return { cancel: true };
-		if (!auth.ok || routeDigest(auth) !== capture.authHash) { fallback("auth changed since capture"); return; }
-		compactionStatus = "generating portable summary";
-		let portable: Awaited<ReturnType<typeof compact>>;
-		try {
-			portable = await compact(event.preparation, capture.model, auth.apiKey, auth.headers as Record<string, string> | undefined, event.customInstructions, event.signal, context.thinkingLevel, capture.provider.streamSimple.bind(capture.provider), auth.env, undefined, undefined, capture.sessionId);
-		} catch {
-			// No result exists to return; let Pi own its ordinary failure/fallback behavior.
-			return !current() ? { cancel: true } : undefined;
+		if (!current()) return cancelled();
+		if (!auth.ok || routeDigest(auth) !== source.authHash) return reject("auth changed since capture");
+		const protocol = capture ? resolveNativeProtocol(context.model) : undefined;
+		let input: ResponseItem[] | undefined;
+		if (capture && protocol && unchanged(branch, capture.branchLength, capture.branchHash) && source.authHash === capture.authHash) {
+			const projection = context.sessionManager.buildSessionProjection();
+			const boundary = projection.entries.findIndex((entry) => entry.sourceEntry.id === event.preparation.firstKeptEntryId);
+			if (boundary >= 0) input = selectCoveredPrefix(capture.model, capture.prepared, transcript(projection.entries.slice(0, boundary).flatMap((entry) => entry.messages)), fallback);
+		}
+		let portable: Awaited<ReturnType<typeof compact>> | undefined;
+		let attemptedUsage: Usage | undefined;
+		let summaryPath = "standard";
+		let summaryReason: string | undefined;
+		if (cached) {
+			compactionStatus = "generating cached portable summary";
+			summarizing = 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; }
+			if (!current()) return cancelled(attemptedUsage);
+		}
+		if (!portable) {
+			if (attempt) return cancelled(attemptedUsage, summaryReason ?? "warm cache unavailable");
+			// Without native coverage or a dispatched cached attempt, Pi can own fallback.
+			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 as Record<string, string> | undefined, event.customInstructions, event.signal, context.thinkingLevel, source.provider.streamSimple.bind(source.provider), auth.env, undefined, undefined, source.sessionId);
+				portable = withFileTracking(portable, event.preparation);
+				portable.usage = combineUsage(attemptedUsage, portable.usage);
+			} catch {
+				if (!current()) return cancelled(attemptedUsage);
+				return reject("portable summary generation failed");
+			}
+		}
+		if (!current() || !portable.summary.trim() || portable.summary === NATIVE_COMPACTION_SUMMARY) return cancelled(portable.usage);
+		const outcome = (path: string, result: typeof portable, reason?: string) => {
+			lastOutcome = { path, elapsedMs: Date.now() - began, usage: result!.usage, reason };
+			result!.details = { ...(isObject(result!.details) ? result!.details : {}), providerCompaction: lastOutcome };
+			return { compaction: result! };
+		};
+		if (!capture || !protocol || !input) {
+			compactionStatus = `${summaryPath} portable summary prepared`;
+			return outcome(summaryPath, portable, summaryReason);
 		}
-		if (!current() || !portable.summary.trim() || portable.summary === NATIVE_COMPACTION_SUMMARY) return { cancel: true };
 		try {
 			const freshAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
-			if (!current()) return { cancel: true };
-			if (!freshAuth.ok || routeDigest(freshAuth) !== capture.authHash) { fallback("auth changed after portable generation"); return { compaction: portable }; }
+			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, fetch: capture.options.fetch,
+				signal: event.signal, isCurrent: current, fetch: capture.options.fetch,
+				...(capture.options.serviceTier === undefined ? {} : { serviceTier: capture.options.serviceTier }),
 			});
-			if (!current()) return { cancel: true };
+			if (!current()) return cancelled(combineUsage(native.usage, portable.usage));
 			const finalAuth = await context.modelRegistry.getApiKeyAndHeaders(context.model);
-			if (!current()) return { cancel: true };
-			if (!finalAuth.ok || routeDigest(finalAuth) !== capture.authHash) { fallback("auth changed after native generation"); return { compaction: portable }; }
+			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"); }
 			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,
@@ -332,28 +476,44 @@ export default function (pi: ExtensionAPI): void {
 				nativeUsage: native.usage, portableUsage: portable.usage,
 				coverage: { kind: "summarized-prefix", firstKeptEntryId: portable.firstKeptEntryId, sourceLeafId: branch.at(-1)!.id, sourceHash: branchHash, policyHash: capture.policyHash, inputHash: digest(input), runtimeId },
 			};
-			pending = { details, capture, summary: portable.summary };
-			return { compaction: { ...portable, usage: combineUsage(native.usage, portable.usage), details } };
-		} catch {
-			if (!current()) return { cancel: true };
-			// Do not expose exception text: provider errors may contain request data.
+			const result = outcome(`${summaryPath} + native`, { ...portable, usage: combineUsage(native.usage, portable.usage), details }, summaryReason);
+			pending = { details: result.compaction.details as NativeCompactionDetails, capture, summary: portable.summary };
+			return result;
+		} catch (error) {
+			if (!current()) return cancelled(error instanceof NativeCompactionValidationError ? combineUsage(error.usage, portable.usage) : portable.usage);
 			fallback("native acquisition or validation failed");
-			// The portable request already succeeded. Never pay for a duplicate summary.
-			return { compaction: portable };
+			if (error instanceof NativeCompactionValidationError && error.usage !== undefined) portable.usage = combineUsage(error.usage, portable.usage);
+			return outcome(summaryPath, portable, "native acquisition or validation failed");
 		}
 	});
 	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 (!compactionStatus.startsWith("portable:")) fallback("another handler supplied the committed result");
+		else if (fallbackReason) compactionStatus = `portable: ${fallbackReason}`;
+		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");
+		} 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 (compactionStatus.startsWith("portable:")) pi.appendEntry("pi-provider-compaction:diagnostic", { status: compactionStatus });
-		active = undefined; snapshot = undefined;
+		if (fallbackReason) pi.appendEntry("pi-provider-compaction:diagnostic", { status: `portable: ${fallbackReason}` });
+		active = undefined; snapshot = undefined; cache = undefined;
 		const candidate = pending; pending = undefined;
 		if (!candidate || !equal(event.compactionEntry.details, candidate.details) || event.compactionEntry.summary !== candidate.summary) return;
 		const branch = context.sessionManager.getBranch();
 		const coverage = candidate.details.coverage;
-		if (!coverage || event.compactionEntry.firstKeptEntryId !== coverage.firstKeptEntryId || event.compactionEntry.parentId !== coverage.sourceLeafId || branch.at(-1)?.id !== event.compactionEntry.id || digest(branch.slice(0, -1)) !== coverage.sourceHash) return;
-		active = { entryId: event.compactionEntry.id, detailsHash: digest(candidate.details), summary: candidate.summary, branchLength: branch.length, branchHash: digest(branch), routeHash: candidate.capture.routeHash, policyHash: candidate.capture.policyHash };
+		const index = branch.findIndex((entry) => entry.id === event.compactionEntry.id);
+		if (!coverage || index < 0 || event.compactionEntry.firstKeptEntryId !== coverage.firstKeptEntryId || event.compactionEntry.parentId !== coverage.sourceLeafId || digest(branch.slice(0, index)) !== coverage.sourceHash) return;
+		active = {
+			entryId: event.compactionEntry.id,
+			summary: candidate.summary,
+			branchLength: index + 1,
+			branchHash: digest(branch.slice(0, index + 1)),
+			routeHash: candidate.capture.routeHash,
+			policyHash: candidate.capture.policyHash,
+			...(typeof candidate.capture.prepared.payload.model === "string" ? { payloadModel: candidate.capture.prepared.payload.model } : {}),
+		};
 	});
-	pi.on("session_compact_failed", () => { pending = undefined; snapshot = undefined; compactionStatus = "compaction failed or cancelled"; });
+	pi.on("session_compact_failed", () => { pending = undefined; snapshot = undefined; cache = undefined; compactionStatus = "compaction failed or cancelled"; });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nijaru/pi-provider-compaction",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "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 tests/",
+    "lint": "oxlint build.ts index.ts protocol.ts policy.ts provider.ts replay.ts cached-summary.ts tests/",
     "typecheck": "tsc --noEmit",
     "check": "bun run build && bun test && bun run lint && tsc --noEmit"
   },
@@ -40,13 +40,14 @@
     "policy.ts",
     "provider.ts",
     "replay.ts",
+    "cached-summary.ts",
     "README.md",
     "LICENSE"
   ],
   "devDependencies": {
-    "@earendil-works/pi-ai": "1.3.0",
-    "@earendil-works/pi-agent-core": "1.3.0",
-    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-ai": "1.4.0",
+    "@earendil-works/pi-agent-core": "1.4.0",
+    "@earendil-works/pi-coding-agent": "1.4.0",
     "@types/bun": "latest",
     "oxlint": "^1.81.0",
     "typescript": "^6.0.3"

package/protocol.ts

@@ -225,10 +225,26 @@ interface TransportRequest {
 	apiKey?: string;
 	headers?: ProviderHeaders;
 	env?: Record<string, string>;
+	/** Cost-relevant request option captured with the original request. */
+	serviceTier?: string;
 	signal: AbortSignal;
+	/** Revalidate request ownership after asynchronous provider preparation. */
+	isCurrent?: () => boolean;
 	fetch?: typeof globalThis.fetch;
 }
 
+function assertCurrent(request: TransportRequest): void {
+	if (request.signal.aborted || request.isCurrent?.() === false) throw new DOMException("Compaction invalidated", "AbortError");
+}
+
+/** The provider answered and was billed, but its window cannot be committed. */
+export class NativeCompactionValidationError extends Error {
+	constructor(message: string, readonly usage?: Usage) {
+		super(message);
+		this.name = "NativeCompactionValidationError";
+	}
+}
+
 export interface TransportResponse {
 	output: ResponseItem[];
 	usage: Usage;
@@ -241,7 +257,7 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 	let dispatches = 0;
 	const baseFetch = request.fetch ?? globalThis.fetch;
 	const bridgeFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
-		if (request.signal.aborted) throw new DOMException("Compaction aborted", "AbortError");
+		assertCurrent(request);
 		dispatches += 1;
 		if (dispatches !== 1 || !preparedPayload) {
 			bridgeError = new Error("Responses Compact provider dispatched an unexpected additional request");
@@ -258,8 +274,12 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 			});
 			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");
-			compacted = { response: parsed, output: validateCompactedOutput(parsed) };
+			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);
 		} catch (error) {
 			bridgeError = error;
@@ -272,11 +292,13 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 		headers: request.headers,
 		env: request.env,
 		signal: request.signal,
+		...(request.serviceTier === undefined ? {} : { serviceTier: request.serviceTier }),
 		transport: "sse",
 		cacheRetention: "none",
 		maxRetries: 0,
 		fetch: bridgeFetch,
 		onPayload: (payload: unknown) => {
+			assertCurrent(request);
 			if (!isObject(payload)) throw new Error("Responses provider exposed a non-object payload");
 			if (request.preparedPayload && request.preparedPayload.model !== payload.model) throw new Error("Native route model changed since capture");
 			preparedPayload = { ...structuredClone(request.preparedPayload ?? payload), input: structuredClone(request.input) };
@@ -288,6 +310,7 @@ async function requestResponsesCompact(request: TransportRequest): Promise<Trans
 		if (bridgeError) throw bridgeError;
 		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 };
@@ -392,6 +415,7 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 	const signal = AbortSignal.any([request.signal, controller.signal]);
 	const inspections: Promise<{ result: CollectedSse } | { error: unknown }>[] = [];
 	const inspectedFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+		assertCurrent(request);
 		const response = await baseFetch(input, init);
 		if (!response.ok || !response.body) return response;
 		const [providerBody, inspectionBody] = response.body.tee();
@@ -410,11 +434,13 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 		headers: request.headers,
 		env: request.env,
 		signal: request.signal,
+		...(request.serviceTier === undefined ? {} : { serviceTier: request.serviceTier }),
 		transport: "sse",
 		cacheRetention: "none",
 		maxRetries: 0,
 		fetch: inspectedFetch,
 		onPayload: (payload: unknown) => {
+			assertCurrent(request);
 			if (!isObject(payload)) throw new Error("Codex provider exposed a non-object payload");
 			sentInput = structuredClone(request.input);
 			if (request.preparedPayload && request.preparedPayload.model !== payload.model) throw new Error("Native route model changed since capture");
@@ -435,6 +461,11 @@ async function requestRemoteV2(request: TransportRequest): Promise<TransportResp
 export async function requestProviderCompaction(
 	request: TransportRequest & { protocol: NativeProtocol },
 ): Promise<TransportResponse> {
+	assertCurrent(request);
 	const result = await (request.protocol === "remote-v2" ? requestRemoteV2(request) : requestResponsesCompact(request));
-	return { ...result, output: validateCompactedOutput(result) };
+	try {
+		return { ...result, output: validateCompactedOutput(result) };
+	} catch (error) {
+		throw new NativeCompactionValidationError(error instanceof Error ? error.message : String(error), result.usage);
+	}
 }