# NativeCAD 0.10.0 "Honeck" — modelling writes build on the kernel worker; two chats on one server no longer stall each other

**106 tools, nothing removed or renamed — every 0.9.0 call keeps working.**
One behaviour moves and a caller can key off it: an offloaded read is now bounded by the worker's wall clock (see "Behaviour changes"). Everything else in this release is the same surface answering faster under concurrency.

## The write path crossed (CADSF-1274, the commit step)
- Every modelling write — primitives, extrude/revolve/sweep/loft, the booleans, blends, chamfers, shells, patterns, holes — is replayed **once, on the kernel worker**, and the protocol thread never runs the executor for a build the worker proved. With two chats (or two sub-agents) driving one server, a 40-op part being rebuilt in one no longer parks the other's calls for the length of that rebuild: the thread that answers stdio is not the thread building. Measured in `tests/test_cadsf-1274-commit.js`: a read on the same document answers in ~1 ms while a 2.5 s union is stalled on the worker.
- The worker's reply IS the response: per-body summaries (bbox / volume / watertight — the tessellate + checkLocal that used to run on the host), the CADSB-528 hole-route advisory and the CADSB-139 replay-regression verdict travel back in a `commit` block. Every refusal keeps its code and shape; `details.provenBy: "kernel-worker"` says which side judged it.
- The host's parse is lazy (`src/session/lazy-parse.js`): after a worker commit, `docParser`/`env`/`consumedBy` are rebuilt from the COMMITTED ops the first time a synchronous consumer (pmi, quote, review, output, evaluate, `resolveBody`) reads them — never from a candidate op still being proven. A chain of writes never parses on the protocol thread; a write followed by a host-side read parses once. The cost that moved: a host-side read after a heavy write pays that document's replay at the read instead of at the write.
- One write at a time per document (`cad_create_sketch` and `cad_build_plan` included); two documents still build concurrently. Checkpointed replay (CADSF-1152) now runs on the worker too, so a build there replays the tail, not the journal. The first op of a document builds on the host (milliseconds) and warms the worker for the second.
- `CADSOLVER_MCP_WRITE_WORKER` is **on by default**; `0` restores the 0.9.0 host-side build byte-for-byte. `CADSOLVER_MCP_OP_GUARD` follows it.

## Behaviour changes
- **Offloaded reads are bounded.** With writes keeping the worker warm, `cad_mass_properties` offloads to it and is bounded by the worker's wall clock: under an impossible `opTimeoutMs` it is refused `E_TIMEOUT` naming itself, where 0.9.0 ran it unbounded on the host.

## Also in this release
- `cad_session_reset {confirm:true}` — close every document and handle, start a fresh journal, keep the epoch (CADSF-1387).
- `cad_batch` accepts host-namespaced tool names and reports per-op `ms` (CADSF-1388).
- Agent instructions gained "Documents, sessions and multi-part builds" (CADSF-1382).

## Known — filed, not hidden
- Pre-existing on master, unchanged by this release, each reproducing with `CADSOLVER_MCP_WRITE_WORKER=0`: `cadsb-701` (drawing simplifier closure), `cadsf-1189`, `cadsf-1224`, `cadsf-1296`, `parity` C1 shell wording, `cadsf-412` stale parity-web matrix, `cadsf-640` quote-digest drift over time, `payload-budget`'s `cad_tube_sweep` example exceeding the 60 s file ceiling on a slow box, the e2e scenarios that need a staged kernel.

**Downloads are served from featureboard.ai** (see `latest.json` for bytes + sha256):
https://featureboard.ai/nativecad/releases/nativecad-mcp-0.10.0.mcpb
Staged kernel: git 1dad30d9, tree 96d801b1ba17.