@diegopetrucci/pi-extensions 0.1.67 → 0.1.68

package/extensions/dynamic-context-pruning/README.md

@@ -130,10 +130,10 @@ Where `r` is `gate.cachedPriceRatio` — the fraction of full price still paid
 for cached tokens (default `0.1`, i.e. cached tokens cost ~10% of fresh
 tokens). `breakEvenCalls` is how many subsequent LLM calls are needed to
 recoup the one-time cache-bust cost via the recurring saving. The gate accepts
-a batch of candidates only if `breakEvenCalls <= gate.breakEvenThreshold`
-(default `22`, calibrated from the representative-corpus benchmark — see the
-calibration note under [Configuration](#configuration) and the
-[Roadmap](#roadmap) evidence).
+a batch of candidates only if `breakEvenCalls` is at most the effective
+threshold for the current state (`idle=22`, `mid_loop=1` by default,
+calibrated from the representative-corpus benchmark — see the calibration
+note under [Configuration](#configuration) and the [Roadmap](#roadmap) evidence).
 
 All candidates proposed in the same `context` call share one cache bust (since
 a prompt cache is a single linear prefix), so they're evaluated and
@@ -179,7 +179,7 @@ branch:
 /context-pruning gate <on|off|always-apply>
 ```
 
-- `status`: enabled state, gate mode/threshold/ratio, per-strategy on/off
+- `status`: enabled state, gate mode/effective per-state thresholds/ratio, per-strategy on/off
   state, protection counts, last call's raw/effective/saved token snapshot,
   and current context usage.
 - `stats`: cumulative tokens saved, overall and per strategy.
@@ -223,7 +223,7 @@ never required to exist. Full shape, with defaults:
     "mode": "on",
     "cachedPriceRatio": 0.1,
     "breakEvenThreshold": 22,
-    "breakEvenThresholdByState": { "idle": 22, "mid_loop": 22 }
+    "breakEvenThresholdByState": { "idle": 22, "mid_loop": 1 }
   }
 }
 ```
@@ -243,7 +243,8 @@ Notes:
   break-even math (`gate.*`), which is a separate, later check on whatever
   survives this floor.
 - `gate.breakEvenThresholdByState` lets `idle` vs `mid_loop` agent states use
-  different thresholds; both default to `gate.breakEvenThreshold`. Real
+  different thresholds; `idle` defaults to `22` and
+  `mid_loop` defaults to `1`. Real
   mid-loop/idle detection is wired through the `context` event handler
   (pe-zy4s): the state is classified straight from the message payload —
   `idle` if the most recent relevant message is a user message (this is the
@@ -253,9 +254,15 @@ Notes:
   runtime-observable definition and found the state-split REVERSED from an
   earlier turn-end-based analysis: at r=0.1, `idle` candidates now carry
   essentially all the realized net benefit and `mid_loop` candidates carry
-  essentially none. Since `idle` is not the worthless state under this
-  definition, both states are kept at parity (`22`/`22`) rather than forcing
-  a stricter default in either direction.
+  essentially none. At r=0.1, the measured corpus therefore supports a
+  conservative `mid_loop=1` default, while `idle` remains `22`. Mid-loop
+  pruning can amortize over enough subsequent calls, but the observed
+  candidates did not justify a more permissive threshold. Turn-start
+  classification does not imply the provider cache is cold. The reported
+  field capture (2026-09-08: a mid_loop prune at `T=22` invalidated 81% of a
+  warm request prefix between consecutive LLM calls separated only by a
+  toolResult) illustrates cache invalidation, not proof that amortization is
+  impossible. Set `mid_loop` back to `22` to restore the old parity behavior.
 - `gate.breakEvenThreshold`'s default of `22` is calibrated from the
   representative-corpus benchmark at `cachedPriceRatio` r=0.1 (aggressive
   prompt caching, the common case) — see [Roadmap](#roadmap) for the full
@@ -448,11 +455,13 @@ re-derived on the representative corpus (460 gate-eligible candidates on the
 current `~/.the-last-harness/agent/sessions` corpus). The split **reverses**:
 at r=0.1, `idle` (T=22, ~20.6k realized net benefit) now carries essentially
 all the value, and `mid_loop` (T=1, ~0 realized net benefit) carries
-essentially none. Per the decision rule (stricter idle default only if idle
-is shown ~worthless), this evidence does **not** support a stricter idle
-default — parity (`22`/`22`) is kept. The table above is retained as the
-historical turn-END-definition record; it no longer reflects how the runtime
-classifies agent state.
+essentially none. Under that ticket's decision rule (stricter idle default
+only if idle is shown ~worthless), parity (`22`/`22`) was retained at the time.
+The 2026-09-08 follow-up supersedes that default with `idle=22` / `mid_loop=1`,
+using the measured mid-loop result to choose a conservative threshold (see
+[Configuration](#configuration) for the evidence and limitations). The table
+above is retained as the historical turn-END-definition record; it no longer
+reflects how the runtime classifies agent state.
 
 **This reframes, rather than weakens, the case for v2.** Small deterministic
 removals (dedupe/error-purge/superseded-file-ops) structurally cannot beat

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

@@ -114,6 +114,22 @@ const DEFAULT_CACHED_PRICE_RATIO = 0.1;
  */
 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.
+ */
+const DEFAULT_MID_LOOP_BREAK_EVEN_THRESHOLD = 1;
+
 /** Tool names never pruned by default: orchestration/subagent-style tools and todo-like state. */
 const DEFAULT_PROTECTED_TOOL_NAMES = [
 	"todo",
@@ -222,20 +238,19 @@ export type GateMode = "on" | "off" | "always-apply";
  * turn-START "idle" population (calls made at the start of a turn) carries
  * essentially ALL the realized net benefit (idle-optimal T=22, total realized
  * net benefit ~20,594 token-units), while "mid_loop" carries essentially NONE
- * (mid_loop-optimal T=1, total realized net benefit ~0.0 -- i.e. no mid_loop
- * candidate is ever worth accepting at r=0.1 under this definition). This is
+ * (mid_loop-optimal T=1, total realized net benefit ~0.0 on this corpus). This is
  * the OPPOSITE of what the pe-c5n9 evidence (measured under the old,
  * non-runtime-observable turn-END definition) suggested.
  *
  * Per the pe-zy4s decision rule (stricter idle default only if idle itself is
  * shown to be ~worthless): idle is NOT worthless here -- it is the ONLY state
- * carrying value at r=0.1 -- so no state-conditioned strictness is justified
- * in either direction. The per-state split is therefore kept at PARITY
- * (`breakEvenThresholdByState: { idle: DEFAULT_BREAK_EVEN_THRESHOLD, mid_loop:
- * DEFAULT_BREAK_EVEN_THRESHOLD }`), both config-overridable. A future ticket
- * could consider a stricter mid_loop default given this evidence, but that is
- * a new, unreviewed direction outside this ticket's authorized decision rule
- * and is left for a follow-up.
+ * carrying value at r=0.1 -- so the idle default stays at
+ * DEFAULT_BREAK_EVEN_THRESHOLD. The mid_loop default, by the same benchmark,
+ * is now DEFAULT_MID_LOOP_BREAK_EVEN_THRESHOLD (=1): the measured candidates
+ * did not justify a more permissive threshold at r=0.1. Mid_loop pruning can
+ * still amortize over enough subsequent calls; state alone does not establish
+ * cache warmth or profitability. Both defaults remain config-overridable via
+ * gate.breakEvenThresholdByState.
  */
 export type AgentState = "idle" | "mid_loop";
 
@@ -285,7 +300,7 @@ export function defaultConfig(): DynamicContextPruningConfig {
 			mode: "on",
 			cachedPriceRatio: DEFAULT_CACHED_PRICE_RATIO,
 			breakEvenThreshold: DEFAULT_BREAK_EVEN_THRESHOLD,
-			breakEvenThresholdByState: { idle: DEFAULT_BREAK_EVEN_THRESHOLD, mid_loop: DEFAULT_BREAK_EVEN_THRESHOLD },
+			breakEvenThresholdByState: { idle: DEFAULT_BREAK_EVEN_THRESHOLD, mid_loop: DEFAULT_MID_LOOP_BREAK_EVEN_THRESHOLD },
 		},
 	};
 }
@@ -2410,7 +2425,7 @@ export function formatStatusReport(input: StatusReportInput): string[] {
 	const lines: string[] = [];
 	lines.push(`Dynamic context pruning: ${config.enabled ? "ENABLED" : "disabled"}`);
 	lines.push(
-		`Gate: mode=${config.gate.mode} threshold=${config.gate.breakEvenThreshold} cachedPriceRatio=${config.gate.cachedPriceRatio}`,
+		`Gate: mode=${config.gate.mode} thresholds={idle:${resolveBreakEvenThreshold(config.gate, "idle")}, mid_loop:${resolveBreakEvenThreshold(config.gate, "mid_loop")}} cachedPriceRatio=${config.gate.cachedPriceRatio}`,
 	);
 	lines.push("Strategies:");
 	lines.push(`  dedupe: ${config.strategies.dedupe.enabled ? "on" : "off"}`);

package/extensions/dynamic-context-pruning/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-dynamic-context-pruning",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
   "description": "A pi extension that dynamically prunes stale context to keep sessions lean.",
   "keywords": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@diegopetrucci/pi-extensions",
-  "version": "0.1.67",
+  "version": "0.1.68",
   "description": "A collection of pi extensions and skills for annotation UIs, context management, workflow audits, contrarian review, review-comment triage, notifications, brrr push alerts, safety guards, GitHub research, repo-local knowledge, todos, tool rendering, model/provider helpers, and Xiaohei-style article illustrations.",
   "keywords": [
     "pi-package",