pi-ui-extend 1.0.42 → 1.0.45

package/external/pi-tools-suite/src/context-gateway/index.ts

@@ -1,10 +1,17 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { randomUUID } from "node:crypto";
 import { classifyShellCommand, type ShellCommandClassification } from "../shell-command-policy.js";
 
+import {
+	contextGatewayAccountingLogDrain,
+	contextGatewayAccountingLogEnabled,
+	writeContextGatewayAccountingLog,
+} from "./accounting-log.js";
 import {
 	contextGatewayBudgetForClass,
 	loadContextGatewayConfig,
 } from "./config.js";
+import { ContextGatewayEfficiencyTracker } from "./efficiency.js";
 import { planContextGatewayEnforcement } from "./enforcement.js";
 import { classifyContextGatewayTool, ContextGatewayTelemetry } from "./telemetry.js";
 import type {
@@ -18,20 +25,25 @@ import type {
 export interface RegisterContextGatewayOptions {
 	loadConfig?: () => ContextGatewayResolvedConfig;
 	telemetry?: ContextGatewayTelemetry;
+	efficiency?: ContextGatewayEfficiencyTracker;
 }
 
 export interface RegisteredContextGateway extends ContextGatewayRuntimeState {
+	readonly efficiency: ContextGatewayEfficiencyTracker;
 	setRuntimeMode(mode: ContextGatewayMode): { ok: boolean; message: string };
 }
 
 function formatStatus(runtime: RegisteredContextGateway): string {
 	const telemetry = runtime.telemetry.snapshot();
+	const efficiency = runtime.efficiency.snapshot();
 	return [
 		`Context Gateway requested=${runtime.requestedMode}, effective=${runtime.effectiveMode}.`,
 		`Observed results=${telemetry.results}, errors=${telemetry.errors}, upstreamTruncated=${telemetry.upstreamTruncatedResults}, overBudget=${telemetry.overBudgetResults}, enforced=${telemetry.enforcedResults}, unbound results=${telemetry.unboundResults}.`,
 		`Repeat exact reads=${telemetry.repeatCandidateCount}, same-source different-range reads=${telemetry.sameSourceDifferentRangeCount}, retrieval calls=${telemetry.retrievalCalls}.`,
 		`Native policy results=${telemetry.nativePolicy.results}, refusals=${telemetry.nativePolicy.refusals}, full overrides=${telemetry.nativePolicy.fullOverrides}.`,
 		`Source contentBytes=${telemetry.contentBytes}, deliveredContentBytes=${telemetry.deliveredContentBytes}, actualBytesSaved=${telemetry.actualBytesSaved}, potentialBytesOverBudget=${telemetry.potentialBytesOverBudget}, detailsBytes=${telemetry.detailsBytes}.`,
+		`Efficiency gross≈${efficiency.grossEstimatedTokensSaved} tokens/${efficiency.grossBytesSaved} bytes, retrieval tax≈${efficiency.retrievalEstimatedTokens} tokens/${efficiency.retrievalBytes} bytes, conservative net≈${efficiency.conservativeNetEstimatedTokens} tokens/${efficiency.conservativeNetBytes} bytes.`,
+		`Provider attempts=${efficiency.providerAttempts}, completions=${efficiency.providerCompletions}, input=${efficiency.providerInputTokens}, cacheRead=${efficiency.providerCacheReadTokens}, cacheWrite=${efficiency.providerCacheWriteTokens}, output=${efficiency.providerOutputTokens}, total=${efficiency.providerTotalTokens}.`,
 	].join("\n");
 }
 
@@ -39,11 +51,12 @@ function formatDoctor(runtime: RegisteredContextGateway): string {
 	const lines = [
 		`Context Gateway doctor: requested=${runtime.requestedMode}, effective=${runtime.effectiveMode}.`,
 		"Budgets: read=maxExactReadBytes; repo search/AST/structure=maxSearchBytes; other results=maxResultBytes; compact inline view=maxInlineBytes.",
-		"Enforce: recognised complete simple test/build output=bounded parser compact; partial/unknown/compound/upstream-truncated/non-text=passthrough.",
+		"Enforce: recognised complete simple test/build output=bounded parser compact; over-budget web_search/web_fetch with structured raw details=bounded recoverable compact; unsupported/unsafe results remain passthrough.",
 		"Read: full passthrough even when over budget; exact recovery/archive is not wired, so irreversible read truncation is disabled.",
 		"Repo tools: producer-native compact is supported with repoDiscovery.profile=native-compact; Gateway never post-hoc slices repo output.",
 		"External paths: MCP=current Pix adapter unsupported; direct parent browser capture=unsupported.",
 		"Storage: disabled; no durable archive, index, quota reservation, or retrieval tools are active.",
+		`Accounting log: ${contextGatewayAccountingLogEnabled(runtime.config) ? "enabled" : "disabled"}; scalar-only JSONL with bounded rotation, no result bodies, paths, or tool arguments.`,
 	];
 	for (const issue of runtime.config.issues) lines.push(`Config issue: ${issue}`);
 	return lines.join("\n");
@@ -59,14 +72,48 @@ export function registerContextGateway(
 ): RegisteredContextGateway {
 	const config = (options.loadConfig ?? (() => loadContextGatewayConfig()))();
 	const telemetry = options.telemetry ?? new ContextGatewayTelemetry();
+	const efficiency = options.efficiency ?? new ContextGatewayEfficiencyTracker();
 	let requestedMode = config.mode;
 	let effectiveMode: ContextGatewayEffectiveMode = requestedMode;
 	type InFlight = { toolClass: ContextGatewayToolClass; shell: ShellCommandClassification };
 	const inFlightToolCalls = new Map<string, InFlight>();
+	const runtimeId = randomUUID();
+	let accountingEpoch = 0;
+	let accountingEpochStartedAt = Date.now();
+	let accountingEpochActive = false;
+
+	const writeAccounting = (event: string, details: Record<string, unknown> = {}): void => {
+		writeContextGatewayAccountingLog(config, event, {
+			runtimeId,
+			sessionEpoch: accountingEpoch,
+			mode: effectiveMode,
+			...details,
+		});
+	};
+
+	const accountingSummary = (): Record<string, unknown> => ({
+		durationMs: Math.max(0, Date.now() - accountingEpochStartedAt),
+		totals: efficiency.snapshot(),
+	});
+
+	const finalizeAccountingEpoch = (reason: string): void => {
+		if (!accountingEpochActive || effectiveMode === "off") return;
+		writeAccounting("session.summary", { reason, ...accountingSummary() });
+		accountingEpochActive = false;
+	};
+
+	const beginAccountingEpoch = (reason: string): void => {
+		efficiency.reset();
+		accountingEpoch += 1;
+		accountingEpochStartedAt = Date.now();
+		accountingEpochActive = effectiveMode !== "off";
+		if (accountingEpochActive) writeAccounting("session.start", { reason });
+	};
 
 	const resetRuntimeTelemetry = (): void => {
 		inFlightToolCalls.clear();
 		telemetry.reset();
+		efficiency.clearTransientBindings();
 	};
 
 	const runtime: RegisteredContextGateway = {
@@ -74,6 +121,7 @@ export function registerContextGateway(
 		get effectiveMode() { return effectiveMode; },
 		config,
 		telemetry,
+		efficiency,
 		setRuntimeMode(mode) {
 			if (mode !== effectiveMode && inFlightToolCalls.size > 0) {
 				return {
@@ -81,9 +129,21 @@ export function registerContextGateway(
 					message: `Context Gateway mode change requires a safe boundary; ${inFlightToolCalls.size} tool call(s) are still in flight.`,
 				};
 			}
+			const previousMode = effectiveMode;
+			if (previousMode !== mode) finalizeAccountingEpoch("mode-change");
 			requestedMode = mode;
 			effectiveMode = mode;
 			telemetry.clearTransientBindings();
+			efficiency.clearTransientBindings();
+			if (previousMode !== mode) {
+				writeContextGatewayAccountingLog(config, "mode.change", {
+					runtimeId,
+					sessionEpoch: accountingEpoch,
+					from: previousMode,
+					to: mode,
+				});
+				beginAccountingEpoch("mode-change");
+			}
 			return { ok: true, message: `Context Gateway runtime mode set to ${mode}; config was not changed.` };
 		},
 	};
@@ -98,7 +158,11 @@ export function registerContextGateway(
 					: { scope: "unknown", kind: "unknown" },
 			});
 		}
-		if (effectiveMode === "observe" || effectiveMode === "enforce") telemetry.recordToolCall(event);
+		if (effectiveMode === "observe" || effectiveMode === "enforce") {
+			telemetry.recordToolCall(event);
+			const accountingCall = efficiency.recordToolCall(event);
+			if (accountingCall) writeAccounting("tool.call", { ...accountingCall });
+		}
 		return undefined;
 	});
 
@@ -114,6 +178,7 @@ export function registerContextGateway(
 			const enforcement = effectiveMode === "enforce" && binding
 				? planContextGatewayEnforcement({
 					event,
+					toolCallId: typeof event.toolCallId === "string" ? event.toolCallId : undefined,
 					toolClass: binding.toolClass,
 					shell: binding.shell,
 					budgetBytes: classBudget,
@@ -123,7 +188,7 @@ export function registerContextGateway(
 					),
 				})
 				: undefined;
-			telemetry.recordToolResult(event, config.budgets, {
+			const observation = telemetry.recordToolResult(event, config.budgets, {
 				maxInlineBytes: config.budgets.maxInlineBytes,
 				...(enforcement ? {
 					delivery: {
@@ -133,7 +198,26 @@ export function registerContextGateway(
 					},
 				} : {}),
 			});
-			if (enforcement?.representation === "test-build-compact") {
+			const accountingResult = efficiency.recordToolResult(
+				event,
+				observation,
+				enforcement?.content ?? event.content,
+			);
+			if (accountingResult) {
+				const efficiencySnapshot = efficiency.snapshot();
+				writeAccounting("tool.result", {
+					...accountingResult,
+					cumulative: {
+						grossBytesSaved: efficiencySnapshot.grossBytesSaved,
+						grossEstimatedTokensSaved: efficiencySnapshot.grossEstimatedTokensSaved,
+						retrievalBytes: efficiencySnapshot.retrievalBytes,
+						retrievalEstimatedTokens: efficiencySnapshot.retrievalEstimatedTokens,
+						conservativeNetBytes: efficiencySnapshot.conservativeNetBytes,
+						conservativeNetEstimatedTokens: efficiencySnapshot.conservativeNetEstimatedTokens,
+					},
+				});
+			}
+			if (enforcement && enforcement.representation !== "passthrough") {
 				const originalDetails = event.details && typeof event.details === "object" && !Array.isArray(event.details)
 					? event.details as Record<string, unknown>
 					: {};
@@ -156,18 +240,58 @@ export function registerContextGateway(
 		return undefined;
 	});
 
+	pi.on("before_provider_request", async (_event, ctx) => {
+		if (effectiveMode === "off") return undefined;
+		const attempt = efficiency.recordProviderAttempt();
+		const model = (ctx as any)?.model;
+		writeAccounting("provider.request", {
+			attempt,
+			provider: typeof model?.provider === "string" ? model.provider : undefined,
+			model: typeof model?.id === "string" ? model.id : undefined,
+		});
+		return undefined;
+	});
+
+	pi.on("message_end", async (event) => {
+		if (effectiveMode === "off" || event.message?.role !== "assistant") return;
+		const completion = efficiency.recordProviderCompletion(event.message as any);
+		const snapshot = efficiency.snapshot();
+		writeAccounting("provider.completion", {
+			...completion,
+			cumulative: {
+				providerInputTokens: snapshot.providerInputTokens,
+				providerOutputTokens: snapshot.providerOutputTokens,
+				providerCacheReadTokens: snapshot.providerCacheReadTokens,
+				providerCacheWriteTokens: snapshot.providerCacheWriteTokens,
+				providerTotalTokens: snapshot.providerTotalTokens,
+				providerCost: snapshot.providerCost,
+				grossEstimatedTokensSaved: snapshot.grossEstimatedTokensSaved,
+				retrievalEstimatedTokens: snapshot.retrievalEstimatedTokens,
+				conservativeNetEstimatedTokens: snapshot.conservativeNetEstimatedTokens,
+			},
+		});
+	});
+
 	pi.on("session_start", async () => {
+		finalizeAccountingEpoch("session-start-reset");
 		resetRuntimeTelemetry();
+		beginAccountingEpoch("session-start");
 		return undefined;
 	});
 
 	pi.on("session_tree", async () => {
+		finalizeAccountingEpoch("session-tree");
 		resetRuntimeTelemetry();
+		beginAccountingEpoch("session-tree");
 		return undefined;
 	});
 
 	pi.on("session_shutdown", async () => {
+		finalizeAccountingEpoch("session-shutdown");
 		resetRuntimeTelemetry();
+		efficiency.reset();
+		accountingEpochActive = false;
+		await contextGatewayAccountingLogDrain();
 		return undefined;
 	});
 
@@ -206,7 +330,16 @@ export default function contextGatewayExtension(pi: ExtensionAPI): void {
 }
 
 export { accountContextGatewayParts } from "./accounting.js";
+export {
+	contextGatewayAccountingLogDrain,
+	contextGatewayAccountingLogEnabled,
+	contextGatewayAccountingLogMaxBackups,
+	contextGatewayAccountingLogMaxBytes,
+	contextGatewayAccountingLogPath,
+	writeContextGatewayAccountingLog,
+} from "./accounting-log.js";
 export { loadContextGatewayConfig } from "./config.js";
+export { ContextGatewayEfficiencyTracker, estimateContextGatewayTokens } from "./efficiency.js";
 export { normalizeRedundantTruncationMetadata } from "./metadata-normalization.js";
 export { STORELESS_CAPABILITIES, storelessCapability } from "./storeless-capabilities.js";
 export { parseTestBuildOutput, planProspectiveTestOutputDelivery } from "./test-output-parser.js";

package/external/pi-tools-suite/src/context-gateway/storeless-capabilities.ts

@@ -1,5 +1,5 @@
 export type StorelessCapabilityStatus = "supported" | "limited" | "unsupported";
-export type StorelessCapabilityStrategy = "native-passthrough" | "metadata-only" | "pure-parser-candidate" | "pure-parser-compact" | "none";
+export type StorelessCapabilityStrategy = "native-passthrough" | "metadata-only" | "pure-parser-candidate" | "pure-parser-compact" | "raw-session-recoverable-compact" | "none";
 
 export interface StorelessCapabilityEntry {
 	surface:
@@ -13,7 +13,7 @@ export interface StorelessCapabilityEntry {
 		| "mcp-direct";
 	status: StorelessCapabilityStatus;
 	strategy: StorelessCapabilityStrategy;
-	lifetime: "current-result" | "producer-managed" | "visual-message" | "none";
+	lifetime: "current-result" | "producer-managed" | "raw-session" | "visual-message" | "none";
 	reason: string;
 }
 
@@ -41,9 +41,9 @@ export const STORELESS_CAPABILITIES: readonly StorelessCapabilityEntry[] = Objec
 	{
 		surface: "web-document",
 		status: "limited",
-		strategy: "native-passthrough",
-		lifetime: "current-result",
-		reason: "Existing web tools own fetch, URL/provider metadata and truncation. Storeless Gateway does not refetch, archive, or claim stable pagination of omitted content.",
+		strategy: "raw-session-recoverable-compact",
+		lifetime: "raw-session",
+		reason: "In enforce mode, over-budget web_search/web_fetch results are compacted only when the producer supplied full structured details. Those raw details remain in the session toolResult and are recoverable by toolCallId through session-recovery; unsupported web shapes remain passthrough.",
 	},
 	{
 		surface: "structured-json",

package/external/pi-tools-suite/src/context-gateway/telemetry.ts

@@ -254,7 +254,7 @@ export function observeToolResult(
 		toolClass?: ContextGatewayToolClass;
 		shellCommandScope?: "simple" | "compound" | "unknown";
 		maxInlineBytes?: number;
-		delivery?: { representation: "passthrough" | "test-build-compact"; contentBytes: number; textBytes: number };
+		delivery?: { representation: "passthrough" | "test-build-compact" | "web-recoverable-compact"; contentBytes: number; textBytes: number };
 	} = {},
 ): ContextGatewayObservation {
 	const toolName = typeof event.toolName === "string" ? event.toolName : "unknown";
@@ -367,7 +367,7 @@ export class ContextGatewayTelemetry {
 	recordToolResult(
 		event: ToolResultLike,
 		budget: number | ContextGatewayBudgets,
-		options: { delivery?: { representation: "passthrough" | "test-build-compact"; contentBytes: number; textBytes: number }; maxInlineBytes?: number } = {},
+		options: { delivery?: { representation: "passthrough" | "test-build-compact" | "web-recoverable-compact"; contentBytes: number; textBytes: number }; maxInlineBytes?: number } = {},
 	): ContextGatewayObservation {
 		const binding = typeof event.toolCallId === "string" ? this.bindings.get(event.toolCallId) : undefined;
 		const observation = observeToolResult(event, budget, {

package/external/pi-tools-suite/src/context-gateway/types.ts

@@ -10,10 +10,17 @@ export interface ContextGatewayBudgets {
 	maxSearchMatches: number;
 }
 
+export interface ContextGatewayAccountingLogConfig {
+	enabled: boolean;
+	maxBytes: number;
+	maxBackups: number;
+}
+
 /** Parsed layered config. `enforce` is selective and fail-open for unsupported result classes. */
 export interface ContextGatewayResolvedConfig {
 	mode: ContextGatewayMode;
 	budgets: ContextGatewayBudgets;
+	accountingLog: ContextGatewayAccountingLogConfig;
 	issues: string[];
 }
 
@@ -48,7 +55,7 @@ export interface ContextGatewayObservedView {
 }
 
 export interface ContextGatewayObservedDelivery {
-	representation: "passthrough" | "test-build-compact";
+	representation: "passthrough" | "test-build-compact" | "web-recoverable-compact";
 	contentBytes: number;
 	textBytes: number;
 }

package/external/pi-tools-suite/src/dcp/auto-compress-budget.ts

@@ -5,13 +5,32 @@ import {
   type AutoCompressionResult,
   type CreateAutoCompressionBlockOptions,
 } from "./auto-compress.js";
-import { canonicalMessageHash } from "./conversation-index.js";
+import { buildExactRangeMembership, canonicalMessageHash } from "./conversation-index.js";
 import { stableMessageKeys } from "./pruner-message-ids.js";
 import type { CompressionCandidate } from "./pruner-types.js";
 import type { DcpState } from "./state.js";
 
 const rejectedSources = new WeakMap<DcpState, { key: string; error: AutoCompressionBlockedError }>();
 const FINALIZATION_GRACE_MS = 1_000;
+const SUMMARY_DEADLINE_FRACTION = 0.75;
+
+function exactCandidateFingerprint(
+  options: CreateAutoCompressionBlockOptions,
+  candidate: CompressionCandidate,
+): { startId: string; endId: string; sourceMembers: Array<{ stableId: string; hash: string }> } | undefined {
+  const membership = buildExactRangeMembership(
+    options.state.conversationIndexSnapshot,
+    candidate.startId,
+    candidate.endId,
+    options.state,
+  );
+  if (!membership) return undefined;
+  return {
+    startId: candidate.startId,
+    endId: candidate.endId,
+    sourceMembers: membership.sourceMembers,
+  };
+}
 
 /**
  * A source-size estimate is not a net-savings estimate. Try the economical
@@ -25,14 +44,28 @@ export async function createBudgetedAutoCompressionBlock(
 ): Promise<AutoCompressionResult> {
   options.signal?.throwIfAborted();
   const epoch = options.state.sessionEpoch;
+  const primaryFingerprint = exactCandidateFingerprint(options, options.candidate);
+  const largestFingerprint = largestSafeCandidate
+    ? exactCandidateFingerprint(options, largestSafeCandidate)
+    : undefined;
+  // Rejection memoization belongs to the exact source that was rejected, not
+  // to the whole provider tail. A long-running agent can append unrelated
+  // messages while the oldest safe candidate stays byte-identical; hashing the
+  // whole tail made that same impossible candidate run again after every tool
+  // result. Fall back to the full-context identity only when exact membership
+  // is unavailable, so memoization never guesses source equivalence.
+  const sourceIdentity = primaryFingerprint && (!largestSafeCandidate || largestFingerprint)
+    ? { primary: primaryFingerprint, largest: largestFingerprint }
+    : {
+      source: options.messages.map(canonicalMessageHash),
+      ids: stableMessageKeys(options.messages),
+    };
   const key = createHash("sha256").update(JSON.stringify({
     epoch,
-    source: options.messages.map(canonicalMessageHash),
-    ids: stableMessageKeys(options.messages),
+    sourceIdentity,
     config: options.config,
     budget: options.requiredGainTokens ?? 0,
     allowPartialGain: options.allowPartialGain === true,
-    largest: largestSafeCandidate,
   })).digest("hex");
   const rejected = rejectedSources.get(options.state);
   if (rejected?.key === key) throw rejected.error;
@@ -41,6 +74,7 @@ export async function createBudgetedAutoCompressionBlock(
   const onAbort = () => controller.abort(options.signal?.reason);
   options.signal?.addEventListener("abort", onAbort, { once: true });
   const timeout = Math.max(1, options.config.compress.autoCompress.timeoutMs);
+	const summaryTimeoutMs = Math.max(1, Math.floor(timeout * SUMMARY_DEADLINE_FRACTION));
   // generateModelSummary owns the configured summarizer deadline and can
   // deliberately recover from it with the deterministic extractive fallback.
   // Keep a small bounded tail for that fallback and durable publication;
@@ -84,6 +118,7 @@ export async function createBudgetedAutoCompressionBlock(
           ...options,
           candidate: candidates[attempt]!,
           signal: controller.signal,
+		  summaryTimeoutMs,
         });
         rejectedSources.delete(options.state);
         return result;

package/external/pi-tools-suite/src/dcp/auto-compress.ts

@@ -16,7 +16,7 @@ import { createHash } from "node:crypto"
 import type { Model, Api, ProviderHeaders } from "@earendil-works/pi-ai"
 import { completeWithModelRegistry, type ModelCompletionRegistry } from "../model-completion.js"
 import type { DcpState } from "./state.js"
-import type { DcpConfig } from "./config.js"
+import { summarizerModelRefs, type DcpConfig } from "./config.js"
 import type { CompressionCandidate } from "./pruner-types.js"
 import { estimateMessageTokens, estimateTokens, stripStaleDcpMetadataLines } from "./pruner-metadata.js"
 import {
@@ -37,11 +37,19 @@ import { settleCompressionProgress } from "./compression-progress.js"
 
 export class AutoCompressionBlockedError extends Error {
 	readonly blockedReason: DcpBlockedReason
-
-	constructor(blockedReason: DcpBlockedReason, message: string) {
+	readonly summarizerFallbackUsed: boolean
+	readonly summarizerAttempts?: ModelSummaryAttempt[]
+
+	constructor(
+		blockedReason: DcpBlockedReason,
+		message: string,
+		details: { summarizerFallbackUsed?: boolean; summarizerAttempts?: ModelSummaryAttempt[] } = {},
+	) {
 		super(message)
 		this.name = "AutoCompressionBlockedError"
 		this.blockedReason = blockedReason
+		this.summarizerFallbackUsed = details.summarizerFallbackUsed === true
+		this.summarizerAttempts = details.summarizerAttempts
 	}
 }
 
@@ -828,12 +836,12 @@ export async function prepareCompressionSummary(options: {
 		fallbackCandidate,
 		sourceManifest,
 	)
-	if (!modelResult?.text && estimateTokens(text) > 8192) {
-		throw new AutoCompressionBlockedError(
-			"budget-exhausted",
-			"Extractive continuity minimum exceeds its 8192-token budget; no checkpoints were silently dropped",
-		)
-	}
+	// Do not impose a second, fixed output ceiling on the deterministic safety
+	// floor. A large source can legitimately require more than 8192 tokens to
+	// preserve every explicit continuity checkpoint. The auto-compression path
+	// already measures the actual replacement against the exact source and
+	// rejects non-positive/full-projection gain below, so compression economics
+	// — not an unrelated constant — decide whether this fallback is usable.
 	return {
 		text,
 		representation: modelResult?.text
@@ -881,6 +889,8 @@ export interface CreateAutoCompressionBlockOptions {
 	requiredGainTokens?: number
 	/** Allow a positive safe commit that reduces, but does not fully settle, the current recovery debt. */
 	allowPartialGain?: boolean
+	/** Optional model-summary sub-deadline. The outer budgeted operation may reserve time for deterministic fallback/publication. */
+	summaryTimeoutMs?: number
 	/** Optional durable publication hook. Live state is not changed unless it succeeds. */
   persistState?: (preparedState: DcpState, publication?: DcpJournalPublicationOptions) => Promise<void>
 	/** Optional pure projection preparation; included in the same durable generation. */
@@ -919,8 +929,9 @@ function createAutoCompressionWorkingState(state: DcpState): DcpState {
 
 /**
  * Create the auto-compression block. Selects the summary source based on
- * `config.compress.autoCompress.summarizerModel`: empty → programmatic digest;
- * non-empty → model summary with programmatic fallback. Then delegates block
+ * `config.compress.autoCompress.summarizerModel` plus explicit
+ * `summarizerFallbackModels`: empty → programmatic digest; non-empty → model
+ * summary with ordered model fallbacks, then programmatic fallback. Delegates block
  * creation to the shared `createRangeCompressionBlock` path so protected
  * content (user messages, tool outputs, prompt info) is handled identically to
  * a model-initiated compress.
@@ -991,8 +1002,8 @@ export async function createAutoCompressionBlock(
 		topic,
 		messages: messagesInRange,
 		candidate: effectiveCandidate,
-		modelRefs: settings.summarizerModel,
-		timeoutMs: settings.timeoutMs,
+		modelRefs: summarizerModelRefs(settings),
+		timeoutMs: options.summaryTimeoutMs ?? settings.timeoutMs,
 		modelRegistry,
 		signal,
 	})
@@ -1065,11 +1076,16 @@ export async function createAutoCompressionBlock(
 	const sourceExactEstimate = messagesInRange.reduce((sum, message) => sum + estimateMessageTokens(message), 0)
 	const replacementExactEstimate = estimateCompressionBlockReplacementTokens(created.block)
 	const projectedGain = sourceExactEstimate - replacementExactEstimate
+	const blockedSummaryDetails = {
+		summarizerFallbackUsed: preparedSummary.representation === "extractive-fallback",
+		summarizerAttempts: preparedSummary.summarizerAttempts,
+	}
 	if (projectedGain <= 0) {
 		throw new AutoCompressionBlockedError(
 			"non-positive-gain",
 			`Auto-compress rejected non-positive full-projection gain for ${effectiveCandidate.startId}..${effectiveCandidate.endId}: ` +
 			`source ${sourceExactEstimate} tokens, replacement ${replacementExactEstimate} tokens`,
+			blockedSummaryDetails,
 		)
 	}
 	const requiredGainTokens = Math.max(0, Math.floor(options.requiredGainTokens ?? 0))
@@ -1078,6 +1094,7 @@ export async function createAutoCompressionBlock(
 			"budget-exhausted",
 			`Auto-compress projected gain for ${effectiveCandidate.startId}..${effectiveCandidate.endId} is below required budget recovery: ` +
 			`${projectedGain} < ${requiredGainTokens} tokens`,
+			blockedSummaryDetails,
 		)
 	}
 
@@ -1089,12 +1106,22 @@ export async function createAutoCompressionBlock(
 		fullProjectedAfterTokens = finalProjection.reduce((sum, message) => sum + estimateMessageTokens(message), 0)
 		fullProjectionGain = fullBefore - fullProjectedAfterTokens
 		if (fullProjectionGain <= 0 || (fullProjectionGain < requiredGainTokens && !options.allowPartialGain)) {
-			throw new AutoCompressionBlockedError("budget-exhausted", `Final provider projection saves ${fullProjectionGain}, below required ${requiredGainTokens}; no state published`)
+			throw new AutoCompressionBlockedError(
+				"budget-exhausted",
+				`Final provider projection saves ${fullProjectionGain}, below required ${requiredGainTokens}; no state published`,
+				blockedSummaryDetails,
+			)
 		}
 	}
 	const pressureRelieved = workingState.compressionProgress
 		? settleCompressionProgress(workingState, fullProjectionGain, fullProjectedAfterTokens)
 		: true
+	created.block.commitMetrics = {
+		operationId: `auto:${created.block.id}`,
+		kind: effectiveCandidate.includedBlockIds.length >= 2 && sourceCoverage.itemCount === effectiveCandidate.includedBlockIds.length ? "consolidation" : "auto",
+		beforeTokens: fullProjectedAfterTokens + fullProjectionGain,
+		afterTokens: fullProjectedAfterTokens, netGainTokens: fullProjectionGain,
+	}
 	assertCurrent()
 	let published = false
 	if (options.persistState) await options.persistState(workingState, {