pi-fold 3.0.0 → 3.1.0

package/extensions/active-context.ts

@@ -6,10 +6,12 @@ import {
   stableStringify,
 } from "./json.ts";
 import {
+  contentText,
   bytes,
   clone,
   emptyActiveContextState,
   ownValue,
+  serializedPrefixHolds,
   sessionEntryMessages,
   uniqueMessageDigestAnchor,
 } from "./lib/canonical.ts";
@@ -70,6 +72,7 @@ import {
   deriveFoldParents,
   flattenFoldRefs,
   foldIdFor,
+  foldRecordRef,
   makeFoldRecordEntry,
   makeStateCheckpoint,
   makeStateDelta,
@@ -104,6 +107,7 @@ import {
   ESTIMATED_BYTES_PER_TOKEN,
   entryTypeNamespace,
   MAX_FOLD_SPAN_CHARS,
+  DEFAULT_TOOL_FOLD_THRESHOLD,
   MAX_PINNED_SHARE,
   PEEK_DEFAULT_MAX_BYTES,
   peekIsEphemeral,
@@ -112,17 +116,22 @@ import {
   RETIRED_TOOL_ACTIONS,
   AUTO_FOLD_BLACKLIST_DEFAULT,
   USER_RESCUE_MAX_SOURCE_CHARS,
+  MEMORY_BODY_CHARS,
+  MEMORY_KEY_CHARS,
+  MEMORY_KEYS_MAX,
+  WORKING_MEMORY_TOOL_ACTIONS,
 } from "./lib/policy.ts";
 import type {
   ActiveContextSnapshot,
   ActiveContextState,
   ActiveContextThresholds,
   ActiveContextToolAction,
+  BriefProvenance,
   FoldCandidate,
   FoldKind,
   FoldRecordEntry,
-  MarkOrigin,
   PreparedFold,
+  WorkingMemoryEntry,
 } from "./lib/policy.ts";
 import {
   absorbWedgeMarks,
@@ -131,6 +140,7 @@ import {
 import {
   contextReceipt,
   foldNoticeText,
+  memoryTocText,
   receiptBlockText,
   withReceipt,
 } from "./lib/curation.ts";
@@ -142,6 +152,7 @@ import {
   commitCoverage,
   windowClaims,
   commitPendingMarks,
+  toolClipAdditions,
   consolidationMarks,
   ephemeralPeekMarks,
   epochCommitDue,
@@ -149,6 +160,7 @@ import {
   foldMarkFor,
   ladderBrief,
   markAccounting,
+  markRewriteTokens,
   markFreedBytes,
   unmarkedRemainder,
   markClaimingRef,
@@ -211,38 +223,6 @@ export * from "./lib/scheduling.ts";
 export * from "./lib/selection.ts";
 export * from "./lib/transcript.ts";
 
-export interface BatchedMarkRequest {
-  ids: string[];
-  brief?: string;
-}
-
-export function batchedMarkRequests(params: Record<string, unknown>): BatchedMarkRequest[] {
-  const batched = params.marks;
-  if (batched === undefined) {
-    return [{
-      ids: stringIds(params.ids),
-      ...(typeof params.brief === "string" && params.brief.trim() ? { brief: params.brief } : {}),
-    }];
-  }
-  const values = denseOwnArrayValues(batched);
-  if (!values || !values.length || values.length > 64) {
-    throw new Error("marks must be a dense array of 1-64 {ids, brief} objects");
-  }
-  return values.map((value, index) => {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error(`marks[${index}] must be an object with ids and an optional brief`);
-    }
-    const brief = ownValue(value, "brief");
-    if (brief !== undefined && (typeof brief !== "string" || !brief.trim())) {
-      throw new Error(`marks[${index}].brief must be a nonempty string`);
-    }
-    return {
-      ids: stringIds(ownValue(value, "ids")),
-      ...(typeof brief === "string" && brief.trim() ? { brief } : {}),
-    };
-  });
-}
-
 export function registerActiveContext(pi: any, options: {
   toolName?: string;
   toolLabel?: string;
@@ -252,6 +232,28 @@ export function registerActiveContext(pi: any, options: {
   blacklistAutoFoldTools?: ReadonlySet<string>;
   providerInputBudget?: number;
   thresholds?: ActiveContextThresholds;
+  /** THE TOOL-CALL DIET's share point (2026-08-24; default 0.50 since 2026-08-28, Shane,
+   *  on the sol-20260826-full2 verdict): tool results in the oldest toolFoldThreshold
+   *  share of the projected window are clipped IN VIEW at each commit, identified head
+   *  kept, full bytes peek-recoverable behind the entry id the marker names. A share in
+   *  [0, 1), where 0 turns the diet off; 0.50 is what every fold repetition from 3 onward
+   *  ran, so the default is the value that was measured rather than the absence of one. */
+  toolFoldThreshold?: number;
+  /** THE INVITATION SWITCH (public since 2026-08-27; DEFAULT FALSE since 2026-08-28,
+   *  Shane, on the sol-20260826-full2 verdict). false is the deterministic shape the
+   *  campaign measured and the one it recommends: no carrier ever invites a brief and
+   *  every fold goes out with the runtime's own words, which drew 14, 14, 9 and 8 correct
+   *  against the invited condition's 3. true restores the standing invitation for the
+   *  agent to improve a brief. Either way the agent verbs stay on the tool, so an agent
+   *  that finds a fold can still annotate what it reads. */
+  postFoldNotice?: boolean;
+  /** THE WORKING MEMORY (Shane, 2026-08-26): a session-scoped ordered dictionary the
+   *  agent maintains beside the fold index. `remember` writes or removes an entry,
+   *  `recall` reads bodies on demand, and the projection carries one table of contents
+   *  that refreshes at each commit. Off when absent: the digest channel earned its
+   *  place in a measured gap (running tallies lost 0/6 against native's 6/6 while the
+   *  index won everything else), and it must stay separable from the index it is not. */
+  workingMemory?: boolean;
 }): {
   projectionCandidates: (ctx: any) => Array<Record<string, unknown>>;
 } {
@@ -260,6 +262,24 @@ export function registerActiveContext(pi: any, options: {
   const brandNoun = options.brandNoun ?? DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN;
   const entryTypePrefix = options.entryTypePrefix ?? DEFAULT_ACTIVE_CONTEXT_ENTRY_TYPE_PREFIX;
   const blacklistAutoFoldTools = options.blacklistAutoFoldTools ?? AUTO_FOLD_BLACKLIST_DEFAULT;
+  if (options.postFoldNotice !== undefined && typeof options.postFoldNotice !== "boolean") {
+    throw new Error("postFoldNotice must be a boolean: true keeps the post-fold invitation " +
+      "notice, false ships every fold with the runtime's deterministic brief and no " +
+      "carrier inviting the agent to improve it");
+  }
+  const postFoldNotice = options.postFoldNotice ?? false;
+  if (options.workingMemory !== undefined && typeof options.workingMemory !== "boolean") {
+    throw new Error("workingMemory must be a boolean: it enables the session-scoped " +
+      "working-memory dictionary and its two actions, remember and recall");
+  }
+  const workingMemory = options.workingMemory === true;
+  const toolFoldThreshold = options.toolFoldThreshold ?? DEFAULT_TOOL_FOLD_THRESHOLD;
+  if (typeof toolFoldThreshold !== "number" || !Number.isFinite(toolFoldThreshold) ||
+      toolFoldThreshold < 0 || toolFoldThreshold >= 1) {
+    throw new Error("toolFoldThreshold must be a share in [0, 1): it names the oldest " +
+      "fraction of the projected window whose tool results are clipped in view at each " +
+      "commit, and 0 turns the diet off");
+  }
   for (const removed of ["foldScheduling", "foldPeekResults", "toolActions"]) {
     if (Object.hasOwn(options, removed)) {
       throw new Error(`${removed} is no longer an option: epoch scheduling, peek foldability ` +
@@ -325,6 +345,7 @@ export function registerActiveContext(pi: any, options: {
   const milestoneProjectionType = `${entryTypePrefix}-milestone`;
   const advisoryProjectionType = `${entryTypePrefix}-advisory`;
   const foldNoticeProjectionType = `${entryTypePrefix}-fold-notice`;
+  const memoryTocProjectionType = `${entryTypePrefix}-memory-toc`;
   const receiptProjectionType = `${entryTypePrefix}-receipts`;
   const curationProjectionType = `${entryTypePrefix}-curation`;
   const entryNamespace = entryTypeNamespace(entryTypePrefix);
@@ -332,7 +353,9 @@ export function registerActiveContext(pi: any, options: {
   const nativeReceiptEntryType = `${entryNamespace}-native-compaction-receipt`;
   const contextEventEntryType = `${entryNamespace}-context-event`;
   const nativeDecisionEntryType = `${entryNamespace}-native-compaction-decision`;
-  const allowedToolActions: readonly ActiveContextToolAction[] = ACTIVE_CONTEXT_TOOL_ACTIONS;
+  const allowedToolActions: readonly ActiveContextToolAction[] = workingMemory
+    ? [...ACTIVE_CONTEXT_TOOL_ACTIONS, ...WORKING_MEMORY_TOOL_ACTIONS]
+    : ACTIVE_CONTEXT_TOOL_ACTIONS;
   const allowedToolActionSet = new Set<string>(allowedToolActions);
 
   type AutomaticFailureState = {
@@ -573,10 +596,9 @@ export function registerActiveContext(pi: any, options: {
   };
 
   const PREFIX_MUTATING_KINDS: ReadonlySet<string> = new Set([
-    "context.commit", "context.fold", "context.absorb", "context.split", "context.recovery",
+    "context.commit", "context.fold", "context.absorb", "context.recovery",
   ]);
   const CACHE_ACTION_REQUEST_CLASS: Readonly<Record<string, string>> = Object.freeze({
-    fold: "after-mark",
     peek: "after-peek",
     expand: "after-expand",
     refold: "after-refold",
@@ -590,8 +612,6 @@ export function registerActiveContext(pi: any, options: {
       folds_committed: receipt.foldsCommitted,
       folds_created: receipt.foldsCreated,
       freed_tokens: receipt.freedTokens,
-      split_folds: receipt.splitFolds,
-      split_from_chars: receipt.splitFromChars,
       absorbed_wedges: receipt.absorbedWedges,
       recovered: receipt.recovered,
       protected_bytes: receipt.protectedBytes,
@@ -897,15 +917,28 @@ export function registerActiveContext(pi: any, options: {
       if (next.folds.length > MAX_ACTIVE_FOLD_RECORDS) {
         throw new Error("Active-context fold closure exceeds persistence limit");
       }
+      // AN ALREADY-DURABLE FOLD NEEDS A DIGEST, NOT A RECORD (2026-08-28). This built the
+      // whole entry for every fold on every persist just to compare one hash and continue:
+      // `makeFoldRecordEntry` canonicalizes, hashes, then `parseFoldRecordEntry` re-validates,
+      // clones the fold again, recomputes `foldIdFor`, hashes a second time and stringifies
+      // for the wire cap. Replaying a real sealed session, 98.2 percent of 4,947 calls hit
+      // the `continue`, and 126 of 135 persists appended nothing while rebuilding all of it.
+      // `foldRecordRef` is the same digest by construction (`makeFoldRecordEntry` stores
+      // `canonicalFoldRecord`, and `stateFromFoldRefs` already matches records to refs on
+      // this equality at persistence.ts:809); gate 152 pins it. Equal digests mean
+      // byte-identical canonical bytes to a record that already passed
+      // `parseFoldRecordEntry`, so skipping the rebuild cannot reach a different verdict.
+      // Measured 85.0ms to 19.6ms at 400 folds.
       for (const fold of next.folds) {
-        const record = makeFoldRecordEntry(fold, sessionId);
-        const existing = persistence.persistedFoldRecords.get(record.foldId);
+        const ref = foldRecordRef(fold);
+        const existing = persistence.persistedFoldRecords.get(ref.id);
         if (existing) {
-          if (existing.recordSha256 !== record.recordSha256) {
-            throw new Error(`Conflicting durable active-context fold ${record.foldId}`);
+          if (existing.recordSha256 !== ref.sha256) {
+            throw new Error(`Conflicting durable active-context fold ${ref.id}`);
           }
           continue;
         }
+        const record = makeFoldRecordEntry(fold, sessionId);
         await pi.appendEntry(foldRecordEntryType, record);
         persistence.persistedFoldRecords.set(record.foldId, record);
         if (!sessionIdentityStillValid(ctx, sessionId, generationAtStart)) {
@@ -914,13 +947,20 @@ export function registerActiveContext(pi: any, options: {
         }
       }
       const wire = persistence.persistedWireVersion === 2 ? makeStateDelta(persistence.persisted, next) : makeStateCheckpoint(next);
-      if (persistence.persistedWireVersion === 2 && persistence.persistedStateSha256 !== semanticStateSha256(persistence.persisted)) {
+      // THE WIRE CARRIES BOTH DIGESTS IT JUST DERIVED (2026-08-28). `makeStateDelta` writes
+      // `baseStateSha256` from `persistence.persisted` and `stateSha256` from `next`, and
+      // nothing mutates either state between that call and here, so re-hashing two whole
+      // states was pure repetition at about 7ms per durable write. The drift check keeps its
+      // teeth: `baseStateSha256` is still derived from `persistence.persisted`, so a
+      // persisted digest that has drifted from the state it claims to describe still raises.
+      // Gate 152 pins both equalities.
+      if (wire.kind === "delta" && persistence.persistedStateSha256 !== wire.baseStateSha256) {
         throw new Error("Active-context durable base digest drift");
       }
       await pi.appendEntry(stateEntryType, wire);
       persistence.persisted = clone(next);
       persistence.persistedWireVersion = 2;
-      persistence.persistedStateSha256 = semanticStateSha256(next);
+      persistence.persistedStateSha256 = wire.stateSha256;
       persistence.state = lifecycle.shuttingDown ? null : clone(next);
       if (!sessionIdentityStillValid(ctx, sessionId, generationAtStart)) {
         if (ctx && !contextSessionMatches(ctx, sessionId)) load(ctx);
@@ -1148,7 +1188,6 @@ export function registerActiveContext(pi: any, options: {
 
   const persistManual = async (
     next: ActiveContextState,
-    action: Exclude<ActiveContextToolAction, "status">,
     ctx: any,
   ): Promise<void> => {
     const stateAtEntry = persistence.state ? clone(persistence.state) : null;
@@ -1393,25 +1432,36 @@ export function registerActiveContext(pi: any, options: {
     };
   };
 
-  const projectedTokenReading = (projected: unknown[]): {
+  // THE SERIALIZATION TRAVELS, THE READING DOES NOT (2026-08-28). Six whole-window
+  // serializations rode every provider request and four were the same string from the same
+  // unmutated array. Only the TEXT is threaded, never a finished reading: each site still
+  // re-reads `measurements.projectionAnchor` and `projectionCharsPerToken()` at its own
+  // time, so every emitted number stays what it was. That matters on the commit path, where
+  // `enforceProjectionBudget` awaits `attemptAutomaticCommit` and an `attributionChanged`
+  // can null the anchor between the last measurement and the read: threading a reading would
+  // freeze `basis` at "measured" where today it flips to "unmeasured". Roughly 50ms per
+  // request at a 467KB window, 100ms at 1MB, all of it blocking main-loop CPU. Honest
+  // framing: six become three, not one.
+  const projectedTokenReading = (projected: unknown[], serialized?: string): {
     tokens: number;
     basis: ProjectionReadingBasis;
     chars: number;
     anchorTokens: number | null;
     deltaChars: number | null;
+    text: string;
   } => {
-    const text = stableStringify(projected);
+    const text = serialized ?? stableStringify(projected);
     const chars = Buffer.byteLength(text, "utf8");
     const charsPerToken = projectionCharsPerToken();
     const estimate = Math.ceil(chars / charsPerToken);
     const anchor = measurements.projectionAnchor;
     if (!anchor || anchor.generation !== lifecycle.generation ||
         anchor.sessionId !== persistence.state?.sessionId) {
-      return { tokens: estimate, basis: "unmeasured", chars, anchorTokens: null, deltaChars: null };
+      return { tokens: estimate, basis: "unmeasured", chars, anchorTokens: null, deltaChars: null, text };
     }
     const separator = text.length > anchor.head.length ? text[anchor.head.length] : "";
     if (!text.startsWith(anchor.head) || (separator !== "," && separator !== "]")) {
-      return { tokens: estimate, basis: "rewritten", chars, anchorTokens: anchor.tokens, deltaChars: null };
+      return { tokens: estimate, basis: "rewritten", chars, anchorTokens: anchor.tokens, deltaChars: null, text };
     }
     const deltaChars = chars - anchor.chars;
     return {
@@ -1420,6 +1470,7 @@ export function registerActiveContext(pi: any, options: {
       chars,
       anchorTokens: anchor.tokens,
       deltaChars,
+      text,
     };
   };
 
@@ -1450,7 +1501,7 @@ export function registerActiveContext(pi: any, options: {
     estimatorErrorShare() * estimate + expectedInflowTokens(),
   ));
 
-  const projectionExceedsBudget = (projected: unknown[], ctx: any): {
+  const projectionExceedsBudget = (projected: unknown[], ctx: any, serialized?: string): {
     tokens: number;
     sizeTokens: number;
     basis: ProjectionReadingBasis;
@@ -1458,12 +1509,13 @@ export function registerActiveContext(pi: any, options: {
     marginTokens: number;
     over: boolean;
     crowded: boolean;
+    text: string;
   } => {
     const capacity = currentCapacity(ctx);
     const budgetTokens = Number.isFinite(capacity.budgetTokens) && capacity.budgetTokens > 0
       ? capacity.budgetTokens
       : Number.POSITIVE_INFINITY;
-    const reading = projectedTokenReading(projected);
+    const reading = projectedTokenReading(projected, serialized);
     const tokens = reading.tokens;
     const sizeTokens = Math.ceil(reading.chars / projectionCharsPerToken());
     const marginTokens = Number.isFinite(budgetTokens)
@@ -1477,6 +1529,7 @@ export function registerActiveContext(pi: any, options: {
       marginTokens,
       over: tokens > budgetTokens,
       crowded: tokens + marginTokens > budgetTokens,
+      text: reading.text,
     };
   };
 
@@ -1626,9 +1679,13 @@ export function registerActiveContext(pi: any, options: {
    * and it does not: the rebuild reads the marks, not its own last text.
    */
   const appendFoldNotice = (projected: unknown[], snapshot: ActiveContextSnapshot): unknown[] => {
+    // The deterministic experiment condition: cuts stage and commits land exactly as
+    // ever, but nothing invites a brief, so briefs stay the runtime's own.
+    if (!postFoldNotice) return projected;
     if (!persistence.state) return projected;
     const held = pendingMarks(persistence.state);
-    const unbriefed = held.filter((mark) => mark.briefProvenance?.kind !== "supplied");
+    const unbriefed = held.filter((mark) =>
+      mark.briefProvenance?.kind !== "supplied" && mark.briefProvenance?.kind !== "augmented");
     // BATCHED, AND APPENDED ONCE. A notice per cut is noise, and noise is how guidance
     // gets ignored; the frontier cuts often and this speaks only when a batch has built
     // up. `carrierAdmitted` is what makes it an APPEND rather than a rewrite: once the
@@ -1649,6 +1706,7 @@ export function registerActiveContext(pi: any, options: {
         id: mark.id,
         kind: mark.kind,
         tokens: estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)),
+        brief: typeof mark.brief === "string" ? mark.brief : undefined,
       })),
       pending: held.length,
       toolName,
@@ -1673,6 +1731,42 @@ export function registerActiveContext(pi: any, options: {
     return projected;
   };
 
+  /**
+   * THE TABLE OF CONTENTS IS ONE COPY PER COMMIT (Shane, 2026-08-26). It is admitted
+   * once per frozen projection, exactly as the fold notice above, and that admission
+   * rule IS the refresh law: between commits the copy stays buried at its index, so a
+   * quiet pass moves no byte and costs no occupancy anchor, and the tool result of every
+   * `remember` carries the live key list in the meantime. A commit rewrites the
+   * projection, the freeze drops, the body filter strips the old copy, and the next pass
+   * seats a fresh one at the tail with the latest keys. Nothing here re-renders in
+   * place, because a carrier that moves on a quiet pass is the exact defect the fold
+   * notice's comment records.
+   */
+  const appendMemoryToc = (projected: unknown[], snapshot: ActiveContextSnapshot): unknown[] => {
+    if (!workingMemory) return projected;
+    if (!persistence.state) return projected;
+    const held = persistence.state.memory ?? [];
+    if (!held.length) return projected;
+    if (!carrierAdmitted("memory-toc")) return projected;
+    const entries = [...held].sort((left, right) => right.ordinal - left.ordinal);
+    const text = memoryTocText({
+      entries: entries.map((entry) => ({ key: entry.key, chars: entry.body.length })),
+      toolName,
+      brandNoun,
+    });
+    projected.push({
+      role: "custom",
+      customType: memoryTocProjectionType,
+      content: text,
+      display: false,
+      details: { source: activeContextSource(entryTypePrefix), ephemeral: true },
+      timestamp: typeof ownValue(snapshot.messages.at(-1), "timestamp") === "number"
+        ? ownValue(snapshot.messages.at(-1), "timestamp")
+        : 0,
+    });
+    return projected;
+  };
+
   const enforceBandTop = async (
     snapshot: ActiveContextSnapshot,
     ctx: any,
@@ -1711,10 +1805,10 @@ export function registerActiveContext(pi: any, options: {
     snapshot: ActiveContextSnapshot,
     projected: unknown[],
     ctx: any,
-  ): Promise<{ projected: unknown[]; aborted: boolean }> => {
+  ): Promise<{ projected: unknown[]; aborted: boolean; text: string }> => {
     let measured = projectionExceedsBudget(projected, ctx);
     const rejected = curation.pendingRejection !== null;
-    if (!measured.crowded && !rejected) return { projected, aborted: false };
+    if (!measured.crowded && !rejected) return { projected, aborted: false, text: measured.text };
     const trigger = measured;
     let reduced = projected;
     let attempts = 0;
@@ -1818,9 +1912,11 @@ export function registerActiveContext(pi: any, options: {
       }));
       curation.pendingRejection = null;
     }
-    if (!measured.over) return { projected: reduced, aborted: false };
+    // `measured` is recomputed on `reduced` at every turn of the loop above, so its text is
+    // the serialization of the array both of these exits return.
+    if (!measured.over) return { projected: reduced, aborted: false, text: measured.text };
     abortOverBudgetProjection(measured.tokens, measured.budgetTokens, ctx, attempts);
-    return { projected: reduced, aborted: true };
+    return { projected: reduced, aborted: true, text: measured.text };
   };
 
   const startPreparation = (snapshot: ActiveContextSnapshot, ratio: number | null, ctx: any): void => {
@@ -1975,7 +2071,7 @@ export function registerActiveContext(pi: any, options: {
       const customType = ownValue(message, "customType");
       return customType !== milestoneProjectionType && customType !== advisoryProjectionType &&
         customType !== receiptProjectionType && customType !== curationProjectionType &&
-        customType !== foldNoticeProjectionType;
+        customType !== foldNoticeProjectionType && customType !== memoryTocProjectionType;
     });
     const withdrawn = withdrawConsumedEphemeralPeeks(body);
     if (withdrawn.size && freeze.body) {
@@ -1984,25 +2080,35 @@ export function registerActiveContext(pi: any, options: {
       if (freeze.projection) carryWithdrawalIntoFreeze(freeze.projection, withdrawn);
     }
     const held = freeze.body?.length ?? 0;
-    freeze.active = freeze.projection !== null && body.length >= held &&
-      stableStringify(body.slice(0, held)) === freeze.bodyText;
+    // THE PREFIX IS READ OUT OF THE WHOLE SERIALIZATION (2026-08-28). This asked
+    // `stableStringify(body.slice(0, held)) === freeze.bodyText`, and in steady state `held`
+    // is `body.length` minus the couple of messages that just arrived, so it was a second
+    // full serialization of the window plus a slice allocation, beside the one below that
+    // every pass does anyway. `serializedPrefixHolds` carries why that is sound; a false
+    // POSITIVE here splices the previous pass's `freeze.projection` in front of the new tail
+    // and emits stale messages, which is a content bug rather than a slowdown, and gate 154
+    // drives the predicate itself rather than restating it.
+    const bodyText = stableStringify(body);
+    freeze.active = freeze.projection !== null &&
+      serializedPrefixHolds(bodyText, freeze.bodyText, held, body.length);
     const projected = freeze.active
       ? [...freeze.projection!, ...body.slice(held)]
       : [...body];
     if (!freeze.active) freeze.keys.clear();
     freeze.body = body;
-    freeze.bodyText = stableStringify(body);
+    freeze.bodyText = bodyText;
     appendReceipts(projected, snapshot);
     appendFoldNotice(projected, snapshot);
+    appendMemoryToc(projected, snapshot);
     return holdFrozen(projected);
   };
-  const noteProjection = (projected: unknown[]): void => {
+  const noteProjection = (projected: unknown[], serialized?: string): void => {
     const digests = messageDigests(projected);
     const comparison = compareProjections(instrumentation.previousDigests, digests);
     recordProjection(instrumentation.ledger, comparison, digests);
     instrumentation.previousDigests = digests;
     instrumentation.lastChange = comparison.change;
-    const text = stableStringify(projected);
+    const text = serialized ?? stableStringify(projected);
     const divergence = prefixDivergence(instrumentation.previousText, text);
     const previousChars = instrumentation.previousText?.length ?? 0;
     instrumentation.lastPreservedShare = previousChars > 0
@@ -2030,7 +2136,7 @@ export function registerActiveContext(pi: any, options: {
           : latestCacheActionClass
             ? latestCacheActionClass
             : divergence.index === null ? "steady-state" : "after-message";
-    const reading = projectedTokenReading(projected);
+    const reading = projectedTokenReading(projected, text);
     emit("context.projection", {
       change: comparison.change,
       previous_count: comparison.previousCount,
@@ -2076,6 +2182,7 @@ export function registerActiveContext(pi: any, options: {
     snapshot: ActiveContextSnapshot;
     candidate: FoldCandidate;
     brief?: string;
+    briefProvenance?: "supplied" | "deterministic" | BriefProvenance;
     ctx: any;
     signal?: AbortSignal;
     maximumSourceChars?: number;
@@ -2093,6 +2200,7 @@ export function registerActiveContext(pi: any, options: {
       state: baseState,
       generation: generationAtStart,
       brief: input.brief,
+      briefProvenance: input.briefProvenance,
       ctx: input.ctx,
       signal: input.signal,
     });
@@ -2226,6 +2334,10 @@ export function registerActiveContext(pi: any, options: {
     });
     state = wedges.state;
     const accounting = markAccounting(snapshot, state);
+    // Derived ONCE, here, against the pre-commit state both readers below report against.
+    // It left `MarkAccounting` because it serializes the whole marked tail and every other
+    // caller of `markAccounting` was paying for a number only this path reads.
+    const rewriteTokens = markRewriteTokens(snapshot, state);
     if (!accounting.pending) {
       const remainder = unmarkedRemainder(snapshot, state, projectionCharsPerToken());
       emit("context.commit", {
@@ -2328,6 +2440,24 @@ export function registerActiveContext(pi: any, options: {
           !closed.applied.some((appliedMark) => appliedMark.id === mark.id)), ...closed.retained],
       };
     }
+    // THE TOOL-CALL DIET RIDES THE SAME TRANSACTION (2026-08-24): clips are selected
+    // against the post-fold state and land in the same revision the commit minted, so
+    // the one paid rewrite carries both and no non-commit pass ever moves a byte. The
+    // full bytes stay in the transcript behind each clip's entry id.
+    let clippedResults = 0;
+    if (toolFoldThreshold > 0) {
+      const clipAdditions = toolClipAdditions({
+        snapshot,
+        state: result.state,
+        threshold: toolFoldThreshold,
+        blacklist: blacklistAutoFoldTools,
+      });
+      if (clipAdditions.length) {
+        clippedResults = clipAdditions.length;
+        result = { ...result, state: { ...result.state,
+          clips: [...(result.state.clips ?? []), ...clipAdditions] } };
+      }
+    }
     persistence.state = result.state;
     const bytesAfter = bytes(projectActiveContext(snapshot, persistence.state));
     const freedBytes = Math.max(0, bytesBefore - bytesAfter);
@@ -2362,9 +2492,10 @@ export function registerActiveContext(pi: any, options: {
       consolidation_marks: consolidationAdded,
       closing_consolidation_marks: closingAdded,
       absorbed_wedges: wedges.absorbed.length,
+      clipped_results: clippedResults,
       freed_bytes: freedBytes,
       freed_tokens: estimatedTokens(freedBytes),
-      rewrite_tokens: accounting.rewriteTokens,
+      rewrite_tokens: rewriteTokens,
       pinned_bytes: accounting.pinnedBytes,
       pinned_results: accounting.pinnedResults,
       protected_stale_bytes: pinHeld.bytes,
@@ -2436,7 +2567,7 @@ export function registerActiveContext(pi: any, options: {
       protectedStaleRefs: pinHeld.refs,
       retainedMarks: result.retained.length,
       eligibleMarks: accounting.eligibleMarks,
-      estimatedRewriteTokens: accounting.rewriteTokens,
+      estimatedRewriteTokens: rewriteTokens,
       estimatedFreedTokens: accounting.freedTokens,
       freedBudgetShare: accounting.freedBudgetShare,
       sourceBytesSaved: freedBytes,
@@ -2486,8 +2617,6 @@ export function registerActiveContext(pi: any, options: {
       occupancyAfter: occupancyBefore === null ? null : Math.max(0, occupancyBefore - freedTokens),
       spansFolded: epoch ? Number(epoch.foldedSpans ?? 0) : foldIds,
       toolResultsFolded: epoch ? Number(epoch.foldedToolResults ?? 0) : 0,
-      splitFolds: Number(action.splitFolds ?? 0),
-      splitFromChars: Number(action.splitFromChars ?? 0),
       absorbedWedges: Number(epoch?.absorbedWedges ?? 0),
       recovered: curation.recoveryAttempts > 0,
       protectedBytes: Number(epoch?.protectedStaleBytes ?? 0),
@@ -2785,7 +2914,7 @@ export function registerActiveContext(pi: any, options: {
       }
       const budgeted = await enforceProjectionBudget(snapshot, projected, ctx);
       projected = budgeted.projected;
-      const reading = projectedTokenReading(projected);
+      const reading = projectedTokenReading(projected, budgeted.text);
       measurements.lastProjectedChars = reading.chars;
       measurements.lastProjectedEstimate = reading.tokens;
       measurements.lastProjectedEstimateBasis = reading.basis;
@@ -2795,7 +2924,7 @@ export function registerActiveContext(pi: any, options: {
         updateStatus(ctx);
         return { messages: projected };
       }
-      noteProjection(projected);
+      noteProjection(projected, budgeted.text);
       updateStatus(ctx);
       return { messages: projected };
     } catch (error) {
@@ -3255,15 +3384,6 @@ export function registerActiveContext(pi: any, options: {
     );
   };
 
-  /**
-   * THE ONE STAGING PATH FOR FOLD MARKS (2026-08-23). The tool's fold action and the
-   * /fold-editor's user marks run THIS code and nothing else: span snapping, claim
-   * refusal, brief contract, prepareFold, replacement of a standing mark over the
-   * same span. Only the ORIGIN differs -- "agent" for the model, "user" for a human
-   * laying marks in the editor -- and origin changes nothing mechanical: a user mark
-   * counts toward the commit's coverage, answers with its commit arithmetic, and
-   * folds at the epoch exactly as an agent mark does.
-   */
   /**
    * THE WITHDRAWAL PATH, shared by the tool's unmark action and the editor's
    * withdraw intent: same refusal for an unknown id, same persist, same status.
@@ -3275,7 +3395,7 @@ export function registerActiveContext(pi: any, options: {
     const removed = before.filter((mark) => requested.has(mark.id));
     const unknown = ids.filter((id) => !before.some((mark) => mark.id === id));
     if (unknown.length) throw new Error(`No pending mark named ${unknown.join(", ")}`);
-    await persistManual(withPendingMarks(persistence.state!, kept), "unmark", ctx);
+    await persistManual(withPendingMarks(persistence.state!, kept), ctx);
     updateStatus(ctx);
     return removed as Array<Record<string, unknown>>;
   };
@@ -3305,7 +3425,7 @@ export function registerActiveContext(pi: any, options: {
           "folding keeps entries exactly recoverable without pinning them.");
       }
     }
-    await persistManual(nextProtection, pin ? "pin" : "unpin", ctx);
+    await persistManual(nextProtection, ctx);
     emit("context.pin", {
       pin,
       ids: ids.join(","),
@@ -3316,140 +3436,140 @@ export function registerActiveContext(pi: any, options: {
     updateStatus(ctx);
   };
 
-  const stageFoldMarks = async (
-    requests: BatchedMarkRequest[],
-    origin: MarkOrigin,
+  /**
+   * THE ONE STAGING PATH FOR FOLD MARKS (2026-08-23). The /fold-editor's user marks
+   * run THIS code and nothing else: span snapping, claim refusal, brief contract,
+   * prepareFold, replacement of a standing mark over the same span. A user mark is
+   * mechanically an ordinary mark: it counts toward the commit's coverage, answers
+   * with its commit arithmetic, and folds at the epoch exactly as a runtime mark does.
+   */
+  const stageFoldMark = async (
+    ids: string[],
+    supplied: string | undefined,
     signal: AbortSignal,
     ctx: any,
     snapshot: ActiveContextSnapshot,
-  ): Promise<{ marks: Array<Record<string, unknown>>; corrections: SpanCorrection[]; staged: ActiveContextState }> => {
-      const resolved: Array<{
-        candidate: FoldCandidate;
-        brief?: string;
-        corrections: SpanCorrection[];
-        splitFrom: number;
-      }> = [];
-      for (const request of requests) {
-        const snapped = snapFoldCandidate(snapshot, persistence.state, request.ids, { allowProtected: true });
-        // AN AGENT'S SPAN IS TAKEN WHOLE (Shane, 2026-08-22). The bite-size cap was
-        // applied to manual marks too, and it was the only caller: the ladder never
-        // splits, because `selectAutomaticChapter` stops accumulating at the cap on its
-        // own. So the split existed solely to second-guess the one judgement the design
-        // wants to encourage, and it charged for it twice. One intended fold became five
-        // or ten placeholders, and every piece was handed the SAME brief, so each one
-        // claimed to describe a span it held a fraction of, while the correction text
-        // said "each with its own brief", which was never true.
-        //
-        // The cap stays for the ladder, where it was earned (2026-08-06 rep 6: one
-        // 60,432-byte chapter hid the fact the run needed). The difference is who chose
-        // the boundary. A ladder fold is a span nobody vouched for, so it is kept small
-        // enough to read back cheaply. An agent fold is a span the agent cut and wrote a
-        // brief for, and it stays navigable by a route that did not exist in 2026-08:
-        // peek takes offset and bytes, states the omitted middle, and reads any child id,
-        // so a large fold has a narrow read. An expand that will not fit is refused with
-        // a peek offered instead, so size costs a refusal rather than a window.
-        resolved.push({
-          candidate: snapped.candidate,
-          brief: request.brief,
-          corrections: snapped.corrections,
-          splitFrom: 0,
-        });
-      }
-      const corrections = resolved.flatMap((item) => item.corrections);
-      const marks: Array<Record<string, unknown>> = [];
-      let staged = persistence.state!;
-      for (const item of resolved) {
-        const { candidate } = item;
-        const alreadyPrepared = staged.folds.some((fold) =>
-          fold.id === foldIdFor(candidate.kind, candidate.parts));
-        const deferred = refsProtected(candidate.sourceRefs, staged, snapshot) ||
-          (candidate.kind === "tool-result" &&
-            refsProtected(candidate.sourceRefs, staged, snapshot));
-        // A MARK IS EDITABLE UNTIL IT COMMITS (Shane, 2026-08-21). Marking a span you
-        // already marked REPLACES the mark, so a brief written in haste is corrected by
-        // writing it again: the span is identical, the id derives from the span, and no
-        // byte has moved yet, so the correction costs nothing at all. After the commit
-        // the fold is standing and there is no rewrite verb, because rewriting a
-        // standing brief rewrites the projection at its placeholder; `reboundary`
-        // re-cuts the span instead, which was going to rewrite anyway.
-        const replacing = foldIdFor(candidate.kind, candidate.parts);
-        const claimed = markClaimingRef(staged, candidate.sourceRefs);
-        if (claimed && claimed.markId !== replacing) {
-          marks.push({
-            id: replacing,
-            kind: candidate.kind,
-            ok: false,
-            deferred: false,
-            reason: `Evidence ${claimed.entryId} is already held by pending mark ${claimed.markId}, ` +
-              `which folds at the next commit. Unmark ${claimed.markId} first if you want to ` +
-              "mark this span differently.",
-          });
-          continue;
-        }
-        const suppliedComplaint = item.brief === undefined
-          ? null
-          : briefContractComplaint(item.brief.trim(), snapshot.policy.maxBriefChars, snapshot.toolName);
-        if (suppliedComplaint !== null) {
-          marks.push({
-            id: foldIdFor(candidate.kind, candidate.parts),
-            kind: candidate.kind,
-            ok: false,
-            deferred: false,
-            reason: `Supplied brief rejected. ${suppliedComplaint}`,
-          });
-          continue;
-        }
-        const briefed = !deferred && !alreadyPrepared
-          ? await prepareFold({
-            candidate,
-            snapshot,
-            state: staged,
-            generation: lifecycle.generation,
-            brief: item.brief,
-            ctx,
-            signal,
-          })
-          : null;
-        const mark = foldMarkFor({
-          candidate,
-          brief: briefed?.fold.brief ?? item.brief ?? ladderBrief(snapshot, staged, candidate),
-          briefProvenance: briefed?.fold.provenance ??
-            (item.brief ? { kind: "supplied" } : { kind: "deterministic" }),
-          origin,
-          ordinal: markOrdinal(snapshot),
-        });
-        // Drop the standing mark over this exact span before adding, so a re-mark is a
-        // replacement rather than a duplicate refusal. `claimed` is this same mark by the
-        // check above, and the id is derived from the span, so the state after is the
-        // state a first mark with the new brief would have produced.
-        const replaced = claimed !== null;
-        if (replaced) {
-          staged = withPendingMarks(staged,
-            pendingMarks(staged).filter((standing) => standing.id !== replacing));
-        }
-        const addition = addPendingMark(staged, mark);
-        if (!addition.added) {
-          marks.push({ id: mark.id, kind: mark.kind, ok: false, deferred: false, reason: addition.reason });
-          continue;
-        }
-        staged = addition.state;
-        marks.push({
-          id: mark.id,
-          kind: mark.kind,
-          ok: true,
-          deferred,
-          ...(replaced ? { replaced: true } : {}),
-          ...(deferred
-            ? {
-              scheduled: "the span is still in the fresh window; this mark is held and folds at the " +
-                "first commit after it ages out",
-            }
-            : {}),
-          brief: mark.brief,
-          provenance: normalizeLegacyProvenance(mark.briefProvenance),
-        });
-      }
-      return { marks, corrections, staged };
+  ): Promise<{ mark: Record<string, unknown>; corrections: SpanCorrection[]; staged: ActiveContextState }> => {
+    const snapped = snapFoldCandidate(snapshot, persistence.state, ids, { allowProtected: true });
+    // AN AGENT'S SPAN IS TAKEN WHOLE (Shane, 2026-08-22). The bite-size cap was
+    // applied to manual marks too, and it was the only caller: the ladder never
+    // splits, because `selectAutomaticChapter` stops accumulating at the cap on its
+    // own. So the split existed solely to second-guess the one judgement the design
+    // wants to encourage, and it charged for it twice. One intended fold became five
+    // or ten placeholders, and every piece was handed the SAME brief, so each one
+    // claimed to describe a span it held a fraction of, while the correction text
+    // said "each with its own brief", which was never true.
+    //
+    // The cap stays for the ladder, where it was earned (2026-08-06 rep 6: one
+    // 60,432-byte chapter hid the fact the run needed). The difference is who chose
+    // the boundary. A ladder fold is a span nobody vouched for, so it is kept small
+    // enough to read back cheaply. An agent fold is a span the agent cut and wrote a
+    // brief for, and it stays navigable by a route that did not exist in 2026-08:
+    // peek takes offset and bytes, states the omitted middle, and reads any child id,
+    // so a large fold has a narrow read. An expand that will not fit is refused with
+    // a peek offered instead, so size costs a refusal rather than a window.
+    const candidate = snapped.candidate;
+    const corrections = snapped.corrections;
+    let staged = persistence.state!;
+    const alreadyPrepared = staged.folds.some((fold) =>
+      fold.id === foldIdFor(candidate.kind, candidate.parts));
+    const deferred = refsProtected(candidate.sourceRefs, staged, snapshot);
+    // A MARK IS EDITABLE UNTIL IT COMMITS (Shane, 2026-08-21). Marking a span you
+    // already marked REPLACES the mark, so a brief written in haste is corrected by
+    // writing it again: the span is identical, the id derives from the span, and no
+    // byte has moved yet, so the correction costs nothing at all. After the commit
+    // the fold is standing and there is no rewrite verb, because rewriting a
+    // standing brief rewrites the projection at its placeholder; `reboundary`
+    // re-cuts the span instead, which was going to rewrite anyway.
+    const replacing = foldIdFor(candidate.kind, candidate.parts);
+    const claimed = markClaimingRef(staged, candidate.sourceRefs);
+    if (claimed && claimed.markId !== replacing) {
+      return {
+        mark: {
+          id: replacing,
+          kind: candidate.kind,
+          ok: false,
+          deferred: false,
+          reason: `Evidence ${claimed.entryId} is already held by pending mark ${claimed.markId}, ` +
+            `which folds at the next commit. Unmark ${claimed.markId} first if you want to ` +
+            "mark this span differently.",
+        },
+        corrections,
+        staged,
+      };
+    }
+    const suppliedComplaint = supplied === undefined
+      ? null
+      : briefContractComplaint(supplied.trim(), snapshot.policy.agentBriefReserve, snapshot.toolName);
+    if (suppliedComplaint !== null) {
+      return {
+        mark: {
+          id: replacing,
+          kind: candidate.kind,
+          ok: false,
+          deferred: false,
+          reason: `Supplied brief rejected. ${suppliedComplaint}`,
+        },
+        corrections,
+        staged,
+      };
+    }
+    const briefed = !deferred && !alreadyPrepared
+      ? await prepareFold({
+        candidate,
+        snapshot,
+        state: staged,
+        generation: lifecycle.generation,
+        brief: supplied,
+        ctx,
+        signal,
+      })
+      : null;
+    const mark = foldMarkFor({
+      candidate,
+      brief: briefed?.fold.brief ?? supplied ?? ladderBrief(snapshot, staged, candidate),
+      briefProvenance: briefed?.fold.provenance ??
+        (supplied ? { kind: "supplied" } : { kind: "deterministic" }),
+      origin: "user",
+      ordinal: markOrdinal(snapshot),
+    });
+    // Drop the standing mark over this exact span before adding, so a re-mark is a
+    // replacement rather than a duplicate refusal. `claimed` is this same mark by the
+    // check above, and the id is derived from the span, so the state after is the
+    // state a first mark with the new brief would have produced.
+    const replaced = claimed !== null;
+    if (replaced) {
+      staged = withPendingMarks(staged,
+        pendingMarks(staged).filter((standing) => standing.id !== replacing));
+    }
+    const addition = addPendingMark(staged, mark);
+    if (!addition.added) {
+      return {
+        mark: { id: mark.id, kind: mark.kind, ok: false, deferred: false, reason: addition.reason },
+        corrections,
+        staged,
+      };
+    }
+    staged = addition.state;
+    return {
+      mark: {
+        id: mark.id,
+        kind: mark.kind,
+        ok: true,
+        deferred,
+        ...(replaced ? { replaced: true } : {}),
+        ...(deferred
+          ? {
+            scheduled: "the span is still in the fresh window; this mark is held and folds at the " +
+              "first commit after it ages out",
+          }
+          : {}),
+        brief: mark.brief,
+        provenance: normalizeLegacyProvenance(mark.briefProvenance),
+      },
+      corrections,
+      staged,
+    };
   };
 
   const executeAction = async (
@@ -3584,7 +3704,8 @@ export function registerActiveContext(pi: any, options: {
             id: mark.id,
             kind: mark.kind,
             tokens: estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)),
-            briefed: mark.briefProvenance?.kind === "supplied",
+            briefed: mark.briefProvenance?.kind === "supplied" ||
+              mark.briefProvenance?.kind === "augmented",
             brief: mark.brief ?? null,
             briefProvenance: mark.briefProvenance ? clone(mark.briefProvenance) : null,
           })),
@@ -3631,7 +3752,41 @@ export function registerActiveContext(pi: any, options: {
         "bytes",
       );
       const target = persistence.state.folds.find((item) => item.id === id);
-      if (!target) throw new Error(`Unknown active-context fold ${id}`);
+      // A CLIPPED RESULT ANSWERS TO ITS ENTRY ID (2026-08-24, the tool-call diet): the
+      // clip marker names the entry, and the full bytes are in the transcript rather
+      // than behind a fold, so the read serves them from the mapped message directly,
+      // through the same admission fence and the same slice bounds as a fold peek.
+      if (!target) {
+        const clip = (persistence.state.clips ?? []).find((item) =>
+          item.entryId === id || item.callId === id);
+        if (clip) {
+          const mapped = snapshot.mapped.find((item) => item.ref?.entryId === clip.entryId);
+          if (!mapped) throw new Error(`Clipped result ${id} is no longer on this branch`);
+          const full = contentText(snapshot.messages[mapped.index]);
+          admit({
+            action: "peek",
+            ctx,
+            foldId: clip.entryId,
+            requestedBytes: Math.max(0, Math.min(sliceBytes, full.length - offset)),
+            children: [],
+          });
+          const slice = full.slice(offset, offset + sliceBytes);
+          return toolPayload({
+            id: clip.entryId,
+            source: slice,
+            truncated: offset + slice.length < full.length,
+            sourceChars: full.length,
+            offset,
+            ...(peekIsEphemeral(params) ? {
+              ephemeral: "this result rides your context exactly until your next message; " +
+                "extract what your current task needs into that reply, which takes over its " +
+                "place. Peeking again is lossless and cheap; pass ephemeral false when you " +
+                "need these bytes standing for several turns",
+            } : { durable: "this result stays in your context like any other tool result" }),
+          });
+        }
+        throw new Error(`Unknown active-context fold ${id}`);
+      }
       admit({
         action: "peek",
         ctx,
@@ -3690,7 +3845,12 @@ export function registerActiveContext(pi: any, options: {
         for (const part of [recut]) {
           const durable = persistence.persistedFoldRecords.get(foldIdFor(part.kind, part.parts));
           const { preparedFold, nextState } = await prepareAndCommitExplicit({
-            snapshot, candidate: part, brief: durable ? durable.fold.brief : supplied, ctx, signal,
+            // A re-cut carries the durable fold's OWN brief and provenance: those words
+            // were validated when they were first accepted, and re-judging them as a
+            // fresh agent submission would refuse a deterministic or composed brief
+            // against the agent's reserve.
+            snapshot, candidate: part, brief: durable ? durable.fold.brief : supplied,
+            briefProvenance: durable ? durable.fold.provenance : undefined, ctx, signal,
           });
           persistence.state = nextState;
           if (durable && supplied) correctedBriefs[preparedFold.id] = supplied;
@@ -3706,7 +3866,7 @@ export function registerActiveContext(pi: any, options: {
             briefs: { ...(persistence.state.briefs ?? {}), ...correctedBriefs },
           };
         }
-        await persistManual(persistence.state, action, ctx);
+        await persistManual(persistence.state, ctx);
         updateStatus(ctx);
         return toolPayload({
           version: 1,
@@ -3744,7 +3904,7 @@ export function registerActiveContext(pi: any, options: {
       if (!Object.keys(briefs).length) delete next.briefs;
       const leases = { ...next.leases };
       delete leases[id];
-      await persistManual({ ...next, leases }, action, ctx);
+      await persistManual({ ...next, leases }, ctx);
       updateStatus(ctx);
       return toolPayload({
         version: 1,
@@ -3790,11 +3950,7 @@ export function registerActiveContext(pi: any, options: {
         delete leases[id];
         next = { ...next, leases };
       }
-      await persistManual(
-        next,
-        action,
-        ctx,
-      );
+      await persistManual(next, ctx);
       updateStatus(ctx);
       return toolPayload({
         version: 1,
@@ -3890,7 +4046,7 @@ export function registerActiveContext(pi: any, options: {
         );
       }
       const text = String(params.brief ?? "").trim();
-      const complaint = briefContractComplaint(text, snapshot.policy.maxBriefChars, snapshot.toolName);
+      const complaint = briefContractComplaint(text, snapshot.policy.agentBriefReserve, snapshot.toolName);
       if (complaint !== null) throw new Error(`Supplied brief rejected. ${complaint}`);
       const nextState = {
         ...persistence.state!,
@@ -3900,7 +4056,7 @@ export function registerActiveContext(pi: any, options: {
           : mark),
       };
       persistence.state = nextState;
-      await persistManual(nextState, action, ctx);
+      await persistManual(nextState, ctx);
       updateStatus(ctx);
       emit("context.brief", { id, chars: text.length, origin: "agent" });
       const accounting = markAccounting(snapshot, persistence.state!);
@@ -3916,7 +4072,8 @@ export function registerActiveContext(pi: any, options: {
         durableRevision: persistence.state!.revision,
         pendingMarks: accounting.pending,
         unbriefed: pendingMarks(persistence.state!)
-          .filter((mark) => mark.briefProvenance?.kind !== "supplied").map((mark) => mark.id),
+          .filter((mark) => mark.briefProvenance?.kind !== "supplied" &&
+            mark.briefProvenance?.kind !== "augmented").map((mark) => mark.id),
         unmarkedSpans: remainder.spans,
         unmarkedTokens: remainder.tokens,
         activation: "durable immediately, and it costs your window nothing: this fold is " +
@@ -3924,14 +4081,104 @@ export function registerActiveContext(pi: any, options: {
           "reaches it only when the commit folds this span. Nothing in your context moved.",
       });
     }
+    if (action === "remember") {
+      // THE DIGEST'S OWN CHANNEL. A working-memory write is durable state outside the
+      // projection, so like `brief` it moves no bytes and costs no prefix cache: the
+      // table of contents the projection carries refreshes at the next commit, and this
+      // result carries the live key list in the meantime.
+      const key = String(params.key ?? "").trim();
+      if (!key) throw new Error("remember needs a key");
+      if (key.length > MEMORY_KEY_CHARS) {
+        throw new Error(`Working-memory keys have a hard ${MEMORY_KEY_CHARS}-character ` +
+          "maximum: the key is a table-of-contents line, not the note. Put the detail " +
+          "in the body.");
+      }
+      const body = String(params.body ?? "").trim();
+      if (body.length > MEMORY_BODY_CHARS) {
+        throw new Error(`Working-memory bodies have a hard ${MEMORY_BODY_CHARS}-character ` +
+          `maximum and this one is ${body.length}. Split the entry, or keep the part ` +
+          "that changes and let the transcript carry the rest: folded material stays " +
+          "losslessly recoverable by peek.");
+      }
+      const held = persistence.state!.memory ?? [];
+      const existing = held.find((entry) => entry.key === key);
+      let nextMemory: WorkingMemoryEntry[];
+      if (!body) {
+        if (!existing) {
+          throw new Error(`No working-memory entry '${key}' to remove. ${held.length
+            ? `The keys are: ${held.map((entry) => entry.key).join(", ")}.`
+            : "Working memory is empty."}`);
+        }
+        nextMemory = held.filter((entry) => entry.key !== key);
+      } else {
+        if (!existing && held.length >= MEMORY_KEYS_MAX) {
+          throw new Error(`Working memory holds its maximum of ${MEMORY_KEYS_MAX} ` +
+            "entries. Merge two entries, or remove one whose facts no longer matter " +
+            `(${toolName} {"action":"remember","key":"<key>","body":""}), then write ` +
+            "this one.");
+        }
+        const ordinal = held.reduce((max, entry) => Math.max(max, entry.ordinal), 0) + 1;
+        nextMemory = existing
+          ? held.map((entry) => entry.key === key ? { key, body, ordinal } : entry)
+          : [...held, { key, body, ordinal }];
+      }
+      const nextState = {
+        ...persistence.state!,
+        revision: persistence.state!.revision + 1,
+        ...(nextMemory.length ? { memory: nextMemory } : {}),
+      };
+      if (!nextMemory.length) delete (nextState as Partial<ActiveContextState>).memory;
+      persistence.state = nextState;
+      await persistManual(nextState, ctx);
+      updateStatus(ctx);
+      const toc = [...nextMemory].sort((left, right) => right.ordinal - left.ordinal)
+        .map((entry) => ({ key: entry.key, chars: entry.body.length }));
+      return toolPayload({
+        version: 1,
+        action,
+        key,
+        ...(body ? { chars: body.length } : { removed: true }),
+        argumentsSha256: executionArgumentsSha256,
+        durableRevision: persistence.state!.revision,
+        entries: toc,
+        activation: body
+          ? "durable immediately, and it costs your window nothing: the body lives in " +
+            "state, this list is the live view, and the table of contents in your " +
+            "context refreshes at the next commit."
+          : "removed. The table of contents in your context refreshes at the next commit.",
+      });
+    }
+    if (action === "recall") {
+      const held = persistence.state!.memory ?? [];
+      if (!held.length) {
+        throw new Error(`Working memory is empty. Write an entry with ${toolName} ` +
+          '{"action":"remember","key":"<key>","body":"..."}.');
+      }
+      const requested = params.keys === undefined && params.key === undefined
+        ? null
+        : (denseOwnArrayValues(params.keys) ?? [params.key ?? params.keys])
+          .map((value) => String(value ?? "").trim()).filter(Boolean);
+      const entries = [...held].sort((left, right) => right.ordinal - left.ordinal);
+      const chosen = requested === null
+        ? entries
+        : entries.filter((entry) => requested.includes(entry.key));
+      if (requested !== null) {
+        const missing = requested.filter((key) => !held.some((entry) => entry.key === key));
+        if (missing.length) {
+          throw new Error(`No working-memory entr${missing.length === 1 ? "y" : "ies"} ` +
+            `${missing.join(", ")}. The keys are: ` +
+            `${entries.map((entry) => entry.key).join(", ")}.`);
+        }
+      }
+      return toolPayload({
+        version: 1,
+        action,
+        argumentsSha256: executionArgumentsSha256,
+        entries: chosen.map((entry) => ({ key: entry.key, chars: entry.body.length, body: entry.body })),
+      });
+    }
     throw new Error(`Unknown ${toolName} action '${action}'`);
   };
-  const requestedMarkCount = (params: Record<string, unknown>): number => {
-    const batched = denseOwnArrayValues(params?.marks);
-    if (batched) return batched.length;
-    return params?.ids === undefined && params?.id === undefined ? 0 : 1;
-  };
-
   const toolHandler = async (
     toolCallId: string,
     params: Record<string, unknown>,
@@ -3948,7 +4195,6 @@ export function registerActiveContext(pi: any, options: {
           ok,
           error,
           tool_call_id: toolCallId,
-          marks_requested: requestedMarkCount(params),
           corrections_applied: corrections.length,
           arguments_sha256: sha256Value(params ?? {}),
           ...(action === "peek" ? { ephemeral: peekIsEphemeral(params) } : {}),
@@ -4234,20 +4480,13 @@ export function registerActiveContext(pi: any, options: {
       onStageMark: async (fromId: string, toId: string, brief?: string): Promise<void> => {
         await runQueued(async () => {
           const fresh = authoritativeSnapshotFor(ctx);
-          const request = brief && brief.trim()
-            ? { ids: [fromId, toId], brief: brief.trim() }
-            : { ids: [fromId, toId] };
-          const { marks, staged } = await stageFoldMarks(
-            batchedMarkRequests(request), "user",
+          const { mark, staged } = await stageFoldMark(
+            [fromId, toId], brief && brief.trim() ? brief.trim() : undefined,
             new AbortController().signal, ctx, fresh);
-          // Refuse BEFORE persisting: an all-refused batch leaves state untouched and
+          // Refuse BEFORE persisting: a refused mark leaves state untouched and
           // persisting it would be a no-op write against the same-state projection.
-          if (!marks.some((mark) => mark.ok === true)) {
-            const reason = marks.map((mark) => mark.reason).filter(Boolean).join("; ") ||
-              "the span was refused";
-            throw new Error(reason);
-          }
-          await persistManual(staged, "fold", ctx);
+          if (mark.ok !== true) throw new Error(String(mark.reason ?? "the span was refused"));
+          await persistManual(staged, ctx);
           updateStatus(ctx);
         });
         safeNotify(ctx, "Staged user mark(s); they apply at the next commit epoch.", "info");
@@ -4291,7 +4530,7 @@ export function registerActiveContext(pi: any, options: {
     label: toolLabel,
     allowedActions: allowedToolActions,
     fullSurface: true,
-    maxBriefChars: ACTIVE_CONTEXT_POLICY.maxBriefChars,
+    maxBriefChars: ACTIVE_CONTEXT_POLICY.agentBriefReserve,
     statusDetails: ["fold_candidates", "tree", "folds", "objects"],
     minPeekSliceBytes: PEEK_MIN_SLICE_BYTES,
     defaultPeekBytes: PEEK_DEFAULT_MAX_BYTES,