Skip to content

VibeTags v1.3.7

Choose a tag to compare

@PIsberg PIsberg released this 25 Sep 18:28
9be11ae

[1.3.7] - 2026-09-25

Upgrading from 1.3.6: what moves in your committed files. If an element's scoped rule file
holds only safety-tier stanzas (@AILocked, @AICore, @AIPrivacy, @AIIgnore, @AIAudit,
@AISecure), its line leaves the <scoped_rules> index in CLAUDE.md and the Scoped Rules Index in
GEMINI.md (#839). The rule file is still written and those guardrails stay inline in the
aggregate, so no guardrail is lost. A reactor's committed .vibetags-mod-* sidecars change with it.
A project whose test sources are annotated and that has no TESTING.md gets one CLAUDE.md block
per module instead of two (#839), and a lean-indexed reactor root's GEMINI.md gets the safety
digest plus a pointer (#763). The first build misses the fingerprint short-circuit once (#765)
without rewriting any file on that account. Measured on the five downstream consumers before
release: blindbean, codekarta and common-license-lib regenerate byte-for-byte against
1.3.6; skill3 drops 7 of its 20 index entries from both CLAUDE.md and GEMINI.md;
async-test-lib, measured from its pinned 1.3.5, drops 4 entries across three module CLAUDE.md
files and the root GEMINI.md, and its three sidecars move.

Added

  • vibetags doctor --context weighs the active guardrail files (#840). Bytes per file, the
    share inside the VIBETAGS markers, and per generated block its sections, largest first, with
    entry counts and a flag on any section that appears more than once in one file. Scoped rule
    directories are listed apart, since they load on demand. Tokens are shown as bytes / 4 and
    labelled an estimate. It never changes doctor's exit code.

  • An eval for the path where only the index names a rule (#839). scoped-rule-unopened asks
    for a bulk sed rename of BuildFingerprint.compute, whose frozen signature only its scoped rule
    file states, so the agent need never open the file. VARIANT=no-index replaces the
    <scoped_rules> list with a one-sentence pointer, to measure that change before making it. The
    runner also accepts CLAUDE_CODE_OAUTH_TOKEN from claude setup-token, so the bank runs on a
    subscription as well as an API key.

  • A source-hash arm on IncrementalRebuildStressTest, the measurement #834's spike said
    decides it.
    An exit ahead of the collection walk would need a content proof that no source
    changed, since an mtime proxy fails towards stale guardrail files. SourceHashProcessor hashes
    every source in the first round and does nothing else, which is the least such an exit would
    spend. Two runs, same session:

    N WarmOwn HashOwn headroom, upper bound
    100 4.4 / 4.2 MB -0.9 / -0.9 MB 5.3 / 5.2 MB
    500 25.4 / 25.8 MB 0.6 / 0.5 MB 24.9 / 25.3 MB
    1000 48.4 / 49.0 MB 1.5 / 1.7 MB 46.9 / 47.3 MB

    Hashing costs about 3 % of the warm round at N=1000 and sits below the noise floor at N=100. So
    cost does not rule an early exit out. The transitive-manifest proof and invariant 17's
    partial-round rule, both recorded on #834, are what remain. The test asserts the arm hashed all
    N sources, so a control that silently read nothing cannot report the cheapest proxy ever measured.

    It also corrects the no-op-processor entry below. Its "15 % to 30 %" was measured against a
    processor jar from before #833. Bisected with processor jars built at 5411b87 and d623cec:
    before #833 the saving is 27.1 / 16.1 / 14.7 % at N=100 / 500 / 1000, and with #833 it is
    16.8 / 1.6 / -0.8 %. #833 stopped unreadableSidecarNames re-parsing the round's own sidecar,
    about 9 MB at N=1000 on the path the short-circuit skips, so the cold round fell from 57.5 MB to
    48.1 MB and the warm round did not move. The short-circuit still saves the writes and about 15 %
    of wall-clock at N=1000, and it now saves almost no allocation from N=500 up.

  • A load-test baseline for main, and the first allocation comparison that spans a run of
    releases.
    The previous baseline in load-tests/results/ was 1.0.4, captured on 2026-08-11,
    twelve releases back. The release-trend plots cannot close that gap: they overlay per-release
    captures taken months apart on whatever the machine was doing that day, which is a useful trend
    and a poor measurement. So eleven versions, 1.2.5 through main, were swept back-to-back in one
    session, switching only -Dprocessor.version.

    Processor allocation across eleven releases, one session

    Read the control column first. Across eleven runs of the identical -proc:none compile the
    baseline moved from 141229 to 141627 KB at N=1000, a spread of 0.28 %, so the machine did not
    drift during the session and a move several times that size is the processor.

    The processor's allocation stepped up 5.9 % at 1.3.2 and has stayed up. 223818 to 236925 KB
    at N=1000, reproducing at +5.9 % at N=100 and +6.4 % at N=500, which is the signature of a
    per-element cost. Bisected to a commit rather than guessed at, by building each of the five
    processor-source commits between v1.3.1 and v1.3.2 in its own worktree and sweeping each in
    one session: the first four sit inside a 0.5 % band and the whole step is in f9b0e83f (#595).
    The mechanism is ModuleSidecar.unreadableSidecarNames, which generateFiles calls on every
    build and which load()s every sidecar on disk a second time so it can name the ones it could
    not read. In an ordinary build it parses all of them, finds every one readable and returns an
    empty list. Its javadoc says the re-read is deliberate and that "a directory listing of a handful
    of files costs nothing next to the compile it runs inside"; for a 1000-class module that second
    parse is 11.6 MB, and this is the first time anyone has measured it. Filed as #833, not fixed
    here: this change measures, it does not touch the processor.

    The guess that the same session first made from the changelog, that the fingerprint's new
    element-kind input was responsible, was wrong. That commit (cd09d259) measures 225867 KB
    against v1.3.1's 226533 KB.

    1.3.5 gave back about a quarter of the step (236816 to 233831 KB at N=1000). Main is
    indistinguishable from 1.3.6
    , +0.12 % at N=1000 and +0.06 % at N=500, both inside the 0.6 %
    floor: the unreleased descriptor-table refactors (#762, #765) replaced 811 lines of per-annotation
    arms and five parallel per-platform structures with two table walks and cost nothing measurable.

    Recorded in load-tests/results/1.3.7-SNAPSHOT/, with memory-same-session.txt carrying the
    overhead, baseline and peak-heap tables and the bisect. The folder is named for the version the
    measured jar reported: main @ 802d142 was installed as 1.3.7-SNAPSHOT on purpose, so that
    building it did not overwrite the published 1.3.6 jar it has to be compared against.

  • A no-op-processor column on IncrementalRebuildStressTest, because the saving was being
    quoted in a unit that is three quarters javac's (#834).
    That test reported what a rebuild of
    unchanged sources saves against a -proc:none baseline, which switches off javac's whole
    annotation-processing subsystem and charges all of it to VibeTags. ProcessorTaxStressTest has
    said for two releases that this inflates the figure three to four times; the incremental table
    was reading it anyway, and #834's headline, "a no-op rebuild still costs 96 % of a cold build",
    is that reading.

    A NoOpProcessor arm gives the base a change to this codebase can actually move. Two runs,
    same session, on this branch:

    N saved vs -proc:none saved vs no-op processor warm, VibeTags' own
    100 7.5 / 7.8 % 27.9 / 29.7 % 4.8 / 4.6 MB
    500 4.2 / 4.1 % 16.2 / 15.9 % 25.8 / 25.9 MB
    1000 3.7 / 3.7 % 14.9 / 14.9 % 48.9 / 48.9 MB

    The fingerprint short-circuit already returns 15 % to 30 % of what VibeTags itself allocates,
    not 3.6 %, and the whole remaining opportunity is the last column: 48.9 MB at N=1000, against
    the 226 MB the diluted column shows still standing. That is what any proposal to decide earlier
    than generateFiles() is bidding for, and it is a quarter of the size the issue implied.

    It also corrects the correction. That test's own javadoc records a first draft asserting a 25 %
    saving and calls the assumption behind it wrong; against the honest denominator 25 % was close.
    What was wrong was the denominator as much as the guess, and the javadoc now says so.

    The pair reproduces to 0.1 % where ProcessorTaxStressTest's equivalent split moved 34 % across
    two runs. The difference is that all three compiles here happen back-to-back inside one test
    method over one fixture, so whatever the machine is doing applies to all of them. Worth copying
    the next time a split has to reproduce.

  • AnnotationBreadthStressTest, because every baseline in this repository measures six of the
    44 annotations.
    SyntheticClassGenerator has rotated @AIContext, @AILocked, @AIAudit,
    @AIIgnore, @AIPrivacy and @AIDraft since 0.5.4, so 38 formatters never ran in any sweep
    here and no committed baseline said anything about their cost (#835). That mattered more since
    #765 replaced 44 hand-written arms in five classes with one table walked per annotation: the
    eleven-release sweep measured that flat, which is the right result about six annotations.

    Measured beside the sweeps rather than by widening them, for the reason the platform-breadth
    entry gives. At N=500, on the usual box:

    Fixture classes annotated refs alloc overhead elapsed generated bytes alloc/ref
    six-annotation mix 500 1214 119 886 KB 422 ms 495 657 101 122 B
    all 44 500 22 000 1 283 709 KB 1487 ms 14 159 829 59 750 B

    A project annotated with all 44 allocates 10.7x the sweep's figure and renders 28.6x the bytes,
    but carries 18x the annotated references, so per reference it is cheaper: the cost is
    sublinear in how many annotations sit on one class. The six-annotation row's 495 657 generated
    bytes is byte-identical to 1.3.7-SNAPSHOT/platform-breadth.txt's sweep row and to
    stress.txt's N=500 OutputSize, which is the anchor that makes the other row readable, and
    its allocation is within 0.7 % of that row's. The 1214 is counted in the fixture's text, not
    computed from the rotation rule; the arithmetic-looking answer is 1500 and it is wrong.

    Per-annotation marginal cost is the number nothing in this harness had ever reported. One
    compile per annotation, 100 classes carrying only that one, against a control of the same
    classes carrying none:

    marginal alloc generated bytes
    @AITestDriven 12 886 KB 83 502
    @AILocked 12 481 KB 34 438
    @AIThreadAffinity 11 239 KB 97 874
    ...
    @AIPrivacy 5 752 KB 33 067
    @AIContract 5 666 KB 33 421

    A 2.0x spread end to end, and rendered bytes do not predict it: @AIObservability renders
    121 KB, the most of any annotation, for less than @AILocked costs rendering 34 KB.

    The fixture is synthesised from each annotation's own reflected shape, not written out:
    GuardrailAnnotations.ALL gives the set, @Target decides where a usage can sit, and the
    declared members decide what to pass. A hand-kept list of 44 annotations and their members is
    the defect #762 and #765 were opened for, in the one fixture whose whole purpose is to leave
    none out. It gates on coverage rather than on a threshold, because the run-to-run floor here is
    wider than the gap between most annotations: every annotation in the table was placed, compiled
    and rendered more than the empty control, and an annotation the fixture cannot place fails by
    name. Only AISunset.replacement needed a literal beyond String, String[], boolean, int and
    enum, and it failed loudly on the first run rather than going quietly unmeasured.

  • PlatformBreadthStressTest, because every baseline in this repository measures a project that
    opted into six platforms.
    AnnotationVolumeStressTest has created the same six opt-in files
    since 0.5.4. VibeTags now writes 65 config files across 45 platforms, so the overhead column in
    every committed baseline is a six-platform project's, and nothing said so. The gap was noted once
    before, in the 0.8.0 entry, and has grown with every platform added since.

    Cost and benefit of opting more platforms in

    At N=500, on the usual box:

    Level opt-ins alloc overhead elapsed generated bytes files CLAUDE.md
    minimal (.cursorrules) 1 100.6 MB 353 ms 106 737 1 not opted in
    sweep (the historical six) 6 116.3 MB 360 ms 495 657 5 168 665
    sweep+granular (.claude/rules/) 7 136.3 MB 852 ms 606 196 505 115 633
    all-files 57 258.5 MB 553 ms 3 746 902 56 168 665
    all+granular 77 487.9 MB 9 434 ms 6 718 978 10 058 115 633

    The 57 and the 65 count different things and both are right: 65 is every generated config file,
    57 is the subset whose own presence is the opt-in, less the three switches
    (.vibetags-root-index, TESTING.md, .vibetags-locks) that change what the other levels mean
    rather than adding to them. The rest are implicit children another service activates.

    A fully opted-in project allocates 4.2x what the sweeps report, and 2.1x for single files alone.
    Scoped rules are the wall-clock story rather than the byte story: all+granular takes 17x as long
    as all-files for 1.8x the bytes, because it writes 10 058 files instead of 56. They are also the
    point, and the table carries both halves: .claude/rules/ on its own takes 31 % out of the
    always-loaded CLAUDE.md, which is invariant 6 working, and the test asserts that collapse
    happened rather than assuming it.

    The sweep row's 495 657 generated bytes is byte-identical to stress.txt's N=500 OutputSize.
    That is the cross-check that makes the rest of the column readable, and it is why the six-file
    level is carried as a column at all. Widening the sweeps' own fixture instead would have made
    every committed baseline incomparable with every one captured after.

    Level membership is read out of ServiceRegistry at run time, so a platform added tomorrow is
    measured tomorrow. It is read reflectively: load-tests is deliberately compiled against older
    processor jars to compare releases, and a direct call to a method those jars lack fails the whole
    module's testCompile and takes the volume sweeps down with it, which is what happened the first
    time this test was written against ServiceRegistry.writesDirectory.

  • IncrementalRebuildStressTest, because every number this harness has ever produced is a cold
    build.
    The volume sweeps give each N a fresh @TempDir, so .vibetags-cache is empty and the
    build fingerprint has nothing to compare against: both short-circuits are structurally
    unreachable, and the build a developer waits for twenty times an afternoon was unmeasured.

    Cold build against no-op rebuild

    The short-circuit fires, and it still leaves 96 % of the cost standing. Compiling the same
    sources twice into one project root: 24.4 to 23.2 MB at N=100 (4.9 % skipped), 116.4 to 112.5 MB
    at N=500 (3.3 %), 229.2 to 221.0 MB at N=1000 (3.6 %). It skips building and writing content, and
    by the time a fingerprint can be computed the collector has already walked every annotated element
    in the round, which is where the allocation is. Filed as #834.

    The test gates on the processor's own "inputs unchanged since last run" note, asserted present on
    the warm round and absent on the cold one, not on the size of the saving. Its first draft
    asserted a 25 % saving, from the reasonable-sounding assumption that skipping content and writes
    would be most of the cost. It is 3.6 %, which is too close to the run-to-run floor to carry a
    threshold at all. The assumption and the number are both recorded in the test.

  • Three plot scripts: plot-release-history.py, plot-platform-breadth.py and
    plot-incremental-rebuild.py
    , for the three figures above. The first reads the same
    memory-same-session.txt as plot-release-comparison.py and answers the other question: that one
    draws two or three releases as grouped bars for "did this release move", this one draws many as
    lines for "where did the curve move", with each series also indexed to its first release so a step
    common to every N is visibly the processor rather than one noisy row, and the 0.6 % floor shaded.

  • Both new tests run in CI. The load-tests job's -Dtest list is pinned, so a test not named
    in it never runs there. docs/WORKFLOW.md now says what that job is: a set of regression gates
    that assert the feature under test engaged, not a measurement, since nothing in CI compares a
    number against a baseline.

    The nightly perf ring does compare, against ls load-tests/results/ | sort -V | tail -1, and
    that has resolved to 1.0.4 since August. Verified rather than assumed: it now resolves to
    1.3.7-SNAPSHOT, so the nightly warning band is measured against a baseline from this month
    instead of one twelve releases old. It stays a warning, never a gate.

Fixed

  • Naming the sidecars a round could not read parsed every sidecar a second time (#833).
    ModuleSidecar.unreadableSidecarNames runs on every build, from generateFiles, and its only
    output is a list of file names that in an ordinary build is empty. It reached that answer by
    load()ing every sidecar on disk again, and a sidecar is not a directory entry but its module's
    whole collected model: every line materialised as a string, then every encoded value
    base64-decoded to prove it decodes, and both thrown away. Measured on a fixture of eight
    sidecars, that second parse allocated 40 591 368 bytes to read 5 593 264 bytes on disk, 7.3x.
    The release sweep in the entry above saw the same thing from the outside as a 5.9 % step in the
    processor's allocation overhead at 1.3.2, bisected to f9b0e83f (#595).

    None of the three things that can produce the two verdicts it reports is in a body: the
    # version header, whether the file opens and decodes as UTF-8 at all, and whether the trailer
    is the last non-blank line. So it now streams the file past a fixed-size scan and decodes
    nothing. The same fixture: 391 816 bytes, 104x less, and 0.07x the bytes on disk rather than
    7.3x
    , a constant per file instead of a share of what the file weighs.

    The whole file is still decoded, deliberately, rather than seeking to its two ends: load
    reaches UNREADABLE through an IOException and invalid UTF-8 in the middle of a file is one,
    so skipping the middle would stop naming that file and put the module back in the silent
    disappearance this warning exists to break (#592). Two tests, and both are needed because either
    one alone is satisfied by reverting the other: ModuleSidecarUnreadableScanAgreementTest holds
    the scan to the verdict load reaches, file shape by file shape, and
    ModuleSidecarUnreadableScanCostTest holds the cost to something that does not grow with the
    bodies it reads past. Both were written failing first; the agreement test was then re-broken on
    purpose and named the torn-write and trailer-prefix cases.

    ModuleSidecarSkeletonLoadTest is replaced by the agreement test. Its future-version case never
    reached that branch: it wrote version=99999 where the header is # version=, so both sides of
    its assertSame were the corrupt verdict and the assertion passed on a fixture it was not
    testing. The replacement asserts FUTURE_VERSION by name before comparing anything. No
    behaviour change and no generated byte changes: mvn verify -Pe2e on vibetags passes 3360 + 6
    tests with Checkstyle, PMD, CPD and SpotBugs all executed.

Changed

  • CLAUDE.md renders one guardrail block per module, not one per source set (#839). A test
    round wrote a second <project_guardrails> block under the first, repeating the header, the
    wrapper and every rule sentence. ClaudeSectionMerge joins the source sets' bodies instead:
    each section once, main entries first, each rule once. It declines, and the old concatenation
    runs, on any body it does not recognise, so no guardrail can be lost to it. The other prose
    formats (AGENTS.md, GEMINI.md, llms.txt) are still stacked; doctor --context shows it.

  • The scoped-rules index leaves out an element whose rule file holds only the safety tier
    (#839).
    Those stanzas are already inline in the aggregate, so the index line pointed at a file
    with nothing new in it. The file is still written. On this repository, measured with
    doctor --context before and after regenerating from a clean cache: CLAUDE.md 14,878 to
    13,444 bytes, its generated block 9,106 to 7,672, and <scoped_rules> 3,089 bytes in two copies
    with 24 entries to 2,002 bytes in one copy with 18.

  • The builder walks the descriptor table's implicit activations instead of restating them
    (#830).
    Five outputs have no opt-in file of their own: the two Codex sidecars and the three
    always-loaded safety files that live inside a rules directory. PlatformDescriptors.ALL records
    which service activates each, in implicitParent, and ServiceRegistry.optInKeys() is derived
    from it. What acted on the relationship was a hand-written if per child in
    GuardrailContentBuilder.build(), left behind by #829 because the calls were not uniform: the
    Codex pair asked the routing view for its model and the three safety files were handed the whole
    model. It is now one loop over the entries with a parent.

    The two are the same call because routesTestGuardrails answers false for every *_safety key,
    so the routing view hands those three the whole model anyway. That is not a coincidence to lean
    on quietly: a safety file carries the six always-loaded buckets, which are exactly the guardrails
    that never move to TESTING.md, and ImplicitActivationFanOutTest now pins it. The same test
    caught the first version of this entry claiming no implicit child routes at all, which is wrong
    about codex_rules; it routes, and routed before this change too.

    The drift the ifs allowed was silent in both directions. A sixth entry added to the table with
    no if beside it is rendered by nobody: no file, no warning, and optInKeys() correctly refuses
    to let the user ask for it by hand, so nothing goes red. ImplicitActivationFanOutTest drives
    the real builder off the table and was confirmed red by disabling one if before the change
    (devin_safety (parent devin_granular)). No generated byte changes: mvn verify -Pe2e on
    vibetags passes 3364 + 6 tests with Checkstyle, PMD, CPD and SpotBugs all executed.

  • Every consumer is swept in a git worktree, so a dirty checkout no longer silently shrinks the
    sweep (#790).
    tools/consumer-sweep.sh refused to sweep a repo with uncommitted work, which is
    right, and then printed the same footer as a complete run. On 2026-09-22 that skipped four of five
    consumers and reported one result; the same guard had already skipped async-test-lib on every
    run until #617. WORKTREE_REPOS becomes IN_PLACE_REPOS, empty and meant to stay empty: a
    worktree off origin/main is what the non-worktree path was trying to build anyway, and it never
    touches the developer's checkout. Read the footer's "Built N of 5" either way.

  • Docs: Bend's LAWS.bend is refused, and the request named a file that does not exist (#760).
    Bend was asked for as a platform, as bend/LAWS.md. The file is LAWS.bend, and it is Bend
    source stating properties the compiler demands a matching proof for in PROOF.bend, not prose an
    agent reads. VibeTags has nothing to render from (a law quantifies over Bend types, and a Bend
    project has no annotated Java), could not write a provable one, and would hand the consumer a red
    bend PROOF.bend if it tried. Bend's own integration instruction is a paragraph in AGENTS.md,
    which VibeTags already writes. Recorded in docs/PLATFORMS.md with the vendor quotes. Read from
    the vendor's README on 2026-09-22, not run. No key, path or generated byte changes.

  • Docs: Trae is now TraeCode, and can import AGENTS.md and CLAUDE.md (#809).
    docs/PLATFORMS.md records the rename, the two import switches, the possible double delivery
    when a project has both CLAUDE.md and .trae/rules/, and the decision that the new
    scene: git_message front-matter field is out of scope. No key, path or generated byte changes.
    Read from the vendor page on 2026-09-21, not run.

  • A lean-indexed reactor root now treats GEMINI.md like CLAUDE.md (#763). With
    .vibetags-root-index, the root GEMINI.md kept every module's verbose tier embedded while the
    root CLAUDE.md, .cursorrules, .windsurfrules and Copilot file got a pointer. It now gets the
    module's safety digest plus a pointer too. This changes generated output in a reactor that
    has .vibetags-root-index, a root GEMINI.md, and modules with their own GEMINI.md or
    .gemini/rules/; nothing else moves. The pointer tells the agent to open the rule file rather
    than saying it loads automatically, because Gemini CLI does not read .gemini/rules/ (#669).
    The cause was one pairing declared four times: GranularRulesWriter.FORMATS,
    GranularIndexSection, ModuleSidecar and a + "_granular" concatenation in the processor
    that names a key gemini_md does not have. All four now read GranularPairing, and
    GranularPairingParityTest holds its paths to the registry's.

  • "Renders as another platform" is now a property, Platform.rendersAs() (#764). GEMINI.md
    prints .gemini/styleguide.md's words, and that used to be a case GEMINI_MD: label beside
    case GEMINI: in 14 formatters plus a second SectionCatalog registration; the one time half
    of a pair was missing, GEMINI.md printed the default headings with nothing failing (#721).
    AnnotationFormatter.format is now a default method that resolves the alias and calls
    render(element, sb, family), which the 44 formatters implement, so no implementation can see
    an alias. The 14 duplicate labels and the second registration are gone. No generated byte
    changes: every golden file passes. TransitiveSection.PLATFORMS still names both Gemini files,
    on purpose: that is a list of files that get a section, not of wordings. The five renderers that
    only forwarded to CursorRenderer (Firebase, Cline, Void, Goose, Replit) are deleted; their
    platforms are fall-through labels beside CURSOR in PlatformRendererRegistry, where the
    comment keeps what each class's Javadoc knew, including that the Replit Agent co-authors
    replit.md.

  • The build fingerprint gives @AILoadBearing its own tag (#765). BuildFingerprint labelled
    both legacyBridge and loadBearing "LB", against the add-annotation rule that tags are
    unique. It was harmless, since sections are positional, and loadBearing is now "LDB". The
    hashed string changes, so the first build on this version misses the fingerprint short-circuit
    once: it rebuilds the content, finds every file unchanged and rewrites none. BuildFingerprintTagUniquenessTest no longer carries
    an allowed collision and enforces the rule outright.

  • One descriptor table replaces 44 hand-written arms in each of five classes (#765).
    AnnotationDescriptors.ALL (in internal/content) holds, per annotation, the fingerprint tag
    and member extractor, the formatter, and the granular stanza's title and body. BuildFingerprint,
    GranularRenderer, AiderConventionsRenderer, InterpreterRenderer and
    GuardrailInstructionBlock walk it, which removes 811 lines of parallel arms; adding an
    annotation is one entry instead of five edits. The table is a new list with its own pinned
    order, not GuardrailAnnotations.ALL. The GuardrailModel and AnnotationCollector named
    accessors stay, since the position-specific renderers read them as method references. No
    generated byte and no fingerprint changes. Verified by rendering every platform and every
    granular stanza for four fixture models (populated, unset, optional-unset, no annotation
    instance) before and after: the two 1,162,376-byte dumps are identical. The new
    BuildFingerprintPinnedValueTest holds the fingerprint of two fixed 44-annotation models to
    literals computed from the old code, and AnnotationDescriptorsTest pins the tag order and
    checks each entry against its own annotation. BuildFingerprintTagUniquenessTest now reads the
    table instead of parsing BuildFingerprint.java with a regex.

  • One descriptor table replaces the five parallel structures a platform was spread over (#762).
    PlatformDescriptors.ALL (in internal/content) holds, per generated output, its service key,
    root-relative path, whether that path is a file or a directory, whether its own presence is the
    opt-in or another service activates it, its Platform, its renderer, and an exclusion file's
    display name and glob flag. ServiceRegistry.buildServiceFileMap, ServiceRegistry.OPT_IN_KEYS,
    ServiceRegistry.writesDirectory, the switch in PlatformRendererRegistry,
    IgnoreFileRenderer.getPlatformSpecificName and the 22-label glob arm of AIIgnoreFormatter are
    all derived from it. Adding a platform is one entry instead of six edits in five files, and every
    one of those places used to fail quietly when missed: a platform with no path renders content the
    write step drops, a path with no opt-in key is an output the user cannot ask for, a missing
    renderer label threw only on the branch that filters the key out first (which is how
    GEMINI_GRANULAR went unnoticed), and a missing glob label produced an exclusion file holding a
    header and no patterns. writesDirectory no longer reads the _granular suffix, which was a
    naming convention standing in for a declaration. No generated byte changes: the 85 service keys,
    their paths, their order and the opt-in set are pinned row by row in PlatformDescriptorsTest
    from values dumped out of the old structures, examples/basic regenerates byte-for-byte, and the
    explanatory comments that lived in the two ServiceRegistry lists and the renderer switch moved
    onto the entries they describe.

  • The corpus sweep now sees every platform path, not 79 of 84 (#762).
    corpus/check-platforms.py scraped map.put("key", root.resolve("literal")) out of
    ServiceRegistry, so it never matched the three granular safety files, .vibetags-locks or
    .vibetags-root-index, whose paths came from a constant or a chained resolve. It reads
    PlatformDescriptors now, where every path is a literal, and takes the file-or-directory answer
    from the declared Kind instead of the _granular suffix. It also stops seeding what is not an
    opt-in: the two Codex sidecars and the three safety files are written because another service is
    active, and .vibetags-root-index changes how the aggregates render rather than naming a
    destination. All five are still verified when a run produces them. Measured on a local
    reproduction of the sweep: 63 platform files written and non-empty, 12 parsed, including the two
    safety files and .vibetags-locks the old extraction never looked at. The gate that caught the
    move was the extraction's own "expected 40 or more" floor, which refused to sweep the subset it
    still recognised rather than reporting success over it.

Fixed

  • Removing the last annotation from a source set left its guardrail behind for good (#781).
    Seen in TESTING.md and, without routing, in CLAUDE.md. Three causes, each shown necessary by
    a test that fails without it. javac never called the processor for a source set with no
    annotation left, so the claim now widens to "*" whenever a sidecar at the root records
    elements; a project with no sidecar is unaffected. A round that found nothing never saved its
    sidecar, so the old one kept contributing; an emptied round that was shown its sources now saves
    its empty one. And the single-sidecar write was gated on the round having found annotations; it
    now also rewrites the files that source set withdrew from. The last two are edits inside the
    @AILocked generateFiles(), unlocked by the owner for this issue; its step order is unchanged
    and checkFiles() mirrors both. A partial round is refused before generation (invariant 17),
    which is what makes an empty result safe to believe. Behaviour change: every compilation of a
    project that has guardrails now reaches the fingerprint check, unannotated source sets included.
  • Deleting TESTING.md left test guardrails in no file when the main sources are unannotated
    (#782).
    A main-only build after the deletion did not put them back in the always-loaded files
    until the tests were compiled again. Two guards decided it. javac never calls a processor whose
    supported annotation types match nothing in the compilation, so VibeTags did not run at all;
    it now claims "*" for as long as a routed sidecar holds an unrouted body and TESTING.md is
    gone, the same narrow widening .vibetags-transitive uses. And the fallback body is substituted
    only on the merge path, which a lone sidecar now reaches while the fallback is in force.
    TestingMdLifecycleEndToEndTest.deletingTestingMdLosesNothingEvenWhenTheMainSourcesAreUnannotated
    was committed @Disabled with #779 and is enabled; it stays red with either half removed.
  • AGENTS.md stopped being written when .vibetags-locks was opted in (#800). The sole-file
    rule counted the locked-elements report as a second AI config file, so a project whose only
    instruction file is AGENTS.md lost it the moment it asked for the report. .vibetags-locks is
    JSON Lines read by the action/locked-files CI guard and by no AI tool, so it no longer counts,
    the same answer .vibetags-root-index (#788) and TESTING.md already get. Verified failing
    first: AgentsMdSoleFallbackTest.agentsMdBesideOnlyTheLocksReportIsStillTheSoleAiConfigFile
    was red before the one-entry change and green after.

Fixed

  • ProcessorHotPathBenchmark had not measured anything since 1.3.5, and reported success the
    whole time.
    Its @Setup(Level.Trial) created every service path as a file. #684 added
    .windsurf/rules/+vibetags-safety.md, a file inside the .windsurf/rules scoped-rules
    directory, so whichever of the two came first in map order won and creating the other threw
    FileAlreadyExistsException. Trial-level setup, so all six benchmarks failed.

    Nothing went red anywhere. CI does not run JMH, and
    java -jar benchmarks.jar <Class> -rf json -rff out.json exits 0 when every benchmark in the
    class fails, having written []; the stack traces scroll past mid-run and the status is clean.
    The capture for this baseline produced a jmh.json holding zero benchmarks where every other
    release folder holds six, which is the only reason it was noticed.

    Which paths are directories is now derived from the service map itself, since a path that is a
    strict ancestor of another path in the map has to be one. That holds for every processor version
    this harness is pointed at, including jars with no writesDirectory method to ask. The rerun
    produces six benchmarks with the tightest error bars any baseline has recorded (2-15 % of score,
    against several earlier captures where the error exceeded the score), and
    writeFileIfChanged_noChange is the cheapest of the three write benchmarks, which is the
    property load-tests/README.md says to check.

  • Every committed comparison and processor-tax plot shipped without its caption. A caption
    placed with ax.text(..., transform=ax.transAxes) at a negative y lands below the figure canvas
    and savefig drops it silently: 107 px of blank below the last ink in
    alloc-release-comparison-*.png, 85 px in processor-tax-1.0.0-RC9.png. The captions carried
    the noise floor, which plot-release-comparison.py's own comment calls load-bearing ("without it
    a reader cannot tell which of these bars means anything"). They now go through
    fig.text(0.5, 0.015, ...), and the affected PNGs are regenerated from their unchanged committed
    data.

  • Two claims in load-tests/results/README.md were false and are corrected.

    OutputSize(B) has not been 14 179 / 101 296 / 495 656 / 988 897 since 1.0.0-RC9. It moved by
    exactly one byte at every N at 1.3.5, to 14 180 / 101 297 / 495 657 / 988 898. A constant,
    N-independent offset is fixed content rather than per-element content, so it was chased: bisected
    by sweeping each release in one session, then rendering one probe class with the 1.3.4 and 1.3.5
    jars and diffing the six files. The whole delta is in gemini_instructions.md, one blank line
    removed after the header and two added before section headings, which is the intended #721/#723
    spacing fix. No defect, but the number a future capture compares against was wrong.

    vibetagsShare does not reproduce to 0.6 %. That figure came from two RC9 runs; two runs in one
    session on 2026-09-22 gave 78004 KB and 58151 KB, a spread of 34 %. What reproduces is apTax,
    five runs across two days inside 2.3 %, which is the expected shape since it is javac's cost and
    does not depend on which processor is loaded. The javac share of the reported overhead is
    therefore "roughly a quarter to a third", not 24.7 %, and nothing finer should be read off it.