pi-ui-extend 1.0.41 → 1.0.42

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

@@ -775,6 +775,80 @@ export async function generateModelSummary(
 	return { attempts }
 }
 
+export interface PreparedCompressionSummary {
+	text: string
+	representation: "model" | "extractive" | "extractive-fallback"
+	sourceManifest: SummarySourceItem[]
+	sourceHash: string
+	sourceCoverage: SummarySourceCoverage
+	summarizerModelRef?: string
+	summarizerAttempts?: ModelSummaryAttempt[]
+}
+
+/**
+ * Shared summary preparation for automatic and explicit compression. The
+ * configured model chain is attempted first; if it is absent/unavailable the
+ * deterministic extractive continuation record is the safety floor.
+ */
+export async function prepareCompressionSummary(options: {
+	topic: string
+	messages: any[]
+	candidate?: CompressionCandidate
+	modelRefs: string[]
+	timeoutMs: number
+	modelRegistry?: ModelSummaryRegistry
+	signal?: AbortSignal
+	sourceManifest?: SummarySourceItem[]
+}): Promise<PreparedCompressionSummary> {
+	options.signal?.throwIfAborted()
+	const sourceManifest = options.sourceManifest ?? buildSummarySourceManifest(options.messages)
+	let modelResult: ModelSummaryResult | undefined
+	if (options.modelRefs.length > 0) {
+		modelResult = await generateModelSummary(
+			options.modelRefs,
+			options.modelRegistry,
+			options.signal,
+			options.topic,
+			options.messages,
+			options.timeoutMs,
+			sourceManifest,
+		)
+		options.signal?.throwIfAborted()
+	}
+	const fallbackCandidate = options.candidate ?? {
+		startId: "generated",
+		endId: "generated",
+		messageCount: sourceManifest.length,
+		estimatedTokens: options.messages.reduce((sum, message) => sum + estimateMessageTokens(message), 0),
+		includedBlockIds: [],
+		reason: "explicit/generated summary source",
+	}
+	const text = modelResult?.text ?? buildExtractiveSummary(
+		options.topic,
+		fallbackCandidate,
+		sourceManifest,
+	)
+	if (!modelResult?.text && estimateTokens(text) > 8192) {
+		throw new AutoCompressionBlockedError(
+			"budget-exhausted",
+			"Extractive continuity minimum exceeds its 8192-token budget; no checkpoints were silently dropped",
+		)
+	}
+	return {
+		text,
+		representation: modelResult?.text
+			? "model"
+			: options.modelRefs.length > 0
+				? "extractive-fallback"
+				: "extractive",
+		sourceManifest,
+		sourceHash: hashSummarySourceManifest(sourceManifest),
+		sourceCoverage: summarySourceCoverage(sourceManifest),
+		summarizerModelRef: modelResult?.usedModelRef,
+		summarizerAttempts: modelResult?.attempts.length ? modelResult.attempts : undefined,
+	}
+}
+
 function extractAssistantText(result: any): string | undefined {
 	const content = result?.content
 	if (!Array.isArray(content)) return undefined
@@ -913,48 +987,26 @@ export async function createAutoCompressionBlock(
 		}
 	}
 
-	// Summary source selection. `summaryMode` distinguishes three cases so the
-	// DCP debug log can tell a real model summary from a programmatic fallback
-	// caused by summarizer failure:
-	//   - "model": a configured model produced the summary.
-	//   - "programmatic": no summarizer models configured (floor by design).
-	//   - "programmatic_fallback": models were configured but all failed/empty.
-	const sourceManifest = buildSummarySourceManifest(messagesInRange)
-	let summary = ""
-	let summaryMode: "programmatic" | "model" | "programmatic_fallback" = "programmatic"
-	let summarizerModelRef: string | undefined
-	let summarizerAttempts: ModelSummaryAttempt[] | undefined
-
-	const modelRefs = settings.summarizerModel
-	if (modelRefs.length > 0) {
-		const modelResult = await generateModelSummary(
-			modelRefs,
-			modelRegistry,
-			signal,
-			topic,
-			messagesInRange,
-			settings.timeoutMs,
-			sourceManifest,
-		)
-		assertCurrent()
-		summarizerAttempts = modelResult.attempts.length > 0 ? modelResult.attempts : undefined
-		if (modelResult.text) {
-			summary = modelResult.text
-			summaryMode = "model"
-			summarizerModelRef = modelResult.usedModelRef
-		} else {
-			// All configured models failed or returned empty — fall back to the
-			// programmatic digest, but mark the mode distinctly so the fallback
-			// is visible in DCP debug logs.
-			summaryMode = "programmatic_fallback"
-		}
-	}
-	if (!summary) {
-		summary = buildExtractiveSummary(topic, effectiveCandidate, sourceManifest)
-		if (estimateTokens(summary) > 8192) {
-			throw new AutoCompressionBlockedError("budget-exhausted", "Extractive continuity minimum exceeds its 8192-token budget; no checkpoints were silently dropped")
-		}
-	}
+	const preparedSummary = await prepareCompressionSummary({
+		topic,
+		messages: messagesInRange,
+		candidate: effectiveCandidate,
+		modelRefs: settings.summarizerModel,
+		timeoutMs: settings.timeoutMs,
+		modelRegistry,
+		signal,
+	})
+	assertCurrent()
+	const summary = preparedSummary.text
+	const sourceManifest = preparedSummary.sourceManifest
+	const summaryMode: "programmatic" | "model" | "programmatic_fallback" =
+		preparedSummary.representation === "model"
+			? "model"
+			: preparedSummary.representation === "extractive-fallback"
+				? "programmatic_fallback"
+				: "programmatic"
+	const summarizerModelRef = preparedSummary.summarizerModelRef
+	const summarizerAttempts = preparedSummary.summarizerAttempts
 
 	const workingState = createAutoCompressionWorkingState(state)
 	const anchor = resolveAnchorBoundary(endTimestamp, workingState, endBoundary.stableId)
@@ -1004,8 +1056,8 @@ export async function createAutoCompressionBlock(
 		: summaryMode === "programmatic_fallback"
 			? "extractive-fallback"
 			: "extractive"
-	const sourceHash = hashSummarySourceManifest(sourceManifest)
-	const sourceCoverage = summarySourceCoverage(sourceManifest)
+	const sourceHash = preparedSummary.sourceHash
+	const sourceCoverage = preparedSummary.sourceCoverage
 	created.block.autoSummaryRepresentation = summaryRepresentation
 	created.block.sourceHash = sourceHash
 	created.block.sourceCoverage = sourceCoverage

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

@@ -179,6 +179,7 @@ const HELP_TEXT = `DCP — Dynamic Context Pruning
 Commands:
   /dcp context      — Show context window usage breakdown
   /dcp stats        — Show pruning statistics for this session
+  /dcp doctor       — Show config compatibility diagnostics
   /dcp sweep [N]    — Prune last N tool outputs (default: all since last user msg)
   /dcp manual       — Show manual mode status
   /dcp manual on    — Enable manual mode (disable autonomous compression nudges)
@@ -189,6 +190,18 @@ function handleHelp(ctx: ExtensionCommandContext): void {
   ctx.ui.notify(HELP_TEXT, "info")
 }
 
+function handleDoctor(ctx: ExtensionCommandContext, config: DcpConfig): void {
+  const issues = config.issues ?? []
+  const lines = ["DCP Doctor", ""]
+  if (issues.length === 0) {
+    lines.push("Config: no removed or ignored DCP settings detected.")
+  } else {
+    lines.push(`Config: ${issues.length} removed/ignored setting${issues.length === 1 ? "" : "s"}:`)
+    for (const issue of issues) lines.push(`  - ${issue}`)
+  }
+  ctx.ui.notify(lines.join("\n"), issues.length > 0 ? "warning" : "info")
+}
+
 // ---------------------------------------------------------------------------
 // Context usage
 // ---------------------------------------------------------------------------
@@ -434,6 +447,7 @@ export function registerCommands(
       const subcommands: AutocompleteItem[] = [
         { value: "context", label: "context", description: "Show context window usage breakdown" },
         { value: "stats", label: "stats", description: "Show pruning statistics" },
+        { value: "doctor", label: "doctor", description: "Show config compatibility diagnostics" },
         { value: "sweep", label: "sweep", description: "Prune tool outputs" },
         { value: "manual", label: "manual", description: "Toggle manual mode" },
         { value: "compress", label: "compress", description: "Trigger LLM compression" },
@@ -469,6 +483,10 @@ export function registerCommands(
             handleStats(pi, ctx, state)
             break
 
+          case "doctor":
+            handleDoctor(ctx, config)
+            break
+
           case "sweep": {
             const rawN = parts[1] !== undefined ? parseInt(parts[1], 10) : 0
             const n = isNaN(rawN) || rawN < 0 ? 0 : rawN

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

@@ -30,8 +30,55 @@ import {
   detectToolGroupSpans,
   findConversationIndexEntry,
 } from "./conversation-index.js"
-import { previewManualCompressionProjection } from "./compression-preview.js"
+import {
+  previewManualCompressionProjection,
+  verifiedManualCompressionMessages,
+} from "./compression-preview.js"
 import { settleCompressionProgress } from "./compression-progress.js"
+import { estimateMessageTokens } from "./pruner-metadata.js"
+import {
+  buildSummarySourceManifest,
+  hashSummarySourceManifest,
+  prepareCompressionSummary,
+  type ModelSummaryAttempt,
+} from "./auto-compress.js"
+
+export const COMPRESS_TOOL_PARAMETERS = Type.Object({
+  topic: Type.String({
+    description:
+      "Short label (3-5 words) for display - e.g., 'Auth System Exploration'",
+  }),
+  ranges: Type.Optional(Type.Array(
+    Type.Object({
+      startId: Type.String({
+        description:
+          "First ID (mNNN/bN); never start inside a tool group—include its calling assistant.",
+      }),
+      endId: Type.String({
+        description:
+          "Last ID (mNNN/bN); include all results of the final tool group, including parallel calls.",
+      }),
+      summary: Type.Optional(Type.String({
+        description: "Optional; omit to use the configured DCP summarizer.",
+      })),
+    }),
+    { description: "One or more ranges to compress" },
+  )),
+  messages: Type.Optional(Type.Array(
+    Type.Object({
+      messageId: Type.String({
+        description: "Raw message ID to compress individually (e.g. m001)",
+      }),
+      topic: Type.Optional(Type.String({
+        description: "Short label for this one-message summary; defaults to top-level topic",
+      })),
+      summary: Type.Optional(Type.String({
+        description: "Optional; omit to use the configured DCP summarizer.",
+      })),
+    }),
+    { description: "Individual raw messages to compress surgically" },
+  )),
+})
 
 type MessageSkipKind =
   | "duplicate"
@@ -51,7 +98,7 @@ interface MessageSkipIssue {
 interface ResolvedRangePlan {
   startId: string
   endId: string
-  summary: string
+  summary?: string
   startTimestamp: number
   endTimestamp: number
   startMessageId?: string
@@ -63,7 +110,7 @@ interface ResolvedRangePlan {
 interface ResolvedMessagePlan {
   messageId: string
   topic: string
-  summary: string
+  summary?: string
   timestamp: number
   stableId?: string
   sourceMembers: CompressionMember[]
@@ -72,6 +119,33 @@ interface ResolvedMessagePlan {
 
 type ResolvedRangeBoundaries = Omit<ResolvedRangePlan, "sourceMembers" | "mutationMembers">
 
+type ManualSummaryMode = "explicit" | "model" | "extractive" | "extractive-fallback"
+
+function verifiedSelectionMessages(
+  state: DcpState,
+  sourceMembers: CompressionMember[],
+): any[] {
+  const projection = verifiedManualCompressionMessages(state)
+  const byStableId = new Map(
+    state.conversationIndexSnapshot.map((entry) => [entry.stableId, entry] as const),
+  )
+  return sourceMembers.map((member) => {
+    const entry = byStableId.get(member.stableId)
+    if (!entry || entry.contentHash !== member.hash || !Number.isSafeInteger(entry.index)) {
+      throw new Error(
+        `Manual compression summary source ${member.stableId} no longer matches the verified provider projection; refresh context and retry.`,
+      )
+    }
+    const message = projection[entry.index]
+    if (!message) {
+      throw new Error(
+        `Manual compression summary source ${member.stableId} is missing from the verified provider projection; refresh context and retry.`,
+      )
+    }
+    return message
+  })
+}
+
 function validateNonOverlappingRanges(plans: ResolvedRangeBoundaries[], state: DcpState): void {
   const sorted = [...plans].sort((a, b) =>
     compareCompressionBoundaries(
@@ -246,43 +320,7 @@ export function registerCompressTool(
     label: COMPRESS_TOOL_DESCRIPTION.label,
     description: COMPRESS_TOOL_DESCRIPTION.description,
     promptSnippet: COMPRESS_TOOL_DESCRIPTION.promptSnippet ?? "Compress ranges of conversation into summaries to manage context",
-    parameters: Type.Object({
-      topic: Type.String({
-        description:
-          "Short label (3-5 words) for display - e.g., 'Auth System Exploration'",
-      }),
-      ranges: Type.Optional(Type.Array(
-        Type.Object({
-          startId: Type.String({
-            description:
-              "First ID (mNNN/bN); never start inside a tool group—include its calling assistant.",
-          }),
-          endId: Type.String({
-            description:
-              "Last ID (mNNN/bN); include all results of the final tool group, including parallel calls.",
-          }),
-          summary: Type.String({
-            description:
-              "Continuation-focused technical summary; avoid raw JSON/code/diffs unless a short literal is required",
-          }),
-        }),
-        { description: "One or more ranges to compress" },
-      )),
-      messages: Type.Optional(Type.Array(
-        Type.Object({
-          messageId: Type.String({
-            description: "Raw message ID to compress individually (e.g. m001)",
-          }),
-          topic: Type.Optional(Type.String({
-            description: "Short label for this one-message summary; defaults to top-level topic",
-          })),
-          summary: Type.String({
-            description: "Continuation-focused technical summary replacing this raw message; avoid raw JSON/code/diffs unless required",
-          }),
-        }),
-        { description: "Individual raw messages to compress surgically" },
-      )),
-    }),
+    parameters: COMPRESS_TOOL_PARAMETERS,
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       _signal?.throwIfAborted()
@@ -462,6 +500,93 @@ export function registerCompressTool(
       }
       assertDisjointSelections(rangePlans, preflightMessages)
 
+      const summaryPreparations: Array<{
+        selection: string
+        mode: ManualSummaryMode
+        summarizerModelRef?: string
+        attempts?: Array<{ ref: string; outcome: ModelSummaryAttempt["outcome"] }>
+      }> = []
+      const resolveSummary = async (input: {
+        startId: string
+        endId: string
+        topic: string
+        sourceMembers: CompressionMember[]
+        explicitSummary?: string
+      }): Promise<string> => {
+        const selection = input.startId === input.endId
+          ? input.startId
+          : `${input.startId}..${input.endId}`
+        if (typeof input.explicitSummary === "string") {
+          summaryPreparations.push({ selection, mode: "explicit" })
+          return input.explicitSummary
+        }
+        const sourceMessages = verifiedSelectionMessages(state, input.sourceMembers)
+        const sourceManifest = buildSummarySourceManifest(sourceMessages)
+        const sourceHash = hashSummarySourceManifest(sourceManifest)
+        const prepared = await prepareCompressionSummary({
+          topic: input.topic,
+          messages: sourceMessages,
+          candidate: {
+            startId: input.startId,
+            endId: input.endId,
+            messageCount: sourceMessages.length,
+            estimatedTokens: sourceMessages.reduce((sum, message) => sum + estimateMessageTokens(message), 0),
+            includedBlockIds: [],
+            reason: "manual delegated summary",
+          },
+          modelRefs: effectiveConfig.compress.autoCompress.summarizerModel,
+          timeoutMs: effectiveConfig.compress.autoCompress.timeoutMs,
+          modelRegistry: (ctx as any).modelRegistry,
+          signal: _signal,
+          sourceManifest,
+        })
+        assertCurrent()
+        const refreshedMessages = verifiedSelectionMessages(state, input.sourceMembers)
+        const refreshedHash = hashSummarySourceManifest(buildSummarySourceManifest(refreshedMessages))
+        if (refreshedHash !== sourceHash || prepared.sourceHash !== sourceHash) {
+          throw new Error(
+            `stale_plan: manual compression summary source changed while preparing ${selection}`,
+          )
+        }
+        const attempts = prepared.summarizerAttempts?.map(({ ref, outcome }) => ({ ref, outcome }))
+        summaryPreparations.push({
+          selection,
+          mode: prepared.representation,
+          summarizerModelRef: prepared.summarizerModelRef,
+          attempts,
+        })
+        log("compress.summary_prepared", {
+          toolCallId: _toolCallId,
+          selection,
+          mode: prepared.representation,
+          summarizerModelRef: prepared.summarizerModelRef,
+          summarizerAttempts: prepared.summarizerAttempts,
+          sourceHash: prepared.sourceHash,
+          sourceCoverage: prepared.sourceCoverage,
+        })
+        return prepared.text
+      }
+
+      for (const range of rangePlans) {
+        range.summary = await resolveSummary({
+          startId: range.startId,
+          endId: range.endId,
+          topic: params.topic,
+          sourceMembers: range.sourceMembers,
+          explicitSummary: range.summary,
+        })
+      }
+      for (const plan of preflightMessages) {
+        plan.summary = await resolveSummary({
+          startId: plan.messageId,
+          endId: plan.messageId,
+          topic: plan.topic,
+          sourceMembers: plan.sourceMembers,
+          explicitSummary: plan.summary,
+        })
+      }
+      const preflightMessageById = new Map(preflightMessages.map((plan) => [plan.messageId, plan] as const))
+
       for (const range of rangePlans) {
         try {
           const anchor = resolveAnchorBoundary(range.endTimestamp, workingState, range.endMessageId)
@@ -478,7 +603,7 @@ export function registerCompressTool(
 
           const created = createRangeCompressionBlock({
             topic: params.topic,
-            summary: range.summary,
+            summary: range.summary!,
             startTimestamp: range.startTimestamp,
             endTimestamp: range.endTimestamp,
             startMessageId: range.startMessageId,
@@ -521,7 +646,6 @@ export function registerCompressTool(
       const seenMessageIds = new Set<string>()
 
       for (const entry of messages) {
-        const { summary } = entry
         const messageId = typeof entry.messageId === "string" ? entry.messageId.trim() : ""
         if (seenMessageIds.has(messageId)) {
           skippedMessageIssues.push({ kind: "duplicate", messageId })
@@ -604,7 +728,7 @@ export function registerCompressTool(
 
         const created = createRangeCompressionBlock({
           topic: entry.topic ?? params.topic,
-          summary,
+          summary: preflightMessageById.get(messageId)?.summary!,
           startTimestamp: meta.timestamp,
           endTimestamp: meta.timestamp,
           startMessageId: meta.stableId,
@@ -620,8 +744,8 @@ export function registerCompressTool(
           validatePlaceholders: false,
           expandPlaceholders: false,
           preparedProtectedFragments,
-          sourceMembers: preflightMessages.find((plan) => plan.messageId === messageId)?.sourceMembers,
-          mutationMembers: preflightMessages.find((plan) => plan.messageId === messageId)?.mutationMembers,
+          sourceMembers: preflightMessageById.get(messageId)?.sourceMembers,
+          mutationMembers: preflightMessageById.get(messageId)?.mutationMembers,
         })
         const block = created.block
         newBlockIds.push(block.id)
@@ -735,6 +859,7 @@ export function registerCompressTool(
       }
       const resultDetails = {
         ...visualDetails,
+        summaryPreparations,
         projectedBeforeTokens: projection?.projectedBeforeTokens,
         projectedAfterTokens: projection?.projectedAfterTokens,
         netGain: projection?.netGain,

package/external/pi-tools-suite/src/dcp/compression-blocks.ts

@@ -8,6 +8,7 @@ import type {
 import type { DcpConfig } from "./config.js"
 import { estimateTokens } from "./pruner-metadata.js"
 import { isToolRecordProtected } from "./pruner-tools.js"
+import { toolRecordContinuity } from "./protected-continuity.js"
 import { compareConversationStableIds, buildExactRangeMembership } from "./conversation-index.js"
 import { createHash } from "node:crypto"
 import { open, realpath } from "node:fs/promises"
@@ -570,10 +571,10 @@ function collectCurrentProtectedFragments(
 		if (!toolCallId) continue
 		const record = state.toolCalls.get(toolCallId)
 		if (!record || record.toolName === "compress" || !isToolRecordProtected(record, config)) continue
-		const output = (record.outputText ?? meta.text ?? "").trim()
-		if (!output) continue
-		const exact = `### Tool: ${record.toolName}\n${output}`
-		fragments.push(compressionProtectedFragment("tool", `tool:${toolCallId}`, exact))
+		const continuity = toolRecordContinuity(record, config)
+		const text = continuity.text?.trim()
+		if (!text) continue
+		fragments.push(compressionProtectedFragment("tool", `tool:${toolCallId}`, text))
 	}
 	return mergeProtectedFragments(fragments)
 }
@@ -657,51 +658,6 @@ function appendProtectedFragmentLedger(summary: string, fragments: CompressionPr
 		missing.map((fragment) => `\n\n${fragment.text}`).join("")
 }
 
-function appendProtectedToolOutputs(
-  summary: string,
-  startTimestamp: number,
-  endTimestamp: number,
-  state: DcpState,
-  config: DcpConfig,
-  ids: { startMessageId?: string; endMessageId?: string } = {},
-): string {
-  const protectedOutputs: string[] = []
-  const seenToolCallIds = new Set<string>()
-  const boundaries = rangeBoundaries(startTimestamp, endTimestamp, ids)
-
-  for (const meta of state.messageMetaSnapshot.values()) {
-    if (meta.blockId !== undefined) continue
-    if (!Number.isFinite(meta.timestamp)) continue
-    if (!isCompressionBoundaryWithinRange(
-      { timestamp: meta.timestamp, stableId: meta.stableId },
-      boundaries.start,
-      boundaries.end,
-      state,
-    )) continue
-    if (meta.role !== "toolResult" && meta.role !== "bashExecution") continue
-
-    const toolCallId = meta.toolCallId
-    if (!toolCallId || seenToolCallIds.has(toolCallId)) continue
-    const record = state.toolCalls.get(toolCallId)
-    if (!record) continue
-
-    // The compress tool's own JSON accounting output is control-plane data and
-    // rarely useful in future summaries; avoid recursively copying it.
-    if (record.toolName === "compress") continue
-    if (!isToolRecordProtected(record, config)) continue
-
-    const output = (record.outputText ?? meta.text ?? "").trim()
-    if (!output) continue
-
-    seenToolCallIds.add(toolCallId)
-    protectedOutputs.push(`\n### Tool: ${record.toolName}\n${output}`)
-  }
-
-  if (protectedOutputs.length === 0) return summary
-  const heading = "\n\nThe following protected tool outputs were included in this conversation section:"
-  return summary + heading + protectedOutputs.join("")
-}
-
 export function estimateVisibleRangeTokens(
   startTimestamp: number,
   endTimestamp: number,
@@ -945,20 +901,12 @@ export function createRangeCompressionBlock(
     ids,
   )
 
-  const expandedSummary = appendProtectedToolOutputs(
-    promptPreservedSummary,
-    startTimestamp,
-    endTimestamp,
-    state,
-    config,
-    ids,
-  )
   const protectedFragments = mergeProtectedFragments(
     collectInheritedProtectedFragments(coveredBlocks),
     collectCurrentProtectedFragments(startTimestamp, endTimestamp, state, config, mode, ids),
     preparedProtectedFragments,
   )
-  const ledgerPreservedSummary = appendProtectedFragmentLedger(expandedSummary, protectedFragments)
+  const ledgerPreservedSummary = appendProtectedFragmentLedger(promptPreservedSummary, protectedFragments)
 
   const block: CompressionBlock = {
     id: state.nextBlockId++,

package/external/pi-tools-suite/src/dcp/compression-preview.ts

@@ -58,6 +58,15 @@ function verifiedSnapshot(state: DcpState): any[] {
   return snapshot
 }
 
+/**
+ * Return a detached, verified copy of the exact provider projection used by
+ * manual compression. Generated summaries must use this source rather than
+ * reconstructing history from timestamps or persisted session entries.
+ */
+export function verifiedManualCompressionMessages(state: DcpState): any[] {
+  return cloneProjectionMessages(verifiedSnapshot(state))
+}
+
 function stripProjectionMetadata(message: any): any {
   const stripped = stripStaleDcpMetadataFromMessage(message)
   return copyDcpProvenance(message, stripped)