pi-ui-extend 1.0.41 → 1.0.45

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

@@ -2,10 +2,11 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import type { AutocompleteItem } from "@earendil-works/pi-tui"
 import type { DcpState } from "./state.js"
 import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./config.js"
-import type { DcpNudgeType } from "./pruner-types.js"
 import { isToolRecordProtected, markToolPruned } from "./pruner.js"
 import { ignoreStaleExtensionContextError, safeGetContextUsage } from "../context-usage.js"
 import { captureDcpTransactionGuard, cloneDcpTransactionState, runDcpStateTransaction } from "./state-transaction.js"
+import { readDcpJournalBranch } from "./journal.js"
+import { formatDcpStatistics } from "./statistics.js"
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -34,42 +35,6 @@ function fmt(n: number): string {
   return n.toLocaleString()
 }
 
-const NUDGE_TYPES: DcpNudgeType[] = ["turn", "iteration", "context-soft", "context-strong"]
-
-function pct(numerator: number, denominator: number): string {
-  if (denominator <= 0) return "n/a"
-  return `${((numerator / denominator) * 100).toFixed(1)}%`
-}
-
-function nudgeLabel(type: DcpNudgeType): string {
-  switch (type) {
-    case "context-strong": return "context-strong"
-    case "context-soft": return "context-soft"
-    case "iteration": return "iteration"
-    case "turn": return "turn"
-  }
-}
-
-function isNudgeType(value: unknown): value is DcpNudgeType {
-  return typeof value === "string" && (NUDGE_TYPES as string[]).includes(value)
-}
-
-function customEntryData(entry: unknown, customType: string): Record<string, unknown> | undefined {
-  const record = entry as { type?: unknown; customType?: unknown; data?: unknown }
-  if (record?.type !== "custom" || record.customType !== customType) return undefined
-  if (!record.data || typeof record.data !== "object" || Array.isArray(record.data)) return undefined
-  return record.data as Record<string, unknown>
-}
-
-function branchEntries(ctx: ExtensionCommandContext): any[] {
-  try {
-    const branch = ctx.sessionManager?.getBranch?.()
-    return Array.isArray(branch) ? branch : []
-  } catch {
-    return []
-  }
-}
-
 async function staleSafe(action: () => void | Promise<void>): Promise<void> {
   try {
     await action()
@@ -78,85 +43,6 @@ async function staleSafe(action: () => void | Promise<void>): Promise<void> {
   }
 }
 
-interface DcpNudgeStats {
-  emitted: number
-  reapplied: number
-  upgraded: number
-  clearedEvents: number
-  clearedAnchors: number
-  byType: Record<DcpNudgeType, number>
-  activeByType: Record<DcpNudgeType, number>
-  last?: {
-    type: DcpNudgeType
-    event: "emitted" | "reapplied" | "upgraded"
-    createdAt?: number
-    contextPercent?: number | null
-  }
-}
-
-function collectNudgeStats(ctx: ExtensionCommandContext, state: DcpState): DcpNudgeStats {
-  const stats: DcpNudgeStats = {
-    emitted: 0,
-    reapplied: 0,
-    upgraded: 0,
-    clearedEvents: 0,
-    clearedAnchors: 0,
-    byType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
-    activeByType: { "turn": 0, "iteration": 0, "context-soft": 0, "context-strong": 0 },
-  }
-
-  for (const anchor of state.nudgeAnchors) {
-    if (isNudgeType(anchor.type)) stats.activeByType[anchor.type]++
-  }
-
-  for (const entry of branchEntries(ctx)) {
-    const data = customEntryData(entry, "dcp-nudge")
-    if (!data) continue
-    const event = data.event
-    if ((event === "emitted" || event === "reapplied" || event === "upgraded") && isNudgeType(data.type)) {
-      if (event === "emitted") stats.emitted++
-      else if (event === "reapplied") stats.reapplied++
-      else stats.upgraded++
-      stats.byType[data.type]++
-      const createdAt = typeof data.createdAt === "number" ? data.createdAt : undefined
-      const rawContextPercent = data.contextPercent
-      let contextPercent: number | null | undefined
-      if (typeof rawContextPercent === "number") contextPercent = rawContextPercent
-      else if (rawContextPercent === null) contextPercent = null
-      if (!stats.last || (createdAt ?? 0) >= (stats.last.createdAt ?? 0)) {
-        stats.last = { type: data.type, event, createdAt, contextPercent }
-      }
-    } else if (event === "cleared") {
-      stats.clearedEvents++
-      stats.clearedAnchors += typeof data.clearedAnchors === "number" ? Math.max(0, data.clearedAnchors) : 0
-    }
-  }
-
-  if (!stats.last && state.lastNudge && isNudgeType(state.lastNudge.type)) {
-    stats.last = {
-      type: state.lastNudge.type,
-      event: "emitted",
-      createdAt: state.lastNudge.createdAt,
-      contextPercent: typeof state.lastNudge.contextPercent === "number"
-        ? state.lastNudge.contextPercent * 100
-        : undefined,
-    }
-  }
-
-  return stats
-}
-
-function formatDate(ts: number | undefined): string {
-  if (typeof ts !== "number" || !Number.isFinite(ts) || ts <= 0) return "unknown time"
-  return new Date(ts).toLocaleString()
-}
-
-function formatContextPercent(value: number | null | undefined): string {
-  if (value === null) return "unknown context"
-  if (typeof value !== "number" || !Number.isFinite(value)) return "unknown context"
-  return `${value.toFixed(1)}% context`
-}
-
 function sendChatSystemMessage(pi: ExtensionAPI, customType: string, content: string, details?: Record<string, unknown>): void {
 	pi.sendMessage({
 		customType,
@@ -179,6 +65,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 +76,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
 // ---------------------------------------------------------------------------
@@ -225,44 +124,16 @@ function handleContext(ctx: ExtensionCommandContext, state: DcpState): void {
 // Stats
 // ---------------------------------------------------------------------------
 
-function handleStats(pi: ExtensionAPI, ctx: ExtensionCommandContext, state: DcpState): void {
-  const activeBlocks = state.compressionBlocks.filter((b) => b.active).length
-  const totalBlocks = state.compressionBlocks.length
-  const nudgeStats = collectNudgeStats(ctx, state)
-  const totalNudgeEvents = nudgeStats.emitted + nudgeStats.reapplied + nudgeStats.upgraded
-  const activeAnchors = state.nudgeAnchors.length
-  const lines: string[] = []
-  lines.push("DCP Session Statistics:")
-  lines.push(`  Tokens saved (estimated): ${fmt(state.tokensSaved)}`)
-  lines.push(`  Total pruning operations: ${fmt(state.totalPruneCount)}`)
-  lines.push(`  Compression blocks active: ${activeBlocks} / ${totalBlocks} total`)
-  lines.push(`  Manual mode: ${state.manualMode ? "on" : "off"}`)
-  lines.push("")
-  lines.push("Nudge telemetry:")
-  lines.push(`  Sent: ${fmt(nudgeStats.emitted)} emitted, ${fmt(nudgeStats.reapplied)} reapplied, ${fmt(nudgeStats.upgraded)} upgraded`)
-  lines.push(
-    `  By type: ${NUDGE_TYPES.map((type) => `${nudgeLabel(type)}=${fmt(nudgeStats.byType[type])}`).join(", ")}`,
-  )
-  lines.push(
-    `  Active anchors: ${fmt(activeAnchors)}${activeAnchors > 0
-      ? ` (${NUDGE_TYPES.map((type) => `${nudgeLabel(type)}=${fmt(nudgeStats.activeByType[type])}`).join(", ")})`
-      : ""}`,
-  )
-  lines.push(`  Cleared after compress: ${fmt(nudgeStats.clearedEvents)} time${nudgeStats.clearedEvents === 1 ? "" : "s"} (${fmt(nudgeStats.clearedAnchors)} anchor${nudgeStats.clearedAnchors === 1 ? "" : "s"})`)
-  lines.push(`  Compliance proxy: ${fmt(nudgeStats.clearedEvents)} compress-after-nudge / ${fmt(totalNudgeEvents)} nudge event${totalNudgeEvents === 1 ? "" : "s"} (${pct(nudgeStats.clearedEvents, totalNudgeEvents)})`)
-  if (nudgeStats.last) {
-    lines.push(
-      `  Last nudge: ${nudgeLabel(nudgeStats.last.type)} ${nudgeStats.last.event} at ${formatDate(nudgeStats.last.createdAt)} (${formatContextPercent(nudgeStats.last.contextPercent)})`,
-    )
-  } else {
-    lines.push("  Last nudge: none recorded")
-  }
-
-  sendChatSystemMessage(pi, DCP_STATS_MESSAGE_TYPE, lines.join("\n"), {
-    generatedAt: new Date().toISOString(),
-    activeAnchors,
-    nudgeEvents: totalNudgeEvents,
-  })
+async function handleStats(pi: ExtensionAPI, ctx: ExtensionCommandContext, state: DcpState): Promise<void> {
+  const epoch = state.sessionEpoch
+  let branch: unknown[] = []
+  let historyStatus: "full" | "unavailable" = "full"
+  try { branch = await readDcpJournalBranch(ctx) }
+  catch { historyStatus = "unavailable" }
+  if (state.sessionEpoch !== epoch) return
+  sendChatSystemMessage(pi, DCP_STATS_MESSAGE_TYPE,
+    formatDcpStatistics({ branch, historyStatus, model: ctx.model, usage: safeGetContextUsage(ctx) }),
+    { generatedAt: new Date().toISOString() })
 }
 
 // ---------------------------------------------------------------------------
@@ -277,7 +148,7 @@ async function handleSweep(
 ): Promise<void> {
   await ctx.waitForIdle()
 
-  const branch = branchEntries(ctx)
+  const branch = await readDcpJournalBranch(ctx) as any[]
 
   // Build the full set of protected tool names.
   const protectedTools = new Set<string>([
@@ -434,6 +305,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" },
@@ -466,7 +338,11 @@ export function registerCommands(
             break
 
           case "stats":
-            handleStats(pi, ctx, state)
+            await handleStats(pi, ctx, state)
+            break
+
+          case "doctor":
+            handleDoctor(ctx, config)
             break
 
           case "sweep": {

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

@@ -5,7 +5,7 @@
 import { Type } from "typebox"
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
 import type { CompressionMember, DcpState } from "./state.js"
-import { modelKeysFromContext, resolveModelConfig, type DcpConfig } from "./config.js"
+import { modelKeysFromContext, resolveModelConfig, summarizerModelRefs, type DcpConfig } from "./config.js"
 import { captureDcpTransactionGuard, cloneDcpTransactionState, runDcpStateTransaction } from "./state-transaction.js"
 import { createHash } from "node:crypto"
 import { clearDcpNudgeAnchors } from "./pruner.js"
@@ -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: summarizerModelRefs(effectiveConfig.compress.autoCompress),
+          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)
@@ -671,6 +795,12 @@ export function registerCompressTool(
         for (const block of workingState.compressionBlocks) {
           if (newBlockIds.includes(block.id)) block.operationRequestHash = requestHash
         }
+        const firstBlock = workingState.compressionBlocks.find((block) => block.id === newBlockIds[0])
+        if (firstBlock) firstBlock.commitMetrics = {
+          operationId: `manual:${_toolCallId}`, kind: "manual",
+          beforeTokens: projection.projectedBeforeTokens,
+          afterTokens: projection.projectedAfterTokens, netGainTokens: projection.netGain,
+        }
         assertCurrent()
         let published = false
         await persistState(ctx, workingState, {
@@ -735,6 +865,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)