pi-fold 4.0.0 → 4.1.1

package/extensions/active-context.ts

@@ -61,6 +61,7 @@ import {
   stringIds,
   toolPayload,
 } from "./lib/measurement.ts";
+import { renderFoldBar, type FoldBarModel } from "./lib/status-widget.ts";
 import type {
   NativeCompactionCompletionReceipt,
   NativeCompactionDecisionReceipt,
@@ -92,7 +93,9 @@ import {
   activeContextSource,
   ACTIVE_CONTEXT_POLICY,
   ACTIVE_CONTEXT_TOOL_ACTIONS,
-  UNBRIEFED_FOLDS_BEFORE_NOTICE,
+  resolveNoticeLeadShare,
+  EDITOR_DETAIL_PAGE_CHARS,
+  EDITOR_ROW_PREVIEW_CHARS,
   contextBrand,
   DEFAULT_ACTIVE_CONTEXT_BRAND_NOUN,
   DEFAULT_ACTIVE_CONTEXT_COMMAND_NAMES,
@@ -129,7 +132,6 @@ import type {
   FoldKind,
   FoldRecordEntry,
   PreparedFold,
-  WorkingMemoryEntry,
 } from "./lib/policy.ts";
 import {
   absorbWedgeMarks,
@@ -172,6 +174,7 @@ import {
 } from "./lib/scheduling.ts";
 import {
   manualFoldCandidate,
+  oneLine,
   peekedSourceFoldIds,
   snapFoldCandidate,
   snapToFoldBoundaries,
@@ -195,7 +198,9 @@ import type {
 } from "./lib/instrumentation.ts";
 import { buildActiveContextCommands, buildActiveContextTool } from "./lib/tool-surface.ts";
 import { buildFoldEditorData, FoldEditorView } from "./lib/editor-ui.ts";
+import { publishLiveSettings } from "./lib/live-settings.ts";
 import {
+  entryText,
   mapActiveContext,
 } from "./lib/transcript.ts";
 import {
@@ -207,12 +212,13 @@ import {
   unansweredToolCalls,
 } from "./lib/rollback.ts";
 
-export type ProjectionReadingBasis = "anchored" | "rewritten" | "unmeasured";
+export type ProjectionReadingBasis = "anchored" | "rewritten" | "unmeasured" | "refused";
 
 export * from "./lib/canonical.ts";
 export * from "./lib/curation.ts";
 export * from "./lib/folding.ts";
 export * from "./lib/instrumentation.ts";
+export * from "./lib/live-settings.ts";
 export * from "./lib/measurement.ts";
 export * from "./lib/persistence.ts";
 export * from "./lib/policy.ts";
@@ -221,6 +227,47 @@ export * from "./lib/scheduling.ts";
 export * from "./lib/selection.ts";
 export * from "./lib/transcript.ts";
 
+/**
+ * The two independent scalars, resolved in ONE place because they are resolved TWICE:
+ * once from the registration options and once from every /fold-settings edit that
+ * reaches the running session. Absent means the package default in both directions,
+ * which is the settings file's own law, and the refusal text is the same sentence
+ * wherever the bad value came from.
+ */
+/**
+ * ONE ENTRY AS ONE ROW: whitespace collapsed, bounded, and the cut STATED.
+ *
+ * Shared by the three places /fold-editor builds an entry row, which each carried their
+ * own inline reading of `content` until 2026-08-30 and each got it wrong the same way:
+ * `content.find((part) => part.type === "text")` sliced to 300 characters, so a message
+ * whose first block was not text rendered as an empty row and everything past the first
+ * block was unreachable at any depth. `entryText` accounts for every block and
+ * `entryDetail` serves the rest; this is the summary that sits on the row.
+ */
+function rowPreview(message: unknown): string {
+  return oneLine(entryText(message), EDITOR_ROW_PREVIEW_CHARS);
+}
+
+function resolvedPreCommitNotice(value: unknown): boolean {
+  if (value !== undefined && typeof value !== "boolean") {
+    throw new Error("preCommitNotice must be a boolean: true states the window's status to " +
+      "the agent once per approach to a commit, false ships every fold with the runtime's " +
+      "deterministic brief and puts no carrier in the projection at all");
+  }
+  return value ?? false;
+}
+
+function resolvedToolFoldThreshold(value: unknown): number {
+  const resolved = value ?? DEFAULT_TOOL_FOLD_THRESHOLD;
+  if (typeof resolved !== "number" || !Number.isFinite(resolved) ||
+      resolved < 0 || resolved >= 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");
+  }
+  return resolved;
+}
+
 export function registerActiveContext(pi: any, options: {
   toolName?: string;
   toolLabel?: string;
@@ -237,14 +284,21 @@ export function registerActiveContext(pi: any, options: {
    *  [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 NOTICE SWITCH (public since 2026-08-27 as postFoldNotice; DEFAULT FALSE since
+   *  2026-08-28, Shane, on the sol-20260826-full2 verdict; RESHAPED from a brief
+   *  solicitation into a status statement on 2026-08-30). false is the deterministic
+   *  shape the campaign measured: no carrier reaches the projection at all and every fold
+   *  goes out with the runtime's own words, which drew 14, 14, 9 and 8 correct against
+   *  the soliciting condition's 3. true states the window's status once per approach to a
+   *  commit: where the commit fires, how far away it is, what is staged, what that frees,
+   *  what is pinned and what the pin costs, with the verbs listed and no argument made
+   *  for any of them. Either way the agent verbs stay on the tool. */
+  preCommitNotice?: boolean;
+  /** HOW FAR BEFORE THE COMMIT THE NOTICE SPEAKS (2026-08-30, Shane), as a share of the
+   *  serving budget below maxTarget; default DEFAULT_NOTICE_LEAD_SHARE 0.10. A DISTANCE
+   *  rather than a point, so it tracks a band that moves. Read only when preCommitNotice
+   *  is true. */
+  noticeLeadShare?: number;
 }): {
   projectionCandidates: (ctx: any) => Array<Record<string, unknown>>;
 } {
@@ -253,18 +307,27 @@ 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;
-  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");
+  // THESE THREE ARE THE SETTINGS SURFACE, AND THEY ARE NOT CONSTANTS (2026-08-29). Each
+  // was resolved once here and read from the closure ever after, so a person editing
+  // /fold-settings changed the file and nothing else while the session kept the values
+  // pi booted with. They are `let` so the live applier published below can replace them,
+  // and every reader takes the variable rather than a copy, so a swap reaches the next
+  // snapshot, the next commit decision and the status line without anything else moving.
+  let preCommitNotice = resolvedPreCommitNotice(options.preCommitNotice);
+  let noticeLeadShare = resolveNoticeLeadShare(options.noticeLeadShare);
+  let toolFoldThreshold = resolvedToolFoldThreshold(options.toolFoldThreshold);
+  // THE RENAMED OPTION IS REFUSED BY NAME, not ignored (2026-08-30). postFoldNotice was
+  // public for three days and named a carrier that no longer exists in that shape: it
+  // fired on a fold count, after the cut, and asked for briefs. Silently accepting the
+  // old name would run the new mechanism under a description of the old one, and
+  // silently DROPPING it would turn a deployment that deliberately chose the invitation
+  // into a silent one without saying so.
+  if (Object.hasOwn(options, "postFoldNotice")) {
+    throw new Error("postFoldNotice is now preCommitNotice, and the carrier it switches has " +
+      "changed: it fires on occupancy approaching the commit rather than on a count of " +
+      "unbriefed folds, and it STATES the window's status rather than asking for briefs. " +
+      "The default is still false. noticeLeadShare sets how far ahead of the commit it " +
+      "speaks");
   }
   for (const removed of ["foldScheduling", "foldPeekResults", "toolActions"]) {
     if (Object.hasOwn(options, removed)) {
@@ -324,7 +387,7 @@ export function registerActiveContext(pi: any, options: {
       commandNames.status === commandNames.fold) {
     throw new Error("Active-context command names must be distinct kebab-case strings");
   }
-  const thresholds = resolveThresholds(options.thresholds);
+  let thresholds = resolveThresholds(options.thresholds);
   assertThresholdsServable(thresholds, providerInputBudget ?? servingBudgetTokens(DEFAULT_CONTEXT_WINDOW));
   const stateEntryType = `${entryTypePrefix}-state`;
   const foldRecordEntryType = `${entryTypePrefix}-fold-record`;
@@ -365,6 +428,9 @@ export function registerActiveContext(pi: any, options: {
     bandTopMeasurement: null as unknown,
     /** The snapshot-and-state key whose frontier scan came back empty; see advanceFoldFrontier. */
     frontierEmptyKey: null as string | null,
+    /** The commit count the pre-commit notice last spoke at; null while it is re-armed.
+     *  One notice per approach, and a landed commit begins the next approach. */
+    noticeLatch: null as number | null,
     pendingManual: false,
     preparing: null as { id: string; controller: AbortController; promise: Promise<void> } | null,
     lastPreparationError: null as string | null,
@@ -402,6 +468,13 @@ export function registerActiveContext(pi: any, options: {
       sessionId: string;
       generation: number;
     } | null,
+    // A REFUSED ANCHOR IS NOT AN ABSENT ONE (2026-08-30). The plausibility floor below
+    // rejects a provider count the projected TEXT cannot explain, which is the earliest
+    // and cheapest evidence that what we project is not what reaches the wire. It set
+    // `projectionAnchor = null` and said nothing, and the reading then called itself
+    // "unmeasured", the same word a session uses before its first provider response.
+    // Those are opposite states: one has no number yet, the other has one it disbelieves.
+    anchorRefusal: null as { consecutive: number } | null,
     estimatorErrors: [] as number[],
     inflowSteps: [] as number[],
     wallInflowSteps: [] as number[],
@@ -465,6 +538,8 @@ export function registerActiveContext(pi: any, options: {
   const curation = {
     receipts: [] as ContextReceipt[],
     contextCalls: 0,
+    /** Receipts delivered this session, monotonic; the pre-commit notice's re-arm signal. */
+    commitsDelivered: 0,
     wallEpisodeOpen: false,
     recoveryAttempts: 0,
     pendingRejection: null as { status: number; ordinal: number } | null,
@@ -482,9 +557,6 @@ export function registerActiveContext(pi: any, options: {
     pendingOverflow: null as { at: number; entryId: string | null } | null,
   };
 
-  const advisory = {
-  };
-
   // EPHEMERAL PEEK (Build 4b): tool call ids whose peek asked for one-read
   // visibility. In-memory ON PURPOSE: a restart forgets the registry and the
   // result stays durable, which is the safe default, and the durable entry
@@ -595,6 +667,10 @@ export function registerActiveContext(pi: any, options: {
 
   const deliverReceipt = (receipt: ContextReceipt): void => {
     curation.receipts = withReceipt(curation.receipts, receipt);
+    // MONOTONIC, unlike `curation.receipts.length`, which saturates at MAX_CONTEXT_RECEIPTS
+    // and would stop distinguishing one approach from the next once the session is long
+    // enough to matter. This is the only counter the notice latch reads.
+    curation.commitsDelivered += 1;
     emit("context.receipt", {
       receipt_kind: receipt.kind,
       trigger: receipt.trigger,
@@ -631,6 +707,63 @@ export function registerActiveContext(pi: any, options: {
    * leads now, occupancy is a percentage of the serving budget, and the commit point is
    * named only when it is close enough to matter.
    */
+  /**
+   * THE FOLD BAR (2026-09-02, dogfooding). One widget row directly above the footer,
+   * drawn by `renderFoldBar` from a model this function rebuilds on every status update.
+   * The component reads the model and the LIVE theme at render time, so it repaints on
+   * a theme switch, which the status string cannot; the host is asked to render after
+   * each rebuild. Installed once per host UI, on the first update that finds one.
+   */
+  const foldBar = {
+    model: null as FoldBarModel | null,
+    installed: false,
+    requestRender: null as (() => void) | null,
+  };
+  const installFoldBar = (ctx: any): void => {
+    if (foldBar.installed || typeof ctx.ui?.setWidget !== "function") return;
+    foldBar.installed = true;
+    ctx.ui.setWidget(entryTypePrefix, (tui: any) => {
+      foldBar.requestRender = () => { try { tui.requestRender(); } catch { } };
+      return {
+        render(width: number): string[] {
+          if (!foldBar.model) return [];
+          try { return [renderFoldBar(foldBar.model, width, ctx.ui.theme)]; }
+          catch { return []; }
+        },
+        invalidate() { },
+      };
+    }, { placement: "belowEditor" });
+  };
+  const foldBarModel = (input: {
+    share: number | null; budgetTokens: number; staged: number; roots: number; weighed: boolean;
+  }): FoldBarModel => {
+    const state = persistence.state;
+    const snapshot = lifecycle.latestSnapshot;
+    let stagedTokens = 0;
+    let placeholderChars = 0;
+    let hiddenChars = 0;
+    if (state && snapshot) {
+      for (const mark of pendingMarks(state)) stagedTokens += estimatedTokens(markFreedBytes(snapshot, state, mark));
+      for (const root of orderedRoots(state, snapshot)) placeholderChars += root.fold.placeholderChars;
+      for (const fold of state.folds) hiddenChars += Math.max(0, fold.sourceChars - fold.placeholderChars);
+    }
+    const budget = input.budgetTokens > 0 ? input.budgetTokens : 1;
+    return {
+      brand: brandNoun,
+      share: input.share,
+      commitShare: thresholds.maxTarget,
+      aimShare: thresholds.minTarget,
+      stagedShare: stagedTokens / budget,
+      stagedMarks: input.staged,
+      stagedTokens,
+      foldedShare: estimatedTokens(placeholderChars) / budget,
+      folds: input.roots,
+      hiddenTokens: estimatedTokens(hiddenChars),
+      weighed: input.weighed,
+      stopped: ladder.automaticFailure?.message ?? null,
+    };
+  };
+
   const updateStatus = (ctx: any): void => {
     try {
       const roots = persistence.state && lifecycle.latestSnapshot ? orderedRoots(persistence.state, lifecycle.latestSnapshot).length : 0;
@@ -638,6 +771,17 @@ export function registerActiveContext(pi: any, options: {
       const capacity = currentCapacity(ctx);
       const used = measurements.lastProviderMeasurement?.tokens ?? null;
       const share = used !== null && capacity.budgetTokens > 0 ? used / capacity.budgetTokens : null;
+      try {
+        installFoldBar(ctx);
+        if (foldBar.installed) {
+          foldBar.model = foldBarModel({
+            share, budgetTokens: capacity.budgetTokens, staged, roots,
+            weighed: ladder.bandTopMeasurement !== null &&
+              ladder.bandTopMeasurement === measurements.lastProviderMeasurement,
+          });
+          foldBar.requestRender?.();
+        }
+      } catch { }
       const parts: string[] = [];
       // FAILURE LEADS. This line is cut to whatever width the host gives it, so the last
       // segment is the first one a narrow terminal removes, and folding having stopped is
@@ -646,21 +790,103 @@ export function registerActiveContext(pi: any, options: {
       // Unmeasured is stated, never guessed: an estimate rendered as a fact is the habit
       // that cost a live session, and this line is the most-read surface there is.
       parts.push(share === null ? "not measured" : `${Math.round(share * 100)}% full`);
-      const trigger = lifecycle.latestSnapshot?.thresholds.maxTarget ?? null;
+      // THE LIVE BAND, NOT THE LAST SNAPSHOT'S (2026-08-29). This read the threshold off
+      // `lifecycle.latestSnapshot`, which is derived per context event, so a band changed
+      // in /fold-settings went on being announced at its old value until the next event
+      // rebuilt a snapshot. The number this line owes a person is the one that will fire,
+      // and that is the runtime's own variable.
+      const trigger = thresholds.maxTarget;
       // WHEN, not just how full. "68% full" only answers the second question a reader has
       // if they already remember where the trigger sits; naming it answers both.
       //
       // NOT WHILE STOPPED, though: the line rendered "COMMIT DUE" and "FOLDING STOPPED"
       // in one breath, promising the thing it was announcing would not happen.
-      if (share !== null && trigger !== null && !ladder.automaticFailure) {
-        parts.push(share >= trigger ? "COMMIT DUE" : `commit at ${Math.round(trigger * 100)}%`);
+      // DUE MEANS ABOUT TO HAPPEN, NOT MERELY OVER THE LINE (2026-08-30). This read
+      // `share >= trigger`, which is true of the BAND and says nothing about the
+      // DECISION. A band-top commit runs ONCE per provider count, so once it has run
+      // against the current one, nothing further will happen until a new count arrives,
+      // whatever it applied. Live session 01a052b1 sat on `COMMIT DUE` through 48
+      // consecutive evaluations that all declined for a recorded reason, and a person
+      // reasonably read a line promising an imminent commit as a runtime that had hung.
+      //
+      // The latch is the whole test and no new state is kept: it already holds the
+      // measurement the last band-top commit ran against, for the cache reason documented
+      // at its own site, and "a commit has already been weighed against this count" is
+      // exactly what a reader needs. Held is lower case because it is not urgent; DUE
+      // keeps its shout because it is the one that is about to cost a rewrite.
+      if (share !== null && !ladder.automaticFailure) {
+        const weighed = ladder.bandTopMeasurement !== null &&
+          ladder.bandTopMeasurement === measurements.lastProviderMeasurement;
+        parts.push(share < trigger
+          ? `commit at ${Math.round(trigger * 100)}%`
+          : weighed ? "commit held" : "COMMIT DUE");
       }
       if (staged > 0) parts.push(`${staged} staged`);
       if (roots > 0) parts.push(`${roots} fold${roots === 1 ? "" : "s"}`);
-      ctx.ui?.setStatus?.(entryTypePrefix, `${brandNoun} ${parts.join(" · ")}`);
+      // ONE SURFACE, NOT TWO (Shane 2026-09-02, from a screenshot showing both). Where
+      // the fold bar widget is installed it carries every fact this string carries, so
+      // the string is withdrawn; a host without widgets keeps the string exactly as it was.
+      ctx.ui?.setStatus?.(entryTypePrefix, foldBar.installed ? undefined : `${brandNoun} ${parts.join(" · ")}`);
     } catch { }
   };
 
+  /**
+   * WHAT A PERSON SAVES IN /fold-settings REACHES THIS SESSION (2026-08-29).
+   *
+   * The screen writes the file and then hands the whole file here, so an absent field
+   * means the package default exactly as it does on disk and at registration; all four
+   * values are resolved through the same functions the options went through, which is
+   * what stops a value meaning one thing at boot and another at an edit.
+   *
+   * ATOMIC: every value is validated before any is assigned, so a refusal leaves the
+   * session on the settings it already had rather than half-moved. It throws the way
+   * registration throws, and the caller decides what that means; the settings screen
+   * catches it, because a screen may not take the session down with it.
+   *
+   * The memo is dropped because `authoritativeSnapshotFor` keys on session, entries and
+   * messages, none of which move when a threshold does, so a cached snapshot would serve
+   * the old band to the next reader that asked.
+   */
+  publishLiveSettings(pi, (settings, ctx) => {
+    const nextThresholds = resolveThresholds(settings?.thresholds);
+    assertThresholdsServable(nextThresholds,
+      providerInputBudget ?? servingBudgetTokens(DEFAULT_CONTEXT_WINDOW));
+    const nextToolFoldThreshold = resolvedToolFoldThreshold(settings?.toolFoldThreshold);
+    const nextPreCommitNotice = resolvedPreCommitNotice(settings?.preCommitNotice);
+    const nextNoticeLeadShare = resolveNoticeLeadShare(settings?.noticeLeadShare);
+    const changed: string[] = [];
+    for (const field of ["maxTarget", "minTarget", "consolidateAfter", "minFoldChars"] as const) {
+      if (nextThresholds[field] !== thresholds[field]) changed.push(field);
+    }
+    if (nextToolFoldThreshold !== toolFoldThreshold) changed.push("toolFoldThreshold");
+    if (nextPreCommitNotice !== preCommitNotice) changed.push("preCommitNotice");
+    if (nextNoticeLeadShare !== noticeLeadShare) changed.push("noticeLeadShare");
+    // A SAVE THAT MOVED NOTHING IS NOT AN EVENT. The screen saves every keystroke that
+    // lands, including a row stepped back to where it started.
+    if (!changed.length) return;
+    thresholds = nextThresholds;
+    toolFoldThreshold = nextToolFoldThreshold;
+    preCommitNotice = nextPreCommitNotice;
+    noticeLeadShare = nextNoticeLeadShare;
+    dropDerivationMemo();
+    // THE STREAM CARRIES IT, because from here on the session's commits fire at a point
+    // no earlier record explains, and an archive reading this run later has no other way
+    // to know the band moved under it.
+    emit("context.settings", {
+      changed,
+      max_target: thresholds.maxTarget,
+      min_target: thresholds.minTarget,
+      consolidate_after: thresholds.consolidateAfter,
+      min_fold_chars: thresholds.minFoldChars,
+      tool_fold_threshold: toolFoldThreshold,
+      pre_commit_notice: preCommitNotice,
+      notice_lead_share: noticeLeadShare,
+    });
+    // The person is standing in the settings screen, so the line they will look at next
+    // is the status line. Without this it keeps the old number until a context event.
+    if (ctx) { try { updateStatus(ctx); } catch { } }
+  });
+
   const budgetWindowFor = (ctx: any): number | null => {
     measurements.descriptorWindow = contextWindowFor(ctx);
     return providerInputBudget ?? measurements.descriptorWindow;
@@ -784,6 +1010,10 @@ export function registerActiveContext(pi: any, options: {
     measurements.lastProviderMeasurement = null;
     measurements.wallInflowSteps.length = 0;
     measurements.projectionAnchor = null;
+    // A RESET IS NOT A RESTORATION. The refusal is dropped without a record because the
+    // session it described is gone; emitting "restored" here would report a recovery that
+    // never happened.
+    measurements.anchorRefusal = null;
     measurements.lastProjectedEstimateBasis = "unmeasured";
     ladder.pendingManual = false;
     if (!preserveThresholdDecision) nativeCompaction.lastThresholdDecision = null;
@@ -1332,7 +1562,6 @@ export function registerActiveContext(pi: any, options: {
     safeNotify(ctx, `Automatic context management suspended: ${message}`, "warning");
   };
 
-
   const PROJECTION_CALIBRATION_MIN_CHARS = 20_000;
   const PROJECTION_CALIBRATION_MIN_TOKENS = 5_000;
   const PROJECTION_CHARS_PER_TOKEN_FLOOR = 2;
@@ -1383,6 +1612,41 @@ export function registerActiveContext(pi: any, options: {
     );
   };
 
+  /**
+   * THE REFUSAL SPEAKS ONCE PER EPISODE, NOT ONCE PER PASS (2026-08-30).
+   *
+   * Every request in a divergent stretch refuses the anchor for the same reason, and a
+   * record per pass would be 48 identical lines in the one session that found this. The
+   * edge is what carries information: entering the state, and leaving it with a count of
+   * what it cost. Same shape as `context.suspend`, which repeats only when its message
+   * changes rather than once per pass.
+   */
+  const noteAnchorRefusal = (
+    measurement: ProviderContextMeasurement,
+    textChars: number,
+    images: number,
+  ): void => {
+    const previous = measurements.anchorRefusal;
+    measurements.anchorRefusal = { consecutive: (previous?.consecutive ?? 0) + 1 };
+    if (previous) return;
+    emit("context.anchor", {
+      state: "refused",
+      reason: "text-cannot-explain-count",
+      text_chars: textChars,
+      images,
+      provider_tokens: measurement.tokens,
+      chars_per_token: measurement.tokens > 0 ? textChars / measurement.tokens : null,
+      floor: PROJECTION_CHARS_PER_TOKEN_FLOOR,
+    });
+  };
+
+  const clearAnchorRefusal = (): void => {
+    const refusal = measurements.anchorRefusal;
+    measurements.anchorRefusal = null;
+    if (!refusal) return;
+    emit("context.anchor", { state: "restored", refused_requests: refusal.consecutive });
+  };
+
   const noteProviderProjectionAnchor = (measurement: ProviderContextMeasurement): void => {
     if (measurements.projectionAnchor?.messageSha256 === measurement.messageSha256) return;
     const text = instrumentation.previousText;
@@ -1404,8 +1668,14 @@ export function registerActiveContext(pi: any, options: {
           textChars / (measurement.tokens - images * IMAGE_ESTIMATED_TOKENS) <
             PROJECTION_CHARS_PER_TOKEN_FLOOR)) {
       measurements.projectionAnchor = null;
+      // ONLY A COUNT WE DISBELIEVE IS A REFUSAL. A zero or absent count is simply nothing
+      // to anchor on and stays silent; the floor failing on a positive count is the state
+      // worth announcing, because it means the provider is billing for mass our own
+      // projection does not contain.
+      if (measurement.tokens > 0) noteAnchorRefusal(measurement, textChars, images);
       return;
     }
+    clearAnchorRefusal();
     measurements.projectionAnchor = {
       tokens: measurement.tokens,
       chars,
@@ -1451,7 +1721,16 @@ export function registerActiveContext(pi: any, options: {
     const imageTokens = mass.images * IMAGE_ESTIMATED_TOKENS;
     const estimate = Math.ceil(textChars / charsPerToken) + imageTokens;
     const anchor = measurements.projectionAnchor;
-    if (!anchor || anchor.generation !== lifecycle.generation ||
+    // REFUSED AND UNMEASURED READ THE SAME NUMBER AND MEAN OPPOSITE THINGS. Both fall back
+    // to the character estimate, so the tokens are identical and only the BASIS separates
+    // them: "unmeasured" is a session that has not been told yet, "refused" is one that was
+    // told something its own projection cannot account for. Reading 48 consecutive
+    // "unmeasured" projections as a quiet session is what hid a 19x divergence.
+    if (!anchor) {
+      const basis: ProjectionReadingBasis = measurements.anchorRefusal ? "refused" : "unmeasured";
+      return { tokens: estimate, basis, chars, sizeTokens: estimate, images: mass.images, anchorTokens: null, deltaChars: null, text };
+    }
+    if (anchor.generation !== lifecycle.generation ||
         anchor.sessionId !== persistence.state?.sessionId) {
       return { tokens: estimate, basis: "unmeasured", chars, sizeTokens: estimate, images: mass.images, anchorTokens: null, deltaChars: null, text };
     }
@@ -1535,7 +1814,6 @@ export function registerActiveContext(pi: any, options: {
     };
   };
 
-
   // THE BAND TOP COMMITS ON ITS OWN (Shane, 2026-08-22).
   //
   // `maxTarget` is what the settings panel calls the commit trigger, and until now it
@@ -1634,9 +1912,9 @@ export function registerActiveContext(pi: any, options: {
   };
 
   /**
-   * Tell the agent what was cut, once there is enough of it to be worth a turn.
+   * Tell the agent where the window stands, once per approach to a commit.
    *
-   * It is built from LIVE state, so it names what is unbriefed at the pass it speaks on,
+   * It is built from LIVE state, so it names what is staged at the pass it speaks on,
    * and it is admitted ONCE per frozen projection, so a pass that adds material leaves it
    * buried at its own index rather than moving it to the tail. Those two together mean it
    * is a snapshot rather than a running tally: cuts staged after it spoke wait for the
@@ -1646,19 +1924,54 @@ export function registerActiveContext(pi: any, options: {
    * epoch early. What it must never do is ask twice for a brief the agent has written,
    * and it does not: the rebuild reads the marks, not its own last text.
    */
-  const appendFoldNotice = (projected: unknown[], snapshot: ActiveContextSnapshot): unknown[] => {
+  const appendFoldNotice = (
+    projected: unknown[],
+    snapshot: ActiveContextSnapshot,
+    bodyBytes: number,
+  ): 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;
+    // ever, but no carrier reaches the projection at all.
+    if (!preCommitNotice) return projected;
     if (!persistence.state) return projected;
     const held = pendingMarks(persistence.state);
-    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
-    // carrier is in the frozen projection it is not pushed again, so raw material
-    // arriving afterwards lands after it and the prefix in front of it never moves.
+    const pinnedMass = explicitProtectedMass(snapshot, persistence.state);
+    // NOTHING TO REPORT IS NOT AN OCCASION. With no staged fold and no pin there is no
+    // status: the commit that is coming will apply nothing, and a notice saying so is a
+    // turn's attention spent on the absence of news.
+    if (!held.length && !pinnedMass.refs) return projected;
+    const capacity = servingCapacity(snapshot.contextWindow);
+    if (!(capacity.budgetTokens > 0)) return projected;
+    // THE TRIGGER IS OCCUPANCY, AND IT NAMES ITS OWN BASIS. The provider's count is
+    // ground truth; the estimate is what there is before the first response lands, and
+    // this runtime's standing law is that an estimate MAY SCHEDULE WORK and may not veto
+    // a request. Appending a notice is scheduling. `bodyBytes` is the serialization this
+    // pass already performed for the freeze predicate, so reading a share here adds no
+    // second pass over the window (gate 155's law).
+    const measured = capacity.usedTokens !== null;
+    const usedTokens = measured
+      ? capacity.usedTokens!
+      : Math.ceil(bodyBytes / projectionCharsPerToken());
+    const share = usedTokens / capacity.budgetTokens;
+    // A DISTANCE BELOW THE TRIGGER, floored at zero so a lead wider than the trigger
+    // means "from the first measurement" rather than a negative point nothing crosses.
+    const firePoint = Math.max(0, thresholds.maxTarget - noticeLeadShare);
+    // EDGE TRIGGERED, ONE NOTICE PER APPROACH. A window sits in the band for many passes,
+    // and the freeze breaks whenever the prefix changes, so `carrierAdmitted` alone would
+    // let this re-admit all the way up the band. Two things re-arm it and nothing else:
+    // falling back below the fire point, and a commit landing, which is the event that
+    // ends one approach and begins the next. Without the second, a commit that lands
+    // above the fire point would leave the latch shut for the rest of the session.
+    if (share < firePoint) {
+      ladder.noticeLatch = null;
+      return projected;
+    }
+    if (ladder.noticeLatch !== null && ladder.noticeLatch === curation.commitsDelivered) {
+      return projected;
+    }
+    // APPENDED ONCE PER FROZEN PROJECTION. `carrierAdmitted` is what makes it an APPEND
+    // rather than a rewrite: once the carrier is in the frozen projection it is not
+    // pushed again, so raw material arriving afterwards lands after it and the prefix in
+    // front of it never moves.
     //
     // The first cut of this withdrew the carrier and re-pushed it at the tail every pass,
     // the way the steward band had to because a band must be able to stand down. That is
@@ -1667,23 +1980,42 @@ export function registerActiveContext(pi: any, options: {
     // gates 110 and 111 read the whole projection as rewritten and dropped the occupancy
     // anchor back to the estimate. A carrier that moves on a quiet pass costs the cache,
     // which is the one thing this design exists to avoid.
-    if (unbriefed.length < UNBRIEFED_FOLDS_BEFORE_NOTICE) return projected;
     if (!carrierAdmitted("fold-notice")) return projected;
+    const briefed = (mark: Record<string, unknown>): boolean =>
+      (mark as any).briefProvenance?.kind === "supplied" ||
+      (mark as any).briefProvenance?.kind === "augmented";
+    const staged = held.map((mark) => ({
+      id: mark.id as string,
+      kind: mark.kind as string,
+      tokens: estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)),
+      brief: typeof mark.brief === "string" ? mark.brief : undefined,
+      briefed: briefed(mark),
+    }));
+    // THE SHARE IS MEASURED THE WAY THE CAP MEASURES IT. The notice states the pinned
+    // share against MAX_PINNED_SHARE, and `applyProtectionChange` refuses past that cap
+    // on `explicitProtectedMass`, so quoting the stale-only figure `windowClaims` reports
+    // would put a number beside a cap it is not compared against.
     const text = foldNoticeText({
-      unbriefed: unbriefed.map((mark) => ({
-        id: mark.id,
-        kind: mark.kind,
-        tokens: estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)),
-        brief: typeof mark.brief === "string" ? mark.brief : undefined,
-      })),
-      pending: held.length,
+      staged,
+      freedTokens: staged.reduce((total, fold) => total + fold.tokens, 0),
+      briefedCount: staged.filter((fold) => fold.briefed).length,
+      pinnedEntries: pinnedMass.refs,
+      pinnedShare: estimatedTokens(pinnedMass.bytes) / capacity.budgetTokens,
+      maxPinnedShare: MAX_PINNED_SHARE,
+      headroomTokens: Math.max(0, thresholds.maxTarget * capacity.budgetTokens - usedTokens),
+      commitAtShare: thresholds.maxTarget,
+      measured,
       toolName,
       brandNoun,
     });
+    ladder.noticeLatch = curation.commitsDelivered;
     emit("context.frontier", {
       cut: 0,
       pending_marks: held.length,
-      unbriefed: unbriefed.length,
+      briefed: staged.filter((fold) => fold.briefed).length,
+      occupancy_share: Number(share.toFixed(4)),
+      fire_point_share: firePoint,
+      measured,
       notice_chars: text.length,
     });
     projected.push({
@@ -1699,7 +2031,6 @@ export function registerActiveContext(pi: any, options: {
     return projected;
   };
 
-
   const enforceBandTop = async (
     snapshot: ActiveContextSnapshot,
     ctx: any,
@@ -2044,7 +2375,7 @@ export function registerActiveContext(pi: any, options: {
     freeze.body = body;
     freeze.bodyText = bodyText;
     appendReceipts(projected, snapshot);
-    appendFoldNotice(projected, snapshot);
+    appendFoldNotice(projected, snapshot, bodyText.length);
     return holdFrozen(projected);
   };
   const noteProjection = (projected: unknown[], serialized?: string): void => {
@@ -2737,6 +3068,7 @@ export function registerActiveContext(pi: any, options: {
     measurements.lastProviderMeasurement = null;
     measurements.wallInflowSteps.length = 0;
     measurements.projectionAnchor = null;
+    measurements.anchorRefusal = null;
     nativeCompaction.lastThresholdDecision = null;
     updateStatus(ctx);
   };
@@ -3337,6 +3669,94 @@ export function registerActiveContext(pi: any, options: {
     return removed as Array<Record<string, unknown>>;
   };
 
+  /**
+   * THE DISSOLVE PATH, shared by the tool's single-id reboundary and the editor's re-cut
+   * (2026-08-30). Returning a fold to raw is the first half of re-cutting it, and the
+   * editor already has the second half: `m` on two raw entries stages the span the person
+   * meant. Extracted rather than reimplemented, because the editor's own law is that
+   * every edit is a skin over an existing validated path, and this one carries the nested
+   * refusal, the brief and lease cleanup and the parent re-derivation with it.
+   */
+  const dissolveFold = async (
+    snapshot: ActiveContextSnapshot,
+    id: string,
+    ctx: any,
+  ): Promise<{ children: string[]; startId: string | null; endId: string | null }> => {
+    const fold = requireActiveFold(snapshot, persistence.state!, id);
+    if (fold.parentId) {
+      throw new Error(
+        `Fold ${id} is nested under ${fold.parentId}; dissolve ${fold.parentId} first so ${id} is a root`,
+      );
+    }
+    const refs = flattenFoldRefs(fold, persistence.state!);
+    const children = childFoldIds(fold);
+    const briefs = { ...(persistence.state!.briefs ?? {}) };
+    delete briefs[id];
+    const next: ActiveContextState = {
+      ...persistence.state!,
+      revision: persistence.state!.revision + 1,
+      folds: deriveFoldParents(persistence.state!.folds.filter((item) => item.id !== id)),
+      expanded: persistence.state!.expanded.filter((expandedId) => expandedId !== id),
+      ...(Object.keys(briefs).length ? { briefs } : {}),
+    };
+    if (!Object.keys(briefs).length) delete next.briefs;
+    const leases = { ...next.leases };
+    delete leases[id];
+    await persistManual({ ...next, leases }, ctx);
+    updateStatus(ctx);
+    return { children, startId: refs[0]?.entryId ?? null, endId: refs.at(-1)?.entryId ?? null };
+  };
+
+  /**
+   * THE EXPANSION PATH, shared by the tool's expand/refold actions and the editor's
+   * promote-to-context intent (2026-08-30).
+   *
+   * THIS IS THE ACT THE EDITOR'S OWN EXPANSION IS NOT. Opening a fold row in /fold-editor
+   * moves a key in a Set the view owns: it reveals the fold to the READER and the model
+   * never learns it happened. This restores the fold's raw bytes to the PROJECTION, which
+   * costs the window and is what the lease exists to reclaim. Shane, 2026-08-30: the user
+   * should "page through/expand for their own viewing purposes" while "setting an expanded
+   * fold is a different choice". Two acts, two paths, and this is the one that spends.
+   */
+  const setFoldExpansion = async (
+    snapshot: ActiveContextSnapshot,
+    id: string,
+    expand: boolean,
+    ctx: any,
+  ): Promise<unknown[]> => {
+    let epochApplied: unknown[] = [];
+    if (expand && pendingMarks(persistence.state!).length) {
+      const result = await commitPendingMarks({
+        snapshot,
+        state: persistence.state!,
+        generation: lifecycle.generation,
+        retainIneligible: true,
+      });
+      persistence.state = result.state;
+      epochApplied = result.applied;
+    }
+    const expanding = requireActiveFold(snapshot, persistence.state!, id);
+    if (expand) {
+      admit({
+        action: "expand",
+        ctx,
+        foldId: id,
+        requestedBytes: Math.max(0, expanding.sourceChars - expanding.placeholderChars),
+        children: childFoldIds(expanding),
+      });
+    }
+    let next = setFoldProjectionState(persistence.state!, id, expand ? "expanded" : "folded");
+    if (expand) next = withExpandLease(next, id);
+    else {
+      const leases = { ...next.leases };
+      delete leases[id];
+      next = { ...next, leases };
+    }
+    await persistManual(next, ctx);
+    updateStatus(ctx);
+    return epochApplied;
+  };
+
   /**
    * THE PIN CHANGE PATH, shared by the tool's pin/unpin actions and the editor's
    * pin toggle: the pinned-share cap, protectEvidence, the canonical event, persist.
@@ -3821,36 +4241,15 @@ export function registerActiveContext(pi: any, options: {
       }
       const id = String(params.id ?? "").trim();
       if (!id) throw new Error("reboundary requires id, or ids naming the span to re-cut");
-      const fold = requireActiveFold(snapshot, persistence.state, id);
-      if (fold.parentId) {
-        throw new Error(
-          `Fold ${id} is nested under ${fold.parentId}; dissolve ${fold.parentId} first so ${id} is a root`,
-        );
-      }
-      const refs = flattenFoldRefs(fold, persistence.state);
-      const children = childFoldIds(fold);
-      const briefs = { ...(persistence.state.briefs ?? {}) };
-      delete briefs[id];
-      const next: ActiveContextState = {
-        ...persistence.state,
-        revision: persistence.state.revision + 1,
-        folds: deriveFoldParents(persistence.state.folds.filter((item) => item.id !== id)),
-        expanded: persistence.state.expanded.filter((expandedId) => expandedId !== id),
-        ...(Object.keys(briefs).length ? { briefs } : {}),
-      };
-      if (!Object.keys(briefs).length) delete next.briefs;
-      const leases = { ...next.leases };
-      delete leases[id];
-      await persistManual({ ...next, leases }, ctx);
-      updateStatus(ctx);
+      const dissolved = await dissolveFold(snapshot, id, ctx);
       return toolPayload({
         version: 1,
         action,
         id,
         dissolved: true,
-        releasedChildren: children,
-        startId: refs[0]?.entryId ?? null,
-        endId: refs.at(-1)?.entryId ?? null,
+        releasedChildren: dissolved.children,
+        startId: dissolved.startId,
+        endId: dissolved.endId,
         durableRevision: persistence.state.revision,
         activation: `the span ${id} held is raw again and its boundary is yours to re-cut; ` +
           "fold the endpoints you meant, or two sub-spans to split it. No evidence moved.",
@@ -3859,36 +4258,7 @@ export function registerActiveContext(pi: any, options: {
     if (action === "expand" || action === "refold") {
       const id = String(params.id ?? "").trim();
       if (!id) throw new Error(`${action} requires id`);
-      let epochApplied: unknown[] = [];
-      if (action === "expand" && pendingMarks(persistence.state).length) {
-        const result = await commitPendingMarks({
-          snapshot,
-          state: persistence.state,
-          generation: lifecycle.generation,
-          retainIneligible: true,
-        });
-        persistence.state = result.state;
-        epochApplied = result.applied;
-      }
-      const expanding = requireActiveFold(snapshot, persistence.state, id);
-      if (action === "expand") {
-        admit({
-          action: "expand",
-          ctx,
-          foldId: id,
-          requestedBytes: Math.max(0, expanding.sourceChars - expanding.placeholderChars),
-          children: childFoldIds(expanding),
-        });
-      }
-      let next = setFoldProjectionState(persistence.state, id, action === "expand" ? "expanded" : "folded");
-      if (action === "expand") next = withExpandLease(next, id);
-      else {
-        const leases = { ...next.leases };
-        delete leases[id];
-        next = { ...next, leases };
-      }
-      await persistManual(next, ctx);
-      updateStatus(ctx);
+      const epochApplied = await setFoldExpansion(snapshot, id, action === "expand", ctx);
       return toolPayload({
         version: 1,
         action,
@@ -4219,6 +4589,37 @@ export function registerActiveContext(pi: any, options: {
       tokens: estimatedTokens(spanBytes(snapshot, Math.min(from, to), Math.max(from, to) + 1)),
     });
 
+    /**
+     * THE READER'S OWN DEPTH, AND IT COSTS THE AGENT NOTHING (2026-08-30).
+     *
+     * A row preview is bounded at EDITOR_ROW_PREVIEW_CHARS because it is a SUMMARY, and
+     * the editor used to have nothing behind it: the whole surface stopped at 300
+     * characters of the first text block. This is the way past that. It is an INJECTED
+     * accessor, like `spanCost`, so the view still holds no runtime reference and still
+     * computes nothing it was not handed, and it is a pure READ: it moves no bytes,
+     * writes no state and never touches the projection, so paging an entry to its end
+     * changes nothing the agent will ever see. That separation is the whole point. A
+     * person auditing the window needs to read further than the model is being shown,
+     * and expanding a fold INTO the model's window is a different act with a different
+     * verb (`expand`) and a different cost.
+     *
+     * The cut is STATED rather than silent, which is gate 136's law carried to a surface
+     * a person reads: `total` and `hasMore` travel with the slice.
+     */
+    const entryDetail = (entryId: string, offset = 0, chars = EDITOR_DETAIL_PAGE_CHARS) => {
+      const item = snapshot.mapped.find((candidate) => candidate.ref?.entryId === entryId);
+      if (!item) return null;
+      const whole = entryText(item.message);
+      const from = Math.max(0, Math.min(offset, whole.length));
+      const width = Math.max(1, Math.min(chars, EDITOR_DETAIL_PAGE_CHARS));
+      return {
+        text: whole.slice(from, from + width),
+        offset: from,
+        total: whole.length,
+        hasMore: from + width < whole.length,
+      };
+    };
+
     // Marks move no bytes until the commit, so window geometry cannot change while
     // the editor holds it open; only pending state grows. Rebuilding against the SAME
     // snapshot with fresh state keeps PROPOSED rows honest without re-deriving indices.
@@ -4248,14 +4649,16 @@ export function registerActiveContext(pi: any, options: {
                 const item = exactMapped(snapshot, ref);
                 const message = item?.message as Record<string, unknown> | undefined;
                 const role = String(item?.ref?.role ?? message?.role ?? "entry");
-                const content = message?.content;
-                let preview = "";
-                if (typeof content === "string") preview = content.slice(0, 300);
-                else if (Array.isArray(content)) {
-                  const firstText = content.find((part) => part?.type === "text");
-                  preview = typeof firstText?.text === "string" ? firstText.text.slice(0, 300) : "";
-                }
-                return { id: ref.entryId, role, preview: preview.replace(/\s+/g, " ") };
+                // A FOLD'S ENTRY IS A MARK POINT AND A PIN POINT TOO (2026-08-30). It
+                // carried no index and no entry id the view could act on, so `p` was
+                // inert on every row inside an expanded fold while working one row over
+                // in a raw gap, for no reason a reader could see.
+                return {
+                  id: ref.entryId,
+                  role,
+                  preview: rowPreview(item?.message),
+                  ...(item ? { index: item.index } : {}),
+                };
               });
             return {
               id: String(row.id),
@@ -4264,6 +4667,16 @@ export function registerActiveContext(pi: any, options: {
               sourceCount: Number(row.sourceCount ?? 0),
               startPosition: Number(row.startPosition),
               endPosition: Number(row.endPosition),
+              // WHAT THE AGENT IS ACTUALLY LOOKING AT (2026-08-30). A fold the agent has
+              // expanded is standing RAW in its window, and the editor rendered it
+              // identically to one that is still a placeholder, so the one surface built
+              // to show a person the model's window could not show them this about it.
+              expandedInContext: (state.expanded ?? []).includes(String(row.id)),
+              // WHERE THE BRIEF CAME FROM. Given the campaign verdict on agent-written
+              // briefs, which sentence is the runtime's and which is the model's is the
+              // fact a person auditing this window most needs, and it was not on the
+              // surface at all.
+              provenance: String((fold as any).briefProvenance?.kind ?? "deterministic"),
               entries,
             };
           }),
@@ -4289,21 +4702,12 @@ export function registerActiveContext(pi: any, options: {
               if (!item) continue;
               const message = item.message as Record<string, unknown> | undefined;
               const role = String(item.ref?.role ?? message?.role ?? "entry");
-              const content = message?.content;
-              // 300 chars, same as fold entries: the view shows 48 on the row and
-              // deepens to 240 on Enter, so a 48-char preview made detail a no-op.
-              let preview = "";
-              if (typeof content === "string") preview = content.slice(0, 300);
-              else if (Array.isArray(content)) {
-                const firstText = content.find((part) => part?.type === "text");
-                preview = typeof firstText?.text === "string" ? firstText.text.slice(0, 300) : "";
-              }
               // THE INDEX IS THE MARK POINT: raw entries carry their mapped position so
               // the view can price a span and name its two boundary ids.
               out.push({
                 id: item.ref?.entryId ?? String(index),
                 role,
-                preview: preview.replace(/\s+/g, " "),
+                preview: rowPreview(message),
                 ...(item.ref?.entryId ? { index } : {}),
               });
             }
@@ -4319,6 +4723,9 @@ export function registerActiveContext(pi: any, options: {
           freedTokens: accounting.freedTokens,
         },
         pinned: state.protected.map((ref) => ref.entryId),
+        // THE FOLDS THE AGENT HAS STANDING RAW IN ITS WINDOW, so the editor can say which
+        // rows are placeholders and which are already costing the projection.
+        expandedInContext: [...(state.expanded ?? [])],
       };
     };
 
@@ -4333,6 +4740,35 @@ export function registerActiveContext(pi: any, options: {
     };
     const editorActions = {
       spanCost,
+      entryDetail,
+      // THE READER'S EXPANSION AND THE WINDOW'S ARE DIFFERENT ACTS, and this is the second
+      // one: it restores the fold's raw bytes to the model's projection and takes the
+      // lease that reclaims them at the next commit. The view's own open/close key never
+      // reaches here.
+      onSetExpanded: async (foldId: string, expand: boolean): Promise<void> => {
+        await runQueued(async () => {
+          await setFoldExpansion(authoritativeSnapshotFor(ctx), foldId, expand, ctx);
+        });
+        safeNotify(ctx, expand
+          ? "Expanded in the model's window: its exact bytes are back in the projection, " +
+            "reclaimed at the next commit unless pinned."
+          : "Refolded: the placeholder stands where the bytes were, still peek-recoverable.",
+        "info");
+        refreshAfter();
+      },
+      // RE-CUT IS DISSOLVE PLUS MARK, and the editor already has the second half: `m` on
+      // two raw entries stages the span the person meant. This is the first half, through
+      // the tool's own validated path.
+      onDissolveFold: async (foldId: string): Promise<void> => {
+        let released: string[] = [];
+        await runQueued(async () => {
+          released = (await dissolveFold(authoritativeSnapshotFor(ctx), foldId, ctx)).children;
+        });
+        safeNotify(ctx,
+          `The span is raw again${released.length ? `, releasing ${released.length} nested fold(s)` : ""}; ` +
+          "no evidence moved. Mark the boundary you meant with m.", "info");
+        refreshAfter();
+      },
       onStageMark: async (fromId: string, toId: string, brief?: string): Promise<void> => {
         await runQueued(async () => {
           const fresh = authoritativeSnapshotFor(ctx);
@@ -4357,11 +4793,24 @@ export function registerActiveContext(pi: any, options: {
           `Withdrew ${removed.length} staged mark(s); no context bytes moved.`, "info");
         refreshAfter();
       },
-      onTogglePin: async (entryId: string): Promise<void> => {
-        const pinnedAlready = persistence.state!.protected
-          .some((ref: any) => ref.entryId === entryId);
+      onTogglePin: async (id: string): Promise<void> => {
+        // A TOGGLE HAS TO ASK THE SAME QUESTION THE PIN PATH ANSWERS (2026-08-30). This
+        // read `protected.some((ref) => ref.entryId === id)`, which is only ever true for
+        // an ENTRY id, and `protectEvidence` has always taken a FOLD id too, holding
+        // every ref underneath it. So the moment the editor started offering p on a fold
+        // row, the second press pinned the same refs again instead of releasing them: the
+        // question was asked about an id that is never in the set being searched.
+        const state = persistence.state!;
+        const fold = state.folds.find((item: any) => item.id === id);
+        const held = new Set(state.protected.map((ref: any) => objectRefKey(ref)));
+        const refs = fold
+          ? flattenFoldRefs(fold, state)
+          : state.protected.filter((ref: any) => ref.entryId === id);
+        const pinnedAlready = fold
+          ? refs.length > 0 && refs.every((ref: any) => held.has(objectRefKey(ref)))
+          : refs.length > 0;
         await runQueued(async () => {
-          await applyProtectionChange(authoritativeSnapshotFor(ctx), [entryId], !pinnedAlready, ctx);
+          await applyProtectionChange(authoritativeSnapshotFor(ctx), [id], !pinnedAlready, ctx);
         });
         safeNotify(ctx, pinnedAlready
           ? "Unpinned: the released entries rejoin the next commit's candidates."
@@ -4414,6 +4863,8 @@ export function registerActiveContext(pi: any, options: {
     lifecycle.latestSnapshot = null;
     curation.receipts = [];
     try { ctx.ui?.setStatus?.(entryTypePrefix, undefined); } catch { }
+    foldBar.model = null;
+    foldBar.requestRender?.();
   });
 
   return { projectionCandidates };