@herbertgao/sol-pi 0.2.0 → 0.3.0

package/docs/compatibility.md

@@ -21,7 +21,7 @@ Action Fusion decodes `file://` targets with Node's `fileURLToPath()` before res
 
 The queue covers only fused operations registered by this SoL-Pi instance. External processes, direct built-in-tool calls outside the replacement, and unrelated extensions are not globally locked. SoL-Pi hashes the target immediately before launching `then_run` and skips the command if it observes an intervening content change.
 
-When another extension already owns `write`, Action Fusion leaves that tool in place and only registers its `edit` replacement. When `pi-automode` exposes `automode_inspect`, Action Fusion registers neither mutation replacement: nested `then_run` cannot re-enter Pi's public `tool_call` permission pipeline, so disabling the fusion is the safe fallback.
+When another extension already owns `write`, Action Fusion leaves that tool in place and only registers its `edit` replacement.
 
 ## ObservationPack
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@herbertgao/sol-pi",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Token-efficient context and tool extensions for Pi, maintained from NVlabs/SoL-Pi.",
   "keywords": [
     "pi-package",

package/src/sol-pi/extensions/action-fusion/index.ts

@@ -80,11 +80,6 @@ export function createActionFusionExtension(options: ActionFusionOptions = {}):
 	const baseWrite = memoizeByCwd((cwd: string) => createWriteToolDefinition(cwd, options.writeOptions));
 
 	return (pi: ExtensionAPI) => {
-		// then_run executes Bash inside the mutation tool, so it cannot pass through
-		// Pi's public tool_call permission handlers. Leave it to automode instead of
-		// creating a nested shell escape hatch.
-		if (hasExternalToolOwner(pi, "automode_inspect")) return;
-
 		const editTemplate = baseEdit(process.cwd());
 		const writeTemplate = baseWrite(process.cwd());
 

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

@@ -218,9 +218,8 @@ export function decideCompaction(input: {
 		carriedDebtTokens: input.carriedDebtTokens,
 		cacheDebtRepaymentTokens: input.cacheDebtRepaymentTokens,
 		compact,
-		reason: !compressible
-			? "non_positive_saving"
-			: windowProtection
+		reason: compressible
+			? windowProtection
 				? "window_protection"
 				: economic
 					? "economic"
@@ -232,6 +231,7 @@ export function decideCompaction(input: {
 								? "deferred_subsequent_margin"
 								: !firstCompaction && baseEconomic && !carriedDebtGateOpen
 									? "deferred_carried_debt"
-									: "deferred_economic",
+									: "deferred_economic"
+			: "non_positive_saving",
 	};
 }

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

@@ -2,12 +2,13 @@
  * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: MIT
  */
-import type { AgentMessage, AgentToolResult } from "@earendil-works/pi-agent-core";
+import type { AgentMessage, AgentToolResult, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import {
 	buildSessionContext,
 	estimateTokens,
 	findCutPoint,
 	sessionEntryToContextMessages,
+	type ExtensionAPI,
 	type ExtensionContext,
 	type ExtensionFactory,
 	type SessionEntry,
@@ -165,6 +166,37 @@ function validPositiveInteger(value: unknown): value is number {
 	return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
 }
 
+type CompactionThinkingOverride = {
+	readonly previous: ThinkingLevel;
+	readonly applied: ThinkingLevel;
+};
+
+// Native summaries share their output cap with reasoning; reserve the cap for summary text.
+function lowerCompactionThinking(
+	pi: ExtensionAPI,
+	reasoning: boolean,
+): CompactionThinkingOverride | undefined {
+	if (!reasoning) return;
+	try {
+		const previous = pi.getThinkingLevel();
+		if (previous !== "high" && previous !== "xhigh" && previous !== "max") return;
+		pi.setThinkingLevel("medium");
+		const applied = pi.getThinkingLevel();
+		return applied === previous ? undefined : { previous, applied };
+	} catch {
+		return;
+	}
+}
+
+function restoreCompactionThinking(pi: ExtensionAPI, override: CompactionThinkingOverride | undefined): void {
+	if (!override) return;
+	try {
+		if (pi.getThinkingLevel() === override.applied) pi.setThinkingLevel(override.previous);
+	} catch {
+		// A compaction result must not be masked by a best-effort state restore.
+	}
+}
+
 function releaseParentContinuation(continuation: PendingContinuation | undefined): void {
 	if (continuation) setTimeout(continuation.resolve, 0);
 }
@@ -182,6 +214,7 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 		let activeDebt: CacheDebt | undefined;
 		let nextContinuation: PendingContinuation | undefined;
 		let compactionInFlight = false;
+		let compactionThinkingOverride: CompactionThinkingOverride | undefined;
 
 		const releaseContinuation = (): void => {
 			const continuation = nextContinuation;
@@ -349,6 +382,7 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 			let compactionError: Error | undefined;
 			try {
 				compactionInFlight = true;
+				compactionThinkingOverride = lowerCompactionThinking(pi, context.model?.reasoning === true);
 				await new Promise<void>((resolve) => {
 					let finished = false;
 					const finish = (): void => {
@@ -382,6 +416,8 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 						},
 					});
 				});
+				restoreCompactionThinking(pi, compactionThinkingOverride);
+				compactionThinkingOverride = undefined;
 				compactionInFlight = false;
 				if (
 					compactionError &&
@@ -422,6 +458,8 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 					await continuation.promise;
 				}
 			} finally {
+				restoreCompactionThinking(pi, compactionThinkingOverride);
+				compactionThinkingOverride = undefined;
 				compactionInFlight = false;
 				activeDebt = undefined;
 				releaseParentContinuation(parentContinuation);
@@ -445,6 +483,8 @@ export function createOnlineContextCompactExtension(options: OnlineContextCompac
 		});
 
 		pi.on("session_shutdown", () => {
+			restoreCompactionThinking(pi, compactionThinkingOverride);
+			compactionThinkingOverride = undefined;
 			releaseContinuation();
 			pendingBoundary = undefined;
 			selected = undefined;

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

@@ -180,7 +180,9 @@ export function recordCompaction(
 	return {
 		...state,
 		epoch: state.epoch + 1,
-		plan: [],
+		// Keep the plan so the post-compaction rebuild does not reclassify
+		// already-completed steps as a new boundary.
+		plan: [...state.plan],
 		pendingProgress: [],
 		lastContextTokens: null,
 		positiveContextDeltaTotal: 0,