export: public tree rebuilt from 2f75ed1

Built by plans/export-fixtures/make_export.py from tracked master blobs only.

Author: mmeyerlein

.github/gates/claims.tsv

@@ -243,15 +243,15 @@ PIN-seed-owns-schema-six-en	docs/meclaw-overview.en.md	declare it and deliberate
 PIN-mutation-invalid-params-de	docs/meclaw-overview.md	- `invalid_params` (GH #404) — der `params`-Block einer zu instanziierenden Zelle	pinned	a_declaration_the_boot_would_refuse_is_refused_at_the_mutation
 PIN-mutation-invalid-params-en	docs/meclaw-overview.en.md	- `invalid_params` (GH #404): the `params` block of a cell about to be instantiated does	pinned	a_declaration_the_boot_would_refuse_is_refused_at_the_mutation
 PIN-web-bundle-destructive-de	docs/cell-types.md	**Was das fuer ein Bundle heisst, das aufraeumt und neu baut** (GH #405)	pinned	a_bundle_whose_creates_are_all_refused_still_applies_its_deletes
-PIN-web-bundle-destructive-en	docs/cell-types.en.md	**What that means for a bundle that clears and rebuilds** (GH #405)	pinned	a_bundle_whose_creates_are_all_refused_still_applies_its_deletes
+PIN-web-bundle-destructive-en	docs/cell-types.en.md	What that means for a bundle that clears and rebuilds (GH #405)	pinned	a_bundle_whose_creates_are_all_refused_still_applies_its_deletes
 PIN-web-bundle-two-sends-de	docs/cell-types.md	ein zerstoerendes Bundle wird als ZWEI geschickt	pinned	the_documented_recipe_sends_two_bundles_and_keeps_the_tree
 PIN-web-bundle-two-sends-en	docs/cell-types.en.md	a destructive bundle is sent as TWO	pinned	the_documented_recipe_sends_two_bundles_and_keeps_the_tree
 PIN-web-rebind-runtime-de	docs/cell-types.md	**`port` und `bind` sind zur Laufzeit änderbar — und damit wird eine Zusage zurückgenommen (GH #410).**	pinned	a_params_update_moves_the_port_of_a_running_display
-PIN-web-rebind-runtime-en	docs/cell-types.en.md	**`port` and `bind` change at runtime — and this retracts a promise (GH #410).**	pinned	a_params_update_moves_the_port_of_a_running_display
+PIN-web-rebind-runtime-en	docs/cell-types.en.md	`port` and `bind` change at runtime, and this retracts a promise (GH #410).	pinned	a_params_update_moves_the_port_of_a_running_display
 PIN-web-rebind-move-then-write-de	docs/cell-types.md	**Die Reihenfolge ist verschieben, dann schreiben.**	pinned	a_bind_nothing_can_resolve_leaves_the_old_listener_serving
-PIN-web-rebind-move-then-write-en	docs/cell-types.en.md	**The order is move, then write.**	pinned	a_bind_nothing_can_resolve_leaves_the_old_listener_serving
+PIN-web-rebind-move-then-write-en	docs/cell-types.en.md	The order is move, then write.	pinned	a_bind_nothing_can_resolve_leaves_the_old_listener_serving
 PIN-web-rebind-boot-failure-de	docs/cell-types.md	**Ein fehlgeschlagener Bind ist per Nachricht heilbar.**	pinned	a_display_that_could_not_bind_at_boot_is_moved_by_a_message
-PIN-web-rebind-boot-failure-en	docs/cell-types.en.md	**A failed bind is curable by message.**	pinned	a_display_that_could_not_bind_at_boot_is_moved_by_a_message
+PIN-web-rebind-boot-failure-en	docs/cell-types.en.md	A failed bind is curable by message.	pinned	a_display_that_could_not_bind_at_boot_is_moved_by_a_message
 PIN-code-warm-semantics-de	docs/cell-types.md	Ein Warm-Runner ändert Latenz, nie Semantik	pinned	warm_answers_the_same_bytes_as_cold
 PIN-code-warm-semantics-en	docs/cell-types.en.md	A warm runner changes latency, never semantics	pinned	warm_answers_the_same_bytes_as_cold
 PIN-code-resident-serial-de	docs/cell-types.md	genau ein** Kind, strikt serieller FIFO	pinned	twenty_messages_come_back_in_the_order_they_went_in

CHANGELOG.md

@@ -9,6 +9,55 @@ documented `error_code` strings (README § Stability). Anything that breaks one
 them is listed under **Breaking** in its release, with the migration named. The
 Rust crates are internals and move without notice.
 
+## [0.32.1] — 2026-09-08
+
+A patch release without a code change. The README and the public documentation
+were rewritten so that a person can read them: shorter sentences, one thought per
+sentence, no slogans, every number with a source in the tree. Nothing in the
+contract moved, and no migration is needed from 0.32.0.
+
+### Changed
+
+- `README.md` went from 234 to 91 lines. The first paragraph and the five
+  quickstart commands are unchanged. The nine "why" sections left the README;
+  they live in `docs/why/`. The stability section keeps all five contract
+  surfaces, the additive rule on `0.x`, and the Breaking rule for this file.
+- `docs/why/` has six essays instead of nine. `names` became the section "Names
+  of the shipped roles" in the glossary. `ontology` had no subject of its own;
+  the mechanism it described (`add_templates`) is in `everything-is-a-file` and
+  `rewiring`. `you-talk-it-shows` claimed there was no voice in this repository,
+  which has been false since 0.31.0; its one durable paragraph moved into
+  `an-os-for-agents`. `rsi` is now `self-modification`, same thesis, no slogan.
+- `docs/meclaw-overview.md` lost about a quarter of its words. Every rule,
+  every error code, every table and every code block is still there; the 54
+  spec-claim anchors and the heading structure are unchanged. What fell was
+  repetition between sections, defect narratives from past audits, and
+  justification prose.
+- `docs/cell-types.md`, `docs/config.md`, `docs/rewiring.md`,
+  `docs/voice-wire-protocol.md`, `docs/store-backed-tool-loop.md`,
+  `docs/costs.md` and `docs/glossary.md` were rewritten paragraph by paragraph
+  with their facts, tables and examples intact. The German editions of the paired
+  documents follow the English ones in the same commit.
+- `templates/README.md` describes each of the 40 templates in a few sentences.
+  The version history that used to sit in the catalogue lives in each template's
+  own README.
+- The private assistant name that served as an example in `docs/cell-types.md`,
+  `docs/rewiring.md`, `templates/voice/README.md` and the `talky` and `voice`
+  descriptions is now the neutral example name Sam.
+- Corrected numbers on the public surface: 16 built-in cell types plus `hive`
+  (the text said 15), 40 templates (the text said 38), 15 cells in
+  `memory-hive` (the text said thirteen), and three cell types that receive a
+  default sandbox profile (the text said four; `mcp` reads the same profile
+  but must declare it).
+- `CONTRIBUTING.md`, `ROADMAP.md`, `examples/README.md` and `docs/README.md`
+  were rewritten for tone only; every issue and register anchor in the roadmap
+  is unchanged.
+
+### Migration
+
+None. No API route, no `template.json` or `config.json` key, no port, no
+`error_code` and no `web` route changed.
+
 ## [0.32.0] — 2026-09-07
 
 A minor release, and what it adds is a **typed offer**. Until now the fenced

CONTRIBUTING.md

@@ -1,30 +1,27 @@
 # Contributing to meclaw
 
-meclaw is a framework for building agentic harnesses, and swarms of them, as a directory tree.
-Issues, discussions, and PRs are all open. This file tells you how to build it, how to test it,
-where the truth lives, and what makes a good first contribution.
-
-First rule: read the honest status before you start. meclaw is a **0.x** proof of concept
-for the DSL and the self-modifying substrate; the version that shipped last is the top entry
-in [`CHANGELOG.md`](CHANGELOG.md). The mutation substrate is real and tested, and so
-is the authoring path on top of it: `templates/builder` drafts a manifest, `templates/submit`
-hands it in, and the colony is what applies it. If a change claims macOS support, or claims
-federation / multi-builder / a native Anthropic provider, it does not match reality and will not
-land. Keep us honest.
+meclaw is one Linux binary that runs a tree of agents. Every folder in the tree is one actor
+with one `config.json` and one SQLite file, and the edges between folders are the routes a
+message may take. Issues, discussions and pull requests are open.
+
+This is a 0.x proof of concept for the DSL and the self-modifying substrate; the version
+that shipped last is the top entry in [`CHANGELOG.md`](CHANGELOG.md). The mutation substrate
+is real and tested, and so is the authoring path on top of it: `templates/builder` drafts a
+manifest, `templates/submit` hands it in, and the colony is what applies it. macOS support,
+federation, more than one builder per scope and a native Anthropic provider do not exist. A
+change that claims one of them does not match the tree and will not land. Keep me honest.
 
 ## Build it
 
-Linux and rustup. `rust-toolchain.toml` pins an **exact** Rust version, so there is nothing to
-choose: rustup fetches that toolchain on the first `cargo` command and your build is the same
-one CI runs. The floor is set by edition 2024, which needs 1.85 or newer; the pin is currently
-well above it.
+Linux and rustup. `rust-toolchain.toml` pins an exact Rust version, so there is nothing to
+choose: rustup fetches that toolchain on the first `cargo` command, and your build is the one
+CI runs. Edition 2024 sets the floor at 1.85, and the pin sits well above it.
 
-The pin is deliberate (GH #406). An unpinned channel made the gate depend on the calendar —
-byte-identical code passed clippy one evening and failed it the next, because a new stable had
-promoted a lint — and it meant "green locally" said nothing, since the workstation and CI were
-never on the same compiler. Raising the pin is therefore its own commit, which handles whatever
-lints the new version denies in the same move. A build break from a newer stable is a piece of
-scheduled work, not something that happens to a release.
+The pin came out of GH #406. On an unpinned channel the gate depended on the calendar.
+Byte-identical code passed clippy one evening and failed it the next, because a new stable had
+promoted a lint. "Green locally" then said nothing, since the workstation and CI were never on
+the same compiler. Raising the pin is therefore its own commit, and that commit handles
+whatever lints the new version denies.
 
 ```bash
 git clone https://github.com/mmeyerlein/meclaw
@@ -54,16 +51,16 @@ cargo fmt --check
 
 Notes that will save you time:
 
-- Run the suite in **debug** (`cargo test`). This is the canonical, deterministic run. A couple
-  of tests exercise a validation gate that is on by default only in debug builds, so they report
+- Run the suite in debug (`cargo test`). That is the canonical, deterministic run. A couple of
+  tests exercise a validation gate that is on by default only in debug builds, so they report
   as failures under `cargo test --release`. Debug is green.
-- A couple of tests can flake in **release** builds under heavy parallelism, on wall-clock timing
-  rather than logic, notably `paket_4` (backpressure `term_timeout`) and `phase_8` (MockOpenAI).
-  These are test-harness timing artifacts, not product bugs. Debug is the canonical run; if you
-  hit one in release, re-run rather than chase it.
-- New behavior comes with a test. The hot routing paths are byte-pinned against fixtures on
-  purpose, so they cannot quietly drift. If a fixture gate fails, that is the point. Do not
-  edit the fixture to make it pass without understanding why it moved.
+- A couple of tests can flake in release builds under heavy parallelism, on wall-clock timing:
+  `paket_4` (backpressure `term_timeout`) and `phase_8` (MockOpenAI). Both are timing artifacts
+  of the test harness. Debug is the canonical run, so if you hit one in release, re-run it
+  before you chase it.
+- New behavior comes with a test. The hot routing paths are byte-pinned against fixtures, so
+  they cannot drift unnoticed. A failing fixture gate is doing its job, so do not edit the
+  fixture to make it pass before you understand why it moved.
 
 ## Where the truth lives
 
@@ -79,24 +76,23 @@ bug worth an issue.
 
 A colony is a folder. Folders marked `type: "hive"` are scopes that hold the graph. Every other
 node is a Cell, an actor with one mailbox and one job. Cells are dumb: a cell knows its
-contract, its params, and the one message in front of it, nothing else. The edges do the
-thinking: routing, filtering, fan-out, loopback. The tool-loop is not a `while` loop, it is an
-edge that routes back. Read `examples/hello` (two cells, one edge), then `examples/swarm` (the
-loop as an edge), and it clicks.
+contract, its params, and the one message in front of it. The edges do the thinking: routing,
+filtering, fan-out, loopback. A tool loop is an edge that routes back into the `llm` cell. Read
+`examples/hello` (two cells, one edge), then `examples/swarm` (the loop as an edge).
 
 ## Good first contributions
 
 These are genuinely useful and scoped to land without a week of context:
 
-- **Example colonies.** New showcase trees under `examples/`. A summarizer, a router, a
-  retry-with-backoff shape, a multi-tool agent. Small, real, runnable under the daemon, with a
-  short voice-matched README in the folder. Use `examples/hello` and `examples/swarm` as the
-  template.
-- **Template cells.** Reusable subtrees under a `templates/` directory: a well-built `code`
-  tool, a store-backed memory, a clean dispatcher or collector. The `code` cell is the Swiss
-  army knife here.
-- **Docs.** Clarify a section of `docs/`, add a worked example, fix a place where the spec and
-  the code have drifted apart. Precision is the whole game.
+- Example colonies. New trees under `examples/`: a summarizer, a router, a retry-with-backoff
+  shape, a multi-tool agent. Keep them small and runnable under the daemon, with a short README
+  in the folder that matches the voice of the others. `examples/hello` and `examples/swarm` are
+  the ones to copy from.
+- Template cells. Reusable subtrees under a `templates/` directory: a well-built `code` tool, a
+  store-backed memory, a clean dispatcher or collector. The `code` cell is the Swiss army knife
+  here.
+- Docs. Clarify a section of `docs/`, add a worked example, fix a place where the spec and the
+  code have drifted apart.
 
 Browse the issues labelled `good first issue` for specifics. If you want to attempt something
 bigger off the roadmap (more than one builder per scope, federation, capability checks with
@@ -112,41 +108,46 @@ teeth, durability hardening), open an issue first so we can talk shape before yo
   test or symbol that embodies it. The anchors themselves do travel, as
   `.github/gates/adr-anchors.tsv`, and the `gate` job resolves every one of them: deleting the
   code that pins an accepted decision is a red run until the ADR is superseded.
-- Match the surrounding voice in any prose. Confident, credible, no hype. And no spaced
-  em-dashes, they read as machine-written.
+- Match the surrounding voice in any prose. Confident and credible, without hype. Spaced
+  em-dashes read as machine-written, so leave them out.
 
 ## Named conventions
 
-Code comments across the tree cite house rules by name. The short registry, so the
-citations resolve without the private process docs:
-
-- **Rule 12 (timeouts, two layers):** every I/O operation in cell code carries its own
-  `tokio::time::timeout` (params-driven, precise); the substrate's per-message timeout is
-  a generous backstop, never the primary shield. A timeout that covers only part of the
-  operation is not a timeout.
-- **Rule 14 (body blob pointers):** the substrate resolves `text_id`/`messages_id`
-  pointers inside `messages[]` at the delivery boundary, recursively, bounded by
-  `blob_max_recursion_depth` and a per-path visited set (issue #19). The former emission
-  ban is gone: a cell may emit them, and no cell ever sees one. `{text_id}` leaves in the
-  `system` tree are resolved at the same boundary under the same guards (issue #86); only
-  the substitution differs, a leaf becomes `{"text": …}` rather than a turn. Both slots
-  resolve against one working copy per delivery, so a failure in either dead-letters the
-  body unchanged. `attachments[]` refs are a different class and stay unresolved by the
-  substrate on purpose: the consuming cell reads them on demand, through a read-only store
-  handle it only receives when its contract declares `consumes.body.attachments` (issue #87).
-- **R9 (CLI shape):** flags only, nginx style. No subcommands.
-- **A1' (panic-free hot path):** the colony routing/dispatch path never panics on
-  pathological input; it answers with errors, skips, or dead letters. A panic there takes
-  the whole colony, not one cell.
-- **30s failure markers:** generous timeouts (30s convention) for failure markers in
-  tests, robust under parallel cargo load; tight timing discriminators only where the
-  test explains why.
-- **Topology tests:** `#[tokio::test(flavor = "multi_thread", worker_threads = 4)]` for
-  anything that boots a real topology.
-- **Coding standards:** no `unwrap()`/`panic!()` outside tests, `thiserror` errors in
-  libraries, doc comments on public items, no blocking sync I/O in async.
-- **Demo discipline:** a test that claims to prove X proves it through a positive
-  receipt signal, never through negative side effects.
+Code comments across the tree cite house rules by name. The short registry, so the citations
+resolve without the private process docs:
+
+- Rule 12, timeouts in two layers. Every I/O operation in cell code carries its own
+  `tokio::time::timeout`, driven by params and cut tight; the substrate's per-message timeout
+  is a generous backstop and never the primary shield. A timeout that covers only part of the
+  operation is no timeout.
+- Rule 14, body blob pointers. The substrate resolves `text_id` and `messages_id` pointers
+  inside `messages[]` at the delivery boundary, recursively, bounded by
+  `blob_max_recursion_depth` and a per-path visited set (issue #19). The former emission ban is
+  gone: a cell may emit them, and no cell ever sees one. `{text_id}` leaves in the `system`
+  tree are resolved at the same boundary under the same guards (issue #86); only the
+  substitution differs, since a leaf becomes `{"text": ...}` where a pointer in `messages[]`
+  becomes a turn. Both slots resolve against one working copy per delivery, so a failure in
+  either dead-letters the body unchanged. `attachments[]` refs are a different class and the
+  substrate leaves them alone: the consuming cell reads them on demand, through a read-only
+  store handle it receives only when its contract declares `consumes.body.attachments`
+  (issue #87).
+- R9, CLI shape. Flags only, nginx style. No subcommands.
+- A1', panic-free hot path. The colony routing and dispatch path never panics on pathological
+  input; it answers with errors, skips, or dead letters. A panic there takes down every cell in
+  the colony at once.
+- 30s failure markers. Generous timeouts (the 30s convention) for failure markers in tests, so
+  they survive parallel cargo load; tight timing discriminators only where the test explains
+  why.
+- Topology tests. `#[tokio::test(flavor = "multi_thread", worker_threads = 4)]` for anything
+  that boots a real topology.
+- Demo discipline. A test that claims to prove X proves it through a positive receipt signal,
+  never through negative side effects.
+
+## Coding standards
+
+No `unwrap()` or `panic!()` outside tests. Libraries return `Result` with `thiserror` errors,
+and the binary may use `anyhow::Result`. Every public item carries a doc comment. No blocking
+sync I/O in async code.
 
 ## License