Skip to content

VibeTags v1.3.5

Choose a tag to compare

@PIsberg PIsberg released this 15 Sep 10:08
dd9958e

[1.3.5] - 2026-09-15

Upgrading changes committed files. If a granular directory is opted in (for example
.claude/rules/ or .gemini/rules/), the scoped-rules index in the matching aggregate
(CLAUDE.md, GEMINI.md and the others) is rewritten on the first build: each entry drops its
restated rule-file path, and the index note states the naming convention once instead (#626, under
Changed). With .gemini/rules/ opted in, GEMINI.md's index note text also changes (#669, under
Changed). GEMINI.md itself takes Gemini's own section wording, drops its # Do not edit manually.
line and sets every section off by one blank line (#721, #723, under Fixed). llms.txt,
llms-full.txt, CONVENTIONS.md, .github/copilot-instructions.md and the Junie files lose empty
headings and doubled blank lines (#725, #726, #728, #730, under Fixed). The .vibetags-mod-*
sidecars that carry that content change with it. Commit the regenerated files together with the
version bump; a -Avibetags.check=true build reports drift until you do.

With .windsurf/rules/ opted in, the front matter of every rule file in it changes from Cursor's
description/globs/alwaysApply header to trigger: glob and globs: (#683, under Fixed). With
.devin/rules/ or .windsurf/rules/ opted in, the first build adds +vibetags-safety.md to that
directory, and in a reactor .claude/skills/vibetags-guardrails/SKILL.md loses the copy of its
front matter repeated inside each module's section (#684, under Added). With .cursor/rules/ or
.trae/rules/ opted in, the globs: line of every rule file in it changes from a bracketed, quoted
list to the bare comma-separated value both vendors document (#699, under Fixed).

Consumer sweep. On 2026-09-15 all five downstream repositories built and passed their own tests
against the code this release tags. Each had 1 to 7 generated files change, and every change was one
named above: the #626 index, GEMINI.md's wording and spacing, and the empty llms.txt headings.
The set of annotated elements named in each changed file was identical before and after. None of the
five opts into .windsurf/rules/, .devin/rules/, .cursor/rules/ or .trae/rules/, so the sweep
does not exercise #683, #684 or #699.

Platform re-check. Release step 0b checked every generated path against its vendor's own
documentation (#664 to #677). This release acts on the findings below, each confirmed at the
vendor before anything changed, and the table under Deprecated lists every deprecated output:

  • Roo Code shut down on 15 May 2026, and its community fork Zoo Code reads the same .roo/rules/,
    .roomodes and .rooignore, confirmed in Zoo Code's own docs and source. The docs now name
    Zoo Code for those outputs, and nothing Roo-related is deprecated (#664).
  • Void is deprecated, and its source read .voidrules, never .void/rules.md, which is
    deprecated (#665).
  • The eight long-tail outputs in #666 were each confirmed retired or never read, and are
    deprecated.
  • .claudeignore (#667), .copilotignore (#668) and .antigravityignore (#670) appear nowhere in
    their vendors' documentation, which names a different mechanism each time. They are deprecated,
    and the @AIIgnore orphan warning stops telling projects to create the first two.
  • Firebase Studio's .idx/airules.md and Amazon Q's .amazonq/rules/ still work, but the vendors
    have announced end dates (22 March 2027 and 30 April 2027), so both are deprecated a release
    ahead of them (#676).
  • No Google product reads .gemini/rules/, so GEMINI.md's index note stops saying those files
    load automatically and tells the agent to open them (#669, under Changed).
  • Cursor calls .cursorrules legacy and says it "will be deprecated", but not that it stopped
    reading it, and Cline reads it too. PLATFORMS.md now says so; it is not deprecated (#672).
  • Junie checks .junie/AGENTS.md first and calls .junie/guidelines.md its "legacy format for
    guidelines (still supported)". VibeTags now writes .junie/AGENTS.md too, and keeps writing the
    legacy file without a deprecation warning (#673, under Added).
  • Windsurf is now Devin Desktop, which prefers .devin/rules/ over the .windsurf/rules/ fallback,
    still reads .windsurfrules, and added .devinignore beside the legacy .codeiumignore.
    VibeTags now writes .devin/rules/ and .devinignore and keeps writing every Windsurf output
    (#671, under Added). The same docs give .windsurf/rules/ a trigger: front matter that VibeTags
    had never written, and its rule files now carry it (#683, under Fixed).
  • The Cody and Supermaven notices from #641 claimed more than the vendors said, and now quote
    Sourcegraph's and Supermaven's own posts (#677).
  • Open Interpreter's profiles moved to TOML, and its config loader strips profiles from a
    project's .openinterpreter/config.toml, so there is no project-level profile to write.
    .interpreter/profiles/vibetags.yaml is deprecated in favour of AGENTS.md, which Open
    Interpreter documents as its project instruction file and VibeTags already writes (#674).
  • Ellipsis's documentation never mentions ellipsis.yaml, which is deprecated. Its current
    .ellipsis/code_review.yaml is not written: it has no rules field, only reviewer agents, and
    declaring the review stage replaces Ellipsis's built-in reviewer. PLATFORMS.md records what the
    docs do and do not pin (#675).

Added

  • CI runs doctor against examples/kotlin. doctor --dir examples/kotlin must exit 1 and
    report AccountLedger.kt:26 @AILocked on fun balanceFor with its @JvmName("balanceFor") remedy,
    and must not report settle or reconcile, whose guardrails kapt keeps. The Kotlin value-class
    check was exercised only by DoctorCommandTest, so a path, encoding or line-ending difference in a
    real checkout would have gone unnoticed; this is the Kotlin half of what #533 does for Groovy. (#693)

  • Devin Desktop's .devin/rules/ and .devinignore (#671). Windsurf is now Devin Desktop, and
    its docs call .devin/rules/*.md "preferred" and .windsurf/rules/*.md the "fallback". Each
    rule file opens with the front matter the docs give a glob rule, trigger: glob and globs:, so
    it loads when a matching file is read or edited. .devinignore takes "the same syntax as
    .gitignore" and gets the @AIIgnore globs. .windsurfrules, .windsurf/rules/ and
    .codeiumignore are still written, and adding .devin/rules/ changes none of them. The Devin CLI
    docs say rule files in both directories are loaded, and VibeTags writes the same file into each,
    so a project should opt into one; PLATFORMS.md quotes what the vendor says. .windsurfrules still collapses to an index
    only for .windsurf/rules/.

    DevinDesktopEndToEndTest was run first against the code without either service, and all 5 of
    its original cases failed; its .devinignore case also went red with only the
    AIIgnoreFormatter arm removed.

  • Devin Desktop's rule directories now get an always-on safety tier (#684), in
    .devin/rules/+vibetags-safety.md and .windsurf/rules/+vibetags-safety.md. Every rule VibeTags
    writes there is trigger: glob and loads only when a matching file is read or edited, so a
    project on a rules directory alone kept no @AILocked, @AICore, @AIPrivacy, @AIIgnore,
    @AIAudit or @AISecure guardrail in front of the agent up front. The new file opens with
    trigger: always_on, which the docs say includes the "Full rule content ... in the system prompt
    on every message", and carries the safety sections .windsurfrules keeps inline as an index. It
    follows #648's shape: an implicit service per directory that takes the marker merge, write cache
    and check mode from the aggregate path, is exempt from the orphan sweep, and is rendered even
    when the tier is empty. With .windsurfrules opted in, which Devin Desktop still reads and loads
    always on, the file names it instead of repeating the tier; with both directories, the
    .windsurf/rules/ file names the .devin/rules/ one. The reactor merge now writes a front
    matter every module shares once, above the module sections. It used to repeat it inside each
    module's section, which left a file created by the merge with no trigger at the top, and gave
    the Claude skill's SKILL.md a repeated header in reactor builds that it now loses.

    DevinSafetyTierEndToEndTest was written first: 15 of its 16 cases failed against the branch
    with no safety file written; the one that passed guards that the aggregate alone creates no
    directory. With the file rendered and the merge unchanged, both reactor cases still failed on a
    second trigger: line inside a module sub-marker.

  • A build warning when a generated .devin/rules/ or .windsurf/rules/ file passes 12,000
    characters
    (#695). Devin Desktop's docs limit a workspace rule file to "12,000 characters per
    file" without saying whether the rest is cut or the file dropped, and a role grouping many
    elements or a safety file with many safety annotations could pass that with the build reporting
    success. Every file VibeTags writes into either directory, +vibetags-safety.md included, is now
    measured as the build leaves it, on a build the fingerprint short-circuit skips and in check mode
    as well, and each one over the cap is named with its length. Characters are UTF-16 code units.
    .windsurfrules is not measured, because the docs name no cap for it.

    RuleFileLengthEndToEndTest was written first and all 7 cases failed with no warning emitted;
    with the check placed before generation, as the YAML duplicate-key warning is, 5 still failed,
    because that measures the previous build's file.

  • The 12,000-character rule file warning covers Antigravity's .agents/rules/ (#701).
    Antigravity's rules page says "Rules files are
    limited to 12,000 characters each.", the same cap and the same silent-loss shape as #695, which
    covered only Devin Desktop and Windsurf. A generated .agents/rules/ file over the cap now gets the
    same warning and the same validation.rule-file-over-limit log event, worded for Antigravity and
    without the .windsurfrules remedy, which does not apply there. The vendor docs of every other
    granular directory were checked for a per-file cap and none documents one; PLATFORMS.md quotes
    what was found, including Augment's combined cap, which is not measured.

    The .agents/rules/ cases in RuleFileLengthEndToEndTest and RuleFileLengthWarnerTest were
    written first: all 3 failed with no warning emitted, and pass with antigravity_granular added to
    RuleFileLengthRule.CAPPED_DIRECTORIES.

  • JetBrains Junie's .junie/AGENTS.md (#673). Junie's guidelines page lists it first in the
    order Junie looks for guidelines, ahead of the root AGENTS.md and of .junie/guidelines.md,
    which it calls legacy and still supported. The new file gets the same rendering as
    .junie/guidelines.md, which is still written and not deprecated. It is a separate service
    (junie_agents), not the root AGENTS.md: that file is still written only as the sole AI config
    file or with a marker pair. One project shape changes: a root AGENTS.md whose only companion
    was .junie/AGENTS.md used to count as the sole config file and receive the Codex rendering, and
    is now left untouched unless it carries a marker pair. PLATFORMS.md records what Junie's page does
    not say, whether it reads both files when both exist.

    JunieAgentsMdEndToEndTest was run first against the code without the service: 4 of its 6 cases
    failed, including the root pointer gaining a Codex block beside .junie/AGENTS.md.

  • Cline's .clinerules/ directory now gets an always-loaded safety tier (#648), in
    .clinerules/+vibetags-safety.md. Every rule file in the directory carries paths: front matter
    and loads only once a file matching its glob is in the task's context, and Cline's aggregate is
    the directory's own path, so a project on the directory form had no file that kept @AILocked,
    @AICore, @AIPrivacy, @AIIgnore, @AIAudit or @AISecure in front of the agent up front. A
    @AIPrivacy field was invisible to Cline until its class was already in context. Invariant 6
    exists to prevent exactly that on every other platform.

    The new file carries what .cursorrules keeps inline when its granular directory is opted in,
    with no front matter, which Cline treats as always active (rule-conditionals.ts evaluates only
    the conditions a rule declares; the docs: "Rules without frontmatter are always active"). It is an
    implicit service under cline_granular, so it takes the marker merge, the reactor merge, the write
    cache and check mode from the aggregate path rather than new code, and the orphan sweep now skips
    any file another service writes inside a granular directory. The leading + keeps the name out of
    reach of every element and role stem. It is rendered even when the safety tier is empty, because a
    file that went quiet would keep the last removed @AILocked loaded with nothing to retire it.
    60 config files.

    ClineSafetyTierEndToEndTest was written first: five of its seven cases failed against main
    with no safety file written, and the multi-module case was added before the merge was relied on.

  • vibetags doctor reports the Kotlin guardrails kapt drops on value-class functions (#688).
    kapt leaves out of its Java stubs every function whose JVM name is mangled because it takes or
    returns a @JvmInline value class, so an @AI* annotation on it, or on one of its parameters,
    generated nothing and logged nothing (#681). The processor cannot warn, since it sees only the
    stub, but doctor can read the .kt sources. It now reports each such function with its file and
    line, the guardrails it loses, the value class responsible and the @JvmName that keeps it, the
    same route the Groovy field check took (#494).

    It is a heuristic source scan and says so on every run. It knows the value classes declared under
    the scanned directory plus UByte, UShort, UInt, ULong and kotlin.time.Duration, resolves
    type names through each file's package and imports (so java.time.Duration is not a hit), and
    skips the three shapes measured to survive on Kotlin 2.4.10: a kotlin.Result parameter, a value
    class used only as a type argument, and a function with @JvmName. It misses value classes from
    other modules or dependencies, type aliases, and shapes never measured against kapt, such as
    extension receivers; docs/JVM-LANGUAGES.md lists them. Where it cannot tell, it stays silent: a
    file mentioning @JvmExposeBoxed is skipped, and a build file passing -Xjvm-expose-boxed skips
    the check with a line saying why, because neither boxed variant was measured against kapt. Both
    silences, and the unmeasured shapes, were replaced by measured rules before release (#692, under
    Changed).

    Eleven new DoctorCommandTest cases. Seven failed before the code they pin existed: the three
    reporting cases, the unreadable file, the summary line the Result case asserts, and the two
    @JvmExposeBoxed cases. The four negatives cannot fail against a doctor that has no check, so
    each exclusion, plus import resolution, was broken once on purpose and turned exactly its own
    test red.

  • vibetags doctor --classpath sees Kotlin value classes declared in dependencies (#691). The
    value-class check knew only value classes declared under --dir, so a function taking a domain
    ID from a shared model library lost its guardrail with nothing reported, although kapt drops
    it the same way: Consumer.forCustomer(CustomerId), with CustomerId in another Gradle module,
    was measured lost in the #692 fixture. --classpath takes jars and class directories, as for
    java -cp, and doctor counts every top-level class whose class file carries
    @kotlin.jvm.JvmInline, which kotlinc writes as a runtime-visible annotation. The reader is plain
    JDK code over the constant pool, so the CLI still has no third-party dependency. kotlin.Result
    is skipped, a source declaration wins over a stale class file, and a missing entry or an
    unreadable class file is a finding. Running from a reactor root already scanned sibling modules'
    sources; that is now pinned by a test and documented.

  • vibetags doctor resolves nested Kotlin value classes, from sources and from --classpath
    (#714). A function taking Outer.Id lost its guardrail through kapt, from the same module or
    another, and doctor said nothing: the source scan knew a nested value class only by its simple
    name, and the class-file reader skipped every Outer$Id class file. Both now use the name Kotlin
    source writes. The declaration walk records classes nested in named classes as pkg.Outer.Id,
    and a dotted type resolves through its first segment's import, the file's package or a star
    import; the reader names a nested class through its InnerClasses attribute, counts no local or
    anonymous class, and turns an InnerClasses chain deeper than 64 into a finding rather than a
    StackOverflowError. The deprecated inline class form needed nothing: javap -v shows kotlinc
    2.4.10 writes @kotlin.jvm.JvmInline into its class file although the source has none, so no
    @kotlin.Metadata decoding and no new dependency. Five guardrails in the #713 fixture (nested
    and inline class parameters, from source and from the model module) were all lost by default
    and kept with -Xjvm-expose-boxed; doctor went from 91 to 94 findings on the model classes and
    reports all five. On kotlin-stdlib the reader now also finds
    kotlin.time.TimeSource.Monotonic.ValueTimeMark. Three new DoctorCommandTest cases, all red
    before the change; the nesting cap was lifted once and the cycle case failed with
    StackOverflowError.

    On the fixture's Gradle compile classpath, the reader found CustomerId plus the nine
    standard-library value classes in kotlin-stdlib, and doctor's findings rose from 55 to 56, the
    new one a UIntArray parameter measured lost. Five new DoctorCommandTest cases and one
    MainTest case; the four that need --classpath were red before it existed, and the reactor-root
    case, which passes on the old code, turned red when the sibling module was excluded from the walk.
    The fifth feeds a class file with an annotation nested 100,000 levels deep, which crashed the
    reader with a StackOverflowError until nesting was capped at 64 levels.

  • A warning when a hand-authored top-level key collides with a generated YAML block (#635).
    VibeTags keeps text outside its markers, as it must, so a user's own read: in .aider.conf.yml
    survives next to the generated one and the document declares the key twice. PyYAML keeps the
    last occurrence and drops the other with nothing logged; a strict loader rejects the file. The
    warning names both lines and which one is read, fires on every build including ones the
    fingerprint short-circuit skips, and covers all seven YAML platforms by reading their keys off the
    renderers. HandAuthoredYamlKeyEndToEndTest was red against the unchanged processor on four of
    its five cases (the fifth asserts silence).

    The previous advice in PLATFORMS.md, to move your own read: entries inside the generated block,
    was wrong and is gone: a probe showed the block is rewritten on the next build and those entries
    are lost.

  • Gemini Code Assist (.gemini/styleguide.md) and aider's .aider.conf.yml. 42 AI
    platforms, 52 config files.

    Gemini Code Assist reviews pull requests on GitHub and takes its per-repository rules from
    .gemini/styleguide.md, which is a different product and a different file from the Gemini CLI's
    GEMINI.md. The path is from
    Google's own docs,
    not from a cross-tool round-up: the last sweep found three of those rows stale, so every path here
    was read from the vendor.

  • .aider.conf.yml is a defect fix wearing a platform's clothes. aider does not load
    CONVENTIONS.md on its own -- its
    conventions docs say the file has to be named
    with /read, --read, or a read: key in the config. VibeTags has generated CONVENTIONS.md
    since v0.5.0, so for eleven releases the aider platform wrote a file no aider session ever opened.
    Nothing failed, because the only thing anyone checked was that the file existed.

    GeminiCodeAssistAndAiderConfEndToEndTest.aiderConfNamesTheConventionsFile is the assertion that
    would have caught it, and it was confirmed red against a renderer that names a different file.

    .gemini/config.yaml is deliberately not written: its ignore_patterns key would duplicate a
    hand-authored one, and PyYAML resolves a duplicate top-level key by keeping the last, so one of
    the two would be lost silently. The same hazard applies to read: in .aider.conf.yml and is
    accepted there only because it is the difference between that platform working and not. Both are
    documented in PLATFORMS.md, with #635 and #636 tracking the follow-ups.

  • The README's own config-file count had drifted from itself: the project-facts line said 50 while
    a link four lines below said 49. ProjectFactsConsistencyTest pinned the first and not the
    second.

  • Three more exclusion files driven by @AIIgnore: .rooignore (Roo Code), .continueignore
    (Continue) and .augmentignore (Augment Code). 53 config files. Each is the only exclusion
    mechanism its tool offers, and VibeTags already wrote that tool's rules directory, so the
    guardrails were reaching the model and the exclusions were not.

    IgnoreFileFamilyEndToEndTest asserts the glob, not the file. AIIgnoreFormatter switches on
    the platform and its default arm writes nothing, so an ignore file wired through
    ServiceRegistry and PlatformRendererRegistry but missed in the formatter is created, opted
    into, and left holding a header with no globs under it, with nothing thrown and nothing logged.
    The test was confirmed red against exactly that state.

    Three further candidates were checked against the vendor's own docs and refused, which is the
    part worth recording: .aiignore (820 public repos) because JetBrains states that a project with
    .cursorignore, .codeiumignore or .aiexclude needs no .aiignore and VibeTags writes all
    three; .cursorindexingignore (670) because it no longer appears in Cursor's ignore-files
    documentation; .clineignore (514) because Cline's own page for it is titled "(deprecate soon)".
    Adoption is not the test -- a file can sit in hundreds of repositories and still be one no tool
    reads any more. PLATFORMS.md carries the table.

  • The cross-client Agent Skills location (.agents/skills/vibetags-guardrails/SKILL.md),
    Zencoder (.zencoder/rules/*.md) and Replit Agent (replit.md). 44 AI platforms,
    57 config files, 18 scoped-rule directories.

    The skill is the cheapest of the three by a distance: VibeTags has rendered a SKILL.md since
    v1.0.0 and wrote it only to .claude/skills/, which is the one directory only Claude Code scans.
    .agents/skills/ is the location clients scan to see each other's skills, so the same bytes at a
    second path reach every client that does. theAgentsSkillIsByteIdenticalToTheClaudeSkill pins
    that they stay the same artifact rather than becoming two that drift.

    Zencoder's front matter is copied from Zencoder's own output, not inferred from its prose: its
    Repo-Info Agent writes .zencoder/rules/repo.md carrying description and alwaysApply. The
    generated rules declare alwaysApply: true, on the same reasoning as Augment Code in 1.3.3 --
    a guardrail the model may decline to load is not a guardrail. VibeTags' orphan cleanup scrubs
    only marker regions, so Zencoder's own repo.md in that directory is left alone.

    replit.md is the one file VibeTags does not solely author: the Replit Agent writes to it as it
    learns about a project. That is survivable only because it is Markdown and therefore
    marker-delimited, so the worst case is a stale block between two compiles rather than lost
    content.

    greptile.json was checked and deferred here, and added in the entry below.
    .continuerules was refused: it does not appear in Continue's current rules
    documentation, which documents .continue/rules/ -- which VibeTags already writes.

  • Greptile (.greptile/rules.md and greptile.json), closing #639. 45 AI platforms, 59 config
    files.

    greptile.json needed a write mode VibeTags did not have. .json outputs carry no markers and
    are whole-file overwrites, and a real greptile.json holds up to thirty hand-set review settings,
    so opting in would have erased every one of them on the first compile. VibeTags now owns a
    delimited span inside the instructions and ignorePatterns string values and nothing else:
    the span is spliced into the original text, so every byte outside it survives, the user's own
    text in either value is kept ahead of it, and a document that cannot be merged without guessing
    (not strict JSON, a non-string or duplicated shared key, a start marker with no end) is left
    untouched with a build warning. GreptileEndToEndTest was confirmed red against the whole-file
    overwrite on a hand-configured document shaped like NVIDIA/Megatron-LM's, then green.

    The span's body carries annotation attributes, including ones copied out of dependency JARs, so
    it is JSON-escaped and any line in it equal to a marker is defused. JsonValueSpansTest feeds it
    quote-and-key injection, control characters, U+2028/U+2029 and forged end markers; with the
    defusing removed, the forged-marker cases went red and showed the value growing a stale copy of
    itself on every build.

    .greptile/rules.md was added alongside because Greptile's docs, read before implementing, call
    the .greptile/ folder the recommended form and greptile.json the legacy one. It is plain
    Markdown and needs none of the above. When both exist in the root, Greptile ignores
    greptile.json; PLATFORMS.md says so.

  • Greptile's .greptile/config.json, closing #651. 60 config files. In the .greptile/ form,
    file exclusions live in config.json under ignorePatterns, so a project on that form got
    @AIIgnore elements only as prose in rules.md: the reviewer was told to disregard them and
    still reviewed them. VibeTags now owns a span inside that one value, with the same merge as
    greptile.json, and leaves the file's own instructions and every other setting alone. Greptile's
    config reference was read before implementing: ignorePatterns is a newline-separated string
    there too, which is what makes the span merge apply at all.

    The merge used to be chosen by file name, and config.json is far too common a name for that:
    .cody/config.json is also a VibeTags output. It is now keyed on the .greptile folder as well.
    GreptileConfigEndToEndTest was confirmed red on the unchanged processor (5 of 7), then green,
    and with the folder check removed its Cody case went red on Cody's config losing its rendering.
    Opting into config.json alone is allowed: it carries the exclusions and creates no other file.

  • Cline's .clinerules/ directory (.clinerules/*.md, #642). 19 scoped-rule directories; the
    config-file count stays 57. Cline documents only the directory now, so a user following its docs
    got no Cline-specific output at all. The single .clinerules file keeps working for projects that
    have it: Cline's loader still reads it, and a path is a file or a directory, so exactly one of
    the two services activates.

    The rule files carry paths: front matter, read from Cline's source rather than inferred:
    rule-helpers.ts activates a rule when a paths: glob matches a file in the task's context,
    including files Cline is about to edit. When Cline converts an existing .clinerules file into
    the directory itself (it does, the first time a rule is created from its UI), the next build
    sweeps the moved VibeTags block out of default-rules.md and keeps the user's text.
    ClineRulesDirectoryEndToEndTest replays that conversion.

    Two keys at one path broke three assumptions, and each was a latent bug rather than a test to
    bend. ProjectFactsConsistencyTest classified directories by "no dot in the name", so it counted
    the directory as a 58th config file; it now counts by service kind through
    ServiceRegistry.writesDirectory, and requires the project-facts line to name any path counted in
    both figures. ExampleOptInCoverageTest checked Files.exists, so examples/basic's .clinerules
    file satisfied the directory service and the check passed for a platform no example carried; it
    now checks the entry's kind, and examples/multimodule-indexed carries the directory. And
    vibetags init --platforms cline_granular reported a .clinerules file as "already active"; it
    now refuses and names the platform that file belongs to.

  • LazyFileAppenderAsyncTest: the lazy log-file open is now driven by more than one thread.
    LazyFileAppender was the only class in src/main with concurrency primitives and no async test,
    and its DeferredFileStream.open() is a double-checked lazy init guarded by a volatile opened
    that hasOpenedFile() reads with no lock. The existing VibeTagsLoggerAsyncTest gives every
    thread its own directory and its own appender, so it proved isolation and nothing about
    contention. The new test drives a busy appender and an idle one together: the busy one must open
    once and lose no event, the idle one must create nothing while its sibling is under load, which is
    the #487 regression where merely configuring the logger dropped a zero-byte vibetags.log into a
    consumer's working tree.

  • @AISecure on Escape and TransitiveManifestReader, the two ends of the path by which text
    authored outside the project reaches an agent's always-loaded instructions. A dependency JAR's
    manifest is read by the latter and merged into the consumer's aggregate; the former is what stops
    a value in it closing a tag and forging its own <locked_files> or <rule> entries. Both facts
    were in the classes' javadoc, where an agent that never opens the file cannot see them; as
    @AISecure they render inline in every aggregate. This also gives the repo's own output its first
    security_elements section, so the always-inline safety path is now dogfooded rather than only
    tested.

Changed

  • vibetags doctor's Kotlin check now follows a measured table, and stopped reporting top-level
    functions that return a value class
    (#692). The #688 check reported only function shapes and
    stayed silent on everything never built through kapt. One kapt build on Kotlin 2.4.10 put a
    guardrail on each remaining shape, 103 in all, and read each back from the generated CLAUDE.md,
    then repeated it with -Xjvm-expose-boxed: 54 were lost by default, 16 with the option.

    Doctor now also reports extension receivers of a value-class type, suspend members returning one,
    constructors (primary and secondary) taking one, member @get:/@set:/@setparam: guardrails
    and a top-level @set:/@setparam: on a value-class property, and every function, getter and
    secondary constructor declared inside a value class. Two #688 behaviours were wrong. A top-level
    function's return type does not mangle, so fun makeId(): AccountId keeps its guardrail and was
    a false finding. And @JvmExposeBoxed and -Xjvm-expose-boxed no longer switch the check off:
    they keep final, non-suspend declarations, so doctor now reports what they leave out (suspend,
    open, abstract and interface members, a value class's secondary constructors, a function taking a
    @JvmExposeBoxed value class, a member of a class nested in an exposed one), and applies the
    option only under the build file that passes it. vararg of a value class does not compile, so
    it needs no rule. The table and the remaining misses are in docs/JVM-LANGUAGES.md.

    Doctor run against the fixture reports 55 findings (the 54 losses plus examples/kotlin's
    balanceFor), and 16 against the -Xjvm-expose-boxed build, each matching a measured loss, with
    no measured loss missed. Nine new DoctorCommandTest cases, all nine red against the #688 scanner
    before the change. The two #688 @JvmExposeBoxed cases keep their inputs and now assert what
    #692 measured on them: a function taking an exposed value class is reported, and a top-level
    function under -Xjvm-expose-boxed is not.

  • vibetags doctor reports the Kotlin shapes #692 had not built, from a second measurement
    (#713). Doctor stayed silent on every shape never built through kapt, so each was a possible
    guardrail loss with nothing reported. The #692 fixture gained 54 guardrails on the missing shapes,
    built on Kotlin 2.4.10 and JDK 21 with and without -Xjvm-expose-boxed and read back from
    CLAUDE.md: 34 were lost by default and 20 with the option, and every #692 result was unchanged.

    Newly reported: an extension property's @get: with a value-class receiver, its @set: and
    @setparam: with a value-class receiver or type, and a member extension getter returning one;
    every guardrail in an object expression, an enum entry's body or a local class, and on the local
    class and its constructors, which kapt's stubs never carry, with the option or without; every
    suspend function inside a value class; an override inside a value class whose signature uses
    one; a value class's primary constructor and an @param: on its property; and an @param: on a
    constructor val of a value-class type. One #692 finding was false: a plain override inside a
    value class keeps an instance bridge, so override val current: String with @get: kept its
    guardrail, and doctor reported it. Measured kept and silent: a top-level extension getter with a
    plain receiver, setters and secondary constructors of a class carrying @JvmExposeBoxed, and a
    bare @AIInputSanitized on a constructor property, which renders on the field. No @AI*
    annotation targets PARAMETER without FIELD, so that shape cannot be written.

    Against the rebuilt fixture, with its compile classpath on --classpath, doctor reports all 94
    measured losses plus examples/kotlin's balanceFor, and no kept guardrail; under
    -Xjvm-expose-boxed its 36 findings are exactly the 36 losses (the 94 and 36 include the five
    #714 guardrails below). Six new DoctorCommandTest cases, each running doctor with and without the option and
    asserting the finding count. Five were red against the #692 scanner; the sixth pins the
    @JvmExposeBoxed setters and constructors the old scanner already kept silent.

  • Four generated outputs are now documented as naming a tool that has moved on, in
    PLATFORMS.md. None is removed and no existing project changes: gemini_instructions.md
    (no Google documentation describes any product reading it), .cody/config.json and .codyignore
    (Cody Free and Pro ended 23 July 2025, Sourcegraph points those users to Amp, which reads
    AGENTS.md, and Sourcegraph's docs name neither file; Cody Enterprise continues),
    .supermavenignore (Supermaven announced its sunset on 21 November 2025, keeping free
    autocomplete only for existing JetBrains and Neovim users; Cursor Tab reads .cursorignore), and
    the single-file .clinerules. Both notices were first written from search summaries and claimed
    more than the vendors said; they now quote the vendors' own posts (#677).

    Removing a service stops an opted-in consumer's file regenerating, which leaves it looking current
    while drifting from the annotations -- worse than a file nobody reads. Removal is a breaking
    change and belongs to a major version; #641 holds the decision and the steps.

  • AtomicityValidator now runs, in a surefire fork of its own (#629). The async detectors were
    switched on earlier, but that one needs bytecode instrumentation and the build attached no
    javaagent, so it reported runner.agent.absent and its silence read as a pass.

    Attaching it is not one line, for two independent reasons, both measured rather than reasoned
    about. Declaring async-test-agent as a test dependency costs 450 errors —
    NoClassDefFoundError: net/bytebuddy/jar/asmjdkbridge/JdkClassReader (wrong name: se/deversity/asynctest/agent/shaded/…) — because it ships a shaded ByteBuddy that collides with
    Mockito's, and those failures land in the fork that is not even running the agent. Attaching it to
    the whole suite costs 784 errors of 2331 — NoClassDefFoundError: se/deversity/asynctest/telemetry/TelemetryRegistry — because ProcessorTestHarness runs javac
    in-process and javac loads the processor in its own classloader, where async-test-lib is invisible.

    What separates them is the test set: none of the six *AsyncTest classes drive javac. So the
    agent jar is copied to target/agents/ rather than depended on, and surefire runs default-test
    excluding **/*AsyncTest.java plus an async-tests execution including only those, with the agent
    attached. 2676 + 6 tests green, runner.agent.attached args="fields=true", and JaCoCo appends both
    forks to one jacoco.exec so coverage is unchanged.

    Two limits stay documented in docs/TESTS.md: Gradle does not get the agent, because its test
    worker uses a classloader the agent cannot see and splitting its test tasks would not change that;
    and even under Maven the runner warns runner.telemetry.unattributed, so a clean atomicity report
    covers the @AsyncTest workers only.

  • Every @AsyncTest now runs async-test-lib's detectors instead of only its threads. The six tests
    set threads, invocations and timeoutMs and nothing else, so roughly 190 detectors shipped in
    the dependency and none of them ran; the tests caught only what a JUnit assertion caught. They now
    set preset = Preset.ALL, failOn = FailOn.HIGH, minTrust = TrustTier.FACT, useVirtualThreads = false, and each class is now @Isolated.

    The isolation is part of the same change, not tidying. Real platform threads plus detector
    instrumentation, running concurrently with the javac-based end-to-end tests (JUnit executes
    classes in parallel here), made TransitiveGuardrailLifecycleE2ETest fail three times on
    windows-latest with compilation reported failure with no ERROR diagnostic out of
    buildLibraryJar — a compilation that returned failure while reporting nothing, the shape of an
    environmental failure rather than a source error. Linux passed and so did a sixteen-core local
    Windows box; only the low-core runner saw it.

    useVirtualThreads = false is the part that matters most. The runner reports LivelockDetector
    and DaemonThreadHygieneDetector as inert under virtual threads, because dumpAllThreads()
    does not see them: a clean report meant "not observed", not "no problem". minTrust = FACT
    because at PROMPT the library labels its own findings "synchronization the library cannot see may
    make this correct", and gating there fails the tests on their own harness. No defect was found in
    the existing five; the change is that the gate now runs. AtomicityValidator remains not-run
    pending the async-test-agent javaagent, and says so with runner.agent.absent.

  • GEMINI.md's scoped-rules index note no longer says the rule files "load automatically when you
    open the matching source file" (#669). Gemini CLI never loads .gemini/rules/: its
    context docs name
    only GEMINI.md files, the hierarchy plus just-in-time ones in a directory a tool touches, and a
    search of google-gemini/gemini-cli finds no .gemini/rules. An agent told a rule is already
    loaded has no reason to open it, so the detail the index moved out of GEMINI.md could reach the
    model only by chance. The note now says Gemini CLI does not load the files and tells the agent to
    open the element's file with read_file before modifying it. The safety tier stays inline, and
    the other four platforms' notes are unchanged. GranularIndexEndToEndTest was red on the
    unchanged renderer, then green.

  • The scoped-rules index no longer repeats each element's file path (issue #626). Every entry used
    to print the element twice: once as the fully qualified name in path=, and once as the
    dot-to-dash transform of that same name in rules=. ElementNaming.granularQName is a pure
    transform of the FQN and the directory and suffix are fixed per platform, so in the ordinary case
    the whole rules= value was derivable from the line it sat on. Because the aggregate is loaded on
    every session, that is context spent on nothing: measured across this repo's own aggregates it was
    117 of 127 entries and 8,219 bytes, between 10.5% and 23.5% of each file. GranularIndexSection
    now states the naming convention once in the index note and emits a path only for an element whose
    file deviates from it, which is what a .vibetags-roles config does when it groups several
    elements onto one role file. examples/basic/CLAUDE.md fell from 10,934 to 8,954 bytes and its
    .cursorrules from 8,537 to 6,646.

Deprecated

  • Outputs whose tool has moved on are deprecated, and stop being written in the next major
    version (#645). They are still written in this release, and no generated content changes. Each
    row was confirmed at the vendor (#641, #664 to #677).

    Deprecated Why Use instead
    gemini_instructions.md No Google product documents reading it GEMINI.md (Gemini CLI), .gemini/styleguide.md (Gemini Code Assist)
    .cody/config.json, .codyignore Sourcegraph ended Cody Free and Pro on 23 July 2025 and its docs name neither file; Cody Enterprise continues AGENTS.md, read by Amp, where Sourcegraph points Free and Pro users
    .supermavenignore Supermaven announced its sunset on 21 November 2025, keeping free autocomplete only for existing JetBrains and Neovim users .cursorignore, read by Cursor Tab
    .clinerules (file) Cline's current docs describe only a .clinerules/ directory the .clinerules/ directory; Cline also reads .cursorrules, .windsurfrules and AGENTS.md
    .void/rules.md Void's README says it is deprecated and its repository is archived, and Void itself read .voidrules, not this file (#665) none named by the vendor
    .mentatconfig.json The Mentat CLI is archived, and it read .mentat_config.json, not this file (#666) none: nothing read it
    sweep.yaml Sweep's README now describes a JetBrains assistant, not the GitHub App that read this file, and the app's docs no longer load (#666) none documented
    .plandex.yaml Plandex's source never names it, and Plandex Cloud has been winding down since 3 October 2025 (#666) plandex load with the guardrail file, such as AGENTS.md
    .pearai/rules/ PearAI's app repositories are archived and its docs name only .pearaiignore (#666) none documented
    .ghostcoderignore The Ghostcoder repository redirects to moatless-tools, which names no such file (#666) none: nothing reads it
    .doubleignore Double's documentation describes no ignore file (#666) none documented
    .piecesignore Pieces' documentation describes no ignore file; it excludes applications in its settings (#666) Pieces' application exclusions
    .ai/rules/ No tool or published convention reads this directory (#666) AGENTS.md
    .claudeignore Claude Code's documentation never mentions it (#667) Read deny rules under permissions.deny in .claude/settings.json
    .copilotignore GitHub's Copilot documentation never mentions it; exclusion is a repository, organization or enterprise setting (#668) Settings, Copilot, Content exclusion
    .antigravityignore Antigravity's documentation never mentions it (#670) read_file Deny permission rules, or .gitignore with Respect .gitignore on
    .idx/airules.md Google is sunsetting Firebase Studio on 22 March 2027; new workspaces disabled since 22 June 2026 (#676) .agents/rules/, for Google Antigravity, which Google names as a migration target
    .amazonq/rules/ AWS ends support for the Amazon Q Developer IDE plugins on 30 April 2027 (#676) .kiro/steering/, for Kiro, which AWS names
    .interpreter/profiles/vibetags.yaml Open Interpreter reads no YAML profile, and ignores [profiles.*] tables in a project's .openinterpreter/config.toml (#674) AGENTS.md, Open Interpreter's documented project instruction file
    ellipsis.yaml Ellipsis's documentation never mentions it (#675) a reviewer prompt in .ellipsis/code_review.yaml, written by hand; VibeTags does not write that file

    A build with any of them opted in now prints one compiler warning per compilation that names
    each file, the reason, and the replacement, and vibetags.log gets a
    platform.deprecated key=... file=... replacement=... event per file. The "no AI config files
    found" note stops offering them to new projects, and names directory outputs with a trailing
    /, since .clinerules is both the deprecated file and the current directory. To move off one, create the replacement, move
    any hand-written content outside the markers across, and delete the deprecated file.

    Why a warning rather than a removal: removing a service stops an opted-in consumer's file
    regenerating, and the file then looks current while it drifts from the annotations. A release
    of warnings makes the removal visible before it lands (#641). DeprecatedServicesTest was run
    red against a stub table, and again with the warning call removed from ServiceRegistry.

  • The release process gains a step that re-checks every platform path against its vendor's own
    documentation before a version is cut (RELEASING.md). Nothing in the build can
    notice a vendor retiring a product, so until now the platform list was only as current as the
    last time someone happened to look.

Fixed

  • llms.txt and llms-full.txt no longer print empty Locked Files and Contextual Rules headings (#730).
    Every project that generates llms.txt or llms-full.txt from a module with nothing locked, or with no
    @AIContext, loses that empty heading (and in llms-full.txt its description) from the generated block on
    the next build.
    LlmsRenderer printed both headings unconditionally, while every other section went
    through appendSection, so a module with nothing in them got headings with nothing under them, repeated
    once per module in a reactor. Both sections now go through appendSection. The compact locked heading was
    the only one without a leading newline, so skipping it would have put the next heading under two blank
    lines; appendSection drops a heading's leading newline when the buffer already ends on a blank line.
    AggregateBlankLineContractTest now covers llms.txt as well, adds a model with nothing locked and no
    context, and fails when either heading is printed with nothing under it. Regenerated
    examples/multimodule (6 empty headings removed from each file) and examples/gradle-multimodule (3 each).

  • llms.txt and llms-full.txt no longer print an empty audit section for a bare @AIAudit (#728).
    Projects that write @AIAudit without checkFor and generate llms.txt or llms-full.txt lose the
    audit heading, and in llms-full.txt its description, from the generated block on the next build.
    A bare
    @AIAudit names no checks, so its formatters render no entry, but LlmsRenderer.appendSection still
    printed the heading: an audit requirement naming no file and no check. It now rolls back a section whose
    entries all render nothing, as AnnotationSections.render has since #726. Aider's CONVENTIONS.md, named in
    the issue, was never affected: it has no section headings, and each entry carries its own. No committed
    example uses a bare @AIAudit, so no generated file in this repository changes.
    UnsetMemberRenderingTest now requires, on every aggregate platform, that a model holding only a bare
    @AIAudit renders byte-identically to an empty model.

  • No double blank lines between sections in llms-full.txt, Copilot, Junie, and CONVENTIONS.md (#726).
    Every project that generates llms-full.txt, .github/copilot-instructions.md, .junie/guidelines.md
    or CONVENTIONS.md gets a whitespace-only change to its generated block on the next build
    : double blank
    lines (\n\n\n) between sections are removed. Four outputs printed two blank lines in a row, each for its
    own reason: LlmsRenderer emitted headings with a leading newline in full mode while each LLMS_FULL
    formatter arm already closed with a blank line; CopilotRenderer in full mode emitted an empty
    ## Locked Files — DO NOT MODIFY heading and description when nothing was locked; JunieRenderer
    similarly emitted an empty ## Locked Files (Do Not Modify) heading and description when nothing was
    locked; and GuardrailContentBuilder.withTransitiveAppendix appended a leading newline before
    ## Inherited Guardrails (dependencies) even when the preceding platform content already ended with a
    blank line (affecting Aider's CONVENTIONS.md and llms-full.txt). Now LlmsRenderer does not prepend a
    newline to section headings in full mode, CopilotRenderer and JunieRenderer omit the locked files
    heading when no elements are locked, and withTransitiveAppendix avoids doubling the blank line before
    inherited guardrails. A fifth cause reached Copilot, Junie and every other renderer that walks
    AnnotationSections or reuses one that does (Cursor, Windsurf, Zed, Codex, Qwen, Gemini, and through them
    Cline, Firebase, Goose, Replit, Void and the Claude skill): a bare @AIAudit names no
    checks and renders no entry by design, but its section heading and description were still printed,
    leaving an empty section followed by two blank lines. AnnotationSections.render now rolls back a
    headed section whose elements all render nothing, so projects with a bare @AIAudit also lose that
    empty audit heading
    from those files. AggregateBlankLineContractTest renders all 44 annotations
    (populated, bare, and with only optional members unset, plus a model with nothing locked) through
    llms-full.txt, CONVENTIONS.md, Copilot and both Junie files and fails on two blank lines in a row
    or on a heading directly under the previous line; GuardrailContentBuilderUnitTest asserts exactly
    one blank line above the inherited-guardrail heading on every platform that carries it.

  • Aider CONVENTIONS.md prints the entry after a TEST-DRIVEN entry with a separating blank line (#725).
    Every project that generates CONVENTIONS.md and uses @AITestDriven gets a whitespace-only change
    on the next build
    : a blank line is added after each TEST-DRIVEN entry. In Aider's CONVENTIONS.md
    every per-element entry is a #### heading followed by bullets, and each formatter's
    AIDER_CONVENTIONS arm ends its entry with a blank line. AITestDrivenFormatter's arm ended with
    CommonFormatterHelper.bullet("Frameworks", ...), which ends with a single newline, so the next entry's
    #### heading was printed directly on the line under the last bullet without a blank line between them.
    Now AITestDrivenFormatter appends the trailing newline. AllAnnotationsAllPlatformsEndToEndTest
    asserts that no #### heading in a rendered CONVENTIONS.md directly follows a non-blank line.
    Regenerated: examples/basic/CONVENTIONS.md, examples/multimodule/CONVENTIONS.md, and
    examples/gradle-multimodule/CONVENTIONS.md.

  • Every Gemini section is set off by exactly one blank line (#723). Every project that
    generates GEMINI.md or gemini_instructions.md gets a whitespace-only change to its generated
    block on the next build
    : blank lines are added or removed between sections, and no text
    changes. Gemini's spacing was carried in two places. Most of its headings open with a blank line,
    but ## IGNORED ELEMENTS, ## IMPLEMENTATION TASKS and ## PII / PRIVACY GUARDRAILS did not,
    and relied on the audit block's trailing blank line instead. After any other list they sat on the
    line directly under the last bullet, which is how an agent reading the raw file sees one section
    run into the next. After an audit block, every heading that did bring its blank line got two, and
    so did the first heading under the generated header, which printed a blank line of its own. Now
    every Gemini heading opens with its blank line, the audit blocks open with theirs instead of
    closing with it, and the header adds none. GranularIndexEndToEndTest renders the full
    GEMINI.md, gemini_instructions.md and the collapsed GEMINI.md and fails on any ## heading
    or File: audit block without a blank line above it, or on two blank lines in a row; on the
    unchanged code it failed on the two blank lines under the header, with ## IMPLEMENTATION TASKS
    and ## PII / PRIVACY GUARDRAILS glued under their lists in the same render.
    SectionCatalogContractTest now requires every catalog header, for every platform, to open with
    a newline. Regenerated: this repository's GEMINI.md and the Gemini files in examples/basic,
    examples/multimodule, examples/multimodule-indexed and examples/gradle-multimodule, each
    diff empty under git diff --ignore-blank-lines. Other platforms were checked for the same glued
    shape: none of their catalog headings omit the newline. Aider's CONVENTIONS.md glues the entry
    after a TEST-DRIVEN entry for a different reason, a formatter arm without a trailing blank line
    (#725), and llms-full.txt, Copilot, Junie and CONVENTIONS.md print double blank lines for
    causes of their own (#726).

  • A collapsed GEMINI.md keeps Gemini's own wording (#721). GEMINI.md renders in two
    shapes, and only the full one printed Gemini's headings. With .gemini/rules/ also opted in the
    file collapses to a scoped-rules index, and the safety sections it keeps inline printed the shared
    Cursor wording (## 🛡️ MANDATORY SECURITY AUDITS where full mode says
    ## CONTINUOUS AUDIT REQUIREMENTS) under the shared # AUTO-GENERATED AI RULES title. Gemini's
    wording was registered in SectionCatalog under the gemini_instructions.md platform only: the
    full render borrowed that platform for its section list, and the collapsed render asked for
    GEMINI_MD, found nothing, and fell back to the defaults. Every other aggregate with its own
    wording keeps it when it collapses, and the inline sections are documented to read identically to
    full mode. SectionCatalog now registers the one Gemini map under both platforms, and both shapes
    share GeminiRenderer's title and locked-files opening. If you opt into both GEMINI.md and
    .gemini/rules/, the generated block of GEMINI.md changes on your next build:
    the title
    becomes # GEMINI AI INSTRUCTIONS, the # Do not edit manually. line goes, the locked heading
    becomes ## LOCKED FILES (DO NOT MODIFY) with its one-line instruction, and the audit, ignore,
    privacy, core and security headings drop their emoji and take Gemini's text. The listed elements,
    the index and anything outside the markers are unchanged, and a GEMINI.md without
    .gemini/rules/ is byte-identical. No fingerprint change is needed: the processor version is
    already part of BuildFingerprint, so the upgrade regenerates. GranularIndexEndToEndTest
    renders the same sources in both shapes and fails if the collapsed file prints a heading the full
    one does not; on the unchanged code it failed at ## CONTINUOUS AUDIT REQUIREMENTS, and with only
    the catalog fixed it still failed at the title. The verify-generated-files check for
    examples/basic now looks for Gemini's audit heading and fails on the shared one.

  • FingerprintShortCircuitTest now fails when the short-circuit does not fire (#700). Every
    case patched the stored sidecar stamp through a WriteCache never bound to the module. Since
    the cache keeps one header section per module (#556) that moved only the root-wide stamp, which
    then disagreed with the module's own, so no compile after the patch could short-circuit. The
    positive case asserted only unchanged mtimes, which the per-file cache also produces, and the
    five negative cases passed whether or not their change was detected. With the skip disabled
    outright (WriteCache.getBuildFingerprint returning a value that never matches) all 6 cases
    stayed green. The patch is gone: a plain no-op recompile short-circuits, the positive case
    asserts the inputs unchanged since last run NOTE, and each negative case first recompiles
    unchanged and asserts the NOTE before asserting its change suppresses it. The same break now
    turns all 6 red, and ignoring the run context in getBuildFingerprint turns
    shortCircuit_doesNotFire_whenProjectNameChanges red where the old class stayed green.
    WriteCacheProcessorIntegrationTest.secondCompile_unchangedSources_doesNotRewriteFiles had the
    same shape: its no-op recompile never reached the per-file cache, so it stayed green with
    WriteCache.isUnchanged forced to false. It now defeats the short-circuit with
    -Avibetags.project and asserts write.skip reason=cache-unchanged in the debug log, which that
    break turns red. Three ProjectLifecycleEndToEndTest cases asserted the short-circuit through
    sidecar mtimes alone, which hold whether or not it fires, and stayed green with it disabled; they
    now assert the NOTE and go red under the same break. That exposed the reactor steady-state case
    as wrong: module-core does not skip on its first rebuild after a cold reactor pass, because
    module-cli wrote its sidecar after module-core recorded the stamp, so the case now takes the
    catch-up pass MultiModuleShortCircuitTest already takes. The two merge cases in
    MultiModuleProcessorTest accepted either module's content, which the first compile had
    already written, so they held with every round short-circuited; they now require both and
    assert the sibling sidecar defeated the skip. Test-only change; nothing ships.

  • Cursor and Trae rule files attach by their globs again (#699). VibeTags wrote the globs of
    .cursor/rules/*.mdc and .trae/rules/*.md as a bracketed, quoted list,
    globs: ["**/PaymentProcessor.java"]. Both vendors document a bare comma-separated value, and
    neither tool's reader parses YAML: Cursor's removes one pair of quotes around the whole value and
    splits on the commas outside braces, Trae's splits on every comma. The list reached the matcher as
    a pattern carrying literal brackets and quotes, which matches no source file, and Cursor files a
    rule that has a glob as glob-attached, so its description did not bring it in either. The value is
    now written bare, several globs joined with commas and brace groups expanded as #696 does:
    globs: **/*Controller.java,**/*Endpoint.java. Continue and PearAI keep the list, which Continue
    documents. Neither tool was run; PLATFORMS.md has the vendor quotes, including a Cursor staff
    reply saying "no brackets or quotes", and what the parser in each tool's shipped bundle does.

    CursorTraeGlobsFormEndToEndTest was written first and restates each reader: all 5 cases failed
    against the list form with no glob the reader takes matching the annotated class. Cursor 3.20.17's
    own parser functions, run on both forms, matched none of three Java paths with the list and each
    named file with the bare value.

  • The locked-files guard no longer fails a pull request for @AILocked text that is not an
    annotation
    (#708). The lock-stripping and deleted-file checks matched the substring
    @AILocked in any removed .java line, so PR #707, which changed only tests, failed for
    editing Java fixture source that FingerprintShortCircuitTest holds in string literals, and had
    to keep those blocks byte-identical to pass. The guard now lexes the base revision of a Java
    source (comments, strings, text blocks, char literals, unicode escapes translated first as javac
    does) and counts a removed line only when a real annotation sat on it. That also closes the
    other direction: a stripped @ AILocked or @se.deversity.vibetags.annotations.AILocked, which
    the substring never matched, now fails. A source that does not lex keeps the substring match, so
    an unsure answer still fails; Kotlin and Groovy sources are lexed too since #709, below. The same change also
    hardens path and rename parsing: changed files are read from git diff --raw -z and diffed one
    at a time, and a change the guard cannot read fails the check. Reproduced on this
    repository: a one-line fixture-string edit drew A line containing @AILocked was removed before
    and passes after, while reordering the locked GuardrailAnnotations.ALL fails on both. The 4
    annotation-text cases and the spaced/qualified strip were red against the old guard.

  • The locked-files guard lexes Kotlin and Groovy sources as well (#709). After #708 only a
    Java source was lexed, so a Kotlin or Groovy test holding fixture source that reads
    @AILocked(...) in a string still failed the guard as PR #707 had, while a stripped
    @field:AILocked, @se.deversity.vibetags.annotations.AILocked, backtick-quoted or
    import ... as aliased lock, none of which contains the substring @AILocked, passed. The
    Kotlin lexer tracks string templates (${ enters code, its matching } returns to the string),
    raw strings, char literals, backtick names and nested block comments, and counts every line from
    an @ to the lock name, through a use-site target, a qualified name or a @[...] group, plus
    any other code token naming the lock or a same-file alias of it. It gives up, so the substring
    match applies, on anything unbalanced and on a $ in code: a multi-dollar $$"""${"""
    string read as a template hides the annotation after it inside a nested string that still
    balances. The Groovy lexer reads quoted strings, templates and non-nesting comments, and gives up
    whenever a / in code does not start a comment, because a slashy string holding quotes can hide
    an annotation the same way and cannot be told from a division; a Groovy source that divides keeps
    the substring match. Against the #708 guard the new fixture cases gave 23 failures (text edits
    failing, and the target, qualified, bracketed, backtick and alias strips passing), and each lexer
    rule, disabled on its own, turned at least one test red.

  • The locked-files guard follows a lock alias declared in another file (#716). Since #709 a
    Kotlin typealias Frozen = AILocked made @Frozen a lock only in the file that declared it, and
    a Groovy @AnnotationCollector bundling @AILocked was not recognised at all, so removing
    @Frozen from any other file passed. The processor does see these locks: on copies of
    examples/kotlin (Kotlin 2.4.10, kapt) and examples/groovy (Groovy 5.1.0) built on JDK 21, a
    cross-file typealias on a class and on a function, a qualified, nested, generic and chained one,
    and a collector that bundles or lists AILocked, is applied under an import alias or collects
    another collector, all reached .vibetags-locks and CLAUDE.md. The report's ranges describe the
    kapt or groovyc stub, though, so no range check covers a Kotlin or Groovy source and the
    lock-stripping check was the only one left. When a diff changes a Kotlin or Groovy source, the
    guard now reads every .kt, .kts and .groovy blob at the base with one git ls-tree and one
    git cat-file --batch, lexes those that contain typealias or AnnotationCollector, follows
    aliases across files, and counts each alias as the lock in every source of its language, so a
    same-named local class makes a removal fail rather than hide the alias. If a source that may
    declare an alias does not lex, removing any annotation line in that language fails. A Kotlin or
    Groovy source that does not lex now matches a removed line holding an @ and a lock name
    anywhere, instead of the substring @AILocked, which @field:AILocked and a qualified name never
    contained. On 8418 Kotlin and Groovy files a guard run took 0.74 to 0.82 s instead of 0.15 to
    0.24 s. Against the #709 guard the new cases gave 18 failures (every cross-file strip, the
    deletion, the shadowing and the fail-safe cases passing), and each new rule, broken on its own in
    a scratch copy, turned at least one test red. A first cut treated any Groovy unicode escape as a
    possible spelling of AnnotationCollector, which made 3 of the 998 Groovy files on the
    development machine switch the fail-wide fallback on; escapes are now translated first.

  • mvn test -Dtest=SomeTest no longer fails a passing test (#686). Since #629 surefire runs
    two executions, and -Dtest overrides the includes and excludes of both, so the named class also
    ran in async-tests under the async-test agent. A class that drives javac passed in
    default-test and then failed there with
    NoClassDefFoundError: se/deversity/asynctest/telemetry/TelemetryRegistry, turning the command
    CLAUDE.md documents into a false red; a named *AsyncTest ran in default-test too, without the
    agent. The named-test-overrides-tags profile now gives each execution its own <test> with an
    exclusion for the other execution's classes, and build-helper:regex-properties computes each
    execution's failIfNoSpecifiedTests from the pattern, so a misspelled name still fails the build.
    Runs without -Dtest do not activate the profile and are unchanged. Build-only change; nothing
    ships.

    Verified by running the commands: -Dtest=AnnotationMirrorAnchorTest went from BUILD FAILURE
    (1 error in async-tests) to one run in default-test only; -Dtest=VibeTagsLoggerAsyncTest
    went from a run in each fork to one in async-tests with the agent attached; a mixed pattern runs
    each class in its own fork; -Dtest=NoSuchTest and -Dtest=NoSuchAsyncTest still fail.
    NamedTestExecutionRoutingTest was red against the unchanged POM, and weakening the async regex
    to ignore ! entries turns one of its cases red.

  • A brace glob no longer splits in Copilot's applyTo: or in Cursor's and Trae's globs:
    (#696). The #685 expansion now covers the three other granular headers whose vendors document
    several globs as a comma-separated value: docs.github.com says "You can specify multiple patterns
    by separating them with commas", cursor.com lists docs/**/*.md, docs/**/*.mdx as
    "(comma-separated)", and Trae's docs separate patterns with ,. A .vibetags-roles glob such as
    **/*.{java,kt} is written as one glob per alternative and a literal comma in a
    .vibetags-mirror glob as ?. Claude Code, Cline and Continue take a list whose entries are
    matched whole, and Claude Code and Cline document brace globs in an entry, so their headers keep
    the glob as written; the other granular platforms write no glob. Per-element headers and every
    committed example are unchanged, since none of their globs holds a brace or comma. PLATFORMS.md
    has the per-platform table with the quotes.

    GranularBraceGlobEndToEndTest was written first: its Copilot, Cursor, Trae and Copilot mirror
    cases failed with the glob split across commas, and its three list-platform cases passed.

  • A brace glob no longer splits into broken halves in .devin/rules/ and .windsurf/rules/
    (#685). Several globs are written as one comma-joined globs: value, the form of the vendor's
    own sample rule (globs: *.js, src/*.js), so a .vibetags-roles glob such as **/*.{java,kt}
    reads as **/*.{java and kt} to a reader that splits on commas, which would load the rule for
    neither file type. How Devin Desktop parses the value is not documented. Brace groups are now expanded into one glob per alternative, nested groups included,
    and a literal comma in a .vibetags-mirror glob line is written as ?. Headers without braces
    or commas, which is every per-element file, are unchanged. PLATFORMS.md records what was and was
    not found about how the value is parsed.

    DevinDesktopEndToEndTest gained three cases first, and all three failed against the plain
    join with the ambiguous header in the failure output.

  • .windsurf/rules/ rule files carry Windsurf's trigger: front matter (#683). They were
    written with Cursor's description, globs and alwaysApply keys. The vendor's page
    (docs.devin.ai, checked 2026-09-14) gives Windsurf rules a trigger field whose values are
    always_on, manual, model_decision, agent and glob, and its glob example is
    trigger: glob with globs: **/*.test.ts; the alwaysApply table on that page belongs to Cursor.
    A rule with no trigger has no documented activation mode, so a guardrail could sit in the
    directory and never reach Cascade. Every rule file VibeTags writes there, per element or per
    .vibetags-roles role, now opens with trigger: glob and its glob, the same front matter
    .devin/rules/ uses, from the same renderer; a role with several globs joins them with commas.
    An existing Cursor-shaped header is replaced on the next build, and text outside the markers is
    kept. Cursor's .cursor/rules/*.mdc headers are unchanged.

    The Windsurf cases in DevinDesktopEndToEndTest and NewPlatformsEndToEndTest failed against
    the previous renderer (5 failures) and pass with the change; a pinned Cursor header case passed
    on both.

  • Opting into QWEN.md no longer overwrites .qwen/settings.json (#650). That file is Qwen
    Code's own project settings file, and VibeTags wrote it as a whole-file overwrite on every compile,
    replacing hand-set MCP servers, model choice and permissions with a fixed three-line document. It
    also created the file for users who never had one, which invariant 1 forbids. None of the keys it
    wrote is a Qwen Code setting (the settings schema has no top-level project key), and QWEN.md
    loads without it, so the file is no longer written at all. The config-file count drops from 59 to
    58.

    If you opted into QWEN.md before this release: a .qwen/settings.json generated by VibeTags
    is left in place, because VibeTags never deletes a file in your tree. If it still holds only
    project.model and project.mcp.enabled, delete it; if VibeTags had overwritten settings you
    wrote, restore them from version control.

    QwenSettingsUntouchedEndToEndTest was red against the unchanged processor on two of its three
    cases (the third, which keeps an old generated copy, guards against a fix that deletes it).

  • .qwen/commands/refactor.md is now an ordinary opt-in (#655). Opting into QWEN.md used to
    create it, and .qwen/commands/ with it, which registered a /refactor slash command in every Qwen
    project that never asked for one: an undocumented second exception to "file presence is the only
    opt-in". It is now regenerated only when the file exists, with or without QWEN.md.

    If you already have the file: nothing changes; it keeps updating, and text outside the
    markers is kept. New projects that want the command create it:
    mkdir -p .qwen/commands && touch .qwen/commands/refactor.md. Nothing is deleted. A reactor that
    carries the file now counts one more active service in its Active services log line.

    QwenRefactorCommandOptInEndToEndTest was red on all three cases against the #650 fix, before
    this change.

  • A .clinerules/ directory no longer activates the single-file cline service. Cline's
    current documentation describes .clinerules/ as a directory of rule files and does not mention
    the single file VibeTags writes, so a user following those docs created a directory at exactly the
    path the cline service maps to. ServiceRegistry.resolveActiveServices opted in on
    Files.exists, which is true for a directory, and the writer was then handed a directory to write
    a regular file over.

    The fix reads the entry's type: a granular service needs a directory, everything else needs a
    regular file. A path cannot be both, so its type is an unambiguous signal for which of the two the
    user meant. The _granular suffix was already load-bearing in PlatformRendererRegistry and
    GuardrailContentBuilder, so this reads an existing convention rather than inventing one.

    ClineDirectoryOptInTest was written first and confirmed red against main. The directory form
    itself is written since #642, above under Added.

  • BuildVersionParityTest no longer reads build files from nested git checkouts (#678). Its
    Gradle discovery walked the whole directory tree, including agent worktrees under
    .claude/worktrees/, each an untracked checkout of an older branch. Preparing this release, a
    local mvn -B clean verify -Pe2e failed on 171 mismatches, all inside worktrees and none in the
    real tree, and stopped before PMD, CPD and SpotBugs ran. CI was unaffected because a clean
    checkout has no such directory. The walk now prunes any directory below the root that holds a
    .git file or directory; the root itself is still walked, and the named-anchor guard still
    fails a walk that finds nothing. DocumentationLinksTest and DocumentedCommandsTest walked the
    tree the same way and now prune by the same rule. Test-only change; nothing ships.

    The new aNestedGitCheckoutIsNotPartOfThisBuild case was red against the old walk (it reported
    the planted worktree and clone files alongside the real one), and removing the root exemption
    from the fix turns it and two existing cases red.

  • Two silent Kotlin losses are now documented and pinned (#681). kapt leaves out of its Java
    stubs every function whose JVM name is mangled because it takes or returns a @JvmInline value class (your own, UInt, ULong, kotlin.time.Duration), so an @AI* annotation on such a
    function, or on one of its parameters, generated nothing and logged nothing, and
    docs/JVM-LANGUAGES.md, the page that exists to list what each language loses, did not say so.
    Separately, an internal function's path embeds the Kotlin module name, which the Kotlin Gradle
    plugin derives from the project's group and name, so renaming the project renamed its
    .vibetags-locks entry and its path in every generated file. Both are now in
    docs/JVM-LANGUAGES.md, USAGE.md and the Kotlin example's README, with the @JvmName
    workaround for each; nothing in the processor changed.

    examples/kotlin gains AccountLedger.kt, and its CI step asserts all three outcomes on Kotlin
    2.4.10: balanceFor(AccountId) is in no generated file, settle(Result<Long>) renders as
    settle(java.lang.Object), and reconcile carries the
    $se_deversity_vibetags_example_vibetags_example_kotlin suffix. Each assertion was flipped once
    and the step went red. A processor warning was not built: the processor sees only the stub, and
    the stub's @kotlin.Metadata records hasAnnotations only for binary-retention annotations (36
    of the #496 spike's 38 @AILocked functions report false), so it cannot tell an annotated
    function from an unannotated one. vibetags doctor checks the sources instead (#688, under Added).

    The same change fixes the Groovy and Scala example steps, whose ! grep absence checks on
    CLAUDE.md could never fail: bash -e does not stop on a negated command, so only the last line
    of each step was live. They now use if grep ...; then exit 1; fi, which fails when a planted
    match is present, where the old form exited 0.