@xynogen/pix-core 0.7.7 → 0.7.9

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-core",
-	"version": "0.7.7",
+	"version": "0.7.9",
 	"description": "Pi extension bundle \u2014 installs and activates all core pix-* extensions",
 	"type": "module",
 	"main": "src/extension.ts",
@@ -43,32 +43,32 @@
 		"access": "public"
 	},
 	"dependencies": {
-		"@xynogen/pix-runtime": "^0.14.0",
-		"@xynogen/pix-data": "^0.5.5",
-		"@xynogen/pix-pretty": "^1.32.0",
-		"@xynogen/pix-welcome": "^0.2.8",
-		"@xynogen/pix-footer": "^0.2.11",
-		"@xynogen/pix-diagnostics": "^0.4.2",
+		"@xynogen/pix-runtime": "^0.15.1",
+		"@xynogen/pix-data": "^0.5.6",
+		"@xynogen/pix-pretty": "^1.33.0",
+		"@xynogen/pix-welcome": "^0.2.9",
+		"@xynogen/pix-footer": "^0.2.12",
+		"@xynogen/pix-diagnostics": "^0.4.3",
 		"@xynogen/pix-display": "^0.3.2",
-		"@xynogen/pix-prompts": "^0.5.8",
-		"@xynogen/pix-skills": "^0.10.3",
-		"@xynogen/pix-models": "^0.4.2",
-		"@xynogen/pix-update": "^0.2.6",
-		"@xynogen/pix-commands": "^0.6.10",
-		"@xynogen/pix-nudge": "^0.3.4",
-		"@xynogen/pix-read": "^0.4.5",
-		"@xynogen/pix-write": "^0.2.10",
-		"@xynogen/pix-edit": "^0.2.11",
-		"@xynogen/pix-find": "^0.3.6",
-		"@xynogen/pix-grep": "^0.3.6",
-		"@xynogen/pix-ls": "^0.3.6",
-		"@xynogen/pix-bash": "^0.2.12",
-		"@xynogen/pix-powershell": "^0.1.3",
-		"@xynogen/pix-todo": "^0.4.8",
-		"@xynogen/pix-ask": "^0.3.3",
-		"@xynogen/pix-optimizer": "^1.3.5",
-		"@xynogen/pix-gate": "^0.4.2",
-		"@xynogen/pix-subagent": "^0.10.9"
+		"@xynogen/pix-prompts": "^0.5.9",
+		"@xynogen/pix-skills": "^0.10.4",
+		"@xynogen/pix-models": "^0.4.3",
+		"@xynogen/pix-update": "^0.2.7",
+		"@xynogen/pix-commands": "^0.6.11",
+		"@xynogen/pix-nudge": "^0.3.6",
+		"@xynogen/pix-read": "^0.4.6",
+		"@xynogen/pix-write": "^0.2.11",
+		"@xynogen/pix-edit": "^0.2.12",
+		"@xynogen/pix-find": "^0.3.7",
+		"@xynogen/pix-grep": "^0.3.7",
+		"@xynogen/pix-ls": "^0.3.7",
+		"@xynogen/pix-bash": "^0.2.13",
+		"@xynogen/pix-powershell": "^0.1.4",
+		"@xynogen/pix-todo": "^0.4.9",
+		"@xynogen/pix-ask": "^0.3.4",
+		"@xynogen/pix-optimizer": "^1.3.6",
+		"@xynogen/pix-gate": "^0.4.3",
+		"@xynogen/pix-subagent": "^0.10.10"
 	},
 	"peerDependencies": {
 		"@earendil-works/pi-ai": "*",

package/src/compaction.ts

@@ -25,6 +25,7 @@
  * notify line with reason, model, and token counts.
  */
 
+import { resolve } from "node:path";
 import { contentText, retryAssistantCall, type ThinkingLevel } from "@earendil-works/pi-ai";
 import { completeSimple } from "@earendil-works/pi-ai/compat";
 import type { ContextEditableContent, ExtensionAPI } from "@earendil-works/pi-coding-agent";
@@ -204,6 +205,123 @@ export function shrinkContent(
 	return saved > 0 ? { content: next, saved } : undefined;
 }
 
+// Observation masking (JetBrains, "The Complexity Trap", 2025): masking stale tool
+// output matches LLM summarization at about half the cost. A read result whose
+// file was later edited or written is provably stale: its anchors no longer
+// match. Masking these first can bring context under the threshold and skip the
+// summary call. Append-only context_edit; the original stays in the session file.
+const MASK_PREFIX = "[pix compaction: stale read masked";
+
+type MaskEntry = {
+	sourceEntry: { id: string };
+	messages: Array<{
+		role?: string;
+		content?: unknown;
+		toolCallId?: string;
+		toolName?: string;
+		isError?: boolean;
+	}>;
+};
+
+/** Read results superseded by a later successful edit/write of the same path. */
+export function staleReads(
+	entries: MaskEntry[],
+	resolvePath: (p: string) => string,
+): Array<{ id: string; path: string }> {
+	const callPath = new Map<string, string>();
+	const reads = new Map<string, Array<{ id: string; path: string }>>();
+	const stale: Array<{ id: string; path: string }> = [];
+	for (const { sourceEntry, messages } of entries) {
+		const msg = messages[0];
+		if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+			for (const part of msg.content as Array<{
+				type?: string;
+				id?: string;
+				arguments?: { path?: unknown };
+			}>)
+				if (part.type === "toolCall" && part.id && typeof part.arguments?.path === "string")
+					callPath.set(part.id, resolvePath(part.arguments.path));
+		}
+		if (msg?.role !== "toolResult" || msg.isError || !msg.toolCallId) continue;
+		const path = callPath.get(msg.toolCallId);
+		if (!path) continue;
+		if (msg.toolName === "read") {
+			const text = Array.isArray(msg.content)
+				? (msg.content[0] as { text?: unknown })?.text
+				: undefined;
+			if (typeof text === "string" && text.startsWith(MASK_PREFIX)) continue;
+			reads.set(path, [...(reads.get(path) ?? []), { id: sourceEntry.id, path }]);
+		} else if (msg.toolName === "edit" || msg.toolName === "write") {
+			stale.push(...(reads.get(path) ?? []));
+			reads.delete(path);
+		}
+	}
+	return stale;
+}
+
+export function maskedRead(path: string): string {
+	return `${MASK_PREFIX}: ${path} was edited later; read it again if needed. Original kept in session file.]`;
+}
+
+// Windowed masking (JetBrains M=10: about half the cost, solve rate on par with
+// summarization; Anthropic clear_tool_uses keeps the last N). Over threshold, tool
+// output older than the newest `keep` results is replaced by a restorable stub.
+// Errors stay: they carry what went wrong. Only pass when it frees enough tokens
+// (`minTokens`), because every pass breaks the prompt cache from that point on.
+const OUTPUT_MASK_PREFIX = "[pix compaction: output masked";
+const MASKABLE_TOOLS = new Set(["bash", "grep", "find", "ls", "read"]);
+
+/** Older tool output to mask: id, stub text, and chars freed. */
+export function windowedMasks(
+	entries: MaskEntry[],
+	keep: number,
+	skip: ReadonlySet<string> = new Set(),
+): Array<{ id: string; text: string; saved: number }> {
+	const callArgs = new Map<string, Record<string, unknown>>();
+	const results: Array<{ id: string; tool: string; callId: string; text: string }> = [];
+	for (const { sourceEntry, messages } of entries) {
+		const msg = messages[0];
+		if (msg?.role === "assistant" && Array.isArray(msg.content)) {
+			for (const part of msg.content as Array<{ type?: string; id?: string; arguments?: unknown }>)
+				if (part.type === "toolCall" && part.id)
+					callArgs.set(part.id, (part.arguments ?? {}) as Record<string, unknown>);
+		}
+		if (msg?.role !== "toolResult" || !msg.toolCallId) continue;
+		const text = Array.isArray(msg.content)
+			? (msg.content as TextOrImage[])
+					.map((p) => (p.type === "text" && typeof p.text === "string" ? p.text : ""))
+					.join("\n")
+			: typeof msg.content === "string"
+				? msg.content
+				: "";
+		// Errors count toward the window but are never masked.
+		results.push({
+			id: sourceEntry.id,
+			tool: msg.isError ? "" : (msg.toolName ?? ""),
+			callId: msg.toolCallId,
+			text,
+		});
+	}
+	const older = results.slice(0, Math.max(0, results.length - Math.max(0, keep)));
+	const out: Array<{ id: string; text: string; saved: number }> = [];
+	for (const r of older) {
+		if (!MASKABLE_TOOLS.has(r.tool) || skip.has(r.id)) continue;
+		if (r.text.startsWith(OUTPUT_MASK_PREFIX) || r.text.startsWith(MASK_PREFIX)) continue;
+		const args = callArgs.get(r.callId) ?? {};
+		const target = [args.command, args.pattern, args.path, args.paths]
+			.flat()
+			.find((v) => typeof v === "string" && v);
+		const label = String(target ?? "")
+			.replace(/\s+/g, " ")
+			.trim()
+			.slice(0, 120);
+		const text = `${OUTPUT_MASK_PREFIX} — ${r.tool}${label ? ` ${label}` : ""}; run again if needed. Original kept in session file.]`;
+		const saved = r.text.length - text.length;
+		if (saved > 0) out.push({ id: r.id, text, saved });
+	}
+	return out;
+}
+
 // Sent as a user message after a self-triggered compaction so the agent picks
 // its task back up on its own. Kept short — the freshly written summary already
 // carries the goal, progress, and next steps. Edit to taste.
@@ -314,7 +432,7 @@ export default function registerCompaction(pi: ExtensionAPI): void {
 	// Runs before agent_settled; committed edits shrink the context the trigger
 	// below measures, so a single oversized message no longer blocks compaction.
 	pi.on("agent_before_settle", (event, ctx) => {
-		const { triggerPercent, minimumTokens } = config(compactionSection);
+		const { triggerPercent, minimumTokens, maskKeep, maskMinTokens } = config(compactionSection);
 		if (triggerPercent <= 0) return;
 		const usage = ctx.getContextUsage?.();
 		if (!usage || usage.tokens === null) return;
@@ -325,7 +443,38 @@ export default function registerCompaction(pi: ExtensionAPI): void {
 
 		const edits: typeof event.entries = [];
 		let saved = 0;
+		const masked = new Set<string>();
+		for (const { id, path } of staleReads(
+			event.context.contextEntries as unknown as MaskEntry[],
+			(p) => resolve(ctx.cwd, p),
+		)) {
+			masked.add(id);
+			edits.push({
+				type: "context_edit",
+				targetId: id,
+				replacement: { content: [{ type: "text", text: maskedRead(path) }] },
+			});
+		}
+		// ponytail: chars/4 token estimate, like the trim notice below. Use a tokenizer if the
+		// maskMinTokens gate needs to be exact for a provider.
+		const windowed = windowedMasks(
+			event.context.contextEntries as unknown as MaskEntry[],
+			maskKeep,
+			masked,
+		);
+		const windowSaved = windowed.reduce((sum, w) => sum + w.saved, 0);
+		const windowCount = windowSaved / 4 >= maskMinTokens ? windowed.length : 0;
+		for (const w of windowed.slice(0, windowCount)) {
+			masked.add(w.id);
+			edits.push({
+				type: "context_edit",
+				targetId: w.id,
+				replacement: { content: [{ type: "text", text: w.text }] },
+			});
+		}
+		const stale = masked.size - windowCount;
 		for (const { sourceEntry, messages } of event.context.contextEntries) {
+			if (masked.has(sourceEntry.id)) continue;
 			const msg = messages[0];
 			const editable =
 				sourceEntry.type === "custom_message" ||
@@ -341,10 +490,16 @@ export default function registerCompaction(pi: ExtensionAPI): void {
 			});
 		}
 		if (edits.length === 0) return;
-		ctx.ui.notify(
-			`Compaction: trimmed ${edits.length} oversized message(s), ~${Math.round(saved / 4).toLocaleString()} tok (head+tail kept; originals stay in session file)`,
-			"info",
+		const trimmed = edits.length - masked.size;
+		const parts = [`masked ${stale} stale read(s)`];
+		if (windowCount)
+			parts.push(
+				`masked ${windowCount} older tool output(s) beyond the last ${maskKeep} (~${Math.round(windowSaved / 4).toLocaleString()} tok)`,
+			);
+		parts.push(
+			`trimmed ${trimmed} oversized message(s)${trimmed ? ` (~${Math.round(saved / 4).toLocaleString()} tok)` : ""}`,
 		);
+		ctx.ui.notify(`Compaction: ${parts.join(", ")}; originals stay in session file`, "info");
 		return { entries: [...event.entries, ...edits] };
 	});
 

package/src/defer-tools.ts

@@ -10,7 +10,16 @@
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-export const CORE_TOOLS: ReadonlySet<string> = new Set(["read", "bash", "edit", "write"]);
+// grep/find stay direct: pix-nudge steers bash cat/grep/find toward them, and a
+// tool_search round-trip for the most common lookups costs more than their schemas.
+export const CORE_TOOLS: ReadonlySet<string> = new Set([
+	"read",
+	"bash",
+	"edit",
+	"write",
+	"grep",
+	"find",
+]);
 const TOOL_SEARCH = "tool_search";
 
 export default function deferNonCoreTools(pi: ExtensionAPI): void {