agentfootprint-lens 0.47.0 → 0.47.1

package/README.md

@@ -891,26 +891,28 @@ if (snapshot) {
 }
 ```
 
-A **stored** recording needs one narrowing today, and the reason is honest on
-both sides: the lens types `Recording.snapshot.commitLog` as `readonly
-unknown[]` — a recording arrives as parsed JSON, and the lens will not claim
-that what came back off disk is a `CommitBundle` — while `timeTravel` takes
-`TimeTravelSource`, whose `commitLog` is `readonly CommitBundle[]`. So a
-replayed run has to say so at the seam:
+A **stored** recording meets the port with no cast either, since footprintjs
+9.18. The lens types `Recording.snapshot.commitLog` as `readonly unknown[]` —
+a recording arrives as parsed JSON, and the lens will not claim that what came
+back off disk is a `CommitBundle` — and `TimeTravelSource.commitLog` accepts
+exactly that, narrowing per row where it folds, which is the only place that
+can honestly do it. A row that is not a bundle is reported by index in
+`stateAt().skipped`, never crashed on:
 
 ```ts
-import type { TimeTravelSource } from 'footprintjs/trace';
-
-const stored = recording.snapshot as unknown as TimeTravelSource;
-const tt = timeTravel(stored, { strategy: lensStopsStrategy(positions) });
+if (recording.snapshot) {
+  const tt = timeTravel(recording.snapshot, { strategy: lensStopsStrategy(positions) });
+  tt.jumpTo(7);
+  tt.stateAt().skipped;  // undefined, or the rows the fold could not read
+}
 ```
 
-That cast disappears — with no change here — the day footprintjs widens
-`TimeTravelSource.commitLog` to accept an unvalidated `readonly unknown[]` and
-does the per-bundle narrowing where it folds, which is the only place that can
-honestly do it. It is reported upstream as a port gap. **Movement never needs
-this**: `openLensCursor` reads the stops and no snapshot at all, which is why
-the lens's own cursor is unaffected either way.
+(Under footprintjs 9.17 — still the peer floor — the same call needs
+`recording.snapshot as unknown as TimeTravelSource`, and a bad row throws
+inside the fold; a types-only difference the lens's `foldFactsAt` reports as
+`foldError`.) **Movement never needs a snapshot at all**: `openLensCursor`
+reads the stops and nothing else, which is why the lens's own cursor is
+unaffected either way.
 
 ### Two axes, and drilling
 
@@ -964,14 +966,15 @@ per message, tool names and schema hashes, the sampling dials, the cache
 verdict). When the two agree the record is complete; when they disagree,
 something reached the model that the run never wrote down. The tab renders both
 halves at the lens's one cursor and checks them with the library's own
-`receiptHash` / `messageDigestInput`.
+`receiptHash` over `messageDigestInput` (a message) and `toolDigestInput` (a
+tool schema).
 
 ### What each badge means
 
 | badge | exactly this |
 |---|---|
-| **Verified** | the receipt's hash for the field EQUALS the hash of what the rebuild produced — run-salted SHA-256, computed with agentfootprint's exported `receiptHash` (over `messageDigestInput` for a message). Nothing softer earns it. |
-| **Reconstructed** | rebuilt from the log, but nothing to check it against: this epoch committed no receipt, the receipt has no hash for this row, or a gap on the view covers the field (a declared hole, printed beside it). Tool NAMES are always here — they carry no hash. Tool SCHEMAS are here too, because the library hashes them over a canonical JSON it does not export, and a lookalike serializer would be a second copy of the rule. |
+| **Verified** | the receipt's hash for the field EQUALS the hash of what the rebuild produced — run-salted SHA-256, computed with agentfootprint's exported `receiptHash` (over `messageDigestInput` for a message, `toolDigestInput` for a tool schema). System text, every piece, every message and every tool schema can read it. Nothing softer earns it. |
+| **Reconstructed** | rebuilt from the log, but nothing to check it against: this epoch committed no receipt, the receipt carries no hash for this KIND of row, or a gap on the view covers the field (a declared hole, printed beside it). Tool NAMES are always here — they carry no hash. Tool SCHEMAS are here only under an agentfootprint peer older than 9.89.0, which does not export `toolDigestInput`; the lens detects the export at call time rather than copy the serializer. |
 | **Damaged** | the record contradicts itself: the receipt's hash disagrees with the rebuild and no gap excuses it, the rebuild produced a row the receipt never witnessed (no gap says a rebuild may be LONG — the receipt is the witness in both directions), or something under the receipt key was refused as not-a-receipt (`cause: 'receipt-shape-rejected'` — the library refuses a value with no `basis.epoch`, the lens refuses one missing the containers it reads). |
 | **Not on record** | the field is absent on both sides — a receipt-only field (model, provider, params, cache) on an epoch that minted no receipt. |
 

package/dist/{chunk-E5ZRMHYY.js → chunk-4PENVNUY.js}

@@ -2967,10 +2967,15 @@ function servedRowForEpoch(recording, epoch) {
 }
 
 // src/core/served/verify.ts
+import * as agentfootprint2 from "agentfootprint";
 import {
   messageDigestInput,
   receiptHash
 } from "agentfootprint";
+function toolDigestOf() {
+  const digest = agentfootprint2.toolDigestInput;
+  return typeof digest === "function" ? digest : void 0;
+}
 var EXCUSING_GAPS = Object.freeze([
   "no-fold-base",
   "no-run-log",
@@ -3035,7 +3040,8 @@ function withoutReceipt(view, absent) {
     pieces: 0,
     messages: 0,
     requestOnly: 0,
-    toolNames: Object.freeze([])
+    toolNames: Object.freeze([]),
+    schemas: Object.freeze([])
   });
   return Object.freeze({
     system: check(absent),
@@ -3103,24 +3109,36 @@ function verify(view, receipt, runId, cause) {
   const namesOnReceiptOnly = receipt.tools.names.filter((n) => !rebuiltNames.has(n));
   const namesContradict = namesRebuiltOnly.length > 0 || namesOnReceiptOnly.length > 0 && !namesExcused;
   const toolNames = check(namesContradict ? "damaged" : "reconstructed");
+  const schemasExcused = excusedOn(view, "tools.schemaHashes");
+  const digest = toolDigestOf();
   const schemas = {};
   for (const schema of view.tools.schemas) {
-    schemas[schema.name] = check("reconstructed", void 0, receipt.tools.schemaHashes[schema.name]);
+    const onReceipt = receipt.tools.schemaHashes[schema.name];
+    schemas[schema.name] = digest === void 0 ? check("reconstructed", void 0, onReceipt) : against(hash(digest(schema)), onReceipt, "damaged", "damaged");
   }
+  const rebuiltSchemaNames = new Set(view.tools.schemas.map((s) => s.name));
+  const schemasRebuiltOnly = [...rebuiltSchemaNames].filter(
+    (n) => receipt.tools.schemaHashes[n] === void 0
+  );
+  const schemasOnReceiptOnly = Object.keys(receipt.tools.schemaHashes).filter(
+    (n) => !rebuiltSchemaNames.has(n)
+  );
   const onReceiptOnly = Object.freeze({
     pieces: unpairedOnReceipt(piecePairs, receipt.system.pieces.length),
     messages: unpairedOnReceipt(messagePairs, receipt.messages.entries.length),
     requestOnly: unpairedOnReceipt(requestOnlyPairs, receipt.messages.requestOnly.length),
-    toolNames: Object.freeze(namesOnReceiptOnly)
+    toolNames: Object.freeze(namesOnReceiptOnly),
+    schemas: Object.freeze(schemasOnReceiptOnly)
   });
   const rebuiltOnly = Object.freeze({
     pieces: unpairedRebuilt(piecePairs),
     messages: unpairedRebuilt(messagePairs),
     requestOnly: unpairedRebuilt(requestOnlyPairs),
-    toolNames: Object.freeze(namesRebuiltOnly)
+    toolNames: Object.freeze(namesRebuiltOnly),
+    schemas: Object.freeze(schemasRebuiltOnly)
   });
-  const unexcusedShort = onReceiptOnly.pieces > 0 && !piecesExcused || onReceiptOnly.messages > 0 && !entriesExcused || onReceiptOnly.requestOnly > 0 && !requestOnlyExcused;
-  const all = [system, ...pieces, ...messages, ...requestOnly, toolNames];
+  const unexcusedShort = onReceiptOnly.pieces > 0 && !piecesExcused || onReceiptOnly.messages > 0 && !entriesExcused || onReceiptOnly.requestOnly > 0 && !requestOnlyExcused || onReceiptOnly.schemas.length > 0 && !schemasExcused;
+  const all = [system, ...pieces, ...messages, ...requestOnly, toolNames, ...Object.values(schemas)];
   return Object.freeze({
     system,
     pieces: Object.freeze(pieces),
@@ -3321,15 +3339,14 @@ var FOLD_FACT_KEYS = Object.freeze([
   "hiddenSkillIds"
 ]);
 function skippedIndicesOf(folded) {
-  const rows = folded.skipped;
-  if (!Array.isArray(rows)) return void 0;
-  const indices = rows.map((r) => r?.index).filter((i) => typeof i === "number");
-  return indices.length > 0 ? Object.freeze(indices) : void 0;
+  const gaps = folded.skipped;
+  return gaps !== void 0 && gaps.length > 0 ? Object.freeze(gaps.map((g) => g.index)) : void 0;
 }
 function foldFactsAt(recording, cursor) {
+  const source = typeof recording === "object" && recording !== null ? recording : void 0;
   let folded;
   try {
-    folded = stateAt(recording, cursor.commitIdx);
+    folded = stateAt(source, cursor.commitIdx);
   } catch (e) {
     return Object.freeze({
       redacted: false,
@@ -3415,4 +3432,4 @@ export {
   FOLD_FACT_KEYS,
   foldFactsAt
 };
-//# sourceMappingURL=chunk-E5ZRMHYY.js.map
+//# sourceMappingURL=chunk-4PENVNUY.js.map