pi-fold 4.2.4 → 4.2.6

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,
@@ -1156,6 +1157,18 @@ export function registerActiveContext(pi: any, options: {
     }
   };
 
+  // WHAT PI'S CONTEXT EVENT WOULD HAND OVER, BEFORE ONE HAS ARRIVED (2026-10-05). Pi's
+  // ExtensionRunner.emitContext filters role "system" before any handler sees a message;
+  // buildSessionContext does not. A `/fold` before the first context event cut folds from
+  // the unfiltered view in session 01a10161: spans that crossed a system-prompt change
+  // looked broken, and that commit erased 739 of 920 folds.
+  const piContextMessages = (ctx: any): unknown[] | null => {
+    const messages = ctx.sessionManager.buildSessionContext?.()?.messages;
+    return Array.isArray(messages)
+      ? messages.filter((message: any) => message?.role !== "system")
+      : null;
+  };
+
   const snapshotForEvent = (ctx: any, messages: unknown[]): ActiveContextSnapshot =>
     timedDerivation(() => mapActiveContext({
     sessionId: ctx.sessionManager.getSessionId(),
@@ -1351,7 +1364,7 @@ export function registerActiveContext(pi: any, options: {
     persistence.deltasSinceCheckpoint = restoredPersistence?.deltasSinceCheckpoint ?? 0;
     persistence.persistedFoldRecords = restoredPersistence?.records ?? new Map<string, FoldRecordEntry>();
     persistence.persistedStateSha256 = restoredPersistence?.stateSha256 ?? semanticStateSha256(durableRestored);
-    const restoredMessages = ctx.sessionManager.buildSessionContext?.()?.messages;
+    const restoredMessages = piContextMessages(ctx);
     measurements.lastProviderMeasurement = latestProviderContextMeasurement(
       Array.isArray(restoredMessages) ? restoredMessages : [],
       budgetWindowFor(ctx),
@@ -3396,6 +3409,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 +3443,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,
@@ -3877,6 +3909,26 @@ export function registerActiveContext(pi: any, options: {
       try { updateStatus(ctx); } catch { }
       return undefined;
     }
+    // PI CHECKS BEFORE THE FIRST PROMPT, BEFORE ANY CONTEXT EVENT (2026-10-05). After a
+    // context_edit (Pi's own retry recovery writes one per failed attempt) Pi stops trusting
+    // the last provider count and estimates the whole raw transcript, folds unseen: 134% on
+    // session 01a10834, 260% on 01a10161. This used to throw for want of a snapshot, suspend
+    // folding and let native compaction run, which ran Pi out of memory on a 272MB session.
+    // The context event that follows projects and commits on the projection itself, so the
+    // boundary is cancelled and folding stays on.
+    const currentSnapshot = lifecycle.latestSnapshot;
+    if (!currentSnapshot || currentSnapshot.sessionId !== ctx.sessionManager.getSessionId()) {
+      nativeCompaction.lastThresholdDecision = {
+        handled: true,
+        retry: false,
+        reason: `${contextBrand(brandNoun)} blocked stock automatic compaction before the first context event; ` +
+          "the projection is measured when the request is built",
+        compactionReason: reason,
+        nativeCompactionCompleted: false,
+      };
+      try { updateStatus(ctx); } catch { }
+      return { cancel: true };
+    }
     let handoff: Record<string, unknown> | null = null;
     try {
       const snapshot = authoritativeSnapshotFor(ctx);
@@ -4774,7 +4826,7 @@ export function registerActiveContext(pi: any, options: {
       if (!persistence.state) persistence.state = emptyActiveContextState(ctx.sessionManager.getSessionId());
       const snapshot = lifecycle.latestSnapshot
         ? authoritativeSnapshotFor(ctx)
-        : snapshotForEvent(ctx, ctx.sessionManager.buildSessionContext().messages);
+        : snapshotForEvent(ctx, piContextMessages(ctx) ?? []);
       if (!lifecycle.latestSnapshot) lifecycle.latestSnapshot = snapshot;
       const divider = args.indexOf(" -- ");
       const selector = (divider >= 0 ? args.slice(0, divider) : args).trim();
@@ -4884,7 +4936,7 @@ export function registerActiveContext(pi: any, options: {
     }
     const snapshot = lifecycle.latestSnapshot
       ? authoritativeSnapshotFor(ctx)
-      : snapshotForEvent(ctx, ctx.sessionManager.buildSessionContext().messages);
+      : snapshotForEvent(ctx, piContextMessages(ctx) ?? []);
     if (!lifecycle.latestSnapshot) lifecycle.latestSnapshot = snapshot;
     if (!persistence.state) throw new Error("The context window is empty; there is nothing to show yet");
 

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,14 +50,34 @@ 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;
+}
+
+// PI NEVER SHOWS AN EXTENSION ITS SYSTEM MESSAGES (2026-10-05). The context event filters
+// role "system" (ExtensionRunner.emitContext), so a system-prompt-change entry has no
+// place in the window and cannot break a span. Folds cut from a view that did include them
+// (a `/fold` before the first context event, session 01a10161) carry such refs; they are
+// skipped here rather than unseating the fold and, at the next commit, its whole subtree.
 export function refsInOrder(snapshot: ActiveContextSnapshot, refs: EvidenceRef[]): number[] | null {
-  const indices = refs.map((ref) => exactMapped(snapshot, ref)?.index ?? -1);
+  const placed = refs.filter((ref) => ref.role !== "system");
+  if (!placed.length) return null;
+  const indices = placed.map((ref) => exactMapped(snapshot, ref)?.index ?? -1);
   if (indices.some((index) => index < 0) || new Set(indices).size !== indices.length) return null;
   for (let index = 1; index < indices.length; index += 1) if (indices[index] !== indices[index - 1] + 1) return null;
   return indices;

package/package.json

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