pi-ui-extend 1.0.47 → 1.0.50

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/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.47",
+  "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": {