When `vibe` builds `vibevm/vibespecs/boot/STATIC.xml`, it concatenates the boot text of every static-linked package — today 31 contributions from 27 packages. Each contribution brings its own section labels, and short labels repeat across packages: `{#root}` is defined 26 times in the compiled file, `{#never}` 17 times, `{#when}` 9 times — 59 `duplicate-anchor` warnings over 11 names (host `specmap.json`, measured 2026-08-03). An address of the form «the STATIC file, section root» is a lottery over 26 candidates. Fact-level labels collide too: 61 fact ids appear more than once in the compiled lane (`sibling-document-pointers` ×14, `full-protocol-pointer` ×7 — generic names minted independently by sibling packages; measured the same day).

The second half is why this blocks the marker strip (the original B-011 filing): the compiled lane carries 838 house-grammar tokens (`##ANCHOR` ids, `@stage/state` markers) that outside consumers should not see. Stripping them naively **changes what is addressable**: a dynamically-loaded module can hold a reference to an anchor that existed in the source markup and vanished after cleaning — the reference resolves at authoring time and dangles at read time. The owner's framing (2026-07-31): stripping is not a filter; it needs a resolution design first.

The owner's ruling that made this the highest priority (2026-08-02, verbatim): «От этой вещи зависит как вообще работает загрузка, насколько детерминированно и хорошо». The requirement behind both halves is **deterministic loading**: every label in the compiled world must have exactly one meaning, that meaning must not depend on splice order or on what else happens to be installed, and references must survive both splicing and future cleaning.

Three layers, each independently useful, together closing B-011: **(1) qualified rename-on-splice** — the splicer rewrites every label a contribution defines into a globally-unique qualified form derived from the package's identity, and rewrites every intra-contribution reference to match, so the compiled file has zero duplicate labels *by construction*; **(2) aliases** — `#use spec://… as X` binds a short local name to a source-of-truth address, and `@!X` references through it; because the alias binds to the *address*, not to the compiled text, it survives both splicing and stripping; **(3) a fixed lookup rule** (the C++ ADL analogy) — an unqualified label reference is resolved against exactly two scopes, the defining document and the file's declared aliases, in that order; anything still ambiguous is a compile error listing the candidates — never a silent pick. Dynamic after-the-fact loading of a library carrying its own `STATIC.md` then composes without renaming anything already spliced, because qualified names depend only on the contribution's own identity, never on the splice's composition.

The owner's requirement (2026-08-02, recorded in B-011): «склейщик переименовывает метки внутри STATIC.md так, чтобы все ссылки на эти метки сохраняли валидность по всему документу», plus the qualified-rewrite idea: «Возможно, при материализации нам нужно сразу переписывать все ссылки на qualified варианты? То есть, если кто-то обращается к #root внутри документа, мы понимаем, что это какой-то из "spec://.....#root"».

**The qualified form.** A contribution is identified by its package origin `<group>/<name>` (e.g. `org.vibevm.world/wal`). Its labels are rewritten by prefixing a deterministic slug of that origin: heading `{#root}` → `{#org-vibevm-world--wal--root}`, fact `##THE-RULE` → `##org-vibevm-world--wal--THE-RULE` (the slug is always lowercase; the original tail keeps its case, so the normative-vs-lead casing convention stays readable in the tail). Dots in the group become `-`; the joiner is `--` (legal under the anchor grammar `[A-Za-z][A-Za-z0-9_-]*`; dots are excluded because `.` already means tree-path descent in `spec://` addresses). Both label kinds are rewritten because they share one namespace (PROP-035 §7.3 clause 3: fact and heading ids, one namespace) and both are measured to collide (§1).

**What gets rewritten inside a contribution:** *(i)* heading anchor definitions `{#x}`; *(ii)* fact id definitions `##X`; *(iii)* intra-document markdown links `[…](#x)` that target a label the same contribution defines. **What is deliberately left alone:** full `spec://…` addresses and `@spec://…` in-place uses (they point at the package's source-of-truth document under `vibedeps/`, which the rename does not touch — they stay valid by construction); directive lines (`#use`/`#embed`/`#source` addresses); anything inside fenced code blocks (the scanner's existing fence mask governs); prose mentions of a label that are not links.

**Why a qualified prefix and not disambiguation suffixes** (`root`, `root-2`, `root-3` — the HTML-renderer convention): a suffix depends on splice *order* — adding, removing, or reordering one package renames another package's labels, which is precisely the non-determinism the owner is buying out of. The qualified name is a pure function of `(origin, original label)`: stable across recomposition, self-describing to a human reader, and append-safe (§6). This is a decision the design treats as settled by the owner's «детерминированно» requirement; the open forks are the slug's exact shape (§8, fork A/B).

**The contract this changes:** PROP-009 §2.3 `##ARTIFACT-STATIC-MD` currently reads «the **verbatim** concatenation … of every static-typed contribution». Rename-on-splice makes the lane an **anchor-qualified** concatenation — byte-identical except label definitions and intra-contribution label references. The PROP edit is listed in §7; until the owner approves it, nothing ships.

**What it buys immediately:** the host `specmap.json` stops minting one ambiguous address per short name over the compiled file (26 units currently answer to the same `#root` coordinate); the 59 `duplicate-anchor` warnings drop to zero — the first half of the M-LOAD milestone (`TOOLING-MAP.md` `##M-LOAD`) becomes measurable.

**Grammar.** `#use [options] spec://<…> as <Alias>` — the `as` clause is a suffix after the address; `<Alias>` is an identifier under the existing anchor-segment grammar (`[A-Za-z][A-Za-z0-9_-]*`). Reference form: `@!<Alias>` — the aliased twin of the `@spec://…` in-place use (PROP-035 §7.4): mandatory to read on first encounter, same read-set discipline, same resolution machinery; the only new thing is the indirection through the alias table. A bare `!X` or an alias mention without the sigil means nothing — only `@!X` is grammar.

**Scope: the declaring file, whole-file.** An alias is visible everywhere in the file that declares it (declaration position does not matter — same as imports in most languages); it is not exported, not inherited by `#use`-ers, not global. Two declarations of one alias name in one file: compile error. `@!X` with no declared `X` in the file: compile error naming the known aliases. File-local scope keeps alias names themselves collision-free without any further machinery — the same reasoning that makes short names CLI-sugar-only in qualified naming.

**What the alias binds to — the address, never the text.** `X` resolves to its declared `spec://` address; the address resolves through the existing router against the package's source markup under `vibedeps/` (the `FileResolver` path the `#embed` pass already uses). Whether the *compiled* lane still carries the target's label after a future strip, or has renamed it, is irrelevant to alias resolution — which is the property the whole entry was filed for: «алиасы привязываются к source-of-truth адресу, поэтому переживают и склейку, и стриппинг» (owner, 2026-08-02). This is the second half of M-LOAD: «a dynamic module resolves an alias whose carrier was cleaned».

**What the splicer does with alias forms.** In the compiled `STATIC.md`, `#use … as X` declaration lines are consumed like every `#use` line today (resolved by the topological ordering, stripped from the body), and every `@!X` occurrence is rewritten to the full `@spec://…` address it denotes. The compiled lane therefore contains only fully-qualified references — self-describing without the alias table, resolvable after any amount of cleaning, and exactly the «переписывать все ссылки на qualified варианты» materialisation the owner proposed. Structural (JIT) mode reads the declaration and the sigil directly — no rewrite needed there.

**The rule.** An *unqualified* label reference — an intra-document `(#x)` link, or any future short-form the grammar grows — is resolved against exactly two scopes, in order: **(1)** the anchor namespace of the document that contains the reference; **(2)** the file's declared aliases. Found in (1) → it is the document's own label (and rename-on-splice rewrites both ends together). Found in (2) → it means the alias target. Found in neither, or found in both: **compile error listing the candidates** — the resolver never widens the search to «all documents that define `#x`» and never picks silently.

**What maps to ADL and what deliberately does not.** The C++ analogy the owner named (Argument-Dependent Lookup): a short call resolves against the namespaces *its arguments bring into scope* — context supplies the search set, and the programmer writes the short form. Here the context is the defining document plus the file's imports (aliases): short labels stay writable, and the search set is exactly what the file itself brought into scope. What is *not* imported from C++ is ADL's willingness to search multiple associated namespaces and overload-resolve among the survivors — for a loading contract the ambiguity must be an error, not a ranking. (Precedent for «fail with candidates, let a human record the qualified form»: the qualified-naming flow's collision law.)

**The agent-facing half.** The compiled `STATIC.md` header grows two sentences stating the convention: labels in this file are qualified `<origin-slug>--<original>`; the provenance comment above each block names the origin. A reader (human or agent) who knows a package's short label can derive the qualified one mechanically, and vice versa. No new tooling is required to *read* the lane.

The owner's named hard case (2026-08-02, recorded in B-011): «отдельно рассмотреть сложные случаи динамической дозагрузки новых библиотек, в которых есть собственные STATIC.md».

**Composition without recomposition.** A library L installed later arrives with its own compiled `STATIC.md` — L's own splice of L's static-linked dependencies, with L-world labels already qualified by *their* origins. Loading L into a running project is then: add L's lane as an entry to the host's `INDEX.md` (the existing dynamic-entry mechanism — a by-reference read, PROP-009 §2.3); nothing in the host's already-compiled `STATIC.md` is renamed or re-spliced, because qualified names collide only if two contributions share an origin — and one origin appearing in both lanes is the *same* text twice (a dedup problem, the read-set's job and PROP-038's hoisting — not a collision). L's outward references are full `spec://` addresses (its `@!X` forms were rewritten at L's own compile time, §4), resolved against the host's materialised `vibedeps/` tree. **The determinism claim, stated once:** under qualified naming, what a label means is decided when its package is *authored*, not when the world is *assembled* — so assembly, in any order, at any time, cannot change any meaning.

**No new loader mechanism is proposed here.** The host's `INDEX.md` dynamic entries, the `when` gating, and the structural loader stay as PROP-009/PROP-035 define them; this design only guarantees that the *names* such a load brings along are conflict-free and its references resolvable. A full «hot-attach a package's lane» UX (who writes the INDEX entry, when) is explicitly out of this slice (§9).

**PROP-035 edits:** §7.2 gains the `as <Alias>` clause (grammar + file-local scope + duplicate-alias error); §7.4 gains the `@!X` sigil (semantics: identical to `@spec://` on the alias's target; unknown-alias error); §8's pipeline gains a **qualify** step in the emit phase (each node's labels and intra-node label links rewritten under its origin slug; `@!X` rewritten to the full address); §11 notes that a compiled block's labels are origin-qualified (`decompile` reverses the qualification by stripping the block's own prefix — reversibility preserved).

**PROP-009 §2.3 edit:** `##ARTIFACT-STATIC-MD`'s «verbatim concatenation» becomes «anchor-qualified concatenation» with one sentence defining the qualification; `##SESSION-START-ORDER` unchanged.

**BACKLOG B-011** gets the acceptance restated as M-LOAD's two measurements (zero `duplicate-anchor` over the compiled lane; an alias resolving with its carrier cleaned) plus the append-safety property test of §6.

Four forks, each with the boss's recommendation first:

**The marker strip itself** — B-011 is «aliasing design first»; the strip builds on top once aliases + qualification land (its own entry when commissioned).

**The git-family double emission** (B-006) — a dedup/hoisting matter; qualification makes the duplicate *visible as* a same-origin repeat rather than a collision, but removing it is B-006's own build.

**The host-as-package root** (B-031) and the grammar-superset decision (B-028) — adjacent loading-plane builds, sequenced after B-011 in wave А.

**A hot-attach UX** for dynamic library lanes (§6) — the naming guarantees are this slice; the workflow that writes the INDEX entry is not.

Four work slices, each a native collaboration packet with a disjoint perimeter; every slice self-verifies with `cargo check -p vibe-spec` / `-p vibe-workspace` class commands and lands behind the existing gate panel:

The §7 PROP edits are boss work (spec authoring is never delegated), applied only on the owner's approval of this design.