pi-smart-compact 10.1.4 → 10.2.0

package/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 ## [Unreleased]
 
+## [10.2.0] - 2026-10-05
+
+### Release approval
+
+- Minor release approved by the release owner after the deterministic gates
+  on the exact candidate. No version-specific applied-canary cohort or live
+  provider run exists for `10.2.0`; the feature is evidenced by unit tests
+  only. The note is gated by `Navigation guide` (`contextGuidanceEnabled`)
+  and turns off with it.
+
+### Added
+
+- **Context attention.** Context pressure used to reach the model only through
+  the human status line and `smart_context status` results, so the anchor,
+  checkpoint/rewind, trim and compaction tools sat idle until a person asked
+  for them. The extension now sends the model one short note when usage
+  enters the cleanup band and one more at the compaction band, naming only
+  the actions available right now: `smart_navigation anchor` (with the lazy
+  `smart_tools` load step when needed), `smart_context checkpoint`/`rewind`
+  and `trim` only when history edits are possible on this model (signed
+  Anthropic thinking blocks them), plus whether automatic compaction will
+  prepare. Mid-turn the note rides along with the next tool batch; at a turn
+  end a cleanup note waits for the next prompt and a compaction note is
+  skipped under auto-trigger because settled compaction runs first. One note
+  per band per session, re-armed once pressure clears; the note is a tail
+  message, so the cached prefix is untouched. Gated by `Navigation guide`
+  (`contextGuidanceEnabled`), tool loading and agent tool access.
+
+## [10.1.5] - 2026-10-05
+
+### Release approval
+
+- Patch release approved by the release owner after the deterministic gates
+  on the exact candidate. No version-specific applied-canary cohort or live
+  provider run exists for `10.1.5`; the fix is evidenced by unit tests and
+  offline replay of a recorded session's cache usage only.
+
+### Fixed
+
+- **Anchor prompt cache no longer evicts the rolling cache marker on OAuth
+  payloads.** pi-ai places `cache_control` on both OAuth system blocks (the
+  Claude Code identity line and the system prompt), so an Anthropic request
+  already carries four breakpoints: identity, system prompt, tools, rolling
+  tail. Adding the anchor marker made five, and the limit enforcement dropped
+  the first foreign message marker, which was the rolling tail. From the
+  first turn after an anchor every request then read only the prefix up to
+  the anchor and wrote nothing: `cacheWrite` stayed 0 while uncached input
+  grew turn by turn (a recorded session fell from 99% to 40% cache hits and
+  stayed there through a compaction that kept the anchor). The rolling tail
+  is now never an eviction candidate; the redundant identity marker goes
+  first, then the tools marker, both of which only cover prefixes of the
+  system-prompt marker. API-key payloads (one system marker) were unaffected.
+
 ## [10.1.4] - 2026-10-02
 
 ### Release approval

package/dist/app/anchor-cache.d.ts

@@ -16,7 +16,9 @@
  * reply after N yet) N's prefix has never been written. The previous anchor M
  * keeps a marker too, [system, tools, M, N], so the prefix through M is read
  * and only (M, N] is written. The bridge uses a free slot or displaces a
- * foreign message marker; it never evicts system/tools markers.
+ * redundant foreign marker (see `evictable`); it never displaces the rolling
+ * tail, which is what advances the cache every turn (pi-ai's OAuth layout
+ * already carries four markers: identity, system prompt, tools, tail).
  *
  * TTL follows the payload: a `1h` marker (Pi long retention) makes the anchor
  * `1h` and rolling markers after it `5m`; otherwise markers stay default.

package/dist/app/anchor-cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"anchor-cache.d.ts","sourceRoot":"","sources":["../../src/app/anchor-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,iCAAiC,CAAC;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,KAAK,iBAAiB,GAAG,IAAI,CAAC,aAAa,EAAE,0BAA0B,GAAG,2BAA2B,CAAC,CAAC;AA6CvG,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAC5B,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;CAAE,GACxC,IAAI,CAEN"}
+{"version":3,"file":"anchor-cache.d.ts","sourceRoot":"","sources":["../../src/app/anchor-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAoB,MAAM,iCAAiC,CAAC;AACtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,KAAK,iBAAiB,GAAG,IAAI,CAAC,aAAa,EAAE,0BAA0B,GAAG,2BAA2B,CAAC,CAAC;AA6CvG,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,EAC5B,IAAI,EAAE;IAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;CAAE,GACxC,IAAI,CAEN"}

package/dist/app/context-attention.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Context attention: one short note to the model when context pressure enters
+ * a band, naming only the actions that are available right now.
+ *
+ * Pressure used to reach the model only through the human status line and
+ * `smart_context status` results, so the navigation, history and compaction
+ * tools sat idle until a person asked for them. The note rides along with the
+ * next tool batch (steer) during a turn; when a turn ends in the cleanup band
+ * it waits for the next prompt instead. One note per band per session,
+ * re-armed once pressure clears (compaction, trim, rewind). The note is a
+ * tail custom message, so the cached prefix is untouched.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { CompactConfig } from "../types.ts";
+export declare const ATTENTION_CUSTOM_TYPE = "smart-compact-attention";
+type AttentionConfig = Pick<CompactConfig, "contextNavigationEnabled" | "contextGuidanceEnabled" | "toolLoading" | "autoTrigger" | "minContextPercent" | "prepareContextPercent" | "maxContextTokens">;
+export interface ContextAttentionDeps {
+    config: () => AttentionConfig;
+    /** Agent-driven context changes are permitted and nothing (pivot, running compaction) takes priority. */
+    canAgentAct: (ctx: ExtensionContext) => boolean;
+    /** A lazy group can still be loaded through `smart_tools`. */
+    reachable: (group: "navigation" | "history") => boolean;
+}
+export declare function registerContextAttention(pi: Pick<ExtensionAPI, "on" | "sendMessage" | "getActiveTools">, deps: ContextAttentionDeps): void;
+export {};
+//# sourceMappingURL=context-attention.d.ts.map

package/dist/app/context-attention.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-attention.d.ts","sourceRoot":"","sources":["../../src/app/context-attention.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,iCAAiC,CAAC;AAEtF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAKjD,eAAO,MAAM,qBAAqB,4BAA4B,CAAC;AAK/D,KAAK,eAAe,GAAG,IAAI,CAAC,aAAa,EACvC,0BAA0B,GAAG,wBAAwB,GAAG,aAAa,GAAG,aAAa,GACnF,mBAAmB,GAAG,uBAAuB,GAAG,kBAAkB,CAAC,CAAC;AAExE,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,eAAe,CAAC;IAC9B,yGAAyG;IACzG,WAAW,EAAE,CAAC,GAAG,EAAE,gBAAgB,KAAK,OAAO,CAAC;IAChD,8DAA8D;IAC9D,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,GAAG,SAAS,KAAK,OAAO,CAAC;CACzD;AAED,wBAAgB,wBAAwB,CACtC,EAAE,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,aAAa,GAAG,gBAAgB,CAAC,EAC/D,IAAI,EAAE,oBAAoB,GACzB,IAAI,CAoCN"}

package/dist/constants.d.ts

@@ -8,7 +8,7 @@ import type { CompressionProfile, ProfileConfig } from "./types.ts";
  * `package.json#version`. Do not hand-edit this line for releases; bump
  * package.json and run `bun run sync-version`.
  */
-export declare const VERSION = "10.1.4";
+export declare const VERSION = "10.2.0";
 /**
  * Opt-in components that are not installed with the extension: optional peer
  * dependencies in package.json, pinned to the versions the release audit

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEN,KAAK,YAAY,EAEjB,MAAM,iCAAiC,CAAC;AAkEzC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAyDtE,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAAE,EAAE,YAAY,QA8lB7D"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAEN,KAAK,YAAY,EAEjB,MAAM,iCAAiC,CAAC;AAmEzC,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAyDtE,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,EAAE,EAAE,YAAY,QAomB7D"}

package/dist/index.js

@@ -5,7 +5,7 @@ import {
 } from "@earendil-works/pi-coding-agent";
 
 // src/constants.ts
-var VERSION = "10.1.4";
+var VERSION = "10.2.0";
 var OPTIONAL_COMPONENTS = {
   mnemopi: { name: "@oh-my-pi/pi-mnemopi", version: "18.3.1", enables: "Mnemopi memory store" },
   bun: { name: "bun", version: "1.4.2", enables: "Mnemopi worker runtime when no Bun 1.3.14+ is on PATH" },
@@ -16807,6 +16807,85 @@ function createSettledAutoTrigger(options = {}) {
   return { request, noteCompaction, clear };
 }
 
+// src/app/context-attention.ts
+var ATTENTION_CUSTOM_TYPE = "smart-compact-attention";
+var CONTEXT_TOOL_NAME = "smart_context";
+var LOADER_TOOL_NAME = "smart_tools";
+function registerContextAttention(pi, deps) {
+  let noted = null;
+  const clear = () => {
+    noted = null;
+  };
+  pi.on("session_start", clear);
+  pi.on("session_before_switch", clear);
+  pi.on("session_before_fork", clear);
+  pi.on("session_tree", clear);
+  pi.on("message_end", (event, ctx) => {
+    const message = event.message;
+    if (message.role !== "assistant")
+      return;
+    const settings = deps.config();
+    if (!settings.contextNavigationEnabled || !settings.contextGuidanceEnabled || settings.toolLoading === "off")
+      return;
+    const sessionId = resolveSessionId(ctx);
+    const pressure = contextPressure(ctx, settings);
+    const band = pressure.compaction ? "compaction" : pressure.cleanup ? "cleanup" : null;
+    if (!band) {
+      if (noted?.sessionId === sessionId)
+        noted = null;
+      return;
+    }
+    if (noted?.sessionId === sessionId && (noted.band === band || noted.band === "compaction"))
+      return;
+    if (message.content.some((block) => block.type === "toolCall" && (block.name === NAVIGATION_TOOL_NAME || block.name === CONTEXT_TOOL_NAME)))
+      return;
+    const midTurn = message.stopReason === "toolUse";
+    if (!midTurn && band === "compaction" && settings.autoTrigger)
+      return;
+    if (!deps.canAgentAct(ctx))
+      return;
+    const active = new Set(pi.getActiveTools());
+    const content = renderAttention(band, pressure.percent, settings, ctx, active, deps.reachable);
+    if (!content)
+      return;
+    noted = { sessionId, band };
+    pi.sendMessage({ customType: ATTENTION_CUSTOM_TYPE, content, display: true, details: { band, percent: pressure.percent } }, { deliverAs: midTurn ? "steer" : "nextTurn" });
+  });
+}
+function renderAttention(band, percent, settings, ctx, active, reachable) {
+  const lines = [];
+  const load = (group, tool) => active.has(tool) ? "" : reachable(group) && active.has(LOADER_TOOL_NAME) ? ` Load it first: ${LOADER_TOOL_NAME} load ${group}.` : null;
+  const navigation = load("navigation", NAVIGATION_TOOL_NAME);
+  const history = load("history", CONTEXT_TOOL_NAME);
+  if (navigation !== null) {
+    lines.push((band === "compaction" ? `- Anchor now: ${NAVIGATION_TOOL_NAME} anchor with a name and a concise handoff (done / in progress / next step). The summary starts from it and the prompt cache stays warm up to it.` : `- Finishing a unit of work? ${NAVIGATION_TOOL_NAME} anchor with a concise handoff; safe cleanup is queued automatically and the prefix up to the anchor stays cached.`) + navigation);
+  }
+  if (history !== null) {
+    const branch = ctx.sessionManager.getBranch();
+    let trimmable = 0;
+    let blocked = false;
+    try {
+      const plan = planContextTrim(branch, inspectContext(branch, resolveSessionId(ctx)).checkpoint?.originId, { readerApi: ctx.model?.api });
+      blocked = Boolean(plan.blockedReason);
+      trimmable = plan.entries.filter((entry) => entry.type === "context_edit").length;
+    } catch {
+      blocked = true;
+    }
+    if (!blocked) {
+      if (trimmable > 0)
+        lines.push(`- ${CONTEXT_TOOL_NAME} trim: ${trimmable} archived tool output${trimmable === 1 ? "" : "s"} eligible now.${history}`);
+      lines.push(`- Starting a large read-only detour? ${CONTEXT_TOOL_NAME} checkpoint first, then rewind(report) when done keeps the findings and drops the research.${trimmable > 0 ? "" : history}`);
+    }
+  }
+  if (!lines.length)
+    return null;
+  const where = percent === null ? "" : ` ${Math.round(percent)}% of the policy window`;
+  const head = band === "compaction" ? `Context attention:${where} (compaction band). ` + (settings.autoTrigger ? "Compaction prepares now and applies when the turn settles." : "Automatic compaction is off here; the user runs /smart-compact.") : `Context attention:${where} (cleanup band). ` + (settings.autoTrigger ? `Automatic compaction prepares at ${settings.minContextPercent}%.` : "Automatic compaction is off here.");
+  return `${head}
+${lines.join(`
+`)}`;
+}
+
 // src/app/host-cache-ledger.ts
 var FOREIGN_REBUILD_WARN_COUNT = 3;
 var num = (value) => typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
@@ -24685,8 +24764,18 @@ function transitionBridge(payload, anchors, anchorLoc) {
 }
 function bridgeFits(payload) {
   const markers = listMarkers(payload);
-  const displaceable = markers.filter((m) => m.section === "messages" && !m.owned).length;
-  return markers.length - displaceable < MARKER_LIMIT;
+  return markers.length - evictable(markers).length < MARKER_LIMIT;
+}
+function evictable(markers) {
+  const foreign = (list) => list.filter((m) => !m.owned);
+  const messages = markers.filter((m) => m.section === "messages");
+  const system = markers.filter((m) => m.section === "system");
+  return [
+    ...foreign(messages.slice(0, -1)),
+    ...foreign(system.slice(0, -1)),
+    ...foreign(markers.filter((m) => m.section === "tools")),
+    ...foreign(system.slice(-1))
+  ];
 }
 function setMarker(payload, ref, control) {
   const block = payload.messages[ref.msgIdx].content[ref.blockIdx];
@@ -24748,7 +24837,7 @@ function countMarkers(payload) {
 function enforceMarkerLimit(payload) {
   let markers = listMarkers(payload);
   while (markers.length > MARKER_LIMIT) {
-    const target = markers.find((m) => m.section === "messages" && !m.owned) ?? markers.find((m) => m.section === "tools" && !m.owned) ?? markers.find((m) => m.section === "system" && !m.owned);
+    const target = evictable(markers)[0];
     if (!target)
       break;
     delete blockAt(payload, target).cache_control;
@@ -25013,6 +25102,11 @@ function smartCompactExtension(pi) {
         hostCache.noteCacheWarm(at);
     }
   });
+  registerContextAttention(pi, {
+    config: automaticConfig,
+    canAgentAct: (ctx) => policy.snapshot().agentToolAccess !== "disabled" && !pivotQueued(ctx) && !isRunning.isSessionActive(resolveSessionId(ctx)),
+    reachable: (group) => toolExposure.reachable(group)
+  });
   registerSmartCompactCommand(pi, {
     pendingRef,
     runLock: isRunning,

package/dist/rtk.js

@@ -198,7 +198,7 @@ class SecretScrubber {
 }
 
 // src/constants.ts
-var VERSION = "10.1.4";
+var VERSION = "10.2.0";
 var OPTIONAL_COMPONENTS = {
   mnemopi: { name: "@oh-my-pi/pi-mnemopi", version: "18.3.1", enables: "Mnemopi memory store" },
   bun: { name: "bun", version: "1.4.2", enables: "Mnemopi worker runtime when no Bun 1.3.14+ is on PATH" },

package/docs/configuration.md

@@ -454,7 +454,7 @@ Settings → **Agent tools & navigation**.
 | `contextPivotEnabled` | `Return to an anchor` | `true` | Returning to an anchor on a new branch with a required carryover. |
 | `contextAnchorCacheEnabled` | `Anchor prompt cache` | `true` | Anthropic models: keeps a prompt-cache marker on the newest anchor. |
 | `contextAnchorStatusEnabled` | `Anchor status` | `true` | Shows the newest anchor on this branch in Pi's footer; display only. |
-| `contextGuidanceEnabled` | `Navigation guide` | `true` | Lets you or the agent open the navigation guide on request; it is never added to a request otherwise. |
+| `contextGuidanceEnabled` | `Navigation guide` | `true` | Lets you or the agent open the navigation guide on request; it is never added to a request otherwise. Also enables context attention: one short note to the model when context usage enters the cleanup band and again at the compaction band, naming only the context tools available right now (anchor; checkpoint/rewind and trim when history edits are possible). Re-armed once pressure clears. |
 
 Group permissions apply in both `lazy` and `eager` modes: `compaction` follows
 `agentToolAccess`, `memory` needs `contextGraphEnabled` or a non-local

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-smart-compact",
-	"version": "10.1.4",
+	"version": "10.2.0",
 	"description": "Pi Continuity — context hygiene and session continuity for Pi Coding Agent: recoverable cleanup, checkpoints, memory and verified compaction.",
 	"type": "module",
 	"packageManager": "bun@1.4.2",