pi-fold 3.1.0 → 4.1.0

package/extensions/active-context.ts

@@ -46,6 +46,7 @@ import {
   explicitProtectedMass,
   budgetOccupancy,
   hardFenceRatio,
+  imageMass,
   latestProviderContextMeasurement,
   orderedRoots,
   parseNativeCompactionCompletion,
@@ -91,7 +92,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,
@@ -105,6 +108,7 @@ import {
   resolveThresholds,
   servingBudgetTokens,
   ESTIMATED_BYTES_PER_TOKEN,
+  IMAGE_ESTIMATED_TOKENS,
   entryTypeNamespace,
   MAX_FOLD_SPAN_CHARS,
   DEFAULT_TOOL_FOLD_THRESHOLD,
@@ -116,10 +120,6 @@ import {
   RETIRED_TOOL_ACTIONS,
   AUTO_FOLD_BLACKLIST_DEFAULT,
   USER_RESCUE_MAX_SOURCE_CHARS,
-  MEMORY_BODY_CHARS,
-  MEMORY_KEY_CHARS,
-  MEMORY_KEYS_MAX,
-  WORKING_MEMORY_TOOL_ACTIONS,
 } from "./lib/policy.ts";
 import type {
   ActiveContextSnapshot,
@@ -131,7 +131,6 @@ import type {
   FoldKind,
   FoldRecordEntry,
   PreparedFold,
-  WorkingMemoryEntry,
 } from "./lib/policy.ts";
 import {
   absorbWedgeMarks,
@@ -140,7 +139,7 @@ import {
 import {
   contextReceipt,
   foldNoticeText,
-  memoryTocText,
+  foldStatusText,
   receiptBlockText,
   withReceipt,
 } from "./lib/curation.ts";
@@ -174,6 +173,7 @@ import {
 } from "./lib/scheduling.ts";
 import {
   manualFoldCandidate,
+  oneLine,
   peekedSourceFoldIds,
   snapFoldCandidate,
   snapToFoldBoundaries,
@@ -197,7 +197,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 {
@@ -209,12 +211,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";
@@ -223,6 +226,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;
@@ -239,21 +283,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 WORKING MEMORY (Shane, 2026-08-26): a session-scoped ordered dictionary the
-   *  agent maintains beside the fold index. `remember` writes or removes an entry,
-   *  `recall` reads bodies on demand, and the projection carries one table of contents
-   *  that refreshes at each commit. Off when absent: the digest channel earned its
-   *  place in a measured gap (running tallies lost 0/6 against native's 6/6 while the
-   *  index won everything else), and it must stay separable from the index it is not. */
-  workingMemory?: boolean;
+  /** 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>>;
 } {
@@ -262,23 +306,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;
-  if (options.workingMemory !== undefined && typeof options.workingMemory !== "boolean") {
-    throw new Error("workingMemory must be a boolean: it enables the session-scoped " +
-      "working-memory dictionary and its two actions, remember and recall");
-  }
-  const workingMemory = options.workingMemory === true;
-  const toolFoldThreshold = options.toolFoldThreshold ?? DEFAULT_TOOL_FOLD_THRESHOLD;
-  if (typeof toolFoldThreshold !== "number" || !Number.isFinite(toolFoldThreshold) ||
-      toolFoldThreshold < 0 || toolFoldThreshold >= 1) {
-    throw new Error("toolFoldThreshold must be a share in [0, 1): it names the oldest " +
-      "fraction of the projected window whose tool results are clipped in view at each " +
-      "commit, and 0 turns the diet off");
+  // 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)) {
@@ -338,14 +386,13 @@ 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`;
   const milestoneProjectionType = `${entryTypePrefix}-milestone`;
   const advisoryProjectionType = `${entryTypePrefix}-advisory`;
   const foldNoticeProjectionType = `${entryTypePrefix}-fold-notice`;
-  const memoryTocProjectionType = `${entryTypePrefix}-memory-toc`;
   const receiptProjectionType = `${entryTypePrefix}-receipts`;
   const curationProjectionType = `${entryTypePrefix}-curation`;
   const entryNamespace = entryTypeNamespace(entryTypePrefix);
@@ -353,9 +400,7 @@ export function registerActiveContext(pi: any, options: {
   const nativeReceiptEntryType = `${entryNamespace}-native-compaction-receipt`;
   const contextEventEntryType = `${entryNamespace}-context-event`;
   const nativeDecisionEntryType = `${entryNamespace}-native-compaction-decision`;
-  const allowedToolActions: readonly ActiveContextToolAction[] = workingMemory
-    ? [...ACTIVE_CONTEXT_TOOL_ACTIONS, ...WORKING_MEMORY_TOOL_ACTIONS]
-    : ACTIVE_CONTEXT_TOOL_ACTIONS;
+  const allowedToolActions: readonly ActiveContextToolAction[] = ACTIVE_CONTEXT_TOOL_ACTIONS;
   const allowedToolActionSet = new Set<string>(allowedToolActions);
 
   type AutomaticFailureState = {
@@ -382,6 +427,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,
@@ -401,6 +449,7 @@ export function registerActiveContext(pi: any, options: {
     lastProviderMeasurement: null as ProviderContextMeasurement | null,
     descriptorWindow: null as number | null,
     lastProjectedChars: null as number | null,
+    lastProjectedImages: 0,
     projectionCalibrations: [] as Array<{ chars: number; tokens: number }>,
     lastProjectedEstimate: null as number | null,
     lastProjectedEstimateCalibrated: false,
@@ -409,11 +458,22 @@ export function registerActiveContext(pi: any, options: {
     projectionAnchor: null as {
       tokens: number;
       chars: number;
+      /** `chars` less the base64 of any image, which is what the delta is taken on. */
+      textChars: number;
+      /** Images inside the anchored prefix, each worth IMAGE_ESTIMATED_TOKENS. */
+      images: number;
       head: string;
       messageSha256: string;
       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[],
@@ -428,6 +488,10 @@ export function registerActiveContext(pi: any, options: {
     ledger: emptyLedger(),
     previousDigests: null as string[] | null,
     previousText: null as string | null,
+    // The image mass of `previousText`, kept beside it because the provider anchor is
+    // built from that text and has no access to the array it came from.
+    previousImages: 0,
+    previousImageChars: 0,
     lastChange: "append" as ProjectionChange,
     lastPreservedShare: null as number | null,
     sinceHandoff: [] as Array<{
@@ -473,6 +537,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,
@@ -490,12 +556,6 @@ export function registerActiveContext(pi: any, options: {
     pendingOverflow: null as { at: number; entryId: string | null } | null,
   };
 
-  const advisory = {
-    hardFenceNoticeKey: null as string | null,
-    hardFenceReleaseSessionId: null as string | null,
-    hardFenceReleasedProjectionKeys: new Set<string>(),
-  };
-
   // 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
@@ -606,6 +666,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,
@@ -632,18 +696,125 @@ export function registerActiveContext(pi: any, options: {
     lifecycle.generation === expectedGeneration && persistence.state?.sessionId === sessionId &&
     (!ctx || contextSessionMatches(ctx, sessionId));
 
+  /**
+   * THE ONE LINE THAT IS ALWAYS ON SCREEN, so it answers the question a person actually
+   * has: how full am I, and is anything about to happen.
+   *
+   * It used to read `pi_fold_context folds: 3 · provider 187234/272000`. That led with the
+   * AGENT TOOL'S NAME, which a person cannot call and does not care about, and then spent
+   * its remaining width on two raw counts they would have to divide themselves. The brand
+   * leads now, occupancy is a percentage of the serving budget, and the commit point is
+   * named only when it is close enough to matter.
+   */
   const updateStatus = (ctx: any): void => {
     try {
       const roots = persistence.state && lifecycle.latestSnapshot ? orderedRoots(persistence.state, lifecycle.latestSnapshot).length : 0;
-      const prepared = persistence.state?.prepared ? " · brief ready" : ladder.preparing ? " · briefing" : "";
-      const usage = measurements.lastProviderMeasurement
-        ? ` · provider ${measurements.lastProviderMeasurement.tokens}/${measurements.lastProviderMeasurement.contextWindow}`
-        : " · provider usage unmeasured";
-      const suspended = ladder.automaticFailure ? " · automatic suspended" : "";
-      ctx.ui?.setStatus?.(entryTypePrefix, `${toolName} folds: ${roots}${prepared}${usage}${suspended}`);
+      const staged = persistence.state ? pendingMarks(persistence.state).length : 0;
+      const capacity = currentCapacity(ctx);
+      const used = measurements.lastProviderMeasurement?.tokens ?? null;
+      const share = used !== null && capacity.budgetTokens > 0 ? used / capacity.budgetTokens : null;
+      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
+      // the one state on this line a person has to act on. It was appended last.
+      if (ladder.automaticFailure) parts.push("FOLDING STOPPED");
+      // 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`);
+      // 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.
+      // 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(" · ")}`);
     } 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;
@@ -767,6 +938,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;
@@ -779,6 +954,8 @@ export function registerActiveContext(pi: any, options: {
     instrumentation.ledger = emptyLedger();
     instrumentation.previousDigests = null;
     instrumentation.previousText = null;
+    instrumentation.previousImages = 0;
+    instrumentation.previousImageChars = 0;
     instrumentation.requests = 0;
     instrumentation.lastMutationRequest = 0;
     instrumentation.lastMutationTokens = null;
@@ -793,16 +970,11 @@ export function registerActiveContext(pi: any, options: {
     curation.lastRecovery = null;
     ladder.lastAutomaticAction = null;
     ladder.automaticFailure = null;
-    advisory.hardFenceNoticeKey = null;
     measurements.providerMeasurementReceipts.clear();
     measurements.providerMeasurementRevisionByMessageSha.clear();
     measurements.providerMeasurementByMessageSha.clear();
     measurements.providerMeasurementAnchorByMessageSha.clear();
     const sessionId = ctx.sessionManager.getSessionId();
-    if (advisory.hardFenceReleaseSessionId !== sessionId) {
-      advisory.hardFenceReleaseSessionId = sessionId;
-      advisory.hardFenceReleasedProjectionKeys.clear();
-    }
     let restored: ActiveContextState | null = null;
     let restoreError: unknown = null;
     let restoredPersistence: MaterializedStatePersistence | null = null;
@@ -1318,54 +1490,6 @@ export function registerActiveContext(pi: any, options: {
     safeNotify(ctx, `Automatic context management suspended: ${message}`, "warning");
   };
 
-  const abortUnsafeHardContext = (
-    snapshot: ActiveContextSnapshot | null,
-    ctx: any,
-    allowUnmeasuredRevisionRelease = false,
-  ): boolean => {
-    if (measurements.latestRatio === null || measurements.latestRatio < hardFenceRatio(snapshot ?? undefined, ctx) || !persistence.state) return false;
-    const measuredRevision = measurements.lastProviderMeasurement
-      ? measurements.providerMeasurementRevisionByMessageSha.get(measurements.lastProviderMeasurement.messageSha256)
-      : undefined;
-    if (allowUnmeasuredRevisionRelease && !ladder.automaticFailure &&
-        measuredRevision !== undefined && measurements.lastProviderMeasurement &&
-        !durableProviderMeasurementMatches(measurements.lastProviderMeasurement)) {
-      const releaseKey = sha256Value({
-        sessionId: persistence.state.sessionId,
-        topologySha256: topologySha256(persistence.state),
-        protectionSha256: protectionSha256(persistence.state),
-        measuredRevision,
-        providerMessageSha256: measurements.lastProviderMeasurement?.messageSha256 ?? null,
-      });
-      if (!advisory.hardFenceReleasedProjectionKeys.has(releaseKey) &&
-          advisory.hardFenceReleasedProjectionKeys.size < 4_096) {
-        advisory.hardFenceReleasedProjectionKeys.add(releaseKey);
-        return false;
-      }
-    }
-    const key = ladder.automaticFailure?.key ?? sha256Value({
-      sessionId: snapshot?.sessionId ?? persistence.state.sessionId,
-      revision: persistence.state.revision,
-      providerMessageSha256: measurements.lastProviderMeasurement?.messageSha256 ?? null,
-      phase: "hard-provider-fence",
-    });
-    ladder.pendingContextNote = `Provider context reached the hard ${brandNoun} fence without a newly committed lossless fold. ` +
-      "The provider request was aborted before transmission; run /compact or make an explicit bounded context fold.";
-    if (advisory.hardFenceNoticeKey !== key) {
-      advisory.hardFenceNoticeKey = key;
-      safeNotify(
-        ctx,
-        "Provider request aborted at the hard context fence; run /compact or make an explicit bounded context fold.",
-        "error",
-      );
-    }
-    if (typeof ctx.abort !== "function") {
-      throw new Error(`Pi hard-fence abort capability is unavailable at ratio ${measurements.latestRatio}`);
-    }
-    ctx.abort();
-    return true;
-  };
-
   const PROJECTION_CALIBRATION_MIN_CHARS = 20_000;
   const PROJECTION_CALIBRATION_MIN_TOKENS = 5_000;
   const PROJECTION_CHARS_PER_TOKEN_FLOOR = 2;
@@ -1385,6 +1509,12 @@ export function registerActiveContext(pi: any, options: {
     }
     const chars = measurements.lastProjectedChars;
     if (chars === null || chars < PROJECTION_CALIBRATION_MIN_CHARS) return;
+    // NEVER LEARN THE RATIO FROM A WINDOW HOLDING AN IMAGE. chars/token is a fact about
+    // prose; a projection carrying base64 has a far higher true ratio, and because
+    // projectionCharsPerToken takes the MINIMUM over the window such a sample is either
+    // discarded (leaving the over-read in place) or, once images dominate, poisons the
+    // ratio for the text around them. The clean rule is to calibrate on text alone.
+    if (measurements.lastProjectedImages > 0) return;
     if (!Number.isFinite(measurement.tokens) || measurement.tokens < PROJECTION_CALIBRATION_MIN_TOKENS) return;
     if (measurements.lastProjectedEstimate !== null && measurements.lastProjectedEstimateCalibrated &&
         measurement.tokens > 0) {
@@ -1410,6 +1540,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;
@@ -1418,13 +1583,32 @@ export function registerActiveContext(pi: any, options: {
       return;
     }
     const chars = bytes(text);
-    if (!(measurement.tokens > 0) || chars / measurement.tokens < PROJECTION_CHARS_PER_TOKEN_FLOOR) {
+    // The anchor is differenced against TEXT characters, so it must store them. The mass
+    // belongs to the same `previousText` this anchor is built from, recorded by
+    // noteProjection when that text was produced.
+    const textChars = Math.max(0, chars - instrumentation.previousImageChars);
+    const images = instrumentation.previousImages;
+    // The floor test reads TEXT against tokens: an image-heavy projection has a raw ratio
+    // far above any prose floor and would sail through a test that is meant to reject a
+    // measurement the text cannot explain.
+    if (!(measurement.tokens > 0) ||
+        (measurement.tokens > images * IMAGE_ESTIMATED_TOKENS &&
+          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,
+      textChars,
+      images,
       head: text.slice(0, -1),
       messageSha256: measurement.messageSha256,
       sessionId: persistence.state.sessionId,
@@ -1446,6 +1630,9 @@ export function registerActiveContext(pi: any, options: {
     tokens: number;
     basis: ProjectionReadingBasis;
     chars: number;
+    /** The image-corrected size of THIS projection, independent of any anchor. */
+    sizeTokens: number;
+    images: number;
     anchorTokens: number | null;
     deltaChars: number | null;
     text: string;
@@ -1453,21 +1640,43 @@ export function registerActiveContext(pi: any, options: {
     const text = serialized ?? stableStringify(projected);
     const chars = Buffer.byteLength(text, "utf8");
     const charsPerToken = projectionCharsPerToken();
-    const estimate = Math.ceil(chars / charsPerToken);
+    // AN IMAGE IS NOT TEXT (2026-08-28, see imageMass). Its base64 leaves the character
+    // count and comes back as a flat per-image cost, because dividing base64 by a ratio
+    // learned from prose read one screenshot as 110,000 tokens against a true 1,500 and
+    // aborted a session that was less than half full.
+    const mass = imageMass(projected);
+    const textChars = Math.max(0, chars - mass.base64Chars);
+    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, anchorTokens: null, deltaChars: null, text };
+      return { tokens: estimate, basis: "unmeasured", chars, sizeTokens: estimate, images: mass.images, anchorTokens: null, deltaChars: null, text };
     }
     const separator = text.length > anchor.head.length ? text[anchor.head.length] : "";
     if (!text.startsWith(anchor.head) || (separator !== "," && separator !== "]")) {
-      return { tokens: estimate, basis: "rewritten", chars, anchorTokens: anchor.tokens, deltaChars: null, text };
+      return { tokens: estimate, basis: "rewritten", chars, sizeTokens: estimate, images: mass.images, anchorTokens: anchor.tokens, deltaChars: null, text };
     }
-    const deltaChars = chars - anchor.chars;
+    // The delta is taken on TEXT characters and images separately, so an image arriving
+    // after the anchor costs its own flat price rather than its base64 length.
+    const deltaChars = textChars - anchor.textChars;
+    const deltaImages = mass.images - anchor.images;
     return {
-      tokens: Math.max(0, anchor.tokens + Math.ceil(deltaChars / charsPerToken)),
+      tokens: Math.max(0, anchor.tokens + Math.ceil(deltaChars / charsPerToken) +
+        deltaImages * IMAGE_ESTIMATED_TOKENS),
       basis: "anchored",
       chars,
+      sizeTokens: estimate,
+      images: mass.images,
       anchorTokens: anchor.tokens,
       deltaChars,
       text,
@@ -1517,7 +1726,7 @@ export function registerActiveContext(pi: any, options: {
       : Number.POSITIVE_INFINITY;
     const reading = projectedTokenReading(projected, serialized);
     const tokens = reading.tokens;
-    const sizeTokens = Math.ceil(reading.chars / projectionCharsPerToken());
+    const sizeTokens = reading.sizeTokens;
     const marginTokens = Number.isFinite(budgetTokens)
       ? projectionMarginTokens(tokens, capacity.window)
       : 0;
@@ -1533,41 +1742,6 @@ export function registerActiveContext(pi: any, options: {
     };
   };
 
-  const abortOverBudgetProjection = (
-    tokens: number,
-    budgetTokens: number,
-    ctx: any,
-    recoveryAttempts = 0,
-  ): void => {
-    const key = sha256Value({
-      sessionId: persistence.state?.sessionId ?? null,
-      revision: persistence.state?.revision ?? null,
-      tokens,
-      budgetTokens,
-      phase: "projection-budget-fence",
-    });
-    ladder.pendingContextNote =
-      `The ${brandNoun} projection estimates ${tokens} tokens against a ${budgetTokens}-token serving budget` +
-      (recoveryAttempts
-        ? `, after ${recoveryAttempts} recovery attempt(s) that folded everything foldable. The remaining ` +
-          "inflow does not fit at any folding depth, which is an impossibility rather than a recoverable state."
-        : ".") +
-      " The provider request was aborted before transmission; run /compact or make an explicit bounded context fold.";
-    if (advisory.hardFenceNoticeKey !== key) {
-      advisory.hardFenceNoticeKey = key;
-      safeNotify(
-        ctx,
-        "Provider request aborted: the projection exceeds the serving budget. " +
-        "Run /compact or make an explicit bounded context fold.",
-        "error",
-      );
-    }
-    if (typeof ctx.abort !== "function") {
-      throw new Error(`Pi projection-budget abort capability is unavailable at ${tokens} estimated tokens`);
-    }
-    ctx.abort();
-  };
-
   // 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
@@ -1666,9 +1840,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
@@ -1678,19 +1852,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
@@ -1699,23 +1908,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({
@@ -1731,42 +1959,6 @@ export function registerActiveContext(pi: any, options: {
     return projected;
   };
 
-  /**
-   * THE TABLE OF CONTENTS IS ONE COPY PER COMMIT (Shane, 2026-08-26). It is admitted
-   * once per frozen projection, exactly as the fold notice above, and that admission
-   * rule IS the refresh law: between commits the copy stays buried at its index, so a
-   * quiet pass moves no byte and costs no occupancy anchor, and the tool result of every
-   * `remember` carries the live key list in the meantime. A commit rewrites the
-   * projection, the freeze drops, the body filter strips the old copy, and the next pass
-   * seats a fresh one at the tail with the latest keys. Nothing here re-renders in
-   * place, because a carrier that moves on a quiet pass is the exact defect the fold
-   * notice's comment records.
-   */
-  const appendMemoryToc = (projected: unknown[], snapshot: ActiveContextSnapshot): unknown[] => {
-    if (!workingMemory) return projected;
-    if (!persistence.state) return projected;
-    const held = persistence.state.memory ?? [];
-    if (!held.length) return projected;
-    if (!carrierAdmitted("memory-toc")) return projected;
-    const entries = [...held].sort((left, right) => right.ordinal - left.ordinal);
-    const text = memoryTocText({
-      entries: entries.map((entry) => ({ key: entry.key, chars: entry.body.length })),
-      toolName,
-      brandNoun,
-    });
-    projected.push({
-      role: "custom",
-      customType: memoryTocProjectionType,
-      content: text,
-      display: false,
-      details: { source: activeContextSource(entryTypePrefix), ephemeral: true },
-      timestamp: typeof ownValue(snapshot.messages.at(-1), "timestamp") === "number"
-        ? ownValue(snapshot.messages.at(-1), "timestamp")
-        : 0,
-    });
-    return projected;
-  };
-
   const enforceBandTop = async (
     snapshot: ActiveContextSnapshot,
     ctx: any,
@@ -1805,10 +1997,10 @@ export function registerActiveContext(pi: any, options: {
     snapshot: ActiveContextSnapshot,
     projected: unknown[],
     ctx: any,
-  ): Promise<{ projected: unknown[]; aborted: boolean; text: string }> => {
+  ): Promise<{ projected: unknown[]; text: string }> => {
     let measured = projectionExceedsBudget(projected, ctx);
     const rejected = curation.pendingRejection !== null;
-    if (!measured.crowded && !rejected) return { projected, aborted: false, text: measured.text };
+    if (!measured.crowded && !rejected) return { projected, text: measured.text };
     const trigger = measured;
     let reduced = projected;
     let attempts = 0;
@@ -1912,11 +2104,24 @@ export function registerActiveContext(pi: any, options: {
       }));
       curation.pendingRejection = null;
     }
-    // `measured` is recomputed on `reduced` at every turn of the loop above, so its text is
-    // the serialization of the array both of these exits return.
-    if (!measured.over) return { projected: reduced, aborted: false, text: measured.text };
-    abortOverBudgetProjection(measured.tokens, measured.budgetTokens, ctx, attempts);
-    return { projected: reduced, aborted: true, text: measured.text };
+    // THE RUNTIME COMMITS AND TRANSMITS; ONLY THE PROVIDER REFUSES (Shane, 2026-08-28).
+    //
+    // This used to abort the request when the projection still read over budget after the
+    // loop. It was deleted because it let an ESTIMATE veto a request that ground truth
+    // would have accepted: a live session read 220,883 tokens where the provider counted
+    // 111,837, was refused before transmission, and could not be rescued, because the
+    // commit before the refusal had applied 28 marks and the next applied 0. The advice it
+    // printed, fold manually or run /compact, named the two things the mechanism had just
+    // proven it could not do.
+    //
+    // maxTarget is a TRIGGER meaning "commit now", not a bound meaning "refuse to
+    // proceed", and only the first is something an estimate can be right about. What
+    // remains is the loop above, which commits everything it can reach; the request then
+    // goes to the provider, and a genuine overflow is handled by the rejection path, which
+    // branches back, folds and retries on the provider's own count rather than ours.
+    // `measured` is recomputed on `reduced` at every turn of the loop, so its text is the
+    // serialization of the array this returns.
+    return { projected: reduced, text: measured.text };
   };
 
   const startPreparation = (snapshot: ActiveContextSnapshot, ratio: number | null, ctx: any): void => {
@@ -2071,7 +2276,7 @@ export function registerActiveContext(pi: any, options: {
       const customType = ownValue(message, "customType");
       return customType !== milestoneProjectionType && customType !== advisoryProjectionType &&
         customType !== receiptProjectionType && customType !== curationProjectionType &&
-        customType !== foldNoticeProjectionType && customType !== memoryTocProjectionType;
+        customType !== foldNoticeProjectionType;
     });
     const withdrawn = withdrawConsumedEphemeralPeeks(body);
     if (withdrawn.size && freeze.body) {
@@ -2098,8 +2303,7 @@ export function registerActiveContext(pi: any, options: {
     freeze.body = body;
     freeze.bodyText = bodyText;
     appendReceipts(projected, snapshot);
-    appendFoldNotice(projected, snapshot);
-    appendMemoryToc(projected, snapshot);
+    appendFoldNotice(projected, snapshot, bodyText.length);
     return holdFrozen(projected);
   };
   const noteProjection = (projected: unknown[], serialized?: string): void => {
@@ -2792,6 +2996,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);
   };
@@ -2888,11 +3093,6 @@ export function registerActiveContext(pi: any, options: {
       try { projected = projectWithAdvisory(snapshot); }
       catch (error) {
         suspendAutomatic(error, "projection", ctx);
-        abortUnsafeHardContext(snapshot, ctx);
-        return { messages: event.messages };
-      }
-      if (abortUnsafeHardContext(snapshot, ctx, true)) {
-        updateStatus(ctx);
         return { messages: event.messages };
       }
       // THE FRONTIER CUTS FIRST, and it costs the projection nothing to do so: a pending
@@ -2908,7 +3108,6 @@ export function registerActiveContext(pi: any, options: {
         try { projected = projectWithAdvisory(snapshot); }
         catch (error) {
           suspendAutomatic(error, "projection", ctx);
-          abortUnsafeHardContext(snapshot, ctx);
           return { messages: event.messages };
         }
       }
@@ -2916,14 +3115,13 @@ export function registerActiveContext(pi: any, options: {
       projected = budgeted.projected;
       const reading = projectedTokenReading(projected, budgeted.text);
       measurements.lastProjectedChars = reading.chars;
+      measurements.lastProjectedImages = reading.images;
       measurements.lastProjectedEstimate = reading.tokens;
       measurements.lastProjectedEstimateBasis = reading.basis;
-      measurements.lastProjectedSizeTokens = Math.ceil(reading.chars / projectionCharsPerToken());
+      // The size is the reading's own image-corrected figure. Recomputing it from raw
+      // chars here is what fed base64 straight into the fence's own accounting.
+      measurements.lastProjectedSizeTokens = reading.sizeTokens;
       measurements.lastProjectedEstimateCalibrated = measurements.projectionCalibrations.length > 0;
-      if (budgeted.aborted) {
-        updateStatus(ctx);
-        return { messages: projected };
-      }
       noteProjection(projected, budgeted.text);
       updateStatus(ctx);
       return { messages: projected };
@@ -2937,7 +3135,6 @@ export function registerActiveContext(pi: any, options: {
         if (!persistedSucceeded) ladder.boundaryFailure = lifecycle.latestSnapshotError;
         suspendAutomatic(error, persistedSucceeded ? "post-persist-projection" : "context", ctx);
       }
-      abortUnsafeHardContext(lifecycle.latestSnapshot, ctx);
       return { messages: event.messages };
     }
   };
@@ -3400,6 +3597,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.
@@ -3884,36 +4169,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.",
@@ -3922,36 +4186,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,
@@ -4081,102 +4316,6 @@ export function registerActiveContext(pi: any, options: {
           "reaches it only when the commit folds this span. Nothing in your context moved.",
       });
     }
-    if (action === "remember") {
-      // THE DIGEST'S OWN CHANNEL. A working-memory write is durable state outside the
-      // projection, so like `brief` it moves no bytes and costs no prefix cache: the
-      // table of contents the projection carries refreshes at the next commit, and this
-      // result carries the live key list in the meantime.
-      const key = String(params.key ?? "").trim();
-      if (!key) throw new Error("remember needs a key");
-      if (key.length > MEMORY_KEY_CHARS) {
-        throw new Error(`Working-memory keys have a hard ${MEMORY_KEY_CHARS}-character ` +
-          "maximum: the key is a table-of-contents line, not the note. Put the detail " +
-          "in the body.");
-      }
-      const body = String(params.body ?? "").trim();
-      if (body.length > MEMORY_BODY_CHARS) {
-        throw new Error(`Working-memory bodies have a hard ${MEMORY_BODY_CHARS}-character ` +
-          `maximum and this one is ${body.length}. Split the entry, or keep the part ` +
-          "that changes and let the transcript carry the rest: folded material stays " +
-          "losslessly recoverable by peek.");
-      }
-      const held = persistence.state!.memory ?? [];
-      const existing = held.find((entry) => entry.key === key);
-      let nextMemory: WorkingMemoryEntry[];
-      if (!body) {
-        if (!existing) {
-          throw new Error(`No working-memory entry '${key}' to remove. ${held.length
-            ? `The keys are: ${held.map((entry) => entry.key).join(", ")}.`
-            : "Working memory is empty."}`);
-        }
-        nextMemory = held.filter((entry) => entry.key !== key);
-      } else {
-        if (!existing && held.length >= MEMORY_KEYS_MAX) {
-          throw new Error(`Working memory holds its maximum of ${MEMORY_KEYS_MAX} ` +
-            "entries. Merge two entries, or remove one whose facts no longer matter " +
-            `(${toolName} {"action":"remember","key":"<key>","body":""}), then write ` +
-            "this one.");
-        }
-        const ordinal = held.reduce((max, entry) => Math.max(max, entry.ordinal), 0) + 1;
-        nextMemory = existing
-          ? held.map((entry) => entry.key === key ? { key, body, ordinal } : entry)
-          : [...held, { key, body, ordinal }];
-      }
-      const nextState = {
-        ...persistence.state!,
-        revision: persistence.state!.revision + 1,
-        ...(nextMemory.length ? { memory: nextMemory } : {}),
-      };
-      if (!nextMemory.length) delete (nextState as Partial<ActiveContextState>).memory;
-      persistence.state = nextState;
-      await persistManual(nextState, ctx);
-      updateStatus(ctx);
-      const toc = [...nextMemory].sort((left, right) => right.ordinal - left.ordinal)
-        .map((entry) => ({ key: entry.key, chars: entry.body.length }));
-      return toolPayload({
-        version: 1,
-        action,
-        key,
-        ...(body ? { chars: body.length } : { removed: true }),
-        argumentsSha256: executionArgumentsSha256,
-        durableRevision: persistence.state!.revision,
-        entries: toc,
-        activation: body
-          ? "durable immediately, and it costs your window nothing: the body lives in " +
-            "state, this list is the live view, and the table of contents in your " +
-            "context refreshes at the next commit."
-          : "removed. The table of contents in your context refreshes at the next commit.",
-      });
-    }
-    if (action === "recall") {
-      const held = persistence.state!.memory ?? [];
-      if (!held.length) {
-        throw new Error(`Working memory is empty. Write an entry with ${toolName} ` +
-          '{"action":"remember","key":"<key>","body":"..."}.');
-      }
-      const requested = params.keys === undefined && params.key === undefined
-        ? null
-        : (denseOwnArrayValues(params.keys) ?? [params.key ?? params.keys])
-          .map((value) => String(value ?? "").trim()).filter(Boolean);
-      const entries = [...held].sort((left, right) => right.ordinal - left.ordinal);
-      const chosen = requested === null
-        ? entries
-        : entries.filter((entry) => requested.includes(entry.key));
-      if (requested !== null) {
-        const missing = requested.filter((key) => !held.some((entry) => entry.key === key));
-        if (missing.length) {
-          throw new Error(`No working-memory entr${missing.length === 1 ? "y" : "ies"} ` +
-            `${missing.join(", ")}. The keys are: ` +
-            `${entries.map((entry) => entry.key).join(", ")}.`);
-        }
-      }
-      return toolPayload({
-        version: 1,
-        action,
-        argumentsSha256: executionArgumentsSha256,
-        entries: chosen.map((entry) => ({ key: entry.key, chars: entry.body.length, body: entry.body })),
-      });
-    }
     throw new Error(`Unknown ${toolName} action '${action}'`);
   };
   const toolHandler = async (
@@ -4232,12 +4371,24 @@ export function registerActiveContext(pi: any, options: {
     try {
       const snapshot = authoritativeSnapshotFor(ctx);
       const status = activeContextStatus(snapshot, persistence.state, 0, 40);
-      safeNotify(
-        ctx,
-        `Active context: ${status.totalFolds} fold(s), roots ${(status.roots as string[]).join(", ") || "none"}. ` +
-          `Use ${toolName} status for exact recursive actions.`,
-        "info",
-      );
+      const capacity = currentCapacity(ctx);
+      const staged = pendingMarks(persistence.state);
+      safeNotify(ctx, foldStatusText({
+        brand: brandNoun,
+        usedTokens: measurements.lastProviderMeasurement?.tokens ?? null,
+        budgetTokens: capacity.budgetTokens,
+        commitAtShare: snapshot.thresholds.maxTarget,
+        aimShare: snapshot.thresholds.minTarget,
+        roots: (status.roots as string[]).length,
+        totalFolds: Number(status.totalFolds ?? 0),
+        stagedMarks: staged.length,
+        stagedTokens: staged.reduce((total, mark) =>
+          total + estimatedTokens(markFreedBytes(snapshot, persistence.state!, mark)), 0),
+        pinned: persistence.state.protected.length,
+        suspended: ladder.automaticFailure?.message ?? null,
+        foldCommand: `/${commandNames.fold}`,
+        editorCommand: "/fold-editor",
+      }), "info");
     } catch (error) {
       safeNotify(ctx, `Active-context status unavailable; native Pi context is unchanged: ${String(error)}`, "warning");
     }
@@ -4366,6 +4517,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.
@@ -4377,12 +4559,15 @@ export function registerActiveContext(pi: any, options: {
         : null;
       const accounting = markAccounting(snapshot, state);
       return {
-        title: `pi-fold context editor · ${snapshot.sessionId.slice(0, 8)}`,
+        // NO SESSION ID. Eight hex characters of a value a person never types, on the
+        // title line of the surface, is the same defect the rows below it just lost.
+        title: `${brandNoun} window`,
         occupancy: {
           usedTokens: capacity.usedTokens,
           budgetTokens: capacity.budgetTokens,
           commitOccupancy: thresholds.maxTarget,
           commitDue: occupancy !== null && occupancy >= thresholds.maxTarget,
+          suspended: Boolean(ladder.automaticFailure),
         },
         blocks: buildFoldEditorData(snapshot, state, {
           foldRows: () => (state.folds ?? []).map((fold: any) => {
@@ -4392,14 +4577,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),
@@ -4408,6 +4595,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,
             };
           }),
@@ -4433,21 +4630,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 } : {}),
               });
             }
@@ -4463,6 +4651,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 ?? [])],
       };
     };
 
@@ -4477,6 +4668,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);
@@ -4501,11 +4721,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."