pi-ui-extend 1.0.41 → 1.0.45

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

@@ -1,6 +1,6 @@
 export type ContextGatewayMode = "off" | "observe" | "enforce";
 
-export type ContextGatewayEffectiveMode = Exclude<ContextGatewayMode, "enforce">;
+export type ContextGatewayEffectiveMode = ContextGatewayMode;
 
 export interface ContextGatewayBudgets {
 	maxInlineBytes: number;
@@ -10,10 +10,17 @@ export interface ContextGatewayBudgets {
 	maxSearchMatches: number;
 }
 
-/** Parsed layered config. `enforce` remains a valid requested value so doctor can refuse it explicitly. */
+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";
+	representation: "passthrough" | "test-build-compact" | "web-recoverable-compact";
 	contentBytes: number;
 	textBytes: number;
 }
@@ -81,11 +88,13 @@ export interface ContextGatewayObservation {
 	version: 1;
 	toolClass: ContextGatewayToolClass;
 	outcome: ContextGatewayExecutionOutcome;
+	budgetBytes: number;
 	source: ContextGatewayObservedSource;
 	view: ContextGatewayObservedView;
 	delivery: ContextGatewayObservedDelivery;
 	overBudget: boolean;
 	potentialBytesOverBudget: number;
+	actualBytesSaved: number;
 	testOutput?: ContextGatewayTestOutputObservation;
 }
 
@@ -93,12 +102,15 @@ export interface ContextGatewayClassTelemetry {
 	results: number;
 	errors: number;
 	contentBytes: number;
+	deliveredContentBytes: number;
 	textBytes: number;
 	imageBytes: number;
 	detailsBytes: number;
 	upstreamTruncatedResults: number;
 	overBudgetResults: number;
 	potentialBytesOverBudget: number;
+	enforcedResults: number;
+	actualBytesSaved: number;
 }
 
 export type ContextGatewayNativePolicyReason =
@@ -134,6 +146,7 @@ export interface ContextGatewayTelemetrySnapshot extends ContextGatewayClassTele
 	pendingCalls: number;
 	unboundResults: number;
 	repeatCandidateCount: number;
+	sameSourceDifferentRangeCount: number;
 	retrievalCalls: number;
 	nativePolicy: ContextGatewayNativePolicyTelemetry;
 	testOutput: ContextGatewayTestOutputTelemetry;

package/external/pi-tools-suite/src/context-inventory.ts

@@ -0,0 +1,99 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	currentModelRef,
+	filterSubagentConfigForParentModel,
+	loadSubagentConfig,
+} from "./async-subagents/lib.js";
+import { publishRpcSessionState } from "./lib/rpc-session-state.js";
+
+export const CONTEXT_INVENTORY_EVENT = "pi-tools-suite:context-inventory";
+
+export interface ContextInventoryState {
+	version: 1;
+	reason?: "startup" | "reload" | "new" | "resume" | "fork" | "model_select";
+	sessionId?: string;
+	sessionFile?: string;
+	model?: string;
+	thinking?: string;
+	tools: string[];
+	skills: string[];
+	agents?: string[];
+}
+
+export function createContextInventoryState(
+	pi: Pick<ExtensionAPI, "getActiveTools" | "getCommands">,
+	ctx: Pick<ExtensionContext, "cwd" | "model" | "sessionManager">,
+	reason?: ContextInventoryState["reason"],
+): ContextInventoryState {
+	const tools = unique(pi.getActiveTools());
+	const skillsReadable = tools.includes("read") || tools.includes("bash");
+	const skills = skillsReadable
+		? unique(pi.getCommands()
+			.filter((command) => command.source === "skill")
+			.map((command) => command.name.replace(/^skill:/u, "")))
+			.sort(compareText)
+		: [];
+	const model = currentModelRef(ctx.model);
+	const thinking = typeof (ctx as { thinkingLevel?: unknown }).thinkingLevel === "string"
+		? (ctx as { thinkingLevel?: string }).thinkingLevel?.trim() || undefined
+		: undefined;
+	const agents = tools.includes("subagents") ? effectiveAgentTypes(ctx.cwd, model) : [];
+	const sessionId = safeSessionId(ctx.sessionManager);
+	const sessionFile = safeSessionFile(ctx.sessionManager);
+	return {
+		version: 1,
+		...(reason ? { reason } : {}),
+		...(sessionId ? { sessionId } : {}),
+		...(sessionFile ? { sessionFile } : {}),
+		...(model ? { model } : {}),
+		...(thinking ? { thinking } : {}),
+		tools,
+		skills,
+		...(agents === undefined ? {} : { agents }),
+	};
+}
+
+export function publishContextInventoryState(
+	pi: ExtensionAPI,
+	ctx: ExtensionContext,
+	reason?: ContextInventoryState["reason"],
+): void {
+	const state = createContextInventoryState(pi, ctx, reason);
+	pi.events?.emit?.(CONTEXT_INVENTORY_EVENT, state);
+	publishRpcSessionState(ctx, CONTEXT_INVENTORY_EVENT, state);
+}
+
+function effectiveAgentTypes(cwd: string, model: string | undefined): string[] | undefined {
+	try {
+		const config = filterSubagentConfigForParentModel(loadSubagentConfig(cwd), model);
+		return Object.keys(config.types).sort(compareText);
+	} catch {
+		return undefined;
+	}
+}
+
+function safeSessionId(sessionManager: ExtensionContext["sessionManager"]): string | undefined {
+	try {
+		const sessionId = sessionManager.getSessionId();
+		return sessionId?.trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function safeSessionFile(sessionManager: ExtensionContext["sessionManager"]): string | undefined {
+	try {
+		const sessionFile = sessionManager.getSessionFile();
+		return sessionFile?.trim() || undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function unique(values: readonly string[]): string[] {
+	return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+
+function compareText(left: string, right: string): number {
+	return left.localeCompare(right);
+}

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
+	readonly summarizerFallbackUsed: boolean
+	readonly summarizerAttempts?: ModelSummaryAttempt[]
 
-	constructor(blockedReason: DcpBlockedReason, message: string) {
+	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
 	}
 }
 
@@ -775,6 +783,80 @@ export async function generateModelSummary(
 	return { attempts }
 }
 
+export interface PreparedCompressionSummary {
+	text: string
+	representation: "model" | "extractive" | "extractive-fallback"
+	sourceManifest: SummarySourceItem[]
+	sourceHash: string
+	sourceCoverage: SummarySourceCoverage
+	summarizerModelRef?: string
+	summarizerAttempts?: ModelSummaryAttempt[]
+}
+
+/**
+ * Shared summary preparation for automatic and explicit compression. The
+ * configured model chain is attempted first; if it is absent/unavailable the
+ * deterministic extractive continuation record is the safety floor.
+ */
+export async function prepareCompressionSummary(options: {
+	topic: string
+	messages: any[]
+	candidate?: CompressionCandidate
+	modelRefs: string[]
+	timeoutMs: number
+	modelRegistry?: ModelSummaryRegistry
+	signal?: AbortSignal
+	sourceManifest?: SummarySourceItem[]
+}): Promise<PreparedCompressionSummary> {
+	options.signal?.throwIfAborted()
+	const sourceManifest = options.sourceManifest ?? buildSummarySourceManifest(options.messages)
+	let modelResult: ModelSummaryResult | undefined
+	if (options.modelRefs.length > 0) {
+		modelResult = await generateModelSummary(
+			options.modelRefs,
+			options.modelRegistry,
+			options.signal,
+			options.topic,
+			options.messages,
+			options.timeoutMs,
+			sourceManifest,
+		)
+		options.signal?.throwIfAborted()
+	}
+	const fallbackCandidate = options.candidate ?? {
+		startId: "generated",
+		endId: "generated",
+		messageCount: sourceManifest.length,
+		estimatedTokens: options.messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0),
+		includedBlockIds: [],
+		reason: "explicit/generated summary source",
+	}
+	const text = modelResult?.text ?? buildExtractiveSummary(
+		options.topic,
+		fallbackCandidate,
+		sourceManifest,
+	)
+	// 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
+			? "model"
+			: options.modelRefs.length > 0
+				? "extractive-fallback"
+				: "extractive",
+		sourceManifest,
+		sourceHash: hashSummarySourceManifest(sourceManifest),
+		sourceCoverage: summarySourceCoverage(sourceManifest),
+		summarizerModelRef: modelResult?.usedModelRef,
+		summarizerAttempts: modelResult?.attempts.length ? modelResult.attempts : undefined,
+	}
+}
+
 function extractAssistantText(result: any): string | undefined {
 	const content = result?.content
 	if (!Array.isArray(content)) return undefined
@@ -807,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. */
@@ -845,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.
@@ -913,48 +998,26 @@ export async function createAutoCompressionBlock(
 		}
 	}
 
-	// Summary source selection. `summaryMode` distinguishes three cases so the
-	// DCP debug log can tell a real model summary from a programmatic fallback
-	// caused by summarizer failure:
-	//   - "model": a configured model produced the summary.
-	//   - "programmatic": no summarizer models configured (floor by design).
-	//   - "programmatic_fallback": models were configured but all failed/empty.
-	const sourceManifest = buildSummarySourceManifest(messagesInRange)
-	let summary = ""
-	let summaryMode: "programmatic" | "model" | "programmatic_fallback" = "programmatic"
-	let summarizerModelRef: string | undefined
-	let summarizerAttempts: ModelSummaryAttempt[] | undefined
-
-	const modelRefs = settings.summarizerModel
-	if (modelRefs.length > 0) {
-		const modelResult = await generateModelSummary(
-			modelRefs,
-			modelRegistry,
-			signal,
-			topic,
-			messagesInRange,
-			settings.timeoutMs,
-			sourceManifest,
-		)
-		assertCurrent()
-		summarizerAttempts = modelResult.attempts.length > 0 ? modelResult.attempts : undefined
-		if (modelResult.text) {
-			summary = modelResult.text
-			summaryMode = "model"
-			summarizerModelRef = modelResult.usedModelRef
-		} else {
-			// All configured models failed or returned empty — fall back to the
-			// programmatic digest, but mark the mode distinctly so the fallback
-			// is visible in DCP debug logs.
-			summaryMode = "programmatic_fallback"
-		}
-	}
-	if (!summary) {
-		summary = buildExtractiveSummary(topic, effectiveCandidate, sourceManifest)
-		if (estimateTokens(summary) > 8192) {
-			throw new AutoCompressionBlockedError("budget-exhausted", "Extractive continuity minimum exceeds its 8192-token budget; no checkpoints were silently dropped")
-		}
-	}
+	const preparedSummary = await prepareCompressionSummary({
+		topic,
+		messages: messagesInRange,
+		candidate: effectiveCandidate,
+		modelRefs: summarizerModelRefs(settings),
+		timeoutMs: options.summaryTimeoutMs ?? settings.timeoutMs,
+		modelRegistry,
+		signal,
+	})
+	assertCurrent()
+	const summary = preparedSummary.text
+	const sourceManifest = preparedSummary.sourceManifest
+	const summaryMode: "programmatic" | "model" | "programmatic_fallback" =
+		preparedSummary.representation === "model"
+			? "model"
+			: preparedSummary.representation === "extractive-fallback"
+				? "programmatic_fallback"
+				: "programmatic"
+	const summarizerModelRef = preparedSummary.summarizerModelRef
+	const summarizerAttempts = preparedSummary.summarizerAttempts
 
 	const workingState = createAutoCompressionWorkingState(state)
 	const anchor = resolveAnchorBoundary(endTimestamp, workingState, endBoundary.stableId)
@@ -1004,8 +1067,8 @@ export async function createAutoCompressionBlock(
 		: summaryMode === "programmatic_fallback"
 			? "extractive-fallback"
 			: "extractive"
-	const sourceHash = hashSummarySourceManifest(sourceManifest)
-	const sourceCoverage = summarySourceCoverage(sourceManifest)
+	const sourceHash = preparedSummary.sourceHash
+	const sourceCoverage = preparedSummary.sourceCoverage
 	created.block.autoSummaryRepresentation = summaryRepresentation
 	created.block.sourceHash = sourceHash
 	created.block.sourceCoverage = sourceCoverage
@@ -1013,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))
@@ -1026,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,
 		)
 	}
 
@@ -1037,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, {