pi-fold 4.1.2 → 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 {
@@ -225,6 +226,7 @@ export * from "./lib/persistence.ts";
 export * from "./lib/policy.ts";
 export * from "./lib/rollback.ts";
 export * from "./lib/scheduling.ts";
+export * from "./lib/status-widget.ts";
 export * from "./lib/selection.ts";
 export * from "./lib/transcript.ts";
 
@@ -746,11 +748,18 @@ export function registerActiveContext(pi: any, options: {
       };
     }, { placement: "belowEditor" });
   };
-  const foldBarModel = (input: {
+  const foldBarModel = (ctx: any, input: {
     share: number | null; budgetTokens: number; staged: number; roots: number; weighed: boolean;
   }): FoldBarModel => {
     const state = persistence.state;
-    const snapshot = lifecycle.latestSnapshot;
+    // THE SAME SNAPSHOT /fold-status PRICES AGAINST. `markFreedBytes` answers ZERO, silently,
+    // for a span it cannot locate contiguously in the snapshot it is handed, and the last
+    // context event's snapshot can trail the branch the marks were cut from; the bar read
+    // "5 staged, 0 to free" beside a status command pricing the same marks at 41,877
+    // tokens (Shane, 2026-09-02, session 01a06272). The authoritative snapshot is memoized
+    // on the branch length, so reading it here costs nothing while nothing has changed.
+    let snapshot = lifecycle.latestSnapshot;
+    try { snapshot = authoritativeSnapshotFor(ctx); } catch { }
     let stagedTokens = 0;
     let placeholderChars = 0;
     let hiddenChars = 0;
@@ -801,7 +810,7 @@ export function registerActiveContext(pi: any, options: {
       try {
         installFoldBar(ctx);
         if (foldBar.installed) {
-          foldBar.model = foldBarModel({
+          foldBar.model = foldBarModel(ctx, {
             share, budgetTokens: capacity.budgetTokens, staged, roots,
             weighed: ladder.bandTopMeasurement !== null &&
               ladder.bandTopMeasurement === measurements.lastProviderMeasurement,
@@ -2520,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 };
   };
 
@@ -2761,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);
@@ -2796,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/extensions/lib/status-widget.ts

@@ -66,11 +66,33 @@ export interface FoldBarTheme {
   fg(color: "dim" | "muted" | "text" | "warning" | "error", text: string): string;
   bold(text: string): string;
   getColorMode?(): "truecolor" | "256color";
+  getFgAnsi?(color: "text"): string;
+  name?: string;
 }
 
-// Crameri batlow10, classes 3, 6 and 8 (0-indexed). The two darkest classes are unusable
-// as fill on a dark terminal, and the lightest washes out on a light one.
-const BATLOW = { raw: "#3C6D56", staged: "#D29343", folded: "#FDB7BC" } as const;
+// Crameri batlow10, three classes per background. Classes 3, 6 and 8 (0-indexed) read on
+// a dark terminal; the lightest of them is 1.7:1 against white, so a light terminal steps
+// two classes darker (2, 5 and 6), the same triple the README's light figure uses.
+const BATLOW_ON_DARK = { raw: "#3C6D56", staged: "#D29343", folded: "#FDB7BC" } as const;
+const BATLOW_ON_LIGHT = { raw: "#1C5A62", staged: "#9D892B", folded: "#D29343" } as const;
+
+/**
+ * WHICH WAY THE BACKGROUND GOES, read off the theme's own text colour rather than its
+ * name: a theme whose body text is dark is drawn on a light background. pi hands the
+ * text colour out as a truecolor escape, and a theme that does not (256-colour mode,
+ * or a host without the accessor) falls back to the name, then to dark.
+ */
+export function lightBackground(theme: FoldBarTheme): boolean {
+  try {
+    const ansi = theme.getFgAnsi?.("text") ?? "";
+    const match = /38;2;(\d+);(\d+);(\d+)/.exec(ansi);
+    if (match) {
+      const [r, g, b] = match.slice(1).map((v) => Number(v) / 255);
+      return 0.2126 * r + 0.7152 * g + 0.0722 * b < 0.5;
+    }
+  } catch { }
+  return /light/i.test(theme.name ?? "");
+}
 
 const truecolor = (hex: string, text: string): string => {
   const r = parseInt(hex.slice(1, 3), 16);
@@ -140,6 +162,7 @@ export function renderFoldBar(model: FoldBarModel, width: number, theme: FoldBar
       width, theme.fg("dim", "..."));
   }
   const rich = theme.getColorMode?.() === "truecolor";
+  const BATLOW = lightBackground(theme) ? BATLOW_ON_LIGHT : BATLOW_ON_DARK;
   const ink: Record<Cell, (text: string) => string> = {
     raw: (t) => rich ? truecolor(BATLOW.raw, t) : theme.fg("muted", t),
     staged: (t) => rich ? truecolor(BATLOW.staged, t) : theme.fg("text", t),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-fold",
-  "version": "4.1.2",
+  "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",