pi-fold 4.1.3 → 4.1.4

package/extensions/active-context.ts

@@ -89,6 +89,7 @@ import {
   sameStateProjection,
   semanticStateSha256,
   topologySha256,
+  adoptDurableFoldRecords,
 } from "./lib/persistence.ts";
 import type { MaterializedStatePersistence } from "./lib/persistence.ts";
 import {
@@ -2528,6 +2529,11 @@ export function registerActiveContext(pi: any, options: {
       state: persistence.state!,
       generation: generationAtStart,
     });
+    const adoption = adoptDurableFoldRecords(nextState.folds, persistence.persistedFoldRecords);
+    if (adoption.adopted.length) {
+      emit("context.adopt", { adopted: adoption.adopted.length, fold_ids: adoption.adopted.slice(0, 64) });
+      return { preparedFold, nextState: { ...nextState, folds: adoption.folds } };
+    }
     return { preparedFold, nextState };
   };
 
@@ -2769,6 +2775,16 @@ export function registerActiveContext(pi: any, options: {
           clips: [...(result.state.clips ?? []), ...clipAdditions] } };
       }
     }
+    // A RE-CUT SPAN ADOPTS ITS DURABLE RECORD (persistence.ts, adoptDurableFoldRecords):
+    // a fold minted here under an id the store already holds, with the same source, takes
+    // the record's bytes before the projection is measured, so the persist path finds
+    // equal digests where session 01a06746 found "Conflicting durable active-context
+    // fold" and stopped folding for good.
+    const adoption = adoptDurableFoldRecords(result.state.folds, persistence.persistedFoldRecords);
+    if (adoption.adopted.length) {
+      result = { ...result, state: { ...result.state, folds: adoption.folds } };
+      emit("context.adopt", { adopted: adoption.adopted.length, fold_ids: adoption.adopted.slice(0, 64) });
+    }
     persistence.state = result.state;
     const bytesAfter = pricedBytes(projectActiveContext(snapshot, persistence.state));
     const freedBytes = Math.max(0, bytesBefore - bytesAfter);
@@ -2804,6 +2820,7 @@ export function registerActiveContext(pi: any, options: {
       closing_consolidation_marks: closingAdded,
       absorbed_wedges: wedges.absorbed.length,
       clipped_results: clippedResults,
+      adopted_records: adoption.adopted.length,
       freed_bytes: freedBytes,
       freed_tokens: estimatedTokens(freedBytes),
       rewrite_tokens: rewriteTokens,

package/extensions/lib/persistence.ts

@@ -789,11 +789,44 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
   return parsed;
 }
 
+/**
+ * A RE-CUT SPAN ADOPTS ITS DURABLE RECORD (2026-09-04).
+ *
+ * A fold's id is derived from its parts, so the same span cut twice mints the same id,
+ * and a durable record under an id is immutable by design. Those two facts met in
+ * session 01a06746: a persistence projection on the first pass after a restart could
+ * not seat one consolidation root and dropped it with its 30 children, the spans read
+ * as raw, the frontier cut them again, and the re-cut folds differed from their records
+ * by 25 bytes of placeholder text. `normalizeFoldsForPersistedRecords` and the persist
+ * path both refused the conflict, folding suspended, and every restart walked into the
+ * same refusal because the durable state had already lost the folds.
+ *
+ * The record is the canonical fold for its source. A fold whose id has a record with
+ * the SAME kind and SAME source hash takes the record's bytes (brief, provenance,
+ * placeholder size, createdAt) and keeps only its own parent link, so the persist path
+ * finds equal digests and the session goes on. A record under the same id with a
+ * DIFFERENT source is a corrupt store and still refuses by name.
+ */
+export function adoptDurableFoldRecords(
+  folds: ActiveFold[],
+  records: Map<string, FoldRecordEntry>,
+): { folds: ActiveFold[]; adopted: string[] } {
+  const adopted: string[] = [];
+  const next = folds.map((fold) => {
+    const record = records.get(fold.id);
+    if (!record || sameFoldRecordIdentity(fold, record.fold)) return fold;
+    if (record.fold.kind !== fold.kind || record.fold.sourceSha256 !== fold.sourceSha256) return fold;
+    adopted.push(fold.id);
+    return { ...clone(record.fold), parentId: fold.parentId };
+  });
+  return { folds: next, adopted };
+}
+
 export function normalizeFoldsForPersistedRecords(
   folds: ActiveFold[],
   records: Map<string, FoldRecordEntry>,
 ): ActiveFold[] {
-  const normalized = folds.map((fold) => {
+  const normalized = adoptDurableFoldRecords(folds, records).folds.map((fold) => {
     const record = records.get(fold.id);
     if (!record) return clone(fold);
     if (!sameFoldRecordIdentity(fold, record.fold)) {

package/package.json

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