pi-ui-extend 1.0.39 → 1.0.41

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

@@ -4,6 +4,7 @@
 
 import { createHash } from "node:crypto"
 import type { DcpNudgeType } from "./pruner-types.js"
+import type { DcpBlockedReason } from "./progress-controller.js"
 
 /**
  * A record of a single tool call, keyed by toolCallId in DcpState.toolCalls.
@@ -15,11 +16,7 @@ export interface ToolRecord {
   toolName: string
   /** The arguments passed to the tool (from the corresponding ToolCall) */
   inputArgs: Record<string, unknown>
-  /**
-   * Deduplication fingerprint: `toolName::sha256:<hash>` where the hash is
-   * computed over recursively key-sorted args. Two calls with the same name +
-   * identical args share the same fingerprint without persisting full args.
-   */
+  /** Stable input fingerprint: `toolName::sha256:<hash>` over key-sorted args. */
   inputFingerprint: string
   /** Whether the tool result was an error */
   isError: boolean
@@ -43,6 +40,8 @@ export interface MessageIdMeta {
   timestamp: number
   /** Stable raw message key when available; falls back to timestamp-derived key. */
   stableId?: string
+  /** SHA-256 of canonical provider-visible content at snapshot publication. */
+  contentHash?: string
   /** The message role at the time the id was injected. */
   role: string
   /** Present when this addressable message represents an active compression block. */
@@ -50,6 +49,8 @@ export interface MessageIdMeta {
   /** Tool call metadata for tool-result-like messages. */
   toolCallId?: string
   toolName?: string
+  /** Tool calls emitted by an assistant message; these messages are structurally coupled to their results. */
+  toolCallIds?: string[]
   /** Plain text extracted from the message when the id was injected. */
   text?: string
   /** Rough token estimate for priority/candidate guidance. */
@@ -58,6 +59,64 @@ export interface MessageIdMeta {
   priority?: "low" | "medium" | "high"
 }
 
+export interface ConversationIndexEntry {
+  /** Position in the current projected branch before DCP metadata carriers. */
+  index: number
+  /** Stable identity of this projected message. */
+  stableId: string
+  /** SHA-256 of the canonical provider-visible message content. */
+  contentHash: string
+  /**
+   * Canonical hash of the raw session message before DCP rewrote this
+   * projection entry's body (e.g. a tool-output placeholder). Equals
+   * `contentHash` for untouched entries. Runtime-only; exact mutation
+   * membership binds to this so a later raw pass still materializes the block.
+   * Omitted when the raw and projected hashes are identical.
+   */
+  rawContentHash?: string
+  /** Persistent mNNN identifier when the message is addressable as raw content. */
+  visibleId?: string
+  /** Message role in the current projection. */
+  role: string
+  /** Message timestamp when finite. */
+  timestamp?: number
+  /** Active block represented by this projected placeholder, when any. */
+  blockId?: number
+  /** Tool result identity for result-like messages. */
+  toolCallId?: string
+  /** Tool calls emitted by an assistant message. */
+  toolCallIds?: string[]
+  /** PI-internal entries are not directly addressable but remain part of range closure. */
+  passthrough: boolean
+  /** Provenance of this projected entry; never inferred from model-visible text. */
+  origin: "raw" | "block" | "dcp-control"
+  /** Signed assistant content must never be edited in place. */
+  signedAssistant: boolean
+}
+
+export interface CompressionProtectedFragment {
+  kind: "user" | "prompt" | "tool"
+  /** Stable provenance key; not rendered into provider-visible context. */
+  origin: string
+  /** SHA-256 of the exact protected text. */
+  hash: string
+  /** Exact text that must survive rollups. */
+  text: string
+}
+
+/**
+ * An immutable source/mutation member recorded by modern compression blocks.
+ *
+ * `stableId` identifies one occurrence in the canonical branch sequence and
+ * `hash` binds that identity to its original provider-visible content. The
+ * timestamp is deliberately not part of this record: host imports/reloads can
+ * normalize timestamps without changing the actual message.
+ */
+export interface CompressionMember {
+  stableId: string
+  hash: string
+}
+
 /**
  * A compression block created by the `compress` tool.
  * Tracks the range of messages that were summarised and where to inject the
@@ -88,6 +147,8 @@ export interface CompressionBlock {
   anchorMessageId?: string
   /** Tool call ID of the compress invocation that created this block. */
   createdByToolCallId?: string
+  /** Binds idempotent manual replay to the exact requested parameters. */
+  operationRequestHash?: string
   /** Whether this block is still being applied (false = soft-deleted) */
   active: boolean
   /** Token estimate for the summary text itself */
@@ -98,8 +159,38 @@ export interface CompressionBlock {
   coveredBlockIds?: number[]
   /** Whether this block was created from a range or a single raw message. */
   mode?: "range" | "message"
-  /** Set when a user explicitly decompressed this block via /dcp decompress. */
-  deactivatedByUser?: boolean
+  /**
+   * Exact projection semantics. New journal sessions only accept version 2
+   * blocks, planned before commit without widening their mutation set.
+   */
+  version?: 2
+  /** Exact v2 materialization behavior. */
+  replacementMode?: "range" | "message-body"
+  /**
+   * Exact provider-projection entries that supplied this summary. For a
+   * roll-up this can contain a synthetic block placeholder while
+   * `mutationMembers` contains that placeholder's canonical raw provenance.
+   */
+  sourceMembers?: CompressionMember[]
+  /**
+   * Exact canonical raw entries that a v2 application is allowed to replace.
+   * The apply path requires every member, in this order and with this hash, to
+   * be present contiguously before it mutates the projection.
+   */
+  mutationMembers?: CompressionMember[]
+  /** E06 provenance for automatically prepared summaries. */
+  autoSummaryRepresentation?: "model" | "extractive" | "extractive-fallback"
+  /** SHA-256 of the bounded source manifest used by the auto summary. */
+  sourceHash?: string
+  /** Bounded source-manifest coverage recorded at auto-summary commit. */
+  sourceCoverage?: {
+    itemCount: number
+    truncatedItems: number
+    toolCallCount: number
+    toolResultCount: number
+  }
+  /** Exact protected continuity fragments carried across rollups. */
+  protectedFragments?: CompressionProtectedFragment[]
   /** Internal reason for automatic soft-deactivation. */
   deactivatedReason?: string
 }
@@ -139,7 +230,29 @@ export interface DcpLastNudge {
 /**
  * Full runtime state for the DCP extension.
  */
+export interface DcpProgressRecovery {
+  blockedReason: DcpBlockedReason
+  projectedBeforeTokens: number
+  inputCapacityTokens: number
+  requiredSavingsTokens: number
+  contextWindow: number
+  createdAt: number
+}
+
+/** Outstanding net savings goal; a small successful block is not necessarily relief. */
+export interface DcpCompressionProgress {
+  remainingTokens: number
+  projectedTokens: number
+  contextWindow: number
+  kind: "routine" | "emergency"
+  /** Last budget observation; unchanged native usage must not undo partial savings. */
+  observedTokens?: number
+  targetHeadroomTokens?: number
+}
+
 export interface DcpState {
+  /** Runtime-only owner epoch. Incremented whenever the active session state is replaced. */
+  sessionEpoch: number
   // ── Tool tracking ──────────────────────────────────────────────────────────
   /** toolCallId → ToolRecord, populated when a tool_result event fires */
   toolCalls: Map<string, ToolRecord>
@@ -147,7 +260,7 @@ export interface DcpState {
   prunedToolIds: Set<string>
   /** toolCallId → reason used for human-readable pruning placeholders/stats. */
   prunedToolReasons: Map<string, string>
-  /** Tool results included in at least one provider request. */
+  /** Tool results consumed by at least one successfully completed provider response stream. */
   providerSeenToolIds: Set<string>
 
   // ── Compression ────────────────────────────────────────────────────────────
@@ -168,6 +281,8 @@ export interface DcpState {
   messageIdSnapshot: Map<string, number>
   /** Extra metadata for the model-visible DCP message IDs in messageIdSnapshot. */
   messageMetaSnapshot: Map<string, MessageIdMeta>
+  /** Ephemeral canonical projection index from the latest context pass. */
+  conversationIndexSnapshot: ConversationIndexEntry[]
   /** Stable message identity → persistent model-visible mNNN assignment. */
   messageIdsByStableId: Map<string, string>
   /** Monotonic counter for persistent message IDs. */
@@ -180,11 +295,6 @@ export interface DcpState {
    * context array in the `context` event handler.
    */
   currentTurn: number
-  /** Last user-turn count at which automatic prune discovery ran. */
-  lastAutomaticPruneTurn: number
-  /** Highest created block ID at the last automatic-prune checkpoint. */
-  lastAutomaticPruneBlockId: number
-
   // ── Statistics ─────────────────────────────────────────────────────────────
   /** Running total of tokens estimated to have been saved by pruning/compression */
   tokensSaved: number
@@ -204,9 +314,9 @@ export interface DcpState {
   accountedPrunedToolIds: Set<string>
   // ── Mode ───────────────────────────────────────────────────────────────────
   /**
-   * When true, the extension will not autonomously emit compress nudges.
-   * Automatic deduplication/error-purge strategies may still run depending on
-   * the `manualMode.automaticStrategies` config flag.
+   * When true, DCP will not autonomously create summaries or routine nudges.
+   * The explicit compress tool and bounded emergency safety behavior retain
+   * their separate contracts.
    */
   manualMode: boolean
 
@@ -240,12 +350,16 @@ export interface DcpState {
    */
   lastContextWindow?: number
   /**
-   * How many consecutive emergency context reminders have been delivered
-   * without a successful compression or emergency prune. This advances even
-   * when no normal compression candidate exists so current-turn fallback
-   * patience cannot be reset by the exact condition it is designed to handle.
+   * How many completed, correlated main-provider opportunities contained an
+   * emergency DCP reminder without sufficient committed compression/pruning gain.
+   * Repeated `context` transforms and retries do not advance this counter.
    */
   consecutiveIgnoredStrongNudges: number
+  /** Completed provider opportunities with any actionable reminder, including failed compress attempts. */
+  consecutiveIgnoredNudges: number
+  compressionProgress?: DcpCompressionProgress
+  /** Last terminal E05 handoff, persisted so restart does not hide why progress stopped. */
+  progressRecovery?: DcpProgressRecovery
 }
 
 // ---------------------------------------------------------------------------
@@ -255,6 +369,7 @@ export interface DcpState {
 /** Create a fresh, zeroed DcpState instance. */
 export function createState(): DcpState {
   return {
+    sessionEpoch: 1,
     toolCalls: new Map(),
     prunedToolIds: new Set(),
     prunedToolReasons: new Map(),
@@ -263,11 +378,10 @@ export function createState(): DcpState {
     nextBlockId: 1,
     messageIdSnapshot: new Map(),
     messageMetaSnapshot: new Map(),
+    conversationIndexSnapshot: [],
     messageIdsByStableId: new Map(),
     nextMessageId: 1,
     currentTurn: 0,
-    lastAutomaticPruneTurn: -1,
-    lastAutomaticPruneBlockId: 0,
     tokensSaved: 0,
     totalPruneCount: 0,
     totalToolCallCount: 0,
@@ -282,6 +396,9 @@ export function createState(): DcpState {
     lastNudge: undefined,
     lastContextWindow: undefined,
     consecutiveIgnoredStrongNudges: 0,
+    consecutiveIgnoredNudges: 0,
+    compressionProgress: undefined,
+    progressRecovery: undefined,
   }
 }
 
@@ -291,6 +408,7 @@ export function createState(): DcpState {
  * reset immediately.
  */
 export function resetState(state: DcpState): void {
+  state.sessionEpoch = Math.max(1, Math.floor(state.sessionEpoch || 0) + 1)
   state.toolCalls.clear()
   state.prunedToolIds.clear()
   state.prunedToolReasons.clear()
@@ -299,11 +417,10 @@ export function resetState(state: DcpState): void {
   state.nextBlockId = 1
   state.messageIdSnapshot.clear()
   state.messageMetaSnapshot.clear()
+  state.conversationIndexSnapshot = []
   state.messageIdsByStableId.clear()
   state.nextMessageId = 1
   state.currentTurn = 0
-  state.lastAutomaticPruneTurn = -1
-  state.lastAutomaticPruneBlockId = 0
   state.tokensSaved = 0
   state.totalPruneCount = 0
   state.totalToolCallCount = 0
@@ -318,546 +435,32 @@ export function resetState(state: DcpState): void {
   state.lastNudge = undefined
   state.lastContextWindow = undefined
   state.consecutiveIgnoredStrongNudges = 0
+  state.consecutiveIgnoredNudges = 0
+  state.compressionProgress = undefined
+  state.progressRecovery = undefined
 }
 
-/**
- * Merge compression blocks (and their accounting) from a source sidecar into
- * the current state without clobbering other fields. Used at session_start to
- * carry compression state across fork/resume/new into a session whose own
- * sidecar is empty.
- *
- * Returns the number of newly added blocks (blocks whose id already exists are
- * skipped). Accounting is carried over so inherited blocks are neither lost
- * nor double-counted when later folded by a new compression range.
- */
-export function inheritCompressionBlocks(state: DcpState, data: unknown): number {
-  if (!data || typeof data !== "object") return 0
-  const saved = data as Partial<SerializedDcpState>
-  if (!Array.isArray(saved.compressionBlocks) || saved.compressionBlocks.length === 0) return 0
-
-  const existingIds = new Set(state.compressionBlocks.map((b) => b.id))
-  const validBlocks = saved.compressionBlocks
-    .filter(
-      (b: any) =>
-        b && Number.isFinite(b.startTimestamp) && Number.isFinite(b.endTimestamp),
-    )
-    .map((b: any) => ({
-      ...b,
-      anchorTimestamp: Number.isFinite(b.anchorTimestamp)
-        ? b.anchorTimestamp
-        : b.endTimestamp + 1,
-    })) as CompressionBlock[]
-
-  const toAdd = validBlocks.filter((b) => !existingIds.has(b.id))
-  if (toAdd.length === 0) return 0
-
-  state.compressionBlocks.push(...toAdd)
-  state.nextBlockId =
-    Math.max(state.nextBlockId, ...state.compressionBlocks.map((b) => b.id)) + 1
-
-  if (Array.isArray(saved.accountedCompressionBlockIds)) {
-    for (const id of saved.accountedCompressionBlockIds) {
-      if (typeof id === "number") state.accountedCompressionBlockIds.add(id)
-    }
-  }
-  if (Array.isArray(saved.compressionTokenSavings)) {
-    for (const [id, val] of saved.compressionTokenSavings) {
-      if (
-        typeof id === "number" &&
-        typeof val === "number" &&
-        !state.compressionTokenSavings.has(id)
-      ) {
-        state.compressionTokenSavings.set(id, val)
-      }
-    }
-  }
-  if (typeof saved.tokensSaved === "number" && saved.tokensSaved > state.tokensSaved) {
-    state.tokensSaved = saved.tokensSaved
-  }
-
-  return toAdd.length
-}
+const COMPRESSION_MEMBER_HASH_RE = /^[a-f0-9]{64}$/i
 
-/**
- * Compact tool record for persistence — strips outputText, outputDetails,
- * and truncates/summarises inputArgs to keep serialized state bounded.
- */
-export interface CompactToolRecord {
-  toolCallId: string
-  toolName: string
-  inputFingerprint: string
-  isError: boolean
-  turnIndex: number
-  timestamp: number
-  tokenEstimate: number
-  /**
-   * Extracted string values from inputArgs that could match file-protection
-   * patterns, persisted so `isProtectedByFilePattern` still works after
-   * session restore. Capped to avoid bloating state with huge arg values.
-   */
-  inputStringValues?: string[]
-}
-
-/**
- * Maximum number of recent tool records retained in persisted state.
- * Older records are still kept when referenced by active compression blocks,
- * pruned tool IDs, or accounted prune IDs.
- */
-export const PERSISTED_TOOL_CALLS_MAX_RECENT = 200
-
-/**
- * Maximum length of individual string values extracted from inputArgs
- * for file-pattern matching. Longer values are truncated.
- */
-const INPUT_STRING_VALUE_MAX_LENGTH = 512
-
-/**
- * Maximum number of inputStringValues to keep per tool record.
- */
-const INPUT_STRING_VALUES_MAX_COUNT = 20
-
-export interface SerializedDcpState {
-  compressionBlocks: CompressionBlock[]
-  nextBlockId: number
-  prunedToolIds: string[]
-  prunedToolReasons: Array<[string, string]>
-  /** Tool result IDs known to have appeared in a provider request. */
-  providerSeenToolIds?: string[]
-  /** Full tool records — present in legacy snapshots. */
-  toolCalls?: ToolRecord[]
-  /** Compact tool records — present in new compact snapshots. */
-  compactToolCalls?: CompactToolRecord[]
-  /**
-   * Total number of tool calls observed during the session, including those
-   * trimmed from the persisted snapshot. Allows `/dcp stats` to report
-   * approximate totals.
-   */
-  totalToolCallCount?: number
-  tokensSaved: number
-  totalPruneCount: number
-  accountedCompressionBlockIds: number[]
-  compressionTokenSavings: Array<[number, number]>
-  accountedPrunedToolIds: string[]
-  manualMode: boolean
-  nudgeAnchors?: DcpNudgeAnchor[]
-  nextNudgeAnchorId?: number
-  lastNudge?: DcpLastNudge
-  /** Persistent stable-identity → mNNN assignments. */
-  messageIdsByStableId?: Array<[string, string]>
-  nextMessageId?: number
-  /**
-   * Persisted since v??. `context` events re-seed currentTurn from raw
-   * messages, but keeping it across session restarts gives diagnostics and
-   * telemetry a contiguous turn counter instead of resetting to 0.
-   */
-  currentTurn?: number
-  /** Automatic pruning runs only when one of these checkpoints changes. */
-  lastAutomaticPruneTurn?: number
-  lastAutomaticPruneBlockId?: number
-  /**
-   * Persisted since v?.?. Without persistence a pi process restart silently
-   * reset the nudge cadence counter to 0, which could suppress the next
-   * reminder on a session that was already near a context threshold.
-   */
-  nudgeCounter?: number
-  /** Persisted since v?.?. Diagnostic turn of the last emitted nudge. */
-  lastNudgeTurn?: number
-  /**
-   * Persisted so a mid-session window downgrade (model switch to a smaller
-   * context window) is still detectable after a pi process restart / resume.
-   */
-  lastContextWindow?: number
-  /**
-   * Persisted so the auto-compress fallback's patience counter survives a pi
-   * process restart / resume, preventing a stuck "model ignores strong nudges"
-   * state from being silently cleared by a reload.
-   */
-  consecutiveIgnoredStrongNudges?: number
-  /** Hash of the last persisted serialized state, used for dedup. */
-  _stateHash?: string
-}
-
-function isToolRecord(value: unknown): value is ToolRecord {
+function isCompressionMember(value: unknown): value is CompressionMember {
   if (!value || typeof value !== "object") return false
-  const record = value as Partial<ToolRecord>
+  const member = value as Partial<CompressionMember>
   return (
-    typeof record.toolCallId === "string" &&
-    typeof record.toolName === "string" &&
-    typeof record.inputFingerprint === "string"
+    typeof member.stableId === "string" &&
+    member.stableId.length > 0 &&
+    typeof member.hash === "string" &&
+    COMPRESSION_MEMBER_HASH_RE.test(member.hash)
   )
 }
 
-function isCompactToolRecord(value: unknown): value is CompactToolRecord {
-  if (!value || typeof value !== "object") return false
-  const record = value as Partial<CompactToolRecord>
-  return (
-    typeof record.toolCallId === "string" &&
-    typeof record.toolName === "string" &&
-    typeof record.inputFingerprint === "string"
-  )
+function isCompressionMemberList(value: unknown): value is CompressionMember[] {
+  if (!Array.isArray(value) || value.length === 0 || !value.every(isCompressionMember)) return false
+  return new Set(value.map((member) => member.stableId)).size === value.length
 }
 
-function isNudgeAnchor(value: unknown): value is DcpNudgeAnchor {
-  if (!value || typeof value !== "object") return false
-  const anchor = value as Partial<DcpNudgeAnchor>
-  return (
-    typeof anchor.id === "number" &&
-    typeof anchor.type === "string" &&
-    Number.isFinite(anchor.anchorTimestamp) &&
-    typeof anchor.anchorRole === "string" &&
-    typeof anchor.turnIndex === "number" &&
-    typeof anchor.createdAt === "number" &&
-    typeof anchor.updatedAt === "number"
-  )
-}
-
-function isLastNudge(value: unknown): value is DcpLastNudge {
-  if (!value || typeof value !== "object") return false
-  const nudge = value as Partial<DcpLastNudge>
-  return (
-    typeof nudge.type === "string" &&
-    typeof nudge.anchorId === "number" &&
-    Number.isFinite(nudge.anchorTimestamp) &&
-    typeof nudge.createdAt === "number"
-  )
-}
-
-// ---------------------------------------------------------------------------
-// Compact tool-record helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Recursively extract string values from a nested object, matching the
- * logic in `pruner-tools.ts::collectStringValues`. Depth-limited to 6.
- */
-function extractStringValues(value: unknown, out: string[] = [], depth = 0): string[] {
-  if (depth > 6) return out
-  if (typeof value === "string") {
-    out.push(value)
-    return out
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) extractStringValues(item, out, depth + 1)
-    return out
-  }
-  if (value !== null && typeof value === "object") {
-    for (const item of Object.values(value as Record<string, unknown>)) {
-      extractStringValues(item, out, depth + 1)
-    }
-  }
-  return out
-}
-
-/**
- * Produce a compact tool record for persistence: strip outputText,
- * outputDetails, and reduce inputArgs to just extracted string values
- * for file-pattern protection checking.
- */
-export function compactifyToolRecord(record: ToolRecord): CompactToolRecord {
-  const stringValues = extractStringValues(record.inputArgs)
-  // Truncate individual values and limit total count
-  const cappedValues = stringValues
-    .slice(0, INPUT_STRING_VALUES_MAX_COUNT)
-    .map((v) => (v.length > INPUT_STRING_VALUE_MAX_LENGTH ? v.slice(0, INPUT_STRING_VALUE_MAX_LENGTH) : v))
-
-  const compact: CompactToolRecord = {
-    toolCallId: record.toolCallId,
-    toolName: record.toolName,
-    inputFingerprint: record.inputFingerprint,
-    isError: record.isError,
-    turnIndex: record.turnIndex,
-    timestamp: record.timestamp,
-    tokenEstimate: record.tokenEstimate,
-  }
-  if (cappedValues.length > 0) {
-    compact.inputStringValues = cappedValues
-  }
-  return compact
-}
-
-/**
- * Determine which tool-call IDs are referenced by active compression blocks
- * (via createdByToolCallId) or by pruned/accounted sets, and therefore must
- * be retained even when trimming old records.
- */
-function referencedToolCallIds(state: DcpState): Set<string> {
-  const refs = new Set<string>()
-  // Tool IDs referenced by active compression blocks
-  for (const block of state.compressionBlocks) {
-    if (block.active && block.createdByToolCallId) {
-      refs.add(block.createdByToolCallId)
-    }
-  }
-  // Pruned tool IDs
-  for (const id of state.prunedToolIds) refs.add(id)
-  // Accounted pruned tool IDs (superset of prunedToolIds in some cases)
-  for (const id of state.accountedPrunedToolIds) refs.add(id)
-  return refs
-}
-
-/** Serialize runtime state into a JSON-safe object for pi.appendEntry(). */
-export function serializeState(state: DcpState): SerializedDcpState {
-  // Build compact tool records, keeping referenced + recent ones.
-  const allRecords = Array.from(state.toolCalls.values())
-  const refs = referencedToolCallIds(state)
-
-  // Sort by timestamp descending so we can pick the most recent ones
-  const sorted = allRecords
-    .slice()
-    .sort((a, b) => b.timestamp - a.timestamp)
-
-  const compactToolCalls: CompactToolRecord[] = []
-  const seen = new Set<string>()
-
-  // First pass: always include referenced records
-  for (const record of sorted) {
-    if (refs.has(record.toolCallId)) {
-      compactToolCalls.push(compactifyToolRecord(record))
-      seen.add(record.toolCallId)
-    }
-  }
-
-  // Second pass: add recent records up to the limit
-  for (const record of sorted) {
-    if (seen.has(record.toolCallId)) continue
-    if (compactToolCalls.length >= PERSISTED_TOOL_CALLS_MAX_RECENT) break
-    compactToolCalls.push(compactifyToolRecord(record))
-    seen.add(record.toolCallId)
-  }
-
-  const persistedToolCallIds = new Set(compactToolCalls.map((record) => record.toolCallId))
-  const providerSeenToolIds = Array.from(state.providerSeenToolIds)
-    .filter((toolCallId) => persistedToolCallIds.has(toolCallId))
-
-  return {
-    compressionBlocks: state.compressionBlocks,
-    nextBlockId: state.nextBlockId,
-    prunedToolIds: Array.from(state.prunedToolIds),
-    prunedToolReasons: Array.from(state.prunedToolReasons.entries()),
-    providerSeenToolIds,
-    compactToolCalls,
-    totalToolCallCount: allRecords.length,
-    tokensSaved: state.tokensSaved,
-    totalPruneCount: state.totalPruneCount,
-    accountedCompressionBlockIds: Array.from(state.accountedCompressionBlockIds),
-    compressionTokenSavings: Array.from(state.compressionTokenSavings.entries()),
-    accountedPrunedToolIds: Array.from(state.accountedPrunedToolIds),
-    manualMode: state.manualMode,
-    nudgeAnchors: state.nudgeAnchors,
-    nextNudgeAnchorId: state.nextNudgeAnchorId,
-    lastNudge: state.lastNudge,
-    messageIdsByStableId: Array.from(state.messageIdsByStableId.entries()),
-    nextMessageId: state.nextMessageId,
-    currentTurn: state.currentTurn,
-    lastAutomaticPruneTurn: state.lastAutomaticPruneTurn,
-    lastAutomaticPruneBlockId: state.lastAutomaticPruneBlockId,
-    nudgeCounter: state.nudgeCounter,
-    lastNudgeTurn: state.lastNudgeTurn,
-    lastContextWindow: state.lastContextWindow,
-    consecutiveIgnoredStrongNudges: state.consecutiveIgnoredStrongNudges,
-  }
-}
-
-/**
- * Restore persisted DCP state into an already-reset state object.
- * Handles older persisted payloads that did not include the newer accounting
- * and tool-call fingerprint fields.
- */
-export function restoreState(state: DcpState, data: unknown): void {
-  if (!data || typeof data !== "object") return
-  const saved = data as Partial<SerializedDcpState>
-
-  if (Array.isArray(saved.compressionBlocks)) {
-    const validBlocks = saved.compressionBlocks
-      .filter((b: any) => Number.isFinite(b?.startTimestamp) && Number.isFinite(b?.endTimestamp))
-      .map((b: any) => ({
-        ...b,
-        anchorTimestamp: Number.isFinite(b.anchorTimestamp)
-          ? b.anchorTimestamp
-          : b.endTimestamp + 1,
-      })) as CompressionBlock[]
-    state.compressionBlocks = validBlocks
-    state.nextBlockId =
-      typeof saved.nextBlockId === "number"
-        ? saved.nextBlockId
-        : validBlocks.length > 0
-          ? Math.max(0, ...validBlocks.map((b) => b.id)) + 1
-          : 1
-  }
-
-  if (Array.isArray(saved.prunedToolIds)) {
-    state.prunedToolIds = new Set(saved.prunedToolIds.filter((id): id is string => typeof id === "string"))
-  }
-
-  if (Array.isArray(saved.prunedToolReasons)) {
-    state.prunedToolReasons = new Map(
-      saved.prunedToolReasons.filter(
-        (entry): entry is [string, string] =>
-          Array.isArray(entry) && typeof entry[0] === "string" && typeof entry[1] === "string",
-      ),
-    )
-  }
-
-  if (Array.isArray(saved.providerSeenToolIds)) {
-    state.providerSeenToolIds = new Set(
-      saved.providerSeenToolIds.filter((id): id is string => typeof id === "string"),
-    )
-  }
-
-  if (Array.isArray(saved.compactToolCalls)) {
-    // New compact format: restore CompactToolRecords as ToolRecords with
-    // synthetic inputArgs derived from inputStringValues.
-    state.toolCalls = new Map(
-      saved.compactToolCalls
-        .filter(isCompactToolRecord)
-        .map((compact) => {
-          const record: ToolRecord = {
-            toolCallId: compact.toolCallId,
-            toolName: compact.toolName,
-            // Reconstruct minimal inputArgs from persisted string values
-            // so isProtectedByFilePattern still works.
-            inputArgs: compact.inputStringValues
-              ? { _restoredValues: compact.inputStringValues }
-              : {},
-            inputFingerprint: compact.inputFingerprint,
-            isError: compact.isError,
-            turnIndex: compact.turnIndex,
-            timestamp: compact.timestamp,
-            tokenEstimate: compact.tokenEstimate,
-            // outputText and outputDetails intentionally not restored —
-            // they are only used during live compression block creation.
-          }
-          return [record.toolCallId, record] as const
-        }),
-    )
-  } else if (Array.isArray(saved.toolCalls)) {
-    // Legacy full format: restore as-is for backward compatibility.
-    state.toolCalls = new Map(
-      saved.toolCalls
-        .filter(isToolRecord)
-        .map((record) => [record.toolCallId, record] as const),
-    )
-  }
-
-  if (typeof saved.tokensSaved === "number") state.tokensSaved = saved.tokensSaved
-  if (typeof saved.totalPruneCount === "number") state.totalPruneCount = saved.totalPruneCount
-
-  // Restore totalToolCallCount from the persisted snapshot, or fall back to
-  // the number of restored tool records (which may be a trimmed subset).
-  if (typeof saved.totalToolCallCount === "number" && saved.totalToolCallCount >= 0) {
-    state.totalToolCallCount = saved.totalToolCallCount
-  } else {
-    state.totalToolCallCount = state.toolCalls.size
-  }
-
-  if (Array.isArray(saved.accountedCompressionBlockIds)) {
-    state.accountedCompressionBlockIds = new Set(
-      saved.accountedCompressionBlockIds.filter((id): id is number => typeof id === "number"),
-    )
-  } else {
-    // Old payloads already persisted aggregate stats but not per-block accounting.
-    // Treat existing active blocks as accounted to avoid inflated stats after reload.
-    state.accountedCompressionBlockIds = new Set(state.compressionBlocks.map((b) => b.id))
-  }
-
-  if (Array.isArray(saved.compressionTokenSavings)) {
-    state.compressionTokenSavings = new Map(
-      saved.compressionTokenSavings.filter(
-        (entry): entry is [number, number] =>
-          Array.isArray(entry) && typeof entry[0] === "number" && typeof entry[1] === "number",
-      ),
-    )
-  }
-
-  if (Array.isArray(saved.accountedPrunedToolIds)) {
-    state.accountedPrunedToolIds = new Set(
-      saved.accountedPrunedToolIds.filter((id): id is string => typeof id === "string"),
-    )
-  } else {
-    // Same migration safety for pre-accounting payloads.
-    state.accountedPrunedToolIds = new Set(state.prunedToolIds)
-  }
-
-  if (typeof saved.manualMode === "boolean") {
-    state.manualMode = saved.manualMode
-  }
-
-  if (Array.isArray(saved.nudgeAnchors)) {
-    const seen = new Set<string>()
-    state.nudgeAnchors = saved.nudgeAnchors
-      .filter(isNudgeAnchor)
-      .filter((anchor) => {
-        const key = `${anchor.anchorStableId ?? ""}|${anchor.anchorTimestamp}`
-        if (seen.has(key)) return false
-        seen.add(key)
-        return true
-      })
-  }
-
-  if (typeof saved.nextNudgeAnchorId === "number" && saved.nextNudgeAnchorId > 0) {
-    state.nextNudgeAnchorId = Math.floor(saved.nextNudgeAnchorId)
-  } else if (state.nudgeAnchors.length > 0) {
-    state.nextNudgeAnchorId = Math.max(...state.nudgeAnchors.map((anchor) => anchor.id)) + 1
-  }
-
-  if (isLastNudge(saved.lastNudge)) {
-    state.lastNudge = saved.lastNudge
-  }
-
-  if (Array.isArray(saved.messageIdsByStableId)) {
-    const usedIds = new Set<string>()
-    const usedStableKeys = new Set<string>()
-    state.messageIdsByStableId = new Map(
-      saved.messageIdsByStableId.filter(
-        (entry): entry is [string, string] => {
-          if (!Array.isArray(entry) || typeof entry[0] !== "string" || typeof entry[1] !== "string") return false
-          if (!entry[0] || !/^m\d+$/.test(entry[1]) || usedIds.has(entry[1]) || usedStableKeys.has(entry[0])) return false
-          usedIds.add(entry[1])
-          usedStableKeys.add(entry[0])
-          return true
-        },
-      ),
-    )
-  }
-  const highestRestoredMessageId = Math.max(
-    0,
-    ...Array.from(state.messageIdsByStableId.values()).map((id) => Number.parseInt(id.slice(1), 10) || 0),
-  )
-  if (typeof saved.nextMessageId === "number" && Number.isFinite(saved.nextMessageId) && saved.nextMessageId > 0) {
-    state.nextMessageId = Math.max(Math.floor(saved.nextMessageId), highestRestoredMessageId + 1)
-  } else {
-    state.nextMessageId = highestRestoredMessageId + 1
-  }
-
-  // nudgeCounter: clamp to a non-negative integer so a corrupted payload
-  // cannot stall reminders by going negative. Default 0 keeps older sessions
-  // behaving like a fresh cadence on first post-restart context event.
-  if (typeof saved.nudgeCounter === "number" && Number.isFinite(saved.nudgeCounter) && saved.nudgeCounter >= 0) {
-    state.nudgeCounter = Math.floor(saved.nudgeCounter)
-  }
-
-  // lastNudgeTurn and currentTurn default to createState() values when absent
-  // (lastNudgeTurn = -1, currentTurn = 0). currentTurn is re-derived from
-  // raw messages on every `context` event, so persistence here is best-effort
-  // for telemetry continuity rather than authoritative.
-  if (typeof saved.lastNudgeTurn === "number" && Number.isFinite(saved.lastNudgeTurn)) {
-    state.lastNudgeTurn = Math.floor(saved.lastNudgeTurn)
-  }
-  if (typeof saved.currentTurn === "number" && Number.isFinite(saved.currentTurn) && saved.currentTurn >= 0) {
-    state.currentTurn = Math.floor(saved.currentTurn)
-  }
-  if (typeof saved.lastAutomaticPruneTurn === "number" && Number.isFinite(saved.lastAutomaticPruneTurn)) {
-    state.lastAutomaticPruneTurn = Math.floor(saved.lastAutomaticPruneTurn)
-  }
-  if (typeof saved.lastAutomaticPruneBlockId === "number" && Number.isFinite(saved.lastAutomaticPruneBlockId) && saved.lastAutomaticPruneBlockId >= 0) {
-    state.lastAutomaticPruneBlockId = Math.floor(saved.lastAutomaticPruneBlockId)
-  }
-  if (typeof saved.lastContextWindow === "number" && Number.isFinite(saved.lastContextWindow) && saved.lastContextWindow > 0) {
-    state.lastContextWindow = saved.lastContextWindow
-  }
-  if (typeof saved.consecutiveIgnoredStrongNudges === "number" && Number.isFinite(saved.consecutiveIgnoredStrongNudges) && saved.consecutiveIgnoredStrongNudges >= 0) {
-    state.consecutiveIgnoredStrongNudges = Math.floor(saved.consecutiveIgnoredStrongNudges)
-  }
+/** True only for a complete, unambiguous modern v2 membership record. */
+export function hasExactCompressionMembership(block: Pick<CompressionBlock, "sourceMembers" | "mutationMembers">): boolean {
+  return isCompressionMemberList(block.sourceMembers) && isCompressionMemberList(block.mutationMembers)
 }
 
 // ---------------------------------------------------------------------------
@@ -883,14 +486,7 @@ function sortObjectKeys(value: unknown): unknown {
   return value
 }
 
-/**
- * Create a stable deduplication fingerprint for a tool call.
- *
- * Two calls with the same `toolName` and semantically identical `args`
- * (regardless of key ordering) will produce the same fingerprint.
- *
- * Format: `<toolName>::sha256:<hash of recursively key-sorted args>`
- */
+/** Create a stable fingerprint for a tool call and canonicalized input args. */
 export function createInputFingerprint(
   toolName: string,
   args: Record<string, unknown>,
@@ -901,21 +497,3 @@ export function createInputFingerprint(
     .digest("hex")
   return `${toolName}::sha256:${hash}`
 }
-
-// ---------------------------------------------------------------------------
-// State hashing for save deduplication
-// ---------------------------------------------------------------------------
-
-/**
- * Compute a fast hash of serialized state for deduplication.
- * Uses a simple DJB2-like hash over the JSON string. This is not
- * cryptographic — it's only used to avoid writing identical snapshots.
- */
-export function hashSerializedState(serialized: SerializedDcpState): string {
-  const json = JSON.stringify(serialized)
-  let hash = 5381
-  for (let i = 0; i < json.length; i++) {
-    hash = ((hash << 5) + hash + json.charCodeAt(i)) | 0
-  }
-  return (hash >>> 0).toString(36)
-}