@diegopetrucci/pi-extensions 0.1.76 → 0.1.79

package/extensions/dynamic-context-pruning/index.ts

@@ -7,10 +7,7 @@ import {
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 
-// ============================================================================
-// Types (kept intentionally minimal/structural so pure helpers stay testable
-// without depending on the full @earendil-works/pi-ai type graph).
-// ============================================================================
+// Structural stand-ins so pure helpers stay testable without the full pi-ai type graph.
 
 export interface MinimalTextContent {
   type: "text";
@@ -143,27 +140,17 @@ export function normalizeSessionProjection(value: unknown): MinimalSessionProjec
   return { entries, messages: entries.flatMap((entry) => entry.messages) };
 }
 
-export function sessionProjectionToMessages(
-  projection: MinimalSessionProjection,
-): MinimalMessage[] {
-  return projection.entries.flatMap((entry) => entry.messages);
-}
-
-// ============================================================================
-// Constants
-// ============================================================================
-
 const EXTENSION_ID = "dynamic-context-pruning";
 const CONFIG_FILE_NAME = "dynamic-context-pruning.json";
 const DECISION_ENTRY_TYPE = "dynamic-context-pruning:decision";
 const STATS_ENTRY_TYPE = "dynamic-context-pruning:stats";
 /**
- * Restore/undo entries (pe-8re9): a lightweight tombstone that records "the
- * decision with this idempotencyKey should be treated as reverted". See
- * `resolvePruneTombstoneState` for the exact chronological resolution rule.
+ * Restore/undo entries: a lightweight tombstone that records "the decision
+ * with this idempotencyKey should be treated as reverted". See
+ * `resolvePruneTombstoneState` for the chronological last-event-wins rule.
  */
 const RESTORE_ENTRY_TYPE = "dynamic-context-pruning:restore";
-/** strategyId used for user-initiated prunes from the /prune picker (pe-8re9). Always source:"manual". */
+/** strategyId used for user-initiated prunes from the /prune picker. Always source:"manual". */
 const MANUAL_STRATEGY_ID = "manual";
 
 const DEFAULT_RECENT_TURNS = 4;
@@ -171,37 +158,10 @@ const DEFAULT_RECENT_TURNS = 4;
 /** Cache cost model default: fraction of full (non-cached) price still paid for cached tokens. */
 const DEFAULT_CACHED_PRICE_RATIO = 0.1;
 
-/**
- * Default net-benefit gate threshold (max amortization calls). Recalibrated
- * (pe-c5n9) from the representative-corpus benchmark (~/.the-last-harness/
- * agent/sessions, 1,390+ session files, 556 candidates): this is the
- * hindsight-optimal break-even T at cachedPriceRatio r=0.1 (aggressive
- * prompt caching, the common Anthropic case). IMPORTANT caveats:
- *  - Provider/ratio-dependent: this optimum shifts higher as caching gets
- *    weaker (T=29 at r=0.25, T=54 at r=0.5, T=58 at r=0.9 on the same
- *    corpus) — see docs/v2-design.md section 4 and the extension README.
- *  - At r=0.1 the realized deterministic savings this threshold buys are
- *    economically marginal (~20.6k token-units total across the whole
- *    corpus, i.e. pennies); savings only become material at r>=0.25.
- *  - Re-derive via `scripts/benchmark.mjs <sessions-dir> --ratio 0.1` if
- *    the representative corpus changes meaningfully.
- */
+/** Default idle net-benefit gate threshold; see README.md and docs/v2-design.md §4. */
 const DEFAULT_BREAK_EVEN_THRESHOLD = 22;
 
-/**
- * Default mid_loop break-even threshold (pe-zy4s follow-up). The package's own
- * representative-corpus benchmark (turn-START state definition — the same one
- * the runtime `context` handler uses) favored rejecting mid_loop candidates
- * at cachedPriceRatio r=0.1 (mid_loop-optimal T=1, total realized
- * net benefit ~0.0). This supports a conservative default for the measured
- * corpus, not a universal claim that mid_loop pruning cannot pay off.
- * The reported 2026-09-08 byte-level capture (a mid_loop prune at T=22
- * invalidating 81% of a warm request prefix) illustrates cache invalidation,
- * not an inability to amortize it: enough subsequent calls can recoup a
- * one-time bust. Idle keeps T=22; turn-start classification does not imply
- * the provider cache is cold. Users who want the old behavior can override
- * via gate.breakEvenThresholdByState.mid_loop.
- */
+/** Default mid_loop threshold; see README.md for the runtime-aligned benchmark rationale. */
 const DEFAULT_MID_LOOP_BREAK_EVEN_THRESHOLD = 1;
 
 /** Tool names never pruned by default: orchestration/subagent-style tools and todo-like state. */
@@ -240,10 +200,6 @@ const DEFAULT_ERROR_PURGE_MIN_TURNS_OLD = 4;
 const DEDUPE_STRATEGY_ID = "dedupe";
 const ERROR_PURGE_STRATEGY_ID = "error-purge";
 
-// ============================================================================
-// Config
-// ============================================================================
-
 export interface PruneProtections {
   /** Tool names (case-insensitive) whose calls are never pruned. */
   toolNames: string[];
@@ -254,22 +210,11 @@ export interface PruneProtections {
 }
 
 export interface PruneThresholds {
-  /**
-   * Minimum raw text characters a fresh AUTOMATIC prune proposal must remove
-   * (original text chars minus placeholder chars) to be considered at all
-   * (pe-qdzb). Enforced by `runDynamicContextPruningPipeline` BEFORE the
-   * net-benefit gate (see `PruneGateConfig`/`gate`, which uses break-even token
-   * math and is a separate, later check): text-only candidates below this floor
-   * are dropped up front and never reach gate/batch consideration. Image-bearing
-   * tool-result candidates bypass this raw-text floor (images receive no
-   * synthetic character count) and proceed to the token-based gate. Manual
-   * prunes and already-persisted/replayed decisions always bypass this floor,
-   * same as the gate. A value of 0 disables the floor (no filtering).
-   */
+  /** Minimum automatic-prune text saving; see README.md Configuration for bypass rules. */
   minCharsSaved: number;
 }
 
-/** Per-strategy toggles/config (pe-u8gd, pe-qs8j). Each strategy can be disabled independently. */
+/** Per-strategy toggles/config. Each strategy can be disabled independently. */
 export interface StrategiesConfig {
   dedupe: { enabled: boolean };
   errorPurge: {
@@ -277,11 +222,10 @@ export interface StrategiesConfig {
     /** A tool call's input is only eligible for purging once it is older than this many turns. */
     minTurnsOld: number;
   };
-  /** Superseded file-ops strategy (pe-qs8j): stale read/write/edit outputs replaced by a placeholder. */
+  /** Superseded file-ops strategy: stale read/write/edit outputs replaced by a placeholder. */
   supersededFileOps: { enabled: boolean };
 }
 
-/** Net-benefit gate operating mode (pe-s2ho). */
 export type GateMode = "on" | "off" | "always-apply";
 
 /**
@@ -484,11 +428,6 @@ async function writeConfig(config: DynamicContextPruningConfig): Promise<void> {
   await fs.writeFile(configPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
 }
 
-// ============================================================================
-// Token estimator (chars/4-style; deliberately simple, good enough for
-// relative before/after accounting used by later savings-accounting work).
-// ============================================================================
-
 export function estimateTokensForText(text: string): number {
   if (!text) return 0;
   return Math.max(0, Math.ceil(text.length / 4));
@@ -510,29 +449,8 @@ export function estimateTokensForContent(
 export type TokenEstimator = (text: string) => number;
 
 /**
- * Classify the agent's current state from the message payload alone (pe-zy4s):
- * this is the runtime-observable definition used both by the live `context`
- * event handler and (via re-export) by the offline benchmark, so the two can
- * never drift apart.
- *
- * Walk backwards from the end of `messages`, skipping any message that is
- * neither `user`, `assistant`, nor `toolResult` (e.g. system-role bookkeeping
- * entries). The first such message found determines the state:
- *  - `user` (a plain user turn message) => "idle": this call is the FIRST LLM
- *    call of a turn, i.e. the decision is being made from a turn-start state.
- *  - `assistant` or `toolResult` (mid-chain) => "mid_loop": the agent is
- *    iterating (already made at least one call this turn, or is reacting to a
- *    tool result).
- *  - No such message found (empty history, or system-only) => "idle" (safe
- *    default: nothing suggests an in-progress loop).
- *
- * The benchmark (scripts/benchmark.mjs) reclassifies its candidate labels to
- * this SAME definition (pe-zy4s), reusing this function directly, so the
- * defaults below rest on evidence measured with the exact definition the
- * runtime observes. (An earlier turn-end-based benchmark definition -- "idle"
- * meant "this IS the turn's last assistant message", only knowable in
- * hindsight -- has been retired: the runtime cannot know in advance whether a
- * call is a turn's last one, so that definition was never runtime-observable.)
+ * Shared runtime/benchmark state classifier; see README.md Configuration and
+ * docs/v2-design.md §4 for the turn-start definition and retired turn-end analysis.
  */
 export function classifyAgentStateFromMessages(messages: MinimalMessage[]): AgentState {
   for (let i = messages.length - 1; i >= 0; i--) {
@@ -544,7 +462,7 @@ export function classifyAgentStateFromMessages(messages: MinimalMessage[]): Agen
   return "idle";
 }
 
-/** Resolve which break-even threshold applies for a given agent state (pe-s2ho state-conditioning hook). */
+/** Resolve which break-even threshold applies for a given agent state. */
 export function resolveBreakEvenThreshold(
   gateConfig: PruneGateConfig,
   agentState: AgentState,
@@ -578,7 +496,7 @@ function estimateMessageTokens(message: MinimalMessage, estimateTokens: TokenEst
 
 /**
  * Sum estimated tokens for messages from `fromIndex` to the end of the array.
- * Used both for cache-bust tail sizing (pe-s2ho cost model) and for raw/
+ * Used both for cache-bust tail sizing and for raw/
  * effective context-size snapshots. Clamped to valid indices; an out-of-range
  * `fromIndex` (e.g. the very last message, or beyond) degrades gracefully.
  */
@@ -595,10 +513,6 @@ export function estimateTailTokens(
   return total;
 }
 
-// ============================================================================
-// Protections
-// ============================================================================
-
 function globToRegExp(glob: string): RegExp {
   let pattern = "^";
   for (let i = 0; i < glob.length; i++) {
@@ -698,7 +612,7 @@ export function isWithinRecencyWindow(index: number, boundaryIndex: number): boo
  * Used by the error-input purge strategy's "older than N turns" rule; a
  * message at the very end of the conversation has 0 turns elapsed.
  */
-export function computeTurnsElapsedSince(messages: MinimalMessage[], index: number): number {
+function computeTurnsElapsedSince(messages: MinimalMessage[], index: number): number {
   let count = 0;
   for (let i = index + 1; i < messages.length; i++) {
     if (messages[i].role === "user") count++;
@@ -706,10 +620,6 @@ export function computeTurnsElapsedSince(messages: MinimalMessage[], index: numb
   return count;
 }
 
-// ============================================================================
-// Correlation
-// ============================================================================
-
 export interface ToolCallPairIndices {
   assistantIndex?: number;
   toolCallBlockIndex?: number;
@@ -722,7 +632,7 @@ export interface ToolCallPairIndices {
  * toolCallIds against the same `messages` array (e.g. the pipeline's
  * per-decision protection/savings/apply passes) should build this once and
  * pass it to `findToolCallPairIndices` and friends to avoid an O(n) rescan
- * per decision (pe-e0zd).
+ * per decision.
  */
 export function buildToolCallPairIndex(
   messages: MinimalMessage[],
@@ -798,10 +708,6 @@ export function findToolCallPairIndices(
   return pair;
 }
 
-// ============================================================================
-// Proposals & persisted decisions
-// ============================================================================
-
 export type PruneTargetKind = "tool_result_content" | "tool_call_input";
 
 /**
@@ -826,7 +732,7 @@ export interface ProposedPrune {
 export interface PruneDecisionRecord {
   idempotencyKey: string;
   strategyId: string;
-  correlation: { type: "toolCallId"; toolCallId: string } | { type: "entryId"; entryId: string };
+  correlation: { type: "toolCallId"; toolCallId: string };
   kind: PruneTargetKind;
   reason: string;
   placeholder?: string;
@@ -843,15 +749,11 @@ export function buildIdempotencyKey(proposal: ProposedPrune): string {
  * omitting `strategyId` (unlike `idempotencyKey`). Two decisions from
  * different strategies that both replace the same tool result's content
  * share this key even though their idempotencyKeys differ — that's exactly
- * the overlap pe-j7sb collapses before gating/apply (see
+ * the overlap the pipeline collapses before gating/apply (see
  * `runDynamicContextPruningPipeline`).
  */
 function buildDecisionTargetKey(decision: PruneDecisionRecord): string {
-  const correlationId =
-    decision.correlation.type === "toolCallId"
-      ? decision.correlation.toolCallId
-      : decision.correlation.entryId;
-  return `${decision.kind}:${decision.correlation.type}:${correlationId}`;
+  return `${decision.kind}:${decision.correlation.type}:${decision.correlation.toolCallId}`;
 }
 
 export function proposalToDecisionRecord(
@@ -885,8 +787,6 @@ export function parseDecisionRecord(data: unknown): PruneDecisionRecord | undefi
   let correlation: PruneDecisionRecord["correlation"] | undefined;
   if (rawCorrelation?.type === "toolCallId" && typeof rawCorrelation.toolCallId === "string") {
     correlation = { type: "toolCallId", toolCallId: rawCorrelation.toolCallId };
-  } else if (rawCorrelation?.type === "entryId" && typeof rawCorrelation.entryId === "string") {
-    correlation = { type: "entryId", entryId: rawCorrelation.entryId };
   }
   if (!correlation) return undefined;
 
@@ -902,10 +802,6 @@ export function parseDecisionRecord(data: unknown): PruneDecisionRecord | undefi
   };
 }
 
-// ============================================================================
-// Restore / undo (pe-8re9): tombstones that reverse a persisted decision
-// ============================================================================
-
 /**
  * A restore record is a tombstone: it records that the decision identified by
  * `idempotencyKey` should stop being applied, WITHOUT deleting or mutating
@@ -1013,11 +909,7 @@ export function resolvePruneTombstoneState(entries: MinimalSessionEntry[]): Prun
   return { activeDecisions, activeIdempotencyKeys, restoredKeys, lastDecisionByKey };
 }
 
-// ============================================================================
-// Apply step (content-replacement only; never drops messages)
-// ============================================================================
-
-export function buildPlaceholderText(reason: string, charsRemoved: number): string {
+function buildPlaceholderText(reason: string, charsRemoved: number): string {
   return `[pruned by ${EXTENSION_ID}: ${reason} (${charsRemoved} chars removed)]`;
 }
 
@@ -1031,8 +923,7 @@ function isImageBearingToolResultTarget(
   decision: PruneDecisionRecord,
   pairIndex?: Map<string, ToolCallPairIndices>,
 ): boolean {
-  if (decision.kind !== "tool_result_content" || decision.correlation.type !== "toolCallId")
-    return false;
+  if (decision.kind !== "tool_result_content") return false;
   const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
   if (pair.resultIndex === undefined) return false;
   const target = messages[pair.resultIndex];
@@ -1056,11 +947,6 @@ export function applyPruneDecision(
   decision: PruneDecisionRecord,
   pairIndex?: Map<string, ToolCallPairIndices>,
 ): ApplyResult {
-  if (decision.correlation.type !== "toolCallId") {
-    // v1 only ever targets tool call/result pairs; entryId correlation is
-    // reserved for future strategies and intentionally not applied yet.
-    return { applied: false, charsRemoved: 0 };
-  }
   const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
 
   if (decision.kind === "tool_result_content") {
@@ -1081,7 +967,7 @@ export function applyPruneDecision(
     }
     if (pair.resultIndex === undefined) return { applied: false, charsRemoved: 0 };
     const resultMessage = messages[pair.resultIndex] as MinimalToolResultMessage;
-    // Only errored-call inputs may ever be redacted (ticket invariant).
+    // Only errored-call inputs may ever be redacted.
     if (!resultMessage.isError) return { applied: false, charsRemoved: 0 };
 
     const assistantMessage = messages[pair.assistantIndex] as MinimalAssistantMessage;
@@ -1132,7 +1018,6 @@ export function isDecisionProtected(
   recencyBoundaryIndex: number,
   pairIndex?: Map<string, ToolCallPairIndices>,
 ): boolean {
-  if (decision.correlation.type !== "toolCallId") return true; // no safe way to check protections yet
   const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
   if (
     pair.resultIndex !== undefined &&
@@ -1154,10 +1039,6 @@ export function isDecisionProtected(
   return false;
 }
 
-// ============================================================================
-// Savings estimation, cache cost model & net-benefit gate (pe-s2ho)
-// ============================================================================
-
 export interface DecisionSavingsEstimate {
   /** Earliest message index this decision changes; used for cache-bust tail sizing. */
   position: number;
@@ -1165,36 +1046,44 @@ export interface DecisionSavingsEstimate {
   tokensRemoved: number;
 }
 
+type DecisionApplyPreview =
+  | {
+      kind: "tool_result_content";
+      position: number;
+      before: (MinimalTextContent | MinimalImageContent)[];
+      after: (MinimalTextContent | MinimalImageContent)[];
+    }
+  | {
+      kind: "tool_call_input";
+      position: number;
+      beforeArgs: Record<string, unknown>;
+      afterArgs: Record<string, unknown>;
+    };
+
 /**
- * Estimate the token savings and affected position of a single decision
- * without mutating the caller's `messages`. Returns undefined when the
- * decision's target is absent or the decision would not actually apply
- * (mirrors `applyPruneDecision`'s no-op conditions).
+ * Non-mutating before/after for one decision. A shallow array copy keeps the
+ * caller's messages intact; pair-index positions stay valid because slice()
+ * preserves length and order. Undefined when the target is absent or apply
+ * would no-op.
  */
-export function estimateDecisionSavings(
+function previewDecisionApply(
   messages: MinimalMessage[],
   decision: PruneDecisionRecord,
-  estimateTokens: TokenEstimator = estimateTokensForText,
   pairIndex?: Map<string, ToolCallPairIndices>,
-): DecisionSavingsEstimate | undefined {
-  if (decision.correlation.type !== "toolCallId") return undefined;
+): DecisionApplyPreview | undefined {
   const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
-
-  // Apply against a shallow copy of the array (not the message objects) so
-  // the caller's messages/content are never mutated by this preview. Indices
-  // in `pairIndex` (built from `messages`) remain valid against `preview`
-  // since slice() preserves length/order.
   const preview = messages.slice();
   const result = applyPruneDecision(preview, decision, pairIndex);
   if (!result.applied) return undefined;
 
   if (decision.kind === "tool_result_content") {
     if (pair.resultIndex === undefined) return undefined;
-    const before = messages[pair.resultIndex] as MinimalToolResultMessage;
-    const after = preview[pair.resultIndex] as MinimalToolResultMessage;
-    const tokensBefore = estimateTokensForContent(before.content);
-    const tokensAfter = estimateTokensForContent(after.content);
-    return { position: pair.resultIndex, tokensRemoved: Math.max(0, tokensBefore - tokensAfter) };
+    return {
+      kind: "tool_result_content",
+      position: pair.resultIndex,
+      before: (messages[pair.resultIndex] as MinimalToolResultMessage).content,
+      after: (preview[pair.resultIndex] as MinimalToolResultMessage).content,
+    };
   }
 
   if (decision.kind === "tool_call_input") {
@@ -1206,11 +1095,11 @@ export function estimateDecisionSavings(
     const afterBlock = (preview[pair.assistantIndex] as MinimalAssistantMessage).content[
       pair.toolCallBlockIndex
     ] as MinimalToolCallContent;
-    const tokensBefore = estimateTokens(JSON.stringify(beforeBlock.arguments ?? {}));
-    const tokensAfter = estimateTokens(JSON.stringify(afterBlock.arguments ?? {}));
     return {
+      kind: "tool_call_input",
       position: pair.assistantIndex,
-      tokensRemoved: Math.max(0, tokensBefore - tokensAfter),
+      beforeArgs: beforeBlock.arguments ?? {},
+      afterArgs: afterBlock.arguments ?? {},
     };
   }
 
@@ -1218,60 +1107,56 @@ export function estimateDecisionSavings(
 }
 
 /**
- * Estimate the character savings of a single decision (pe-qdzb), i.e. the
- * same before/after delta basis as `estimateDecisionSavings` but measured in
- * raw characters rather than estimated tokens. Used by the pipeline to
- * enforce `thresholds.minCharsSaved` against fresh automatic proposals
- * *before* they reach the net-benefit gate. Returns undefined under the same
- * conditions as `estimateDecisionSavings` (target absent / would not apply).
- * Mirrors `estimateDecisionSavings`'s `Math.max(0, ...)` clamp, so a
- * decision whose placeholder text would be LONGER than the original content
- * (negative savings) is reported as 0 chars saved, not a negative number.
+ * Estimate the token savings and affected position of a single decision
+ * without mutating the caller's `messages`. Returns undefined when the
+ * decision's target is absent or the decision would not actually apply
+ * (mirrors `applyPruneDecision`'s no-op conditions).
  */
-export function estimateDecisionCharsSaved(
+export function estimateDecisionSavings(
   messages: MinimalMessage[],
   decision: PruneDecisionRecord,
+  estimateTokens: TokenEstimator = estimateTokensForText,
   pairIndex?: Map<string, ToolCallPairIndices>,
-): number | undefined {
-  if (decision.correlation.type !== "toolCallId") return undefined;
-  const pair = findToolCallPairIndices(messages, decision.correlation.toolCallId, pairIndex);
-
-  // Same non-mutating preview approach as `estimateDecisionSavings`.
-  const preview = messages.slice();
-  const result = applyPruneDecision(preview, decision, pairIndex);
-  if (!result.applied) return undefined;
-
-  if (decision.kind === "tool_result_content") {
-    if (pair.resultIndex === undefined) return undefined;
-    const before = messages[pair.resultIndex] as MinimalToolResultMessage;
-    const after = preview[pair.resultIndex] as MinimalToolResultMessage;
-    const charsBefore = contentTextLength(before.content);
-    const charsAfter = contentTextLength(after.content);
-    return Math.max(0, charsBefore - charsAfter);
+): DecisionSavingsEstimate | undefined {
+  const preview = previewDecisionApply(messages, decision, pairIndex);
+  if (!preview) return undefined;
+  if (preview.kind === "tool_result_content") {
+    const tokensRemoved =
+      estimateTokensForContent(preview.before) - estimateTokensForContent(preview.after);
+    return { position: preview.position, tokensRemoved: Math.max(0, tokensRemoved) };
   }
+  const tokensRemoved =
+    estimateTokens(JSON.stringify(preview.beforeArgs)) -
+    estimateTokens(JSON.stringify(preview.afterArgs));
+  return { position: preview.position, tokensRemoved: Math.max(0, tokensRemoved) };
+}
 
-  if (decision.kind === "tool_call_input") {
-    if (pair.assistantIndex === undefined || pair.toolCallBlockIndex === undefined)
-      return undefined;
-    const beforeBlock = (messages[pair.assistantIndex] as MinimalAssistantMessage).content[
-      pair.toolCallBlockIndex
-    ] as MinimalToolCallContent;
-    const afterBlock = (preview[pair.assistantIndex] as MinimalAssistantMessage).content[
-      pair.toolCallBlockIndex
-    ] as MinimalToolCallContent;
-    const charsBefore = JSON.stringify(beforeBlock.arguments ?? {}).length;
-    const charsAfter = JSON.stringify(afterBlock.arguments ?? {}).length;
-    return Math.max(0, charsBefore - charsAfter);
+/**
+ * Character savings for one decision: original text or argument JSON minus
+ * the placeholder. Same no-op conditions as `estimateDecisionSavings`.
+ * Clamped at 0 so a longer placeholder is reported as no savings. The
+ * pipeline uses this as the minimum-size floor before the net-benefit gate.
+ */
+export function estimateDecisionCharsSaved(
+  messages: MinimalMessage[],
+  decision: PruneDecisionRecord,
+  pairIndex?: Map<string, ToolCallPairIndices>,
+): number | undefined {
+  const preview = previewDecisionApply(messages, decision, pairIndex);
+  if (!preview) return undefined;
+  if (preview.kind === "tool_result_content") {
+    return Math.max(0, contentTextLength(preview.before) - contentTextLength(preview.after));
   }
-
-  return undefined;
+  return Math.max(
+    0,
+    JSON.stringify(preview.beforeArgs).length - JSON.stringify(preview.afterArgs).length,
+  );
 }
 
 /**
- * Cache-aware cost model (pe-s2ho ticket NOTES, binding over the looser prose
- * in the ticket body): prompt caches are prefix-based, so pruning at message
- * position p invalidates ('busts') the cached tail from p onward exactly
- * once. Modelled per NOTES as:
+ * Cache-aware cost model: prompt caches are prefix-based, so pruning at
+ * message position p invalidates ('busts') the cached tail from p onward
+ * exactly once:
  *
  *   penalty          ~= (1 - r) * tailTokensAfterEarliestChange
  *   recurringSaving  ~= r * tokensRemoved
@@ -1326,7 +1211,7 @@ export interface NetBenefitGateResult {
 }
 
 /**
- * Net-benefit gate (pe-s2ho): decides whether fresh, automatic prune
+ * Net-benefit gate: decides whether fresh, automatic prune
  * proposals are worth the one-time cache bust they cause. Batch-aware: since
  * prompt caches are a single linear prefix, every candidate in one pipeline
  * pass is "behind" the earliest changed position and shares that one cache
@@ -1410,11 +1295,6 @@ export function evaluateNetBenefitGate(
   };
 }
 
-// ============================================================================
-// Savings accounting & stats API (consumed by pe-8re9 /context-pruning stats
-// and the pe-e9pv benchmark harness)
-// ============================================================================
-
 export interface PruneStatsRecord {
   idempotencyKey: string;
   strategyId: string;
@@ -1530,14 +1410,8 @@ export function computeContextSizeSnapshot(
   };
 }
 
-// ============================================================================
-// Strategy registry (populated by follow-up tickets pe-u8gd/pe-qs8j)
-// ============================================================================
-
 export interface StrategyProposeInput {
   messages: MinimalMessage[];
-  protections: PruneProtections;
-  estimateTokens: TokenEstimator;
   /**
    * Full config, so strategies can read their own enable flag and any
    * strategy-specific settings (e.g. error-purge's `minTurnsOld`).
@@ -1546,7 +1420,7 @@ export interface StrategyProposeInput {
    */
   config: DynamicContextPruningConfig;
   /**
-   * Session working directory (pe-qs8j), used to normalize relative file
+   * Session working directory, used to normalize relative file
    * paths (e.g. from read/write/edit tool args) against an absolute base so
    * the same file referenced via different relative/absolute spellings is
    * recognized as the same path. Optional/backward-compatible: undefined
@@ -1562,15 +1436,10 @@ export interface PruneStrategy {
   propose(input: StrategyProposeInput): ProposedPrune[];
 }
 
-// ----------------------------------------------------------------------
-// Argument canonicalization (shared by the dedupe strategy; exported for
-// direct unit testing of key-order/nesting/whitespace behavior).
-// ----------------------------------------------------------------------
-
 /**
  * Recursively canonicalize a parsed tool-call arguments value: object keys
  * are sorted (recursively); array order and all string/number/boolean VALUES
- * are left untouched (per ticket: never normalize argument values beyond
+ * are left untouched (never normalize argument values beyond
  * structural key ordering). Serializing the result via JSON.stringify then
  * yields a deterministic, whitespace-free representation regardless of the
  * original key order.
@@ -1596,7 +1465,7 @@ export function buildDedupeKey(toolName: string, args: unknown): string {
   return `${toolName.trim().toLowerCase()}::${canonicalizeArgumentsJSON(args)}`;
 }
 
-/** Exported for /prune picker item building (pe-8re9) and direct unit testing. */
+/** Exported for /prune picker item building and direct unit testing. */
 export interface ToolCallOccurrence {
   toolCallId: string;
   toolName: string;
@@ -1646,12 +1515,8 @@ export function collectCompletedToolCallOccurrences(
   return occurrences;
 }
 
-// ----------------------------------------------------------------------
-// Strategy 1: deduplication (pe-u8gd)
-// ----------------------------------------------------------------------
-
 /** Placeholder text for a duplicate tool result whose content was replaced. */
-export function buildDedupePlaceholder(toolName: string, newestToolCallId: string): string {
+function buildDedupePlaceholder(toolName: string, newestToolCallId: string): string {
   return `[pruned by ${EXTENSION_ID}: duplicate ${toolName} call result; see newest occurrence (call ${newestToolCallId})]`;
 }
 
@@ -1688,10 +1553,6 @@ export const dedupeStrategy: PruneStrategy = {
   },
 };
 
-// ----------------------------------------------------------------------
-// Strategy 2: error-input purge (pe-u8gd)
-// ----------------------------------------------------------------------
-
 export const errorPurgeStrategy: PruneStrategy = {
   id: ERROR_PURGE_STRATEGY_ID,
   propose(input: StrategyProposeInput): ProposedPrune[] {
@@ -1716,50 +1577,6 @@ export const errorPurgeStrategy: PruneStrategy = {
   },
 };
 
-// ----------------------------------------------------------------------
-// Strategy 3: superseded file operations (pe-qs8j)
-// ----------------------------------------------------------------------
-//
-// When the same file path is read and/or written multiple times in a
-// session, older read/write/edit tool *outputs* for that path can become
-// stale relative to a later operation. This strategy proposes replacing
-// those older outputs with a placeholder, per the following CONSERVATIVE,
-// binding rules (do not loosen without an architect decision):
-//
-//   1. A full-file read (no offset/limit args) is superseded by a LATER
-//      full-file read of the same normalized path.
-//   2. A partial read (offset/limit args present) is NOT superseded by a
-//      later partial read UNLESS the later read's range fully covers the
-//      earlier one's range. If range coverage can't be reliably determined
-//      from the args (e.g. earlier read has no limit — reads to EOF — but
-//      the later read is bounded), skip: do not propose supersession.
-//      Full-file reads are represented as the range [1, EOF); comparing
-//      that representation via the same coverage check naturally satisfies
-//      rule 1 as a special case of rule 2 (see `readRangeCovers`).
-//   3. ANY read of a path (full or partial) is superseded once a LATER
-//      *successful* (non-error) write/edit to that same path occurs — the
-//      old read output is now known-stale regardless of read-vs-read range
-//      comparisons. The placeholder explicitly notes the file has since
-//      changed. An ERRORED later write/edit does NOT count (the file may be
-//      unchanged; conservative).
-//   4. Older write/edit outputs for a path are superseded by a LATER
-//      *successful* write/edit to that same path (again, a later errored
-//      write/edit never supersedes). Write/edit tool outputs are usually
-//      small, so proposals are only ever emitted when there is a non-empty
-//      result to prune; the shared net-benefit gate additionally decides
-//      whether the estimated savings are worth the cache-bust cost.
-//
-// The NEWEST operation for a given path (by message order) is never
-// superseded/pruned, regardless of kind — there is nothing later to point
-// the placeholder at.
-//
-// Path extraction is defensive: pi's built-in `read`/`write`/`edit` tools
-// all accept a `path` argument (see packages/coding-agent/src/core/tools/
-// {read,write,edit}.ts); some tool-call renderers also fall back to a
-// legacy `file_path` name, and `filePath` is accepted as a further
-// defensive fallback. `bash` is explicitly OUT of scope: this strategy does
-// not attempt to parse shell commands for file paths.
-
 const SUPERSEDED_FILE_OPS_STRATEGY_ID = "superseded-file-ops";
 
 type FileOpKind = "read" | "write" | "edit";
@@ -1916,7 +1733,7 @@ export const supersededFileOpsStrategy: PruneStrategy = {
       // `group` is already in message/chronological order because
       // `collectCompletedToolCallOccurrences` iterates messages in order.
       //
-      // Single reverse pass (pe-e0zd): instead of `group.slice(i + 1).find(...)`
+      // Single reverse pass: instead of `group.slice(i + 1).find(...)`
       // per index (O(k^2) allocations+scans for a group of size k), walk the
       // group back-to-front and maintain:
       //  - `nearestLaterSuccessfulWrite`: the nearest (chronologically first)
@@ -2040,10 +1857,6 @@ function collectProposals(input: StrategyProposeInput): ProposedPrune[] {
   return proposals;
 }
 
-// ============================================================================
-// Pipeline
-// ============================================================================
-
 export interface PipelineInput {
   messages: MinimalMessage[];
   config: DynamicContextPruningConfig;
@@ -2052,7 +1865,7 @@ export interface PipelineInput {
   knownIdempotencyKeys: ReadonlySet<string>;
   /**
    * Idempotency keys most-recently restored/undone via the /prune picker
-   * (pe-8re9; see `resolvePruneTombstoneState`). Fresh AUTOMATIC proposals
+   * (see `resolvePruneTombstoneState`: last event wins). Fresh AUTOMATIC proposals
    * matching one of these keys are dropped so a restored decision does not
    * silently re-apply on the very next context event. Manual re-prunes
    * always use a fresh idempotencyKey namespaced by "manual" (see
@@ -2063,7 +1876,7 @@ export interface PipelineInput {
   restoredIdempotencyKeys?: ReadonlySet<string>;
   /** Omitted defaults to idle. The context handler passes the classified state. */
   agentState?: AgentState;
-  /** Session working directory (pe-qs8j), forwarded to strategies for path normalization. */
+  /** Session working directory, forwarded to strategies for path normalization. */
   cwd?: string;
 }
 
@@ -2085,7 +1898,7 @@ export interface PipelineResult {
  * single place that mutates content. Pairing invariants are preserved by
  * construction: messages/blocks are never added or removed, only replaced.
  *
- * Net-benefit gate (pe-s2ho): only NEW, automatic (non-manual) proposals are
+ * Net-benefit gate: only NEW, automatic (non-manual) proposals are
  * gated; already-persisted decisions stay applied (their cache bust already
  * happened) and manual decisions always bypass the gate (user intent wins).
  */
@@ -2116,16 +1929,14 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
     input.config.protections.recentTurns,
   );
   // Built once and reused across all protection/savings/apply checks below so
-  // each per-decision lookup is O(1) instead of an O(n) rescan of `messages`
-  // (pe-e0zd). Positions are stable across the apply loop below (and against
+  // each per-decision lookup is O(1) instead of an O(n) rescan of `messages`.
+  // Positions are stable across the apply loop below (and against
   // `input.messages`) because decisions only ever replace a message's
   // content at its existing index, never insert/remove/reorder messages.
   const pairIndex = buildToolCallPairIndex(messages);
 
   const proposals = collectProposals({
     messages,
-    protections: input.config.protections,
-    estimateTokens: estimateTokensForText,
     config: input.config,
     cwd: input.cwd,
   });
@@ -2154,18 +1965,12 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
   const freshManual = dedupedFresh.filter((decision) => decision.source === "manual");
   const freshAutomaticUnfiltered = dedupedFresh.filter((decision) => decision.source !== "manual");
 
-  // Minimum-size floor (pe-qdzb): drop fresh automatic proposals whose
-  // character savings (original content chars minus placeholder chars) fall
-  // below `thresholds.minCharsSaved`, BEFORE gate evaluation so dropped
-  // candidates never consume batch/earliest-position gate consideration.
-  // Applies to automatic proposals only; manual (`freshManual` above) and
-  // already-persisted decisions (`input.persistedDecisions`, applied later)
-  // bypass this floor entirely, same as the net-benefit gate. Tool-result
-  // candidates containing images also bypass this raw-text floor because
-  // images have no character count; their token savings still go through the
-  // existing net-benefit gate. A floor of 0 (the config default before
-  // pe-c5n9's DEFAULT_MIN_CHARS_SAVED constant was introduced) is a no-op:
-  // every non-negative delta clears it.
+  // Minimum-size floor: drop fresh automatic proposals whose character
+  // savings fall below `thresholds.minCharsSaved` BEFORE gate evaluation, so
+  // dropped candidates never consume batch/earliest-position consideration.
+  // Manual and already-persisted decisions bypass this floor. Image-bearing
+  // tool results bypass it too (no character count) and still hit the token
+  // gate. A floor of 0 is a no-op.
   const minCharsSaved = input.config.thresholds.minCharsSaved;
   const freshAutomatic =
     minCharsSaved <= 0
@@ -2177,7 +1982,7 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
         });
 
   // Collapse fresh AUTOMATIC candidates that target the same (kind,
-  // correlation) down to a single decision (pe-j7sb). Two strategies (e.g.
+  // correlation) down to a single decision. Two strategies (e.g.
   // `dedupe` and `superseded-file-ops`) can independently propose a decision
   // for the exact same tool result; their idempotencyKeys differ (each
   // embeds its own strategyId) so the self-dedup above does not catch this,
@@ -2216,12 +2021,9 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
   // target's tokensRemoved even though the apply-loop guard further down
   // correctly skips applying the fresh candidate — corrupting the gate's
   // net-benefit math (and potentially flipping ACCEPT/REJECT) even though no
-  // double-apply occurs. Only decisions with `correlation.type ===
-  // "toolCallId"` are applyable targets worth tracking here; anything else is
-  // ignored safely (it cannot collide with a toolCallId-keyed target).
+  // double-apply occurs.
   const claimedTargetKeys = new Set<string>();
   for (const decision of [...input.persistedDecisions, ...freshManual]) {
-    if (decision.correlation.type !== "toolCallId") continue;
     claimedTargetKeys.add(buildDecisionTargetKey(decision));
   }
 
@@ -2269,8 +2071,8 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
   // `applyPruneDecision` unconditionally re-applies its placeholder even when
   // the target is already a placeholder and reports `applied: true`, so
   // without this guard the second candidate would silently overwrite the
-  // first's placeholder AND still be credited full stats/newlyAppliedDecisions
-  // (pe-j7sb). The pre-gate collapse above already prevents this among fresh
+  // first's placeholder AND still be credited full stats/newlyAppliedDecisions.
+  // The pre-gate collapse above already prevents this among fresh
   // automatic candidates; this guard additionally covers persisted-vs-fresh
   // (and any other) overlap within a single call.
   const appliedTargetKeys = new Set<string>();
@@ -2310,10 +2112,6 @@ export function runDynamicContextPruningPipeline(input: PipelineInput): Pipeline
   return { messages, newlyAppliedDecisions, newlyAppliedStats, contextSizeSnapshot, gate };
 }
 
-// ============================================================================
-// /prune picker helpers (pe-8re9)
-// ============================================================================
-
 function resolveSessionProjection(ctx: ExtensionContext): MinimalSessionProjection | undefined {
   try {
     const sessionManager = ctx.sessionManager as unknown as {
@@ -2331,7 +2129,7 @@ export function sessionEntriesToMessages(
   entries: MinimalSessionEntry[],
   projection?: MinimalSessionProjection,
 ): MinimalMessage[] {
-  if (projection) return sessionProjectionToMessages(projection);
+  if (projection) return projection.entries.flatMap((entry) => entry.messages);
   const messages: MinimalMessage[] = [];
   for (const entry of entries) {
     if (entry.type === "message" && entry.message) messages.push(entry.message);
@@ -2364,14 +2162,12 @@ export interface PrunableItem {
  * for manual prune/restore. `activeByToolCallId` should be built from
  * currently-ACTIVE decisions only (kind: "tool_result_content"), keyed by
  * toolCallId; `restoredToolCallIds` from currently-restored keys' underlying
- * toolCallId (see `buildActiveResultDecisionMap`/`extractToolCallIdFromDecisionKey`
- * usage in the extension wiring).
+ * toolCallId (see `buildActiveResultDecisionMap` in the extension wiring).
  */
 export function buildPrunableItems(
   messages: MinimalMessage[],
   activeByToolCallId: Map<string, PruneDecisionRecord>,
   restoredToolCallIds: ReadonlySet<string>,
-  _estimateTokens: TokenEstimator = estimateTokensForText,
 ): PrunableItem[] {
   const items: PrunableItem[] = [];
   for (const occurrence of collectCompletedToolCallOccurrences(messages)) {
@@ -2404,7 +2200,6 @@ export function buildActiveResultDecisionMap(
   const map = new Map<string, PruneDecisionRecord>();
   for (const decision of activeDecisions) {
     if (decision.kind !== "tool_result_content") continue;
-    if (decision.correlation.type !== "toolCallId") continue;
     if (!map.has(decision.correlation.toolCallId))
       map.set(decision.correlation.toolCallId, decision);
   }
@@ -2466,10 +2261,6 @@ export function formatPrunableItemsReport(items: PrunableItem[]): string[] {
   return items.map((item, index) => `${index + 1}. ${formatPrunableItemOption(item)}`);
 }
 
-// ============================================================================
-// /context-pruning control + status/stats helpers (pe-8re9)
-// ============================================================================
-
 export type StrategyKey = "dedupe" | "errorPurge" | "supersededFileOps";
 
 const STRATEGY_ALIASES: Record<string, StrategyKey> = {
@@ -2659,10 +2450,6 @@ export function formatStatsReport(stats: CumulativePruneStats): string[] {
   return lines;
 }
 
-// ============================================================================
-// Extension wiring
-// ============================================================================
-
 function notify(
   ctx: ExtensionContext,
   message: string,
@@ -2722,9 +2509,6 @@ export default function dynamicContextPruningExtension(pi: ExtensionAPI) {
       persistedDecisions,
       knownIdempotencyKeys,
       restoredIdempotencyKeys,
-      // Real mid-loop/idle agent-state detection (pe-zy4s): derived straight from
-      // the message payload via classifyAgentStateFromMessages -- see its doc
-      // comment for the exact runtime-observable definition.
       agentState: classifyAgentStateFromMessages(event.messages as unknown as MinimalMessage[]),
       cwd: ctx.sessionManager.getCwd(),
     });
@@ -2805,11 +2589,8 @@ export default function dynamicContextPruningExtension(pi: ExtensionAPI) {
       const activeByToolCallId = buildActiveResultDecisionMap(persistedDecisions);
       const restoredToolCallIds = new Set(
         Array.from(lastDecisionByKey.values())
-          .filter(
-            (d) =>
-              d.correlation.type === "toolCallId" && restoredIdempotencyKeys.has(d.idempotencyKey),
-          )
-          .map((d) => (d.correlation as { type: "toolCallId"; toolCallId: string }).toolCallId),
+          .filter((d) => restoredIdempotencyKeys.has(d.idempotencyKey))
+          .map((d) => d.correlation.toolCallId),
       );
       const items = buildPrunableItems(messages, activeByToolCallId, restoredToolCallIds);
 
@@ -2839,12 +2620,8 @@ export default function dynamicContextPruningExtension(pi: ExtensionAPI) {
         const latestActive = buildActiveResultDecisionMap(persistedDecisions);
         const latestRestoredToolCallIds = new Set(
           Array.from(lastDecisionByKey.values())
-            .filter(
-              (d) =>
-                d.correlation.type === "toolCallId" &&
-                restoredIdempotencyKeys.has(d.idempotencyKey),
-            )
-            .map((d) => (d.correlation as { type: "toolCallId"; toolCallId: string }).toolCallId),
+            .filter((d) => restoredIdempotencyKeys.has(d.idempotencyKey))
+            .map((d) => d.correlation.toolCallId),
         );
         const latestItems = buildPrunableItems(
           latestMessages,