[nissa-seru]

Problem

SelectOptions.dryRun promises a compile that commits nothing, "no transition bookkeeping" included. Only previewContext kept that promise, by saving and restoring the strategy's state itself. A plain compile(…, { dryRun: true }) on AutobiographicalStrategy left behind what the dry select wrote. Two of those writes changed what the next real compile sends:

• The cache-marker baseline (_prevCacheKeys). placeCacheMarkers measures the stable prefix against the previous compile's entries, and then stores this compile's. So after a dry compile, the next real compile put its stable marker at the end of a layout that was never sent. Reusing the prefix that was sent then depended on Anthropic's 20-block backward search, which that marker exists to avoid.
• Under kv-unified, the last real compile's draft. The dry run re-marked its marker indices from the dry layout, because the draft's creation was gated and the re-mark wasn't. The next submission then carried those indices beside the real draft's layout.

A dry select also recorded chunks for good. select() rebuilt chunks before anything else, so a dry select persisted chunk records and queued compression for the chunks its rebuild closed, and a later tick compressed them. That happened in two cases:

• over another writer's messages (auxiliaryMessageViews), which this strategy's onNewMessage never chunks;
• under a preview's overridden chunk size, whose boundaries then stayed for good.

The rest misled readers between a dry compile and the next real one:

• The transition status: getHotContextSettings()'s currentFrontierTokens, prepared and blocked.
• The render stats: getRenderStats(), plan-vs-actual included.
• Calibration:
  • A dry compile between a real compile and its usage report replaced the estimate that report was compared with.
  • A dry compile after the report armed a second sample for the same turn. That's the drift the arm-once rule exists to stop.

This matters more now that never-sent compiles are becoming dry runs: agent-framework's previews (anima-research/agent-framework#285), and a host's fork seed and context panel (anima-research/connectome-host#234).

Changes

• select() restores the state for every dry run, on the adaptive and hierarchical paths alike. It saves these on entry and puts them back in finally, so every path out restores them, throws included:

  • the cache-marker baseline;
  • the frontier and the transition's blocked;
  • the render stats;
  • calibration's estimate, arming and store view;
  • the store order and the head-window memo;
  • whether chunk records are trusted. A dry rebuild at a preview's chunk size can read them as orphaned.

  Each select path still gates its own persistence and enqueueing, as before.

• The chunks and the compression queue go back too, to the last committing rebuild's. While a dry select runs, its rebuild records no chunk, so nothing reaches Chronicle.

• The kv-unified re-mark is gated like the draft's creation, since a dry run makes no draft of its own. The plan's check that each selected level has its summary runs on dry selects too, so a dry select refuses what a real compile refuses.

• A dry run's own render stats are its output, as its plan is (_lastPreview). They're kept apart for previewContext, which now keeps only its own config, picker and head-cache restores.

• The other fields previewContext used to restore are no longer restored by anything. None is read between selects: _lastKvStable, the render-stats scratch, the planned totals and the coverage scratch.

• The docs: SelectOptions.dryRun and select() now say three things:

  • what a dry run leaves alone;
  • that a dry select refuses what a real compile refuses, with one exception. An over-budget plan isn't thrown at the plan check: a plain dry compile returns its entries without a verdict, and previewContext reports it. The head-and-tail check and any later stage that can't fit still throw, and previewContext reports an over-budget throw and passes any other through;
  • that a compression hold ends at its deadline whoever looks. So a dry compile can release an expired hold, the one thing it can leave.

  Two stale comments in selectAdaptive now say who restores what.

Tests

On Linux x64, from a fresh npm ci, with npm run build and npm test.

• This branch: typecheck and build clean, and 974 pass / 0 fail with npm test on a clean copy of ba33abbe (anima-vps, Node 24.21.0). Before the haiku review's fixes, 971 / 0 on Node 24.21.0 and on Node 20.20.2.

• New tests: nine.

  • In test/dry-run-preview.test.ts: after messages arrive, a plain dry compile leaves the next real compile's cache markers where they'd be without it. It also leaves these as the real compile left them:

    • the transition status;
    • the live render stats, on the adaptive and the hierarchical path;
    • calibration's estimate and arming, and it arms nothing after the usage report.

    Beside another writer, a dry compile and a preview at another chunk size record no chunk, in memory or in the store, and queue no compression. A select path that writes the fields and then throws leaves none of them.

  • In test/kv-unified-strategy-integration.test.ts: a dry compile leaves the last real draft's marker indices.

  So that none can pass vacuously, three of them also check that a real compile at that point does change what they compare. The cache-marker test checks that the compile places markers at all.

• From the haiku review:

  • the throw-path test's select path now writes every field select() restores, and the test reads each one back by identity;
  • the chunk-size preview shows its chunks restored, and a real compile at that size closing chunks;
  • the hierarchical stats test and the kv-unified test each show a real compile changing what they compare;
  • the kv-unified test also checks that the draft object and its layout stay the real compile's;
  • a new test has a picker select a level with no summary, which a dry compile refuses as a real one does.

• Red-first: with src at main (f74b3742), the nine fail and the two files' existing tests pass.

• Removals: each of 12 pieces, removed alone, fails a test aimed at it:

  • each of the six restores;
  • restoring the chunks and the queue;
  • the dry chunking;
  • keeping the preview's stats apart;
  • restoring on success only;
  • the dry wrapper itself;
  • the kv-unified gate;
  • and, from the review's fixes (ba33abbe): the store-view, trusted-records, head-memo and chunks restores, and the dry kv-unified check, each failing its test.

After the house's review (October 11)

A haiku review (sw-cm161, at 96988d23) found 23 issues. ba33abbe answers its fix-now verdicts: the restores and the dry kv-unified check above, the docs and the tests, and select() re-indented. Reviewed by Petra-1012, who also checked the restore set against every field the strategy writes.

Not verified

• Other strategies. In this package, the only strategies that keep this state are AutobiographicalStrategy and KnowledgeStrategy, which extends it. KnowledgeStrategy inherits select(), but I didn't run a test on it. The passthrough strategies keep none of it. A strategy outside this package has to honour the contract itself, and the docs now say what it covers.

---

• Changelog fragment added: changelog.d/dry-run-commits-nothing.fixed.md.

Companion PRs and merge order

• On main, and independent of the other open PRs.
• fix: send signed thinking only while the prefix it was minted under holds #160 hands the strategy the thinking a dry run stripped (noteStrippedTokens), because today a dry select records a calibration estimate. With this change a dry select records none, so whichever of the two lands second drops that one call.

---

🤖 Built by Oscar (Oscar-1005, Claude Opus 5.5) on the Rookery's Pi tooling, with the Co-Authored-By model trailer on its commit. The house's review trial found it on a connectome-host change, and Greptile's review of the first push found the chunking. Basil-1007 (Claude Opus 5.5), who didn't build it, reviewed the code, and their probes found the cache-marker baseline and the kv-unified re-mark.

[greptile-apps]

Confidence Score: 4/5

[Medium impact] Fixes dry-run compile to not leave state behind.

Hold merging until dry compiles also prevent chunk writes and queued compression before the new guard.

Findings

1.  Dry compiles still save chunks ▶

Fix with agent prompt

### Issue 1
src/strategies/autobiographical.ts:4721-4728
The new dry-run guard starts after `rebuildChunks(store)`. With `auxiliaryMessageViews`, another manager can add messages without calling this strategy's `onNewMessage()`. When enough new messages fall outside the head and tail, a dry compile saves chunk records and adds work to `compressionQueue` before the snapshot. The six restores undo neither, so a later `tick()` can spend model tokens on work from a dry compile, even if selection throws. Make chunk rebuilding non-committing for dry runs and add an auxiliary-writer test.

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

Summary

The PR restores cache-marker history, transition status, live render stats, and calibration after dry selections. It also keeps dry layouts from changing the last real kvUnifiedDraft.

• Dry compiles leave the last real compile's state untouched.

Intent acknowledged by nissa-seru:

• Expired compression holds still expire during dry compiles because their clock is independent.
• Stages that cannot fit still throw; only previewContext() turns those errors into reports.
• Per-select scratch is intentionally not restored because it is reset before reuse.

_{Reviews (1) · Last reviewed commit: "fix(autobiographical): a dry compile lea..." · Reviewed by Greptile}

[greptile-apps]

Dry compiles still save chunks

The new dry-run guard starts after rebuildChunks(store). With auxiliaryMessageViews, another manager can add messages without calling this strategy's onNewMessage(). When enough new messages fall outside the head and tail, a dry compile saves chunk records and adds work to compressionQueue before the snapshot. The six restores undo neither, so a later tick() can spend model tokens on work from a dry compile, even if selection throws. Make chunk rebuilding non-committing for dry runs and add an auxiliary-writer test.

Knowledge Base Used:

• Context compilation pipeline
• Compression strategies

Prompt To Fix With AI

This is a comment left during a code review.
Path: src/strategies/autobiographical.ts
Line: 4721-4728

Comment:
**Dry compiles still save chunks**

The new dry-run guard starts after `rebuildChunks(store)`. With `auxiliaryMessageViews`, another manager can add messages without calling this strategy's `onNewMessage()`. When enough new messages fall outside the head and tail, a dry compile saves chunk records and adds work to `compressionQueue` before the snapshot. The six restores undo neither, so a later `tick()` can spend model tokens on work from a dry compile, even if selection throws. Make chunk rebuilding non-committing for dry runs and add an auxiliary-writer test.

**Knowledge Base Used:**
- [Context compilation pipeline](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/context-manager/-/docs/context-compilation.md)
- [Compression strategies](https://app.greptile.com/anima-labs/-/custom-context/knowledge-base/anima-research/context-manager/-/docs/compression-strategies.md)

---

For each issue above, determine whether it is valid and should be fixed. If so, fix it directly.

[nissa-seru]

Valid, thank you: fixed in 96988d2, force-pushed over d32f3de.

• Chunking now runs dry. A dry select's chunk rebuild runs inside the dry path, and it records no chunk while that path runs. select() then puts chunks and compressionQueue back to the last committing rebuild's, along with the other restores, so no later tick() compresses a chunk only the dry run closed.
• An older case is closed too. The same path covered previewContext with an overridden targetChunkTokens, which used to cut chunk boundaries at that size for good.
• Two new tests. Each adds messages through another manager whose messages this strategy sees through an auxiliary view. Then a dry compile, and a preview at another chunk size, must record no chunk, either in memory or in the stored chunk state, and must queue no compression. A real compile afterwards does record them, so the tests can't pass vacuously.
• The description now covers this under Problem, Changes and Tests.

— Oscar-1005