Build AI methods with your coding agent, then run them anywhere: as an MCP for chatbots, as a webapp for people, or via API for your software.
Cover the open-shaped natives in the shared projection corpus (#1187)
Louis Choquelb182fad40eed
diff --git a/AGENTS.md b/AGENTS.mdindex 62313f62d..bde475258 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -103,7 +103,12 @@- **`generate-projection-corpus`**: Write the shared inputs-template projection fixture corpus — the descriptors, the expected fill-in templates in both shapes and both formats, and the record of where the expectation deliberately differs from the engine's own renderer. Sole producer of the capture committed byte-identically in `mthds-js/tests/fixtures/protocol/` and `mthds-python/tests/fixtures/protocol/`, which is what pins the TypeScript and Python projections against each other. See `docs/contribute/generate-projection-corpus.md`.```bash- .venv/bin/pipelex-dev generate-projection-corpus tests/data/input_semantics/*.mthds -o /tmp/projection-corpus+ .venv/bin/pipelex-dev generate-projection-corpus \+ tests/data/input_semantics/hinted_bundle.mthds \+ tests/data/input_semantics/probe_bundle.mthds \+ tests/data/input_semantics/scaffold_bundle.mthds \+ tests/data/input_semantics/output_bundle.mthds \+ -o /tmp/projection-corpus```### Pipelex CLI Commandsdiff --git a/CHANGELOG.md b/CHANGELOG.mdindex d739b0cc8..f1e94459f 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -27,6 +27,7 @@### Changed- **Inference errors now declare an `error_domain`, derived from the category the worker already assigned** (breaking): the whole `CogtError` family used to report no domain at all, so every inference failure — a content-policy refusal included — was rendered as HTTP 500 by any consumer reading `ErrorReport.http_status`. `InferenceErrorCategory` gains an `error_domain` property and `CogtError.to_error_report()` derives from it, which means a **content-classified failure now answers 422 instead of 500**: a provider content-policy refusal, a malformed prompt image, a bad prompt parameter and their siblings are all properties of material the caller submitted. The widest reach of that mapping is worth stating plainly, because it goes past the classes that declare `CONTENT` on themselves: **every provider HTTP 400 classifies as `CONTENT`**, as does a builtin `ValueError` / `RuntimeError` / `FileNotFoundError` out of a local file extractor, so a context-length overflow, a parameter a model rejects, and an engine-side request-construction fault all answer 422 now and leave the 5xx rate. The `UserAction` on those was already `CHANGE_INPUT`, so the status is only catching up with the advice the report was already giving. The other mappings change no status and only make the report truthful about why — `CONFIGURATION` is `config`, `TRANSIENT` / `CAPACITY` / `AMBIGUOUS` are `runtime`, and `UNKNOWN` deliberately asserts no domain, since classification itself failed there and an absent domain already renders 500. Deriving rather than declaring per class is what keeps `error_domain` and `error_category` from contradicting each other on the wire; a leaf that declares its own domain still wins, and the provider-429 passthrough is still checked before the domain. The effect reaches the HTTP boundary through every wrapping layer: `PipelineExecutionError`'s generic `RUNTIME` was documented as a floor applied only when the cause chain surfaced no domain, and until now the cause chain surfaced none for any inference failure, so the floor fired every time. Consumers that route on the domain rather than the status see the same correction — a validate hook classifying `config` / `runtime` as a warning and everything else as a block now warns on a genuine backend or model-deck misconfiguration surfacing through dry-run inference, where before an undomained error fell through to the default block and told the agent to edit a `.mthds` file that was not at fault. On the agent CLI this makes three `AGENT_ERROR_DOMAINS` entries unreachable, since a report that carries its own domain is read before that fallback lookup: `ModelDeckPresetValidatonError` and `GatewayUnknownModelError` derive the `config` the dict already stated and are simply removed, while `ModelChoiceNotFoundError` now declares `error_domain = input` on the class itself — a mistyped model reference is the caller's to fix, on the hosted API as much as in a local file, even though its category is `CONFIGURATION` from the provider call's point of view, and an operator-side deck fault surfaces as `ModelDeckPresetValidatonError` instead. The drift test that bars a self-describing class from those dicts gained the arm that covers derivation, so the next such entry cannot go dead unnoticed. See [Error Model](under-the-hood/error-model.md).+- **The shared projection corpus covers the open-shaped natives the two engine fixes unblocked**: `scaffold_bundle.mthds` gains a `scaffold_anything_slot` pipe carrying `native.Anything` and a `scaffold_dynamic_prompt` pipe putting a `native.Dynamic` slot at an LLM prompt position under both markers — the latter a bundle that did not validate at all while the prompt analyzers read a dynamic concept's universal compatibility as identity. The `Anything` slot is captured knowing the runtime refuses it: its template is the empty object every `unknown` node renders, and at an `Anything` position the input shaper accepts a bare string alone and returns it as a `native.Text` stuff, so both shapes of its pipe are declared in `EXPECTED_UNSHAPEABLE` against the item tracking the shaper fix rather than left to fail the round-trip gate. That is the gap being stated, not widened — the descriptor states `Anything` as `unknown` exactly as it states `Dynamic` and `Composite`, so a projection reading only the descriptor has nothing else to render there, and closing it deletes those entries and regenerates. It gets a pipe to itself deliberately: an `EXPECTED_UNSHAPEABLE` key is a whole template and the shaper stops at the first slot it refuses, so declaring it inside `scaffold_open_natives` would have suspended the round-trip check for the pinned and structureless natives beside it — including the only site where `unknown-empty-object` is measured. **`output_bundle.mthds` also joins the documented bundle list**, in the command block, in the CI corpus list and in the agent rules: it has been part of the committed capture since the output-form descriptor landed, but every regeneration recipe still named three bundles, so following one would have dropped its pipes from the capture. Re-committing the capture byte-identically in `mthds-js` and `mthds-python` is tracked separately, since a capture has to come from a merged `dev` and the two mirrors must land together. See [Projection Fixture Corpus](contribute/generate-projection-corpus.md).- **`kajson` version**: The pin moves to `kajson==0.7.1`, the release making `ClassRegistry.register_classes_dict({})` a no-op instead of raising `IndexError` — its logging branch for the single-class case indexed into an empty collection. This engine seeds a fresh per-run or per-library registry from a snapshot of the process-global one, so a snapshot that happens to be empty used to crash the seeding rather than register nothing; both seeding sites (distributed-run rehydration and the scoped-registry test fixture) are now safe unconditionally. The release changes nothing in the encoder or decoder, so the serialized wire format is untouched in both directions. Everyone downstream inherits that exact version.### Removeddiff --git a/CLAUDE.md b/CLAUDE.mdindex 668981253..c9514ec5c 100644--- a/CLAUDE.md+++ b/CLAUDE.md@@ -166,7 +166,12 @@- **`generate-projection-corpus`**: Write the shared inputs-template projection fixture corpus — the descriptors, the expected fill-in templates in both shapes and both formats, and the record of where the expectation deliberately differs from the engine's own renderer. Sole producer of the capture committed byte-identically in `mthds-js/tests/fixtures/protocol/` and `mthds-python/tests/fixtures/protocol/`, which is what pins the TypeScript and Python projections against each other. See `docs/contribute/generate-projection-corpus.md`.```bash- .venv/bin/pipelex-dev generate-projection-corpus tests/data/input_semantics/*.mthds -o /tmp/projection-corpus+ .venv/bin/pipelex-dev generate-projection-corpus \+ tests/data/input_semantics/hinted_bundle.mthds \+ tests/data/input_semantics/probe_bundle.mthds \+ tests/data/input_semantics/scaffold_bundle.mthds \+ tests/data/input_semantics/output_bundle.mthds \+ -o /tmp/projection-corpus```- **`drift`**: Drift contracts — deterministic review obligations between code and docs, declared in the root `drift.toml` (see `docs/contribute/drift-contracts.md`). When `make drift-check` (part of `make agent-check`, `make check`, and CI) reports an open contract: run `make drift-plan` to see what changed and what to review, actually review the targets and fix what is stale, `git add` the trigger files (the digest reads the git index, not the working tree), then record the review with `make drift-ack CONTRACT=<id> RATIONALE="…"`. The rationale is the on-the-record review decision — write an honest sentence. There is no bypass flag; "reviewed, no doc change needed" is a legitimate rationale.diff --git a/docs/contribute/generate-projection-corpus.md b/docs/contribute/generate-projection-corpus.mdindex 71b613ccd..9a9b9db65 100644--- a/docs/contribute/generate-projection-corpus.md+++ b/docs/contribute/generate-projection-corpus.md@@ -9,6 +9,7 @@ The MTHDS build routes no longer render a pipe's fill-in inputs template on thetests/data/input_semantics/hinted_bundle.mthds \tests/data/input_semantics/probe_bundle.mthds \tests/data/input_semantics/scaffold_bundle.mthds \+ tests/data/input_semantics/output_bundle.mthds \-o /tmp/projection-corpus```@@ -65,13 +66,15 @@ The verdict follows the same declared-never-discovered discipline as the divergeThe manifest holds the error's **class name**, never its message. The class name is contract-stable — the error-identity snapshot makes a rename a reviewable diff — while the message is wording that would churn these committed bytes across pydantic versions, so it goes to the console and to the refusal only. Passing verdicts are printed as a count, never committed: a template the shaper takes back is the state every entry is working towards, not a fact worth pinning.-The entries declared today are all one descriptor gap — a nested list inside a structure — which takes both shapes of the two probe pipes that reach it. Closing it deletes the four entries; the lapse rule fails the command until somebody does.+Two gaps are declared today, and each entry names the item whose fix retires it. One is a descriptor gap — a nested list inside a structure — which takes both shapes of the two probe pipes that reach it. The other is `native.Anything`, whose slot the input shaper refuses: it accepts a bare string alone at an `Anything` position, so the empty object the contract publishes as that slot's template is a template the runtime cannot take back. Closing either one deletes its own entries; the lapse rule fails the command until somebody does.++A key is a whole template and never a slot, and the shaper stops at the first slot it refuses — so an entry suspends this check for every other slot in the same pipe. Put a known-open gap in a pipe of its own rather than declaring the pipe that happens to contain it: `scaffold_anything_slot` exists for exactly that reason, so that `scaffold_open_natives` beside it keeps round-tripping and the `unknown-empty-object` claim keeps the one site that demonstrates it.## The bundles-`tests/data/input_semantics/` holds the corpus bundles. `probe_bundle.mthds` exercises every construct the language accepts and `hinted_bundle.mthds` the intent hints; `scaffold_bundle.mthds` was added for this corpus and covers what the other two do not — a text field merely named `url` beside a real file position, an optional nested structure, optional `native.Image` and `native.Document` fields inside a structure, and both a fixed `[N]` and a variable `[]` slot over a structured concept. Its `scaffold_open_natives` pipe holds the natives whose payload shape the descriptor states openly, at slot positions: `native.Dynamic` and `native.Composite`, which declare no pinned structure and whose node is therefore `unknown`, beside `native.JSON`, which does declare one — its pinned blueprint carries a required `json_obj`, so it expands like any other pinned native and its dict is where `unknown-empty-object` is measured.+`tests/data/input_semantics/` holds the corpus bundles, and the command above names every one of them: a bundle that exists in that directory but is left off the command line does not appear in the capture, and the regeneration silently drops the pipes it contributed. `probe_bundle.mthds` exercises every construct the language accepts and `hinted_bundle.mthds` the intent hints; `output_bundle.mthds` covers the output form specifically, since every bundle before it resolved to `Text`; `scaffold_bundle.mthds` was added for this corpus and covers what the others do not — a text field merely named `url` beside a real file position, an optional nested structure, optional `native.Image` and `native.Document` fields inside a structure, and both a fixed `[N]` and a variable `[]` slot over a structured concept. Its `scaffold_open_natives` pipe holds the natives whose payload shape the descriptor states openly, at slot positions: `native.Dynamic` and `native.Composite`, which declare no pinned structure and whose node is therefore `unknown`, beside `native.JSON`, which does declare one — its pinned blueprint carries a required `json_obj`, so it expands like any other pinned native and its dict is where `unknown-empty-object` is measured. Its `scaffold_dynamic_prompt` pipe puts a `native.Dynamic` slot at an LLM prompt position under both markers, which the corpus could not carry while the prompt analyzers read a dynamic concept's universal compatibility as identity and demanded an `ImageContent` for it.-`native.Anything` belongs in that pipe and is not there yet. It no longer crashes the engine's renderer — the structureless arm renders it without resolving a class — but its template value is the empty mapping `{}`, which the input shaper refuses in both shapes, so adding it fails the round-trip gate this page describes. Its slot coverage waits on that being resolved.+`native.Anything` is the third of that family, and it sits in `scaffold_anything_slot` on its own — the one slot the corpus carries knowing the runtime refuses it. It no longer crashes the engine's renderer — the structureless arm renders it without resolving a class — but its template value is the empty mapping `{}`, which the input shaper takes back in neither shape: at an `Anything` position the shaper accepts a bare string alone, and returns it as a `native.Text` stuff rather than an `Anything` one. That is a runtime gap, not a projection one — the descriptor states `Anything` as `unknown` exactly as it states `Dynamic` and `Composite`, and a projection reading only the descriptor has nothing to render there but the empty object. So the slot is captured and both shapes of its own pipe are declared in `EXPECTED_UNSHAPEABLE` against the item tracking the shaper fix, which is the mechanism this page describes for a known-open gap. Giving it a pipe to itself is what keeps that declaration from reaching the three natives beside it that do round-trip. Closing it deletes those entries and regenerates.## When to rerun itdiff --git a/pipelex/cli/dev_cli/commands/generate_projection_corpus_cmd.py b/pipelex/cli/dev_cli/commands/generate_projection_corpus_cmd.pyindex 887cb4487..b469c355c 100644--- a/pipelex/cli/dev_cli/commands/generate_projection_corpus_cmd.py+++ b/pipelex/cli/dev_cli/commands/generate_projection_corpus_cmd.py@@ -140,13 +140,24 @@ DIVERGENCE_ITEMS: dict[str, str] = {# whose template has started shaping fails it too — so closing the gap retires its declaration# deliberately instead of leaving the manifest claiming a defect that no longer exists.#-# Every entry below is the one nested-list descriptor gap (`matrix` in `Widget`), which takes both-# shapes of both pipes that reach it. Its fix deletes these four entries and regenerates.+# A key is a whole template, never a slot, and the shaper aborts at the first slot it refuses — so an+# entry suspends this check for every OTHER slot in that pipe too. A gap therefore belongs in a pipe+# that carries nothing else; where a corpus bundle would otherwise mix it with slots that do shape,+# the bundle isolates it instead of widening the declaration.+#+# Two gaps are declared. `L-260830-191719` is the nested-list descriptor gap (`matrix` in `Widget`),+# which takes both shapes of both probe pipes that reach it. `L-260902-10eb56` is `native.Anything`,+# which is why `scaffold_anything_slot` holds that native alone: its template value is the empty+# object every `unknown` node renders, and the shaper accepts a bare string alone at an `Anything`+# position — so the contract publishes a template the runtime cannot take back. Each fix deletes its+# own entries and regenerates.EXPECTED_UNSHAPEABLE: dict[tuple[str, str], str] = {("input_semantics_probe.probe_markers", COMPACT_SHAPE): "L-260830-191719",("input_semantics_probe.probe_markers", EXPLICIT_SHAPE): "L-260830-191719",("input_semantics_probe.probe_single", COMPACT_SHAPE): "L-260830-191719",("input_semantics_probe.probe_single", EXPLICIT_SHAPE): "L-260830-191719",+ ("input_semantics_scaffold.scaffold_anything_slot", COMPACT_SHAPE): "L-260902-10eb56",+ ("input_semantics_scaffold.scaffold_anything_slot", EXPLICIT_SHAPE): "L-260902-10eb56",}diff --git a/pipelex/kit/agent_rules/codex_commands.md b/pipelex/kit/agent_rules/codex_commands.mdindex f90c971d5..796981911 100644--- a/pipelex/kit/agent_rules/codex_commands.md+++ b/pipelex/kit/agent_rules/codex_commands.md@@ -101,7 +101,12 @@- **`generate-projection-corpus`**: Write the shared inputs-template projection fixture corpus — the descriptors, the expected fill-in templates in both shapes and both formats, and the record of where the expectation deliberately differs from the engine's own renderer. Sole producer of the capture committed byte-identically in `mthds-js/tests/fixtures/protocol/` and `mthds-python/tests/fixtures/protocol/`, which is what pins the TypeScript and Python projections against each other. See `docs/contribute/generate-projection-corpus.md`.```bash- .venv/bin/pipelex-dev generate-projection-corpus tests/data/input_semantics/*.mthds -o /tmp/projection-corpus+ .venv/bin/pipelex-dev generate-projection-corpus \+ tests/data/input_semantics/hinted_bundle.mthds \+ tests/data/input_semantics/probe_bundle.mthds \+ tests/data/input_semantics/scaffold_bundle.mthds \+ tests/data/input_semantics/output_bundle.mthds \+ -o /tmp/projection-corpus```## Pipelex CLI Commandsdiff --git a/pipelex/kit/agent_rules/commands.md b/pipelex/kit/agent_rules/commands.mdindex 3408512af..2385c0223 100644--- a/pipelex/kit/agent_rules/commands.md+++ b/pipelex/kit/agent_rules/commands.md@@ -164,7 +164,12 @@- **`generate-projection-corpus`**: Write the shared inputs-template projection fixture corpus — the descriptors, the expected fill-in templates in both shapes and both formats, and the record of where the expectation deliberately differs from the engine's own renderer. Sole producer of the capture committed byte-identically in `mthds-js/tests/fixtures/protocol/` and `mthds-python/tests/fixtures/protocol/`, which is what pins the TypeScript and Python projections against each other. See `docs/contribute/generate-projection-corpus.md`.```bash- .venv/bin/pipelex-dev generate-projection-corpus tests/data/input_semantics/*.mthds -o /tmp/projection-corpus+ .venv/bin/pipelex-dev generate-projection-corpus \+ tests/data/input_semantics/hinted_bundle.mthds \+ tests/data/input_semantics/probe_bundle.mthds \+ tests/data/input_semantics/scaffold_bundle.mthds \+ tests/data/input_semantics/output_bundle.mthds \+ -o /tmp/projection-corpus```- **`drift`**: Drift contracts — deterministic review obligations between code and docs, declared in the root `drift.toml` (see `docs/contribute/drift-contracts.md`). When `make drift-check` (part of `make agent-check`, `make check`, and CI) reports an open contract: run `make drift-plan` to see what changed and what to review, actually review the targets and fix what is stale, `git add` the trigger files (the digest reads the git index, not the working tree), then record the review with `make drift-ack CONTRACT=<id> RATIONALE="…"`. The rationale is the on-the-record review decision — write an honest sentence. There is no bypass flag; "reviewed, no doc change needed" is a legitimate rationale.diff --git a/tests/data/input_semantics/scaffold_bundle.mthds b/tests/data/input_semantics/scaffold_bundle.mthdsindex 53a2ce5de..c44406d74 100644--- a/tests/data/input_semantics/scaffold_bundle.mthds+++ b/tests/data/input_semantics/scaffold_bundle.mthds@@ -58,9 +58,48 @@ Any number of bookmarks:# `native.JSON` is not: its pinned blueprint carries a required `json_obj`, so it expands like any# other pinned native, and the dict inside it is the corpus's first REQUIRED unknown node — the# engine invents a sample key there, the projection leaves the object empty for whoever fills it in.+# `native.Anything` belongs to the same family and is deliberately NOT here: it is the one open+# native the input shaper refuses, so it sits in its own pipe below rather than putting this whole+# template behind a declared refusal. That matters because the round-trip gate keys on the pipe and+# the shape, never on the slot: an entry here would suspend the shaper check for `json_in`,+# `dynamic_in` and `composite_in` too, and `json_in`'s dict is the only site where the corpus+# measures `unknown-empty-object` — the class whose whole claim is that the empty object round-trips.[pipe.scaffold_open_natives]type = "PipeCompose"description = "SCAFFOLD_pipe_scaffold_open_natives: a pinned-dict native beside the two structureless ones, each at a slot position"inputs = { json_in = "JSON", dynamic_in = "Dynamic", composite_in = "Composite" }output = "Text"template = "SCAFFOLD_template_open_natives: $json_in $dynamic_in $composite_in"++# `native.Anything`, alone, because the runtime refuses the template the descriptor makes it publish.+# The node is `unknown` exactly as its two siblings above are, so the projection renders the same+# empty object — and those two hand that value straight back, while `native.Anything` alone has no+# dict-content arm: the shaper answers "not compatible with a dict content" and accepts a bare string+# there and nothing else, returning it as a `native.Text` stuff. Both shapes of THIS pipe are+# therefore declared in the capture's unshapeable record, and nothing else is dragged in with them.+[pipe.scaffold_anything_slot]+type = "PipeCompose"+description = "SCAFFOLD_pipe_scaffold_anything_slot: the one open-shaped native whose published template the runtime refuses, alone at a slot position"+inputs = { anything_in = "Anything" }+output = "Text"+template = "SCAFFOLD_template_anything_slot: $anything_in"++# A `native.Dynamic` slot read by a PipeLLM prompt, under both markers. Until the prompt analyzers+# stopped reading universal compatibility as identity, this bundle did not validate at all: a dynamic+# input was recorded as a DIRECT image reference and dry-run validation demanded `ImageContent`. It+# renders as text through the prompt like any other variable, which is what makes it a slot the+# corpus can carry — the descriptor states it `unknown` exactly as the PipeCompose above does, so the+# capture holds one open-shaped native at an LLM prompt position beside the same native at a+# template position.+[pipe.scaffold_dynamic_prompt]+type = "PipeLLM"+description = "SCAFFOLD_pipe_scaffold_dynamic_prompt: a structureless native read by an LLM prompt under both markers"+inputs = { dynamic_prompted = "Dynamic", bookmark = "Bookmark" }+output = "Text"+prompt = """+SCAFFOLD_prompt_dynamic_marker_at:+@dynamic_prompted+SCAFFOLD_prompt_dynamic_marker_dollar: $dynamic_prompted+And the bookmark beside it:+@bookmark+"""diff --git a/tests/unit/pipelex/cli/dev_cli/test_generate_projection_corpus.py b/tests/unit/pipelex/cli/dev_cli/test_generate_projection_corpus.pyindex fc39e5c5a..d09100ccd 100644--- a/tests/unit/pipelex/cli/dev_cli/test_generate_projection_corpus.py+++ b/tests/unit/pipelex/cli/dev_cli/test_generate_projection_corpus.py@@ -45,6 +45,7 @@ CORPUS_BUNDLES = [Path("tests/data/input_semantics/hinted_bundle.mthds"),Path("tests/data/input_semantics/probe_bundle.mthds"),Path("tests/data/input_semantics/scaffold_bundle.mthds"),+ Path("tests/data/input_semantics/output_bundle.mthds"),]# A pipe declaring no inputs at all, which no corpus bundle does: the descriptor is the empty form@@ -123,7 +124,8 @@ class TestGenerateProjectionCorpus:# (L-260831-1e1a71) will change it without changing anything this corpus pins.assert entry.error_type- # The gap is a descriptor one, so it takes both shapes of the pipes it touches.+ # Both declared gaps sit under the shape, not above it — a descriptor gap in the probe pipes+ # and a runtime one at the `Anything` slot — so each takes both shapes of the pipe it touches.assert {entry.shape for entry in manifest.unshapeable} == set(manifest.shapes)async def test_a_rerun_writes_the_same_bytes(self, tmp_path: Path) -> None:diff --git a/wip/open-native-inputs/plan.md b/wip/open-native-inputs/plan.mdindex e1dc1e887..7de8672f9 100644--- a/wip/open-native-inputs/plan.md+++ b/wip/open-native-inputs/plan.md@@ -104,6 +104,16 @@ This is the work L-260831-264cbd had to leave behind, and it lands as a fixture> Phase 3 is tracked by L-260902-543ad0, filed when Phase 1 landed: both bug items that used to carry this campaign are closed, so the document's `item:` now names the phase that is still open rather than a finished one.+> **Checkpoint 3 recorded (2026-09-02) — the `pipelex` half.** Both slots are in: `native.Anything` arrives as `scaffold_anything_slot`, a pipe of its own, and a new `scaffold_dynamic_prompt` PipeLLM puts a `native.Dynamic` slot at a prompt position under both markers. One authoring constraint is worth carrying forward: the `@` marker had to move onto its own line, because the sigil produces tag-wrapped block content and rejects an inline use. The capture regenerates deterministically — no divergence class appears or retires, and two runs taken either side of a `plxt fmt` that realigned the new pipe's keys are byte-identical.+>+> **The item 4 risk resolved as declaring the gap, not as fixing the shaper.** Re-measured on `dev` at `82c56b8e3` through `shape_inputs` with the pipe's own `anything_in` spec, an `Anything` slot accepts a bare string and nothing else, returning it as a `native.Text` stuff; the empty object the contract publishes as its own template is refused in both spellings, as are number, bool, list and dict, and even the *enveloped* string is refused ("not compatible with native concept 'native.Text', 'native.Date', or 'native.Time'") — narrower than the earlier probe recorded, which measured the bare form. So the slot is captured with both its shapes declared in `EXPECTED_UNSHAPEABLE` against L-260902-10eb56, filed for the shaper arm. That is the round-trip gate's own mechanism for a known-open gap rather than a workaround: an entry states the gap, the manifest records it, and the lapse rule fails the command the moment the template starts shaping, so the fix retires its own declaration and forces the regeneration. Declaring it is not the projection difference the phase warned against — a projection difference would pin a *projection* nobody can submit, where this pins the descriptor's only honest rendering and names the runtime as what has to catch up, which is exactly what `docs/under-the-hood/pipe-io-contracts.md` already says about R1's width.+>+> **Two things a pre-landing review changed, both about a gate that stops measuring.** `anything_in` was first added to `scaffold_open_natives` beside `json_in`, `dynamic_in` and `composite_in`. An `EXPECTED_UNSHAPEABLE` key is a whole template and the shaper aborts at the first slot it refuses, so that one declaration suspended the round-trip check for the three natives beside it — and `json_in`'s dict is the only site in the corpus where `unknown-empty-object` is measured, the class whose committed reason string says in so many words that the empty object round-trips. Measured: the pipe shaped cleanly before the slot arrived and was a declared refusal after, so the loss was real and silent, and any future projection regression at those three slots would have landed inside the declaration and exited 0. Giving `Anything` its own pipe keeps the gap declared and gives the other three their check back. The rule this produced is now stated where the registry is defined and on the contributor page: a known-open gap belongs in a pipe carrying nothing else.+>+> **And the corpus turned out to be four bundles, not three.** `output_bundle.mthds` has been part of the committed mirror capture since the output-form descriptor landed, but it was never added to the command block on the contributor page, to `CORPUS_BUNDLES` in the CI test, or to the agent rules — which named a glob that also swept it in under the wrong order. Every regeneration recipe therefore said three bundles, and following one produces a capture missing every `input_semantics_output.*` pipe. Because `conformance`'s parity check compares the two mirrors against each other and nothing holds a canonical copy, both mirrors shrinking together is green. All four lists now name the four bundles in the mirrors' own order, with `output_bundle.mthds` last so the existing bytes stay stable.+>+> **The cross-repo half is deliberately not in this branch.** A capture must come from a merged `pipelex` `dev`, and the two mirror pull requests have to merge together or `conformance`'s `check-fixture-drift` goes red on `dev` for everyone. Filed as L-260902-f7d9e7 (`mthds-python`) and L-260902-720ec1 (`mthds-js`), both `blocked_by` this phase's item, each carrying the capture's measured summary so the receiving session can check its own regeneration against it. Note for whoever picks them up: cut the recapture branch from `dev`, not from whatever the mirror checkout happens to be sitting on.+## Ledger- Both items carry `plan:` refs at this document. Claim (`ledger claim <id>`) at the start of each implementation phase.@@ -111,5 +121,8 @@ This is the work L-260831-264cbd had to leave behind, and it lands as a fixture## Deferred — noted, deliberately not in scope+- **The unshapeable registry declares a ledger item but never an expected error** (L-260902-587766). `ShapingGate.round_trip` catches bare `Exception` and `declared()` only checks key membership, so any exception at a declared key reads as the declared refusal. Isolating each gap in its own pipe narrows the blast radius to that one template, which is why this is deferred rather than blocking, but the declaration still cannot say what it expects. Moves together with L-260831-1e1a71.+- **A symmetric parity check cannot see a symmetric deletion** (L-260902-e62273, owner `conformance`). `check-protocol-fixture-parity.py` compares the two mirrors against each other and nothing holds a canonical copy, so both mirrors dropping the same pipes is green — which is exactly how the missing `output_bundle.mthds` would have landed unnoticed. Wants a pipe-ref expectation that does not come from the capture under test.+- **`PipeIOContractError` declares no `error_domain`, so its residual causes still render HTTP 500** (a user structure class genuinely missing from the request, a pydantic schema-generation failure). The `Anything` fix removes the illegitimate trigger; whether the remaining ones are INPUT-domain is its own ruling, adjacent to L-260829-fa8267's theme. File a ledger item during Phase 1 rather than widening this PR.- **A sweep of other compatibility-as-identity sites.** `grep is_compatible pipelex/pipe_operators/` shows the same pattern deciding behavior in `pipe_extract`, `pipe_img_gen`, `pipe_compose`, `pipe_search`, `pipe_structure`, and `PipeLLM`'s text-vs-object dispatch — each site reachable with a `Dynamic` input or output, each currently answered by the dynamic short-circuit. Some of those leniencies are by design (`validate_output_with_library` says so explicitly); none has been audited. File as a ledger task during Phase 2.