pi-fold 2.0.0 → 3.0.0

package/extensions/lib/folding.ts

@@ -28,7 +28,6 @@ import {
   orderedRoots,
   refsInOrder,
   refsProtected,
-  toolRefsProtected,
 } from "./measurement.ts";
 import {
   childFoldIds,
@@ -54,7 +53,6 @@ import {
   PEEK_DEFAULT_MAX_BYTES,
   PEEK_HEAD_SHARE,
   STATUS_DIET_INDEX_ROWS,
-  zoneBytes,
 } from "./policy.ts";
 import type {
   ActiveContextSnapshot,
@@ -85,7 +83,6 @@ import {
 export function selectAutomaticChapter(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
-  maximumSourceRefs: number = snapshot.policy.maxFoldSourceRefs,
   claimed: ReadonlySet<string> = new Set<string>(),
 ): FoldCandidate | null {
   const units = chapterUnits(snapshot);
@@ -93,24 +90,22 @@ export function selectAutomaticChapter(
   for (let unitIndex = 0; unitIndex < units.length; unitIndex += 1) {
     const first = units[unitIndex];
     let best: FoldCandidate | null = null;
-    const turnStarts = new Set<number>();
     for (let endIndex = unitIndex; endIndex < units.length; endIndex += 1) {
       const unit = units[endIndex];
       if (endIndex > unitIndex && unit.start !== units[endIndex - 1].end) break;
-      turnStarts.add(unit.turnStart);
-      if (turnStarts.size > snapshot.policy.maxChapterTurns) break;
       const coherentSegment = endIndex > unitIndex || first.end - first.start > 1;
       if (!coherentSegment) continue;
       const parts = partsForRange(snapshot, state, first.start, unit.end - 1, allowedChildren);
       if (!parts || parts.some((part) => part.kind === "fold" && state.expanded.includes(part.foldId))) continue;
       const refs = candidateSourceRefs(parts, state);
-      if (refs.length > maximumSourceRefs) break;
       if (claimed.size && refs.some((ref) => claimed.has(objectRefKey(ref)))) continue;
       if (refsProtected(refs, state, snapshot)) continue;
       const size = bytes(encodedFoldSource(snapshot, state, parts, "chapter"));
-      if (size > snapshot.policy.maxChapterChars && endIndex > unitIndex) break;
       const biteSized = size <= MAX_FOLD_SPAN_CHARS || endIndex === unitIndex;
-      if (size >= snapshot.policy.minChapterChars && biteSized) best = { kind: "chapter", parts, sourceRefs: refs };
+      // ACCUMULATE UNTIL OVER, never cut to hit the number. The walk grows the span one
+      // whole unit at a time and records the first one that carries it past the floor,
+      // so a fold is always at least minFoldChars and always ends on a message boundary.
+      if (size >= snapshot.thresholds.minFoldChars && biteSized) best = { kind: "chapter", parts, sourceRefs: refs };
       if (size > MAX_FOLD_SPAN_CHARS) break;
     }
     if (best) return best;
@@ -123,7 +118,7 @@ export function selectAutomaticStaleSpan(
   state: ActiveContextState,
   claimed: ReadonlySet<string> = new Set<string>(),
 ): FoldCandidate | null {
-  const chapter = selectAutomaticChapter(snapshot, state, snapshot.policy.maxFoldSourceRefs, claimed);
+  const chapter = selectAutomaticChapter(snapshot, state, claimed);
   const folds = selectAutomaticConsolidations(snapshot, state)[0] ?? null;
   if (!chapter || !folds) return chapter ?? folds;
   const at = (candidate: FoldCandidate): number =>
@@ -173,7 +168,7 @@ export function selectAutomaticRung(
   const claimedFoldIds = options.claimedFoldIds ?? new Set<string>();
   if (!options.toolOnly && state.prepared) {
     if (!Number.isFinite(ratio) || ratio < hardFenceRatio(snapshot)) return null;
-    const candidate = selectAutomaticChapter(snapshot, state, snapshot.policy.maxFoldSourceRefs, claimed);
+    const candidate = selectAutomaticChapter(snapshot, state, claimed);
     return candidate ? { kind: "prepared-chapter", candidate } : null;
   }
   const tool = selectAutomaticToolBatch(snapshot, state, claimed)[0] ?? null;
@@ -405,10 +400,8 @@ export async function prepareFold(input: {
   now?: () => number;
 }): Promise<PreparedFold> {
   const { candidate, snapshot, state } = input;
-  const protectedSource = candidate.kind === "tool-result"
-    ? toolRefsProtected(candidate.sourceRefs, state, snapshot)
-    : refsProtected(candidate.sourceRefs, state, snapshot);
-  if (!candidate.sourceRefs.length || candidate.sourceRefs.length > snapshot.policy.maxFoldSourceRefs ||
+  const protectedSource = refsProtected(candidate.sourceRefs, state, snapshot);
+  if (!candidate.sourceRefs.length ||
       refsInOrder(snapshot, candidate.sourceRefs) === null || protectedSource) {
     throw new Error("Fold source is not exact, stale, and unprotected");
   }
@@ -580,13 +573,12 @@ export function preparedFoldError(input: {
   if (prepared.branchSha256 !== branchSha256(snapshot, [
     ...prepared.beforeRefs, ...prepared.sourceRefs, ...prepared.afterRefs,
   ])) return "branch drift";
-  const toolSource = prepared.fold.kind === "tool-result";
-  if (indices.some((index) => toolSource
-    ? snapshot.toolProtectedIndices.has(index)
-    : snapshot.protectedIndices.has(index))) return "fresh-tail drift";
-  if (toolSource
-    ? toolRefsProtected(prepared.sourceRefs, state, snapshot)
-    : refsProtected(prepared.sourceRefs, state, snapshot)) return "source became protected";
+  // One protected set now: an entry is unfoldable because its turn has not completed or
+  // because it carries no evidence ref, and both are validity, not recency. The branch on
+  // fold kind went with fresh-tail protection: it read `toolRefsProtected` on one side,
+  // and once that collapsed onto `refsProtected` both arms were the same call.
+  if (indices.some((index) => snapshot.protectedIndices.has(index))) return "protection drift";
+  if (refsProtected(prepared.sourceRefs, state, snapshot)) return "source became protected";
   if (Object.prototype.hasOwnProperty.call(input, "ratio")) {
     if (input.ratio === null || typeof input.ratio !== "number" || !Number.isFinite(input.ratio)) {
       return "current pressure unavailable";
@@ -686,7 +678,7 @@ export function protectEvidence(
   if (byKey.size > MAX_ACTIVE_PROTECTED) {
     throw new Error(
       `Protecting ${ids.join(", ")} would hold ${byKey.size} refs, over the ${MAX_ACTIVE_PROTECTED}-ref cap; ` +
-        "unprotect something first",
+        "unpin something first",
     );
   }
   return clearPrepared({
@@ -737,9 +729,7 @@ export function renderFold(
   const refs = flattenFoldRefs(fold, state);
   const indices = refsInOrder(snapshot, refs);
   if (!indices) return null;
-  const mustReveal = state.expanded.includes(fold.id) || (fold.kind === "tool-result"
-    ? toolRefsProtected(refs, state, snapshot)
-    : refsProtected(refs, state, snapshot));
+  const mustReveal = state.expanded.includes(fold.id) || (refsProtected(refs, state, snapshot));
   if (!mustReveal) {
     const first = snapshot.messages[indices[0]] as Record<string, unknown>;
     const text = foldPlaceholder(fold, state, snapshot);
@@ -879,9 +869,7 @@ export function foldStatusRow(fold: ActiveFold, state: ActiveContextState, snaps
   const refs = flattenFoldRefs(fold, state);
   const allSourceIds = refs.map((ref) => ref.entryId);
   const sourceIds = allSourceIds.slice(0, 64);
-  const blocked = fold.kind === "tool-result"
-    ? toolRefsProtected(refs, state, snapshot)
-    : refsProtected(refs, state, snapshot);
+  const blocked = refsProtected(refs, state, snapshot);
   const projection = state.expanded.includes(fold.id) ? "expanded" : "folded";
   return {
     id: fold.id,
@@ -905,7 +893,7 @@ export function foldStatusRow(fold: ActiveFold, state: ActiveContextState, snaps
         : { action: "refold", id: fold.id },
       expand: { action: "expand", id: fold.id },
       refold: { action: "refold", id: fold.id },
-      protect: { action: "protect", ids: [fold.id] },
+      pin: { action: "pin", ids: [fold.id] },
     },
   };
 }
@@ -995,7 +983,6 @@ export function activeContextStatus(
   state: ActiveContextState,
   offset = 0,
   limit = 40,
-  maximumChapterSourceRefs = Number.MAX_SAFE_INTEGER,
   statusOptions: { diet?: boolean; indexRows?: number } = {},
 ): Record<string, unknown> {
   const roots = orderedRoots(state, snapshot).map((item) => item.fold.id);
@@ -1010,11 +997,11 @@ export function activeContextStatus(
     stale: !snapshot.protectedIndices.has(item.index),
     protected: snapshot.protectedIndices.has(item.index) || protectedKeys.has(objectRefKey(item.ref)),
     staleToolResult: item.ref.role === "toolResult" &&
-      !snapshot.toolProtectedIndices.has(item.index) && !protectedKeys.has(objectRefKey(item.ref)) &&
+      !snapshot.protectedIndices.has(item.index) && !protectedKeys.has(objectRefKey(item.ref)) &&
       resultCall(snapshot, item.index, true) !== null,
   }] : []);
   const selectedObjects = objects.slice(offset, offset + limit);
-  const eligibleChapter = selectAutomaticChapter(snapshot, state, maximumChapterSourceRefs);
+  const eligibleChapter = selectAutomaticChapter(snapshot, state);
   const eligibleSourceIds = eligibleChapter?.sourceRefs.map((ref) => ref.entryId) ?? [];
   const eligibleEndpoints = eligibleSourceIds.length
     ? [...new Set([eligibleSourceIds[0], eligibleSourceIds.at(-1)!])]
@@ -1067,12 +1054,11 @@ export function activeContextStatus(
       endId: eligibleSourceIds.at(-1),
       action: { action: "fold", ids: eligibleEndpoints, brief: "<factual brief, at most 1000 characters>" },
     } : null,
-    rawTailMinimumBytes: zoneBytes(snapshot.thresholds.freshTail, snapshot.budgetTokens),
     currentTurnRequiresBoundary: false,
     actions: {
       status: { action: "status", offset, limit },
       fold: { action: "fold", ids: ["<source-or-fold-id>"], brief: "<optional factual brief, at most 1000 characters>" },
-      protect: { action: "protect", ids: ["<source-or-fold-id>"] },
+      pin: { action: "pin", ids: ["<source-or-fold-id>"] },
     },
   };
 }
@@ -1120,8 +1106,8 @@ export function boundStatusPayload(
   shrink(instrumentation, "events", "context event(s)", true);
   if (shrink(payload, "sourceMap", "source map row(s)") > 0) payload.sourceMapTruncated = true;
   shrink(payload, "topFolds", "top fold row(s)");
-  // The last epoch's receipt lists grow with commit depth (a 0.20 minTarget epoch
-  // applies dozens of marks). They are the commit's own receipt, so they outlast
+  // The last epoch's receipt lists grow with commit depth (a deep epoch applies dozens
+  // of marks). They are the commit's own receipt, so they outlast
   // every other diagnostic, but they still page away before any listing row the
   // caller actually asked for: on the detail pages, where none of the diagnostics
   // above exist, they are the mass that made one fold row miss the cap.
@@ -1170,9 +1156,7 @@ export function visibleCollapsedFolds(
   const visit = (fold: ActiveFold): void => {
     const refs = flattenFoldRefs(fold, state);
     if (!foldInterval(fold, state, snapshot)) return;
-    const protectedSource = fold.kind === "tool-result"
-      ? toolRefsProtected(refs, state, snapshot)
-      : refsProtected(refs, state, snapshot);
+    const protectedSource = refsProtected(refs, state, snapshot);
     if (!state.expanded.includes(fold.id) && !protectedSource) {
       output.push(fold);
       return;
@@ -1352,7 +1336,7 @@ export function peekFoldSource(input: {
       ...(children.length ? { child: { action: "peek", id: children[0] } } : {}),
     },
     ...(truncated
-      ? { wider: { action: "peek", id: fold.id, bytes: Math.min(sourceBytes, ACTIVE_CONTEXT_POLICY.maxChapterChars) } }
+      ? { wider: { action: "peek", id: fold.id, bytes: Math.min(sourceBytes, ACTIVE_CONTEXT_POLICY.maxSourceChars) } }
       : {}),
     lifetime: "these bytes stay in the window exactly as returned, like any other tool result, and " +
       `nothing rewrites this result in place. It is a COPY of fold ${fold.id}'s stored source, so the ` +
@@ -1372,7 +1356,7 @@ export function peekFoldSource(input: {
           "bytes were NOT shown" +
           (view.omittedBytes ? " (the middle; the head and tail are both above)" : " (everything after this slice)") +
           `. Widen with {"action":"peek","id":"${fold.id}","bytes":${
-            Math.min(sourceBytes, ACTIVE_CONTEXT_POLICY.maxChapterChars)}}` +
+            Math.min(sourceBytes, ACTIVE_CONTEXT_POLICY.maxSourceChars)}}` +
           (nextOffset === null ? "" : ` or read on with {"action":"peek","id":"${fold.id}","offset":${nextOffset}}`) +
           ".",
       }

package/extensions/lib/instrumentation.ts

@@ -64,6 +64,7 @@ export interface CacheObservation {
   change: ProjectionChange;
   inputTokens: number;
   cacheReadTokens: number;
+  cacheWriteTokens: number;
   providerSideMiss: boolean;
 }
 
@@ -83,15 +84,15 @@ export interface ContextEvent {
 export type ContextEventKind =
   | "context.attempt"
   | "context.correction"
-  | "context.protect"
+  | "context.pin"
   | "context.capacity"
   | "context.receipt"
-  | "context.rider"
   | "context.lastcall"
   | "context.response"
   | "context.suggestion"
   | "context.outcome"
   | "context.notice"
+  | "context.frontier"
   | "context.commit"
   | "context.fold"
   | "context.brief"
@@ -197,9 +198,14 @@ export function observeCacheUsage(
   const usage = input.usage;
   const inputTokens = ownValue(usage, "input");
   const cacheReadTokens = ownValue(usage, "cacheRead");
+  const rawCacheWriteTokens = ownValue(usage, "cacheWrite");
   if (typeof inputTokens !== "number" || !Number.isFinite(inputTokens) || inputTokens <= 0 ||
       typeof cacheReadTokens !== "number" || !Number.isFinite(cacheReadTokens) ||
       cacheReadTokens < 0) return null;
+  const cacheWriteTokens = typeof rawCacheWriteTokens === "number" &&
+      Number.isFinite(rawCacheWriteTokens) && rawCacheWriteTokens >= 0
+    ? rawCacheWriteTokens
+    : 0;
   const missed = cacheReadTokens === 0;
   const preserved = typeof input.preservedShare === "number" && Number.isFinite(input.preservedShare)
     ? input.preservedShare
@@ -209,7 +215,8 @@ export function observeCacheUsage(
     change: input.change,
     inputTokens,
     cacheReadTokens,
-    providerSideMiss: missed && (input.change !== "rewrite" ||
+    cacheWriteTokens,
+    providerSideMiss: missed && cacheWriteTokens === 0 && (input.change !== "rewrite" ||
       (preserved !== null && preserved >= PROVIDER_SIDE_MISS_PRESERVED_SHARE)),
   };
   if (missed) ledger.observedMisses += 1;

package/extensions/lib/measurement.ts

@@ -325,6 +325,12 @@ export function explicitProtectedKeys(state: ActiveContextState): Set<string> {
   return new Set(state.protected.map(objectRefKey));
 }
 
+/**
+ * Held against folding: pinned by name, or unfoldable for validity (an unfinished turn, an
+ * entry with no evidence ref). There used to be a second reading of this for tool spans,
+ * differing only in which protected set it consulted; the two sets collapsed into one when
+ * fresh-tail was deleted, and the two functions were byte-identical after that.
+ */
 export function refsProtected(
   refs: EvidenceRef[],
   state: ActiveContextState,
@@ -337,18 +343,6 @@ export function refsProtected(
   });
 }
 
-export function toolRefsProtected(
-  refs: EvidenceRef[],
-  state: ActiveContextState,
-  snapshot: ActiveContextSnapshot,
-): boolean {
-  const explicit = explicitProtectedKeys(state);
-  return refs.some((ref) => {
-    const item = exactMapped(snapshot, ref);
-    return !item || explicit.has(objectRefKey(ref)) || snapshot.toolProtectedIndices.has(item.index);
-  });
-}
-
 export function protectedStaleMass(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,

package/extensions/lib/persistence.ts

@@ -56,7 +56,7 @@ export const PENDING_FOLD_MARK_KEYS = [
   "mark", "id", "kind", "parts", "brief", "briefProvenance", "origin", "ordinal",
 ] as const;
 export const PENDING_REFOLD_MARK_KEYS = ["mark", "id", "origin", "ordinal"] as const;
-export const MARK_ORIGINS = Object.freeze(["agent", "ladder"] as const);
+export const MARK_ORIGINS = Object.freeze(["agent", "ladder", "user"] as const);
 export const STATE_CHECKPOINT_V2_KEYS = [
   "version", "kind", "sessionId", "revision", "foldRefs", "expanded", "protected", "prepared", "stateSha256",
 ] as const;
@@ -91,8 +91,7 @@ export function validPendingMark(value: unknown): value is PendingMark {
   const kind = ownValue(value, "kind");
   const parts = denseOwnArrayValues(ownValue(value, "parts"));
   return (kind === "tool-result" || kind === "chapter" || kind === "consolidation") &&
-    Boolean(parts?.length) && parts!.length <= ACTIVE_CONTEXT_POLICY.maxFoldSourceRefs &&
-    parts!.every(validFoldPart) && structurallyValidBrief(ownValue(value, "brief")) &&
+    Boolean(parts?.length) && parts!.every(validFoldPart) && structurallyValidBrief(ownValue(value, "brief")) &&
     validProvenance(ownValue(value, "briefProvenance")) &&
     id === foldIdFor(kind as FoldKind, parts as FoldPart[]);
 }
@@ -210,7 +209,6 @@ export function validFoldShape(value: unknown): value is ActiveFold {
   return (kind === "tool-result" || kind === "chapter" || kind === "consolidation") &&
     typeof ownValue(value, "id") === "string" && Boolean(ownValue(value, "id")) &&
     (parentId === null || typeof parentId === "string") && Boolean(parts?.length) &&
-    parts!.length <= ACTIVE_CONTEXT_POLICY.maxFoldSourceRefs &&
     parts!.every(validFoldPart) && structurallyValidBrief(ownValue(value, "brief")) &&
     validProvenance(ownValue(value, "provenance")) && typeof sourceSha256 === "string" &&
     /^[a-f0-9]{64}$/.test(sourceSha256) && Number.isSafeInteger(ownValue(value, "sourceChars")) &&
@@ -325,7 +323,9 @@ export function parseActiveContextState(
   const hasPendingMarks = recordLike && Object.prototype.hasOwnProperty.call(value, "pendingMarks");
   const hasPinnedPeeks = recordLike && Object.prototype.hasOwnProperty.call(value, "pinnedPeeks");
   const hasBriefs = recordLike && Object.prototype.hasOwnProperty.call(value, "briefs");
-  const hasRider = recordLike && Object.prototype.hasOwnProperty.call(value, "rider");
+  // Read and dropped, never stored: see legacyRiderStateSha256. A v1 state has no digest
+  // to reproduce, so here the tolerance is the whole of it.
+  const hasLegacyRider = recordLike && Object.prototype.hasOwnProperty.call(value, "rider");
   refuseRetiredStateFields(value);
   const extraKeys = [
     ...(hasPrepared ? ["prepared"] : []),
@@ -335,7 +335,7 @@ export function parseActiveContextState(
     ...(hasPendingMarks ? ["pendingMarks"] : []),
     ...(hasPinnedPeeks ? ["pinnedPeeks"] : []),
     ...(hasBriefs ? ["briefs"] : []),
-    ...(hasRider ? ["rider"] : []),
+    ...(hasLegacyRider ? ["rider"] : []),
   ];
   if (!exactRecord(value, [...ACTIVE_STATE_KEYS, ...extraKeys])) throw new Error("Invalid active-context state keys");
   const folds = denseOwnArrayValues(ownValue(value, "folds"));
@@ -357,9 +357,6 @@ export function parseActiveContextState(
   if (hasAdvisory && !validAdvisoryState(ownValue(value, "advisory"))) {
     throw new Error("Invalid active-context advisory state");
   }
-  if (hasRider && !validRiderState(ownValue(value, "rider"))) {
-    throw new Error("Invalid active-context rider state");
-  }
   if (hasTokensSinceToolFold && !validTokensSinceToolFold(ownValue(value, "tokensSinceToolFold"))) {
     throw new Error("Invalid active-context tool-fold cadence");
   }
@@ -386,7 +383,6 @@ export function parseActiveContextState(
     ...(hasAdvisory
       ? { advisory: clone(source.advisory!) }
       : defaultAdvisory ? { advisory: { highWater: 0, delivered: {} } } : {}),
-    ...(hasRider ? { rider: clone(source.rider!) } : {}),
     ...(hasPrepared ? { prepared: clone(source.prepared!) } : {}),
   };
 }
@@ -441,6 +437,29 @@ export function legacyCadenceOmittedStateSha256(state: ActiveContextState): stri
   return sha256Value(legacy);
 }
 
+/**
+ * THE DIGEST A RIDER-ERA BUILD WROTE, reproduced without the subsystem.
+ *
+ * `semanticStateSha256` hashes the materialized state object, and `stableStringify` walks
+ * own keys in INSERTION order, so a field that is gone changes the digest even though it
+ * changed nothing else. The rider sat immediately before `prepared` in the materialized
+ * literal, and last when there was no prepared, so that is where it goes back for the one
+ * moment it is needed. It joins the two legacy derivations already here, which exist for
+ * exactly this reason: a state stays verifiable across the build that stopped writing it.
+ *
+ * Consulted ONLY when the wire actually carried a rider, so a current state whose digest
+ * has genuinely drifted still fails rather than finding a second way to pass.
+ */
+export function legacyRiderStateSha256(state: ActiveContextState, rider: unknown): string {
+  const legacy: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(state)) {
+    if (key === "prepared") legacy.rider = rider;
+    legacy[key] = value;
+  }
+  if (!Object.prototype.hasOwnProperty.call(legacy, "rider")) legacy.rider = rider;
+  return sha256Value(legacy);
+}
+
 export function legacyReplayOrderStateSha256(state: ActiveContextState): string {
   return sha256Value({
     version: state.version,
@@ -503,13 +522,11 @@ export function validateV2ProjectionFields(
   leasesValue: unknown,
   pendingMarksValue?: unknown,
   briefsValue?: unknown,
-  riderValue?: unknown,
 ): {
   expanded: string[];
   protected: EvidenceRef[];
   prepared?: PreparedFold;
   advisory?: NonNullable<ActiveContextState["advisory"]>;
-  rider?: NonNullable<ActiveContextState["rider"]>;
   tokensSinceToolFold: number;
   leases: Record<string, number>;
   pendingMarks: PendingMark[];
@@ -527,9 +544,6 @@ export function validateV2ProjectionFields(
   if (advisoryValue !== undefined && !validAdvisoryState(advisoryValue)) {
     throw new Error("Invalid active-context v2 advisory state");
   }
-  if (riderValue !== undefined && !validRiderState(riderValue)) {
-    throw new Error("Invalid active-context v2 rider state");
-  }
   if (tokensSinceToolFoldValue !== undefined && !validTokensSinceToolFold(tokensSinceToolFoldValue)) {
     throw new Error("Invalid active-context v2 tool-fold cadence");
   }
@@ -543,9 +557,6 @@ export function validateV2ProjectionFields(
     ...(advisoryValue === undefined ? {} : {
       advisory: clone(advisoryValue) as NonNullable<ActiveContextState["advisory"]>,
     }),
-    ...(riderValue === undefined ? {} : {
-      rider: clone(riderValue) as NonNullable<ActiveContextState["rider"]>,
-    }),
     tokensSinceToolFold: tokensSinceToolFoldValue === undefined ? 0 : Number(tokensSinceToolFoldValue),
     leases,
     pendingMarks,
@@ -575,7 +586,7 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
     Object.prototype.hasOwnProperty.call(value, "addBriefs"));
   const hasRemoveBriefIds = Boolean(value && typeof value === "object" &&
     Object.prototype.hasOwnProperty.call(value, "removeBriefIds"));
-  const hasRider = Boolean(value && typeof value === "object" &&
+  const hasLegacyRider = Boolean(value && typeof value === "object" &&
     Object.prototype.hasOwnProperty.call(value, "rider"));
   refuseRetiredStateFields(value);
   const optionalKeys = [
@@ -589,7 +600,9 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
     ...(hasBriefs ? ["briefs"] : []),
     ...(hasAddBriefs ? ["addBriefs"] : []),
     ...(hasRemoveBriefIds ? ["removeBriefIds"] : []),
-    ...(hasRider ? ["rider"] : []),
+    // Carried no further than the digest check in `materializeStatePersistence`, which is
+    // the only thing on a load that the rider's absence can change.
+    ...(hasLegacyRider ? ["rider"] : []),
   ];
   const checkpoint = kind === "checkpoint" &&
     exactRecord(value, [...STATE_CHECKPOINT_V2_KEYS, ...optionalKeys]);
@@ -605,7 +618,6 @@ export function parseActiveContextStateV2(value: unknown, sessionId: string): Ac
     ownValue(value, "expanded"), ownValue(value, "protected"), ownValue(value, "prepared"),
     ownValue(value, "advisory"), ownValue(value, "tokensSinceToolFold"), ownValue(value, "leases"),
     ownValue(value, "pendingMarks"), ownValue(value, "briefs"),
-    ownValue(value, "rider"),
   );
   if (checkpoint) {
     const refs = denseOwnArrayValues(ownValue(value, "foldRefs"));
@@ -700,7 +712,7 @@ export function stateFromFoldRefs(
   wire: Pick<
     ActiveContextCheckpointV2,
     "sessionId" | "revision" | "expanded" | "protected" | "prepared" | "advisory" |
-      "tokensSinceToolFold" | "leases" | "pendingMarks" | "briefs" | "rider"
+      "tokensSinceToolFold" | "leases" | "pendingMarks" | "briefs"
   >,
   refs: FoldRecordRef[],
   records: Map<string, FoldRecordEntry>,
@@ -723,7 +735,6 @@ export function stateFromFoldRefs(
     ...(wire.pendingMarks?.length ? { pendingMarks: clone(wire.pendingMarks) } : {}),
     ...(wire.briefs && Object.keys(wire.briefs).length ? { briefs: clone(wire.briefs) } : {}),
     ...(wire.advisory === undefined ? {} : { advisory: clone(wire.advisory) }),
-    ...(wire.rider === undefined ? {} : { rider: clone(wire.rider) }),
     ...(wire.prepared === null || wire.prepared === undefined ? {} : { prepared: clone(wire.prepared) }),
   };
   return parseActiveContextState(state, wire.sessionId, false);
@@ -793,6 +804,14 @@ export function materializeStatePersistence(
     },
   };
   let stateSha256 = semanticStateSha256(state);
+  // WHAT THE LAST ACCEPTED ENTRY ACTUALLY RECORDED, when that is not what this build
+  // would compute. A state accepted through one of the legacy derivations below was
+  // written by a build that hashed it differently, and the delta that follows it names
+  // its base by THAT digest, so a chain of them is unreadable unless the reading carries
+  // both: the modern digest for what this build writes next, and the written one for what
+  // the next entry will name. Null whenever they agree, which is every state this build
+  // wrote itself, so the chain check below is unchanged for them.
+  let writtenSha256: string | null = null;
   let stateStart = -1;
   let checkpointIndex = -1;
   let v2Seen = false;
@@ -845,7 +864,8 @@ export function materializeStatePersistence(
     if (wire.kind === "checkpoint") {
       state = stateFromFoldRefs(wire, wire.foldRefs, records);
     } else {
-      if (wireVersion === 0 || wire.baseRevision !== state.revision || wire.baseStateSha256 !== stateSha256 ||
+      if (wireVersion === 0 || wire.baseRevision !== state.revision ||
+          (wire.baseStateSha256 !== stateSha256 && wire.baseStateSha256 !== writtenSha256) ||
           wire.revision <= wire.baseRevision) {
         throw new Error("Broken active-context delta chain");
       }
@@ -916,13 +936,17 @@ export function materializeStatePersistence(
       );
     }
     const calculated = semanticStateSha256(state);
+    const legacyRider = (wire as { rider?: unknown }).rider;
     if (calculated !== wire.stateSha256 &&
         legacyCadenceOmittedStateSha256(state) !== wire.stateSha256 &&
-        legacyReplayOrderStateSha256(state) !== wire.stateSha256) {
+        legacyReplayOrderStateSha256(state) !== wire.stateSha256 &&
+        (legacyRider === undefined ||
+          legacyRiderStateSha256(state, legacyRider) !== wire.stateSha256)) {
       throw new Error("Active-context v2 state digest drift");
     }
     wireVersion = 2;
     stateSha256 = calculated;
+    writtenSha256 = wire.stateSha256 === calculated ? null : wire.stateSha256;
     rememberProjection();
   }
   return { state, wireVersion, records, stateSha256, projectionFingerprints };
@@ -966,7 +990,6 @@ export function makeStateCheckpoint(state: ActiveContextState): ActiveContextChe
     ...(state.pendingMarks?.length ? { pendingMarks: clone(state.pendingMarks) } : {}),
     ...(state.briefs && Object.keys(state.briefs).length ? { briefs: clone(state.briefs) } : {}),
     ...(state.advisory ? { advisory: clone(state.advisory) } : {}),
-    ...(state.rider ? { rider: clone(state.rider) } : {}),
     stateSha256: semanticStateSha256(state),
   }, state.sessionId) as ActiveContextCheckpointV2;
 }
@@ -1039,7 +1062,6 @@ export function makeStateDelta(previous: ActiveContextState, next: ActiveContext
     ...(Object.keys(addBriefs).length ? { addBriefs } : {}),
     ...(removeBriefIds.length ? { removeBriefIds } : {}),
     ...(next.advisory ? { advisory: clone(next.advisory) } : {}),
-    ...(next.rider ? { rider: clone(next.rider) } : {}),
     stateSha256: semanticStateSha256(next),
   }, next.sessionId) as ActiveContextDeltaV2;
 }
@@ -1056,12 +1078,13 @@ export const ADVISORY_MILESTONES = Object.freeze(
   ["orientation", "notice", "tools", "chapters", "urgent"] as AdvisoryMilestone[],
 );
 
-export const MAX_RIDER_TEXT_BYTES = 4_096;
-
 /**
  * THE RETIRED STATE FIELDS, REFUSED BY NAME.
  *
- * `lastCall` and `notices` were the occupancy thermostat's two announcements. Nothing
+ * `lastCall` and `notices` were the occupancy thermostat's two announcements, and `rider`
+ * was the post-commit invitation to create marks, deleted 2026-08-23 with the curation
+ * redesign: the runtime cuts and the agent edits, so an invitation to create is a carrier
+ * with nothing left to invite. Nothing
  * writes them any more and nothing reads them, so a durable state that still carries one
  * was written by a build that had them, and the exact-record readers would reject it with
  * "Invalid active-context state keys" -- true, and useless to whoever has to act on it.
@@ -1071,6 +1094,15 @@ export const MAX_RIDER_TEXT_BYTES = 4_096;
  * that comes back is not the state that was written. Gate 17 already states the wire's
  * policy in the other direction -- an older exact-record reader rejects newer fields, and
  * a bump is explicit -- and this is that same policy read from the newer side.
+ *
+ * `rider` IS NOT ON THIS LIST, and the distinction is the whole point of the list. The
+ * refusal's own reason is "a state it cannot reproduce", so a field the build CAN
+ * reproduce is out of its scope: the rider was projection carrier text, it changed no
+ * fold, no ref and no brief, and the only thing it ever touched that survives a load is
+ * the state digest. So it is read, spent on the digest, and dropped, which is what
+ * `legacyRiderStateSha256` below is for. Retiring it by name instead made every state the
+ * sol-20260815-hidden campaign sealed unreadable and cost the hidden-mass result its 102
+ * attributed carriage rows, which is a high price for a field that carried no behaviour.
  */
 const RETIRED_STATE_FIELDS: readonly string[] = Object.freeze(["lastCall", "notices", "surfacing"]);
 
@@ -1086,14 +1118,6 @@ export function refuseRetiredStateFields(value: unknown): void {
   );
 }
 
-export function validRiderState(value: unknown): value is NonNullable<ActiveContextState["rider"]> {
-  if (!exactRecord(value, ["epoch", "text"])) return false;
-  const epoch = ownValue(value, "epoch");
-  const text = ownValue(value, "text");
-  return Number.isSafeInteger(epoch) && Number(epoch) >= 0 &&
-    typeof text === "string" && text.length > 0 && text.length <= MAX_RIDER_TEXT_BYTES;
-}
-
 export function validAdvisoryState(value: unknown): value is NonNullable<ActiveContextState["advisory"]> {
   const hasArmed = Boolean(value && typeof value === "object" &&
     Object.prototype.hasOwnProperty.call(value, "armed"));