The gate gains seam-error and conformance-assertion parity across languages

1. The measured basis

02Seam errors — one paradigm, three states (census R1). The Rust paradigm is one fact (Fact::ErrorVariant, facts.rs:66-73) carrying both the Display message and the owning-enum enum_attrs, and two rules each gating a different field: ErrorMessageCitesReq (diagnostics.rs:229-282, fires when the Display text carries no spec://) and ErrorEnumCitesReq (:308-366, fires when the enum carries no #[spec(...)]). Go has only the structure half — the seam_error_missing_req finding-kind INSIDE the go-unsafe-in-domain umbrella (rules/go.rs:145-149), emitted by go-extract when a *Error type owning an Error() method has no Spec field (extract.go:519-535); no rule id of its own, and the message half (does Error() render the REQ?) is checked by nobody because go-extract never reads an Error() body (census R1 Q2). TS has neither half — no error fact, no error rule; the extractor emits nothing carrying union shape, variant members, or a spec:// reference on an error type (R1 Q4), though the guide promises «E a discriminated union of named error variants carrying spec:// REQ references» (GUIDE-AI-NATIVE-TYPESCRIPT.xml:152,159).

03Conformance assertions — Go idiom live, gate blind (census R2). The Go idiom var _ seams.X = (*Impl)(nil) is live (four demo sites, the guide's own — MUST example at GUIDE-AI-NATIVE-GO.xml:201) and the guide PROMISES «conform checks its presence (T-syn)» while self-annotating that promise as not-yet-built (→ B-030). But go-extract actively discards the assertion: the ValueSpec branch skips every _-named var (extract.go:461-463, «conformance assertions et al.»), so no fact reaches the engine. Rust has no var _ analogue rule — cargo check at the use site IS the assertion (GUIDE-AI-NATIVE-RUST.xml:68), and the guide makes no promise that a gate checks a written assertion (R2 Q3). TS promises branded seams / satisfies never / type-level tests (GUIDE-AI-NATIVE-TYPESCRIPT.xml:130,154,237); the gate checks none and the extractor emits no fact for any (R2 Q4).

04The floor asymmetry (B-049, parity loop row 13). Go and TS consumers disable a floor step with a recorded reason (GoConfig/TsConfig floor_disable, enforced with a loud print + hard-fail on an unknown step); the Rust floor (rust-ai-native-cli/src/floor.rs:46-141) runs every step unconditionally and RustConfig has no such field — the loop's one asymmetry pointing the wrong way.

05The wire every new signal rides (census R1 Q5, R2 Q2). The ts_env_read pathway (B-039) is the proven four-hop template: extractor emit → bridge RawFact arm → engine Fact → rule match → driver mount. Adding a Fact variant bumps the frontend version and retires cache slots (facts.rs:5-8) AND is a cross-package ripple (batch-1 lesson, §8 sixth paid fact); adding a Kind VALUE to the existing GoUnsafe fact is neither.

2. The boss decisions (no owner fork inside this batch)

06No map fork opens here. The two nearest owner forks are taken (№2 gate units, №9 parity home). Every choice below is a boss design decision on measured fact, not an owner decision — recorded so the workers elaborate, never redraw. Should elaboration surface a genuine owner fork, it stops for the owner one at a time (the standing rule); none is expected.

07One Go rule, both halves, per-half fingerprints. The Go doc promises a single named rule — «seam-error-cites-req — a seam's closed error set carries its REQ URI» (conform-frontend-go.xml:41). Go's idiom is one struct type with two obligations (carry the spec:// URI as a Spec field; render it in Error()), so the projection is one rule go-seam-error-cites-req, not two. Rust's two-rule split is an artifact of its two-field fact, not a strength Go lacks: one Go rule checking both halves is not weaker than two Rust rules checking one half each (the parity test is strength, not id count — §4). The baseline granularity Rust's two ids give is preserved by two distinct fingerprints off the one rule (…-structure|… and …-message|…), so the ratchet still tightens each half independently and SARIF still separates them.

08The TS twin builds now, conservatively, with its limit recorded. The parity principle (being lifted this batch) forbids leaving TS weaker without a recorded reason, and «TS has nothing» is not a reason — it is the gap. So ts-seam-error-cites-req is built now. Detection is the honest-minimal form (the batch-1 ts-flag-sites precedent: build the detectable core, record the undetectable remainder as a documented limit, never a silent claim). The exact discriminated-union-error heuristic is a measured refinement point (§3.3).

09B-030's survey verdicts. Go — build the presence rule; the written var _ assertion is the one seam-conformance signal that can drift, so a presence check earns its keep (owner ruling 2.2a). Rust — record the reason, do not build: the compiler at the use site is the assertion (GUIDE-AI-NATIVE-RUST.xml:68); the guide promises no gate-checked written assertion, so there is no promise-without-check to close — a genuine recorded reason, not a refusal. TS — record and route: the guide's promise that public branded/union surfaces carry type-level tests (:237) IS a promise-without-check, but its build (detecting expectTypeOf/tsd/ @ts-expect-error/satisfies never presence) is a distinct rule over a distinct surface from the Go var _ scan; it is named as parity debt carried by the B-035 loop, not silently dropped and not crammed into this batch (BUILD-FIRST is honoured by a named carrier, not by same-batch delivery).

10The fact plan (ripple-minimising). The Go message half rides a new GoUnsafe KIND seam_error_message_no_req — no new Fact variant, no ripple. The Go assertion signal needs seam+impl names the GoUnsafe {kind, line} fact cannot carry, and overloading the ban-census go_unsafe with a POSITIVE signal is semantically wrong — so a new Fact::GoConformance variant. The TS seam-error signal needs union/citation shape no existing TS fact carries — a new Fact::TsSeamError variant. Two new variants → two ripples; the engine-spine worker greps the whole tree and budgets exhaustive-match arms in every frontend (§5, S1).

3. The design past the decisions (boss-settled, worker-elaborated)

4. The parity-principle lift (boss contract diff, fork №9)

19The home, ruled. Map fork №9 (2026-08-04): «Ядро дисциплины» — the language-neutral guiding layer of core-ai-native, manifesto level, one home, the stacks cite. The carrier is 00-MANIFESTO.xml §4 (where the strictness lives), a boss-authored clause set the language guides cite.

20The principle (owner verbatim, 2026-08-02, B-035 anchor): «Мы по условию идеи не должны делать поддержку других языков … хуже, чем это сделано для Rust. А по факту мы почему-то начинаем ослаблять правила без видимой причины». Lifted to a discipline law: no language projection enforces the discipline more weakly than another; where a projection genuinely lacks an idiom's analogue, the gap is recorded with its reason — never left silent. It is the projection-level twin of ##BAN-WITHOUT-HATCH-IS-A-BUG: an unexplained asymmetry between projections is a bug in the discipline exactly as a reasonless deviation is a bug in the code. The pilot (Rust) is the current reference bar, not a permanent privilege; Python inherits the law on arrival.

21The stacks cite, they do not restate. Each language guide adds one citation to the new manifesto anchor beside its own conformance section (Go ##CONFORMANCE-IS-MADE-LOUD, TS ##RULE-FAILURE-ON-A-SEAM-IS-A-TYPED-VALUE, Rust its scaffold-F row), so the principle has one home and N pointers — the gate-parity-config home-and-pointers pattern.

5. The build cut

22S1 — engine spine (one thread, cargo-heavy): in canonical core-ai-native/v0.8.0 only — facts.rs (Fact::GoConformance, Fact::TsSeamError, the new seam_error_message_no_req kind documented in the kinds docstring); rules/go.rs (GoSeamErrorCitesReq consuming both Go kinds with per-half fingerprints, GoConformanceAssertion; the seam_error_missing_req arm removed from GoUnsafeInDomain); rules/typescript.rs (TsSeamErrorCitesReq); rules/mod.rs re-exports; engine unit tests feeding the new facts; the ripple — grep the whole tree for exhaustive Fact matches and add arms for the two new variants in every frontend (the Rust FE total sort, health census, any consumer). Self-verify: canonical engine check + test + clippy -D warnings + wc -l ≤ 600 per changed .rs (split rules/go.rs along seams if it crosses the budget). One thread because facts.rs/mod.rs are shared and the ripple crosses packages.

23S2a ∥ S2b — extractors + bridges (two disjoint lanes, after S1 lands + sync-engines): S2a (Go): extract.go reads Error() bodies (emit seam_error_message_no_req) and recognises var _ Seam = (*Impl)(nil) before the _-skip (emit the conformance record); go-bridge gains the RawFact arm → Fact::GoConformance (the message half rides the existing go_unsafe mapping — verify the kind flows). S2b (TS): extract.ts detects the error union (§3.2 heuristic) and emits ts_seam_error; ts-bridge gains RawFact::TsSeamError → Fact::TsSeamError. Disjoint files (go- vs ts-) → parallel. Self-verify: each extractor's own go test / node --test + the bridge crate's cargo check/test.

24S3 — driver mounts + B-049 (parallel, disjoint): Go driver build_rules mounts GoSeamErrorCitesReq (always) + GoConformanceAssertion (conditional on cells_dir); TS driver mounts TsSeamErrorCitesReq; B-049 (its own lane, may run as early as alongside S1 — disjoint from facts.rs/rules): RustConfig.floor_disable + rust floor enforcement. Self-verify: each driver crate's check/test/clippy; a live demo exhibit at real exit.

25S4 — docs + demo + fixtures + citations (doc lane, after the rules are real): the Go guide's ##RULE-SEAM-ERROR-CONTRACT and ##CONFORMANCE-IS-MADE-LOUD self-annotations die (the rule and the message half are built; the assertion presence is checked); the TS guide's «Specified, not built» seam-error note dies and its type-level-test routed-build is named honestly; the parity-principle citation lands in all three guides (#lift-citation); demo/fixtures gain the citing and non-citing exhibits for each new rule (red exhibit per new rule).

26The boss tail per slice: review by WORKER-REPORT (existence part of the set-compare), cargo xtask sync-engines from the host root whenever a package crate changed, cargo fmt --all + fmt per package manifest, vibe install rematerialise after canonical package edits, cargo clean -p before diagnosing any stale-fingerprint build, panel bare with the tail read on an untouched tree, commits per Rules 1–4, meta.md per worker. After the batch: the B-035 loop pass №2 re-cuts the parity table, and the F-185 family re-judgement drains through vibe progress mirror --campaign → merge-verdicts.py → seal (never chained; seal takes explicit paths).

6. Acceptance

27Measured, not narrated: (1) go-seam-error-cites-req is a distinct rule id emitting two fingerprints — a dirty seam error red on both halves, the clean demo green — exhibited; (2) ts-seam-error-cites-req reds a non-citing error union and greens a citing one on the demo, its limit documented — exhibited; (3) go-conformance-assertion reds a cell missing var _ Seam = (*Impl)(nil) and ignores the var _ = New near-miss — exhibited; (4) the Rust floor disables a named step with a loud print and hard-fails an unknown one — exhibited; (5) the parity principle reads once in the manifesto and is cited by three guides; (6) the panel green with the tail read; (7) the B-035 loop table shows no language cell weaker than Rust without a recorded reason, and F-185's family re-judgement rides the landing.