agentfootprint-lens 0.51.1 → 0.52.1

package/README.md

@@ -1018,12 +1018,20 @@ composed them); tools as sent (names, expandable schemas, the forced tool
 marked, `withheld` shown as the library states it). **BASIS** — epoch, call id,
 commit index, model, provider, params (only the dials the receipt carries — an
 absent dial is not rendered as a default), cache (transform, breakpoints
-applied). **FOLD** — `iteration`, `currentSkillId`, `stepPointer`, engagement,
+applied, and since 0.52.0 the **cache strategy** as the receipt names it —
+`*` is the built-in pass-through, printed as itself; the receipt's `null`
+reads *no cache strategy*; a receipt from before agentfootprint 9.93.0 reads
+Not on record). **FOLD** — `iteration`, `currentSkillId`, `stepPointer`, engagement,
 active injections, hidden skill ids, read from the fold at the stop; a row the
 fold could not read is printed there as data (skipped indices, or the fold's
 error), beside a Damaged badge.
-**OMISSIONS** — attention drops from the receipt when present, else the
-library's `UNGAPPED_FIELDS` sentence for the field. **GAPS** — every gap on the
+**OMISSIONS** — the attention drops from the receipt (0.52.0): the count,
+then one line per turn the agent's window evicted for budget — its hash and
+the epoch it was **last served on**, paired by the library's own rule (the
+hash is that earlier receipt's `messages.entries[].hash`), or Not on record
+when no earlier receipt in this recording served it; a receipt that says
+nothing was dropped reads count 0, and a record that cannot say draws the
+badge. **GAPS** — every gap on the
 view: its kind, the fields it covers, its sentence verbatim, and its `cause`
 when the library established one (`receipt-shape-rejected` styled as damage).
 **SINCE PREVIOUS** — messages entered/left, tools added/removed, schemas whose
@@ -1072,7 +1080,8 @@ crossed into the call, one edge per system piece, message, request-only line and
 tool, each carrying its badge and, against the previous epoch, whether it
 *entered*, *left* or is *unchanged* — then **WITHHELD**: held and not sent. The
 withheld band is the reason to build it. The model never learns what it was
-denied; the operator should — the withheld tool list, the attention drops, the
+denied; the operator should — the withheld tool list, each evicted turn as an
+edge into the messages slot with the epoch that last served it (0.52.0), the
 skills a role hid (read from the fold, since a receipt carries no authority
 names), a redacted fold, and every gap the view declares, each with the
 library's own sentence. Same cursor, same row, same badges: a Damaged row draws

package/dist/{chunk-ZZJ2OIQP.js → chunk-DMENQHPR.js}

@@ -2904,23 +2904,46 @@ function cursorProvenance(runner, cursorRuntimeStageId) {
   return { writtenKeys: [...written], sliceFor };
 }
 
-// src/core/served/servedRowAt.ts
-import {
-  epochLocations,
-  receiptAt,
-  servedAt,
-  SERVED_GAPS
-} from "agentfootprint";
-
 // src/core/served/receiptShape.ts
 var isRecord = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
 function isReceiptShaped(value) {
   if (!isRecord(value)) return false;
   const { system, messages, tools, params, cache, basis } = value;
+  if (isRecord(cache) && "strategy" in cache && cache.strategy !== null && typeof cache.strategy !== "string") {
+    return false;
+  }
   return isRecord(basis) && typeof basis.epoch === "number" && typeof basis.runId === "string" && isRecord(system) && typeof system.hash === "string" && Array.isArray(system.pieces) && isRecord(messages) && Array.isArray(messages.entries) && Array.isArray(messages.requestOnly) && isRecord(tools) && Array.isArray(tools.names) && isRecord(tools.schemaHashes) && isRecord(params) && isRecord(cache) && Array.isArray(cache.markersApplied);
 }
+function carriesCacheStrategy(receipt) {
+  return receipt.cache !== void 0 && "strategy" in receipt.cache;
+}
+
+// src/core/served/evictedTurns.ts
+function attentionOmissionStatus(receipt) {
+  if (receipt === void 0) return "not-on-record";
+  if (receipt.omittedForAttention !== void 0) return "on-receipt";
+  return carriesCacheStrategy(receipt) ? "none-on-receipt" : "not-on-record";
+}
+function pairEvictedTurns(drops, earlier) {
+  return Object.freeze(
+    drops.hashes.map((hash) => {
+      let lastServedOn;
+      for (const receipt of earlier) {
+        if (!receipt.messages.entries.some((entry) => entry.hash === hash)) continue;
+        if (lastServedOn === void 0 || receipt.basis.epoch > lastServedOn) lastServedOn = receipt.basis.epoch;
+      }
+      return Object.freeze(lastServedOn === void 0 ? { hash } : { hash, lastServedOn });
+    })
+  );
+}
 
 // src/core/served/servedRowAt.ts
+import {
+  epochLocations,
+  receiptAt,
+  servedAt,
+  SERVED_GAPS
+} from "agentfootprint";
 function runLogIndexOf(location) {
   if (location.subflowScope === void 0) return location.callIdx;
   const log = location.runLog;
@@ -2960,9 +2983,18 @@ function rowOf(recording, locations, at, betweenCalls) {
     ...receipt !== void 0 ? { receipt } : {},
     betweenCalls,
     ...previous !== void 0 ? { previousEpoch: previous.epoch } : {},
-    ...cause !== void 0 ? { receiptCause: cause } : {}
+    ...cause !== void 0 ? { receiptCause: cause } : {},
+    ...receipt?.omittedForAttention !== void 0 ? { evictedTurns: evictedTurnsOf(recording, locations, at, receipt.omittedForAttention) } : {}
   });
 }
+function evictedTurnsOf(recording, locations, at, drops) {
+  const earlier = [];
+  for (const location of locations.slice(0, at)) {
+    const read = receiptAt(recording, location.epoch);
+    if (read !== void 0 && isReceiptShaped(read)) earlier.push(read);
+  }
+  return pairEvictedTurns(drops, earlier);
+}
 function servedRowAt(recording, cursor) {
   const locations = epochLocations(recording);
   if (locations.length === 0) return void 0;
@@ -3174,7 +3206,7 @@ function verify(view, receipt, runId, cause) {
     basis: "on-receipt",
     params: "on-receipt",
     cache: "on-receipt",
-    omittedForAttention: receipt.omittedForAttention !== void 0 ? "on-receipt" : "not-on-record",
+    omittedForAttention: attentionOmissionStatus(receipt),
     onReceiptOnly,
     rebuiltOnly,
     damaged: unexcusedShort || all.some((c) => c.status === "damaged")
@@ -3414,8 +3446,7 @@ function foldFactsAt(recording, cursor) {
 
 // src/core/served/servedGraphAt.ts
 import {
-  SERVED_GAPS as SERVED_GAPS2,
-  UNGAPPED_FIELDS
+  SERVED_GAPS as SERVED_GAPS2
 } from "agentfootprint";
 var SLOT_ORDER = Object.freeze({
   "system-prompt": 0,
@@ -3635,26 +3666,28 @@ function withheldNodes(input) {
   for (const id of fold.hiddenSkillIds ?? []) {
     out.push(Object.freeze({ kind: "hidden-skill", name: id, from: "fold" }));
   }
-  const drops = row.receipt?.omittedForAttention;
-  out.push(
-    Object.freeze(
-      drops !== void 0 ? {
+  for (const turn of row.evictedTurns ?? []) {
+    out.push(
+      Object.freeze({
         kind: "attention-drop",
         name: "omittedForAttention",
         from: "receipt",
-        count: drops.count,
-        hashes: Object.freeze([...drops.hashes])
-      } : {
-        // Absent is not none: the library's own sentence for a field no gap
-        // explains, printed beside the Not-on-record badge.
+        slot: "messages",
+        hash: turn.hash,
+        ...turn.lastServedOn !== void 0 ? { lastServedOn: turn.lastServedOn } : {}
+      })
+    );
+  }
+  if (input.checks.omittedForAttention === "not-on-record") {
+    out.push(
+      Object.freeze({
         kind: "attention-drop",
         name: "omittedForAttention",
         from: "receipt",
-        status: "not-on-record",
-        why: UNGAPPED_FIELDS.omittedForAttention
-      }
-    )
-  );
+        status: "not-on-record"
+      })
+    );
+  }
   if (fold.redacted) {
     out.push(Object.freeze({ kind: "redacted", name: "redacted", from: "fold" }));
   }
@@ -3686,6 +3719,9 @@ function callNode(input, edges) {
     ...row.previousEpoch !== void 0 ? { previousEpoch: row.previousEpoch } : {},
     ...basis !== void 0 ? { basis } : {},
     basisStatus: basis !== void 0 ? "reconstructed" : "not-on-record",
+    // Present only where the receipt SAYS — a string or null. A receipt
+    // without the key (pre-9.93.0) leaves it absent: "cannot say".
+    ...row.receipt !== void 0 && carriesCacheStrategy(row.receipt) ? { cacheStrategy: row.receipt.cache.strategy } : {},
     ...row.receiptCause !== void 0 ? { receiptCause: row.receiptCause } : {},
     damaged: checks.damaged || edges.some((e) => e.check.status === "damaged")
   });
@@ -4073,6 +4109,9 @@ export {
   structureGraphFromRunner,
   structureGraphFromSpec,
   cursorProvenance,
+  carriesCacheStrategy,
+  attentionOmissionStatus,
+  pairEvictedTurns,
   servedRowAt,
   servedRowForEpoch,
   EXCUSING_GAPS,
@@ -4100,4 +4139,4 @@ export {
   tagStopsFor,
   tagAxisPositions
 };
-//# sourceMappingURL=chunk-ZZJ2OIQP.js.map
+//# sourceMappingURL=chunk-DMENQHPR.js.map