Release train v0.35.0: embedded regions + Svelte 0.2.0, Vue 0.1.0, Ruby 0.9.0 (RSpec), #336 precision, #340 influence cost, #339, #346 #351

Closed
buildagent wants to merge 0 commits from train-0.35 into master
Member

This is release train v0.35.0. The operator asked to batch issues into one CI round and one release instead of one round per issue. All lanes were integrated on train-0.35, rebased onto master 05dcbee2 (#344 CI fast path), version-bumped to 0.35.0, and run through ONE full local gate run.

Contents

Item What Kind
#275 Embedded regions: a package names a byte range, the host's compiled-in TS/JS extractor indexes it. Svelte 0.2.0 hands every <script> over. host + package
#275 follow-up lang joins the resolver's group keys. Without it, one file holding two languages that use one name failed the WHOLE index pass with UNIQUE constraint failed: resolve_groups…. host
#331 de.h-dv.vue 0.1.0: <script> / <script setup> via embedded regions; template component tags, handlers, interpolations. On Zammad, 525 .vue files gain 5,472 symbols and 7,331 newly resolved refs. new package
#335 de.h-dv.ruby 0.9.0 (shared walker): RSpec groups and examples are symbols; constants in arguments are refs. Host side: the enclosing-symbol sweep (−3..−16% SQLite work on all pinned repos) and a whitespace-name pool rule. host + package
#336 Proximity (same-file / same-directory) may no longer choose the target of a call on a captured receiver, in every language. Schema v80 re-decides the affected rows once. host
#340 Influence step 3 computes competitors once; the anchor arm matches by key. On Zammad + Vue the step goes 516M → 35M vm_step; results identical on every ref. host
#339 A package profile stored by an older host decodes over its extends profile; re-recording it is not a move. host
#346 plugin status names a live daemon's build instead of "interrupted — retry". host
#343 A regression test pins that a restart after a killed promotion runs the owed resolve. Not reproduced in the field. test
fix-ups code-index://registry/plugins is served whole or refused, never truncated (the catalog had outgrown the 4k cap). A Pss-reading test runs alone. disclosure_derivation_registry handles braceless #[cfg(test)] items. host

Records re-recorded (each operator-approved, with categorised reasons)

  • #335: ruby-sinatra rows (+489 binds, 0 moved; the known ::Logger wrong bind is named). cost-baseline.json whole-record re-measured after two reduction rounds.
  • #336: rows for sinatra, flask, zod, ripgrep, django and rust-analyzer. Sampled wrong-bind rates: flask ~100%, Ruby/Python/TS ~75–90%; Rust ripgrep has a ~57% correct-bind loss, tracked as #348.
  • #275: the embedded_dispatch_version condition.
  • Ruby package cost: re-measured on the final tree. It is cheaper than before #340 on both counters, after the anchor-scan fix.
  • Unchanged: baseline.json rows for repos that did not move are byte-identical.

Local full run (train @ 166f2a3a, before the fix-ups)

  • fmt, clippy, rustdoc (-D warnings --document-private-items) and guest_gates.sh: clean.
  • nextest ci: 4816/4819. The 3 failures were fixed by the fix-ups and re-run green (registry_mcp_e2e 7/7 in both legs, idle_worker_footprint).
  • nextest ci-timing: 31/31.
  • Doc-tests and the daemon leg: green.
  • Corpus: all 13 suites from ci.yml green (ratchet, stage, cost, mutation, metamorphic, scale, tier3, watcher_replay, require_floor, migration_cost, package_baseline, …).
  • precision_gate: 7/7 with phantoms 0, and the POPULATION lines are unchanged (forbid_sites JS 2, Ruby 3, PHP 3, C# 3, TS 5, Rust 20, Python 39).
  • After the fix-ups: fast_gates.sh 62/62 targets, clippy, fmt.

Known limits (in the release notes)

  • A template reference does not yet bind to a symbol in the same file's script; that needs a cross-language tier.
  • Rust recall cost of #336 (#348).
  • Python package cold cost (#347).
  • Package-owned source (#345).

Note

The title of c891fc75 says "CORPUS RECORDS NOT RE-RECORDED". f8505460 re-records them, and the history is kept as is.

🤖 Generated with Claude Code

https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu

This is release train v0.35.0. The operator asked to batch issues into one CI round and one release instead of one round per issue. All lanes were integrated on `train-0.35`, rebased onto master 05dcbee2 (#344 CI fast path), version-bumped to 0.35.0, and run through ONE full local gate run. ## Contents | Item | What | Kind | |---|---|---| | #275 | Embedded regions: a package names a byte range, the host's compiled-in TS/JS extractor indexes it. Svelte 0.2.0 hands every `<script>` over. | host + package | | #275 follow-up | `lang` joins the resolver's group keys. Without it, one file holding two languages that use one name failed the WHOLE index pass with `UNIQUE constraint failed: resolve_groups…`. | host | | #331 | de.h-dv.vue 0.1.0: `<script>` / `<script setup>` via embedded regions; template component tags, handlers, interpolations. On Zammad, 525 `.vue` files gain 5,472 symbols and 7,331 newly resolved refs. | new package | | #335 | de.h-dv.ruby 0.9.0 (shared walker): RSpec groups and examples are symbols; constants in arguments are refs. Host side: the enclosing-symbol sweep (−3..−16% SQLite work on all pinned repos) and a whitespace-name pool rule. | host + package | | #336 | Proximity (same-file / same-directory) may no longer choose the target of a call on a captured receiver, in every language. Schema v80 re-decides the affected rows once. | host | | #340 | Influence step 3 computes competitors once; the anchor arm matches by key. On Zammad + Vue the step goes 516M → 35M vm_step; results identical on every ref. | host | | #339 | A package profile stored by an older host decodes over its `extends` profile; re-recording it is not a move. | host | | #346 | `plugin status` names a live daemon's build instead of "interrupted — retry". | host | | #343 | A regression test pins that a restart after a killed promotion runs the owed resolve. Not reproduced in the field. | test | | fix-ups | `code-index://registry/plugins` is served whole or refused, never truncated (the catalog had outgrown the 4k cap). A `Pss`-reading test runs alone. `disclosure_derivation_registry` handles braceless `#[cfg(test)]` items. | host | ## Records re-recorded (each operator-approved, with categorised reasons) - **#335:** ruby-sinatra rows (+489 binds, 0 moved; the known `::Logger` wrong bind is named). `cost-baseline.json` whole-record re-measured after two reduction rounds. - **#336:** rows for sinatra, flask, zod, ripgrep, django and rust-analyzer. Sampled wrong-bind rates: flask ~100%, Ruby/Python/TS ~75–90%; Rust ripgrep has a ~57% correct-bind loss, tracked as #348. - **#275:** the `embedded_dispatch_version` condition. - **Ruby package cost:** re-measured on the final tree. It is cheaper than before #340 on both counters, after the anchor-scan fix. - **Unchanged:** `baseline.json` rows for repos that did not move are byte-identical. ## Local full run (train @ 166f2a3a, before the fix-ups) - fmt, clippy, rustdoc (`-D warnings --document-private-items`) and `guest_gates.sh`: clean. - nextest `ci`: 4816/4819. The 3 failures were fixed by the fix-ups and re-run green (`registry_mcp_e2e` 7/7 in both legs, `idle_worker_footprint`). - nextest `ci-timing`: 31/31. - Doc-tests and the daemon leg: green. - Corpus: all 13 suites from ci.yml green (ratchet, stage, cost, mutation, metamorphic, scale, tier3, watcher_replay, require_floor, migration_cost, package_baseline, …). - precision_gate: 7/7 with phantoms 0, and the POPULATION lines are unchanged (forbid_sites JS 2, Ruby 3, PHP 3, C# 3, TS 5, Rust 20, Python 39). - After the fix-ups: `fast_gates.sh` 62/62 targets, clippy, fmt. ## Known limits (in the release notes) - A template reference does not yet bind to a symbol in the same file's script; that needs a cross-language tier. - Rust recall cost of #336 (#348). - Python package cold cost (#347). - Package-owned source (#345). ## Note The title of c891fc75 says "CORPUS RECORDS NOT RE-RECORDED". f8505460 re-records them, and the history is kept as is. 🤖 Generated with [Claude Code](https://claude.com/claude-code) https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
A new optional fact record, 0x8009: `span | language u16 | scope u8`.
The language is an INDEX into the host-owned EMBEDDED_LANGUAGES table
(typescript, javascript), never a string; scope says whether the
region is an instance script (nothing importable) or a module script.

validate() refuses, each from one comparison:
  * end past the file / inverted        fact.region_out_of_range
  * a region inside or around its
    predecessor (depth budget is one)   fact.region_depth_exceeded
  * an index outside the table          fact.region_language_unknown (new, appended)
  * a guest fact starting inside a
    region the same frame delegated     fact.language_not_owned
  * empty, descending, partial overlap,
    scope byte > 1                      abi.non_canonical
  * more than MAX_EMBEDDED_REGIONS (64)  fact.count_exceeded

Each extent is charged against max_decoded_bytes; disjointness bounds
the parsed bytes by the file, so the "64 one-byte regions at EOF parse
64 copies of the file" shape is not reachable. Skippable, and skipping
is thinner rather than wrong, so ABI_MINOR does not move.

Three producerless reason codes gain producers; reason_producers'
PRODUCERLESS and the reason-code register drop their rows in the same
commit. The guest kit gains the language rows, the region tag/scope
bytes and the ceiling as CONSTANTS ONLY: an SDK method moved all nine
build.py extractors' bytes (measured), so the svelte guest builds the
record through the existing Encoder::raw.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`embedded::delegate` extracts each validated region with the compiled-in
TypeScript/JavaScript extractor — the type admits only a LanguagePlugin,
so another package's sandboxed extractor is unreachable by construction.
The region is SLICED, not padded, and positions are shifted back into
the file (lines by the region's line, first-line columns in codepoints),
so total parsed bytes stay bounded by the file. The parse runs under the
worker's wall-clock budget (HostDeadlineExceeded, transient); scope
decides visibility (instance script: all `file`; module script:
`unknown` -> `file`, exports kept).

Each region is written as its own file_contributions row at
[region_start, region_end) under the DELEGATING package's key
(de.h-dv.svelte/typescript) via contributions::ensure_delegated_component,
which refuses a reserved key and inherits the package's grant; the
ordinary grant writer now re-grants every component of a package.

Scoped vs Full: instead of folding into the file-level outline hash
(signatures -> every $state edit Full), write_upsert compares the POOL
outline (name, kind, visibility, parent) across all contributions,
read back from the rows it replaces — no stored column, no migration.
Adds/removes force Full; initializer edits stay Scoped. The container
rule in write_upsert is contribution-scoped.

EMBEDDED_DISPATCH_SEMANTICS_VERSION 0 -> 1 (every index re-activates via
Cause::EmbeddedDispatch), pinned beside embedded::DELEGABLE.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The guest still reads nothing inside <script>; it now names the body's
range: lang="ts"/"typescript" -> TypeScript, no lang / js -> JavaScript,
any other lang -> no region; `module` / context="module" -> module scope.
Capped at MAX_EMBEDDED_REGIONS with extract.node_limit_reached.

0.1.0 was released, so the version moves: svelte.digest, the registry
row and the extractor pin are re-recorded; the frozen host fixture is
svelte@0.2.0 (0.1.0 removed, nothing reads it).

svelte_package_e2e: the 0.1.0 "script yields nothing" criterion becomes
the positive one (rows under de.h-dv.svelte/typescript over exactly the
script bytes, file-visible); find_callers reaches delegated calls at
file positions through CRLF and a multi-byte prefix, binds across files
through the script's import, and does NOT bind a .ts caller to an
instance-script helper; removing a script function removes its symbol.
The cross-directory component ceiling is re-measured with the import
present: still not bound (template ref vs TypeScript import row).

svelte_package_cost: delegation vs the same TypeScript standalone,
parity on symbols AND positions, wall ratio floor/ceiling.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
A security review flagged a0e5768b for capability-grant bleed. Measured:

* ensure_delegated_component COPIED its siblings' grants across every
  generation at mint time, and write_capability_grants then re-granted
  every component of the package. Each masked the other: removing the
  re-grant stayed GREEN because the copy covered it, and widening the
  copy into the current generation stayed GREEN because the re-grant
  replaced it — so neither was graded. The copy is removed: a delegated
  component is minted INERT and granted only by the two package-level
  writers (write_capability_grants on the ordinary pass, which runs
  after extraction and before the resolve; project_generation_grants per
  generation, joined by package, at build and promotion). Both REPLACE.

tests/delegated_grant_boundary.rs, through the production doors:
  1. its capabilities equal the package's through both -> one -> none ->
     both re-approvals;
  2. a component minted after a narrowing (wide generation retained as
     superseded) gets the narrow grant;
  3. a pass with no package drops template and script rows together; a
     declined package leaves no live delegated row and no active grant
     (counted on the LIVE projection — the superseded generation keeps
     its exclusive rows for rollback, which is not serving them);
  4. no package reaches another's delegated component; a claim named
     `typescript` with another row language is refused; both reserved
     keys are refused.
Each with a run mutation; results in the doc comments.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
stage-baseline, tier3-baseline and host-package-lifecycle each drifted on
exactly one line, `[activation] embedded_dispatch_version "0" -> "1"`,
over the full pinned universe; every bless diff is empty. baseline.json
(corpus_ratchet) does not move.

The stage and tier-3 drivers could not record it: they grade the
`activation` block as its own axis but never handed it to the bless
claim, so an activation-only move was red on the gate and refused as
"NOTHING MOVED" by the bless (measured, both drivers). The same
comparison the gate makes is now passed as `activation.<key>` conditions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Rebased onto #318 phase 2, `crates/guest-kit/src/ids.rs` is a SHARED
INPUT of every first-party extractor: each package's `.provenance` hashes
it, so the constants 393b809b added there would have moved every
package's `source_inputs` for a record only Svelte writes. They move to
`crates/guest/svelte/src/region.rs` (plain constants plus the 11-byte
payload builder); the kit and its test return to master byte for byte.
The rebuilt extractor is byte-identical (sha256 3fd45b60…), MEASURED.

The parent-parity grading moves with them, to the package's own leg:
`crates/first-party-tests/tests/svelte_region_record.rs` mounts that
exact source with #[path] and checks tag, language rows, scope bytes,
payload layout and ceiling against `code_index_abi`'s registry, encoder
and validator.

Records re-derived through the phase-2 flow: the provenance artifact
pin and `input` rows, `source_inputs` (`package_records --write`, which
moved no other package's record).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
After the rebase the three records were taken from master and each was
re-measured: stage-baseline, tier3-baseline and host-package-lifecycle
drifted on exactly `embedded_dispatch_version "0" -> "1"` and nothing
else; every bless diff is empty (`outcome: conditions_only`).
tier3-baseline's bless also names `schema: 78 -> 79` as a condition:
master's #326 re-recorded stage and lifecycle under v79 and left that
record at 78 (its gate does not grade the schema), so this is the first
bless to observe it. baseline.json does not move.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The pin records each frozen package's digest beside the FINGERPRINT of
what the host derives from it. Only svelte's package_digest moved (the
frozen fixture is now 0.2.0); its fingerprint, fixture count and row
count are unchanged, because this derivation runs the package's frame
and not the host's delegation. Re-recorded with COSI_BLESS_HOST_EPOCH=1;
the diff is that one line.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
An #[ignore]d diagnostic beside the gated cost test, in
cost_attribution's style: per-statement vm_step for both legs (package
minus builtin, SQL whitespace-folded) and the in-process time of
embedded::delegate alone. SVELTE_COST_FIRST_PARTY=1 classifies the test
key first party, as the release key is.

MEASURED (120 components, release): package leg +3.93M vm_step over
builtin, of which 3.39M (86%) is ONE statement — influence step 3,
"COMPETED", `UPDATE refs SET influence = 2, influence_component_id =
(competitors MIN) WHERE EXISTS (competitors 1)`, evaluated per ref and
computing the same correlated subquery twice. It runs because a Svelte
index takes `influence::apply_general`: the first-party exemption needs
a package whose every claim adopts a builtin profile, which svelte's
does not, so first-party classification changes nothing (measured
identical). Step 2 (ENDPOINT) is the next 0.29M; everything else is
row-proportional (refs/symbols inserts, resolve temps). The delegated
TypeScript extraction itself is 33-37 ms for 120 files in-process —
the same parse the builtin leg pays for its .ts files. No baseline is
changed to absorb any of this.

Also: rustfmt of the svelte guest's use order (extractor byte-identical,
3fd45b60…) and the re-derived provenance input row; fmt of the region
record test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
* lang_literal_gate — the host spelled two builtin language ids (the
  ABI's region table and `embedded::DELEGABLE`). The table now holds
  ROUTES, by file extension: `EMBEDDED_ROUTES = ["ts", "js"]`
  (`EmbeddedRouteId`, `Region::route`). The host dispatches a region as
  `embedded.<ext>` to the compiled-in set exactly as the walker would,
  and the row language is whatever the chosen extractor stamps — no
  language id in host code, no allowlist entry. Wire bytes unchanged
  (index 0/1), so the Svelte extractor and its digests do not move; its
  provenance re-records the one edited comment in region.rs.
  `the_route_table_is_pinned_beside_the_dispatch_version` pins the
  routes to the dispatch version and checks, in a test, which language
  each lands in.
* ignored_test_reachability — the #[ignore]d per-statement attribution
  in svelte_package_cost is waived the way `cost_attribution` is: a
  diagnostic with no bound; the gated half of the same target runs in
  every workspace run.
* bounding_site_registry — MAX_EMBEDDED_REGIONS registered with
  FieldIn("daemon", "parse_error_files + error"): it refuses, never
  truncates. New embedded_region_ceiling.rs proves the claim through a
  real worker and index pass: 64 regions accepted and all delegated,
  65 refuse the whole file with `fact.count_exceeded` in parse_error and
  nothing stored.

Mutations RUN, all RED: ceiling `>=`→`>`; a route appended; a builtin
literal reintroduced in embedded.rs; the waiver's target renamed; the
registry row renamed; a fabricated disclosure field. The embedded.rs
suite's earlier mutations re-run after the change, all RED.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Embedded-region dispatch put a package's template rows and the host's
delegated <script> rows under one file_id. A template ref and a script
ref of one unresolved name (`onclick={inc}` beside `inc();`) then made
two groups agreeing on (file_id, name, pool_class, qualified,
recv_unproven), and the INSERT into temp.resolve_groups failed its
PRIMARY KEY: the index pass exited 1, the daemon never reported ready,
and nothing in the project resolved.

`lang` (the ref's own row language) is now in the key of every
group-keyed resolver table -- resolve_groups, resolve_stats,
resolve_decisions, reachable_stats (both builders), t3_groups, t3_reach,
qual_groups, qual_decisions, tqt_groups, tqt_decisions -- and every
statement that correlates on a group key carries it: the tier 1a/1b/2/3
writers, the tier-3 estimate, ambiguous_remain, follow_own_imports, the
shadow refusal, the per-tier attribution, the apply UPDATEs of tiers
1/2/3, 1Q and T, and the 1Q receiver veto. tier1q_rel_samefile, the one
1Q pass whose candidate pool was not lang-scoped (same file used to
imply same language), now is.

Each language's group is decided within its own language's pool, so the
template's `inc` (de.h-dv.svelte/svelte) stays unresolved: the function
is a JavaScript symbol, and a same-file cross-language tier is #331's
work. Both new suites assert that ceiling so it goes red when it moves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The first cut used a <Button /> tag beside a Button() call. A tag is a
type ref and a call a value ref, so their groups never shared a key and
every lang mutation survived it. Both refs are calls now, the kind is
asserted, and the measured result of each mutation is written at the
test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`tests/grammars/build-tree-sitter-vue.sh` hands the shared recipe the
crates.io `tree-sitter-vue-next` 0.1.0 crate (sha256 e9ac89ac…), whose
parser.c, scanner.c, tag.h, node-types.json and grammar.js are each
sha256-identical to tree-sitter-grammars/tree-sitter-vue at ce8011a4
(MEASURED). ABI 15, inside the host's 13..=15 window; the shim needed no
new header. Rebuilt three times from fresh workdirs to the same
ff1cc0cb… (31,760 bytes). grammar_provenance gains its two rows.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The first fully package-owned language: `crates/guest/vue` is the whole
of what makes a `.vue` file more than text. No `#[path]` into a host
crate; `region.rs` and `expr.rs` are this guest's own copies.

* Each `<script>` body is handed to the host as an embedded region
  (`TAG_EMBEDDED_REGION`, #275): `lang="ts"` routes `ts`, no `lang` or
  `lang="js"` routes `js`; `setup` makes it LOCAL scope, a plain
  `<script>` MODULE. Any other `lang` (coffee, tsx, …) delegates nothing
  and the frame carries ONE `extract.unsupported_syntax` at the first
  such value. Empty bodies emit nothing; past MAX_EMBEDDED_REGIONS the
  guest stops and says `extract.node_limit_reached`.
* The template: PascalCase component tags are `type` refs; `@evt` /
  `v-on` handlers `call` refs (bare identifier or call shape);
  `:prop`/`v-bind`/`v-if`/`v-model`/… values and `{{ }}` interpolations
  are `call` (call shape) or `read` (path head); a `v-for` source is a
  `read`; `#slot` values declare and yield nothing. One `module` symbol
  per file named by the host from the basename (#229),
  `fact_minor_min = 2`, grant `same_file_candidate,exported_candidate`.
  No new ABI, kind, role or capability.

Seven graded fixtures (`plugin check` passes all seven under a throwaway
key); `vue_regions.rs` grades the regions through a live PackageHost;
`vue_region_record.rs` the record against the parent; and
`vue_guest_rebuild.rs` byte-compares the extractor with its source, which
the svelte package still lacks. Every mutation listed in the files was
run. Records written by `package_records --write`, which moved no other
package's record. guest_gates' population floor is now 5.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`distribution/registry.v1.json` lists de.h-dv.vue 0.1.0 (identities
derived by `package_records`); release.yml's package matrix packs it and
its notes block looks it up by its own id; package-ci.yml gains the
`vue` leg (`ci_changes.sh` derives package scope from the tree and
needed no edit); release_gate gains its PACKAGE_JOBS row, which moves
release_gate.rs's live-path census 27 -> 29 in
host_reads_no_live_package; ci_path_gating's rebuildable set names vue;
README's package table gains its row.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`tests/host-fixtures/packages/vue@0.1.0` + its PINS row; the host
extraction epoch record gains `vue` (COSI_BLESS_HOST_EPOCH=1, every
other package's fingerprint unchanged). `vue_package_e2e.rs`: a
`<script setup>` function is a symbol under `de.h-dv.vue/typescript`,
file-visible, at the file's line; find_callers reaches delegated calls at
file positions (first line after a two-byte `é` included) and across
files through the script's import; a plain `<script>` is a MODULE region;
`<TicketRow />` binds to TicketRow.vue. `vue_package_cost.rs`: the
svelte suite's parity, positions and loose caps (release: 199% of the
same TypeScript standalone, svelte 192%).

The e2e and cost corpora avoid one shape ON PURPOSE and say so: a file
whose template and script reference the same unresolved name fails the
WHOLE index pass on `resolve_groups`' primary key, which #275 left
without `lang`. Svelte 0.2.0 fails the same way. Reported, not fixed
here.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The shape both corpora avoided until the resolver's group keys carried
`lang` (51039b8c): `@click="inc"` beside `inc(1)` in `<script setup>`,
and a PascalCase tag (`TicketRow`, `Model{i}`) the script also names.
`a_name_shared_by_template_and_script_is_two_groups`: the daemon reaches
ready, the script call resolves, the template call is present and
unresolved (no same-file cross-language tier, as for Svelte). The cost
suite asserts the same per component (120 template `@click`s, 0
resolved; every script `inc{i}` call resolved).

MUTATION (RUN): `lang` dropped from `resolve_groups`' PRIMARY KEY ->
all five e2e tests RED (daemon never ready), the cost suite RED with
`UNIQUE constraint failed: resolve_groups.file_id, …`.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`rebuild_symbol_edges_scope` picks, for every line bearing a resolved
ref, the innermost symbol spanning it (smallest span, latest start,
lowest id). It did so with one ROW_NUMBER() window over a range join of
lines against every CONTAINING symbol, so its work grew with nesting
depth. #335's RSpec symbols put 2-4 containers on most spec lines, and
the statement became 26% of the +2.97M vm_step #335 cost ruby-sinatra
(cost_attribution).

`index::enclosing::innermost_per_line` reads each file's symbols once,
sorted by start, and sweeps the file's ref lines with an ordered set of
the symbols open at each line, keyed by exactly the window's ORDER BY;
id is unique, so the first element IS the rn = 1 row. Same rule, same
rows: corpus_ratchet's `edges` is byte-identical on all seven tier-1
repos.

cost_attribution, all nine pinned repos, before -> after (vm_step):
  cs-dapper      25.77M -> 24.31M  (-5.6%)
  js-express     18.25M -> 17.64M  (-3.3%)
  php-guzzle     43.84M -> 37.97M  (-13.4%)
  py-django     837.65M -> 782.37M (-6.6%)
  python-flask   17.03M -> 15.88M  (-6.8%)
  ruby-sinatra   19.38M -> 17.93M  (-7.5%)
  rust-analyzer 782.43M -> 679.72M (-13.1%)
  rust-ripgrep   53.19M -> 44.79M  (-15.8%)
  ts-zod        123.66M -> 117.04M (-5.3%)
fullscan_step flat (largest move +916 on php-guzzle, of 392k).

Tests: a deep-nesting/tie case and 300 randomized span sets against an
INDEPENDENT transcription of the window. Mutations run: start
tie-break inverted and end-inclusion made exclusive are RED in both;
`first()` -> `last()` is RED in corpus_ratchet (rust-ripgrep edges
8501 -> 4538). A first oracle that shared the sweep's key let the
tie-break mutation survive; it is now spelled out separately.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`temp.symbol_buckets` — the base pool every bare-name tier (1a, 1b, 2,
3) and `exported_pools`/`dir_bucket` derive from — now excludes a symbol
whose NAME contains a space or a tab (`SPELLABLE_NAME_SQL`). Keyed on the
name, not on a language.

SOUND FOR EVERY LANGUAGE: a pool exists to be joined on
`name = refs.name`, and a ref's name is the identifier/constant token at
its own span (a packaged ref is held to `src[name_span]` by
abi::validate; every builtin walker emits an identifier, constant or
member node's text), and no supported language admits whitespace in one.
MEASURED: zero ref rows with whitespace in their name on all seven tier-1
repos under both the 514e37e0 build and this tree. Today's whitespace
names are #335's RSpec groups/examples (ruby-sinatra 1,540) and three
TypeScript string-literal methods in ts-zod (`"zod 4 (after)"`). The
symbols stay in `symbols`: outlines, search_symbols and the
enclosing-symbol sweep read the table, not the pools.

RESULTS UNCHANGED: corpus_ratchet (edges, resolved, every dimension),
corpus_stage and package_baseline green on all seven repos with no
re-record; /tmp/claude-1000/r335/sinatra_new_binds.tsv and
sinatra_moved.tsv re-derived byte-identical (489 new binds, 0 moved).

COST (cost_attribution, all nine repos, vm_step, vs the sweep commit):
ruby-sinatra 17.93M -> 17.28M (-3.6%); the other eight within +0.05% to
+0.13% (cs-dapper +27k, js-express +20k, php-guzzle +21k, py-django
+393k, python-flask +10k, rust-analyzer +253k, rust-ripgrep +34k,
ts-zod +75k: the per-symbol instr() probe on repos with nothing to
drop). ruby-sinatra is still +9.7% vm_step / +9.2% fullscan_step over
cost-baseline.json, so corpus_cost stays red pending the operator.

Test: `a_name_no_reference_can_spell_is_offered_to_no_reference` hands
the writer refs no extractor would emit (`describe Foo`, `it<TAB>works`)
beside `foo`, through the real resolve. Mutations run, all RED: clause
neutralised `({unspellable} OR 1)`, space made `#`, tab dropped,
predicate `AND 0`. A first version graded a refactored copy of the
statement and turned three pool_capability_registry scans red; the
statement stays inline where those gates read it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The fix lives in the canonical walker crates/plugins/src/ruby.rs, which
inputs.rs owns as `shared`: it moves the builtin AND de.h-dv.ruby
together, and ruby_package_parity holds them equal row for row.
Package-owned projects get it from a de.h-dv.ruby 0.9.0 release;
builtin-owned ones with the next host release.

A. `emit_spec_symbol`: an RSpec group or example that carries a block and
   a description (`describe X`, `RSpec.describe X`, `context '…'`,
   `it '…'`, `shared_examples '…'`, x/f forms) is a `file`-visible
   `function`, named as RSpec prints it, nested under its group by a
   stack of its own; the walk's `parent` is untouched, so a `module`/`def`
   inside a block keeps its namespace. Argument-less forms and
   `let`/`subject` declare nothing — measured, a helper symbol only ever
   bound wrongly (sinatra `described_class.token` -> `let(:token)`;
   Zammad 68 `context '…' do` -> `let(:context)`).
B. `emit_call`: a constant passed as an ARGUMENT emits the per-segment
   `type` refs a receiver does; a receiver-less mixin operand stays
   `emit_mixin`'s supertype.

Ported arm for arm to the 0.7 guest oracle (crates/guest/ruby/src; new
`block` field via gen-kinds.sh) so ruby_native_differential holds. New
fixture rspec.rb.rbx with decoys; expectations generated from the builtin
(COSI_BLESS_RUBY_EXPECT=1). Package 0.8.1 -> 0.9.0, extractor rebuilt,
ruby records by package_records --write (the other build.py packages'
source_inputs are left to REPORT, per inputs.rs); the catalog row's
version key moved by hand, because the writer refuses to mint a row.
ruby_package_parity pin 3085 -> 3576, both legs.

Measured, builtin, occurrence-joined bind diff against 514e37e0:
ruby-sinatra resolved 3070 -> 3559 (+489, all on 859 NEW rows, 0 moved;
one known wrong bind, base.rb:1844 `::Logger`, by the host's
pre-existing rule-11 `::X` bypass); Zammad 42063 -> 49480 (+7417 on new
rows, 0 moved), spec files with symbols 332 -> 1697 of 1836.

Tests and mutations: four plugin unit tests (8 mutations RED), the
native differential (2 guest mutations RED), the expectations generator
(2 RED), and parity (a packaged extractor without the argument loop is
RED at the resolved equality: 3576 vs 3085).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Taken from train-0.35's records and re-blessed with the sanctioned
switches only; no number was merged by hand. Each `_blessed` carries
its reason and categorised diff, and each file was checked key by key
against train-0.35's bytes.

  baseline.json (COSI_CORPUS_BLESS)        ruby-sinatra row only:
      symbols 1260 -> 2800, refs +859, resolved 3070 -> 3559 (+489),
      edges 1173 -> 2909, resolved_type +210, resolved_member_access +279.
      The reason names the one known wrong bind among the +489
      (lib/sinatra/base.rb:1844 `::Logger` -> Sinatra::Middleware::Logger,
      the host's pre-existing rule-11 `::X` bypass).
  stage-baseline.json (COSI_STAGE_BLESS)   ruby-sinatra rules only.
  host-package-lifecycle.json (COSI_PACKAGE_BLESS)  ruby/* states only;
      #275's re-recorded fields and every xaml/svelte state are
      untouched. What moves is the one BUILTIN-owned un-shadowed sinatra
      file (+8 symbols, +2 refs); the frozen 0.8.1 package does not.
  cost-baseline.json (COSI_COST_BLESS)     WHOLE RECORD, operator-approved
      2026-10-09: ruby-sinatra 15.75M -> 17.28M vm_step (+9.7%), every
      other repo's ceiling tightens (ripgrep -14.7%, guzzle -13.4%, the
      rest -3.3..-6.6%) after #335's two HOST reductions; schema stamp
      78 -> 79. Load average 3.4 -> 3.2 across the run.
  ruby-package-cost.json (COSI_RUBY_PKG_COST_BLESS)  package 0.9.0:
      package leg vm_step 29.34M -> 31.48M, builtin 16.31M -> 17.17M.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
A host that adds a trait made every stored declared profile unreadable
("profile.(fields) = 17 of 18"): load_book fell back to the builtin,
silently dropping the package's overrides for migration and promotion
passes, and the next ordinary pass re-wrote the row in full and called
the new spelling a MOVE -- one spurious Full re-resolve per upgrade per
package-owned project.

- ProfileTraits::decode_over: a field the row does not carry takes the
  extends profile's value. A build that did not know a field also refused
  any manifest overriding it, so the extends default IS the package's
  answer. Unknown, repeated and unreadable fields are still refused.
- profiles::load_book decodes each row over traits_of(wire id), which is
  the profile its declaration extends.
- profiles::write_declared compares DECODED profiles, not stored strings.

Tests (mutations RUN, each RED):
  lang_profile::an_older_row_decodes_over_its_extends_profile
    - decode_over from NONE; decode_over strict
  profiles::an_older_hosts_row_is_read_and_rewriting_it_is_no_move
    - decode_row strict; fingerprint over stored strings

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
durable_state read the generation table alone, and a building row is the
same row whether its process is alive or dead. So a daemon mid-build
(generation 5, 6,518 of 10,208 files) was reported as 'interrupted
mid-build -- code-index plugin retry', inviting a second activation
against a live one.

The owner is already measured -- activation::owner, the lockfile (incl.
daemon-<pid>.toml) plus port-connect probe every mutating command defers
on. cmd_status now probes it ONCE and hands it to durable_state, whose
owed line (activation::owed_line) says:
- live daemon: 'building generation N (owner: the running daemon, pid P,
  port X, D of T queued file(s) settled) -- the owner drives this
  generation itself', no retry advice;
- no live owner: the existing interrupted wording and retry repair;
- undetermined owner: says so, and conditions the repair on it.

Tests (mutations RUN, each RED):
  plugin_activation_cli::status_tells_a_live_daemons_build_from_an_interrupted_one
    (real building generation + build queue; dead owner, then a real
     listener behind a payload)
    - daemon arm rendered as Cli; cmd_status passing Owner::Cli;
      Cli arm rendered as the daemon arm
  activation::tests::an_undetermined_owner_and_an_idle_index_say_what_they_measured
    - Unknown rendered as Cli; unreadable progress dropped

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The field restart picked scope=Skipped with owed work; this drives the
same shape -- a startup rebuild under an older host's digest, the pointer
switch committed and the resolve never (crash::AFTER_POINTER_SWITCH's
state, which is what a SIGTERM mid-resolve leaves), then the cold-start
index_path_with_packages -- and it runs the owed Full resolve: owed
(49, 4, 0) -> scope=Full, pending cleared, every active bind restored.
No fix: the field difference is not found.

MUTATION (RUN): index_path_inner skips apply_resolution_observed when
nothing was parsed or deleted -> RED at 'the restart owed a resolve and
skipped it'.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Step 3 ("COMPETED") of `apply_general` spliced a correlated competitor
subquery into its UPDATE twice (EXISTS witness + MIN in SET), probing
every same-named symbol for every ref in the project. It was 89% of
the Vue package's extra SQLite work on Zammad and 86% of Svelte's.

Now the relation is built ONCE per pass into temp.influence_competed
(ref_id PRIMARY KEY, MIN component) and the UPDATE is keyed on it:

* UNSCOPED pass (cold, or after a grant change): over
  temp.influence_dyn_names, the admitted dynamic symbols folded to one
  row per (name, capability, component, file-or-0) with n and MIN(id).
  "some candidate is not the target" == n > 1 OR sid <> target. Only
  the same-file channel keeps rows per file; a unit test holds every
  `reaches` to reading no symbol column but s.file_id.
* SCOPED pass: the symbol-level join driven from the in-scope refs, so
  a one-file edit pays for its scope only.

The anchor arm's three qualifier channels are decided once per
DISTINCT qualifier into temp.influence_anchored_quals and joined back
by equality, the shape path_evidence_match_sql uses.

Results identical. Measured, vm_step (load avg 6-16 throughout):
* Zammad + de.h-dv.vue, cold: step 3 516.1M -> 35.3M; whole index
  1,728.3M -> 1,247.7M (-27.8%). All 684,900 refs' (influence,
  component) byte-identical to the old code (157,574 influenced).
  A symbol-level dynamic-driven join was tried first: 398.1M.
* svelte_package_cost: package leg 7,372,206 -> 4,506,497; step 3
  3,392,810 -> ~0.50M. vue_package_cost: 7,494,503 -> 4,647,516.
* cost_attribution, nine pinned repos: influence statements net 0 on
  every repo (the short-circuit runs there); totals move +-0.03% in
  FTS segment merges only.

influence_step3_differential: the pre-#340 pass written out as an
independent literal-SQL oracle (own channel table, capability names,
fold and bridge gates), validated against the ORIGINAL code first, then
compared row-for-row by refs.id under unscoped, scoped and batch scopes
from a seeded mix of classes, with population floors asserted. Twelve
mutations run and recorded at the test; MIN->MAX (both shapes), the
count test, the same-file fold, the anchor prefix flip and the
separator check all SURVIVE influence_classification and go red here.

ref_kind_stance_registry: competitors and competitors_by_name now read
`FROM refs` and are declared, with apply_general's stance.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
A method call whose receiver is a captured, non-self NAME (local, param,
ivar) was bound by the two rules whose only fact is proximity: tier 2
(same file) and tier 3's same-directory edge. Field: `record.name` inside
Space#name's own body bound Space#name (tier2_same_file); `message.name`
bound the only `def name` one directory over (tier3_import_boost, edge 1).
#189 refused this for csharp/php only (RECEIVER_LOCALITY_BLIND_PROFILES).

Structural rule: recv_proof::CAPTURED (3) for a captured non-self receiver
in every language whose imports CAN name a file.
- tier 2 refuses it (it requires PROVEN);
- tier 3's same-directory edge still REACHES its candidates
  (t3_reach.named = 0) so they count as competitors, but may not CHOOSE
  one; nor may the ref's own file be chosen. Dropping the edge instead was
  measured: rust-analyzer +752 new binds (syntax.kind() x206 onto
  AstNode::kind), all sampled wrong -- a reachable set shrunk to one.
- the import-key edge and the resolved-specifier edge still choose
  (rust-ripgrep dir.create x334; precision_gate's ruby greeter).
- tier 1a (project-unique) untouched.
- m0080 re-decides the rows proximity bound (CURRENT_VERSION 80).

Bind diff vs the train-0.35 binary, joined on (path,line,col,kind,occ):
gained 0 everywhere; cs-dapper, php-guzzle, js-express byte-identical.
  ruby-sinatra -185  python-flask -344  ts-zod -131  py-django -776
  rust-ripgrep -410  rust-analyzer -1940  zammad 7.0.2 -642
  retargets (all to tier1r_receiver): django 75, ripgrep 44, RA 58,
  zammad 19, sinatra 5.
Losses are overwhelmingly phantoms in python/ruby/typescript; Rust pays a
real recall cost (ripgrep ~half of sampled losses correct). corpus_ratchet,
package_baseline (schema 79->80) and the cost records move and are NOT
re-recorded: operator decision.

Tests (mutations RUN, each RED): receiver_phantom
  - tier 2 admits CAPTURED; tier-3 CAPTURED arm disabled; edge 1 drops
    CAPTURED (competitor test); edge 2 refuses CAPTURED (ruby greeter);
    CASE maps CAPTURED to PROVEN; m0080 returns early (upgrade test);
  - own-file arm: provenance_invariants was RED (122 rows) without it.
rust_captured_receiver_keeps_same_file_locality is replaced: its
fixture's bind (c: Conn -> Bench::query) was itself a phantom.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Measured with cost_attribution: recording edge 1 first forced
ON CONFLICT DO UPDATE on both naming edges; the import-key insert cost
+5.1% on py-django (13.99M -> 14.72M vm_step). Run last with OR IGNORE,
it keeps the naming edges' named = 1 and adds only what proximity alone
reaches: same pair set, -172k vm_step on py-django, -99k on rust-analyzer.

Test: a_neighbour_the_import_names_is_still_chosen.
MUTATION (RUN): edge 1 as INSERT OR REPLACE (proximity overwrites the
import's named = 1) -> RED.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Through the sanctioned switches only (COSI_CORPUS_BLESS, COSI_STAGE_BLESS,
COSI_TIER3_BLESS, COSI_PACKAGE_BLESS), each with the #336 reason:

- baseline.json / stage-baseline.json: ruby-sinatra, python-flask, ts-zod,
  rust-ripgrep rows only; schema 79 -> 80. cs-dapper, php-guzzle,
  js-express rows byte-identical.
- tier3-baseline.json: py-django, rust-analyzer; schema 79 -> 80.
- host-package-lifecycle.json: ruby/active only (-185, the same binds as
  the builtin leg) plus the schema condition; every other state
  byte-identical.
- package_parity RESOLVED_BOTH_LEGS 3576 -> 3391 (both legs, -185),
  history in ruby_package_parity.rs.

Bind diff vs train-0.35 @ 409e797c on (path,line,col,kind,occurrence),
0 gained: sinatra -185, flask -344, zod -131, ripgrep -410, django -776,
rust-analyzer -1940; sampled wrong-bind rates and the operator's 21-bind
check in each reason; Rust recall cost tracked as #348.

NOT re-recorded: ruby-package-cost.json (schema condition 79 -> 80). It
demands an isolated re-measure below ~88% disk; the box is at 92%.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
#340 decided the anchor arm's three qualifier channels once per
DISTINCT qualifier, but each one still scanned file_keys, file_pkg and
first_stem in full: on the frozen Ruby package (which holds
reachability_anchor) `INSERT INTO temp.influence_anchored_quals` was
433k fullscan_step and took the package leg over its band (lane H35).

A qualifier q is rooted at key k iff k is non-empty and is q itself or
a prefix of q that a separator ('.', ':', '/') follows. So both sides
are reduced to what that rule can match, and joined by equality:

* temp.influence_anchor_roots: the non-empty keys of anchored files,
  one scan per key relation, PRIMARY KEY (root, folded);
* the prefixes of each distinct qualifier that end before a separator
  (plus q), generated by a recursive CTE and probed against the roots.

The #165 fold survives as `folded`: a package tail meets the folded
prefix, through index::fold_pkg_sep_sql as before.

Measured, load 2-5:
* package_cost_attribution, package leg: fullscan 710,684 -> 299,557,
  vm_step 27,879,595 -> 25,314,395 (pre-#340 b330f8b2 per H35:
  654,201 fullscan). The anchored-quals statement: 433,629 -> 20,445
  fullscan (its one refs scan), 2.73M -> 0.14M vm_step.
* ruby_package_cost package leg: fullscan 752,049 -> 329,842, vm_step
  30,434,421 -> 27,800,725. Its band test is red on BOTH sides for a
  reason that is not this change: the record was measured under schema
  79 and the train is schema 80. Not re-blessed.
* cost_attribution, nine repos: influence statements net 0 on every
  repo; totals within +-0.1% (FTS merge noise). svelte/vue cost: equal.

influence_step3_differential stays green; four new mutations of the
new form run and recorded (separator rule, prefix length, unfolded
package tail, no first_stem roots), all RED.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Two mcp-server registry gates were red on train-0.35:

- ref_kind_stance_registry: m0080_captured_receiver_reheal::up reads
  refs. Registered with what its SQL names: `method_call` only, so
  Import::Excluded and Access::Excluded (unlike m0062's kind-blind unbind).
- bounding_site_registry: `CAPTURED` (index::recv_proof, value 3) matches
  the scan's "CAP" marker. It is not a bound: registered Intentional,
  exactly as its sibling `UNCAPTURED` is (#189), not renamed around the
  gate. The same gate also flagged `MAX_SPEC_NAME_BYTES` (#335, ruby.rs),
  a REAL bound on an RSpec symbol's display name: registered Intentional
  (no row dropped, the span covers the block, search_text sees the full
  text); the #335 owner should confirm the wording.

Each gate was RED without its entry (that was the train state) and is
green with it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Through COSI_RUBY_PKG_COST_BLESS only, isolated: 1-min load 1.69 at the
bless (surveys started at 3.58 / 2.51 / 2.17), disk 83%.

- schema 79 -> 80: #336's m0080. Both legs resolve 3391 (-185 each).
- #340's rewrite plus its anchor-scan follow-up leave the package leg
  cheaper than the #335 record on both counters: vm_step 31484016 ->
  27798372 (-11.7%), fullscan_step 656980 -> 329842 (-49.8%); sort 584,
  autoindex 2677. Builtin vm_step ~17.32M (+0.9%).
- Wall ratio 143% (unblessed surveys 145 / 149 / 142).

Replaces the discarded 23da75e8, which had absorbed the anchor scan the
#340 follow-up removed. Afterwards: ruby_package_cost 7/7,
ruby_package_parity 4/4, corpus_cost 12/12, bless_registry 11/11.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
The resource was capped by READ_CODE_MAX_TOKENS (4,000) and the catalog
crossed it — the de.h-dv.vue row plus the bumped svelte/ruby rows took
registry.v1.json from 13,167 to 14,399 bytes — so clients got
`{"truncated":true,"preview":…}`: half a JSON catalog that parses as
nothing. registry_mcp_e2e's two catalog tests went red on it.

It now gets the skill-file arm's failure mode under its OWN stated
ceiling, REGISTRY_RESOURCE_MAX_TOKENS (12,000, envelope included):
served whole, or refused with an error naming its size and the cap.

`the_registry_resource_fits_its_ceiling_with_the_worst_case_matches`
keeps the refusal unreachable for the embedded catalog: it renders the
catalog with every claimed extension symbol-blind and every package
installed (27 match rows for 11 packages) and grades it through
`headroom::Ceiling` — 5,209 of 12,000 tokens, with 4,000 reserved for
the envelope (REGISTRY_BODY_BUDGET_TOKENS = 8,000).
MUTATION (RUN): body budget = READ_CODE_MAX_TOKENS, the old cap -> RED.

Both constants are registered in bounding_site_registry; the ceiling is
graded through the headroom mechanism (payload_headroom_registry).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
`idle_worker_footprint::an_idle_worker_holding_a_compiled_grammar_costs_what_this_says`
failed once in the train's full nextest run and passes alone. Not a
product defect: it asserts on `Pss` from /proc/<pid>/smaps_rollup, and
Pss divides every shared page by the number of processes mapping it
SYSTEM-WIDE — under nextest, every other plugin-host test's workers off
the same binary and grammar. MEASURED: alone, 3/3 green, first
grammar-holding worker 17,201–17,342 KiB; six copies at once, 12/12 RED
on the grammar floor, first worker 4,171–5,322 KiB. Its own doc claimed
immunity to contention; corrected.

It moves to `ci-timing` (excluded from `ci`, run one at a time), and
wall_clock_registry gains the sibling class: every non-ignored test whose
file reads smaps_rollup's `Pss` (string literals, comments not counted)
must be in both profiles' lists. VmRSS/VmHWM readers are not in the
class — they count a shared page in full whoever else maps it.
`the_pss_rule_takes_readers_only` is its anti-vacuity.
MUTATION (RUN): drop the term from both profiles -> RED naming the test.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
disclosure_derivation_registry: a braceless #[cfg(test)] item ends at its ;
All checks were successful
Package CI / package (timeline) (push) Successful in 26m34s
Package CI / package (svelte) (push) Successful in 26m44s
Package CI / package (rust) (push) Successful in 47m0s
Package CI / package (javascript) (push) Successful in 47m7s
Package CI / package (php) (push) Successful in 47m9s
Package CI / package (csharp) (push) Successful in 47m13s
Package CI / package (typescript) (push) Successful in 47m20s
Package CI / package (python) (push) Successful in 48m2s
Package CI / package (ruby) (push) Successful in 53m28s
Release Build / Generate Version (push) Successful in 35s
Release Build / Required CI green (push) Successful in 51s
Release Build / Build linux-aarch64 (push) Successful in 12m39s
Release Build / Build linux-x86_64 (push) Successful in 14m44s
Release Build / Build linux-x86_64-musl (push) Successful in 15m20s
Release Build / Pack the first-party packages-9 (push) Successful in 52s
Release Build / Pack the first-party packages (push) Successful in 56s
Release Build / Pack the first-party packages-2 (push) Successful in 57s
Release Build / Pack the first-party packages-1 (push) Successful in 1m7s
Release Build / Pack the first-party packages-5 (push) Successful in 1m2s
Release Build / Pack the first-party packages-7 (push) Successful in 1m5s
Release Build / Pack the first-party packages-8 (push) Successful in 1m11s
Release Build / Pack the first-party packages-3 (push) Successful in 1m16s
Release Build / Pack the first-party packages-10 (push) Successful in 1m19s
Release Build / Pack the first-party packages-6 (push) Successful in 1m26s
Release Build / Pack the first-party packages-4 (push) Successful in 1m30s
Release Build / Build windows-x86_64 (push) Successful in 19m9s
Release Build / Assemble the release archives (push) Successful in 3m24s
Release Build / Windows archive smoke (msvc) (push) Successful in 26s
Release Build / Create Forgejo Release (push) Successful in 10m10s
Release Build / Seed the package channel (push) Successful in 2m38s
bd6832005c
`production_server()` strips every `#[cfg(test)]` item by skipping to
the first `{` and its matching `}`. A braceless item — the test-only
`#[cfg(test)] const REGISTRY_BODY_BUDGET_TOKENS` added in 360d9f8b —
has no `{`, so the skip ran on through the NEXT item and deleted the
production `registry_plugins_resource`; the gate then reported that
surface as "declared and call NO renderer any more". The skip now stops
at a braceless item's `;`.

MUTATION (RUN): without the new arm, on this tree -> RED,
`the_surface_set_is_derived_not_asserted`: ["registry_plugins_resource"].

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0126PDDLB4wNHxKXvWM1VNmu
Author
Member

Fast-forwarded into master at bd683200 and released as v0.35.0 in release run 1062, with 60 assets: https://git.h-dv.de/h-dv/code-index/releases/tag/v0.35.0

CI was green on the PR (runs 1056–1058) and on the master push (runs 1059–1061). Forgejo does not mark a fast-forward as merged, so I'm closing this by hand.

Fast-forwarded into master at bd683200 and released as v0.35.0 in release run 1062, with 60 assets: https://git.h-dv.de/h-dv/code-index/releases/tag/v0.35.0 CI was green on the PR (runs 1056–1058) and on the master push (runs 1059–1061). Forgejo does not mark a fast-forward as merged, so I'm closing this by hand.
buildagent closed this pull request 2026-10-09 17:50:08 +02:00
All checks were successful
Package CI / changes (which packages this run must test) (pull_request) Successful in 21s
CI / changes (what this run must test) (pull_request) Successful in 31s
CI (Windows) / changes (what this run must test) (pull_request) Successful in 50s
CI / cargo fmt (pull_request) Successful in 1m15s
CI / OSS corpus tier-3 scale (nightly) (pull_request) Has been skipped
CI / Grammar rebuild from source (nightly) (pull_request) Has been skipped
CI / CI lane wall-clock headroom (pull_request) Successful in 1m41s
CI / guest crates (fmt, clippy, doc) (pull_request) Successful in 1m48s
CI / cargo doc (intra-doc links) (pull_request) Successful in 14m51s
Package CI / package suites (clippy) (pull_request) Successful in 17m25s
CI / cargo deny (pull_request) Successful in 17m43s
CI / cargo test (abi, 32-bit + wasm32) (pull_request) Successful in 17m57s
CI / cargo check (MSRV 1.98) (pull_request) Successful in 21m6s
CI / cargo clippy (pull_request) Successful in 21m29s
CI / cargo check (windows-gnu) (pull_request) Successful in 22m58s
Package CI / package (xaml) (pull_request) Successful in 35m38s
Package CI / package (timeline) (pull_request) Successful in 35m49s
Package CI / package (svelte) (pull_request) Successful in 35m53s
Package CI / package (vue) (pull_request) Successful in 36m7s
CI (Windows) / fmt + clippy + build + test (windows) (pull_request) Successful in 40m12s
Package CI / package (javascript) (pull_request) Successful in 1h1m53s
Package CI / package (rust) (pull_request) Successful in 1h2m54s
Package CI / package (csharp) (pull_request) Successful in 1h3m9s
Package CI / package (php) (pull_request) Successful in 1h3m12s
Package CI / package (typescript) (pull_request) Successful in 1h3m26s
Package CI / package (python) (pull_request) Successful in 1h4m27s
Package CI / package (ruby) (pull_request) Successful in 1h8m37s
CI / OSS corpus (tier 1) (pull_request) Successful in 1h12m14s
CI / cargo test (pull_request) Successful in 56m48s
CI / cargo test (daemon transport) (pull_request) Successful in 12m14s
CI / Plugin path cost + pool throughput (nightly) (pull_request) Has been skipped
Package CI / changes (which packages this run must test) (push) Successful in 23s
CI / changes (what this run must test) (push) Successful in 37s
CI (Windows) / changes (what this run must test) (push) Successful in 43s
CI (Windows) / fmt + clippy + build + test (windows) (push) Has been skipped
CI / cargo fmt (push) Successful in 55s
CI / cargo check (MSRV 1.98) (push) Has been skipped
CI / cargo check (windows-gnu) (push) Has been skipped
CI / cargo test (abi, 32-bit + wasm32) (push) Has been skipped
CI / cargo deny (push) Has been skipped
CI / CI lane wall-clock headroom (push) Has been skipped
CI / guest crates (fmt, clippy, doc) (push) Has been skipped
CI / cargo doc (intra-doc links) (push) Has been skipped
CI / OSS corpus (tier 1) (push) Has been skipped
CI / OSS corpus tier-3 scale (nightly) (push) Has been skipped
CI / Grammar rebuild from source (nightly) (push) Has been skipped
CI / cargo clippy (push) Has been skipped
CI / cargo test (push) Has been skipped
CI / cargo test (daemon transport) (push) Has been skipped
CI / Plugin path cost + pool throughput (nightly) (push) Has been skipped
Package CI / package suites (clippy) (push) Successful in 10m1s
Package CI / package (xaml) (push) Successful in 25m37s
Package CI / package (vue) (push) Successful in 26m34s
Package CI / package (timeline) (push) Successful in 26m34s
Package CI / package (svelte) (push) Successful in 26m44s
Package CI / package (rust) (push) Successful in 47m0s
Package CI / package (javascript) (push) Successful in 47m7s
Package CI / package (php) (push) Successful in 47m9s
Package CI / package (csharp) (push) Successful in 47m13s
Package CI / package (typescript) (push) Successful in 47m20s
Package CI / package (python) (push) Successful in 48m2s
Package CI / package (ruby) (push) Successful in 53m28s
Release Build / Generate Version (push) Successful in 35s
Release Build / Required CI green (push) Successful in 51s
Release Build / Build linux-aarch64 (push) Successful in 12m39s
Release Build / Build linux-x86_64 (push) Successful in 14m44s
Release Build / Build linux-x86_64-musl (push) Successful in 15m20s
Release Build / Pack the first-party packages-9 (push) Successful in 52s
Release Build / Pack the first-party packages (push) Successful in 56s
Release Build / Pack the first-party packages-2 (push) Successful in 57s
Release Build / Pack the first-party packages-1 (push) Successful in 1m7s
Release Build / Pack the first-party packages-5 (push) Successful in 1m2s
Release Build / Pack the first-party packages-7 (push) Successful in 1m5s
Release Build / Pack the first-party packages-8 (push) Successful in 1m11s
Release Build / Pack the first-party packages-3 (push) Successful in 1m16s
Release Build / Pack the first-party packages-10 (push) Successful in 1m19s
Release Build / Pack the first-party packages-6 (push) Successful in 1m26s
Release Build / Pack the first-party packages-4 (push) Successful in 1m30s
Release Build / Build windows-x86_64 (push) Successful in 19m9s
Release Build / Assemble the release archives (push) Successful in 3m24s
Release Build / Windows archive smoke (msvc) (push) Successful in 26s
Release Build / Create Forgejo Release (push) Successful in 10m10s
Release Build / Seed the package channel (push) Successful in 2m38s

Pull request closed

Sign in to join this conversation.
No reviewers
No milestone
No project
No assignees
1 participant
Notifications
Due date
The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set

Reference
h-dv/code-index!351
No description provided.