diff --git a/changelog.d/unsent-compiles-dry-run.fixed.md b/changelog.d/unsent-compiles-dry-run.fixed.md
new file mode 100644
index 000000000..58c3249e1
--- /dev/null
+++ b/changelog.d/unsent-compiles-dry-run.fixed.md
@@ -0,0 +1,62 @@
+- Compiles that are never sent are now dry runs (context-manager's
+  `SelectOptions.dryRun`): `previewActivation`, which undo, rollback and
+  hiding messages also run for their "last visible" line; the API's
+  `message.list` and agent context commands; and a conversation fork's seed
+  (the template's compile and the new namespace's emptiness check). A
+  committing compile persists fold resolutions and queues the compression its
+  fold plan calls for. Once context-manager's thinking binding
+  (anima-research/context-manager#160, not yet released) ships, it will also
+  commit stamps and join the branch's compiles awaiting acceptance, where one
+  never sent can cost a live stream's later replies their thinking. A dry run
+  does none of that, and it leaves the agent's consumed watermark and a
+  prepared budget change alone, as `previewActivation` already promised; a
+  preview at the live window used to settle a converging budget change.
+  `ActivationRequestOptions` gains `dryRun`.
+- With context-manager 0.14, a dry run leaves what a select leaves behind as
+  the last committing compile left it: no chunk record, no calibration, and
+  none of the bookkeeping the next compile or an observer reads. The one thing
+  it can still leave is the release of a compression hold whose deadline has
+  passed, as any compile does.
+- Under the autobiographical strategy, a dry run still refuses a budget the
+  context can't fit, as a committing compile does: context-manager skips only
+  its post-pick check, and an adaptive fold plan that doesn't fit then
+  overruns at the middle's emission, with a refusal that names the tokens and
+  the limit. So at such a budget a preview, `message.list` and the API's agent
+  context command still fail, and a fork whose template's fold plan doesn't
+  fit the default budget its seed is compiled at still fails to spawn.
+  Windowed passthrough, though, skips its refusal of a newest message larger
+  than the budget on a dry run: where they failed on such a message, a
+  preview, `message.list` and the agent context command now return it alone,
+  larger than the budget, and a fork is seeded with it. Passthrough, the
+  default strategy, keeps the newest messages that fit, as before.
+- A conversation fork's seed no longer copies the template's `thinking` and
+  `redacted_thinking` blocks, and leaves out a message with no content left.
+  A fork inherits the template's conversation, not its reasoning. A signed
+  block was minted under the template's prefix, which the fork's system
+  prompt, tools and scoped injections don't promise to match, so on an
+  account that enforces thinking binding the fork's first request could be
+  refused (inferred from probes of other requests, not observed on a fork).
+  Unsigned reasoning, from text-only providers or XML mode, goes by the same
+  rule. On models that don't bind thinking to its prefix (by probes, Fable 5
+  and Sonnet 5), a copy would have been kept, so there the fork loses the
+  template's reasoning. That a provider accepts the stripped seed rests on
+  probes of two shapes, each sent without its thinking: an assistant text
+  turn followed by a new user turn, on Sonnet 5.5, Fable 5.1, Fable 5 and
+  Sonnet 5; and a tool round, a `tool_use` with no thinking before it and
+  its result, continued by the model, on those four, Opus 5.5 and Haiku 5.5.
+  Other thinking models weren't probed.
+- On the OpenAI Responses path, the seed's items that were paired with a
+  reasoning item it left out (the message's text, a function call) lose
+  their provider-native raw item and render from their fields, so the fork
+  replays no item id whose reasoning is gone. Opaque items, such as a
+  compaction or a hosted tool's call, keep theirs.
+- A fork's seed keeps no tool call whose result isn't in it, and no result
+  whose call isn't (context-manager's `stripUnpairedToolBlocks`): the rest of
+  their messages stays, and a message left with nothing becomes
+  `[tool call omitted]`. A fork spawned while the template was between a
+  tool round's call and its results (the coalescer can spawn one outside the
+  event loop) gave the fork's first request an unanswered call under the
+  passthrough strategies.
+- A fork's spawn logs one line when its seed left something out:
+  `[conversation] <fork>: seeded from <template> without N thinking
+  block(s), N unanswered tool call(s) and N orphaned tool result(s)`.
diff --git a/src/agent.ts b/src/agent.ts
index 8e75d3369..9780d879d 100644
--- a/src/agent.ts
+++ b/src/agent.ts
@@ -20,6 +20,9 @@ import {
 export interface ActivationRequestOptions {
   /** The silent heartbeat tick this request answers, if any. */
   silentHeartbeat?: SilentHeartbeatTick;
+  /** A request that will never be sent (a preview): compile it as a dry
+   *  run (see `compileWithInjections` for what that leaves alone). */
+  dryRun?: boolean;
 }
 
 export interface StartStreamResult {
@@ -827,6 +830,11 @@ export class Agent {
     }
   }
 
+  /** A committing compile, as for a request that is sent: the context
+   * manager commits what it commits for one, the consumed watermark moves,
+   * and a prepared budget change settles. To inspect what the agent would
+   * see, use the framework's `previewActivation`, which compiles as a dry
+   * run. */
   async compileContext(budget?: TokenBudget): Promise<CompileResult> {
     // RFC-006 §3.3: consumption is determined at assembly — a compile that
     // fails assembled nothing, so the watermark moves only on success.
@@ -838,18 +846,42 @@ export class Agent {
   }
 
   /**
-   * Compile the context with injections.
-   * Same as compileContext but forwards injections (e.g. from MCPL servers)
-   * to the context manager so they are merged into the compiled messages.
+   * Compile the context with injections (e.g. from MCPL servers), which the
+   * context manager merges into the compiled messages. Without
+   * `opts.dryRun` it commits as `compileContext` does: the consumed
+   * watermark moves, and a compile at the live window settles a prepared
+   * budget change. With `opts.dryRun`, for a compile that will never be
+   * sent, it does neither (see below).
    */
   async compileWithInjections(
     budget?: TokenBudget,
     injections?: ContextInjection[],
-    opts?: { kvUnifiedImmutablePrefixHash?: string },
+    opts?: { kvUnifiedImmutablePrefixHash?: string; dryRun?: boolean },
   ): Promise<CompileResult> {
-    const watermark = this.pendingWatermark();
+    // A dry run is a compile that will never be sent. The context manager
+    // persists no fold resolutions for it and queues none of the compression
+    // or merge work its fold plan calls for. Its thinking binding
+    // (context-manager#160, not yet released) will commit stamps and add a
+    // compile awaiting acceptance for a committing compile only. Here nothing
+    // moves either: the agent never read what a dry run assembled, so the
+    // consumed watermark stays. A dry run proves nothing about the budget
+    // either, so it goes straight to the compile, around
+    // compileAtLiveBudget: it settles no descent (a prepared budget change
+    // waits for the compile that is sent), notes no compiled budget, and
+    // restores nothing the boot applied at once, whether it fits or is
+    // refused.
+    //
+    // Context-manager 0.14 leaves what a select leaves behind as the last
+    // committing compile left it, on every path out of a dry run, throws
+    // included: no chunk record and no compression queued for a chunk the
+    // dry run closes, no calibration, and none of the bookkeeping the next
+    // compile or an observer reads (its `SelectOptions.dryRun` gives the
+    // contract). The one thing a dry run can still leave is the release of a
+    // compression hold whose deadline has passed, which `compile` does for
+    // any compile before it selects.
+    const watermark = opts?.dryRun ? null : this.pendingWatermark();
     const compile = () => this.contextManager.compile(this.compileBudget(budget), injections, opts as never);
-    const result = budget ? await compile() : await this.compileAtLiveBudget(compile);
+    const result = budget || opts?.dryRun ? await compile() : await this.compileAtLiveBudget(compile);
     if (watermark) this.consumedWatermark = watermark;
     return result;
   }
@@ -1035,10 +1067,13 @@ export class Agent {
    *
    * This is the single source of truth for request assembly, shared by the
    * real activation path (`startStreamWithInjections`) and debug/preview
-   * tooling (`Framework.previewActivation`). It is pure and non-mutating:
-   * it does not touch agent state and does not call the membrane, and
-   * `ContextManager.compile` is itself side-effect-free (compression runs in
-   * the background). Safe to call regardless of the agent's current status.
+   * tooling (`Framework.previewActivation`). It does not call the membrane.
+   * A compile that is sent commits what the context manager commits for it
+   * (fold resolutions, the compression its fold plan calls for, the consumed
+   * watermark); a preview passes `options.dryRun`, so its compile commits
+   * none of that (see `compileWithInjections` for what a dry run still
+   * leaves). Either way the context manager is handed the compression tool
+   * definitions. Safe to call regardless of the agent's current status.
    * It doesn't wait for the tool-result guard's annotations, so a preview
    * never waits on a workspace write (rollback, undo and redo report one), and
    * may show a withheld stub before its place is added; the activation waits
@@ -1079,7 +1114,12 @@ export class Agent {
     let { messages, systemInjections } = await this.compileWithInjections(
       budget,
       injections,
-      immutablePrefixHash ? { kvUnifiedImmutablePrefixHash: immutablePrefixHash } : undefined,
+      immutablePrefixHash || options.dryRun
+        ? {
+            ...(immutablePrefixHash ? { kvUnifiedImmutablePrefixHash: immutablePrefixHash } : {}),
+            ...(options.dryRun ? { dryRun: true } : {}),
+          }
+        : undefined,
     );
 
     // Sanitize: strip empty/whitespace text blocks and drop messages left with
diff --git a/src/api/mcp-server.ts b/src/api/mcp-server.ts
index e0df861c0..2332ea557 100644
--- a/src/api/mcp-server.ts
+++ b/src/api/mcp-server.ts
@@ -391,7 +391,12 @@ export class McpServer {
             },
             maxTokens: {
               type: 'number',
-              description: 'Maximum tokens to include (optional)',
+              description:
+                "A hypothetical budget to compile the context at (optional; without it, the context manager's " +
+                "default of 100000, not the agent's own window). Under the autobiographical strategy, a budget " +
+                "the context can't fit fails the call with the context manager's refusal, which names the tokens " +
+                'and the limit. Passthrough keeps the newest messages that fit (none, if the newest alone is ' +
+                'larger), and windowed passthrough returns the newest message alone, larger than the budget.',
             },
           },
           required: ['agentName'],
diff --git a/src/api/server.ts b/src/api/server.ts
index 5b59d236e..b67e04b50 100644
--- a/src/api/server.ts
+++ b/src/api/server.ts
@@ -497,7 +497,11 @@ export class ApiServer {
     }
 
     const contextManager = agent.getContextManager();
-    const { messages } = await contextManager.compile();
+    // A dry run: listed, never sent, so it persists no fold resolutions and
+    // queues none of the compression its fold plan calls for (see
+    // Agent.compileWithInjections for what a dry run still leaves, and for
+    // context-manager#160's thinking binding).
+    const { messages } = await contextManager.compile(undefined, undefined, { dryRun: true });
 
     const limit = params?.limit ?? 50;
     const offset = params?.offset ?? 0;
@@ -705,10 +709,21 @@ export class ApiServer {
     }
 
     const contextManager = agent.getContextManager();
+    // A dry run: shown, never sent, so it persists no fold resolutions and
+    // queues none of the compression its fold plan calls for, at a
+    // hypothetical budget least of all (see Agent.compileWithInjections for
+    // what a dry run still leaves). Under the autobiographical strategy, a
+    // budget the context can't fit still throws: a dry run skips only
+    // context-manager's post-pick check, and an adaptive fold plan that
+    // doesn't fit then overruns at the middle's emission. Windowed
+    // passthrough's newest message alone is the one window that comes back
+    // larger than the budget.
     const { messages } = await contextManager.compile(
       params.maxTokens
         ? { maxTokens: params.maxTokens, reserveForResponse: 4096 }
-        : undefined
+        : undefined,
+      undefined,
+      { dryRun: true },
     );
 
     return { context: messages };
diff --git a/src/api/types.ts b/src/api/types.ts
index 21079d291..4dccb8e4b 100644
--- a/src/api/types.ts
+++ b/src/api/types.ts
@@ -147,7 +147,15 @@ export interface BranchDeleteParams {
 export interface AgentContextParams {
   /** Agent name */
   agentName: string;
-  /** Maximum tokens to include (optional) */
+  /** A hypothetical budget to compile the context at (optional). Without it
+   *  the context compiles at context-manager's default budget (100,000, with
+   *  4,000 reserved for the response), not the agent's own window. The
+   *  compile is a dry run. Under the autobiographical strategy, a budget the
+   *  context can't fit still fails the command, with context-manager's
+   *  refusal, which names the tokens and the limit. Passthrough keeps the
+   *  newest messages that fit (none, if the newest alone is larger), and
+   *  windowed passthrough returns the newest message alone, larger than the
+   *  budget. */
   maxTokens?: number;
 }
 
diff --git a/src/framework.ts b/src/framework.ts
index e120c52cc..04089b36c 100644
--- a/src/framework.ts
+++ b/src/framework.ts
@@ -6,7 +6,7 @@ import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeF
 import { JsStore } from '@animalabs/chronicle';
 import type { Membrane, ContentBlock, NormalizedRequest, YieldingStream, ToolResult as MembraneToolResult, ToolResultContentBlock } from '@animalabs/membrane';
 import { MembraneError } from '@animalabs/membrane';
-import { ContextManager, PassthroughStrategy, WindowedPassthroughStrategy, OverBudgetError, UncoveredDropError } from '@animalabs/context-manager';
+import { ContextManager, PassthroughStrategy, WindowedPassthroughStrategy, OverBudgetError, UncoveredDropError, stripUnpairedToolBlocks } from '@animalabs/context-manager';
 import type { CacheWireReceipt } from './kv-unified-wire.js';
 import type { SilentHeartbeatStamp } from './silent-heartbeat.js';
 import { SUBCONSCIOUS_TOOLS, SUBCONSCIOUS_TOOL_NAMES, type SubconsciousConfig } from './tune-out/tools.js';
@@ -638,6 +638,80 @@ function normalizeDiscordAwarenessDeadline(value: number | undefined): number {
   );
 }
 
+/** Messages copied into another conversation (a fork's seed) without their
+ *  `thinking` and `redacted_thinking` blocks: a fork inherits the template's
+ *  conversation, not its reasoning. A signed block was minted under the
+ *  template's prefix, which the fork's doesn't promise to match; unsigned
+ *  reasoning (text-only providers, XML mode) goes by the same rule. On the
+ *  OpenAI Responses path a removed block also carried the reasoning item
+ *  (`rawItem`) the message's other items were paired with by id, so in a
+ *  message that lost its thinking those items lose their `rawItem` and render
+ *  from their fields, without ids; an opaque carrier (a text block whose raw
+ *  item isn't a `message`, such as a compaction) keeps it, since the raw item
+ *  is its whole content. An Anthropic or XML-mode message's thinking carries
+ *  no raw item, and its only raw items are such carriers (membrane keeps a
+ *  block it has no type for, such as a `server_tool_use`, that way), so it
+ *  loses only its thinking. A message with no content left, whether
+ *  the filter emptied it or it was already empty, is left out, since a
+ *  request can't carry an empty message; any other message without thinking
+ *  is kept as it was. */
+function withoutThinking<M extends { content: ContentBlock[] }>(messages: readonly M[]): M[] {
+  const out: M[] = [];
+  for (const message of messages) {
+    const content = message.content.filter((b) => !isThinkingBlock(b));
+    if (content.length === 0) continue;
+    out.push(content.length === message.content.length
+      ? message
+      : { ...message, content: content.map(releasePairedRawItem) });
+  }
+  return out;
+}
+
+function isThinkingBlock(block: ContentBlock): boolean {
+  return block.type === 'thinking' || block.type === 'redacted_thinking';
+}
+
+function rawItemOf(block: ContentBlock): unknown {
+  return (block as { rawItem?: unknown }).rawItem;
+}
+
+/** A block without the provider-native item it was parsed from, unless that
+ *  item is the block's whole content: an opaque carrier, a text block whose
+ *  raw item isn't a `message` item (membrane keeps compaction and other items
+ *  it has no block for that way). */
+function releasePairedRawItem(block: ContentBlock): ContentBlock {
+  const raw = rawItemOf(block);
+  if (raw === undefined) return block;
+  const rawType = typeof raw === 'object' && raw !== null ? (raw as { type?: unknown }).type : undefined;
+  if (block.type === 'text' && rawType !== 'message') return block;
+  const { rawItem: _released, ...rest } = block as ContentBlock & { rawItem?: unknown };
+  return rest as ContentBlock;
+}
+
+/** One log line for a fork's seed that left something out, so an operator who
+ *  sees a fork answer differently from its template has something to check:
+ *  the template's thinking blocks, and the tool blocks the pairing pass
+ *  dropped (calls with no result in the seed, results whose call isn't in
+ *  it). `withoutReasoning` is the seed before that pass, `seed` after it. */
+function logSeedOmissions(
+  fork: string,
+  template: string,
+  compiled: readonly { content: ContentBlock[] }[],
+  withoutReasoning: readonly { content: ContentBlock[] }[],
+  seed: readonly { content: ContentBlock[] }[],
+): void {
+  const count = (messages: readonly { content: ContentBlock[] }[], test: (b: ContentBlock) => boolean) =>
+    messages.reduce((n, m) => n + m.content.filter(test).length, 0);
+  const thinking = count(compiled, isThinkingBlock);
+  const calls = count(withoutReasoning, (b) => b.type === 'tool_use') - count(seed, (b) => b.type === 'tool_use');
+  const results = count(withoutReasoning, (b) => b.type === 'tool_result') - count(seed, (b) => b.type === 'tool_result');
+  if (thinking + calls + results === 0) return;
+  console.log(
+    `[conversation] ${fork}: seeded from ${template} without ${thinking} thinking block(s), ` +
+    `${calls} unanswered tool call(s) and ${results} orphaned tool result(s)`,
+  );
+}
+
 class DiscordAwarenessAccountingError extends Error {
   constructor(operation: string, cause: unknown) {
     const detail = cause instanceof Error ? cause.message : String(cause);
@@ -4796,13 +4870,28 @@ export class AgentFramework {
    * were activated right now — WITHOUT running inference, opening a stream, or
    * mutating agent state. Intended for debug/preview tooling.
    *
-   * Transparency contract (default): the preview is side-effect-free and
-   * leaves no trace on the system. It does only read-only work —
-   * `ContextManager.compile` (which never triggers compression itself;
-   * compression runs in the background out-of-band), tool filtering, and
-   * system-prompt assembly — then delegates to `Agent.buildActivationRequest`.
-   * No tokens are spent, nothing is written to Chronicle, and no external
-   * MCPL server is contacted.
+   * What a preview commits (default): nothing of its own. It compiles as a
+   * dry run (`dryRun`), filters tools and assembles the system prompt, then
+   * delegates to `Agent.buildActivationRequest`. No tokens are spent, no
+   * external MCPL server is contacted, no fold resolution is persisted and
+   * none of the compression its fold plan calls for is queued; the consumed
+   * watermark and any prepared budget change are left alone; and once
+   * context-manager's thinking binding (context-manager#160, not yet
+   * released) ships, no stamps are committed and no compile awaits
+   * acceptance. In context-manager 0.14 its dry run leaves nothing else
+   * behind but the release of an expired compression hold, as any compile
+   * does (see `Agent.compileWithInjections`). The preview keeps in-memory
+   * bookkeeping of its own, such as handing the context manager the
+   * compression tool definitions, as every activation request does.
+   * Under the autobiographical strategy, a budget the context can't fit
+   * still throws, as for a committing compile: a dry run skips only
+   * context-manager's post-pick check, and an adaptive fold plan that
+   * doesn't fit then overruns at the middle's emission, with a refusal that
+   * names the tokens and the limit. Windowed passthrough's newest message
+   * alone is the one window that comes back larger than the budget. For a
+   * verdict instead of the refusal, `previewContextSettings` returns
+   * context-manager's own at a budget, with the agent's `maxTokens` reserved
+   * for the response.
    *
    * The trade-off is fidelity: the dynamically-gathered ContextInjection[]
    * (module `gatherContext` + MCPL `beforeInference` hooks) are NOT included
@@ -4833,13 +4922,15 @@ export class AgentFramework {
     };
 
     // An explicit budget compiles against a HYPOTHETICAL window instead of the
-    // agent's live one. That also suppresses transition-settling in
-    // compileWithInjections (which only settles when no budget is passed), so
-    // previewing a smaller window cannot advance a converging descent.
-    // Default: no dynamic injection gathering → fully transparent (no
-    // inference, no Chronicle writes, no external RPC). Opt in explicitly.
+    // agent's live one. Every preview is a dry run, so none of them settles
+    // a converging descent or commits what a sent compile commits (see the
+    // doc comment above).
+    // Default: no dynamic injection gathering → no inference, no Chronicle
+    // writes of its own, no external RPC. Opt in explicitly.
     if (!opts?.injections) {
-      return capture(await agent.buildActivationRequest(tools, undefined, opts?.budget, presentation?.available ?? tools));
+      return capture(await agent.buildActivationRequest(
+        tools, undefined, opts?.budget, presentation?.available ?? tools, { dryRun: true },
+      ));
     }
 
     // Full-fidelity path: mirrors startAgentStream's injection gathering.
@@ -4874,7 +4965,9 @@ export class AgentFramework {
       }
     }
 
-    return capture(await agent.buildActivationRequest(tools, injections, opts?.budget, presentation?.available ?? tools));
+    return capture(await agent.buildActivationRequest(
+      tools, injections, opts?.budget, presentation?.available ?? tools, { dryRun: true },
+    ));
   }
 
   /**
@@ -4884,9 +4977,11 @@ export class AgentFramework {
    *
    * Unlike `previewActivation` (which renders a request), this returns the
    * picker's plan: resulting tokens, whether it fits, how many summaries would
-   * have to be produced first, and the per-chunk fold levels. Commits nothing:
-   * no resolution persistence, no compression enqueue, no transition
-   * bookkeeping — see `AutobiographicalStrategy.previewContext`.
+   * have to be produced first, and the per-chunk fold levels. It commits
+   * nothing: its select is a dry run, which in context-manager 0.14 leaves
+   * what a select leaves behind as the last committing compile left it —
+   * see `AutobiographicalStrategy.previewContext` and
+   * `Agent.compileWithInjections`.
    *
    * Returns null when the agent's strategy has no fold plan (non-adaptive).
    */
@@ -8902,9 +8997,10 @@ export class AgentFramework {
   /**
    * Spawn a persistent per-channel conversation agent ("fork") from the
    * template agent: own ContextManager under `conversations/{name}`, seeded
-   * with a copy of the template's compiled context (the SubagentModule
-   * wholesale-copy pattern), registered in the event loop like any agent —
-   * but never primary.
+   * with the template's compiled context without its thinking or its unpaired
+   * tool blocks (the SubagentModule wholesale-copy pattern; see the seeding
+   * comment below), registered in the event loop like any agent — but never
+   * primary.
    */
   private async createConversationAgent(name: string, channelId: string): Promise<Agent> {
     const router = this.conversationRouter!;
@@ -8938,14 +9034,54 @@ export class AgentFramework {
       // persisted precisely so names aren't reused, but if this namespace has
       // history anyway (counter state lost, crash between spawn and persist),
       // seeding again would stack another template copy on top of it.
-      const { messages: existing } = await contextManager.compile();
+      //
+      // Both compiles are dry runs: neither is sent, and the template's runs
+      // while the template may be mid-stream, where a committing compile
+      // would commit fold resolutions and queue the compression its fold plan
+      // calls for (and, once context-manager's thinking binding ships, fence
+      // its stream's replies). In context-manager 0.14 a dry run leaves
+      // nothing else behind but the release of an expired compression hold
+      // (see Agent.compileWithInjections), so the template's request in
+      // flight keeps its calibration estimate.
+      // The template's compile runs at context-manager's default budget (none
+      // is passed), and a dry run still refuses a budget it can't fit: it
+      // skips only the post-pick check, and an adaptive fold plan that
+      // doesn't fit then overruns at the middle's emission. So a template
+      // whose fold plan doesn't fit that budget fails the spawn with
+      // context-manager's refusal, which names the tokens and the limit, as
+      // a committing compile failed it. Only a windowed-passthrough template
+      // whose newest message alone exceeds it seeds that message, larger than
+      // the budget. The fork's own compiles meet its window by its strategy's
+      // rule: passthrough, the fork's default, keeps the newest messages that
+      // fit; an adaptive strategy folds to fit or throws over_budget for the
+      // drain breaker.
+      // The seed leaves out the template's thinking (withoutThinking): a
+      // signed block verifies only while everything before it is what it was
+      // minted under, and a fork's system, tools and scoped injections don't
+      // promise that, while its own namespace holds no stamps that could
+      // vouch for the copies. On models that don't bind thinking to its
+      // prefix a copy would have been kept, so there the fork loses the
+      // template's reasoning.
+      // Then context-manager's stripUnpairedToolBlocks drops each call whose
+      // result isn't in the seed and each result whose call isn't, keeping
+      // the rest of their messages (a message left with nothing becomes its
+      // "[tool call omitted]" placeholder). A fork spawned while the template
+      // is between a round's call and its results (the coalescer can spawn
+      // one outside the event loop) would otherwise give the fork's first
+      // request an unanswered call: the passthrough strategies have no
+      // pairing pass, and an adaptive template's compile has been through its
+      // own.
+      const { messages: existing } = await contextManager.compile(undefined, undefined, { dryRun: true });
       if (existing.length === 0) {
         // The copy is the fork's own, and the template's annotation edits only
         // the template's message: seed only once each of the template's
         // annotations has finished.
         const { messages: compiled } = await template.toolResultGuard.afterAnnotations(
-          () => template.getContextManager().compile());
-        for (const msg of compiled) {
+          () => template.getContextManager().compile(undefined, undefined, { dryRun: true }));
+        const withoutReasoning = withoutThinking(compiled);
+        const seed = stripUnpairedToolBlocks(withoutReasoning);
+        logSeedOmissions(name, template.name, compiled, withoutReasoning, seed);
+        for (const msg of seed) {
           const participant = msg.participant === template.name ? name : msg.participant;
           contextManager.addMessage(participant, msg.content);
         }
diff --git a/test/agent-runtime-settings.test.ts b/test/agent-runtime-settings.test.ts
index 77f85f76a..4eed3e766 100644
--- a/test/agent-runtime-settings.test.ts
+++ b/test/agent-runtime-settings.test.ts
@@ -956,6 +956,34 @@ describe('a reached budget across a restart', () => {
     });
   });
 
+  it('a dry run under a budget the boot applied at once proves nothing: the fallback stays armed, whether the preview fits or is refused', async () => {
+    await run(async (h) => {
+      const restarted = await provenAtBoot(h, 60_000);
+      const recorded = persisted(restarted);
+      // A preview that fits notes nothing and keeps the fallback.
+      await restarted.previewActivation('agent');
+      // A preview refused at the boot budget restores nothing from a preview.
+      const refusal = Object.assign(new Error('over budget'), { name: 'OverBudgetError' });
+      const log = quietErrors();
+      try {
+        await withPatched('compile', async () => { throw refusal; }, async () => {
+          await assert.rejects(restarted.previewActivation('agent'), /over budget/);
+        });
+      } finally {
+        log.restore();
+      }
+      assert.ok(!log.lines.some((l) => l.includes('the context manager refused')), log.lines.join('\n'));
+      assert.deepEqual(budgets(restarted), { target: 60_000, effective: 60_000, transition: 'stable' }, 'still the boot budget, applied at once');
+      assert.deepEqual(persisted(restarted), recorded, 'neither preview wrote the record');
+      // The fallback is still armed: the first sent compile refused at the
+      // boot budget restores it paced, and goes on.
+      const { planned, lines, thrown } = await refusedFirst(restarted);
+      assert.equal(thrown, undefined);
+      assert.deepEqual(planned, [60_000, 100_000]);
+      assert.ok(lines.some((l) => l.includes('restored it as a paced descent from the recipe\'s budget')), lines.join('\n'));
+    });
+  });
+
   it("the fallback runs once: if the recipe's budget is refused too, its compile reports that refusal", { timeout: 20_000 }, async () => {
     // Restored paced, and kept set where the strategy can't prepare a smaller window.
     for (const canPace of [true, false]) {
diff --git a/test/conversation-routing.test.ts b/test/conversation-routing.test.ts
index 489a94e87..c6c6c6b0a 100644
--- a/test/conversation-routing.test.ts
+++ b/test/conversation-routing.test.ts
@@ -11,6 +11,8 @@ import { mkdtempSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { AgentFramework } from '../src/index.js';
 import type { ProcessEvent, ConversationRouterConfig, TraceEvent } from '../src/index.js';
+import { Membrane, OpenAIResponsesAPIAdapter, OpenAIResponsesFormatter } from '@animalabs/membrane';
+import type { ContentBlock } from '@animalabs/membrane';
 import { MockMembrane, createMockResponse } from './helpers/mock-membrane.js';
 
 function incomingEvent(overrides: {
@@ -216,7 +218,29 @@ describe('Conversation routing', () => {
     await framework.stop();
   });
 
-  it('fork inherits the template context', async () => {
+  /** Spawn the fork for `slack:D3`, and return what its namespace was seeded
+   *  with and the `[conversation]` lines the spawn logged. */
+  async function seedOf(framework: AgentFramework) {
+    const log = mock.method(console, 'log', () => {});
+    let lines: string[];
+    try {
+      framework.pushEvent(incomingEvent({ channelId: 'slack:D3', text: 'hi', channelType: 'im' }));
+      await framework.runUntilIdle();
+      lines = log.mock.calls.map((c) => String(c.arguments[0])).filter((line) => line.startsWith('[conversation]'));
+    } finally {
+      log.mock.restore();
+    }
+    const seeded = framework.getAgent('conversation-slack-D3-g1')!.getContextManager().getAllMessages();
+    return { seeded, lines };
+  }
+
+  /** The line a spawn logs for a seed that left something out. */
+  function seedLine(thinking: number, calls: number, results: number): string {
+    return `[conversation] conversation-slack-D3-g1: seeded from trunk without ${thinking} thinking block(s), ` +
+      `${calls} unanswered tool call(s) and ${results} orphaned tool result(s)`;
+  }
+
+  it('fork inherits the template context, and a seed that leaves nothing out logs nothing', async () => {
     membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
     const framework = await makeFramework();
 
@@ -225,19 +249,248 @@ describe('Conversation routing', () => {
       { type: 'text', text: 'HANDBOOK: always check the logs first.' },
     ]);
 
-    framework.pushEvent(incomingEvent({ channelId: 'slack:D2', text: 'hi', channelType: 'im' }));
-    await framework.runUntilIdle();
-
-    const fork = framework.getAgent('conversation-slack-D2-g1')!;
-    const { messages } = await fork.getContextManager().compile();
+    const { seeded, lines } = await seedOf(framework);
     assert.ok(
-      messages.some((m) => JSON.stringify(m.content).includes('HANDBOOK')),
+      seeded.some((m) => JSON.stringify(m.content).includes('HANDBOOK')),
       'fork should inherit trunk context',
     );
+    assert.deepEqual(lines, [], 'a seed with nothing left out logs no line');
+
+    await framework.stop();
+  });
+
+  it("a fork's seed is a dry run, and carries none of the template's thinking", async () => {
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const framework = await makeFramework();
+    const trunk = framework.getAgent('trunk')!.getContextManager();
+    trunk.addMessage('user', [{ type: 'text', text: 'HANDBOOK: always check the logs first.' }]);
+    trunk.addMessage('trunk', [
+      { type: 'thinking', thinking: 'minted under the trunk\'s prefix', signature: 'sig-trunk' },
+      { type: 'text', text: 'Checked the logs.' },
+    ] as never);
+    trunk.addMessage('trunk', [{ type: 'redacted_thinking', data: 'opaque' }] as never);
+
+    // Every compile on any context manager during the spawn, by instance.
+    const proto = (trunk.constructor as { prototype: { compile: (...args: unknown[]) => unknown } }).prototype;
+    const original = proto.compile;
+    const compiles: Array<{ cm: unknown; dry: boolean }> = [];
+    proto.compile = function (this: unknown, ...args: unknown[]) {
+      compiles.push({ cm: this, dry: (args[2] as { dryRun?: boolean } | undefined)?.dryRun === true });
+      return original.apply(this, args);
+    };
+    let seed: Awaited<ReturnType<typeof seedOf>>;
+    try {
+      seed = await seedOf(framework);
+    } finally {
+      proto.compile = original;
+    }
+    const { seeded, lines } = seed;
+
+    const fork = framework.getAgent('conversation-slack-D3-g1')!.getContextManager();
+    const onTrunk = compiles.filter((c) => c.cm === trunk);
+    assert.ok(onTrunk.length >= 1, 'the seed compiled the template');
+    assert.ok(onTrunk.every((c) => c.dry), "the template's compiles during the spawn are dry runs");
+    assert.equal(compiles.find((c) => c.cm === fork)?.dry, true, "the new namespace's emptiness check is a dry run");
+
+    const types = seeded.flatMap((m) => m.content.map((b) => b.type));
+    assert.ok(!types.includes('thinking') && !types.includes('redacted_thinking'), `no thinking in the seed: ${types}`);
+    const texts = seeded.map((m) => JSON.stringify(m.content));
+    assert.ok(texts.some((t) => t.includes('HANDBOOK')) && texts.some((t) => t.includes('Checked the logs.')));
+    assert.ok(seeded.some((m) => m.participant === 'conversation-slack-D3-g1'
+      && JSON.stringify(m.content).includes('Checked the logs.')), "the reply keeps its text, under the fork's name");
+    assert.ok(seeded.every((m) => m.content.length > 0), 'the thinking-only message is left out, not stored empty');
+    assert.deepEqual(lines, [seedLine(2, 0, 0)], 'one line counts what the seed left out');
+
+    await framework.stop();
+  });
+
+  it("a seed that ends on a completed tool round keeps the round, without its thinking", async () => {
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const framework = await makeFramework();
+    const trunk = framework.getAgent('trunk')!.getContextManager();
+    trunk.addMessage('user', [{ type: 'text', text: 'check the logs' }]);
+    trunk.addMessage('trunk', [
+      { type: 'thinking', thinking: 'the logs first', signature: 'sig-round' },
+      { type: 'tool_use', id: 'toolu_logs', name: 'read_logs', input: {} },
+    ] as never);
+    trunk.addMessage('user', [{ type: 'tool_result', toolUseId: 'toolu_logs', content: 'all quiet' }] as never);
+
+    const { seeded, lines } = await seedOf(framework);
+    const contents = seeded.map((m) => m.content);
+    const round = contents.findIndex((c) => c.some((b) => b.type === 'tool_use'));
+    assert.ok(round >= 0, 'the round is in the seed');
+    assert.deepEqual(contents[round]!.map((b) => b.type), ['tool_use'], 'its call stays, its thinking goes');
+    assert.equal(seeded[round]!.participant, 'conversation-slack-D3-g1');
+    assert.deepEqual(contents[round + 1]!.map((b) => b.type), ['tool_result'], 'its result follows it');
+    assert.deepEqual(lines, [seedLine(1, 0, 0)]);
+    await framework.stop();
+  });
+
+  it("a seed's unanswered call gives way to a placeholder, and the seed ends on neither it nor a thinking-only row", async () => {
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const framework = await makeFramework();
+    const trunk = framework.getAgent('trunk')!.getContextManager();
+    trunk.addMessage('user', [{ type: 'text', text: 'check the logs' }]);
+    trunk.addMessage('trunk', [{ type: 'text', text: 'Looking.' }]);
+    // A tool round's assistant row, stored before its results (the spawn can
+    // land between the two when the coalescer spawns outside the event loop),
+    // and a thinking-only row after it.
+    trunk.addMessage('trunk', [
+      { type: 'thinking', thinking: 'mid-round', signature: 'sig-mid' },
+      { type: 'tool_use', id: 'toolu_pending', name: 'read_logs', input: {} },
+    ] as never);
+    trunk.addMessage('trunk', [{ type: 'thinking', thinking: 'still thinking', signature: 'sig-after' }] as never);
+
+    const { seeded, lines } = await seedOf(framework);
+    const types = seeded.flatMap((m) => m.content.map((b) => b.type));
+    assert.ok(!types.includes('tool_use') && !types.includes('thinking'), `no unanswered call or thinking in the seed: ${types}`);
+    // The seed is everything before the fork's own first message ('hi').
+    const firstOwn = seeded.findIndex((m) => JSON.stringify(m.content).includes('"hi"'));
+    assert.ok(firstOwn > 1, 'the incoming message follows the seed');
+    // The thinking goes first, so the round's row holds only its unanswered
+    // call, which the pairing pass replaces with its placeholder.
+    const last = seeded[firstOwn - 1]!;
+    assert.deepEqual(last.content.map((b) => b.type), ['text']);
+    assert.ok(JSON.stringify(last.content).includes('[tool call omitted]'), `the seed ends on the placeholder: ${JSON.stringify(last.content)}`);
+    assert.equal(last.participant, 'conversation-slack-D3-g1');
+    assert.ok(JSON.stringify(seeded[firstOwn - 2]!.content).includes('Looking.'), 'the exchange before the round stays');
+    assert.deepEqual(lines, [seedLine(2, 1, 0)]);
+    await framework.stop();
+  });
+
+  it("a seed keeps a partly answered round's answered call and drops the other, drops an orphaned result and a trailing unanswered call, and keeps the text beside each", async () => {
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const framework = await makeFramework();
+    const trunk = framework.getAgent('trunk')!.getContextManager();
+    // A result whose call isn't in the history (as where a window starts
+    // after the call), beside the user's text.
+    trunk.addMessage('user', [
+      { type: 'tool_result', toolUseId: 'toolu_gone', content: 'stale' },
+      { type: 'text', text: 'check both' },
+    ] as never);
+    // A parallel round with one of its two calls answered.
+    trunk.addMessage('trunk', [
+      { type: 'text', text: 'Checking both.' },
+      { type: 'tool_use', id: 'toolu_a', name: 'read_logs', input: {} },
+      { type: 'tool_use', id: 'toolu_b', name: 'read_config', input: {} },
+    ] as never);
+    trunk.addMessage('user', [{ type: 'tool_result', toolUseId: 'toolu_a', content: 'all quiet' }] as never);
+    // The next round's row, stored before its result: thinking, text and a call.
+    trunk.addMessage('trunk', [
+      { type: 'thinking', thinking: 'the config next', signature: 'sig-next' },
+      { type: 'text', text: 'And the config.' },
+      { type: 'tool_use', id: 'toolu_c', name: 'read_config', input: {} },
+    ] as never);
+
+    const { seeded, lines } = await seedOf(framework);
+    const blocks = seeded.flatMap((m) => m.content) as Array<{ type: string; id?: string; toolUseId?: string }>;
+    assert.deepEqual(blocks.filter((b) => b.type === 'tool_use').map((b) => b.id), ['toolu_a'], 'the answered call stays, the unanswered ones go');
+    assert.deepEqual(blocks.filter((b) => b.type === 'tool_result').map((b) => b.toolUseId), ['toolu_a'], 'its result stays, the orphaned one goes');
+    const round = seeded.find((m) => m.content.some((b) => b.type === 'tool_use'))!;
+    assert.deepEqual(round.content.map((b) => b.type), ['text', 'tool_use'], "the round's text stays beside its answered call");
+    assert.ok(seeded.some((m) => JSON.stringify(m.content).includes('check both')), "the user's text stays beside the orphaned result");
+    const trailing = seeded.find((m) => JSON.stringify(m.content).includes('And the config.'))!;
+    assert.deepEqual(trailing.content.map((b) => b.type), ['text'], "the trailing row keeps its text, without its thinking or its unanswered call");
+    assert.deepEqual(lines, [seedLine(1, 2, 1)]);
+    await framework.stop();
+  });
+
+  /** A Responses reply as membrane stores it: `output` through membrane's own
+   *  Responses adapter and its conversion to content blocks, with the HTTP
+   *  call stubbed. */
+  async function storedResponsesReply(output: Array<Record<string, unknown>>): Promise<ContentBlock[]> {
+    const completed = {
+      type: 'response.completed',
+      response: { id: 'resp_seed', status: 'completed', output, usage: { input_tokens: 1, output_tokens: 1 } },
+    };
+    const realFetch = globalThis.fetch;
+    globalThis.fetch = (async () => new Response(`data: ${JSON.stringify(completed)}\n\n`, {
+      status: 200,
+      headers: { 'content-type': 'text/event-stream' },
+    })) as typeof fetch;
+    try {
+      const responses = new Membrane(new OpenAIResponsesAPIAdapter({ apiKey: 'test' }), {
+        formatter: new OpenAIResponsesFormatter(),
+      });
+      const response = await responses.stream({
+        messages: [{ participant: 'user', content: [{ type: 'text', text: 'what changed?' }] }],
+        config: { model: 'gpt-test', maxTokens: 100 },
+        tools: [{ name: 'read_config', description: 'Read the config.', inputSchema: { type: 'object', properties: {} } }],
+      } as never);
+      return (response as { content: ContentBlock[] }).content;
+    } finally {
+      globalThis.fetch = realFetch;
+    }
+  }
 
+  it("a Responses seed replays no item paired with the reasoning it left out; opaque carriers stay whole", async () => {
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'ok' }]));
+    const framework = await makeFramework();
+    const trunk = framework.getAgent('trunk')!.getContextManager();
+    trunk.addMessage('user', [{ type: 'text', text: 'what changed?' }]);
+    // A reply holding a compaction, a reasoning item, a hosted web search, a
+    // message and a function call, as membrane stores it.
+    trunk.addMessage('trunk', await storedResponsesReply([
+      { type: 'compaction', id: 'cmp_1', encrypted_content: 'earlier history' },
+      { type: 'reasoning', id: 'rs_1', encrypted_content: 'enc', summary: [] },
+      { type: 'web_search_call', id: 'ws_1', status: 'completed', action: { type: 'search', query: 'config' } },
+      { type: 'message', id: 'msg_1', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: 'The config.' }] },
+      { type: 'function_call', id: 'fc_1', call_id: 'call_1', name: 'read_config', arguments: '{}', status: 'completed' },
+    ]));
+    trunk.addMessage('user', [{ type: 'tool_result', toolUseId: 'call_1', content: 'ok' }] as never);
+    // A reply with no reasoning item: nothing it was paired with is left out,
+    // so it replays as it was.
+    trunk.addMessage('trunk', await storedResponsesReply([
+      { type: 'message', id: 'msg_2', role: 'assistant', status: 'completed', content: [{ type: 'output_text', text: 'Read it.' }] },
+    ]));
+    // An Anthropic reply in the same history: its thinking carries no raw item.
+    trunk.addMessage('trunk', [
+      { type: 'thinking', thinking: 'plain', signature: 'sig-plain' },
+      { type: 'text', text: 'Done.' },
+    ] as never);
+
+    const { seeded } = await seedOf(framework);
+    const items = new OpenAIResponsesFormatter().buildMessages(
+      seeded.map((m) => ({ participant: m.participant, content: m.content })),
+      { participantMode: 'simple', assistantParticipant: 'conversation-slack-D3-g1', humanParticipant: 'user', systemPrompt: 'fork' } as never,
+    ).messages as unknown as Array<Record<string, unknown>>;
+    const ids = items.map((item) => item.id).filter((id) => id !== undefined);
+    assert.deepEqual(ids, ['cmp_1', 'ws_1', 'msg_2'], `only the opaque carriers and the unpaired reply replay by id: ${JSON.stringify(items)}`);
+    assert.ok(!items.some((item) => item.type === 'reasoning'), 'the reasoning item is left out');
+    assert.ok(items.some((item) => item.type === 'function_call' && item.call_id === 'call_1'), 'the call renders from its fields');
+    assert.ok(items.some((item) => item.type === 'message' && JSON.stringify(item.content).includes('The config.')), 'the text renders from its fields');
+    const plain = seeded.find((m) => JSON.stringify(m.content).includes('Done.'))!;
+    assert.deepEqual(plain.content.map((b) => b.type), ['text'], "an Anthropic reply loses only its thinking");
     await framework.stop();
   });
 
+  it("a fork whose namespace already holds history isn't seeded again", async () => {
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'noted' }]));
+    const fw1 = await makeFramework({}, 'reseed.chronicle');
+    fw1.getAgent('trunk')!.getContextManager().addMessage('user', [
+      { type: 'text', text: 'HANDBOOK-V1: always check the logs first.' },
+    ]);
+    fw1.pushEvent(incomingEvent({ channelId: 'slack:D8', text: 'case one', channelType: 'im' }));
+    await fw1.runUntilIdle();
+    assert.ok(fw1.getAgent('conversation-slack-D8-g1'), 'first engagement spawns g1');
+    await fw1.stop();
+
+    // Restart with the generation counters lost, so the next engagement
+    // proposes g1 again, and its namespace already holds g1's history.
+    membrane.pushResponse(createMockResponse([{ type: 'text', text: 'again' }]));
+    const fw2 = await makeFramework({}, 'reseed.chronicle');
+    (fw2.getConversationRouter() as unknown as { generations: Map<string, number> }).generations.clear();
+    fw2.pushEvent(incomingEvent({ channelId: 'slack:D8', text: 'case two', channelType: 'im' }));
+    await fw2.runUntilIdle();
+
+    const g1 = fw2.getAgent('conversation-slack-D8-g1');
+    assert.ok(g1, 'the lost counters propose g1 again');
+    const contents = g1!.getContextManager().getAllMessages().map((m) => JSON.stringify(m.content));
+    assert.equal(contents.filter((c) => c.includes('HANDBOOK-V1')).length, 1, 'no second template copy on its history');
+    assert.ok(contents.some((c) => c.includes('case one')), 'its own history stays');
+    await fw2.stop();
+  });
+
   // Exercise the delivery boundary without scheduling inference. The same
   // handler receives ordinary channel traffic and coalesced fixed-audience notices.
   async function deliver(framework: AgentFramework, channelId: string, text: string, deliverTo?: string) {
diff --git a/test/unsent-compiles.test.ts b/test/unsent-compiles.test.ts
new file mode 100644
index 000000000..321538d28
--- /dev/null
+++ b/test/unsent-compiles.test.ts
@@ -0,0 +1,137 @@
+/**
+ * Compiles that are never sent are dry runs.
+ *
+ * A committing compile commits fold resolutions and queues compression work.
+ * Agent-framework also moves the agent's consumed watermark (RFC-006) and
+ * settles a prepared budget change at a full compile. With context-manager's
+ * thinking binding (context-manager#160), a committing compile also commits
+ * stamps and joins the branch's compiles awaiting acceptance, where one never
+ * sent can fence the replies of a live stream. Previews and the API's message
+ * list and context are never sent, so each compiles as a dry run.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { AutobiographicalStrategy, type ContextManager } from '@animalabs/context-manager';
+import type { Membrane } from '@animalabs/membrane';
+import { AgentFramework, ApiServer } from '../src/index.js';
+import { Agent } from '../src/agent.js';
+import { MockMembrane } from './helpers/mock-membrane.js';
+
+async function make(agent: Record<string, unknown> = {}) {
+  const dir = mkdtempSync(join(tmpdir(), 'unsent-compiles-'));
+  const framework = await AgentFramework.create({
+    storePath: join(dir, 'store'),
+    membrane: new MockMembrane().asMembrane(),
+    agents: [{ name: 'agent', model: 'test-model', systemPrompt: 'test', ...agent }],
+    modules: [],
+  });
+  return {
+    framework,
+    async close() { await framework.stop(); rmSync(dir, { recursive: true, force: true }); },
+  };
+}
+
+/** Record whether each compile on `cm` is a dry run. */
+function recordCompiles(cm: ContextManager): boolean[] {
+  const dry: boolean[] = [];
+  const original = cm.compile.bind(cm);
+  (cm as unknown as { compile: (...args: unknown[]) => unknown }).compile = (...args: unknown[]) => {
+    dry.push((args[2] as { dryRun?: boolean } | undefined)?.dryRun === true);
+    return (original as (...a: unknown[]) => unknown)(...args);
+  };
+  return dry;
+}
+
+describe('compiles that are never sent', () => {
+  it('a preview is a dry run, with or without gathered injections; a request that is sent is not', async () => {
+    const x = await make();
+    try {
+      const agent = x.framework.getAgent('agent')!;
+      const dry = recordCompiles(agent.getContextManager());
+      await x.framework.previewActivation('agent');
+      await x.framework.previewActivation('agent', { injections: true });
+      await x.framework.previewActivation('agent', { budget: { maxTokens: 50_000, reserveForResponse: 4_000 } });
+      // The control: the assembly a sent request goes through (as
+      // startStreamWithInjections calls it) commits.
+      await agent.buildActivationRequest([]);
+      assert.deepEqual(dry, [true, true, true, false]);
+    } finally { await x.close(); }
+  });
+
+  it('a preview leaves the consumed watermark: the agent never read what it assembled', async () => {
+    const x = await make();
+    try {
+      const agent = x.framework.getAgent('agent')!;
+      const before = agent.getConsumedWatermark();
+      const id = agent.getContextManager().addMessage('user', [{ type: 'text', text: 'not yet read' }]);
+      await x.framework.previewActivation('agent');
+      assert.deepEqual(agent.getConsumedWatermark(), before);
+      // The control: a request that is sent assembled it, so it's read.
+      await agent.buildActivationRequest([]);
+      const sequence = agent.getContextManager().getMessage(id)!.sequence;
+      assert.ok((agent.getConsumedWatermark()?.sequence ?? -1) >= sequence, 'a sent request moves the watermark past what it assembled');
+    } finally { await x.close(); }
+  });
+
+  it('a preview leaves a prepared budget change for the compile that is sent', async () => {
+    const x = await make({
+      strategy: new AutobiographicalStrategy({
+        adaptiveResolution: true, foldingStrategy: 'kv-stable', recentWindowTokens: 30_000, kvStableReachTokens: 8_000,
+      }),
+      contextBudgetTokens: 100_000,
+      maxTokens: 10_000,
+    });
+    try {
+      // A sent compile first, so the frontier it records already fits the
+      // window the lowered budget prepares: the descent is prepared before
+      // the preview runs, and only the dry run keeps the preview from
+      // settling it.
+      await x.framework.getAgent('agent')!.buildActivationRequest([]);
+      assert.equal(x.framework.updateAgentRuntimeSettings('agent', { contextBudgetTokens: 60_000 }).transition, 'converging');
+      assert.equal(x.framework.getAgent('agent')!.getContextManager().getHotContextSettings()?.prepared, true);
+      await x.framework.previewActivation('agent');
+      assert.equal(x.framework.getAgentRuntimeSettings('agent').transition, 'converging', 'a preview settles nothing');
+      // The control: the assembly a sent request goes through settles it.
+      await x.framework.getAgent('agent')!.buildActivationRequest([]);
+      assert.equal(x.framework.getAgentRuntimeSettings('agent').transition, 'stable');
+    } finally { await x.close(); }
+  });
+
+  it("the API's message list and agent context are dry runs", async () => {
+    const x = await make();
+    try {
+      const dry = recordCompiles(x.framework.getAgent('agent')!.getContextManager());
+      const server = new ApiServer(x.framework, { port: 0, host: '127.0.0.1' }) as unknown as {
+        cmdMessageList(params?: unknown): Promise<unknown>;
+        cmdAgentContext(params: unknown): Promise<unknown>;
+      };
+      await server.cmdMessageList({});
+      await server.cmdAgentContext({ agentName: 'agent' });
+      await server.cmdAgentContext({ agentName: 'agent', maxTokens: 50_000 });
+      assert.deepEqual(dry, [true, true, true]);
+    } finally { await x.close(); }
+  });
+
+  it("a kv-unified preview carries the immutable prefix hash and the dry run together; a sent request carries the hash alone", async () => {
+    const options: unknown[] = [];
+    const cm = {
+      getStrategy: () => ({ isKvUnifiedEnabled: () => true }),
+      setToolDefinitions: () => {},
+      compile: async (_budget: unknown, _injections: unknown, opts: unknown) => {
+        options.push(opts);
+        return { messages: [{ participant: 'user', content: [{ type: 'text', text: 'hello' }] }], systemInjections: [] };
+      },
+    } as unknown as ContextManager;
+    const agent = new Agent({ name: 'resident', model: 'test', systemPrompt: 'system' }, cm, {} as Membrane);
+    await agent.buildActivationRequest([], undefined, undefined, [], { dryRun: true });
+    await agent.buildActivationRequest([]);
+    const [preview, sent] = options as Array<{ kvUnifiedImmutablePrefixHash?: unknown; dryRun?: unknown }>;
+    assert.equal(typeof preview.kvUnifiedImmutablePrefixHash, 'string');
+    assert.equal(preview.dryRun, true);
+    assert.equal(sent.kvUnifiedImmutablePrefixHash, preview.kvUnifiedImmutablePrefixHash, 'both compile against the same prefix');
+    assert.equal(sent.dryRun, undefined);
+  });
+});