pi-fold 1.0.4 → 3.0.0

package/extensions/lib/selection.ts

@@ -16,7 +16,6 @@ import {
   orderedRoots,
   refsInOrder,
   refsProtected,
-  toolRefsProtected,
   visibleCollapsedRoots,
 } from "./measurement.ts";
 import {
@@ -28,7 +27,6 @@ import {
 import {
   ACTIVE_CONTEXT_POLICY,
   DEFAULT_ACTIVE_CONTEXT_TOOL_NAME,
-  MAX_FOLD_SPAN_CHARS,
 } from "./policy.ts";
 import type {
   ActiveContextSnapshot,
@@ -42,7 +40,6 @@ import type {
 } from "./policy.ts";
 import {
   chapterSegments,
-  currentTurnBoundary,
   scanTurnToolBatches,
   structurallyClosedChapterUnits,
   terminalAssistant,
@@ -152,19 +149,23 @@ export function toolCallArguments(snapshot: ActiveContextSnapshot, assistantInde
   return calls.get(id);
 }
 
-/**
- * Anchor budgets for a stage-identified brief. They exist to keep the composed brief
- * inside the hard 1200-character brief cap with the generic prose trimmed away: an
- * argument list, a leading label from the result head, and the result TAIL, which is
- * where a staged chain puts its keys and a report puts its conclusion.
- */
 export const IDENTIFIED_BRIEF_ARGUMENT_CHARS = 240;
 export const IDENTIFIED_BRIEF_VALUE_CHARS = 96;
+// A composed stage-identified brief is held to the ONE policy cap, maxBriefChars
+// (Shane 2026-08-14: "2k brief is more appropriate"). The head keeps the
+// result's leading paragraph and gets exactly what remains of the cap after the
+// parts that identify the fold (call signatures, tail anchor, fixed text), so
+// the paragraph takes every character the contract can give it. The 1,100
+// sub-cap this replaced held 100 below a separate 1,200 supplied maximum as
+// headroom for commit-time gap absorption's appended sentence; the absorption
+// eligibility law (gate 136) removed that hazard, and both smaller numbers went
+// with it. Gate 134 pins the paragraph surviving.
+// The head bound for a result with NO terminated opening paragraph: its first
+// line, exactly the pre-paragraph behaviour.
 export const IDENTIFIED_BRIEF_HEAD_CHARS = 160;
 export const IDENTIFIED_BRIEF_TAIL_CHARS = 120;
 export const IDENTIFIED_BRIEF_CALLS_CHARS = 400;
 
-/** Every scalar argument of a call, in stable key order, bounded per value and in total. */
 export function identifiedCallArguments(
   args: unknown,
   factual: (value: string, maximum: number) => string,
@@ -182,7 +183,6 @@ export function identifiedCallArguments(
   return oneLine(pairs.join(", "), IDENTIFIED_BRIEF_ARGUMENT_CHARS);
 }
 
-/** The last characters of a result, which is the region a truncated read never shows. */
 export function identifiedResultTail(
   message: unknown,
   factual: (value: string, maximum: number) => string,
@@ -192,13 +192,6 @@ export function identifiedResultTail(
   return factual(text.slice(Math.max(0, text.length - IDENTIFIED_BRIEF_TAIL_CHARS)), IDENTIFIED_BRIEF_TAIL_CHARS);
 }
 
-/**
- * The stage-identified brief. The generic prose is trimmed to a few words so the
- * character budget buys ANCHORS instead: which call this was, with which arguments,
- * what the result opened with, and what it ENDED with. The tail anchor is the point
- * of the whole change: a reader deciding which fold holds a chain key can only tell
- * from the tail, and a generic sentence never carried one.
- */
 export function stageIdentifiedToolBrief(input: {
   snapshot: ActiveContextSnapshot;
   refs: EvidenceRef[];
@@ -216,31 +209,92 @@ export function stageIdentifiedToolBrief(input: {
     );
     return args ? `${factualToolName(call.name)}(${args})` : factualToolName(call.name);
   });
-  const label = factualValue(
-    String(contentText(messages[0]) ?? "").split(/\r?\n/).find((line) => line.trim()) ?? "",
-    IDENTIFIED_BRIEF_HEAD_CHARS,
-  );
+  // THE LEADING PARAGRAPH, not the first line (Shane 2026-08-14). A tool result
+  // that opens with a header line and then states, in prose, what the caller must
+  // do or know had everything after that header dropped: the head kept ONE line
+  // and the header was it. sol-20260814-traps rep 1 is what that costs. A stage
+  // result opens "STAGE 09 / read" and carries its audit note, including a code
+  // word and a correction WITHDRAWING an earlier one, on the next line. The fold
+  // committed at entry 121 with a head of "STAGE 09 / read", the model brief that
+  // did carry both facts landed at entry 311, and the answer at entry 185 in
+  // between was a fabricated code word present nowhere in the run.
+  //
+  // Reading to the first blank line is the generic form of that: a result whose
+  // payload follows a blank line contributes its whole opening paragraph, and a
+  // result that is bulk from line one contributes exactly what it did before. The
+  // deterministic brief is what a fold is COMMITTED with, so it has to stand alone
+  // the moment the fold appears, and never be the thing an async upgrade rescues.
+  // Paragraph-shaped means TERMINATED: an opening block is only kept whole when
+  // a blank line ends it before the bulk. A result that is bulk from its first
+  // line has no opening prose to keep, and handing its first thousand characters
+  // to the brief is noise that inflates every status page and shrinks every
+  // fold's reclaimable mass; that result contributes its first line, exactly as
+  // before.
+  const leadingParagraph = (message: unknown): string | null => {
+    const lines = String(contentText(message) ?? "").split(/\r?\n/);
+    const kept: string[] = [];
+    for (const line of lines) {
+      if (line.trim()) kept.push(line.trim());
+      else if (kept.length) return kept.join(" ");
+    }
+    return null;
+  };
   const tail = identifiedResultTail(messages.at(-1), factualValue);
-  const composed = [
+  // THE AGENT'S OWN CLOSING NOTES (Shane 2026-08-14). The batch the fold absorbs
+  // runs past its results: the assistant text between the last result and the
+  // next batch's work is the agent recording what it just derived, and
+  // sol-20260814-traps rep 2 lost trace-a-02 and trace-d-05 because those lines
+  // lived nowhere else. Each assistant message contributes its leading
+  // paragraph, INCLUDING the one that also opens the next batch: in a
+  // pull-shaped session the agent closes batch N and calls batch N+1 in one
+  // message (36 of rep 3's 37 assistant messages carry text and the next call
+  // together), so the text is collected before the tool-calling break, and
+  // ownership stays with batch N because batch N+1's own walk starts after
+  // its own results. The walk stops at the first user turn or tool result,
+  // and after consuming one tool-calling assistant.
+  const resultIndices = refs.map((ref) => exactMapped(snapshot, ref)?.index ?? -1);
+  const noteTexts: string[] = [];
+  for (let index = Math.max(...resultIndices) + 1; index < snapshot.mapped.length; index += 1) {
+    const message = snapshot.mapped[index]?.message;
+    const role = messageRole(message);
+    if (role !== "assistant") break;
+    const paragraphText = assistantNoteText(message);
+    if (paragraphText) noteTexts.push(paragraphText);
+    const callsTools = (denseOwnArrayValues(ownValue(message, "content")) ?? [])
+      .some((part) => ownValue(part, "type") === "toolCall");
+    if (callsTools) break;
+  }
+  // Compose the identifying parts FIRST, then hand the paragraph what is left of
+  // the bound. A fixed head allowance either starves the paragraph or outgrows
+  // the composed contract; the remainder does neither. The head is seated before
+  // the notes: the instruction prose won gate 134 on sealed evidence, so when
+  // both are long the head keeps its allowance and the notes take the remainder.
+  const assemble = (label: string, noted: string): string => [
     `Read ${oneLine(signatures.join("; "), IDENTIFIED_BRIEF_CALLS_CHARS)}`,
     label ? `opens "${label}"` : "",
     tail ? `ends "${tail}"` : "",
+    noted ? `agent noted "${noted}"` : "",
     calls.length > 1 ? `${calls.length} exact results here` : "exact source here",
   ].filter(Boolean).join(" · ");
-  const bounded = oneLine(composed, ACTIVE_CONTEXT_POLICY.maxBriefChars);
+  // A present label costs its own wrapper on top of the fixed parts: the
+  // ` · opens "` prefix and closing quote are 11 characters that assemble("")
+  // does not count, because an empty label drops the whole term.
+  const headAllowance = Math.max(0, ACTIVE_CONTEXT_POLICY.maxBriefChars - assemble("", "").length - 11);
+  const paragraph = leadingParagraph(messages[0]);
+  const label = paragraph !== null
+    ? factualValue(paragraph, headAllowance)
+    : factualValue(
+      String(contentText(messages[0]) ?? "").split(/\r?\n/).find((line) => line.trim()) ?? "",
+      IDENTIFIED_BRIEF_HEAD_CHARS,
+    );
+  // The notes wrapper costs 18 characters the empty form does not count, the
+  // same accounting as the label's 11.
+  const notesAllowance = Math.max(0, ACTIVE_CONTEXT_POLICY.maxBriefChars - assemble(label, "").length - 18);
+  const noted = noteTexts.length ? factualValue(noteTexts.join(" · "), notesAllowance) : "";
+  const bounded = oneLine(assemble(label, noted), ACTIVE_CONTEXT_POLICY.maxBriefChars);
   return usefulBrief(bounded, ACTIVE_CONTEXT_POLICY.maxBriefChars, snapshot.toolName) ? bounded : null;
 }
 
-/**
- * The fold ids a batch of tool results PEEKED, or null if the batch is not one.
- *
- * A peek result is the one tool output whose bytes the runtime already holds: it is a
- * copy of a fold's own stored source. Reclaiming it therefore has an identity the
- * ordinary tool-fold path does not have, and that identity has to be derivable from the
- * transcript alone, because whichever mechanism claims the copy (the epoch's own
- * reclaim marking or the doorless ladder) the record it leaves behind must still point
- * back at the source.
- */
 export function peekedSourceFoldIds(
   snapshot: ActiveContextSnapshot,
   refs: readonly EvidenceRef[],
@@ -262,14 +316,6 @@ export function peekedSourceFoldIds(
   return ids.length ? ids : null;
 }
 
-/**
- * The brief a reclaimed peek copy leaves behind: a pointer, not a summary.
- *
- * The copy's content is the source fold's content, so summarizing it again would mint
- * a second description of bytes that already have one. What the agent needs from the
- * placeholder is the id it already used once, so re-reading the verbatim content is the
- * same one-hop peek it was before the reclaim.
- */
 export function peekReclaimBrief(sourceFoldIds: readonly string[]): string {
   const named = sourceFoldIds.join(", ");
   return sourceFoldIds.length === 1
@@ -293,26 +339,19 @@ export function automaticToolBrief(snapshot: ActiveContextSnapshot, candidate: F
     throw new Error("Automatic tool brief crossed a validated assistant batch");
   }
   const first = calls[0];
-  const factualValue = (value: string, maximum: number): string => value
-    .replace(new RegExp(snapshot.toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi"), "active-context service")
-    .replace(/[\u0000-\u001f\u007f]+/g, " ")
-    .replace(/\s+/g, " ")
-    .trim()
-    .slice(0, maximum);
+  const factualValue = (value: string, maximum: number): string => oneLine(
+    value
+      .replace(new RegExp(snapshot.toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi"), "active-context service")
+      .replace(/[\u0000-\u001f\u007f]+/g, " "),
+    maximum,
+  );
   const factualBriefValue = (value: string): string => factualValue(value, 120);
   const factualToolName = (name: string): string => name.toLowerCase() === snapshot.toolName.toLowerCase()
     ? "active-context status inspection"
     : factualBriefValue(name);
   const args = toolCallArguments(snapshot, first.assistantIndex, first.id);
-  // A peek copy is named by what it copied, before anything else. The stage-identified
-  // brief below describes a result by its own head and tail, which for a peek copy is a
-  // second description of a fold that already has one; the pointer is what makes the
-  // reclaim recoverable, so it comes first and it is derived here rather than at the one
-  // call site that happens to know a reclaim is under way.
   const peeked = peekedSourceFoldIds(snapshot, refs);
   if (peeked) return peekReclaimBrief(peeked);
-  // Exact anchors before generic prose: one sentence per tool made every fold of that
-  // tool carry the SAME brief, so no index could answer which fold holds a given stage.
   const identified = stageIdentifiedToolBrief({ snapshot, refs, calls, factualValue, factualToolName });
   if (identified) return identified;
   const targets: string[] = [];
@@ -328,10 +367,28 @@ export function automaticToolBrief(snapshot: ActiveContextSnapshot, candidate: F
   return `Completed one read-only ${names} batch with ${calls.length} exact results${target}; every stale output remains recoverable from this fold.`;
 }
 
-/** The narrowest entry in a parent's index that still names a subject rather than a stub. */
 const MIN_SUBJECT_CHARS = 24;
+const CHAPTER_NOTE_CHARS = 160;
+
+// The leading paragraph of an assistant message read as the agent's own note.
+// Unlike a tool result's opening prose, an unterminated block is KEPT: the
+// whole message is the agent's words, so a note with no blank line is a
+// one-paragraph note, not bulk to refuse.
+function assistantNoteText(message: unknown): string {
+  const lines = String(contentText(message) ?? "").split(/\r?\n/);
+  const kept: string[] = [];
+  for (const line of lines) {
+    if (line.trim()) kept.push(line.trim());
+    else if (kept.length) break;
+  }
+  return kept.join(" ");
+}
 
-/** Cut to a character budget without splitting a surrogate pair, marked where it cut. */
+// THE one bounding primitive (Shane 2026-08-14). Every deterministic brief cut
+// runs through here so a bound always leaves its mark: "..." means exactly
+// "content continues in the exact source", and a reader never mistakes a cut
+// value for a complete one. oneLine collapses whitespace then delegates;
+// factualValue sanitizes then delegates through oneLine. No other site slices.
 function boundedSubject(text: string, budget: number): string {
   if (text.length <= budget) return text;
   let kept = text.slice(0, Math.max(0, budget - 3)).trimEnd();
@@ -340,48 +397,80 @@ function boundedSubject(text: string, budget: number): string {
   return `${kept}...`;
 }
 
-/**
- * A parent's fallback brief: an index of its children, one entry each.
- *
- * This used to concatenate the children's briefs and slice the result at the cap, which
- * cannot represent them. Ten children whose briefs may each run to the cap need ten times
- * the cap, so the slice landed inside the first child or two and the rest of the group
- * left no trace at all. In the 2026-08-11 rep every parent came out at exactly the cap,
- * the bottom rung showed five of ten children and every rung above it showed ONE: at rung
- * two the first child was itself a capped parent, so it spent the whole budget alone.
- *
- * The budget is divided instead. Children shorter than an even share hand their remainder
- * to the longer ones, so the cut falls on the children that are actually long rather than
- * on whoever sorts last, and every child appears whatever its neighbours cost. Coverage is
- * the property being defended: this is the brief a group carries when no generator wrote
- * it one, and a group that cannot say what a member holds cannot be navigated back into.
- */
-export function deterministicConsolidationBrief(candidate: FoldCandidate, state: ActiveContextState): string {
+export function deterministicConsolidationBrief(
+  candidate: FoldCandidate,
+  state: ActiveContextState,
+  toolName = DEFAULT_ACTIVE_CONTEXT_TOOL_NAME,
+  snapshot?: ActiveContextSnapshot,
+): string {
   const byId = foldMap(state);
-  const subjects = candidate.parts.flatMap((part) => {
-    if (part.kind !== "fold") return [];
-    const child = byId.get(part.foldId);
-    // Through the override map, never off the record: a child upgraded since it committed
-    // presents the model's brief, and reading the record here would index the sentence
-    // that brief replaced.
-    return child ? [foldBrief(child, state).replace(/\s+/g, " ").trim()] : [];
+  const escapedToolName = toolName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const sanitize = (value: string): string => value
+    .replace(new RegExp(escapedToolName, "gi"), "active-context service")
+    .replace(/\s+/g, " ")
+    .trim();
+  let foldCount = 0;
+  let spanStart = Number.MAX_SAFE_INTEGER;
+  let spanEnd = -1;
+  const seat = (ref: EvidenceRef): void => {
+    const item = snapshot ? exactMapped(snapshot, ref) : null;
+    if (!item) return;
+    spanStart = Math.min(spanStart, item.index);
+    spanEnd = Math.max(spanEnd, item.index);
+  };
+  const childSubjects = candidate.parts.flatMap((part) => {
+    if (part.kind === "fold") {
+      const child = byId.get(part.foldId);
+      if (!child) return [];
+      foldCount += 1;
+      for (const ref of flattenFoldRefs(child, state)) seat(ref);
+      return [sanitize(foldBrief(child, state))];
+    }
+    seat(part.ref);
+    return [];
   });
+  // The agent's own recorded words are the ONLY carrier a derived fact ever
+  // has (sol-20260814-traps rep 2 lost trace-a-02 and trace-d-05 exactly here:
+  // each lived in one assistant turn between two tool batches, the parent
+  // indexed only its children's briefs, and the value reached zero briefs), so
+  // every assistant message the group hides contributes its leading paragraph
+  // as its OWN subject, sharing the division with the child briefs. The child
+  // briefs are not trusted to carry the notes for it: a child's subject is
+  // truncated to its division share, and a note past the cut is the rep-2
+  // loss again one level up, so a note rides whole or not at all, which the
+  // ascending-length division guarantees for anything shorter than its fair
+  // share. The span is WALKED rather than read off the candidate's raw parts,
+  // because absorption geometry varies: rep 2 held its notes as unclaimed raw
+  // parts while denser sessions claim the same assistant text into a child's
+  // interval, and both spellings hide the same words. Non-assistant gaps
+  // contribute nothing: their facts live in the folds beside them. Without a
+  // snapshot the exact text is unreadable and the output is the
+  // pre-2026-08-14 bytes exactly.
+  const notes: string[] = [];
+  if (snapshot && spanEnd >= 0) {
+    for (let index = spanStart; index <= spanEnd; index += 1) {
+      const item = snapshot.mapped[index];
+      if (!item?.message) continue;
+      if (messageRole(item.message) !== "assistant") continue;
+      const noteText = assistantNoteText(item.message);
+      if (noteText) notes.push(sanitize(boundedSubject(noteText, CHAPTER_NOTE_CHARS)));
+    }
+  }
+  const noteCount = notes.length;
+  const subjects = [...childSubjects, ...notes];
   if (!subjects.length) return "Grouped completed context covering no readable folds.";
   const separator = " | ";
-  const lead = `Grouped completed context covering ${subjects.length} folds: `;
-  // Below this width an entry says nothing a reader could act on, so a group too wide to
-  // give every child that much names as many as it can and then says, in the brief itself,
-  // how many it could not name. A count is a poor substitute for a subject and a truthful
-  // one; a slice through the middle of the third child is neither.
+  const lead = noteCount
+    ? `Grouped completed context covering ${foldCount} folds and ${noteCount} agent notes: `
+    : `Grouped completed context covering ${subjects.length} folds: `;
   const room = ACTIVE_CONTEXT_POLICY.maxBriefChars - lead.length - 1;
   const named = Math.max(1, Math.min(subjects.length,
     Math.floor((room + separator.length) / (MIN_SUBJECT_CHARS + separator.length))));
   const omitted = subjects.length - named;
-  const tail = omitted ? `${separator}${omitted} more folds in this group` : "";
+  // With notes in the division, what the slice drops may be a note rather than
+  // a fold, so the tail only claims folds when folds are all it holds.
+  const tail = omitted ? `${separator}${omitted} more ${noteCount ? "in this group" : "folds in this group"}` : "";
   const budget = room - tail.length - separator.length * (named - 1);
-  // Shortest first, so every subject that fits whole releases what it did not use to the
-  // subjects still to be measured. `owed` is always the even share of what is left among
-  // those that remain, which is the largest floor that still leaves room for all of them.
   const order = subjects.slice(0, named).map((text, index) => ({ text, index })).sort((a, b) =>
     a.text.length - b.text.length || a.index - b.index);
   const bounded = new Array<string>(named);
@@ -395,21 +484,11 @@ export function deterministicConsolidationBrief(candidate: FoldCandidate, state:
   return `${lead}${bounded.join(separator)}${tail}.`.replace(/\s+/g, " ").trim();
 }
 
-/**
- * Every fold kind, as a span may contain it.
- *
- * The agent path composes with this set, and so does the count law's parent: a fold is a
- * fold, whatever kind made it, and a parent may take any of them. What an automatic
- * CHAPTER may take is nothing of the sort, at any count: a placeholder reaches an
- * automatic fold through exactly one route now, which is the count (Shane 2026-08-10).
- */
 export const ALL_FOLD_KINDS: ReadonlySet<FoldKind> =
   new Set<FoldKind>(["tool-result", "chapter", "consolidation"]);
 
-/** No placeholder is span material. What an automatic chapter composes is raw entries. */
 export const NO_FOLD_KINDS: ReadonlySet<FoldKind> = new Set<FoldKind>();
 
-/** The first pinned fold a span would nest, or null when the span swallows no pin. */
 export function pinnedChildFold(
   parts: FoldPart[],
   state: ActiveContextState,
@@ -421,41 +500,18 @@ export function pinnedChildFold(
     const child = byId.get(part.foldId);
     if (!child) continue;
     const refs = flattenFoldRefs(child, state);
-    const pinned = child.kind === "tool-result"
-      ? toolRefsProtected(refs, state, snapshot)
-      : refsProtected(refs, state, snapshot);
+    const pinned = refsProtected(refs, state, snapshot);
     if (pinned) return child;
   }
   return null;
 }
 
-/**
- * The one refusal nesting keeps.
- *
- * A span may take in any fold, so the pin is the sole thing that can stop it, and a pin
- * is a promise to hold bytes raw. Nesting one would put a fold the agent asked to keep
- * visible behind a placeholder, so the span is refused by name with the release valve
- * in it, the same texture the pinned-share cap uses.
- */
 export function pinnedNestingRefusal(pinned: ActiveFold, toolName: string): string {
   return `fold refused: ${pinned.id} is pinned, and nesting it would hide context you asked to keep. ` +
-    `Release it with ${toolName} {"action":"unprotect","ids":["${pinned.id}"]} first, ` +
+    `Release it with ${toolName} {"action":"unpin","ids":["${pinned.id}"]} first, ` +
     "or name a span that stops at its boundary.";
 }
 
-/**
- * The span you named is already folded, said the way every other collision here is said.
- *
- * A fold that already owned the evidence used to reach the agent as
- * "Evidence <id> has multiple direct fold owners", an invariant message thrown out of the
- * tool call with no next move in it. The collision is ordinary: automatic folding and an
- * agent curate the same window, so the ladder taking a span the agent was about to name
- * is the campaign working, not a race. So it reads like the pin refusal above: name the
- * fold holding it, give the two verbs that open it, and name the span that would work.
- *
- * One sentence covers the three ways a caller can point at folded material: an entry a
- * fold directly owns, a span sitting inside one, and a span whose only reading IS one.
- */
 export function foldedSpanRefusal(ownerId: string, subject: string, toolName: string): string {
   return `fold refused: ${subject} is already folded inside ${ownerId}, so there is nothing ` +
     `left to fold there. Read it with ${toolName} {"action":"peek","id":"${ownerId}"}, restore it ` +
@@ -509,22 +565,6 @@ export function chapterUnits(snapshot: ActiveContextSnapshot): ChapterUnit[] {
     .flatMap((segment) => structurallyClosedChapterUnits(snapshot.messages, segment));
 }
 
-/**
- * The automatic jurisdiction, as a list of roots: THE ROOTS THE COUNT COUNTS.
- *
- * Membership, not position, and not kind. Every visible collapsed root belongs unless the
- * agent pinned it or the fresh tail covers it, and an EXPANDED fold is not a placeholder
- * at all. One predicate answers all of it, because that is the same question
- * `refsProtected` already asks of a span's evidence.
- *
- * A consolidation counts here like anything else. A consolidated fold is not a different
- * species of span, and depth is the point: ten visible parents make a grandparent, and
- * under gradual accrual the stalest parent is simply the stalest member of the next group
- * of ten, so the oldest context sits a few layers down after a long session. The only
- * folds outside the count are the held ones, because a counted fold must be groupable and
- * a held one is exactly the fold that cannot be (Shane 2026-08-10). A fold already nested
- * inside a parent is not a root and is never counted separately.
- */
 export function unpinnedStaleFolds(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -533,7 +573,6 @@ export function unpinnedStaleFolds(
     .filter(({ fold }) => !refsProtected(flattenFoldRefs(fold, state), state, snapshot));
 }
 
-/** Everything a pending mark already speaks for: whole folds by id, raw evidence by key. */
 export function pendingMarkClaims(
   state: ActiveContextState,
 ): { foldIds: Set<string>; refKeys: Set<string> } {
@@ -552,7 +591,6 @@ export function pendingMarkClaims(
   return { foldIds, refKeys };
 }
 
-/** Whether the raw material between two roots is material a parent may swallow. */
 function absorbableGap(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -561,9 +599,6 @@ function absorbableGap(
   claims: { refKeys: Set<string> },
 ): boolean {
   if (from > to) return true;
-  // No fold kind is admitted, so any root sitting in the gap -- a parent the count
-  // already made, a fold the agent expanded, a fold the agent pinned -- refuses the
-  // range outright and splits the run there.
   const parts = partsForRange(snapshot, state, from, to, NO_FOLD_KINDS);
   if (!parts) return false;
   const refs = parts.flatMap((part) => part.kind === "raw" ? [part.ref] : []);
@@ -571,7 +606,6 @@ function absorbableGap(
   return !refs.some((ref) => claims.refKeys.has(objectRefKey(ref)));
 }
 
-/** Every tool call in the window, by id, with the assistant and the result that close it. */
 function windowToolLinkage(snapshot: ActiveContextSnapshot): Map<string, { call: number; result: number }> {
   const linkage = new Map<string, { call: number; result: number }>();
   const at = (id: string): { call: number; result: number } => {
@@ -598,15 +632,6 @@ function windowToolLinkage(snapshot: ActiveContextSnapshot): Map<string, { call:
   return linkage;
 }
 
-/**
- * The parent's span, widened until hiding it keeps every tool call with its result.
- *
- * A collapsed parent renders as ONE entry, so a span that opens on a tool-result fold
- * would hide the result while its call stayed visible, and the projection guard rejects
- * that split outright. The widening is the same raw absorption the law already grants
- * between children, applied at the edges: it takes the calling assistant in, never a
- * fold, and if the material it needs is not absorbable the group does not form.
- */
 function linkageClosedSpan(
   snapshot: ActiveContextSnapshot,
   start: number,
@@ -630,7 +655,6 @@ function linkageClosedSpan(
   return { start: from, end: to };
 }
 
-/** One group of exactly `consolidateAfter` roots, read as the parent it must become. */
 function consolidationCandidate(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -647,34 +671,9 @@ function consolidationCandidate(
   if (refsProtected(raw, state, snapshot)) return null;
   if (raw.some((ref) => claims.refKeys.has(objectRefKey(ref)))) return null;
   const sourceRefs = candidateSourceRefs(parts, state);
-  // THE ONE PHYSICAL BOUND, HANDLED LOUDLY. A record carries at most
-  // `maxFoldSourceRefs` exact references. A group over that bound is left UNFORMED
-  // rather than quietly shrunk: shrinking would make the parent a function of the
-  // record format instead of the count, and the law is the count.
-  if (sourceRefs.length > snapshot.policy.maxFoldSourceRefs) return null;
   return { kind: "consolidation", parts, sourceRefs };
 }
 
-/**
- * CONSOLIDATION IS A PURE FUNCTION OF THE COUNT (Shane 2026-08-10).
- *
- * Not a crossing event, not a paced rung, and not one candidate per pass. Count the
- * visible unheld roots of every kind; each `consolidateAfter` consecutive ones, stalest
- * first, MUST be under a parent, and the remainder is left alone. From a count of n that
- * is `n / consolidateAfter` parents, and all of them form in the epoch that notices,
- * because a rule that formed one per commit would leave a count the rule says is
- * impossible standing for as many commits as it takes to drain.
- *
- * A parent it made is a root like any other, so the epoch applies the rule to a FIXPOINT:
- * ten parents are a group, and the grandparent that follows is how the oldest context
- * ends up several layers down after a long session.
- *
- * The run is where the count is taken. A hold -- a pin, the fresh tail, an expanded fold,
- * evidence a pending mark spoke for -- cannot be swallowed, so it splits the run and each
- * side counts on its own; a run shorter than the width waits as remainder. Gaps of raw
- * context between children fall into the parent, which is what makes the span one
- * contiguous range instead of a list of islands.
- */
 export function selectAutomaticConsolidations(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -702,30 +701,12 @@ export function selectAutomaticConsolidations(
   return groups;
 }
 
-/** One completed batch the automatic law may take, with the indices it covers. */
 export interface AutomaticToolBatch {
   refs: EvidenceRef[];
   indices: number[];
   bytes: number;
 }
 
-/**
- * MEMBERSHIP, WRITTEN ONCE: every completed tool batch the automatic law may take,
- * stalest first, whether or not anything has claimed it yet.
- *
- * A batch is a member when it is complete and validated, its tool is not blacklisted
- * (`resultCall` runs the batch scan with the deployment's list), its evidence carries
- * exact refs in branch order, it is inside the record's reference bound, it is large
- * enough to be worth a placeholder, and neither an agent pin nor the fresh byte tail
- * covers any part of it. There is no position in that list. A prefix of the window is
- * not more foldable than the middle of it, and the middle is not a wall: it is whatever
- * the ladder has not needed yet plus whatever the agent pinned (Shane 2026-08-10).
- *
- * Ownership is deliberately NOT membership. A batch some fold or pending mark already
- * speaks for is still a member of the class; it is simply taken. The selector filters on
- * ownership because it must propose something new, and the announcement counts the class
- * because that is the mass a commit can reach. One definition, two readings of it.
- */
 export function automaticToolBatches(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -748,19 +729,13 @@ export function automaticToolBatches(
         refs.some((ref) => !ref || ref.role !== "toolResult")) continue;
     const exactRefs = refs as EvidenceRef[];
     const size = group.reduce((total, { item }) => total + bytes(item.message), 0);
-    if (exactRefs.length > snapshot.policy.maxFoldSourceRefs ||
-        toolRefsProtected(exactRefs, state, snapshot) || refsInOrder(snapshot, exactRefs) === null ||
-        size < snapshot.policy.minToolChars) continue;
+    if (refsProtected(exactRefs, state, snapshot) || refsInOrder(snapshot, exactRefs) === null ||
+        size < snapshot.thresholds.minFoldChars) continue;
     batches.push({ refs: exactRefs, indices: group.map(({ item }) => item.index), bytes: size });
   }
   return batches;
 }
 
-/**
- * The stalest member batch nothing has claimed. `claimed` lets a caller exclude evidence
- * already spoken for by something that is not yet a fold (a pending mark), so repeated
- * calls walk forward instead of returning the same batch.
- */
 export function selectAutomaticToolBatch(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -779,14 +754,6 @@ export function selectAutomaticToolBatch(
   return [];
 }
 
-/**
- * The re-fold path.
- *
- * An expansion is a deliberate act, and the way to make it permanent is a pin: a pinned
- * fold is never re-folded, and a leased one is held for the term of its lease. Anything
- * else the agent opened is an ordinary member of the foldable class again, so automation
- * may return it to its placeholder, stalest and narrowest first.
- */
 export function selectAutomaticRefold(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -796,9 +763,7 @@ export function selectAutomaticRefold(
     if (claimedFoldIds.has(id)) return [];
     const fold = state.folds.find((item) => item.id === id);
     const interval = fold ? foldInterval(fold, state, snapshot) : null;
-    const protectedSource = fold && (fold.kind === "tool-result"
-      ? toolRefsProtected(flattenFoldRefs(fold, state), state, snapshot)
-      : refsProtected(flattenFoldRefs(fold, state), state, snapshot));
+    const protectedSource = fold && (refsProtected(flattenFoldRefs(fold, state), state, snapshot));
     return fold && interval && !protectedSource && !state.leases[id]
       ? [{ id, ...interval }]
       : [];
@@ -831,63 +796,9 @@ export function resolveFoldInputIds(
 export function chapterRangeIsUnitAligned(snapshot: ActiveContextSnapshot, start: number, end: number): boolean {
   const units = chapterUnits(snapshot).filter((unit) => unit.end > start && unit.start <= end);
   if (!units.length || units[0].start !== start || units.at(-1)!.end !== end + 1) return false;
-  if (new Set(units.map((unit) => unit.turnStart)).size > snapshot.policy.maxChapterTurns) return false;
   return units.every((unit, index) => index === 0 || unit.start === units[index - 1].end);
 }
 
-/**
- * Bite-sized folds.
- *
- * A fold is only navigable if reading one back is cheap. Measured 2026-08-06 (rep 6):
- * one 60,432-byte chapter fold hid the fact the run needed in its tail, and every peek
- * of it was either truncated short of the answer or too expensive to widen. So a span
- * whose content exceeds the cap becomes SEQUENTIAL folds, each with its own brief,
- * split only at structurally closed unit boundaries -- never mid-entry.
- *
- * A single unit that alone exceeds the cap is returned whole: there is no valid
- * interior boundary, and refusing to fold it would leave the biggest span in the
- * window as the one thing nothing may reclaim. The caller reports the split.
- */
-export function splitCandidateBySize(
-  snapshot: ActiveContextSnapshot,
-  state: ActiveContextState,
-  candidate: FoldCandidate,
-  maxChars: number = MAX_FOLD_SPAN_CHARS,
-): FoldCandidate[] {
-  // A tool-result fold owns exactly one validated assistant batch and a consolidation
-  // owns whole child folds; neither has an interior boundary to split on.
-  if (candidate.kind !== "chapter") return [candidate];
-  const refs = candidate.sourceRefs.length ? candidate.sourceRefs : candidateSourceRefs(candidate.parts, state);
-  const indices = refs.map((ref) => exactMapped(snapshot, ref)?.index ?? -1);
-  if (!indices.length || indices.some((index) => index < 0)) return [candidate];
-  const start = Math.min(...indices);
-  const end = Math.max(...indices);
-  if (spanBytes(snapshot, start, end + 1) <= maxChars) return [candidate];
-  const units = chapterUnits(snapshot).filter((unit) => unit.start >= start && unit.end <= end + 1);
-  if (units.length < 2) return [candidate];
-  const split: FoldCandidate[] = [];
-  const emit = (from: number, to: number): boolean => {
-    const parts = partsForRange(snapshot, state, from, to, new Set<FoldKind>(["tool-result"]));
-    if (!parts) return false;
-    split.push({ kind: "chapter", parts, sourceRefs: candidateSourceRefs(parts, state) });
-    return true;
-  };
-  let runStart = units[0].start;
-  let runBytes = 0;
-  for (const unit of units) {
-    const size = spanBytes(snapshot, unit.start, unit.end);
-    if (runBytes > 0 && runBytes + size > maxChars) {
-      if (!emit(runStart, unit.start - 1)) return [candidate];
-      runStart = unit.start;
-      runBytes = 0;
-    }
-    runBytes += size;
-  }
-  if (runBytes > 0 && !emit(runStart, units.at(-1)!.end - 1)) return [candidate];
-  return split.length ? split : [candidate];
-}
-
-/** Exact serialized size of a candidate's whole span, folds and raw entries alike. */
 export function candidateSpanChars(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -899,12 +810,10 @@ export function candidateSpanChars(
   return spanBytes(snapshot, Math.min(...indices), Math.max(...indices) + 1);
 }
 
-/** Exact serialized size of a half-open mapped message range. */
 export function spanBytes(snapshot: ActiveContextSnapshot, start: number, end: number): number {
   return bytes(snapshot.messages.slice(start, end));
 }
 
-/** One auto-snap the runtime applied to a requested span, reported never inferred. */
 export interface SpanCorrection {
   from: string[];
   to: string[];
@@ -916,15 +825,6 @@ export interface SnappedFoldSpan {
   corrections: SpanCorrection[];
 }
 
-/**
- * Resolve a requested span, correcting it where a correction exists.
- *
- * A span the agent got slightly wrong -- crossing a fold it forgot about, reaching
- * into the turn still in flight, landing mid-unit -- is a span it MEANT, and refusing
- * it teaches the agent that curating is a coin flip. So an invalid span SNAPS to the
- * nearest valid edge and the correction is stated in the result. Rejection is reserved
- * for a request with no valid interpretation at all, and it says exactly what failed.
- */
 export function snapFoldCandidate(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -937,11 +837,6 @@ export function snapFoldCandidate(
   } catch (error) {
     directError = error instanceof Error ? error : new Error(String(error));
   }
-  // Nearest first, then the other readings of the same intent. A span that cuts into one
-  // fold has exactly two endpoint corrections -- absorb it, or step past it -- and which
-  // one survives depends on structure the caller cannot see. A whole fold left inside the
-  // corrected span is no longer a reason to fail: the span nests it. What still fails is
-  // a span with no valid frame at all, and a pin the span would swallow.
   const alternatives = snapSpanAlternatives(snapshot, state, ids);
   let lastError: Error = directError;
   for (const snapped of alternatives) {
@@ -954,23 +849,12 @@ export function snapFoldCandidate(
       lastError = error instanceof Error ? error : new Error(String(error));
     }
   }
-  // A suggestion the caller cannot act on is worse than no suggestion: never name a
-  // "nearest valid span" this same validation just refused. Nothing snapped, so the
-  // refusal is the direct one, stated once.
   throw new Error(
     `${directError.message}. No corrected reading of that span is constructible`,
     { cause: lastError },
   );
 }
 
-/**
- * Every constructible reading of a requested span, nearest intent first.
- *
- * The three endpoint modes move the EDGES; the fourth reading moves the FRAME, reading
- * the span as the whole folds it cuts into. The frame reading survives the nesting law
- * because it is still the faithful one where the endpoints cannot snap to closed units:
- * the folds themselves already tile the range exactly.
- */
 export function snapSpanAlternatives(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -991,13 +875,6 @@ export function snapSpanAlternatives(
   });
 }
 
-/**
- * The requested span read as the whole folds it cuts into.
- *
- * Constructible only when the outward snap lands on a contiguous tiling of two or more
- * foldable roots: then the span the agent named IS those folds, and consolidating them
- * is the one reading that both covers what was asked for and validates.
- */
 export function snapSpanToWholeFolds(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -1023,19 +900,13 @@ export function snapSpanToWholeFolds(
   };
 }
 
-/**
- * The correction itself: pull the endpoints out of any fold they cut through, out of
- * the turn still in flight, and onto structurally closed unit boundaries.
- */
 export function snapSpanIds(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
   ids: string[],
-  /** How an endpoint inside a fold is read: by distance, or always one way. */
   mode: "nearest" | "absorb" | "exclude" = "nearest",
 ): { ids: string[]; corrections: SpanCorrection[] } | null {
   let resolved: Array<{ start: number; end: number; fold?: ActiveFold }>;
-  // An unknown id has no nearest valid edge: there is nothing to snap TO.
   try { resolved = resolveFoldInputIds(snapshot, state, ids); }
   catch { return null; }
   const requested = [resolved[0].start, resolved.at(-1)!.end] as [number, number];
@@ -1049,11 +920,6 @@ export function snapSpanIds(
     });
   };
   const units = chapterUnits(snapshot);
-  // Each correction can undo another: pulling an endpoint onto a unit boundary can put
-  // it back inside a fold, and clamping the width can cut one in half. So the passes run
-  // to a FIXED POINT rather than once each. After the first pass an endpoint inside a
-  // fold always absorbs it, which is outward and therefore terminating: stepping past a
-  // fold here would drop material the agent named, and nesting no longer loses anything.
   for (let pass = 0; pass < state.folds.length + 2; pass += 1) {
     const passStart = start;
     const passEnd = end;
@@ -1073,11 +939,6 @@ export function snapSpanIds(
           `${absorb ? "end" : "near"} boundary`);
       }
     }
-    const boundary = currentTurnBoundary(snapshot);
-    if (boundary >= 0 && end > boundary) {
-      end = boundary;
-      note("span reached into the turn still in flight; corrected back to the last closed turn");
-    }
     const startUnit = units.find((unit) => start >= unit.start && start < unit.end);
     if (startUnit && startUnit.start !== start) {
       start = startUnit.start;
@@ -1088,26 +949,6 @@ export function snapSpanIds(
       end = endUnit.end - 1;
       note("span ended mid-unit; corrected to the end of its closed user/assistant/tool unit");
     }
-    // A chapter spans at most a few closed turns. A longer request is a span the agent
-    // meant, so it is CLAMPED to what one fold may hold rather than refused; the
-    // remainder stays raw and is the agent's to fold next.
-    const covered = units.filter((unit) => unit.start >= start && unit.end <= end + 1);
-    if (covered.length) {
-      const turns: number[] = [];
-      let clamped = end;
-      for (const unit of covered) {
-        if (!turns.includes(unit.turnStart)) {
-          if (turns.length >= snapshot.policy.maxChapterTurns) break;
-          turns.push(unit.turnStart);
-        }
-        clamped = unit.end - 1;
-      }
-      if (clamped < end) {
-        end = clamped;
-        note(`span covered more than the ${snapshot.policy.maxChapterTurns}-turn chapter limit; ` +
-          "corrected to the last turn that fits");
-      }
-    }
     if (start === passStart && end === passEnd) break;
   }
   if (!corrections.length || end < start ||
@@ -1115,14 +956,6 @@ export function snapSpanIds(
   return { ids: [entryIdAt(snapshot, start), entryIdAt(snapshot, end)], corrections };
 }
 
-/**
- * Snap a span OUTWARD to whole-fold boundaries.
- *
- * The re-boundary verb operates on folds, so a span that cuts one in half has exactly
- * one sane reading: the agent meant that fold. Outward rather than nearest, because
- * losing a fold the agent did not name is the surprising outcome and re-cutting a
- * slightly larger span is not.
- */
 export function snapToFoldBoundaries(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
@@ -1132,7 +965,6 @@ export function snapToFoldBoundaries(
   const requested: [number, number] = [resolved[0].start, resolved.at(-1)!.end];
   let [start, end] = requested;
   const corrections: SpanCorrection[] = [];
-  // Fixed point: absorbing one fold can pull the span across the next.
   for (let pass = 0; pass < state.folds.length + 1; pass += 1) {
     let moved = false;
     for (const root of orderedRoots(state, snapshot)) {
@@ -1163,39 +995,19 @@ export function manualFoldCandidate(
   snapshot: ActiveContextSnapshot,
   state: ActiveContextState,
   ids: string[],
-  /**
-   * Accept a span that is still fresh or protected. Only a caller that will DEFER the
-   * fold may pass this: it relaxes eligibility, never structure, so contiguity, unit
-   * alignment and batch completeness are still enforced and the commit still refuses
-   * to apply a mark whose span is protected at commit time.
-   */
   options: { allowProtected?: boolean } = {},
 ): FoldCandidate {
   const blockedTool = (refs: EvidenceRef[]): boolean =>
-    !options.allowProtected && toolRefsProtected(refs, state, snapshot);
+    !options.allowProtected && refsProtected(refs, state, snapshot);
   const blocked = (refs: EvidenceRef[]): boolean =>
     !options.allowProtected && refsProtected(refs, state, snapshot);
-  // The forest as it stands, read once. Building it here can only throw when the STORED
-  // forest is already corrupt, which is the loud case and stays loud; every collision
-  // between this request and a fold that exists is answered below by name.
   const owners = directFoldOwners(state.folds);
   const bounded = (candidate: FoldCandidate): FoldCandidate => {
-    if (candidate.sourceRefs.length > snapshot.policy.maxFoldSourceRefs) {
-      throw new Error(`Folds may include at most ${snapshot.policy.maxFoldSourceRefs} exact source references`);
-    }
-    // Every reading of a requested span leaves through here, so one check covers the
-    // tool-batch, consolidation and chapter readings alike. It runs before anything is
-    // prepared or persisted: no brief is generated, no state is touched, and the caller
-    // gets a span it can act on instead of an invariant it cannot.
     for (const part of candidate.parts) {
       if (part.kind !== "raw") continue;
       const ownerId = owners.get(objectRefKey(part.ref));
       if (ownerId) throw new Error(foldedSpanRefusal(ownerId, part.ref.entryId, snapshot.toolName));
     }
-    // A reading that is exactly one fold that already exists is not a fold to make. It
-    // wraps a placeholder in a placeholder, reclaims nothing, and buries the fold the
-    // caller was pointing at one level deeper, so it is the same refusal: the span is
-    // already folded, and here is what opens it.
     const only = candidate.parts.length === 1 ? candidate.parts[0] : null;
     if (only?.kind === "fold") {
       throw new Error(foldedSpanRefusal(only.foldId, "that span", snapshot.toolName));
@@ -1236,10 +1048,6 @@ export function manualFoldCandidate(
   }
   const parts = partsForRange(snapshot, state, start, end, ALL_FOLD_KINDS);
   if (!parts) {
-    // Two shapes reach here, and they are different asks. A span INSIDE one fold is
-    // material that is already folded, so there is no fold to make and the useful answer
-    // names the fold holding it. A span that merely cuts one is a boundary the snap
-    // corrects, and it says which fold moved the edge.
     const cut = orderedRoots(state, snapshot).filter((root) => root.start <= end && start <= root.end);
     const container = cut.find((root) => root.start <= start && root.end >= end);
     throw new Error(container
@@ -1254,12 +1062,7 @@ export function manualFoldCandidate(
 }
 
 export function oneLine(value: string, maximum: number): string {
-  const text = value.replace(/\s+/g, " ").trim();
-  if (text.length <= maximum) return text;
-  let bounded = text.slice(0, maximum).trimEnd();
-  const finalCode = bounded.charCodeAt(bounded.length - 1);
-  if (finalCode >= 0xd800 && finalCode <= 0xdbff) bounded = bounded.slice(0, -1);
-  return bounded;
+  return boundedSubject(value.replace(/\s+/g, " ").trim(), maximum);
 }
 
 export function deterministicChapterBrief(
@@ -1271,8 +1074,6 @@ export function deterministicChapterBrief(
     throw new Error("Deterministic chapter brief requires aligned exact evidence");
   }
   const firstUser = messages.find((message) => messageRole(message) === "user");
-  const firstAssistant = messages.find((message) =>
-    messageRole(message) === "assistant" && contentText(message).trim());
   const toolCounts = new Map<string, number>();
   for (const message of messages) {
     if (messageRole(message) !== "assistant") continue;
@@ -1282,18 +1083,39 @@ export function deterministicChapterBrief(
       if (typeof name === "string" && name) toolCounts.set(name, (toolCounts.get(name) ?? 0) + 1);
     }
   }
+  // EVERY assistant note in the span, not the first line of the first one
+  // (Shane 2026-08-14). A chapter is the first fold that hides its span, and a
+  // value the agent recorded once on a later turn died with the old single
+  // line: sol-20260814-traps rep 2 lost trace-a-02 and trace-d-05 to exactly
+  // that shape, an assistant message between two tool batches whose words
+  // reached zero briefs. Each note is the message's leading paragraph, capped
+  // per note, seated whole in span order until the brief's own bound refuses
+  // the next one, with the count of what did not seat stated rather than cut.
+  const notes = messages.flatMap((message) => {
+    if (messageRole(message) !== "assistant") return [];
+    const note = assistantNoteText(message);
+    return note ? [boundedSubject(note, CHAPTER_NOTE_CHARS)] : [];
+  });
   const ask = oneLine(firstUser ? contentText(firstUser) : "No user ask in this span", 90);
-  const assistant = oneLine(firstAssistant ? contentText(firstAssistant).split(/\r?\n/)[0] :
-    "No assistant text in this span", 110);
   const tools = oneLine([...toolCounts.entries()]
     .sort(([left], [right]) => left.localeCompare(right))
     .map(([name, count]) => `${count}×${name}`)
     .join(" ") || "no tools", 500);
+  const separator = " | ";
+  const compose = (kept: number): string => {
+    const omitted = notes.length - kept;
+    const shown = kept ? notes.slice(0, kept).join(separator)
+      : (notes.length ? "" : "No assistant text in this span");
+    const tail = omitted ? `${kept ? separator : ""}${omitted} more notes in this span` : "";
+    return `User: ${ask} · Tools: ${tools} · Assistant: ${shown}${tail}`;
+  };
+  let composed = compose(notes.length);
+  for (let kept = notes.length; kept > 0 && composed.length > ACTIVE_CONTEXT_POLICY.maxBriefChars; kept -= 1) {
+    composed = compose(kept - 1);
+  }
   const escapeName = (name: string) => name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const composed = `User: ${ask} · Tools: ${tools} · Assistant: ${assistant}`
-    .replace(new RegExp(escapeName(toolName), "gi"), "active-context service");
+  composed = composed.replace(new RegExp(escapeName(toolName), "gi"), "active-context service");
   if (usefulBrief(composed, ACTIVE_CONTEXT_POLICY.maxBriefChars, toolName)) return composed;
-  // Constant floor-of-the-floor: provably passes usefulBrief (no tool name, no structural pattern).
   return `Folded ${refs.length} exact messages from this span's complete turns.`;
 }