pi-fold 4.2.4 → 4.2.5

package/README.md

@@ -27,7 +27,7 @@ Compaction replaces the transcript with a summary and discards the originals. Fo
   <img alt="Compaction turns the transcript into a summary and discards the originals, so the session starts over. pi-fold turns it into a brief and keeps the exact originals on disk, one peek or expand away, so the session keeps going." src="https://raw.githubusercontent.com/shaneconner/fold/main/media/fold-vs-compaction-light.svg">
 </picture>
 
-A fold takes a contiguous span of session entries and replaces it, in the window only, with a short brief. The entries go to a fold store byte for byte, addressed by their SHA-256 hash. The brief carries a handle, the handle resolves to the original, and expansion restores the exact bytes after verifying the hash.
+A fold takes a contiguous span of session entries and replaces it, in the window only, with a short brief. The entries stay in Pi's session file byte for byte; the fold finds them by Pi's own entry ids and records each one's SHA-256 hash when it folds. The brief carries a handle, the handle resolves to the originals, and expansion restores them as Pi holds them. If an entry's bytes no longer match the recorded hash, the fold still stands and the change is logged as a `context.drift` event.
 
 The package registers one tool, `pi_fold_context`, with nine actions over the transcript: `status`, `peek`, `brief`, `expand`, `refold`, `pin`, `unpin`, `reboundary` and `unmark`. A session that never calls the tool still folds; it degrades into lossless hierarchical compaction.
 

package/extensions/active-context.ts

@@ -52,6 +52,7 @@ import {
   latestProviderContextMeasurement,
   orderedRoots,
   parseNativeCompactionCompletion,
+  contentDrifted,
   exactMapped,
   foldInterval,
   parseNativeCompactionDecision,
@@ -3396,6 +3397,24 @@ export function registerActiveContext(pi: any, options: {
     return changed;
   };
 
+  // A FOLDED ENTRY WHOSE BYTES CHANGED (2026-10-05). The fold still stands over it, by Pi's
+  // identity (lib/measurement exactMapped); what changed is recorded once per entry per
+  // process, so the drift is on the record instead of silently unseating the fold.
+  const reportedDrift = new Set<string>();
+  const recordContentDrift = (snapshot: ActiveContextSnapshot): void => {
+    const state = persistence.state;
+    if (!state) return;
+    const drifted: string[] = [];
+    for (const fold of state.folds) {
+      for (const part of fold.parts) {
+        if (part.kind !== "raw" || reportedDrift.has(part.ref.entryId)) continue;
+        if (!contentDrifted(snapshot, part.ref)) continue;
+        reportedDrift.add(part.ref.entryId);
+        drifted.push(part.ref.entryId);
+      }
+    }
+    if (drifted.length) emit("context.drift", { entries: drifted.length, entry_ids: drifted.slice(0, 64) });
+  };
   const handleContext = async (event: { messages: unknown[] }, ctx: any) => {
     if (lifecycle.shuttingDown) return { messages: event.messages };
     beginMutationPass();
@@ -3412,6 +3431,7 @@ export function registerActiveContext(pi: any, options: {
       const snapshot = snapshotForEvent(ctx, event.messages);
       lifecycle.latestSnapshot = snapshot;
       foldBar.startupSnapshot = null;
+      recordContentDrift(snapshot);
       if (ladder.automaticFailure) {
         ladder.automaticFailure.suppressedCallbacks = Math.min(
           Number.MAX_SAFE_INTEGER,

package/extensions/lib/instrumentation.ts

@@ -99,7 +99,8 @@ export type ContextEventKind =
   | "context.projection"
   | "context.usage"
   | "context.prefix"
-  | "context.anchor";
+  | "context.anchor"
+  | "context.drift";
 
 export function prefixDivergence(
   previous: string | null,

package/extensions/lib/measurement.ts

@@ -50,10 +50,23 @@ export function mappedByKey(snapshot: ActiveContextSnapshot): Map<string, Mapped
   return indexed;
 }
 
+// A FOLDED ENTRY IS FOUND BY PI'S IDENTITY, NOT BY ITS BYTES (2026-10-05). Pi names every
+// entry (session, entry id, role) and the transcript it hands back is the truth for that
+// entry. This also required the content digest recorded at fold time to match, and one
+// assistant message in session 01a10834 hashed differently live than as persisted (1 of
+// 3,686 refs, cause unidentified): on resume its root could not be seated, the commit
+// that followed erased the root's 377 folds, and the request went out at ~1.49M tokens
+// against a 1M window. A fold over an entry whose bytes changed now stands over Pi's
+// current bytes; `contentDrifted` names the case so it is recorded rather than silent.
 export function exactMapped(snapshot: ActiveContextSnapshot, ref: EvidenceRef): MappedMessage | null {
   const item = mappedByKey(snapshot).get(objectRefKey(ref));
-  return item && sameObjectIdentity(item.ref!, ref) && item.ref!.sha256 === ref.sha256 &&
-    evidenceSha256(item.message) === ref.sha256 ? item : null;
+  return item && sameObjectIdentity(item.ref!, ref) ? item : null;
+}
+
+/** The entry is where the ref says, but its bytes are not the ones it was folded with. */
+export function contentDrifted(snapshot: ActiveContextSnapshot, ref: EvidenceRef): boolean {
+  const item = exactMapped(snapshot, ref);
+  return item !== null && item.ref!.sha256 !== ref.sha256;
 }
 
 export function refsInOrder(snapshot: ActiveContextSnapshot, refs: EvidenceRef[]): number[] | null {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fold",
-  "version": "4.2.4",
+  "version": "4.2.5",
   "description": "Lossless context folding for the Pi coding agent: only the oldest context changes; the fresh window stays untouched.",
   "keywords": [
     "pi-package",