pi-fold 1.0.4 → 3.0.0

package/extensions/evidence.js

@@ -562,16 +562,6 @@ function mcpServerForTool(toolName, fallback) {
     : fallback;
 }
 
-/**
- * MCP tools are recognized by their name, and by nothing else.
- *
- * This was a host-supplied predicate whose default returned false for everything, so a
- * conventionally named MCP tool was never classified unless a host wrote the predicate:
- * a documented feature whose shipped state guaranteed it never ran. `mcp__server__tool`
- * is the convention every MCP host follows, so it is the rule. A name outside the
- * convention is deliberately not classified as MCP, and its oversized results fall to
- * the ordinary tool-result path.
- */
 function conventionalMcpTool(toolName) {
   return mcpServerForTool(toolName, null) !== null;
 }

package/extensions/index.js

@@ -1,45 +1,43 @@
 import { registerActiveContext } from "./active-context.ts";
 import { registerEvidenceIngestion } from "./evidence.js";
-import { createSummarizeContextSpan } from "./summarizer.js";
 
-/**
- * THE public surface: five options, and every name outside them is refused.
- *
- * Unknown keys used to spread through silently, which made every deletion a no-op rather
- * than an error and handed a deployment the opposite of what it asked for. A caller that
- * passes a name believes it bought behavior, so a name this package does not sell is a
- * throw with the replacement named in it.
- */
+export {
+  applyFoldSettingsEdit,
+  loadFoldSettingsFile,
+  readFoldSettingsFile,
+  registerFoldSettings,
+  saveFoldSettingsFile,
+} from "./settings.ts";
+
 const PUBLIC_OPTIONS = Object.freeze([
-  "thresholds", "summarizer", "providerInputBudget", "blacklistAutoFoldTools", "guidance",
+  "thresholds", "providerInputBudget", "blacklistAutoFoldTools",
 ]);
 
-/**
- * Both spellings of the auto-fold list were ALLOW-lists, and the list runs the other way
- * now. Forwarding one silently would be the worst possible outcome of a rename: a set of
- * tools a deployment named to make foldable would become the exact set it barred.
- */
+const GENERATOR_DELETED = "the model brief generator is deleted (2026-08-14): across 15 sealed " +
+  "generator runs, 75 percent of its 1,186 upgraded briefs were never consulted or never became " +
+  "visible, and the no-generator build scored the same for less. Every fold carries its " +
+  "deterministic brief; sessions already holding model briefs keep them on load";
+
 const INVERTED_AUTO_FOLD_LIST = "renamed blacklistAutoFoldTools, and the sense is INVERTED: " +
   "every completed tool batch folds unmarked, and the list names the exceptions whose " +
   "results must stay raw. An allow-list moved across verbatim would bar exactly the tools " +
   "it meant to permit";
 
-/**
- * Options that left the surface, each answered by name. Deployment identity is hardwired:
- * this is a branded package with one deployment, not a framework a host rebrands, and a
- * consumer that moved `entryTypePrefix` stranded its own durable folds under a namespace
- * nothing would read back.
- */
 const REFUSED_OPTIONS = Object.freeze({
+  guidance: "deleted 2026-08-23: it switched the copy that taught the agent to " +
+    "CHOOSE SPANS, and the agent does not choose spans. The runtime cuts at the frontier and " +
+    "the agent annotates what it cut, so the guidance it switched is replaced wholesale by " +
+    "the post-fold notice, which is not optional: a fold the agent is never told about is one " +
+    "it can never brief",
   toolName: "the deployment identity is hardwired to pi-fold: the tool is pi_fold_context",
   toolLabel: "the deployment identity is hardwired to pi-fold",
   brandNoun: "the deployment identity is hardwired to pi-fold",
   entryTypePrefix: "the deployment identity is hardwired to pi-fold: durable state lives " +
     "under pi-fold-active-context, and moving it would strand every fold already written",
   commandPrefix: "the deployment identity is hardwired to pi-fold: the commands are " +
-    "/pi-fold-context and /fold-context",
+    "/fold, /fold-editor, /fold-status and /fold-settings",
   commandNames: "the deployment identity is hardwired to pi-fold: the commands are " +
-    "/pi-fold-context and /fold-context",
+    "/fold, /fold-editor, /fold-status and /fold-settings",
   isMcpTool: "MCP tools are recognized by the mcp__server__tool naming convention. The " +
     "predicate defaulted to false, so conventionally named MCP tools were never classified " +
     "unless a host supplied one, which is a documented feature that never ran",
@@ -52,11 +50,11 @@ const REFUSED_OPTIONS = Object.freeze({
   providerTotalWindow: "renamed providerInputBudget, and it is ALREADY NET: pass the tokens " +
     "the deployment may actually fill, not the total window the runtime then subtracts a " +
     "guessed output reservation from",
-  summarizeContextSpan: "choose a brief generator with summarizer (\"session\" or " +
-    "{ provider, model, effort })",
+  summarizer: GENERATOR_DELETED,
+  summarizeContextSpan: GENERATOR_DELETED,
 });
 
-export function registerPiFold(pi, options = {}, loadHostModule) {
+export function registerPiFold(pi, options = {}) {
   for (const name of Object.keys(options)) {
     if (Object.hasOwn(REFUSED_OPTIONS, name)) {
       throw new Error(`${name} is no longer an option: ${REFUSED_OPTIONS[name]}`);
@@ -66,13 +64,8 @@ export function registerPiFold(pi, options = {}, loadHostModule) {
         `${PUBLIC_OPTIONS.join(", ")}`);
     }
   }
-  const { summarizer = "session", ...activeContextOptions } = options;
-  const summarizeContextSpan = createSummarizeContextSpan(summarizer, loadHostModule);
-  // Evidence first, then the runtime. Ingestion is unconditional: the artifacts are the
-  // exact-recovery anchors an oversized tool result folds against, so a deployment that
-  // turned them off kept the folds and lost what makes them lossless.
   registerEvidenceIngestion(pi);
-  return registerActiveContext(pi, { ...activeContextOptions, summarizeContextSpan });
+  return registerActiveContext(pi, options);
 }
 
 export default function piFold(pi, options) {

package/extensions/json.ts

@@ -8,7 +8,6 @@ export interface EvidenceRef {
   sha256: string;
 }
 
-// Capture trust-boundary intrinsics before mutable prototypes can influence validation.
 const ArrayConstructor = Array;
 const arrayIsArray = Array.isArray;
 const arrayPrototype = Array.prototype;
@@ -95,7 +94,6 @@ function safeJson(value: unknown, ancestors: unknown[]): string | undefined {
   }
 }
 
-/** Preserve JSON property order without invoking getters, toJSON, coercion, iterators, or mutable prototypes. */
 export function stableStringify(value: unknown): string {
   const serialized = safeJson(value, new ArrayConstructor<unknown>());
   if (typeof serialized !== "string") throw new Error("Value is not JSON-serializable");
@@ -122,7 +120,6 @@ export function ownDataProperty(value: unknown, key: PropertyKey): unknown {
   return descriptor && "value" in descriptor ? descriptor.value : undefined;
 }
 
-/** Copy a dense own-data array without invoking inherited accessors, iterators, or methods. */
 export function denseOwnArrayValues(value: unknown): unknown[] | null {
   if (!arrayIsArray(value) || isProxy(value) || getPrototypeOf(value) !== arrayPrototype) return null;
   const lengthDescriptor = getOwnPropertyDescriptor(value, "length");
@@ -202,7 +199,9 @@ export function objectRefKey(ref: EvidenceRef): string {
 }
 
 export function sameObjectIdentity(left: EvidenceRef, right: EvidenceRef): boolean {
-  return objectRefKey(left) === objectRefKey(right);
+  return left.sessionId === right.sessionId &&
+    left.entryId === right.entryId &&
+    left.role === right.role;
 }
 
 export function evidenceValue(message: unknown): unknown {
@@ -216,31 +215,6 @@ export function evidenceValue(message: unknown): unknown {
   };
 }
 
-/**
- * Evidence digests, kept against the message OBJECT.
- *
- * A message is canonicalized and hashed whole to produce its digest, and the messages
- * this runs on are transcript entries: tool results in the tens of kilobytes. Nothing
- * cached the result, so every reading that wanted to confirm a ref rehashed the entire
- * message from scratch. `exactMapped` does exactly that on every lookup, and the
- * selection, surfacing, ordering and accounting passes call it once per ref, per fold,
- * several times a turn. Replayed against the sealed sol-20260812 rep-2 session at its
- * 85 percent point, that single recomputation was 76 percent of all CPU, and it grows
- * with the transcript because the transcript is what it rehashes.
- *
- * A WeakMap on the object is the same shape `MAPPED_BY_KEY` and `BRANCH_POSITIONS`
- * already use one line over, and the same rule gate 113 settled for entry evidence: the
- * session is append-only, so keep the derivation against the object and let a REPLACED
- * object miss rather than serve a stale answer. Entries are never edited in place; they
- * are appended, and a changed message is a different object, which misses and rehashes.
- *
- * What this no longer detects, stated plainly: a message mutated IN PLACE after it was
- * first hashed now keeps its original digest. That case was already half invisible,
- * because the ref a snapshot carries was itself computed from that same object at
- * mapping time, so a mutation that beat the digest would have to be caught by this
- * recomputation alone. No path in this package edits a persisted message, and the
- * runtime clones before it stores.
- */
 const EVIDENCE_DIGESTS = new WeakMap<object, string>();
 
 export function evidenceSha256(message: unknown): string {

package/extensions/lib/canonical.ts

@@ -18,16 +18,9 @@ export function bytes(value: unknown): number {
 export function boundedUtf8(text: string, maximumBytes: number): string {
   const buffer = Buffer.from(text, "utf8");
   if (buffer.length <= maximumBytes) return text;
-  // A multi-byte sequence cut by the bound decodes to one trailing replacement
-  // character; dropping it keeps the slice an exact prefix of the source.
   return buffer.subarray(0, maximumBytes).toString("utf8").replace(/\uFFFD$/, "");
 }
 
-/**
- * The suffix of `text` beginning at a byte offset. A multi-byte sequence cut by the
- * offset decodes to one leading replacement character; dropping it keeps the slice an
- * exact suffix of the source, which is what makes a paged peek losslessly rejoinable.
- */
 export function utf8Slice(text: string, offsetBytes: number): string {
   if (offsetBytes <= 0) return text;
   const buffer = Buffer.from(text, "utf8");
@@ -75,7 +68,6 @@ export function contentText(message: unknown): string {
   return text.join("\n");
 }
 
-/** Pi's exact one-entry projection, kept local so this service has no second transcript owner. */
 export function sessionEntryMessages(entry: Record<string, unknown>): unknown[] {
   if (entry.type === "message" && entry.message && typeof entry.message === "object") {
     const message = entry.message as Record<string, unknown>;

package/extensions/lib/curation.ts

@@ -1,311 +1,70 @@
-import { objectRefKey } from "../json.ts";
-import {
-  boundedUtf8,
-  bytes,
-  messageRole,
-} from "./canonical.ts";
 import { boundReceiptText } from "./measurement.ts";
 import {
   contextBrand,
-  CONTEXT_MARK_RESPONSE_BYTES,
   CONTEXT_RECEIPT_BLOCK_BYTES,
+  FOLD_NOTICE_BYTES,
   DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN,
   MAX_CONTEXT_RECEIPTS,
-  MAX_LAST_CALL_TEXT_BYTES,
-  MAX_SURFACING_LINE_BYTES,
-  MAX_THRESHOLD_NOTICE_TEXT_BYTES,
-} from "./policy.ts";
-import type {
-  ActiveContextSnapshot,
-  ActiveContextState,
 } from "./policy.ts";
 
 /**
- * Guided curation.
- *
- * The ladder's commit triggers are correct and silent. Silent is the problem: the
- * agent learns that its evidence became placeholders by reading a placeholder, which
- * is the one moment it can no longer do anything about it. So a commit is ANNOUNCED
- * before it happens, early enough that reacting is still cheap, and the announcement
- * carries what is about to happen, what it costs, and the actions that change it.
- *
- * Everything here is deterministic: transcript ordinals, measured tokens and byte
- * counts only. No wall clock and no randomness.
- */
-
-export interface StaleToolMass {
-  /** Serialized bytes of tool results outside the fresh tail and outside every fold. */
-  bytes: number;
-  /** How many tool results that mass is spread over. */
-  results: number;
-}
-
-/**
- * Tool-result mass a commit could actually reach: outside the fresh tail, outside any
- * protection, and not already owned by a fold. Occupancy alone would announce commits
- * that have nothing to fold; this is the second signal that says the announcement is
- * about to be worth something.
- */
-export function staleToolMass(
-  snapshot: ActiveContextSnapshot,
-  state: ActiveContextState,
-): StaleToolMass {
-  const owned = new Set(state.folds.flatMap((fold) =>
-    fold.parts.flatMap((part) => part.kind === "raw" ? [objectRefKey(part.ref)] : [])));
-  let total = 0;
-  let results = 0;
-  for (const item of snapshot.mapped) {
-    if (!item.ref || messageRole(item.message) !== "toolResult") continue;
-    if (snapshot.toolProtectedIndices.has(item.index)) continue;
-    if (owned.has(objectRefKey(item.ref))) continue;
-    total += bytes(item.message);
-    results += 1;
-  }
-  return { bytes: total, results };
-}
-
-export interface CurationSignals {
-  /** Measured provider tokens as a share of the truthful serving budget; null unmeasured. */
-  occupancy: number | null;
-  /** The trigger line this occupancy is read against: thresholds.maxTarget. */
-  maxTarget: number;
-  occupancyTokens: number | null;
-  /** THE serving budget: one resolved value, the same one the fence and estimator use. */
-  budgetTokens: number;
-  window: number;
-  /** Stale tool mass as a share of the serving budget, in the session's own tokens. */
-  staleToolShare: number;
-  staleToolTokens: number;
-  staleToolResults: number;
-  /** Marks a commit could apply right now. */
-  eligibleFolds: number;
-}
-
-/**
- * Both signals are measured against ONE resolved serving budget, handed in by the
- * caller that owns the capacity accounting. Nothing here re-derives a window from a
- * descriptor: rep 15's trigger and gate ran the whole run against a 272,000-token
- * per-request descriptor while the fence used the truthful 383,616, because the budget
- * was computed twice from two different places.
- */
-export function curationSignals(input: {
-  snapshot: ActiveContextSnapshot;
-  state: ActiveContextState;
-  usedTokens: number | null;
-  budgetTokens: number;
-  /** The resolved serving WINDOW the budget was taken from, reported for audit. */
-  window: number;
-  /** The session's own measured serialized chars per token; never a fixed constant. */
-  charsPerToken: number;
-  eligibleFolds: number;
-}): CurationSignals {
-  const mass = staleToolMass(input.snapshot, input.state);
-  const charsPerToken = Number.isFinite(input.charsPerToken) && input.charsPerToken > 0
-    ? input.charsPerToken
-    : 4;
-  const staleToolTokens = Math.ceil(mass.bytes / charsPerToken);
-  return {
-    maxTarget: input.snapshot.thresholds.maxTarget,
-    occupancy: input.usedTokens === null || input.budgetTokens <= 0
-      ? null
-      : input.usedTokens / input.budgetTokens,
-    occupancyTokens: input.usedTokens,
-    budgetTokens: input.budgetTokens,
-    window: input.window,
-    staleToolShare: input.budgetTokens > 0 ? staleToolTokens / input.budgetTokens : 0,
-    staleToolTokens,
-    staleToolResults: mass.results,
-    eligibleFolds: input.eligibleFolds,
-  };
-}
-
-/**
- * ONE signal. Occupancy of the serving budget reaches maxTarget, and a commit is due.
+ * THE POST-FOLD NOTICE: THE ONE MOMENT THE AGENT KNOWS SOMETHING THE RUNTIME DOES NOT.
  *
- * The second signal is gone with the announcement it guarded. It existed because the
- * trigger ANNOUNCED a commit before running one, and announcing a commit that has
- * nothing stale to fold is a false statement in the window; the announcement was
- * deleted when its cache cost was measured, and the AND-condition outlived its reason.
- * A commit with nothing eligible now simply applies nothing and says so, which the
- * reclaim floor and the eligibility accounting already report. Stale mass is still
- * measured and still reported; it is no longer a condition on the trigger.
- */
-export function curationTriggerFires(signals: CurationSignals): boolean {
-  return signals.occupancy !== null &&
-    Number.isFinite(signals.occupancy) &&
-    signals.occupancy >= signals.maxTarget;
-}
-
-/**
- * The awareness block a mark call answers with.
+ * The runtime has just cut folds behind the agent, out of material the agent is still
+ * looking at. It knows the spans, the sizes and the staleness; it does not know why any
+ * of it mattered. So the notice states what was cut and asks for exactly one thing, a
+ * brief, and it states the price of answering, which is nothing: the folds it names are
+ * PENDING, so a brief written now is stored outside the projection and reaches the window
+ * only when the commit writes that placeholder for the first time.
  *
- * The projection is byte-frozen between fold events, so this tool result is the ONLY
- * cache-free place left to tell the agent where it stands. It carries three things and
- * stops: what is now held, what is still on the table as an aggregate with a bounded
- * head of the largest names, and the one percentage worth steering by. It is hard
- * bounded on the receipt block's principle: awareness that becomes bloat is bloat.
+ * It is batched rather than continuous. One notice per cut is noise, and noise is how
+ * guidance gets ignored; this one appears when enough folds are standing unbriefed to be
+ * worth a turn's attention, and it is ephemeral, so it never accumulates.
  */
-export function markAwarenessText(input: {
-  held: ReadonlyArray<{ id: string; kind: string; tokens: number }>;
-  remainder: { spans: number; tokens: number; share: number; candidates: ReadonlyArray<{ id: string; tokens: number }> };
+export function foldNoticeText(input: {
+  unbriefed: ReadonlyArray<{ id: string; kind: string; tokens: number }>;
+  pending: number;
   toolName: string;
   brandNoun?: string;
 }): string {
   const brand = contextBrand(input.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
-  const { remainder } = input;
-  const held = input.held.length
-    ? input.held.map((span) => `${span.id} (${span.kind}, about ${span.tokens} tokens)`).join("; ")
-    : "none";
-  const candidates = remainder.candidates.length
-    ? remainder.candidates.map((item) => `${item.id} (about ${item.tokens} tokens)`).join("; ")
-    : "none";
-  return boundReceiptText([
-    `[${brand} marks] Held until they age out or the next fold event: ${held}.`,
-    `Unmarked remainder: ${remainder.spans} span(s), about ${remainder.tokens} tokens of stale mass, ` +
-      `${Math.round(remainder.share * 100)}% of the non-fresh window.`,
-    `Largest unmarked by reclaim value: ${candidates}.`,
-    `Mark several spans in one ${input.toolName} call: one call, and this whole picture comes back with it.`,
-  ].join("\n"), CONTEXT_MARK_RESPONSE_BYTES, `[${brand} marks] Held; the remainder is unavailable this pass.`);
-}
-
-/**
- * The rider: the one post-commit carrier, composed at a fold commit and delivered
- * INSIDE the rewrite that commit already paid for, beside the receipt. Its wording
- * follows the curation rule (report what is happening, name the actions), its numbers
- * are decision inputs only: pending agent marks with what they free, up to three
- * completed-unit anchors, and the pinned share against its cap. Raw occupancy,
- * distance-to-commit and unmarked-share percentages stay OUT: they are pressure
- * readouts, not decisions, and the pre-commit last call is where they are both
- * accurate and free.
- */
-export function contextRiderText(input: {
-  toolName: string;
-  brandNoun?: string;
-  pendingAgentMarks: number;
-  eligibleMarks: number;
-  freedTokens: number;
-  eligibleFreedTokens: number;
-  /** Up to three completed-unit entry ids the agent could mark next. */
-  anchors: string[];
-  pinnedShare: number;
-  maxPinnedShare: number;
-  /** The surfacing slate, already bounded and already logged; null on a silent pass. */
-  suggestion?: string | null;
-}): string {
-  const brand = contextBrand(input.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
-  const anchors = input.anchors.length
-    ? input.anchors.slice(0, 3).join(", ")
-    : "none";
-  const pinnedPercent = Math.round(input.pinnedShare * 100);
-  const capPercent = Math.round(input.maxPinnedShare * 100);
-  // The slate carries its OWN bound and is joined after this text is bounded, so the
-  // carrier's overhead is its bound plus the line's, and neither can eat the other: a
-  // long rider must never truncate the one sentence a suggestion consists of.
-  return joinSurfacing(boundReceiptText(
-    [
-      `[${brand} notice] A fold commit just landed; the next one will batch every pending mark ` +
-        "into one rewrite, and marks are free until then.",
-      "Mark FINISHED units at their clean boundaries; batches beat singles: " +
-        `${input.toolName} {"action":"fold","marks":[{"ids":["<start>","<end>"],"brief":"<factual brief>"}]} ` +
-        "carries several decisions into that single rewrite, each keeping your brief instead of a " +
-        `generated one. ${input.pendingAgentMarks} of your mark(s) pending; ` +
-        `${input.eligibleMarks} mark(s) eligible now, freeing about ${input.eligibleFreedTokens} ` +
-        `of the ${input.freedTokens} marked token(s).`,
-      `Completed units ready to mark, largest first: ${anchors}.`,
-      `Pinning: ${input.toolName} {"action":"protect","ids":["<entry-id>"]} holds entries raw through ` +
-        `every fold, and {"action":"unprotect"} releases them. Pinned context is ${pinnedPercent}% of ` +
-        `the working window against a ${capPercent}% cap; at the cap, protect refuses until ` +
-        "something is released.",
-    ].join("\n"),
-    2_048,
-    `[${brand} notice] Post-commit curation details are unavailable this pass.`,
-  ), input.suggestion);
-}
-
-/** One carrier, one optional slate line, appended last and bounded on its own. */
-export function joinSurfacing(text: string, suggestion?: string | null): string {
-  if (!suggestion) return text;
-  return `${text}\n${boundedUtf8(suggestion, MAX_SURFACING_LINE_BYTES)}`;
-}
-
-/** The ruled last-call sentence (Shane, 2026-08-09 13:23), verbatim. */
-export const LAST_CALL_WORDING =
-  "Fold commit triggered, please add or edit marks, pin or unpin context based on foreseeable relevance.";
-
-/**
- * The pre-commit last-call.
- *
- * It rides the commit boundary: the band-top trigger has fired, the rewrite is one
- * round away, so this is the single moment telemetry is both accurate and free. It
- * carries the ruled wording, the three numbers the ruling names (occupancy against the
- * commit line, unmarked foldable mass the ladder can reach, pending marks), the verbs,
- * and the one-round law. Never a question: continuing the task is the stated default,
- * and the commit proceeds regardless.
- */
-export function lastCallText(input: {
-  signals: CurationSignals;
-  unmarked: { spans: number; tokens: number };
-  pendingMarks: number;
-  /** Peek copies this exposure marked for reclaim, so the pin that vetoes one is timely. */
-  peekReclaims?: number;
-  /** The surfacing slate, already bounded and already logged; null on a silent pass. */
-  suggestion?: string | null;
-  toolName: string;
-  brandNoun?: string;
-}): string {
-  const brand = contextBrand(input.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
-  const { signals } = input;
-  const occupancy = signals.occupancy === null ? "unmeasured" : `${Math.round(signals.occupancy * 100)}%`;
-  const peekReclaims = input.peekReclaims ?? 0;
-  return joinSurfacing(boundReceiptText([
-    `[${brand} last call] ${LAST_CALL_WORDING}`,
-    `Occupancy is ${occupancy} of the ${signals.budgetTokens}-token serving budget, at or past the ` +
-      `${Math.round(signals.maxTarget * 100)}% commit line. Unmarked foldable mass: ` +
-      `${input.unmarked.spans} span(s), about ${input.unmarked.tokens} tokens. ` +
-      `Pending marks: ${input.pendingMarks}.`,
-    // Stated only when there is one to veto: a standing sentence about zero peek copies
-    // is bytes every exposure pays for and no round ever acts on.
-    peekReclaims > 0
-      ? `Peek copies reclaimed by this commit: ${peekReclaims}. Each duplicates a fold you can peek ` +
-        "again at any time, and its placeholder names that fold, so nothing becomes unreachable. " +
-        "Pin one to keep the copy raw."
-      : "",
-    `Marks: ${input.toolName} ` +
-      "{\"action\":\"fold\",\"marks\":[{\"ids\":[\"<start>\",\"<end>\"],\"brief\":\"<factual brief>\"}]} " +
-      "adds or widens several in one call. Pins: {\"action\":\"protect\",\"ids\":[\"<entry-id>\"]} holds " +
-      "entries raw through every fold, and {\"action\":\"unprotect\"} releases them.",
-    "This is one round: the commit proceeds on the pass after your next response with whatever marks " +
-      "exist. Continuing the task is the default; nothing here needs a reply.",
-  ].filter(Boolean).join("\n"), MAX_LAST_CALL_TEXT_BYTES,
-  `[${brand} last call] ${LAST_CALL_WORDING}`), input.suggestion);
-}
-
-/**
- * One occupancy waypoint, stated once. Informatory and quiet: below the commit line
- * nothing folds automatically, so the only useful sentence is where the window stands
- * and that marks and pins made now shape the eventual commit.
- */
-export function thresholdNoticeText(input: {
-  share: number;
-  occupancyTokens: number;
-  budgetTokens: number;
-  maxTarget: number;
-  toolName: string;
-  brandNoun?: string;
-}): string {
-  const brand = contextBrand(input.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN);
-  return boundReceiptText(
-    `[${brand} notice] Context occupancy crossed ${Math.round(input.share * 100)}% of the ` +
-      `${input.budgetTokens}-token serving budget (${input.occupancyTokens} tokens). Nothing folds before ` +
-      `the fold commit at ${Math.round(input.maxTarget * 100)}%; marks and pins made now shape it: ` +
-      `${input.toolName} {"action":"fold","marks":[{"ids":["<start>","<end>"],"brief":"<factual brief>"}]} ` +
-      'or {"action":"protect","ids":["<entry-id>"]}.',
-    MAX_THRESHOLD_NOTICE_TEXT_BYTES,
-    `[${brand} notice] Context occupancy crossed ${Math.round(input.share * 100)}% of the serving budget.`,
-  );
+  // THE INSTRUCTION IS SEATED BEFORE THE LIST, and the list is what gives when the
+  // notice runs out of room. The first cut of this built one string with the ids in the
+  // opening line and handed the whole thing to the bound, so a seven-fold batch spent its
+  // budget on ids and lost "here is how to answer" off the end: the agent was told which
+  // folds were unbriefed and not told that briefing them was free, which is the only fact
+  // in here it cannot work out for itself. Fold count grows without limit and the
+  // instruction does not, so the instruction is fixed and the ids are the variable part.
+  const head = [
+    `[${brand} folds] ${input.unbriefed.length} of your ${input.pending} pending fold(s) carry ` +
+      "no brief yet. These spans are cut but NOT folded: every byte they cover is still in " +
+      "front of you exactly as it was, and they enter your window only when a commit " +
+      "applies them.",
+    `Give each one a sentence: ${input.toolName} {"action":"brief","id":"<fold-id>","brief":"..."}. ` +
+      "You know why the span mattered and what you will want back from it; the automatic " +
+      "brief reads the span alone and does not. Writing it now costs your window nothing, " +
+      "because the fold is not in your window yet.",
+    `Wrong boundary? ${input.toolName} {"action":"reboundary","ids":[...]} re-cuts it. ` +
+      `Should not be taken at all? ${input.toolName} {"action":"unmark","ids":["<fold-id>"]}.`,
+  ].join("\n");
+  // WHAT IT COULD NOT NAME, IT COUNTS (gate 136's law, and gate 115's shape one level
+  // out): a list that stops early and says nothing reads as a complete list.
+  const entries = input.unbriefed
+    .map((fold) => `${fold.id} (${fold.kind}, ~${fold.tokens} tokens)`);
+  const overflowText = (seated: number) =>
+    `${input.toolName} {"action":"status"} lists the other ${input.unbriefed.length - seated}.`;
+  let seated = entries.length;
+  let list = `Unbriefed: ${entries.join("; ")}.`;
+  while (seated > 0 && Buffer.byteLength(`${head}\n${list}`, "utf8") > FOLD_NOTICE_BYTES) {
+    seated -= 1;
+    list = seated === 0
+      ? overflowText(0)
+      : `Unbriefed: ${entries.slice(0, seated).join("; ")}. ${overflowText(seated)}`;
+  }
+  return boundReceiptText(`${head}\n${list}`, FOLD_NOTICE_BYTES,
+    `[${brand} folds] Pending folds are waiting for briefs; the list is unavailable this pass.`);
 }
 
-/** One automatic context action, reported back as status rather than as advice. */
 export interface ContextReceipt {
   kind: string;
   ordinal: number;
@@ -313,20 +72,14 @@ export interface ContextReceipt {
   foldsCommitted: number;
   foldsCreated: number;
   freedTokens: number;
-  /** Measured occupancy either side of the action, in tokens. The impact, concretely. */
   occupancyBefore: number | null;
   occupancyAfter: number | null;
-  /** What the action actually folded, split the way an agent thinks about it. */
   spansFolded: number;
   toolResultsFolded: number;
-  /** Bite-sized splitting, when an oversized span became sequential folds. */
   splitFolds: number;
   splitFromChars: number;
-  /** Short stale spans a commit absorbed into their later neighbour fold. */
   absorbedWedges: number;
-  /** Overflow recovery, when this action rebuilt a request the provider would reject. */
   recovered: boolean;
-  /** Mass the agent's pins held out of this commit's reach, in bytes. */
   protectedBytes: number;
   note: string | null;
 }
@@ -352,7 +105,6 @@ export function contextReceipt(input: Partial<ContextReceipt> & { kind: string;
   };
 }
 
-/** Newest last, oldest evicted: a receipt block that can never grow into its own problem. */
 export function withReceipt(
   receipts: readonly ContextReceipt[],
   receipt: ContextReceipt,
@@ -387,18 +139,13 @@ export function receiptLine(receipt: ContextReceipt): string {
       ? "This ran as overflow recovery: the request would not have been transmissible, and it was rebuilt rather than dropped."
       : "",
     receipt.protectedBytes
-      ? `${receipt.protectedBytes} byte(s) stay pinned under protect; unprotect releases them when the work moves on.`
+      ? `${receipt.protectedBytes} byte(s) stay pinned; unpin releases them when the work moves on.`
       : "",
     receipt.note ?? "",
   ];
   return parts.filter(Boolean).join(" ");
 }
 
-/**
- * The receipt block. Informatory, never exhortative: it reports what the runtime did,
- * what it cost, and the verbs that correct it. Hard-bounded, because a report about
- * bloat that becomes bloat has argued against itself.
- */
 export function receiptBlockText(input: {
   receipts: readonly ContextReceipt[];
   toolName: string;
@@ -410,14 +157,8 @@ export function receiptBlockText(input: {
     `[${brand} actions] Recent automatic context actions, newest last. Exact source remains expandable.`;
   const verbs = `Correct any of it: ${input.toolName} ` +
     "{\"action\":\"expand\",\"id\":\"<fold-id>\"} restores a span in place; " +
-    "{\"action\":\"rebrief\",\"id\":\"<fold-id>\",\"brief\":\"<factual brief>\"} replaces a brief that " +
-    "does not describe what you needed; {\"action\":\"reboundary\",\"id\":\"<fold-id>\"} returns a " +
-    "mis-cut fold to raw so you can fold the span you meant.";
-  // The verbs are the only part of this block an agent can act on, and they sit last, so
-  // a plain tail truncation drops them precisely when the report runs long -- which is
-  // when a commit did the most and correcting it matters most. Reserve them, and spend
-  // what remains on receipt lines newest-first: an older action that no longer fits is
-  // the right thing to lose, and its structured record is still in the ring.
+    "{\"action\":\"reboundary\",\"id\":\"<fold-id>\"} returns a mis-cut fold to raw so you can " +
+    "fold the span you meant.";
   const fixed = Buffer.byteLength(header, "utf8") + Buffer.byteLength(verbs, "utf8") + 1;
   if (fixed > CONTEXT_RECEIPT_BLOCK_BYTES) {
     return `[${brand} actions] Recent automatic context actions are unavailable this pass.`;
@@ -427,8 +168,6 @@ export function receiptBlockText(input: {
   for (let index = input.receipts.length - 1; index >= 0; index -= 1) {
     const line = receiptLine(input.receipts[index]);
     if (Buffer.byteLength(line, "utf8") + 1 > remaining) {
-      // Not even the newest line fits whole: carry as much of it as the reservation
-      // leaves rather than reporting an action with no detail at all.
       if (!kept.length && remaining > 1) kept.push(boundReceiptText(line, remaining - 1, ""));
       break;
     }