@herbertgao/pi-extensions 2026.9.19 → 2026.10.0

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/economics.ts

@@ -9,6 +9,8 @@ export type CompactionEconomics = {
 	readonly windowReserveTokens: number;
 	readonly firstCompactionRequestScale: number;
 	readonly subsequentCompactionMargin: number;
+	/** Minimum provider requests since the last compaction before economics may compact again. */
+	readonly minimumRequestsSinceCompaction: number;
 };
 
 export const DEFAULT_COMPACTION_ECONOMICS: CompactionEconomics = Object.freeze({
@@ -17,6 +19,7 @@ export const DEFAULT_COMPACTION_ECONOMICS: CompactionEconomics = Object.freeze({
 	windowReserveTokens: 16_384,
 	firstCompactionRequestScale: 2,
 	subsequentCompactionMargin: 1.5,
+	minimumRequestsSinceCompaction: 2,
 });
 
 export type CompactionReason =
@@ -25,6 +28,7 @@ export type CompactionReason =
 	| "deferred_economic"
 	| "deferred_subsequent_margin"
 	| "deferred_carried_debt"
+	| "deferred_post_compaction_cooldown"
 	| "horizon_unavailable"
 	| "cache_ratio_unavailable"
 	| "native_not_compactable"
@@ -44,6 +48,8 @@ export type CompactionDecision = {
 	readonly writeTokens: number;
 	readonly archiveTokens: number;
 	readonly memoTokens: number;
+	/** Estimated context written after compaction, including the replacement memo. */
+	readonly postCompactionTokens: number;
 	readonly contextTokens: number;
 	readonly completedBoundaryRequestCounts: readonly number[] | null;
 	readonly requestsPerBoundaryMean: number | null;
@@ -58,6 +64,7 @@ export type CompactionDecision = {
 	readonly cacheWriteReadRatio: number | null;
 	readonly incrementalCacheCostRatio: number | null;
 	readonly priorCompactionCount: number;
+	readonly requestsSinceLastCompaction: number | null;
 	readonly carriedDebtTokens: number;
 	readonly cacheDebtRepaymentTokens: number;
 	readonly compact: boolean;
@@ -129,6 +136,8 @@ export function decideCompaction(input: {
 	readonly averageContextTokenIncrement: number | null;
 	readonly contextWindowTokens: number | null;
 	readonly priorCompactionCount: number;
+	/** Provider requests since the last compaction; null when never compacted. */
+	readonly requestsSinceLastCompaction?: number | null;
 	readonly carriedDebtTokens: number;
 	readonly cacheDebtRepaymentTokens: number;
 	readonly cacheWriteReadRatio: number | null;
@@ -147,15 +156,16 @@ export function decideCompaction(input: {
 					averageContextTokenIncrement: input.averageContextTokenIncrement,
 				});
 	const savingTokens = input.archiveTokens - input.memoTokens;
+	const postCompactionTokens = Math.max(0, input.writeTokens - savingTokens);
 	const incrementalCacheCostRatio =
 		input.cacheWriteReadRatio === null ? null : Math.max(0, input.cacheWriteReadRatio - 1);
+	const newDebtTokens = postCompactionTokens * (incrementalCacheCostRatio ?? 0);
 	const breakevenRequests =
-		savingTokens > 0 && incrementalCacheCostRatio !== null
-			? (input.writeTokens * incrementalCacheCostRatio) / savingTokens
-			: null;
+		savingTokens > 0 && incrementalCacheCostRatio !== null ? newDebtTokens / savingTokens : null;
+	const combinedRepaymentTokens = input.cacheDebtRepaymentTokens + savingTokens;
 	const combinedBreakevenRequests =
-		savingTokens > 0 && incrementalCacheCostRatio !== null
-			? (input.carriedDebtTokens + input.writeTokens * incrementalCacheCostRatio) / savingTokens
+		savingTokens > 0 && incrementalCacheCostRatio !== null && combinedRepaymentTokens > 0
+			? (input.carriedDebtTokens + newDebtTokens) / combinedRepaymentTokens
 			: null;
 	const firstCompaction = input.priorCompactionCount === 0;
 	const effectiveHorizonRequests =
@@ -193,12 +203,19 @@ export function decideCompaction(input: {
 		combinedBreakevenRequests <= horizon.expectedRemainingRequests;
 	const economic = firstCompaction ? firstEconomic : baseEconomic && subsequentMarginOpen && carriedDebtGateOpen;
 	const compressible = savingTokens > 0;
-	const compact = compressible && (windowProtection || economic);
+	const cooldownActive =
+		input.requestsSinceLastCompaction !== null &&
+		input.requestsSinceLastCompaction !== undefined &&
+		input.requestsSinceLastCompaction < input.economics.minimumRequestsSinceCompaction;
+	// Window protection stays absolute: near the context limit, compact even in cooldown.
+	const economicAllowed = economic && !cooldownActive;
+	const compact = compressible && (windowProtection || economicAllowed);
 
 	return {
 		writeTokens: input.writeTokens,
 		archiveTokens: input.archiveTokens,
 		memoTokens: input.memoTokens,
+		postCompactionTokens,
 		contextTokens: input.contextTokens,
 		...(horizon ?? {
 			completedBoundaryRequestCounts: null,
@@ -215,13 +232,16 @@ export function decideCompaction(input: {
 		cacheWriteReadRatio: input.cacheWriteReadRatio,
 		incrementalCacheCostRatio,
 		priorCompactionCount: input.priorCompactionCount,
+		requestsSinceLastCompaction: input.requestsSinceLastCompaction ?? null,
 		carriedDebtTokens: input.carriedDebtTokens,
 		cacheDebtRepaymentTokens: input.cacheDebtRepaymentTokens,
 		compact,
 		reason: compressible
 			? windowProtection
 				? "window_protection"
-				: economic
+				: economic && cooldownActive
+					? "deferred_post_compaction_cooldown"
+					: economic
 					? "economic"
 					: horizon === null
 						? "horizon_unavailable"

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/extension.ts

@@ -4,7 +4,6 @@
  */
 import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import {
-	buildSessionContext,
 	estimateTokens,
 	findCutPoint,
 	sessionEntryToContextMessages,
@@ -20,11 +19,13 @@ import {
 	type CompactionDecision,
 } from "./economics.ts";
 import { analyzePlanTransition, formatPlanSnapshot, parsePlanSteps } from "./plan.ts";
+import { projectedEntryTokens } from "./projection.ts";
 import {
 	appendOnlineState,
 	initialOnlineState,
 	recordBoundary,
 	recordCompaction,
+	recordCompletedPlanHandoff,
 	recordCorrection,
 	recordProviderRequest,
 	restoreOnlineState,
@@ -39,7 +40,17 @@ export const BOUNDARY_COMPACTION_INSTRUCTIONS =
 	"Preserve completed work, verification results, important decisions, and remaining work.";
 export const POST_COMPACTION_PLAN_REMINDER =
 	"Online context compaction finished. The parent task is still active. " +
-	"Before continuing work, call update_plan with a fresh plan for the remaining work.";
+	"Continue the remaining work from the current plan. Preserve existing step IDs when updating progress.";
+export const SKIPPED_COMPACTION_REMINDER =
+	"Online context compaction was skipped. The existing context is still available. " +
+	"Continue the remaining work from the current plan.";
+// Pi rejects these before committing a replacement summary, so the current
+// context is still usable. Unknown errors and user cancellation remain distinct.
+const RECOVERABLE_COMPACTION_ERRORS = new Set([
+	"Nothing to compact (session too small)",
+	"Already compacted",
+	"Summarization failed: generation hit the token cap and the summary is incomplete",
+]);
 
 export type OnlineContextCompactOptions = {
 	readonly cacheWriteReadRatio?: number | null;
@@ -49,6 +60,11 @@ export type OnlineContextCompactOptions = {
 type PendingBoundary = { readonly toolCallId: string };
 type SelectedCompaction = { readonly decision: CompactionDecision };
 type CacheDebt = { readonly debtTokens: number; readonly repaymentTokens: number };
+type PendingContinuation = { readonly promise: Promise<void>; readonly resolve: () => void };
+
+function releaseParentContinuation(continuation: PendingContinuation | undefined): void {
+	if (continuation) setTimeout(continuation.resolve, 0);
+}
 
 const SUBAGENTS_MANAGER_KEY = Symbol.for("pi-subagents:manager");
 
@@ -100,13 +116,24 @@ function progressSummary(input: PlanUpdateInput, completedStepId: string): Progr
 	};
 }
 
-function compactionMessageCount(entries: readonly SessionEntry[], startIndex: number, endIndex: number): number {
-	let count = 0;
+function compactionTokenEstimate(
+	entries: readonly SessionEntry[],
+	startIndex: number,
+	endIndex: number,
+	projected?: ReadonlyMap<string, number>,
+): number {
+	let tokens = 0;
 	for (let index = startIndex; index < endIndex; index++) {
 		const entry = entries[index];
-		if (entry && entry.type !== "compaction" && sessionEntryToContextMessages(entry).length > 0) count++;
+		if (!entry || entry.type === "compaction") continue;
+		if (projected) {
+			tokens += projected.get(entry.id) ?? 0;
+			continue;
+		}
+		const message = sessionEntryToContextMessages(entry)[0];
+		if (message) tokens += estimateTokens(message);
 	}
-	return count;
+	return tokens;
 }
 
 function branchAfterAbort(entries: readonly SessionEntry[]): SessionEntry[] {
@@ -140,25 +167,33 @@ function branchAfterAbort(entries: readonly SessionEntry[]): SessionEntry[] {
 	];
 }
 
-function nativeCompactionFeasible(entries: readonly SessionEntry[], keepRecentTokens: number): boolean {
+export function estimateNativeCompactionTokens(
+	entries: readonly SessionEntry[],
+	keepRecentTokens: number,
+	projectedMessages?: readonly AgentMessage[],
+): number {
 	const path = branchAfterAbort(entries);
+	const projected = projectedMessages === undefined ? undefined : projectedEntryTokens(entries, projectedMessages);
 	let startIndex = 0;
+	let previousSummaryTokens = 0;
 	for (let index = path.length - 1; index >= 0; index--) {
 		const entry = path[index];
 		if (entry?.type !== "compaction") continue;
 		const keptIndex = path.findIndex((item) => item.id === entry.firstKeptEntryId);
 		startIndex = keptIndex >= 0 ? keptIndex : index + 1;
+		const previousSummary = sessionEntryToContextMessages(entry)[0];
+		previousSummaryTokens = projected
+			? projected.get(entry.id) ?? 0
+			: previousSummary ? estimateTokens(previousSummary) : 0;
 		break;
 	}
 
+	// Keep Pi's native cut on session entries; price only the corresponding
+	// messages that the provider actually saw after context projection.
 	const cut = findCutPoint(path, startIndex, path.length, keepRecentTokens);
-	const historyEnd = cut.isSplitTurn ? cut.turnStartIndex : cut.firstKeptEntryIndex;
-	const historyMessages = historyEnd > startIndex ? compactionMessageCount(path, startIndex, historyEnd) : 0;
-	const prefixMessages =
-		cut.isSplitTurn && cut.turnStartIndex >= 0
-			? compactionMessageCount(path, cut.turnStartIndex, cut.firstKeptEntryIndex)
-			: 0;
-	return historyMessages > 0 || prefixMessages > 0;
+	const firstKept = cut.firstKeptEntryIndex;
+	if (compactionTokenEstimate(path, startIndex, firstKept) === 0) return 0;
+	return previousSummaryTokens + compactionTokenEstimate(path, startIndex, firstKept, projected);
 }
 
 function validPositiveInteger(value: unknown): value is number {
@@ -209,18 +244,26 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 		let activeDebt: CacheDebt | undefined;
 		let compactionInFlight = false;
 		let compactionThinkingOverride: CompactionThinkingOverride | undefined;
+		let nextContinuation: PendingContinuation | undefined;
+		let compactionRefused = false;
+
+		const releaseContinuation = (): void => {
+			const continuation = nextContinuation;
+			nextContinuation = undefined;
+			continuation?.resolve();
+		};
 
 		const restore = (context: ExtensionContext): void => {
+			releaseContinuation();
 			state = restoreOnlineState(context.sessionManager.getBranch());
 			restored = true;
-			observedMessages = buildSessionContext(
-				context.sessionManager.getEntries(),
-				context.sessionManager.getLeafId(),
-			).messages;
+			// Restoring raw history is not evidence of a provider-visible projection.
+			observedMessages = [];
 			pendingBoundary = undefined;
 			selected = undefined;
 			activeDebt = undefined;
 			compactionInFlight = false;
+			compactionRefused = false;
 		};
 		const ensureRestored = (context: ExtensionContext): void => {
 			if (!restored) restore(context);
@@ -245,7 +288,7 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 				if (completedIds.length > 0) {
 					state = recordBoundary(state, steps, progressSummary(input, completedIds[0] ?? ""));
 					if (!pendingBoundary) pendingBoundary = { toolCallId: input.toolCallId };
-				} else if (JSON.stringify(state.plan) !== JSON.stringify(steps)) {
+				} else {
 					state = { ...state, plan: [...steps] };
 				}
 				save();
@@ -279,10 +322,16 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 		});
 
 		pi.on("input", (event, context) => {
+			compactionRefused = false;
+			ensureRestored(context);
 			if (event.streamingBehavior !== "steer" && !event.text.startsWith("CORRECTION:")) {
+				const next = recordCompletedPlanHandoff(state);
+				if (next !== state) {
+					state = next;
+					save();
+				}
 				return { action: "continue" as const };
 			}
-			ensureRestored(context);
 			pendingBoundary = undefined;
 			selected = undefined;
 			activeDebt = undefined;
@@ -292,9 +341,12 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 		});
 
 		pi.on("turn_end", (event, context) => {
+			// Plan chatter cannot make a rejected compact feasible. Require actual
+			// tool work or new user input before attempting another boundary.
+			if (event.toolResults.some((item) => item.toolName !== "update_plan" && !item.isError)) compactionRefused = false;
 			const boundary = pendingBoundary;
 			pendingBoundary = undefined;
-			if (!boundary || selected || hasRunningSubagents()) return;
+			if (!boundary || selected || compactionRefused || hasRunningSubagents()) return;
 			const toolResult = event.toolResults.find((item) => item.toolCallId === boundary.toolCallId);
 			if (
 				event.message.role !== "assistant" ||
@@ -309,8 +361,11 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 
 			const usage = context.getContextUsage();
 			const writeTokens = contextTokens(context);
-			const fixedTokens = tokenEstimate(context.getSystemPrompt());
-			const archiveTokens = Math.max(0, writeTokens - fixedTokens - keepRecentTokens);
+			const archiveTokens = estimateNativeCompactionTokens(
+				context.sessionManager.getBranch(),
+				keepRecentTokens,
+				observedMessages,
+			);
 			const contextWindowTokens = validPositiveInteger(usage?.contextWindow)
 				? usage.contextWindow
 				: validPositiveInteger(context.model?.contextWindow)
@@ -330,13 +385,17 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 				averageContextTokenIncrement,
 				contextWindowTokens,
 				priorCompactionCount: state.nativeCompactionCount,
+				requestsSinceLastCompaction:
+					state.lastCompactionRequestCount === null
+						? null
+						: state.requestCount - state.lastCompactionRequestCount,
 				carriedDebtTokens: state.cacheDebtTokens,
 				cacheDebtRepaymentTokens: state.cacheDebtRepaymentTokens,
 				cacheWriteReadRatio,
 				economics: DEFAULT_COMPACTION_ECONOMICS,
 			});
 			const decision: CompactionDecision =
-				priced.compact && !nativeCompactionFeasible(context.sessionManager.getBranch(), keepRecentTokens)
+				priced.compact && archiveTokens === 0
 					? { ...priced, compact: false, reason: "native_not_compactable" }
 					: priced;
 			if (!decision.compact) return;
@@ -346,16 +405,24 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 		});
 
 		pi.on("agent_settled", async (_event, context) => {
+			// Older hosts start a continuation synchronously; newer hosts defer it
+			// until settled handlers return. Preserve both print-mode barriers.
+			const parentContinuation = nextContinuation;
+			nextContinuation = undefined;
 			const pending = selected;
 			selected = undefined;
 			if (!context.isIdle()) {
 				selected = pending;
+				nextContinuation = parentContinuation;
+				return;
+			}
+			if (!pending || hasRunningSubagents()) {
+				releaseParentContinuation(parentContinuation);
 				return;
 			}
-			if (!pending || hasRunningSubagents()) return;
 
 			activeDebt = {
-				debtTokens: pending.decision.writeTokens * (pending.decision.incrementalCacheCostRatio ?? 0),
+				debtTokens: pending.decision.postCompactionTokens * (pending.decision.incrementalCacheCostRatio ?? 0),
 				repaymentTokens: Math.max(0, pending.decision.archiveTokens - pending.decision.memoTokens),
 			};
 			let compacted = false;
@@ -391,6 +458,7 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 							}
 						},
 						onError: (error) => {
+							activeDebt = undefined;
 							compactionError = error;
 							finish();
 						},
@@ -399,36 +467,66 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 				restoreCompactionThinking(pi, compactionThinkingOverride);
 				compactionThinkingOverride = undefined;
 				compactionInFlight = false;
+				const recoverableError = compactionError !== undefined && RECOVERABLE_COMPACTION_ERRORS.has(compactionError.message);
 				if (
 					compactionError &&
+					!recoverableError &&
 					compactionError.name !== "AbortError" &&
 					compactionError.message !== "Compaction cancelled"
 				) {
 					throw compactionError;
 				}
 
-				if (compacted) {
-					// Pi >=0.87 defers this turn until agent_settled handlers finish and
-					// awaits it before prompt() resolves, so print/JSON mode stays alive.
-					pi.sendMessage(
-						{
-							customType: "sol-pi-online-context-compact",
-							content: POST_COMPACTION_PLAN_REMINDER,
-							display: false,
-						},
-						{ triggerTurn: true },
-					);
+				if (recoverableError) {
+					compactionRefused = true;
+					pi.appendEntry("sol-pi-online-context-compact-skipped", { reason: compactionError!.message });
+					if (context.mode === "tui") context.ui.notify(`Online compaction skipped: ${compactionError!.message}`, "warning");
+				}
+				if (compacted || recoverableError) {
+					let resolveContinuation!: () => void;
+					const continuation: PendingContinuation = {
+						promise: new Promise<void>((resolve) => {
+							resolveContinuation = resolve;
+						}),
+						resolve: () => resolveContinuation(),
+					};
+					nextContinuation = continuation;
+					try {
+						pi.sendMessage(
+							{
+								customType: "sol-pi-online-context-compact",
+								content: compacted ? POST_COMPACTION_PLAN_REMINDER : SKIPPED_COMPACTION_REMINDER,
+								display: false,
+							},
+							{ triggerTurn: true },
+						);
+					} catch (error) {
+						if (nextContinuation === continuation) nextContinuation = undefined;
+						continuation.resolve();
+						throw error;
+					}
+					if (context.isIdle() && nextContinuation === continuation) {
+						// Newer Pi hosts defer runs until settled handlers return. Hand
+						// control back to that host instead of waiting on a deferred run.
+						nextContinuation = undefined;
+						continuation.resolve();
+					} else {
+						// Pi 0.85.1 starts synchronously; keep its print-mode barrier.
+						await continuation.promise;
+					}
 				}
 			} finally {
 				restoreCompactionThinking(pi, compactionThinkingOverride);
 				compactionThinkingOverride = undefined;
 				compactionInFlight = false;
 				activeDebt = undefined;
+				releaseParentContinuation(parentContinuation);
 			}
 		});
 
 		pi.on("session_compact", (event, context) => {
 			ensureRestored(context);
+			compactionRefused = false;
 			state = recordCompaction(
 				state,
 				event.fromExtension || !activeDebt ? { debtTokens: 0, repaymentTokens: 0 } : activeDebt,
@@ -437,13 +535,11 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 			pendingBoundary = undefined;
 			selected = undefined;
 			activeDebt = undefined;
-			observedMessages = buildSessionContext(
-				context.sessionManager.getEntries(),
-				context.sessionManager.getLeafId(),
-			).messages;
+			observedMessages = [];
 		});
 
 		pi.on("session_shutdown", () => {
+			releaseContinuation();
 			restoreCompactionThinking(pi, compactionThinkingOverride);
 			compactionThinkingOverride = undefined;
 			pendingBoundary = undefined;

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/index.ts

@@ -19,6 +19,7 @@ export {
 	createOnlineContextCompactExtension,
 	DEFAULT_KEEP_RECENT_TOKENS,
 	DEFAULT_NATIVE_SUMMARY_TOKEN_ESTIMATE,
+	estimateNativeCompactionTokens,
 	POST_COMPACTION_PLAN_REMINDER,
 	type OnlineContextCompactOptions,
 	resolveKeepRecentTokens,

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/plan.ts

@@ -59,7 +59,8 @@ export function analyzePlanTransition(previous: readonly PlanStep[], next: reado
 
 	for (const step of next) {
 		const prior = previousById.get(step.id);
-		if ((!prior || prior.status !== "completed") && step.status === "completed") completedSteps.push(step);
+		// A newly introduced completed step establishes history, not a status transition.
+		if (prior && prior.status !== "completed" && step.status === "completed") completedSteps.push(step);
 		if (prior && prior.goal !== step.goal) {
 			advice.push(`Plan step ${JSON.stringify(step.id)} changed goal; reuse an id only for the same goal.`);
 		}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/projection.ts

@@ -0,0 +1,58 @@
+/*
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: MIT
+ */
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { estimateTokens, sessionEntryToContextMessages, type SessionEntry } from "@earendil-works/pi-coding-agent";
+
+/** ObservationPack changes tool-result content while preserving its call identity. */
+function messageKey(message: AgentMessage): string {
+	return message.role === "toolResult"
+		? `tool:${JSON.stringify([message.toolCallId, message.toolName, message.timestamp])}`
+		: JSON.stringify(message);
+}
+
+/** Map the last observed projection to source entries, without rerunning context hooks. */
+export function projectedEntryTokens(
+	entries: readonly SessionEntry[],
+	projected: readonly AgentMessage[],
+): ReadonlyMap<string, number> {
+	const lastCompaction = entries.findLastIndex((entry) => entry.type === "compaction");
+	let active = entries;
+	if (lastCompaction >= 0) {
+		const compaction = entries[lastCompaction];
+		if (compaction?.type === "compaction") {
+			const firstKept = entries.findIndex((entry) => entry.id === compaction.firstKeptEntryId);
+			active = [compaction, ...(firstKept >= 0 ? entries.slice(firstKept, lastCompaction) : []), ...entries.slice(lastCompaction + 1)];
+		}
+	}
+	const sources = new Map<string, string[]>();
+	for (const entry of active) {
+		if (entry.type === "compaction" && entry !== entries[lastCompaction]) continue;
+		for (const message of sessionEntryToContextMessages(entry)) {
+			const key = messageKey(message);
+			const ids = sources.get(key) ?? [];
+			ids.push(entry.id);
+			sources.set(key, ids);
+		}
+	}
+	const visible = new Map<string, number[]>();
+	for (const message of projected) {
+		const key = messageKey(message);
+		const sizes = visible.get(key) ?? [];
+		sizes.push(estimateTokens(message));
+		visible.set(key, sizes);
+	}
+	const tokens = new Map<string, number>();
+	for (const [key, ids] of sources) {
+		const sizes = visible.get(key);
+		// Dropped, rewritten, newly appended, or ambiguously duplicated messages
+		// provide no proven savings. Never fall back to their raw content size.
+		if (!sizes || sizes.length !== ids.length || (key.startsWith("tool:") && ids.length > 1)) continue;
+		for (let index = 0; index < ids.length; index++) {
+			const id = ids[index]!;
+			tokens.set(id, (tokens.get(id) ?? 0) + sizes[index]!);
+		}
+	}
+	return tokens;
+}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/state.ts

@@ -22,6 +22,8 @@ export type OnlineState = {
 	readonly plan: readonly PlanStep[];
 	readonly pendingProgress: readonly ProgressSummary[];
 	readonly requestCount: number;
+	/** requestCount when the last compaction ran; null before the first compaction. */
+	readonly lastCompactionRequestCount: number | null;
 	readonly lastBoundaryRequestCount: number;
 	readonly completedBoundaryRequestCounts: readonly number[];
 	readonly lastContextTokens: number | null;
@@ -39,6 +41,7 @@ export function initialOnlineState(): OnlineState {
 		plan: [],
 		pendingProgress: [],
 		requestCount: 0,
+		lastCompactionRequestCount: null,
 		lastBoundaryRequestCount: 0,
 		completedBoundaryRequestCounts: [],
 		lastContextTokens: null,
@@ -101,6 +104,8 @@ function parseOnlineState(value: unknown): OnlineState | undefined {
 		!completedBoundaryRequestCounts ||
 		!completedBoundaryRequestCounts.every(nonNegativeInteger) ||
 		!nonNegativeInteger(record.epoch) ||
+		(typeof record.lastCompactionRequestCount !== "undefined" &&
+			!(record.lastCompactionRequestCount === null || nonNegativeInteger(record.lastCompactionRequestCount))) ||
 		!nonNegativeInteger(record.requestCount) ||
 		!nonNegativeInteger(record.lastBoundaryRequestCount) ||
 		record.lastBoundaryRequestCount > record.requestCount ||
@@ -119,6 +124,7 @@ function parseOnlineState(value: unknown): OnlineState | undefined {
 		plan,
 		pendingProgress: pendingProgress as readonly ProgressSummary[],
 		requestCount: record.requestCount,
+		lastCompactionRequestCount: record.lastCompactionRequestCount ?? null,
 		lastBoundaryRequestCount: record.lastBoundaryRequestCount,
 		completedBoundaryRequestCounts: completedBoundaryRequestCounts as readonly number[],
 		lastContextTokens: record.lastContextTokens,
@@ -180,16 +186,16 @@ export function recordCompaction(
 	return {
 		...state,
 		epoch: state.epoch + 1,
-		// Keep the plan so the post-compaction rebuild does not reclassify
-		// already-completed steps as a new boundary.
+		// Preserve the plan and its progress samples. Compaction changes the
+		// context representation, not which steps have completed.
 		plan: [...state.plan],
+		lastCompactionRequestCount: state.requestCount,
 		pendingProgress: [],
+		// Do not compare context sizes across the replacement summary.
 		lastContextTokens: null,
-		positiveContextDeltaTotal: 0,
-		positiveContextDeltaCount: 0,
 		nativeCompactionCount: state.nativeCompactionCount + 1,
-		cacheDebtTokens: Math.max(0, debt.debtTokens),
-		cacheDebtRepaymentTokens: Math.max(0, debt.repaymentTokens),
+		cacheDebtTokens: state.cacheDebtTokens + Math.max(0, debt.debtTokens),
+		cacheDebtRepaymentTokens: state.cacheDebtRepaymentTokens + Math.max(0, debt.repaymentTokens),
 	};
 }
 
@@ -208,3 +214,19 @@ export function recordCorrection(state: OnlineState): OnlineState {
 		cacheDebtRepaymentTokens: 0,
 	};
 }
+
+/** A new user task must not inherit the completed task's request horizon. */
+export function recordCompletedPlanHandoff(state: OnlineState): OnlineState {
+	if (state.plan.length === 0 || state.plan.some((step) => step.status !== "completed")) return state;
+	return {
+		...state,
+		epoch: state.epoch + 1,
+		plan: [],
+		pendingProgress: [],
+		lastBoundaryRequestCount: state.requestCount,
+		completedBoundaryRequestCounts: [],
+		lastContextTokens: null,
+		positiveContextDeltaTotal: 0,
+		positiveContextDeltaCount: 0,
+	};
+}

package/node_modules/@herbertgao/sol-pi/src/sol-pi/extensions/online-context-compact/tools.ts

@@ -50,10 +50,11 @@ export function registerOnlineTools(pi: ExtensionAPI, handlers: OnlineToolHandle
 		name: "update_plan",
 		label: "Update plan",
 		description:
-			"Replace the complete working plan. A newly completed step becomes a safe point where SoL-Pi may compact context if doing so is economical.",
+			"Replace the complete working plan. Completing a previously registered unfinished step becomes a safe point where SoL-Pi may compact context if doing so is economical. Newly introduced completed steps are recorded as history.",
 		promptSnippet: "Keep the working plan current",
 		promptGuidelines: [
 			"Send the complete plan on every update_plan call.",
+			"Preserve step IDs and register unfinished steps before reporting their completion.",
 			"Keep at most one step in_progress and mark finished steps completed.",
 			"When completing a step, include concise progress evidence when available.",
 		],

package/node_modules/@herbertgao/sol-pi/src/sol-pi/runtime-paths.ts

@@ -3,15 +3,28 @@
  * SPDX-License-Identifier: MIT
  */
 
+import { mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 
+const temporaryRoots = new Map<string, string>();
+
 export function runtimeRoot(ctx: ExtensionContext): string {
 	const sessionDir = ctx.sessionManager.getSessionDir();
-	if (!sessionDir) throw new Error("SoL-Pi requires a persistent Pi session directory");
 	const sessionId = ctx.sessionManager.getSessionId();
 	if (!/^[a-z0-9][a-z0-9._-]*$/iu.test(sessionId)) {
 		throw new Error("SoL-Pi requires a safe Pi session id");
 	}
-	return join(sessionDir, "sol-pi", sessionId);
+	if (sessionDir) return join(sessionDir, "sol-pi", sessionId);
+
+	// --no-session and SDK in-memory sessions still need files for exact recall.
+	// Share the root across contexts and mechanisms, without sharing a predictable
+	// directory with other processes. Keep files after shutdown for parent workers.
+	let root = temporaryRoots.get(sessionId);
+	if (!root) {
+		root = mkdtempSync(join(tmpdir(), `sol-pi-${sessionId}-`));
+		temporaryRoots.set(sessionId, root);
+	}
+	return root;
 }