pi-ui-extend 1.0.46 → 1.0.50

package/README.md

@@ -512,10 +512,21 @@ Pix implements the Pi extension UI surface for notifications, keyed toasts, widg
 
 ## Development
 
+Use the exact Node.js version in `.node-version` for development and builds;
+`.nvmrc` mirrors it for nvm users. No particular version manager is required:
+all npm scripts use the `node` and `npm` already on your `PATH`.
+The supported runtime range is `>=22.19.0 <25`, shared by Pix, ACP, and Desktop.
+CI checks the pinned version on Linux, macOS, and Windows, plus the minimum
+supported version on Linux.
+
 ```bash
 git clone https://github.com/dnaroid/pix.git
 cd pix
-npm install
+
+# Select the version from .node-version using your preferred installation method.
+# With nvm (optional): nvm install && nvm use
+node --version
+npm ci
 
 # Run from source
 npm run dev -- --cwd /path/to/project

package/bin/pix.mjs

@@ -1,10 +1,9 @@
 #!/usr/bin/env node
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-const minimumNodeVersion = [22, 19, 0];
-const minimumNodeVersionLabel = "22.19.0";
+const supportedNodeRange = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8")).engines.node;
 const launcherPath = fileURLToPath(import.meta.url);
 const packageRoot = dirname(dirname(launcherPath));
 const mainPath = fileURLToPath(new URL("../dist/main.js", import.meta.url));
@@ -13,8 +12,8 @@ const installPath = fileURLToPath(new URL("../dist/app/cli/install.js", import.m
 const cliArgs = process.argv.slice(2);
 
 if (!isCurrentNodeSupported()) {
-	console.error(`[pix] Node ${minimumNodeVersionLabel}+ is required; current Node is ${process.versions.node}.`);
-	console.error("[pix] Install/use a newer Node, for example `mise install node@22.19.0` or `nvm install 22`.");
+	console.error(`[pix] Node ${supportedNodeRange} is required; current Node is ${process.versions.node}.`);
+	console.error("[pix] Install a supported Node.js release and ensure node and npm use it on PATH.");
 	process.exit(1);
 }
 
@@ -45,9 +44,15 @@ if (!existsSync(mainPath)) {
 await import(new URL("../dist/main.js", import.meta.url));
 
 function isCurrentNodeSupported() {
-	const parts = process.versions.node.split(".").map((part) => Number.parseInt(part, 10));
+	// Only the project's bounded stable range is accepted; fail closed if its format changes.
+	const range = /^>=(\d+)\.(\d+)\.(\d+) <(\d+)$/u.exec(supportedNodeRange);
+	const version = /^(\d+)\.(\d+)\.(\d+)$/u.exec(process.versions.node);
+	if (!range || !version) return false;
+	const minimumNodeVersion = range.slice(1, 4).map(Number);
+	const parts = version.slice(1).map(Number);
+	if (parts[0] >= Number(range[4])) return false;
 	for (let index = 0; index < minimumNodeVersion.length; index += 1) {
-		const current = parts[index] ?? 0;
+		const current = parts[index];
 		const minimum = minimumNodeVersion[index];
 		if (current > minimum) return true;
 		if (current < minimum) return false;

package/dist/app/app.d.ts

@@ -80,6 +80,7 @@ export declare class PiUiExtendApp {
     private selectDraftModel;
     private draftModelState;
     private draftModelStatus;
+    private draftModelUsageSelection;
     private applyPixConfig;
     private updateOutputFilters;
     start(): Promise<void>;

package/dist/app/app.js

@@ -185,6 +185,7 @@ export class PiUiExtendApp {
         });
         this.modelUsageController = new AppModelUsageController({
             runtimeSession: () => this.runtime?.session,
+            draftSelection: () => this.draftModelUsageSelection(),
             render: () => this.render(),
         });
         this.tabsController = new AppTabsController({
@@ -948,6 +949,7 @@ export class PiUiExtendApp {
         this.draftModelRef = ref;
         this.draftThinkingLevel = thinkingLevel;
         this.draftModelOverrideRef = `${ref}:${thinkingLevel}`;
+        this.modelUsageController.observeSession(undefined);
         this.setStatus("new conversation");
     }
     draftModelState() {
@@ -965,6 +967,13 @@ export class PiUiExtendApp {
             return undefined;
         return { modelLabel: state.modelRef, thinkingLabel: state.thinkingLevel };
     }
+    draftModelUsageSelection() {
+        const state = this.draftModelState();
+        if (!state?.modelRef)
+            return undefined;
+        const model = state.models.find((candidate) => `${candidate.provider}/${candidate.id}` === state.modelRef);
+        return model ? { model, thinkingLevel: state.thinkingLevel } : undefined;
+    }
     applyPixConfig(config) {
         replaceRecord(this.pixConfig.toolRenderer, config.toolRenderer);
         replaceRecord(this.pixConfig.outputFilters, config.outputFilters);

package/dist/app/commands/command-model-actions.js

@@ -384,10 +384,8 @@ export class ModelCommandActions {
         });
     }
     saveDefaultThinking(level) {
-        const runtime = getRuntime(this.host, "default-thinking");
-        if (!runtime)
-            return;
-        const fallbackModelRef = runtime.session.model ? this.host.modelRef(runtime.session.model) : undefined;
+        const runtime = this.host.runtime();
+        const fallbackModelRef = runtime?.session.model ? this.host.modelRef(runtime.session.model) : undefined;
         const saved = savePixDefaultThinking(level, fallbackModelRef);
         if (!saved)
             throw new Error("Set /default-model first or select a session model before setting default thinking");
@@ -396,7 +394,7 @@ export class ModelCommandActions {
             kind: "system",
             text: `Default thinking level set to ${saved.thinking ?? level} for ${saved.modelRef}. New sessions will use it unless --model is provided.`,
         });
-        this.host.setSessionStatus(runtime.session);
+        this.host.setSessionStatus(runtime?.session);
     }
 }
 function formatDefaultModelRef(defaultModel) {

package/dist/app/model/model-usage-controller.d.ts

@@ -1,4 +1,5 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
+import type { SessionModel } from "../types.js";
 import { type ModelUsageDescriptor, type ModelUsageStatus } from "./model-usage-status.js";
 export type AppModelUsageQuery = (descriptor: ModelUsageDescriptor) => Promise<ModelUsageStatus | undefined>;
 export type ModelUsageRefreshResult = "refreshed" | "unavailable" | "failed";
@@ -12,6 +13,10 @@ export type ModelUsageRefreshStart = {
 };
 export type AppModelUsageControllerHost = {
     runtimeSession(): AgentSession | undefined;
+    draftSelection?(): {
+        model: SessionModel;
+        thinkingLevel: string;
+    } | undefined;
     render(): void;
 };
 export declare class AppModelUsageController {
@@ -32,4 +37,5 @@ export declare class AppModelUsageController {
     private refresh;
     private syncActiveModel;
     private activeStatus;
+    private activeDescriptor;
 }

package/dist/app/model/model-usage-controller.js

@@ -45,7 +45,7 @@ export class AppModelUsageController {
     refreshNow() {
         const session = this.host.runtimeSession();
         this.syncActiveModel(session);
-        const descriptor = modelUsageDescriptor(session?.model, session?.thinkingLevel);
+        const descriptor = this.activeDescriptor(session);
         if (!descriptor)
             return { kind: "unsupported" };
         const promise = this.refresh(true, descriptor);
@@ -54,7 +54,7 @@ export class AppModelUsageController {
     tick(force = false) {
         const session = this.host.runtimeSession();
         this.syncActiveModel(session);
-        const descriptor = modelUsageDescriptor(session?.model, session?.thinkingLevel);
+        const descriptor = this.activeDescriptor(session);
         if (!descriptor)
             return;
         const cacheKey = descriptorCacheKey(descriptor);
@@ -68,7 +68,7 @@ export class AppModelUsageController {
     }
     refresh(force = false, activeDescriptor) {
         const session = this.host.runtimeSession();
-        const descriptor = activeDescriptor ?? modelUsageDescriptor(session?.model, session?.thinkingLevel);
+        const descriptor = activeDescriptor ?? this.activeDescriptor(session);
         if (!descriptor)
             return undefined;
         const modelKey = descriptorCacheKey(descriptor);
@@ -96,7 +96,7 @@ export class AppModelUsageController {
         });
     }
     syncActiveModel(session) {
-        const nextModelKey = descriptorCacheKey(modelUsageDescriptor(session?.model, session?.thinkingLevel));
+        const nextModelKey = descriptorCacheKey(this.activeDescriptor(session));
         if (nextModelKey === this.activeModelKey)
             return false;
         this.activeModelKey = nextModelKey;
@@ -106,4 +106,10 @@ export class AppModelUsageController {
     activeStatus() {
         return this.activeModelKey ? this.statuses.get(this.activeModelKey) : undefined;
     }
+    activeDescriptor(session) {
+        if (session)
+            return modelUsageDescriptor(session.model, session.thinkingLevel);
+        const draft = this.host.draftSelection?.();
+        return draft ? modelUsageDescriptor(draft.model, draft.thinkingLevel) : undefined;
+    }
 }

package/dist/bundled-extensions/question/tui.js

@@ -325,6 +325,30 @@ export async function runQuestionnaire(questions, ctx) {
             }
             showReview();
         }
+        function confirmMultipleAnswer() {
+            const question = currentQuestion();
+            if (!question.multiple)
+                return;
+            const selection = selections.get(question.id);
+            if (!selection || !selectionIsComplete(question, selection)) {
+                const existing = multipleSelection(question);
+                if (existing.customText !== undefined && !existing.customText.trim() && (existing.images?.length ?? 0) === 0) {
+                    customError = "Custom Answer cannot be empty.";
+                }
+                else {
+                    const minimum = question.minSelections ?? 1;
+                    customError = `Choose at least ${minimum} answer${minimum === 1 ? "" : "s"}.`;
+                }
+                refresh();
+                return;
+            }
+            customError = undefined;
+            if (questionIndex < questions.length - 1) {
+                moveToQuestion(questionIndex + 1);
+                return;
+            }
+            submitOrAnswerRemaining();
+        }
         function enterCustomMode() {
             const question = currentQuestion();
             const existing = selections.get(question.id);
@@ -410,7 +434,7 @@ export async function runQuestionnaire(questions, ctx) {
                 mode = "choices";
                 customError = undefined;
                 syncChoiceSelection();
-                refresh();
+                confirmMultipleAnswer();
                 return;
             }
             selections.set(question.id, {
@@ -558,7 +582,17 @@ export async function runQuestionnaire(questions, ctx) {
                 goBack();
                 return;
             }
-            if (isKey(data, "enter") || data === " ") {
+            if (currentQuestion().multiple) {
+                if (data === " ") {
+                    selectChoice(selectedChoiceIndex);
+                    return;
+                }
+                if (isKey(data, "enter")) {
+                    confirmMultipleAnswer();
+                    return;
+                }
+            }
+            else if (isKey(data, "enter") || data === " ") {
                 selectChoice(selectedChoiceIndex);
                 return;
             }

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

@@ -36,6 +36,7 @@ import {
 } from "./compression-preview.js"
 import { settleCompressionProgress } from "./compression-progress.js"
 import { estimateMessageTokens } from "./pruner-metadata.js"
+import { incompleteToolGroupGuidance } from "./protocol-closed-ranges.js"
 import {
   buildSummarySourceManifest,
   hashSummarySourceManifest,
@@ -190,7 +191,7 @@ function validateProtocolClosedRanges(plans: ResolvedRangeBoundaries[], state: D
     if (closure.incompleteToolGroup) {
       throw new Error(
         `Compression range ${plan.startId}..${plan.endId} intersects an incomplete tool group. ` +
-        "Wait until the complete assistant/tool-result group is present or choose another closed range.",
+        incompleteToolGroupGuidance(state.conversationIndexSnapshot, plan.startId, plan.endId),
       )
     }
     if (closure.expanded) {

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

@@ -0,0 +1,96 @@
+import { detectToolGroupSpans, findConversationIndexEntry } from "./conversation-index.js"
+import { estimateMessageTokens, stripStaleDcpMetadataFromMessage } from "./pruner-metadata.js"
+import type { CompressionCandidate } from "./pruner-types.js"
+import type { DcpState } from "./state.js"
+
+export interface DcpContextMapTelemetry {
+  readonly revision: number
+  readonly sessionEpoch: number
+  readonly generatedAt: number
+  readonly tokenEstimates: {
+    readonly candidate: number
+    readonly protected: number
+    readonly compressed: number
+    readonly retained: number
+  }
+}
+
+type ContextMapKind = keyof DcpContextMapTelemetry["tokenEstimates"]
+
+function isSafeNonnegativeInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0
+}
+
+/** Capture immediately after applyPruning, before any await or carrier changes. */
+export function captureDcpContextTokenEstimates(
+  entries: DcpState["conversationIndexSnapshot"],
+  preparedMessages: readonly any[],
+  metadata: DcpState["messageMetaSnapshot"],
+): number[] | undefined {
+  if (entries.length !== preparedMessages.length) return undefined
+  const tokens: number[] = []
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index]!
+    const message = preparedMessages[index]
+    if (entry.index !== index || entry.role !== (message?.role ?? "")) return undefined
+    const cached = entry.visibleId ? metadata.get(entry.visibleId) : undefined
+    // Reuse the body estimate made by this exact pruning pass. Non-addressable
+    // messages have no cache; only these need the ordinary content estimator.
+    const estimate = cached?.contentHash === entry.contentHash && cached.tokenEstimate !== undefined
+      ? cached.tokenEstimate
+      : estimateMessageTokens(stripStaleDcpMetadataFromMessage(message))
+    if (!isSafeNonnegativeInteger(estimate)) return undefined
+    tokens.push(estimate)
+  }
+  return tokens
+}
+
+/** Classifies the already-prepared provider projection without reading history or planning. */
+export function projectDcpContextMapTelemetry(
+  entries: DcpState["conversationIndexSnapshot"],
+  candidate: CompressionCandidate | null,
+  preparedTokenEstimates: readonly number[] | undefined,
+  revision: number,
+  sessionEpoch: number,
+  generatedAt = Date.now(),
+): DcpContextMapTelemetry | undefined {
+  if (
+    entries.length === 0 || entries.length !== preparedTokenEstimates?.length ||
+    !isSafeNonnegativeInteger(revision) || revision === 0 || !isSafeNonnegativeInteger(sessionEpoch) ||
+    !isSafeNonnegativeInteger(generatedAt) || generatedAt === 0 || !Number.isFinite(new Date(generatedAt).getTime())
+  ) return undefined
+
+  const protectedIndexes = new Set<number>()
+  for (const group of detectToolGroupSpans(entries)) {
+    if (!group.complete) {
+      for (let index = group.startIndex; index <= group.endIndex; index++) protectedIndexes.add(index)
+    }
+  }
+  const candidateIndexes = new Set<number>()
+  if (candidate) {
+    const start = findConversationIndexEntry(entries, candidate.startId)?.index
+    const end = findConversationIndexEntry(entries, candidate.endId)?.index
+    if (start !== undefined && end !== undefined) {
+      for (let index = Math.min(start, end); index <= Math.max(start, end); index++) candidateIndexes.add(index)
+    }
+  }
+
+  const tokenEstimates: Record<ContextMapKind, number> = {
+    candidate: 0, protected: 0, compressed: 0, retained: 0,
+  }
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index]!
+    const tokens = preparedTokenEstimates[index]
+    if (!isSafeNonnegativeInteger(tokens)) return undefined
+    const kind: ContextMapKind = entry.origin === "dcp-control" ? "retained"
+      : protectedIndexes.has(index) ? "protected"
+      : candidateIndexes.has(index) ? "candidate"
+      : entry.origin === "block" && entry.blockId !== undefined ? "compressed"
+      : "retained"
+    if (!Number.isSafeInteger(tokenEstimates[kind] + tokens)) return undefined
+    tokenEstimates[kind] += tokens
+  }
+  const total = tokenEstimates.candidate + tokenEstimates.protected + tokenEstimates.compressed + tokenEstimates.retained
+  if (!Number.isSafeInteger(total) || total <= 0) return undefined
+  return { revision, sessionEpoch, generatedAt, tokenEstimates }
+}

package/external/pi-tools-suite/src/dcp/index.ts

@@ -78,6 +78,7 @@ import { inferDcpBlockedReason, planDcpBudget, type DcpBlockedReason } from "./p
 import { createBudgetedAutoCompressionBlock } from "./auto-compress-budget.js"
 import { compressionPlanningTokens, outstandingCompressionTokens, resetCompressionProgress, routineRecoveryTokens, trackCompressionProgress } from "./compression-progress.js"
 import { captureDcpTransactionGuard, cloneDcpTransactionState, runDcpStateTransaction, invalidateDcpStateOwner } from "./state-transaction.js"
+import { captureDcpContextTokenEstimates, projectDcpContextMapTelemetry } from "./context-map-telemetry.js"
 
 const PIX_DCP_RUNTIME_STATS_SYMBOL = Symbol.for("pix.dcp.runtime-stats")
 
@@ -163,7 +164,15 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 	const state = dependencies.state ?? createState()
 	// Pix ACP runs one pi process per session. Expose only this tiny live metric
 	// to the patched RPC session-stats surface; DCP state remains extension-owned.
-	runtimeGlobals[PIX_DCP_RUNTIME_STATS_SYMBOL] = () => ({ tokensSaved: state.tokensSaved })
+	let contextMapRevision = 0
+	let contextMapPass = 0
+	let contextMap: ReturnType<typeof projectDcpContextMapTelemetry> | undefined
+	// This process-local bridge is read-only. Its map is produced only by the
+	// existing context pass, never by Desktop inspection or a streaming delta.
+	runtimeGlobals[PIX_DCP_RUNTIME_STATS_SYMBOL] = () => ({
+		tokensSaved: state.tokensSaved,
+		contextMap: contextMap?.sessionEpoch === state.sessionEpoch ? contextMap : undefined,
+	})
 	let journalMirror: DcpJournalMirror | undefined
 	let journalSupported = false
 	let journalBlockedReason: string | undefined
@@ -283,6 +292,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 		try { ctx.ui.notify(message, "warning") } catch { /* Headless/notification failure is not a persistence failure. */ }
 	}
 	const invalidateOwner = () => {
+		contextMap = undefined
+		contextMapPass++
 			invalidateDcpStateOwner(state)
 			routinePressureTracker.reset()
 			// Successful exposure belongs to the old provider/branch too, not only
@@ -353,6 +364,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 
 	// ── 5. session_start: restore state from session entries ──────────────────
 	pi.on("session_start", async (event, ctx) => {
+		contextMap = undefined
+		contextMapPass++
 		resetState(state)
 		routinePressureTracker.reset()
 		freshToolResults.reset()
@@ -387,6 +400,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 	// Journal operations are committed at the mutation boundary; shutdown does
 	// not write a full runtime snapshot.
 	pi.on("session_shutdown", async () => {
+		contextMap = undefined
+		contextMapPass++
 		routinePressureTracker.reset()
 		freshToolResults.reset()
 		journalMirror = undefined
@@ -472,6 +487,9 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 	// ── 10. context: apply pruning and inject nudges ──────────────────────────
 	pi.on("context", async (event, ctx) => {
 		const contextEpoch = state.sessionEpoch
+		const mapPass = ++contextMapPass
+		contextMap = undefined
+		let mapEntries = state.conversationIndexSnapshot
 		const effectiveConfig = configForContext(ctx)
 		ensureEphemeralJournal(ctx)
 		const contextMessages = event.messages
@@ -509,6 +527,18 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 				state: summarizeDcpState(state, effectiveConfig),
 				...details,
 			}, ctx)
+			if (mapPass === contextMapPass) {
+				contextMap = providerReady
+					? projectDcpContextMapTelemetry(
+						mapEntries,
+						candidate ?? emergencyCompressionCandidate,
+						mapTokenEstimates,
+						++contextMapRevision,
+						contextEpoch,
+						Date.now(),
+					)
+					: undefined
+			}
 			return { messages }
 		}
 
@@ -545,6 +575,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 			writeDcpDebugLog(effectiveConfig, "context.rehydrated_tool_records", { ...rehydration }, ctx)
 		}
 		let prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
+		mapEntries = state.conversationIndexSnapshot
+		let mapTokenEstimates = captureDcpContextTokenEstimates(mapEntries, prunedMessages, state.messageMetaSnapshot)
 		// Stable IDs and any pruning decisions that affect this provider-visible
 		// projection must be committed before the request can use them.
 		await persistJournalState(ctx, state)
@@ -1011,6 +1043,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 						// Re-apply pruning so the new block takes effect on this
 						// same context pass instead of the next one.
 						prunedMessages = preparedProjection ?? applyPruning(contextMessages, state, effectiveConfig)
+						mapEntries = state.conversationIndexSnapshot
+						mapTokenEstimates = captureDcpContextTokenEstimates(mapEntries, prunedMessages, state.messageMetaSnapshot)
 						const clearedAnchors = clearDcpNudgeAnchors(state)
 						warnedProgress.clear()
 						state.progressRecovery = undefined
@@ -1128,6 +1162,8 @@ export default async function dcpModule(pi: ExtensionAPI, dependencies: { config
 				)
 				if (emergencyPruneResult.prunedToolCallIds.length > 0) {
 					prunedMessages = applyPruning(contextMessages, state, effectiveConfig)
+					mapEntries = state.conversationIndexSnapshot
+					mapTokenEstimates = captureDcpContextTokenEstimates(mapEntries, prunedMessages, state.messageMetaSnapshot)
 					const clearedAnchors = clearDcpNudgeAnchors(state)
 					state.consecutiveIgnoredStrongNudges = 0
 					state.progressRecovery = undefined

package/external/pi-tools-suite/src/dcp/protocol-closed-ranges.ts

@@ -0,0 +1,90 @@
+import { closeConversationRange, detectToolGroupSpans } from "./conversation-index.js";
+import type { ConversationIndexEntry } from "./state.js";
+
+interface RangeBoundary {
+  id: string;
+  messageIndex: number;
+}
+
+function diagnosticId(id: string): string {
+  return id.length > 160 ? `${id.slice(0, 157)}...` : id;
+}
+
+/**
+ * Maximal closed runs inside an already policy-filtered selection. Incomplete
+ * groups are barriers, not reasons to discard all later completed work. Never
+ * widen across a retention boundary or an excluded message/block to close one.
+ */
+export function protocolClosedBoundaryRuns<T extends RangeBoundary>(
+  boundaries: T[],
+  entries: ConversationIndexEntry[],
+): T[][] {
+  if (boundaries.length === 0 || entries.length === 0) return [];
+  const first = boundaries[0]!.messageIndex;
+  const last = boundaries[boundaries.length - 1]!.messageIndex;
+  const included = new Set(boundaries.map((boundary) => boundary.messageIndex));
+  const excluded = new Set(entries.filter((entry) =>
+    entry.index >= first && entry.index <= last && !included.has(entry.index) &&
+    !entry.passthrough && entry.origin !== "dcp-control",
+  ).map((entry) => entry.index));
+  const barriers = [...excluded].map((index) => ({ startIndex: index, endIndex: index }));
+  for (const group of detectToolGroupSpans(entries)) {
+    if (group.endIndex < first || group.startIndex > last) continue;
+    if (!group.complete || group.startIndex < first || group.endIndex > last ||
+      entries.slice(group.startIndex, group.endIndex + 1).some((entry) => excluded.has(entry.index))) {
+      barriers.push(group);
+    }
+  }
+  barriers.sort((a, b) => a.startIndex - b.startIndex);
+
+  const runs: T[][] = [];
+  let cursor = 0;
+  for (const barrier of barriers) {
+    const start = cursor;
+    while (cursor < boundaries.length && boundaries[cursor]!.messageIndex < barrier.startIndex) cursor++;
+    if (cursor > start) runs.push(boundaries.slice(start, cursor));
+    while (cursor < boundaries.length && boundaries[cursor]!.messageIndex <= barrier.endIndex) cursor++;
+  }
+  if (cursor < boundaries.length) runs.push(boundaries.slice(cursor));
+
+  // Use the executor's closure authority, including non-addressable entries.
+  return runs.filter((run) => {
+    const closure = closeConversationRange(entries, run[0]!.id, run[run.length - 1]!.id);
+    return closure && !closure.expanded && !closure.incompleteToolGroup;
+  });
+}
+
+/** Bounded recovery guidance for stale/manual selections; never changes them. */
+export function incompleteToolGroupGuidance(
+  entries: ConversationIndexEntry[],
+  startId: string,
+  endId: string,
+): string {
+  const closure = closeConversationRange(entries, startId, endId);
+  if (!closure) return "Choose another protocol-closed range.";
+  const blockers = detectToolGroupSpans(entries).filter((group) =>
+    !group.complete && group.startIndex <= closure.endIndex && group.endIndex >= closure.startIndex,
+  );
+  const details = blockers.slice(0, 3).map((group) => {
+    const assistant = entries[group.startIndex]!;
+    const results = new Set(entries.slice(group.startIndex + 1, group.endIndex + 1)
+      .filter((entry) => entry.role === "toolResult" || entry.role === "bashExecution")
+      .map((entry) => entry.toolCallId));
+    const missing = group.toolCallIds.filter((id) => !results.has(id));
+    return `${diagnosticId(assistant.visibleId ?? assistant.stableId)} (missing tool result: ${missing.slice(0, 3).map(diagnosticId).join(", ")}${missing.length > 3 ? ", …" : ""})`;
+  });
+  const boundaries = entries.flatMap((entry) => {
+    if (entry.index < closure.requestedStartIndex || entry.index > closure.requestedEndIndex ||
+      entry.passthrough || entry.origin === "dcp-control") return [];
+    const id = entry.blockId !== undefined ? `b${entry.blockId}` : entry.visibleId;
+    return id ? [{ id, messageIndex: entry.index }] : [];
+  });
+  const alternatives = protocolClosedBoundaryRuns(boundaries, entries);
+  const hints = alternatives.slice(0, 3).map((run) => `${run[0]!.id}..${run[run.length - 1]!.id}`);
+  return `Blocking group(s): ${details.join("; ")}${blockers.length > 3 ? "; …" : ""}. ` +
+    (hints.length > 0
+      ? `Protocol-safe alternatives inside this selection: ${hints.join(", ")}${alternatives.length > 3 ? ", …" : ""}. `
+      : "No protocol-closed subrange is available inside this selection. ") +
+    "Choose a closed range or message-mode candidates outside the blocked groups. " +
+    "Changing only an endId beyond a blocked group will not help; wait only if its tool is actually still running.";
+}

package/external/pi-tools-suite/src/dcp/pruner-candidates.ts

@@ -5,7 +5,8 @@ import {
   estimateMessageTokens,
 } from "./pruner-metadata.js";
 import { stableMessageKeys } from "./pruner-message-ids.js";
-import { detectToolGroupSpans, findConversationIndexEntry } from "./conversation-index.js";
+import { closeConversationRange, detectToolGroupSpans, findConversationIndexEntry } from "./conversation-index.js";
+import { protocolClosedBoundaryRuns } from "./protocol-closed-ranges.js";
 
 interface CandidateBoundary {
   id: string;
@@ -120,58 +121,39 @@ function selectOldestSafePrefix(
   maxSafeMessageIndex: number,
   options?: CompressionCandidateSelectionOptions,
 ): CandidateBoundary[] | null {
-  if (boundaries.length === 0) return null;
-  if (!options || options.requiredSavingsTokens === undefined) {
-    let full = boundaries.slice();
-    while (full.length > 0 && full[0]!.isSystemReminder) full = full.slice(1);
-    while (full.length > 0 && full[full.length - 1]!.isSystemReminder) full = full.slice(0, -1);
-    if (full.length < Math.max(1, settings.minMessages)) return null;
-    if (full.reduce((sum, boundary) => sum + boundary.tokenEstimate, 0) < settings.minTokens) return null;
-    return full;
-  }
-  const requiredSavings = Math.max(0, Math.floor(options.requiredSavingsTokens));
+  const requiredSavings = Math.max(0, Math.floor(options?.requiredSavingsTokens ?? 0));
   const estimatorMargin = Math.max(0, Math.floor(options?.estimatorMarginTokens ?? 0));
   const targetSourceTokens = Math.max(settings.minTokens, requiredSavings + estimatorMargin);
   const minMessages = Math.max(1, settings.minMessages);
-
-  let selectedEnd = -1;
-  let selectedTokens = 0;
-  for (let index = 0; index < boundaries.length; index++) {
-    selectedTokens += boundaries[index]!.tokenEstimate;
-    if (index + 1 >= minMessages && selectedTokens >= targetSourceTokens) {
-      selectedEnd = index;
-      break;
-    }
-  }
-  if (selectedEnd < 0) selectedEnd = boundaries.length - 1;
-
-  let selected = boundaries.slice(0, selectedEnd + 1);
-  if (state.conversationIndexSnapshot.length > 0) {
-    const groups = detectToolGroupSpans(state.conversationIndexSnapshot);
-    const startMessageIndex = selected[0]!.messageIndex;
-    let endMessageIndex = selected[selected.length - 1]!.messageIndex;
-    let changed = true;
-    while (changed) {
-      changed = false;
-      for (const group of groups) {
-        const overlaps = group.startIndex <= endMessageIndex && group.endIndex >= startMessageIndex;
-        if (!overlaps) continue;
-        if (!group.complete) return null;
-        if (group.endIndex > endMessageIndex) {
-          if (group.endIndex > maxSafeMessageIndex) return null;
-          endMessageIndex = group.endIndex;
-          changed = true;
+  const eligible = boundaries.filter((boundary) => boundary.messageIndex <= maxSafeMessageIndex);
+  while (eligible[0]?.isSystemReminder) eligible.shift();
+  while (eligible[eligible.length - 1]?.isSystemReminder) eligible.pop();
+
+  for (const run of protocolClosedBoundaryRuns(eligible, state.conversationIndexSnapshot)) {
+    while (run[0]?.isSystemReminder) run.shift();
+    while (run[run.length - 1]?.isSystemReminder) run.pop();
+    if (run.length === 0) continue;
+    let selectedEnd = run.length - 1;
+    if (options?.requiredSavingsTokens !== undefined) {
+      let selectedTokens = 0;
+      for (let index = 0; index < run.length; index++) {
+        selectedTokens += run[index]!.tokenEstimate;
+        if (index + 1 >= minMessages && selectedTokens >= targetSourceTokens) {
+          selectedEnd = index;
+          break;
         }
       }
     }
-    selected = boundaries.filter((boundary) => boundary.messageIndex <= endMessageIndex);
+    const closure = closeConversationRange(state.conversationIndexSnapshot, run[0]!.id, run[selectedEnd]!.id);
+    if (!closure || closure.incompleteToolGroup || closure.startIndex !== run[0]!.messageIndex ||
+      closure.endIndex > run[run.length - 1]!.messageIndex) continue;
+    const selected = run.filter((boundary) => boundary.messageIndex <= closure.endIndex);
+    if (selected[selected.length - 1]!.messageIndex !== closure.endIndex) continue;
+    if (selected.length < minMessages) continue;
+    if (selected.reduce((sum, boundary) => sum + boundary.tokenEstimate, 0) < settings.minTokens) continue;
+    return selected;
   }
-
-  while (selected.length > 0 && selected[0]!.isSystemReminder) selected = selected.slice(1);
-  while (selected.length > 0 && selected[selected.length - 1]!.isSystemReminder) selected = selected.slice(0, -1);
-  if (selected.length < minMessages) return null;
-  if (selected.reduce((sum, boundary) => sum + boundary.tokenEstimate, 0) < settings.minTokens) return null;
-  return selected;
+  return null;
 }
 
 export function detectCompressionCandidate(

package/external/pi-tools-suite/src/dcp/pruner-replay-context.ts

@@ -0,0 +1,35 @@
+import type { DcpState } from "./state.js";
+import { stableMessageKeys } from "./pruner-message-ids.js";
+
+/** Match the SDK provider transform, not UI visibility or tool-result errors. */
+export function isReplayableContextMessage(message: any): boolean {
+  return !(message?.role === "assistant" &&
+    (message.stopReason === "error" || message.stopReason === "aborted"));
+}
+
+/**
+ * SDK retry removes failed attempts from live agent state but keeps them in
+ * JSONL. Reload restores them; the provider later omits error/aborted assistants.
+ * Normalize before exact block replay so those history-only attempts cannot
+ * split a range that was committed from the live, post-retry context.
+ *
+ * Older blocks may explicitly include such an attempt. Keep every referenced
+ * occurrence until the existing matcher has checked its exact ID/order/hash;
+ * neither membership arrays nor signed message contents are rewritten. Any
+ * remaining attempts are omitted after replay, before new IDs/plans are built.
+ */
+export function prepareDcpReplayMessages(messages: any[], state: DcpState): any[] {
+  if (messages.every(isReplayableContextMessage)) return messages;
+
+  const referencedIds = new Set<string>();
+  for (const block of state.compressionBlocks) {
+    if (!block.active) continue;
+    for (const members of [block.mutationMembers, block.sourceMembers]) {
+      for (const member of members ?? []) referencedIds.add(member.stableId);
+    }
+  }
+  const keys = stableMessageKeys(messages);
+  return messages.filter((message, index) =>
+    isReplayableContextMessage(message) || referencedIds.has(keys[index]!),
+  );
+}

package/external/pi-tools-suite/src/dcp/pruner.ts

@@ -5,6 +5,7 @@ import { stripStaleDcpMetadataFromMessage } from "./pruner-metadata.js";
 import { injectMessageIds } from "./pruner-message-ids.js";
 import { copyRawMutationHash } from "./conversation-index.js";
 import { applyToolOutputPruning } from "./pruner-tools.js";
+import { isReplayableContextMessage, prepareDcpReplayMessages } from "./pruner-replay-context.js";
 
 export type {
   CompressionCandidate,
@@ -54,7 +55,7 @@ export function applyPruning(
 ): any[] {
   // Deep-clone each message and its content to prevent mutations from
   // affecting the original objects across context events.
-  const msgs: any[] = messages.map((m: any) => {
+  let msgs: any[] = messages.map((m: any) => {
     const clone = { ...m };
     if (Array.isArray(clone.content)) {
       clone.content = clone.content.map((contentBlock: any) =>
@@ -70,6 +71,8 @@ export function applyPruning(
     return stripped;
   });
 
+  msgs = prepareDcpReplayMessages(msgs, state);
+
   // 1. Count user turns → update state.currentTurn. Do this before inserting
   // synthetic compression summaries; the raw session is the source of truth.
   state.currentTurn = msgs.filter((m) => m.role === "user").length;
@@ -79,6 +82,11 @@ export function applyPruning(
   syncCompressionBlocks(msgs, state, config);
   applyCompressionBlocks(msgs, state);
 
+  // Terminal attempts retained solely for old exact ledgers must not become
+  // new addressable source, protocol groups or budget pressure. Raw session
+  // entries remain untouched; this is the same omission the provider makes.
+  msgs = msgs.filter(isReplayableContextMessage);
+
   // Existing explicit/emergency pruning decisions are replayed, but routine
   // context construction never discovers new retroactive deletions. A new user
   // turn must remain append-only for provider prefix caching; destructive

package/external/pi-tools-suite/src/todo/index.ts

@@ -10,6 +10,7 @@ import { applyTaskMutation } from "./state/state-reducer.js";
 import { getState, replaceState } from "./state/store.js";
 import {
 	activateTodoStateScope,
+	appendTodoStateSnapshot,
 	DEFAULT_PROMPT_GUIDELINES,
 	DEFAULT_PROMPT_SNIPPET,
 	publishTodoState,
@@ -456,6 +457,7 @@ export default function (pi: ExtensionAPI) {
 		}
 		const autoClear = autoClearCompletedTodos(result.state);
 		replaceState(autoClear.state);
+		appendTodoStateSnapshot(pi as any, action, params as Record<string, unknown>);
 		publishTodoState(pi as any, ctx, action, params as Record<string, unknown>);
 		if (todoThinkingEnabled) applyTodoThinkingAfterCommit(result.state, ctx, { action, params });
 		try {

package/external/pi-tools-suite/src/todo/todo.ts

@@ -249,7 +249,7 @@ export function publishTodoState(
 	publishRpcSessionState(ctx as TodoStateEventContext | undefined, TODO_STATE_EVENT, snapshot);
 }
 
-function appendTodoStateSnapshot(
+export function appendTodoStateSnapshot(
 	pi: TodoStateEntryWriter,
 	action: TaskAction,
 	params: Record<string, unknown>,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-ui-extend",
-  "version": "1.0.46",
+  "version": "1.0.50",
   "description": "Pix: a workspace-first terminal UI for Pi with tabs, readable tool activity, voice input, and bundled agent tools.",
   "private": false,
   "repository": {
@@ -48,19 +48,19 @@
   ],
   "scripts": {
     "predev": "npm run link:pix --silent",
-    "dev": "mise exec node@24.16.0 -- tsx src/main.ts",
-    "start": "mise exec node@24.16.0 -- tsx src/main.ts",
+    "dev": "tsx src/main.ts",
+    "start": "tsx src/main.ts",
     "prebuild:pix": "npm run generate-schemas --silent",
-    "build:pix": "mise exec node@24.16.0 -- tsc -p tsconfig.json",
+    "build:pix": "tsc -p tsconfig.json",
     "prelink:pix": "npm run build:pix --silent",
-    "link:pix": "mise exec node@24.16.0 -- npm link --silent",
-    "watch:pix": "npm run link:pix --silent && mise exec node@24.16.0 -- node scripts/watch-pix.mjs",
-    "watch:all": "mise exec node@24.16.0 -- node scripts/watch-all.mjs",
+    "link:pix": "npm link --silent",
+    "watch:pix": "npm run link:pix --silent && node scripts/watch-pix.mjs",
+    "watch:all": "node scripts/watch-all.mjs",
     "rebuild:all": "npm run build:desktop",
-    "check": "mise exec node@24.16.0 -- npm run check:inner",
+    "check": "npm run check:inner",
     "precheck:inner": "npm run generate-schemas --silent",
     "check:inner": "npm run sync:sdk-pin:check --silent && tsc --noEmit && npm run test:inner",
-    "test": "mise exec node@24.16.0 -- npm run test:inner",
+    "test": "npm run test:inner",
     "test:inner": "node --import tsx --test \"tests/**/*.test.ts\"",
     "test:tools-suite": "npm --prefix external/pi-tools-suite test",
     "test:dcp-session-sim": "npm --prefix external/pi-tools-suite run test:dcp-session-sim",
@@ -75,12 +75,12 @@
     "sync:pi-tools-suite:check": "node scripts/sync-pi-tools-suite.mjs --check",
     "sync:sdk-pin": "node scripts/sync-sdk-pin.mjs",
     "sync:sdk-pin:check": "node scripts/sync-sdk-pin.mjs --check",
-    "test:coverage": "mise exec node@24.16.0 -- node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=94 --test-coverage-branches=80 --test-coverage-functions=94 \"tests/**/*.test.ts\"",
-    "update-sdk-references": "mise exec node@24.16.0 -- node .pi/skills/pi-sdk/scripts/update-references.mjs",
+    "test:coverage": "node --import tsx --test --experimental-test-coverage --test-coverage-include=src/**/*.ts --test-coverage-exclude=src/main.ts --test-coverage-lines=94 --test-coverage-branches=80 --test-coverage-functions=94 \"tests/**/*.test.ts\"",
+    "update-sdk-references": "node .pi/skills/pi-sdk/scripts/update-references.mjs",
     "prepack": "npm run generate-schemas --silent",
     "pack:dry-run": "npm pack --dry-run",
-    "smoke-test": "mise exec node@24.16.0 -- bash scripts/smoke-test-package.sh",
-    "smoke-test:cli": "mise exec node@24.16.0 -- node scripts/smoke-test-package-cli.mjs",
+    "smoke-test": "bash scripts/smoke-test-package.sh",
+    "smoke-test:cli": "node scripts/smoke-test-package-cli.mjs",
     "release:check": "npm run check && npm run build:pix && npm run pack:dry-run",
     "publish-npm": "bash scripts/publish.sh",
     "generate-schemas": "tsx scripts/generate-schemas.ts",