What's new.

Python calls into a package's own __init__.py now resolve, and the dashboard opens with no snapshot

A gap in Python call resolution for symbols a package defines in its own __init__.py is fixed, and the dashboard now opens even before a snapshot exists, with clearer findings and dependency graphs.

• FixedCalls to a symbol a Python package defines in its own __init__.py, rather than re-exporting from elsewhere, now resolve instead of dangling.
• AddedThe dashboard now opens even with no snapshot yet generated, showing the exact command to run, and a Refresh control loads newer snapshots without disrupting the graph you're inspecting.
• FixedFindings are prioritized, lifetime usage is separated from diagnostics, and confidence labels and suggested actions are clearer.
• FixedThe dependency graph condenses cycles into clusters, renders edges more clearly, and gets a clear-selection control; browser launching on macOS is fixed and the docs are updated.

Action: re-pin baselines taken on a Python repository that uses this pattern — extraction caches from earlier releases are invalidated, so the first snapshot after upgrading re-extracts.

Policy-as-code constraints now cover Go structs, and a silent gap in intent checking is reported

A new policy-as-code example demonstrates GDPR and PCI-DSS constraints end to end; require_defines now matches Go/Rust/C++/C# structs as well as classes, and a stale-citation check that was silently skipping unmeasured repositories now says so.

• AddedA new examples/policy-as-code example walks through declaring GDPR and PCI-DSS cardholder-data constraints and checking a codebase against them.
• Fixedrequire_defines now matches struct-kind types (Go, Rust, C++, C#) as well as classes, so a rule like "every store defines Erase" no longer verdicts nothing on a Go codebase.
• FixedA page whose anchors name a repository the current snapshot doesn't carry now raises an "Anchors not checked" notice instead of silently passing as if nothing were wrong.
• Fixedconstraints lint now resolves component membership through compiled policy pages, matching what the constraint check itself resolves.
• FixedA yarn.lock dependency descriptor that itself contains an @ (an npm alias or a git+ssh URL) now resolves correctly, so a lockfile-pinned dependency is no longer reported as unpinned.

Action: re-pin baselines on projects with yarn.lock aliases or git-protocol dependency ranges — extraction caches from earlier releases are invalidated, so the first snapshot after upgrading re-extracts.

PyPI wheels now install cleanly on RHEL and Rocky Linux 8

pip install enola failed on RHEL and Rocky Linux 8 with "no matching distribution found"; Linux wheels now carry an extra tag so older pip versions on those distros can see them.

• FixedLinux PyPI wheels now carry both the PEP 600 tag and the older manylinux2014 alias, so pip 20.2.4 as shipped on RHEL/Rocky Linux 8 can find and install them.

Action: if pip install enola failed on RHEL or Rocky Linux 8, upgrading to 0.4.15 resolves it; 0.4.14's wheel cannot be fixed in place since PyPI won't accept a replacement file for a version it already has.

Enola ships on PyPI as a prebuilt wheel

pip install enola now works directly, with prebuilt wheels for Linux, macOS, and Windows published automatically from tagged releases; the installer also adds support for opencode.

• AddedEnola now publishes to PyPI as prebuilt wheels for Linux (x86_64/aarch64), macOS, and Windows — pip install enola — built automatically from tagged GitHub releases.
• AddedThe installer supports opencode as a target, writing its plugin hook and a strictly-validated MCP config entry.
• FixedCodex installation instructions in the README described the wrong MCP server setup.

Action: none — pip install enola is a new, optional install path alongside the existing ones. RHEL/Rocky Linux 8 users hitting "no matching distribution found" should install 0.4.15 instead; see below.

A new explainer measures what importing your Python package actually costs

A new import-closure explainer reports what importing a Python package executes, several Python and C++ call-resolution bugs are fixed, and three Go extractor passes get faster.

• AddedA new import-closure explainer reports what import yourpackage actually executes in Python, including the package __init__.py files no import statement names but Python runs anyway, and flags the ones that dominate the closure.
• FixedC++ call resolution now uses include visibility, qualified names, unique project-wide matches, and explicit receiver types to resolve more calls instead of relying on speculative matches.
• FixedPython absolute imports resolve to the exact module they name rather than the enclosing package directory, and forty-two standard-library modules missing from Enola's own list no longer misreport as third-party dependencies.
• PerformanceThree Go extractor passes now match tree-sitter queries directly and share a single pass instead of each walking the syntax tree separately.

Action: re-pin baselines taken on a C++ or Python repository — extraction caches from earlier releases are invalidated, so the first snapshot after upgrading re-extracts.

GraphQL clients and servers now connect through the same route

Enola now reads GraphQL across TypeScript/JavaScript, Vue/Nuxt, Ruby, and Hasura, matching client operations to the server root fields they call and flagging schema operations nothing calls.

• AddedGraphQL extraction across a wide range of servers, including Apollo Server, GraphQL Yoga, Mercurius, NestJS GraphQL, TypeGraphQL, Nexus, Pothos, graphql-ruby, and Hasura metadata.
• AddedGraphQL extraction across clients, including Apollo Client, Relay, urql, graphql-request, Nuxt Apollo, and plain fetch-based requests.
• AddedClient operations and server root fields now share a canonical route name such as Query.books or Mutation.addBook, so Enola can connect a client to the schema it consumes and report GraphQL operations nothing calls.

Action: none.

A Vue component's template is code, and enola now reads it

Vue and Nuxt extraction no longer stops at the <script> block: a component or handler used only from a template no longer reads as an orphan.

• AddedVue and Nuxt template interpolations and directive values resolve against the SFC's own declarations and component tags, so references from a template become calls edges seen by traverse, find_path, impact_analysis, and orphan analysis.
• Added<script setup> compiler macros (defineProps, defineEmits, defineSlots, defineModel, defineExpose, defineOptions) are recorded as the component's public surface.
• AddedNuxt file-based routing covers more page extensions and drops route-group and named-view/client/server suffixes from the URL; literal Vue Router records compose into page routes with handled_by component edges.
• ChangedExtraction caches from earlier releases are invalidated for Vue and Nuxt repositories, so the first snapshot after upgrading re-extracts.

Action: re-pin baselines taken on a Vue or Nuxt repository — the new template edges can resolve orphan findings and surface coupling that was previously invisible.

Facts and evidence get stable ids, and the file formats are documented

Every fact and every piece of insight evidence can now carry a stable id computed at write time, two findings that cited names nothing in the snapshot carried are fixed, and the facts/insights/receipt file formats have a written reference.

• AddedFacts and insight-evidence citations can carry a stable id, computed when facts.jsonl and insights.json are written rather than stored on the fact itself.
• FixedTwo findings cited names no fact actually carried; both now cite the real fact and its location.
• FixedThe served insights.json emitted null where the written file emitted [].
• AddedA new docs/schema/ reference documents the facts, insights, and receipt file formats, plus an INTEGRATING.md guide for building on Enola's output.

The dashboard runs in the background, and changes route to who owns what they touch

enola dashboard now starts detached by default, and a new --reviewers flag routes a change to the owner of what it touched using the import graph rather than just the commit log.

• Addedenola dashboard starts detached in the background by default and adds dashboard status and dashboard stop to manage it; --generate, --refresh, and check --write print a one-line hint pointing at it.
• Added--reviewers reports, per module a change touched, who owns it and whether the author is a stranger to something they own an import of.
• FixedA repository-scoped fact's directory label was read as a file the change touched, wrongly opening routing with a note about the root module on changes that only moved coverage counters.
• FixedA wrapper binary built on Enola reported "dev" in doctor, its SARIF driver, and its dashboard instance record instead of its own version.
• ChangedDocumentation reorganized across the CLI, constraints, clusters, providers, intent, and glossary references, with new doc-lint checks enforcing structure.

Action: enola dashboard now returns immediately instead of blocking; pass --foreground if you relied on the old behavior.

Declared dependencies join the constraint vocabulary, and every excuse gets counted

A new rule can require every external dependency to be pinned to a version, and enola constraints ledger reports how much of the declared architecture is being excused rather than obeyed.

• AddedA dependency member kind and a shipped supply-chain recipe can require every declared external dependency to be pinned to a version.
• Addedenola constraints ledger reports, across the whole rule set, what share of breaches are excused, the oldest excuse nobody has revisited, and which suppressions or exemptions matched nothing in the current snapshot.

Built-in providers respect what you told the engine to ignore, and layer rules stop flagging wiring code

A built-in fact provider now skips files your ignore rules already excluded instead of building facts for them and throwing the result away, and the layers explainer adds a neutral classification for dependency-injection and wiring code that was never meant to sit in a dependency order.

• PerformanceA built-in fact provider now receives the engine's ignore-glob decisions and skips an excluded file before reading it, instead of building the fact and discarding it afterward. A Rails monolith snapshot dropped from 440s to 193s.
• AddedLayer definitions gain a neutral classification for code that is classified but never ordered, such as dependency-injection wiring — one wiring package had been responsible for most of a repository's reported layer violations.
• AddedNuxt, SvelteKit, and PHP layer taxonomies.
• FixedThe Android clean-architecture taxonomy now orders data below domain, matching Android's own documented guidance; the previous ordering flagged legitimate domain-to-repository calls as violations.

Action: re-pin baselines if your project uses the layers explainer against Android, Nuxt, SvelteKit, or PHP code — violation counts will change.

A Rubydex reference could not stop referencing itself

The Rubydex Ruby fact provider could hang indefinitely on certain code shapes. A single self-referencing constant in a real Rails monolith reproduced it every time.

• FixedRubydex's declaration-path walk could loop forever when a reference's end column, plus its separator, equaled its own start column, making the reference its own predecessor. A candidate now qualifies only when it is a different reference whose end line matches the line being walked.

Action: a Ruby snapshot that previously hung or timed out should be retried.

Detection stops re-walking the tree, and constraint verdicts speak CI's language

Every extractor's file detection now reads from the same walked file list the engine already built, instead of re-scanning the tree with its own depth limit, recovering files that previously sat past an old scan boundary. The constraints program also gained CI-native output formats and richer explain results.

• FixedLanguage detection no longer re-walks the tree with a per-extractor bounded scan; it now reads membership over the file list the engine already walked, so a marker or source file counts wherever in the tree it sits.
• AddedA vendored-candidates explainer reports directories that look like an in-tree copy of another project — a licensed subdirectory under a conventional dependency folder — informational only and never gating.
• Fixedconstraints init and constraints explain no longer report a successful run as a failure. Both used to return without exiting, so the outer argument parser mistook the completed run for an unknown command.
• AddedThe constraints program writes SARIF and CI annotations alongside its existing text and JSON formats, constraints explain reports the blast radius of moving a file out of its part, and every verdict now carries a "could not see" line naming what the provider census could not resolve.
• ChangedDocumentation reorganized, including a dedicated Rails guide and a repository CHANGELOG.md mirroring this page.

Action: detection behavior changed across every language — regenerate snapshots and re-pin baselines.

Laws written in Ruby, Angular, and the rule forms only a graph can state

Architecture constraints can now be written as Ruby sentences, parsed and never executed. The rule vocabulary reaches 21 forms, including the ones that need the whole graph. Angular is read the way the framework works — decorators, dependency injection, composed routes and templates. Convention recipes ship with the binary, so a repository adopts them in one command.

• AddedConstraints may be written in Ruby. Files ending .rb under enola/constraints/ are parsed with the same grammar the extractor uses and never executed, compiling to exactly what the YAML loader produces — same merge order, same evaluator, same lint surface. Nineteen verbs cover the rule forms.
• AddedAngular extraction: @Component/@Directive/@Pipe/@Injectable/@NgModule classes and the role the container gives them, constructor and inject() dependency injection as edges, routes composed outward from forRoot/provideRouter including lazy loadChildren, templates joined to the component that owns them, @NgModule composition arrays, and requests made through an injected HttpClient.
• AddedRule forms only a graph can state: storage_stays_home, cap_runtime, require_consumer, unique_across, require_governed, forbid_cycles and independent — taking the vocabulary to 21 forms.
• AddedConvention recipes ship with the binary. enola constraints init binds every recipe whose roles resolve to directories the repository has — rails-conventions, rails-strict, vanilla-rails, layered, ports-and-adapters and more — naming what it could not bind and guessing nothing.
• AddedA component may select by ancestry (ancestor:), read transitively over resolved inheritance. Rubydex joins Prism as a Ruby fact provider carried by the binary itself.
• Addedsince and growth put a time dimension on a rule, and every edge or cycle verdict names its smallest cut.
• FixedA snapshot no longer depends on whether a previous snapshot exists: markdown links resolve against the walked file list rather than the filesystem, and the output directory is ignored at any depth rather than only at the repository root.

Rails route parity, fewer query-loop false positives, and utoipa routes

Rails route derivation matched Rails across a 3,500-route application. This release also adds dead-method detection and utoipa routes, improves query-loop analysis, and cuts a 22-repository cluster rerun from 891s to 224s.

• AddedRails routes now derive the way Rails derives them — plural/singular naming, scope module:/controller: composition, leading-slash escapes, and the hash-rocket mount form — checked against ActionDispatch::Routing::RouteSet line for line on a 3,500-route application.
• Addeddead-methods reports Ruby methods that no call edge in the graph reaches.
• Fixedquery-loops now follows a relation back to where it was built and accounts for declared preloads, removing two classes of false positive.
• AddedExternal fact providers can contribute lint findings through the same seam as other facts. A reference ESLint provider ships as a worked example, and constraints mine --scaffold-eslint writes a mined convention out as an ESLint rule.
• AddedRust services using #[utoipa::path] (utoipa_axum) now have their routes extracted. These routes were previously invisible because there is no .route(path, …) call to read.
• PerformanceCluster generation across multiple repositories does each shared step once instead of once per repository. A 22-repository, 1.56M-fact cluster went from 891s to 224s on a rerun.

Action: extractors changed, so regenerate snapshots and re-pin baselines.

Fact paths fixed on Windows; docs checked against the code

A declared layer order could silently match zero modules on Windows. Every fact path is now forced to forward slashes regardless of host, and a new CI check catches documentation that has drifted from what the code actually does.

• FixedFact paths — module names, layer classification, ignore globs, cross-repo linking — always use forward slashes now, even when generated on Windows. The host's backslash paths previously stopped matching everywhere paths get compared, so a declared layer order could report itself valid while classifying zero modules.
• FixedThe query_insights MCP tool's explainer= filter description named eleven explainers while the engine ran sixteen. Five — intent, constraints, domain, query-loops, entry-points — were invisible to an agent deciding what it could ask for, even though their findings already existed.
• FixedSeveral docs pages had explainer, tool, and rule-form counts that had silently drifted from the code, and two links pointed at files that had been renamed. A new CI check (docslint) now catches this going forward instead of publishing it.

Action: none for Unix users. Windows users should regenerate snapshots and re-check declared layer orders — matches that were silently empty before now report correctly.

AsyncAPI channels and Kafka call sites, cross-service

Messaging contracts declared in AsyncAPI now join the graph the same way HTTP routes do, so a missing consumer or an undeclared producer shows up as a finding instead of staying invisible.

• AddedAsyncAPI spec files (asyncapi.yaml/.yml) parse into declared channels, messages, and their schemas.
• AddedKafka producer and consumer call sites extracted in Go, TypeScript, and Scala, matched to declared channels by topic.
• AddedA new messaging-coverage explainer reports channels nobody produces or consumes, and messaging code with no declared contract — the messaging counterpart to unused-routes.
• AddedWorks across repositories: a producer in one service and its consumer in another link through the same multi-repo snapshot that already joins HTTP routes to their clients.

Action: none. Existing snapshots pick up messaging facts on the next generate_snapshot.

Declared architectural law

Architecture rules you write down are now verdicted against the measured graph, checked before an edit lands, and gateable in CI. Tools Enola does not ship can contribute facts through one seam, and the recorded history moves between machines.

• AddedA constraint vocabulary: components select facts, and rules state what may not reach what. Declarations live in enola/constraints/*.yaml beside the code they govern, so CODEOWNERS can route each file to the team that owns it.
• Addedenola constraints lint reports every validation problem with its file context and resolves each component against the snapshot, so a selector that matches nothing is caught while you are writing it rather than by a rule that passes vacuously.
• Addedenola constraints mine proposes candidate rules from regularities the graph already shows, with their evidence and their exceptions. Proposals for review, never self-adopting law.
• Addedenola plan answers before the edit: which rules govern the change, its blast radius, and — for a patch — the verdicts that would appear, evaluated over a scratch copy. Nothing is written.
• Addedenola endpoint walks a URL to what changing it reaches: the controller serving it, the models it touches, the models associated with those, and the tables behind them.
• Addedenola history push|pull|verify|gc shares the recorded architecture history between machines through a plain directory store — a Git repository, a shared mount, an S3-synced folder. Content-addressed and tamper-evident; verify walks every chain and names gaps and tampering.
• AddedA fact-provider seam: an external tool can contribute facts in the store's own schema. Fail-closed end to end — one invalid line discards that provider's whole output, every fact must declare how it was resolved, and the seam stamps provenance itself.
• AddedThree MCP tools: constraints_for, plan_check and endpoint_impact. Four explainers: constraints, domain, query-loops and entry-points.
• AddedRuby reads db/schema.rb and db/structure.sql, Stimulus and Turbo bindings declared in markup, and model associations. TypeScript adds constructors, decorators, accessors and extends bases; Go adds interface methods.
• Changedhotspots now reports its top 20 per repository. It was around 80% of every finding Enola produced, which buried the other explainers; corpus findings fall from 29,633 to 9,131.
• Changed--fail-on refuses a name no explainer has. It previously accepted anything and enforced nothing, so a typo in a CI config was indistinguishable from a passing build.
• FixedA plain file named enola at a repository root no longer aborts the snapshot — building a binary by that name in your own repository was enough to make generation fail.

Action: extractors changed, so regenerate snapshots and re-pin baselines. Two things may need attention: if a --fail-on value in CI is misspelled, that job will now fail rather than silently enforcing nothing — which is the point. And a service whose label came from its directory name may be renamed, since labels derive from the Git remote at a repository root.

Nothing fails until you name it

The check gate no longer ships an opinion about which findings should break a build, and repository labels come from the Git remote so a second clone compares against its own baseline.

• Changedenola check defaulted to failing on cycles. It now fails on nothing until --fail-on names it — a cycle is exactly measurable and still contested, so shipping it as a default asserted a rule about a codebase Enola had not looked at.
• AddedA run that enforced nothing now says so, rather than printing a bare pass. A silent green is indistinguishable from a broken gate.
• ChangedA repository's label comes from its Git remote when the indexed directory is that repository's root, and from the directory name otherwise.
• FixedA label mismatch between a snapshot and its baseline is now blocking rather than graded, so a worktree no longer reports its entire graph as added and removed.

Action: if you relied on the old default, add --fail-on=cycles to your CI job explicitly. Service names taken from a directory may change where the Git remote differs.

Express sub-router mounts compose across files

A router declared in one file and mounted in another now reports its routes at the path they actually serve, which is the layout most Express services use.

• FixedRoutes from a router declared in routes/*.js and mounted in index.js were dropped entirely, because a per-file pass cannot resolve the mount. A repository-wide pass now propagates mount prefixes from the application roots.
• FixedA same-file mount onto an unmounted parent emitted a fragment path; it now emits nothing. An extensioned ./x.js specifier now resolves to the x.ts it names.
• Fixedinstall and uninstall printed the full plan twice when --yes left no prompt between the preview and the result.

Action: cacheVersion moves to v198, so cached TypeScript snapshots re-extract on the next run.

Lower peak memory, and a verdict that says why nothing failed

Cold-run peak heap drops by a quarter to two fifths on large repositories, and advisory findings now name the reason they did not fail the build.

• PerfCold peak heap falls 24% on a large C# repository and 40% on the Linux kernel; the --explain report falls 41% and 43%. Output is unchanged — the determinism suite is the proof.
• ChangedThe extractor cache streams to disk instead of being buffered whole, and unsaved cache writes are skipped.
• FixedAn advisory finding now says why it did not fail: below the confidence floor, or from an explainer no policy named. One line could not cover both, and the old text asserted "Confidence < 1.00" over findings printing exactly 1.00.

Action: none. Peak memory is a property of the run, not of the output.

Full Rails route tables, plus Grape

Rails routes are now read from every routes file, not just the top-level one, and Grape APIs are detected automatically.

• AddedRoutes now come from every config/routes.rb and every .rb file under config/routes/ at any depth, with mount resolved to the mounted engine's own route file.
• AddedRoutes carry a handled_by edge to their controller action, and Rails classes carry a rails_component prop.
• AddedGrape API classes are now detected automatically by transitive inheritance, without needing a route file of their own.
• FixedThe Ember util layer no longer claims Ruby lib directories in a mixed Rails/Ember repo — layer matching is by path segment, and lib isn't a real Ember layer.

Action: regenerate snapshots for Rails repositories to pick up the full route table and Grape detection.

Five grammar updates and a protocol bump

Java, Ruby, C, C++, and PHP move to newer tree-sitter grammars, the bundled MCP SDK updates to the latest protocol, and CI gets hermetic tests and pinned tool versions.

• ChangedJava, Ruby, C, C++, and PHP tree-sitter grammars all updated to their latest upstream versions.
• ChangedThe bundled MCP SDK updates to v1.7.0, tracking the 2026-07-28 protocol revision.
• FixedGit-dependent tests no longer pick up the machine's own git config, so results stay the same in CI and locally.
• ChangedCI now runs a dedicated probe test for every supported tree-sitter grammar, plus actionlint and pinned action versions.

Action: none. Regenerate a snapshot if you want facts extracted with the newer grammars.

Vendored OpenAPI specs no longer read as your own server routes

A mobile app vendoring the OpenAPI spec of a backend it calls was indexed as if it served those routes itself, manufacturing inbound edges and unused-route findings that don't exist.

• FixedOpenAPI specs vendored by a native mobile client in a bare openapi/ directory were classified as server routes; they're now demoted to client routes when the repo looks like a native app and declares no server route of its own.
• AddedA Next.js loading.tsx under a single dynamic segment now extracts as a route, matching any one-segment client call with a path parameter.

Action: regenerate snapshots for repositories that vendor OpenAPI specs to drop the phantom server routes and findings.

The update-available notice actually gets written now

The check for a newer enola release only ever ran from two entry points, so most installs never got the cache file it depends on. It now refreshes from any command.

• FixedThe update-available cache only refreshed from the session-start hook and the MCP server's boot; an install using neither never wrote it and silently never notified.
• FixedA command that exits fatally with "snapshot produced no facts" now also prints the update notice, since that failure is often actually caused by running a build that's behind.

Action: none. The refresh still runs in a detached background process, so no command anyone waits on touches the network.

Uninstall leaves nothing behind

enola uninstall now removes the empty files and directories it leaves behind, instead of stripping its own configuration out and abandoning the shell.

• FixedA hook config emptied by uninstall used to leave a stray {} file and its directory behind; both are now removed when a mutation empties them.
• FixedThe heartbeat's output directory is now removed on uninstall too, when nothing else is left inside it.

Action: none. Existing installs are unaffected until the next enola uninstall.

Dart and Flutter extraction, gin routes, and update notices

Enola now extracts Dart and Flutter apps — widgets, navigation, storage, and outbound calls — plus gin routes in Go, and tells you when a newer enola is available.

• AddedDart and Flutter are now extracted: symbols, imports, the call graph, and complexity metrics, plus Flutter widget roles, navigation routes, outbound HTTP calls, and local/remote stores.
• Addedgin routes are now extracted from the Go extractor, including Group prefixes and handlers registered via Any or the generic Handle.
• AddedEnola now checks for a newer release at most every 12 hours in the background and prints a notice — never on a command a person is waiting on.
• FixedA Dart project's pubspec.yaml was silently excluded by the default ignore globs, so every legal Dart import cycle was misreported and Flutter projects went undetected.
• FixedA Dart call resolving to a same-named constant (not just callables) could misattribute high fan-in to the constant instead of the real function.

Action: regenerate snapshots for Dart, Flutter, and Go/gin repositories to pick up the new facts. No configuration change is required for the update notice.

Scala extraction and native Codex hooks

Enola now extracts Scala — call graph, routes, storage, and complexity metrics tuned for its effect-typed idioms — and enola install --hooks wires real session hooks for Codex.

• AddedScala is now extracted: symbols, the call graph, complexity metrics, and dependency injection across a fourth JVM language sharing packages with Java and Kotlin.
• AddedPlay Framework routes (including conf/routes), Pekko/Akka HTTP, and http4s route trees are extracted, along with Scala storage facts and outbound clients.
• Addedenola install --hooks now wires real SessionStart/Stop hooks for Codex, matching its native hook schema.
• FixedScala anonymous class bodies (new T { ... }) are now walked instead of skipped, recovering thousands of declarations and calls that were producing false dead-code positives.
• FixedA parenless Scala method reference — its uniform access principle drops the parentheses — now counts as a call edge instead of being silently dropped.

Action: regenerate snapshots for Scala repositories to pick up the new extractor. Codex users should run enola install --hooks and approve the new hook once via /hooks.

Understand the architecture of an entire .NET solution

Enola now reads every language in a .NET solution, not just C#, and understands how the pieces are wired together — project references, EF Core storage, outbound HTTP calls, and dependency injection.

• AddedF#, VB.NET, Razor/Blazor, and XAML (WPF, WinUI, MAUI, Avalonia) are now extracted into the same fact set as C#, so cross-language references resolve.
• AddedMSBuild project and solution files are parsed, so .NET dependencies and cycles are judged at the real assembly boundary instead of by directory.
• AddedEF Core, Dapper, and MongoDB storage facts are extracted, along with outbound HTTP client calls and conventional MVC routing.
• FixedClasses registered only through dependency injection (services.AddScoped<IFoo, Foo>()) no longer read as dead code.
• Fixed.NET test directories named Test/ or Tests/ were missed by case-sensitive globs and indexed as production code; this is now fixed.

Action: regenerate snapshots for .NET repositories to pick up the new languages, storage facts, and dependency edges. No configuration change is required.

C# extraction

Enola now extracts C#: types and members, dependency injection, and both of ASP.NET Core's routing mechanisms.

• AddedC# types, members, using dependencies, base lists, and constructor/primary-constructor injection are now extracted, with a partial class's several files merged into one symbol.
• AddedASP.NET Core routes are extracted from attribute routing ([Route]/[HttpGet], including inherited templates) and minimal APIs (MapGroup/MapGet).
• FixedA C# call through an interface — the common dependency-injection shape — now produces an inbound edge instead of reading as dead code.
• FixedA qualified reference like VideoRange.HDR now emits edges to both the member and its declaring type, so enum members and static fields used without a call stop reading as unreferenced.
• ChangedA foreach or LINQ loop's iterable is now walked in the enclosing scope, fixing spurious O(n²) complexity readings on the most common C# iteration idiom.

Action: regenerate snapshots to pick up C# facts. If your mcp-arch.yaml overrides the extractors: list, add csharp to it — a config written before this release silently disables the new extractor.

Declared architectural intent, five new extraction kinds, and a lower memory footprint

Repos and knowledge pages can now declare what the architecture is supposed to be, graded against every snapshot. Coverage extends to five new kinds, Ember support is complete, and large graphs use substantially less memory.

• AddedRepos and knowledge pages can declare intended architecture in enola-intent.yaml, graded against every snapshot through a new governing_intent tool.
• AddedNew extractors cover GraphQL, Terraform/HCL, Ansible, and React Navigation, plus Sequel storage facts alongside existing ActiveRecord support.
• AddedEmber and Glimmer support is complete: navigation edges, full resolver joins, engines, and monorepo-safe ignores.
• PerformanceThe fact store's memory footprint on large graphs is substantially lower, using an interned, compressed-sparse-row graph index.
• FixedSequel's call-form superclass declaration now correctly emits a storage fact instead of being silently dropped.

Action: regenerate snapshots to pick up the new route and storage kinds. Declaring architectural intent is opt-in via enola-intent.yaml; see docs/INTENT.md.

Ember and Glimmer extraction

Enola now resolves routes, templates, services, and data-model relationships in Ember applications.

• Added.gts, .gjs, and classic .hbs templates now contribute symbol references without changing source line numbers.
• AddedThe Ember resolver links template invocations, @service injections, and ember-data relationships to declarations under app/. Ambiguous matches remain unresolved and are counted in ember_unresolved.
• AddedRouter.map declarations produce composed page routes. Route templates attach to route classes, with controllers used as a fallback. Ember-data models produce storage companions.

Action: regenerate snapshots for Ember repositories. No configuration change is required; Ember detection requires ember-source.

Incomplete binary releases are no longer published

A release remains a GitHub draft until binaries and checksums exist for every supported platform.

• FixedThe release workflow now verifies all five expected binary and checksum pairs before publishing. A failed or unscheduled platform build leaves the release in draft.
• Fixedinstall.sh now identifies the missing OS/architecture artifact and links to the release downloads instead of returning a generic curl error.

Action: none.

Architecture history — enola log, show, diff, blame, and backfill

• AddedEvery prior surface describes the tree as it is now, diff_snapshot included, which compares two nows. enola log answers a question a snapshot structurally can't: when did this happen. Recording is on by default: every generate_snapshot appends a revision to an append-only history kept under ~/.enola/graphs/<workspace>/history/, outside the repository, so running it against a checkout you don't own is safe and clearing .enola doesn't take the history with it. enola show <rev> explains one revision, enola diff <a>..<b> compares any two, and agents reach the same two questions through new architecture_history and architecture_blame MCP tools. #190
• Addedenola blame <pattern> matches a module or symbol name, a file path, or both endpoints of an edge, and reports the revision where it first appeared; --findings searches recorded findings instead ("which snapshot introduced this cycle?"), --first stops at the introduction. A revision whose stored contents have aged out is reported as unsearched, never as absent, since "not found" and "not found in what I could read" are different answers and only one means the pattern truly never occurred. #190
• AddedA repository enola has never analyzed still gets a past: enola log --backfill --sample=daily (also all/merges/tags, plus --since/-n/--dry-run) walks existing commit history, extracting each selected commit's tree to a temporary directory and snapshotting it with today's enola and today's config, never the config that happened to be committed alongside that commit, which would make every historical config edit look like an architectural event. It reads the repository and writes nothing into it, and re-running resumes rather than repeating. #190
• AddedA delta is only a description of somebody's change when both sides were produced the same way. Each revision is stamped with an epoch, a fingerprint of enola's version, extraction behaviour, effective config, and plugin sets, and a revision straddling a changed epoch is marked incomparable in enola log rather than reported as an ordinary architectural change — elapsed time alone never earns that mark. #190
• AddedHistory entries are keyed by facts.RepoIdentity (the normalized git remote), never an absolute path, so two machines' histories of one repository describe the same subject and are mergeable by union-and-dedup; each revision is stored as a patch against the previous one, with a full copy periodically, at roughly 600 bytes per revision header (measured: ~600B–4KB with contents on a ~4k-fact repo, ~600B–34KB on a ~23k-fact repo). enola gc reports what's stored and reclaims what isn't needed; --thin-older-than drops old contents while keeping the timeline, --prune-working discards uncommitted-tree snapshots. #190
• ChangedThe history package is deliberately read-only and imports only pkg/facts and the standard library, staying buildable with CGO_ENABLED=0 so a viewer that reads a history doesn't have to link ten tree-sitter grammars. Nothing that judges the present, check, diff_snapshot, freshness, or drift, reads the history: deleting it changes no verdict and no snapshot_id, per the same authority rule docs/SNAPSHOTS.md already holds everything else to. Experimental: the commands and the on-disk format may still change. #190

Cross-repo linking becomes a plugin architecture

• ChangedExtractor→linker prop values (client sources, route kinds) were spelled out independently on both sides, so the Java extractor's java-http-client and feign sources were never in the linker's hand-written set — Java call sites linked as via="http" instead of via="http-client", silently. Both sides now share internal/facts/contract.go, guarded by tests that reject an unregistered route source or a literal spelled outside the contract; 24 files migrated to constants. Java call sites now correctly link as via="http-client", pinned by a new multi-repo fixture. #188 #189
• ChangedThe engine resolved gRPC and HTTP routes to handlers itself, as four methods in a fixed sequence — httpbind tested language == "go", grpcbind carried a regex per code generator — so a new language meant editing the engine. Binders are now plugin.Binder implementations under internal/linkers/binders, each declaring the stage it runs in; the HTTP binder keys on the structural http_handler prop instead of a language name. Order-independence is enforced by a test that serializes the store after running binders forward and reversed. #188 #189
• ChangedAll four cross-repo signals — HTTP calls, imports, Kafka topics, shared code — lived in one 1,823-line file with a dedicated field and materializer block each, so a fifth signal meant editing both. Signals are now plugin.CrossRepoSignal implementations under signals/, each declaring a phase and reporting evidence into a sink; crossrepo.go is down to 78 lines of orchestration. A new routeindex package holds the path-matching rules the HTTP signal and both unmatched-route passes must agree on. #188 #189
• AddedCross-repo linking vocabulary — the word lists deciding which names are too generic to link on, and the thresholds signals compare against — is now configurable via a linking: block in enola.yaml, overlaid under internal/linkers/vocab. List fields are add/remove rather than replace, so one added base class can't silently discard every default; an out-of-range threshold is a config error rather than a silent clamp. The vocabulary is now part of computeConfigHash, since it changes which edges are drawn. #188 #189
• FixThe bundled mcp-arch.yaml ignores **/*.json, so collectPackageNames — which read package.json off the engine's glob-filtered file list — never saw one under the shipped config. No module carried package_name, so the cross-repo linker's own-@scope guard had nothing to fire on: a repo importing its own published package was reported as depending on whatever other repo happened to share that scope name. package.json is now read directly from disk, the same principle the OpenAPI and Symfony-config extractors already apply. cacheVersion v145 → v146. #188 #189
• FixThe Axum route rewrite emitted one route copy per mount prefix using nf := f, which copies the struct but not the map behind Props — a router nested at two mount points produced two facts sharing one props map, so a per-route binder verdict written onto one copy landed on both. Cache-dependent: cached facts round-trip through json.Unmarshal and come back with independent maps, so it only bit on a cache miss. Fixed with facts.Fact.CloneProps(). #188 #189
• FixThe layers explainer ranked pkg/ below internal/ and fired on any import from the lower rank into the higher one — flagging essentially every Go repository with both directories (15 false findings on enola's own snapshot), since publishing an API over a private implementation is the standard layout, not a violation. internal/, pkg/, and api/ are now collapsed to one tier; the only ordering the layout actually expresses — nothing should import into cmd/ — still fires. #189
• ChangedNew docs/EXTENDING.md documents the plugin surface this release created: which plugin kind fits a given problem, adding a binder or a cross-repo signal, the linking: vocabulary, and the prop-vocabulary contract. Its config example is asserted by a test, TestLinkingExample_FromDocsParsesAndApplies, so it can't silently stop matching what it claims to show. #188 #189

Scope conformance, pluggable measurements & a shared command surface

• AddedA structural diff reports what changed and nothing about what was meant to change. New internal/conformance takes a declared target (or the packages a caller expected to touch), runs reverse-dependency impact analysis on the pre-change graph, and reports any package the change reached outside that radius as spillover — the coupling case where a package gains an outbound dependency without any of its own facts moving. With nothing declared, the edited packages are taken as the statement of intent. #186
• AddedConformance is now exposed as target/expected_packages on diff_snapshot and as --target/--expected on enola check, reported as a policy measurement rather than graded in place — it only fails a build under --max-spillover, so passing --target for the first time can't silently break a build that never opted in. #187
• AddedA caller running its own analysis over two snapshots had no way to feed the result into the verdict, so it had to grade itself. New Measurement, Threshold, and Breach types let pkg/check's Evaluate take arbitrary caller-reported counts and decide what they mean against policy; a verdict with no configured thresholds stays byte-identical to before. #183
• AddedAn analyzer computing a continuous per-module value had nowhere to publish it — one insight per module is noise, publishing only outliers discards the rest, so the value never left a single snapshot's analysis. A new Annotator interface lets an explainer write derived values onto facts after linking and before every Explain call, so no explainer's insights depend on registration order; values are rounded before storing, since facts are hashed into the snapshot ID. The fact diff now names which prop moved, as key: before → after, instead of only showing that a fact changed. #184
• Changedcheck, coverage, doctor, baseline, install/uninstall, and hook lived in cmd/enola, unreachable from a wrapper binary built on internal packages that don't cross a module boundary. Moved to pkg/command behind a Runner holding the binary name, so usage lines and error prefixes name whichever binary is actually running; --help output is unchanged. #180
• FixModuleDir stripped the repo label unconditionally, so a top-level source directory sharing the repository's own name resolved to a name no module had — edges out of that tree hung off a phantom node, taking cycle and layer detection with them. New ModuleDirCandidates returns both the raw and repo-stripped directory, and callers try exact matches against both before walking up. #178
• AddedcompareMeta compared extractor sets between snapshots but never explainer sets, so an explainer present on only one side made its entire finding set read as new or resolved with no warning and Comparable: true. New WarnExplainerSet adds the same symmetric check, registered in the verdict's advisory summary. #179
• ChangedThe working-tree drift warning was computed inline inside the diff_snapshot handler, so any other consumer building its own delta had to reimplement it — and the wording had already begun to diverge. Shared via new internal/drift, exposed out-of-module as pkg/bootstrap.AddDriftWarning. Also pins the diff's attribution contract: a cycle closed between two modules that both pre-date a change attributes through the added edge's endpoints, while a finding citing nothing the change touched stays incidental. #182
• ChangedResolveBaselineDir — the shared contract behind what diff_snapshot, compare_receipts, and enola check mean by "previous" — is now re-exported from pkg/bootstrap, so an out-of-module consumer no longer has to spell the baseline subdirectories out locally and risk disagreeing silently once the rotation changes. #181
• ChangedREADME and docs/BENCHMARKS.md refreshed against re-measured numbers. #177

Python inheritance edges, and explainer findings that attribute to the right fact

• AddedThe Python extractor now resolves implements edges for inheritance relations, taking import context into account — previously the only extractor missing this relation entirely. #175
• FixLayer-violation findings cited only the importing file, not the underlying dependency fact or raw import target; since the diff engine matches fact names and edge endpoints, file-only evidence never attributed, so every new violation landed in the incidental bucket the gate doesn't grade. Findings now key on the actual fact (layer violations, unused routes), and a new common.ModuleDir resolves cross-repo file paths back to modules so a composed multi-repo graph doesn't resolve to phantom nodes with undetected cycles. god-class and the layers pattern now clamp at common.MaxHeuristicConfidence rather than 1.0, since 1.0 is what the receipt, dashboard, and query_insights(min_confidence=) read as a structural fact, and a cycle should be the only finding that reaches it. layers and complexity-outliers now also exclude test code from their populations, matching every other explainer. #176

Config resolution, agent-hook reliability, and reproducibility fixes across explainers and extractors

• FixConfig resolution could silently analyze the wrong config: lookup fell back to the binary's own directory, and a list-valued key like extractors: replaced the built-in list rather than extending it — an eleven-extractor config sitting beside a go build output disabled Rust for every repository that binary touched, from any directory without its own config, with zero facts and zero error. bootstrap.ResolveConfig now returns and prints the resolved path on every command; the engine detects extractors disabled by an incomplete extractors: list and records them as shadowed_extractors in the receipt. Shipped configs no longer declare extractor lists at all — full.yaml had claimed to enable all languages while omitting grpc, openapi, and python. #166
• Fixinstall --hooks's Stop hook was registered as a flat list, but Claude Code expects every hook event as matcher groups — it parsed, and never fired. The correctly-shaped SessionStart hook beside it didn't fire either, since one malformed entry invalidates the whole hooks block: install --hooks configured nothing while reporting success. Every event is now written grouped, with migration for existing installs (enola's legacy flat entry is dropped, foreign entries preserved) and an opt-in end-to-end test that installs the hooks, closes a real dependency cycle in a headless session, and asserts the hook actually ran. #167
• FixA hardcoded .enola/** ignore-glob literal only matched the default output location by coincidence — pointing output.dir anywhere else made each snapshot walk the previous one's own artifacts, so an unchanged tree produced a different snapshot every run, breaking the reproducibility the baseline diff depends on. The ignore glob is now derived from output.dir itself, which must now name a subdirectory of the repo (absolute paths and .. escapes rejected); a config that exists but is invalid now errors instead of silently falling back to defaults that analyze the working directory. #168
• FixMeanStdDev's float reduction ran over the fact store's insertion order, which varies between runs of an unchanged tree due to concurrent extraction — and god-class is the only explainer that puts a threshold into its output (confidence) rather than using it only to select. Across 90 runs of 30 repositories, 11 of 25 insights.json findings drifted by ~1.9e-15, invisible at the two decimals anyone reads but enough to break insights.json's output-hash reproducibility. MeanStdDev now sorts a copy before reducing. Also fixes insights.json serializing as null instead of [] for a repository with no findings. #169
• AddedA hook that never fires and a hook that fires and finds nothing look identical from inside a session — the Stop-hook registration defect above shipped silently for exactly that reason. Every hook invocation now stamps <output.dir>/hooks.json, including no-op runs; enola doctor reports when each hook last ran and what it concluded (always exits 0, since a diagnostic can't borrow the non-zero-means-regression convention); and a pre-push git hook runs the agent-hook end-to-end test when a push touches the installer, since CI runners can't run real agent sessions. #170
• FixThree extraction gaps surfaced by widening the benchmark corpus to languages it had no prior coverage for: Kotlin/Retrofit only matched positional @GET("...") arguments, missing the named-argument form (@GET(value = "...")) real Android code uses, so no mobile-to-backend edges existed for it at all; Axum route chains terminated at the first non-verb method (e.g. .layer(mw)), dropping routes with the verb in plain sight; and TypeScript path-alias resolution picked the first matching prefix by map-iteration order instead of the longest, the only reproducibility failure found in the corpus. cacheVersion bumped to v144, v145. #171
• Fixexamples/multi-repo.yaml claimed in its own header to enable all extractors “regardless of which languages each repository uses,” then pinned five of twelve — a cluster containing PHP, Rust, Python, Java, or C++ indexed those repos as unsupported. A multi-repo cluster config is the one place the language mix can't be known in advance, so it no longer pins a plugin list; per-language example configs keep theirs. Also republishes docs/BENCHMARKS.md (38 repositories, 4,211,113 facts, zero parse errors, 38/38 byte-identical across 114 runs) and widens the regression ratchet to 12 repositories and 8 languages. #172
• FixThe Stop hook only emitted when a diff found a regression, so a baseline that couldn't be compared at all looked identical to a clean session — nothing was ever graded. shouldAutoPin now refreshes an auto-pinned baseline that's blocking-incomparable, not just one whose tree moved; the hook emits on incomparability too, naming the cause and remedy from the same table enola check prints from; and doctor reports baseline usability before a session starts rather than after. #173
• ChangedAdded docs/SNAPSHOTS.md, documenting the design argument for why enola's graph is a computed snapshot rather than a continuously maintained one: a verdict is a function of two states, and updating a graph in place would destroy the earlier state with the very edit being graded. Corrects a benchmark citation (30 repositories vs. the actual 38) and a mischaracterized cost comparison in docs/BENCHMARKS.md, and trims retrospective narration from ARCHITECTURE.md and docs/extraction/python.md down to present-tense statements of each rule. #174

See which cross-repo edges resolved, from the CLI

• Addedenola coverage reports which cross-repo edges actually resolved, now callable from the CLI instead of only through an MCP tool call — extracted into pkg/coverage so both surfaces compute the same report. The unresolved list is unconditional, not a flag: a report showing only successes would be marketing, and each miss is labeled as a repo you haven't loaded, a third-party endpoint, or a genuine blind spot. Exits 0 whenever it ran (2 on a usage error) — it's a report, not a gate; check owns the meaning of a non-zero exit. Also adds an examples/cross-repo pair whose link depends on a prefix composed across a function boundary, plus one deliberately dynamic call that stays unresolved, with a test that fails if the mount is removed. #165

enola check: grade architectural regressions from the CLI or CI, wired into agent sessions

• AddedGrading an architectural diff previously required an agent to remember to call an MCP tool. A pure Evaluate(*diff.SnapshotDiff, Policy) Verdict now backs a new enola check subcommand, exiting 0 clean / 1 regression / 2 could-not-run / 3 declined — 3 is deliberately distinct from 1, since a delta built over different inputs describes how the snapshots were produced, not what was edited, and grading that as a failure would be a lie. Comparability gains a typed Kind set instead of a single bool, so a stale baseline now warns and still grades rather than hard-refusing. Policy gates on the explainer (cycles by default), not on raw confidence, since god-class and layers findings both use 1.0/0.4 for reasons unrelated to certainty. Also adds baseline pin|show|clear and rejects unrecognized arguments instead of silently absorbing them as config paths. #161
• AddedA baseline pinned on one machine can now be graded on another. Comparability previously compared absolute RepoPath, so a baseline pinned in a CI runner's workspace and restored on a developer's machine always read as a different repository — the delta was correct, only the verdict was wrong. Repository identity now comes from the git remote, normalized (host/path, with scheme, credentials, port and a trailing .git stripped) so an HTTPS clone with an injected CI token and an SSH clone of the same repo compare equal, falling back to checkout directory name when neither side has a remote. CI gains an advisory architecture job that grades every PR against a published baseline without ever failing the build. #162
• Addedenola install --hooks wires the check loop into an agent session automatically: a baseline pins when a session starts, and the architectural delta is reported when it ends, only if the change introduced a regression. The stop hook is advisory by default (emits context, always exits 0), and the session-start snapshot runs detached so a large repo's index time never stalls session start — measured at the binary's floor (~17ms) on a repo that takes roughly ten seconds to index. Concurrent sessions are single-flighted through a non-blocking file lock, and a deliberately pinned baseline is never overwritten by the hook's own auto-pins. Two engine fixes this depended on: copyArtifacts now publishes a baseline atomically (a failed pin no longer destroys the previous one), and the extractor cache now records the binary that wrote it, after a missed cacheVersion bump was observed serving 568 phantom facts from a stale binary. #163
• ChangedRewrote the README and CLI docs to lead with architectural regression testing — the check/--hooks loop shipped in this release — instead of cross-repo linking as the primary pitch, and added CLI reference docs and two agent-session screenshots. #164

Traversal cap fixed to bound output, not the walk, and staleness checks scoped to the loaded graph

• FixtraverseFrom's maxNodes cap stopped the BFS frontier outright instead of bounding only the returned set, so every node reachable only through a capped-out node was silently missed — and NodesVisited/MaxDepthReached, computed over that truncated walk, were reported as properties of the whole graph. The frontier now queues a node even after the cap is hit, matching the existing node-kind-filter contract; maxNodes bounds the returned set only. Also fixes a fused impact-summary statistic: the dependent count came from an uncapped reachableCount while the depth printed beside it came from the cut walk. Measured on a 1.9M-fact graph: worst-case traversal 6ms → 22ms; extraction output is unchanged, no cacheVersion bump. #157
• FixStaleness checks pulled both the age signal and the per-repo VCS check from the machine-wide graph receipt, which every server process on the machine rewrites — so it reported drift for repos absent from the loaded graph and missed drift in the ones actually loaded. Receipt entries are now filtered to repos present in the loaded graph, and age comes from the loaded snapshot's own generated_at, with the receipt as a fallback only when it describes a loaded repo. #158
• FixgitInfo flagged a repo dirty on any git status --porcelain output, which lists untracked paths — and the snapshot creates <repo>/.enola before the receipt reads git state, so any repo that doesn't gitignore it recorded dirty:true for a fully committed checkout, disabling the staleness check's VCS arm (which only fires when the recorded state was clean). The status query now excludes the configured output dir via a pathspec, defined once in gitInfo so the snapshot-time capture and the live check share one definition of dirty. #159
• Fixdiff_snapshot and validate_architecture_change both labelled one side “current” without checking it still matched the working tree; the only age check was relative (baseline vs. current), so two equally stale snapshots compared clean, and an inverted pair was silent because a non-positive gap shared its signal with “no timestamp recorded”. Engine.Drift re-walks under the current config and re-hashes against the snapshot's recorded file hashes, and both tools now surface a comparability warning naming the drifted files — a filesystem comparison, not a VCS one, so it also works for repos that aren't git working trees. Known limit, documented: in append mode, drift checks only the most-recently-indexed repo and reports “cannot verify” for the others. #160

TypeScript server routes, fixed client-call detection, and multi-repo clusters outside MCP sessions

• FixThe optional type-argument group in TypeScript client-call patterns was <[^>]*>, which can't span a nested type argument — fetch<ApiResponse<Foo>>(...) matched one level of generics but not two, including on the openapi-fetch shape the pattern was written for. Lowercase verb calls (axios.get('/path'), http.post('/path')) matched nothing at all, excluded to avoid colliding with map.get()/cache.delete(); admitting them required gating client-route extraction on facts.IsTestPath, since a supertest e2e call is byte-identical in shape to production traffic — one API's own test suite had produced 500+ phantom client routes ungated, promoting an isolated service to connected and fabricating a cross-repo dependency edge out of test traffic. cacheVersion bumped to v141. #154
• AddedTypeScript emitted server routes only for file-based routers (Next.js, Nuxt, SvelteKit); a decorator- or call-routed backend contributed zero routes, so every client call against it stayed unresolved and the backend itself was classified isolated. Two new passes cover NestJS/InversifyJS @Controller classes and Express/Fastify/Hono/Koa <recv>.<verb>('/path', handler) calls, separated from client-call extraction by receiver binding and gated on facts.IsTestPath so an e2e fixture can't mint routes nothing calls. Also folds four duplicated route-path composition implementations (Axum, FastAPI, Spring, Symfony) into one facts.JoinRoutePath. cacheVersion bumped to v142, v143. #155
• AddedCross-repo linking was reachable only from an MCP session — append is a generate_snapshot tool parameter that both CLIs hardcoded to false, so a CI job or a developer not driving an agent saw only the single-repo subset: no service nodes, no cross-repo edges, no coverage_report. A config can now name a repo cluster (repos: [../api, ../web, ../sdk]), indexed with one --generate run — first repo fresh, the rest appended, resolved against the config file's own directory so a checked-in cluster config means the same thing on a laptop and in CI. --explain now also accepts a cluster config instead of always treating its argument as a repository path. #156
• AddedA live MCP Toplist rank badge in the README. #153

Query credit scaled by the corpus searched, and seeded across restarts

• FixQuery credit was a flat per-tool weight with no corpus term, so the same query_insights call earned an identical figure over a 1.9M-fact graph and over a few hundred facts — finding 51 cycles across 55,399 files priced the same as finding them across thirty. A query tool's ordinal weight now scales by the loaded graph's corpus, logarithmically and capped, so a haystack 100x larger costs a few more rounds of greps, not 100x, and a query can never earn more than reading the graph it searched outright would have cost. #152
• FixAutoLoadSnapshot restores a graph after a restart without re-snapshotting, but the corpus pool wasn't seeded on that path, so every query against a restored graph priced unscaled — measured at 23,669 tokens for a call worth 189,836. Each repo's parsed-source size (GraphRepoEntry.SourceBytes) is now carried in the graph receipt and published via Server.SeedCorpus before serving, behind an atomic pointer since it's now read on every concurrent tool call. #152

Value model re-anchored on measured corpus instead of flat call weights

• FixThe estimate behind --status and the dashboard was a flat per-tool weight and two conversion constants, so a 72K-token service and a 33M-token monorepo priced identically, a failed call still earned full credit, and the output_mode ladder — the main token-saving lever — never moved the number. Re-anchored on the counterfactual it claims to measure: what an agent would have had to ingest with grep and file reads to reach the same answer. Store.SourceBytesWithFacts now sums exactly the files that produced facts (summing the walked-file list instead pulls in images, media, and vendored databases — a 39x difference on one repository); snapshot credit derives from that corpus plus a cross-repo premium and reduced refresh tiers; credit is capped at a repo's own corpus so cumulative credit can never exceed the code it was computed over; and accounting moved into middleware that runs after the handler, so a failed call earns nothing. #151
• AddedCorpora exceeding a context window are now flagged instead of priced — for those the counterfactual isn't expensive, it's impossible, and a token figure would understate it. #151

Python test-file isolation, package re-export resolution & generated-code dead-code signals

• FixThe default ignore globs covered Go, TypeScript, and Ruby test conventions but not Python's: a pytest fixture mounting routers on a throwaway app is a route-mount fact, and the repo-wide FastAPI prefix fixpoint folds every mount it sees, so test-only prefixes rewrote production routes (six phantom endpoints in one repo, ~35% of its facts). Adds **/conftest.py, **/test_*.py, **/tests/**/*.py, and **/test/**/*.py to Ignore and TestGlobs — deliberately not a bare **/*_test.py suffix, which would repeat an earlier Ruby hazard of swallowing production code. #147
• FixThe bundled mcp-arch.yaml users are told to curl had drifted behind config.Default().Ignore — missing two Ruby spec globs plus dist/, coverage/, .nuxt/, .svelte-kit/, and target/ — so every adopter of the shipped file silently stopped ignoring those paths. Added a containment guard test. #148
• AddedA production Python symbol exercised only by a pytest file read as dead code (253 of 1,927 orphans in one corpus). New TestRefExtractor plugin credits these test-only references without polluting the production route graph — it emits only KindTestRef facts, so re-reading test files the ignore globs exclude can't reintroduce a fixture's include_router prefix. cacheVersion bumped to v137. #148
• FixA Python package is a directory, so from pkg.sub import thing left a call target pkg.sub.thing whose prefix matched no module file: 674 dangling targets carrying 4,660 call edges in one corpus, including every router factory an API composition root mounts, so find_path from that file reached none of them. resolveCallTargets now indexes package __init__ re-exports the walker already recorded; exact module resolution still runs first, so this is purely additive. #148
• FixTwo more Python call-target resolution bugs, both producing a wrong target rather than merely an unresolved one. Suffix matching and the internal-root gate accepted any directory name at any depth, so an internal directory sharing a name with a third-party package captured its imports (~500 third-party call edges misclassified as first-party in one repo); both now apply Python's actual package rule — a directory is a top-level package only if its parent isn't one. Separately, resolveAbsolute dropped trailing segments on failure, which is correct for an import but wrong for a call target: pkg.mod.Cls.method resolved to pkg/mod and kept only the last segment, yielding pkg/mod.method — a plausible-looking but wrong edge, not a dangling one. Resolution now walks the module/symbol split point leftward with an exact module lookup; an unconfirmed multi-segment candidate stays dotted rather than minting a wrong edge. cacheVersion bumped to v138. #149
• AddedTwo new signals let the dead-code detector drop findings it can never act on. Facts from a file carrying a codegen banner (DO NOT EDIT, generated by, @generated, matched case-insensitively against the leading comment block only, so it works for any generator and any language) now gain generated=true, since a generator's unreferenced half is guaranteed noise. Python functions registered with a framework by decorator — FastAPI @app.exception_handler/@app.middleware/@app.on_event/@router.websocket, Modal @app.local_entrypoint and (gated on the file importing modal) @app.function/@app.cls — now gain framework_registered=true, the same treatment Click/Typer commands already had. Facts are flagged, never dropped, so callers of generated code still resolve. cacheVersion bumped to v139. #149
• FiximportableRoots stopped scanning a path at the first package parent, but a directory without an __init__.py breaks the package chain and starts a new source root, so a segment below a package can itself be importable — classifying a real internal import as external made a whole analysis tree read as dead. Now judged per position, matching buildSuffixIndex, which already did (v138 continued). Separately, a function handed to a decorator as a bare value (@override_run_tasks(handler)) is a real use — the decorator-argument walk looked only for nested calls, so a bare identifier slipped past and the referenced function had no incoming edge. #150

Python FastAPI route composition, safer install script & cross-repo single-segment route linking

• Changedinstall.sh now uses install -m 755 instead of cp when placing the extracted binary, guaranteeing rwxr-xr-x permissions regardless of umask or archive attributes, and unlinking the existing binary before replacing it to avoid a Text file busy error when updating enola while it's running. #144
• AddedRoute decorators on defs nested inside a function body — the router-factory idiom — are now extracted; module-level statement walking never reached them. A repo-wide fixpoint folds include_router mount prefixes onto the bare decorator path, so a route is stored at the path it actually serves: the Python analog of the Go (v125) and Axum (v130) subrouter composers, keyed by the decorator's receiver rather than by line span. Unresolved mounts keep the bare path. #145
• FixTypeScript module facts now carry package_name (from the nearest package.json), and the http-client verb is read from the call's own options-object literal instead of a flat forward byte window that let a later call's method: bleed backwards onto an earlier one. The cross-repo linker also no longer binds a client call to an API-compatible reimplementation elsewhere when the calling repo serves that route itself, and a scoped import under a namespace the consumer itself publishes no longer draws a false cross-repo edge. #145
• FixSingle-segment endpoints could never form a cross-repo HTTP edge, from two compounding bugs: isGenericPath rejected any path under two segments, sweeping up named endpoints alongside /health and /status; and pathSuffixes yields nothing below minSharedSegments, so single-segment server routes were indexed under no key at all. The first is now a vocabulary test, with linkHTTP requiring an unambiguous provider for a one-segment match; the second gets a new pathMatchKeys whole-path fallback used by every server-index builder. Also excludes **/testdata/** from the OpenAPI and gRPC extractors, which walk the repo themselves and previously attributed fixture repos' routes to the host repo. cacheVersion bumped to v135. #146

Running-server instance registry fixes cross-process dashboard and restart state bugs

• FixOne MCP server is started per agent session, so several run at once against a shared ~/.enola, but nothing modelled a running instance, conflating per-process and shared state: the dashboard's PID/uptime/session cards were filled from the cross-process aggregate (a page served by one process could announce another process's PID), the graph panel read the machine-wide receipt while other panels read the live store (describing different codebases on one page), per-repo counter files were overwritten rather than merged (two servers on one repo silently discarded each other's increments), and a restart could come back holding whatever repos another session had snapshotted last. New instance registry under ~/.enola/instances/, written by the process it describes and reaped once that PID is gone; counter writes now merge only the unflushed delta under a cross-process lock; graph receipts are additionally written per workspace and preferred on restart. The dashboard now binds a fixed port and lists every live server. #143

Kotlin-on-Maven detection, programmatic servlet routes & Kafka topic cross-repo linking

• AddedKotlin detection only recognized Gradle, so a Kotlin service built with Maven was skipped entirely — no symbols, routes, or client calls extracted. Detection now also reads pom.xml (kotlin plugin/dependency, src/main/kotlin sourceDir) and falls back to a src/main/kotlin source root. Also adds route extraction for the fluent .addServlet("/path", handler) registration DSL, emitted with a new facts.MethodAny ("*") method that the cross-repo HTTP linker treats as a wildcard matched by any concrete-verb client call. #140
• AddedAsync coupling via message topics was invisible — a service consuming another's events showed no dependency. New topic fact (KindStorage, storage_kind=topic) extracted from an envconfig default: tag on a *Topic field or an env.Get("..._TOPIC", "default") call, plus a linkKafka cross-repo signal binding consumer to producer via the topic name's owning-service prefix. #141
• ChangedDocumented the Kafka topic signal in ARCHITECTURE.md's fact model, linker section, and pipeline stage 4 (previously shipped undocumented), backfilled the one-sentence Go entry in Supported languages, and added the golden fixture covering the producer/consumer topic-name join that unit tests of each half individually had missed. cacheVersion bumped to v132 for changelog convention only — Go facts are never cached. #142

Cross-repo shared-symbol linking overhaul: verified matches replace name-only guesses

• FixCross-repo shared-symbol edges were materialized in both directions even when an import or HTTP call had already fixed the direction, so a library whose types a consumer also declares came out depending on that consumer; edges now annotate the existing directional edge instead, staying symmetric only when nothing else fixed a direction. Separately, graph nodes are keyed by name, so same-named facts from different kinds merged and the earliest-stored one supplied the label — meaning node_kinds filtering on that label could drop a node from a service-filtered traversal. nodeFor now picks the fact whose kind matches the relation that reached it. #136
• FixGenerated stubs (.gen/.pb/_pb2/.generated, /mocks/) and unqualified type names shared across more than half of loaded repos were feeding the shared_symbols cross-repo signal, so services generating clients for the same API, or independently modelling the same domain vocabulary, fabricated a cross-repo dependency. Real HTTP/import edges are unaffected. #137
• FixTwo repos declaring the same distinctive type names were linked with a traversable depends_on edge even though neither imports nor calls the other and the linker has no way to substantiate the claim from names alone — measured across real identities behind these edges, about 45% were entirely unrelated code sharing a name, and depends_on also composes across hops while shared code does not, so a caller of one side of a copy-paste pair appeared to transitively reach the other. Such a pair now yields one symmetric, non-relational cross_repo_shared_code fact (queryable but never in the traversable graph) plus a separate lower-confidence insight; shared symbols still annotate an edge an import or call already established. Also fixed the direction gate, which enumerated directional via kinds and omitted grpc — it now tests for any via except shared_symbols. #138
• AddedA shared type name only ever meant "both repos declare this," which could equally be copied code or two teams independently naming the same concept alike. The linker now optionally reads source and, for each name-matched candidate, compares the two declaring files by token-set overlap (calibrated against a character diff: line-set comparison disagreed on 4 of 13 sampled declarations, all false negatives, versus token-set agreeing on all 13). Only verified names count toward the link threshold, and the resulting fact keeps both symbol_count and name_match_count so the gap between shared code and shared vocabulary stays visible; the insight moves to 0.8 confidence when verified. #139

CLI gains --help, --list & --status, plus a read-only live dashboard

• AddedNew pkg/cli renders the tool catalogue behind --list and a composable help spec behind --help (usage, flags, config path, examples, MCP configuration, build), documenting the previously-undocumented upgrade command. New pkg/status records per-tool usage under ~/.enola/usage/, keyed by absolute repo path so counters survive both a restart and deleting .enola/, letting --status report uptime, session and lifetime call counts, and an estimate of time/context saved; --status --all breaks this down per repo. #134
• AddedStarting the MCP server now also serves an auto-refreshing read-only dashboard on a free loopback port (--no-dashboard to opt out; --status prints its URL). Shows the same activity/value data as --status plus snapshot and graph receipts, the service and cross-repo-edge lists with a node-link diagram, insights grouped by explainer and filterable by confidence, and the extraction-quality proof (coverage, unresolved routes, skipped-file and parse-error samples). Every request reads through the same concurrency-safe accessors the MCP tools use, and each source degrades to an explanatory note rather than an error page. #135

Cross-repo linker stops false-linking on Rails boilerplate, Swift XcodeGen app targets sub-divided, graph restore-on-restart

• FixTwo repos declaring the same Rails framework-convention classes (ApplicationController, ApplicationRecord, ApplicationJob, ApplicationMailer, ApplicationHelper, ApplicationCable::Connection/::Channel, CanCanCan's Ability) or auto-generated Rails migration classes under db/migrate/ were linked as sharing code by the cross-repo shared_symbols signal, even though every app of that framework declares these identically and every app that ran the same migration gets a coinciding class name. Both are now excluded from the shared-symbol identity check. #131
• AddedThe Swift extractor mapped every file under an XcodeGen application/app-extension target's source root to one module identity, so a target spanning many directories collapsed the whole app into a single module in package_metrics (hundreds of types, no internal structure) — only SPM-style Sources/<Target> layouts appeared split. Application and app-extension targets are now sub-divided by leaf directory (matching Go/Ruby), with the type-reference pass run intra-target so per-directory packages get real directory-to-directory coupling; framework and SPM targets stay whole. cacheVersion bumped v130 → v131. #132
• AddedThe MCP server dropped its in-memory graph on restart: AutoLoadSnapshot reloaded only the configured repo's facts.jsonl, skipping insights and snapshot metadata, so multi-repo graphs had to be regenerated every restart with no generated_at to judge freshness against. Restore now rebuilds the whole graph from disk with no extractor runs, via a graph-wide registry (~/.enola/receipt.json) read by engine.LoadGlobalReceipt and republished by engine.RestoreFromDir; adds warn-only staleness surfacing (graph older than 24h, or a repo's git HEAD moved / working tree turned dirty since its snapshot) prepended to read-tool results. #133

TypeScript HTTP-client precision fixes & Axum nested-router prefix composition

• FixFour precision fixes in the TypeScript http-client extractor: a left word-boundary on the fetch()/makeRequest() matcher so a call merely ending in "fetch" (router.prefetch(), query.refetch()) is no longer captured as an outbound HTTP call; an options-object url: must now carry a real HTTP verb or request-payload key, not just a non-verb type: (SEO metadata, JSON-LD); a required leading "/" in cleanTSPath so non-path string literals don't become phantom routes; and a stripped query-string placeholder fused to a path's final segment. cacheVersion bumped to v128. #128
• FixA client call written as ${this.basePath}/calculate, where basePath is a "/"-rooted string literal in the same file, previously lost its base — cleanTSPath stripped the leading ${...} token, leaving a single-segment suffix the cross-repo matcher skips. A per-file identifier-to-literal base map now reconstructs the full path so these calls resolve to their server route; conflicting bindings are left unresolved. cacheVersion bumped to v129. #129
• FixThe Rust Axum extractor emitted routes at their bare in-router path and skipped .nest(...), so a router built by one function and mounted by a parent via .nest("/api/v1/datasets", module::router()) in another file was stored as /status instead of the true runtime /api/v1/datasets/status, breaking cross-repo client-route matching. A crate-wide fixpoint now resolves each nest to its callee builder and propagates mount prefixes from root builders, mirroring the Go gorilla/mux+chi subrouter composition shipped in v0.1.38. cacheVersion bumped to v130. #130

Go route-prefix composition, struct-usage edges & Rails route-extraction fixes

• AddedNew optional config.Config.ChangeVerifyHint (set programmatically before server construction, not read from YAML) appended to both the server's Instructions block and the post-snapshot loopHint nudge, giving a host or wrapper that registers extra change-verification tools a way to surface them from the workflow that pulls agents to diff_snapshot. Empty by default, so OSS behavior is unchanged. #123
• FixThe Go route extractor composed gorilla/mux and chi subrouter PathPrefix mounts only within a single function, so a subrouter created in one place and passed into a per-file/per-package registration function or method that registers bare leaf paths on it started with an empty prefix map — storing a route as /things instead of the true runtime /api/things, skewing cross-repo client-to-route matching. New buildRoutePrefixIndex module-wide fixpoint propagates each router argument's prefix to the callee's router parameter, also handling receiver-method registrations via the extractor's shared type resolver. cacheVersion bumped v124 → v125. #124
• FixThree further Go-extractor accuracy fixes. A collection-root route registered as sub.HandleFunc("", h) was dropped because the empty path was checked before composing the subrouter prefix; an empty string literal is now distinguished from a dynamic arg, composing to the prefix instead of being discarded. A struct used as a composite literal or as another struct's field type now emits a RelInstantiates edge, so an internal type referenced only that way no longer reads as dead code. scaling_loop_depth now discounts hierarchical nested loops (a loop reached through an enclosing loop variable, e.g. range pkg.Files) so a tree/AST walk is no longer over-reported as O(n²+). cacheVersion bumped v125 → v126. #125
• FixThe new RelInstantiates struct-usage edges (above) kept ubiquitous data structs out of the dead-code report, but a data struct built at many sites is not a god class or call-graph hotspot, and those edges started surfacing ubiquitous data types as false-positive high-fan-in findings. RelInstantiates is now filtered out of Graph.ArchitecturalReverse, the shared fan-in helper used only by the god-class and hotspots explainers; traversal, impact_analysis, find_path, and the dead-code detector are unaffected. Explainer-only change, no cache impact. #126
• FixThree Rails route-extraction fixes. A nested plural resources with shallow: true now emits its member routes (show/edit/update/destroy) at the shallow path while collection routes (index/create/new) stay nested, matching Rails; an optional path segment like foo(/:bar) now expands to both paths it actually serves instead of one literal that matched nothing; and the hash-rocket route form get 'path' => 'ctrl#action' is now extracted, where previously the path was skipped entirely. cacheVersion bumped v126 → v127. #127

I/O metadata for Rust, PHP & C++, module-graph fixes for nested layouts, SvelteKit route entry points & concurrency-safe snapshots

• Addedpkg/facts re-exports NewStore, NewGraph, and the Graph/ImpactResult/TraversalNode type aliases, so out-of-module consumers can reconstruct an in-memory store and dependency graph from a loaded snapshot (e.g. facts read back from a persisted baseline) without importing the internal package. #112
• ChangedScrubbed a real customer repository's name from source comments and test fixtures across the test-path, god-class, surface, and diff explainers, replacing it with anonymized examples. No functional change. #113
• FixBuildModuleGraph derived a dependency edge's source module from the file's leaf directory. In nested module layouts — an Xcode/SPM target with files under Sources/<Target>/<Sub>/ — the leaf directory is not a module, so source nodes never matched module-name targets and no strongly-connected component could form, silently zeroing cycle detection (and skewing dependency-depth) on such projects. New nearestModule helper walks a file's directory up to its enclosing production/test module for the edge source; a no-op on flat layouts (Go packages, directory-based Ruby/TypeScript modules). #114
• FixCompanion to the edge-source fix: BuildModuleGraph and the layers explainer matched an import edge's target against an exact module name, but extractors emit targets at differing granularity — a bare module dir (Go/Ruby), a module dir plus imported symbol (Kotlin/Java import a.b.C → a/b/C), or a file stem (TypeScript) — so an exact match dropped every class- or file-suffixed target; on a Kotlin codebase this hid all Kotlin-sourced layer violations and dependency cycles. Target resolution now walks up to the nearest enclosing module in both BuildModuleGraph and the layers explainer's detectViolations. #115
• FixThe Svelte extractor only ever fed a SFC's <script> block to the parser — the template/markup was discarded, so any handler, action, or binding wired solely from markup (on:click={fn}, {fn(x)}, bind:x={fn}, use:action) had zero incoming edges and was mis-reported as dead code by find_orphans. New extractSvelteMarkupRefs scans the markup for such identifiers and folds them into a KindFileRef fact, mirroring the TypeScript extractor's JSX file-ref pass. cacheVersion bumped to v120. #116
• AddedThe Rust extractor emitted only cyclomatic complexity, unlike every other extractor, so downstream performance analysis produced nothing for Rust regardless of loop nesting or I/O. The AST walker now tracks syntactic loop nesting with a constant-trip-vs-scaling distinction, records loop_count/calls_in_loop/calls_in_scaling_loop, flags recursive_self, and detects direct filesystem/DB/HTTP primitives as io_direct, with a transitive performs_io fixpoint over the call graph ported from the Python extractor. #117
• AddedThe PHP extractor emitted loop metadata but no I/O signal, so an in-loop call to a DB/HTTP wrapper was invisible to N+1 detection — only a keyword name match could fire, under-detecting wrappers and over-firing on in-memory helpers. The walker now flags io_direct on direct filesystem/DB/HTTP primitives (file_get_contents/fopen/curl_exec/mysqli_*/wp_remote_*, and distinctive $wpdb->get_results/get_row/get_var/get_col, PDO/mysqli fetch/query/execute calls) and runs the same transitive performs_io fixpoint as the Python/Rust extractors. #118
• ChangedRemoved developer-machine-only C++ integration tests that referenced absolute local paths and would never run in CI, and anonymized a further customer name reference in a Python extractor test comment. No functional change. #119
• AddedThe C++ extractor emitted loop metadata but no I/O signal, so an in-loop file/socket call was invisible to N+1 detection. The walker now flags io_direct on a deliberately narrow set of direct file/socket data-transfer primitives called as free/namespaced functions (fopen/freopen/fread/fwrite/socket/recvfrom/sendto) and runs the same transitive performs_io fixpoint; console/logging calls and ambiguous socket verbs (bind, connect, send) are excluded to avoid mass false positives, and <fstream> stream I/O via member calls is not detectable. #120
• FixSvelteKit's file/export-name-convention entry points — load in +page.ts/+layout.ts/+page.server.ts/+layout.server.ts under routes/, HTTP-method exports in +server.ts, and handle/handleError/handleFetch in hooks.server.ts — got no route fact and no symbol classification, since detectSvelteKitRoute only ever ran for .svelte SFCs; these plain-.ts framework entry points had zero incoming edges and their exports read as find_orphans false positives. cacheVersion bumped to v124. #121
• FixTool handlers dispatch on their own goroutines, unserialized, so multiple handlers could run against the one shared engine at once. GenerateSnapshot mutated the fact store in place (Clear → Add → BuildGraph) while readers took no lock, racing the snapshot pointer and repoPaths map — and snapshot.Facts aliases the store's live slice, so a reader could iterate an array being reallocated mid-regeneration. Snapshot state is now published as an immutable bundle behind an atomic.Pointer; GenerateSnapshot builds a new store off to the side and swaps the pointer once at the end. Added -race stress tests covering overlapping generates against lock-free readers. #122

Fixed dead-code false positives from macro-defined C/C++ functions, Python closures & guarded imports

• FixA C/C++ function defined through a name-carrying macro the grammar can't expand parsed either as an errored statement with a detached top-level body, or as a clean function_definition whose declarator lacked a function_declarator — both cases dropped the body's calls, so a static helper reached only from it had zero incoming references and was flagged dead code. New handleDetachedBody credits the body's calls to the module owner, the same mechanism already used for #define replacement lists; no symbol is emitted for the macro-defined function itself. cacheVersion bumped to v116. #109
• FixPython's walkForCalls hard-stopped at nested class_definition/function_definition/decorated_definition nodes, so a closure's body — every call, decorator, lazy import, and reference inside it — was never walked. Any module-level helper reached only from a closure (router factories, decorator factories, event-listener registrations) had zero incoming references, the single largest false-positive bucket in the Python corpus (~25%). New walkNestedScope walks nested definitions in a shadowed scope that credits references to the enclosing symbol, with metrics suppressed and bound names extended both directions to prevent fabricated edges. cacheVersion bumped to v117. #110
• FixPython imports nested inside a module-level try/if block — the try/except ImportError dual-import pattern, if __name__ == "__main__": imports, if TYPE_CHECKING: imports — registered no binding and no dependency fact, so calls through the guarded name were unresolvable and mis-reported as dead code. These statements now route through registerBodyImports, with an importFallback flag so an except-branch import can't clobber the try-branch binding. Conditionally-guarded definitions are deliberately still not emitted as symbols, to avoid manufacturing a dead-code false positive for an intentional shim. cacheVersion bumped to v119. #111

Rust language extractor & Java SPI dead-code fix

• AddedFirst Rust extractor — tree-sitter-based symbols for fn/struct/enum/trait/type/const/static with impl/trait and nested mod {} qualification, impl Trait for Type as an implements edge, use-based dependency facts classified internal/external/stdlib with cross-crate and submodule resolution for Cargo workspaces, calls/instantiates edges, per-function cyclomatic complexity, and Axum route detection (including chained verbs like get(a).post(b)). Tested on dbt-core and Axum. #85
• FixJava classes loaded only by name — SPI implementations registered in a service file, or classes discovered by classpath scanning for a plugin annotation — produced neither a call edge nor a prop and were reported as dead code. Service files are now read and resolved to their in-repo canonical type, emitting a KindFileRef fact the orphan detector already folds in as a reference; classpath-scanned plugin classes are now tagged scanned_plugin as entry points. #108

Test-path gating for architecture explainers, findings-diff dedup & TypeScript ORM storage

• Fixgod-class and hotspots ranked symbols by fan-in with no notion of a test path, so a test-scaffolding assertion helper could outrank real findings. A shared facts.IsTestPath now gates the candidate (not the edges) across Swift, Kotlin/Java, Python, and C/C++ — languages the prior reference-only-kind filter never covered. #102
• Fixenola-enterprise's analyze_performance could summarize the unfiltered result set instead of the filtered one — a package="androidTest" filter printed the repo-wide total above an empty table. New mcputil.Scoped[T] carries the filtered set plus its population size so a renderer has nothing else to count; traverse's node-count stat is fixed the same way. #103
• Fixcycles and dependency-depth only excluded test modules via module_role == ModuleRoleTest, a prop only Java, Kotlin, Ruby, and Swift emit — Go, Python, TypeScript, PHP, and C/C++ test trees walked straight into the coupling graph. Both explainers, and exported-surface's public-API count, now fall back to facts.IsTestPath where the build-file prop is absent. #104
• Fixenola-enterprise's performance analyzer carried its own weaker glob matcher that silently matched nothing against any ** pattern. The engine's directory-scoped **-capable matcher is now exported as pkg/facts.MatchGlob/MatchAnyGlob so both sides share one implementation. #105
• Fixdiff_snapshot could report "no facts, edges, or findings altered" while insights.json's hash had changed — a findings key collapsed distinct findings (e.g. "5621 more" vs. "3662 more" dead-code candidates) into one bucket with no changed-content case to land in, and 78 same-titled layer violations shared a map key so all but the last were silently dropped from the diff. Findings are now grouped and paired positionally, matching the facts side; a pinned baseline older than 3 days now warns. #106
• AddedTypeScript now emits storage facts — the only backend language in enola that modelled no tables. Covers TypeORM (@Entity()), Drizzle (pgTable(...)), and Prisma (schema.prisma models), gated on the package.json dependency. performs_io now also propagates through repository-wrapper methods around ORM query calls, so a per-iteration call to a wrapper is caught as a candidate N+1. #107
• AddedCode of Conduct and contributing guidelines. #101

Loop-depth parity for Java/C/C++/PHP, Swift override & #if fixes, Flask route detection

• ChangedJava (v104), C/C++ (v105), and PHP (v106) now emit scaling_loop_depth and calls_in_scaling_loop via the same three-valued loop classifier (constant/infinite/scaling) as Go/Python/TS/Kotlin — a literal-bounded loop no longer inflates the reported Big-O exponent. #95
• Fixquery_insights, query_facts(kind=service), and the llm_context renderer reported "cross-repo explainer did not run" identically to "found nothing," and misattributed which explainers actually produced an insight. The no-match case now distinguishes a single-repo snapshot (no cross-repo linker output) from a genuine no-match, and lists sources from Insight.Source instead of the ran-without-error set. #96
• FixSwift methods carrying the override modifier are now tagged override:true (v107), matching the existing Kotlin prop — an override is dispatched by its supertype (UIKit/SwiftUI lifecycle callbacks, XCTestCase hooks) and was being flagged dead by the orphan detector, which already consumed this prop for Kotlin but Swift never set it. #97
• FixA Swift type declared in both branches of a #if/#else block produced two same-name symbol facts. Branch symbols are now tagged conditional so counting analyzers collapse the duplicate while keeping genuine overloads intact. #98
• FixPython route detection matched only FastAPI verb decorators and hardcoded framework:"fastapi" on every match — @app.route/@bp.route and Flask-AppBuilder @expose produced zero route facts (0 of 293 on python/superset). Flask idioms are now detected and tagged framework:"flask" (v109), with the verb-shorthand label derived from the detected framework instead of a literal. #99
• AddedJava now emits io_direct/performs_io (v110) from high-precision, type-level signals — every method of a @FeignClient interface or Spring Data repository, any @Query/@Modifying/@Procedure method, and Room ops inside a @Dao interface — so a per-iteration repository call can be recognized as a confirmed N+1 instead of ranked on a keyword guess. Deliberately excludes bare @GET/@GetMapping, which are inbound handlers, not outbound I/O. #100

Test-ref parity for Go & TypeScript, Python shadow-guard fix & LLM-context repair

• Fixllm_context.md's Extraction Quality block only reported unresolved-edge counts when coverage_gaps > 0, hiding real signal on snapshots with many unresolved calls but zero gaps; the Repository Map section could also consume the entire token budget on multi-repo snapshots and drop the quality preface entirely. Sections now reserve budget ahead of layout, and a byte- vs. rune-boundary truncation bug that could emit invalid UTF-8 is fixed. #87
• FixPython call resolution checked same-class method/property matches before the local-binding shadow guard, so the common self.x = x constructor idiom produced a false calls edge whenever the class also defined a property literally named x (e.g. a SQLAlchemy synonym property). The shadow guard now gates every resolution branch, not just the same-module fallback. #86
• ChangedKotlin now emits scaling_loop_depth and calls_in_scaling_loop alongside loop_depth, joining the Go/Python/TypeScript convention — a constant-count loop no longer inflates the reported Big-O exponent. The same fix separates "grows with input" from "has a non-constant trip count" across all four languages, so an infinite loop with a chain walk inside it is now caught as an N+1 candidate instead of masked. #88
• FixGo functions called only from their own _test.go file were reported as high-confidence dead code — test files are now scanned for reference-only test_ref facts, matching the existing Ruby handling. #89
• FixA Go baseURL + "/path" HTTP-client pattern discarded the host, causing third-party API calls to be counted as unresolved internal edges and flip isolated backends to a false coverage_gap. The base identifier now resolves through a package-scoped string-literal index and is tagged external when every binding is an absolute http(s) URL. #90
• FixA Swift type reached only through its typealias name was reported as dead code — handleTypeAlias now folds the aliased type in as an instantiates edge. #91
• Fixtest_ref and file_ref nodes were indexed into the coupling graph, so their edges landed in the reverse adjacency map and inflated fan-in and centrality for the god-class and hotspots explainers — drifting their outlier thresholds and dropping genuine findings below the cut. Both explainers now read from a filtered reverse index that excludes reference-only edges. #92
• FixTypeScript was the last extractor without test_ref support — a production symbol called only from its .test.ts(x)/.spec.ts(x) file was reported dead. Closed to parity with Go and Ruby. #93
• ChangedDoc comments referenced an unmatched_reason value (no_match) the cross-repo linker never actually emits; the four reason strings are now exported crossrepo.Reason* constants so the list is defined once. #94

Cross-repo linking, diff-pairing determinism & skip-accounting fixes

• Fixdiff_snapshot no longer drops or misreports facts that share an identical key (e.g. Swift types declared under mutually exclusive #if/#else branches, overloaded methods) — colliding facts are now bucketed, sorted deterministically, and paired positionally instead of last-write-wins, fixing both silently-dropped deletions and spurious changed-fact reports on byte-identical fact sets. #81
• FixCross-repo shared-symbol linking no longer treats nested type names (e.g. Kotlin/Swift Outer.Inner) as namespace-qualified — only :: now counts. Dotted nested names were bypassing the same-language guard and producing spurious bidirectional depends_on edges between unrelated repos that merely reused a type name. #82
• FixCoverage-gap detection consolidated behind a single rule — the snapshot receipt was flagging any unresolved outbound call as a gap, while coverage_report and the coverage explainer required zero resolved edges, so the receipt's gap count saturated and lost its signal on healthy repos. All three now classify through one shared function. #83
• FixSnapshot receipts now count pruned directories — a directory dropped by an ignore glob (e.g. node_modules/) previously left its files uncounted entirely, understating files_skipped by orders of magnitude on trees with large ignored directories. A new dirs_skipped field is added, and each skip sample now names the glob that matched it. #84

Python value-ref resolution, relation-kind breakdown & Ruby test-file scoping

• FixPython call resolution now emits a value-ref edge when a function is passed on via assignment or return (cb = handler; return cb) — a common factory/registry/DI-by-return pattern that previously left the referenced function with no incoming edge and misreported it as dead code. #79
• FixThe Python call-resolution shadow guard now covers every name bound anywhere in a function's scope — not just parameters — so a loop variable, local assignment, with ... as alias, or walrus binding that happens to share a name with an unrelated top-level function no longer gets credited as a call to it. #79
• Added--explain now reports a relation-kind count breakdown (declares/imports/calls/.../has_method) for visibility into a snapshot's edge mix. #79
• FixRuby test-file matching now requires both a _spec.rb/_test.rb filename and a spec/ or test/ directory segment — a filename-only rule was silently excluding production files that merely end in the token _test (e.g. an ab_test.rb A/B-test job) from indexing entirely. #80

Cross-repo coverage triage, Swift/Rails route fixes & Rails explainer tuning

• AddedCross-repo coverage now buckets calls to hardcoded third-party hosts as external, separate from genuine unresolved internal gaps; unresolved client calls are tagged with a reason (method_mismatch, path_unknown, generic_path) so the residual can be triaged from data. #77
• FixSwift HTTP method inference widened — multi-line case-label lists and single-value method properties no longer silently default to GET; URLSession verb detection now scans a symmetric window and recognizes enum/.rawValue forms. #77
• FixRails route extraction now covers PUT on resource updates, symbol-path routes (get :cities_by_zip), bare scope symbol prefixes, and resource(s) path: overrides — on a 3-repo test graph, unresolved client calls dropped from 97 to 59. #77
• ChangedRuby/Rails architecture explainers tuned to cut false positives — two-tier layering (delivery vs. domain), deduplicated god-class/hotspot candidates, oversized dependency clusters reported as one low-confidence note instead of a cyclic-dependency alarm, and framework scaffolding excluded from god-class and hotspot findings. #78

Graph-wide receipt for multi-repo snapshots

• AddedGlobal receipt written to ~/.enola/receipt.json — describes the current multi-repo graph of graphs: composing repositories, each repo's git commit/ref/dirty state, membership duration, and graph-wide stats (fact/insight counts, cross-repo services and edges, coverage). Complements the existing per-repo receipt.json. #76

Self-update via enola upgrade

• Addedenola upgrade command — resolves the latest GitHub release, downloads the matching platform artifact, verifies its checksum, and atomically replaces the running binary. #75

Python gRPC support & call-resolution fixes

• AddedFirst-class Python gRPC support — servicer-to-route binding via the Servicer subclass convention and client detection from stub.Method() calls (including positional rebinding of a stub variable across services), bringing Python to parity with the existing Go and TypeScript gRPC support. #74
• FixPython resolveCall no longer fabricates same-module call edges for callable parameters, locals, and loop variables — removes spurious "used" signals, inflated fan-out, and misleading impact analysis. #74
• FixModule-graph construction no longer misclassifies single-segment internal modules (e.g. top-level cmd, config) as external, which was silently dropping real dependency edges. #74

Explainer correctness & determinism fixes

• FixMetric parsing in pkg/explain corrected — digits inside symbol or module names (e.g. Sha256Hash, oauth2) no longer corrupt parsed fan-in/fan-out and exported-surface percentages. #73
• FixCycle detection made deterministic — cycle paths, evidence order, and insight order no longer depend on map iteration order, via a shared strongly-connected-components pass. #73
• FixDependency-depth explainer no longer under-counts chains hidden behind a cycle — depth is now computed over the SCC condensation instead of a globally memoized, back-edge-truncated walk. #73
• FixCross-repo explainer no longer drops the via detail after a facts.jsonl round-trip. #73
• FixLayer explainer hardened — deterministic pattern-insight evidence ordering, layer violations deduplicated by source/target module, and relative import targets (./x, ../y) resolved before layer matching. #73

Python dead-code false-positive fixes & complexity signal improvements

• FixPython dead-code false positives reduced — absolute intra-project imports, function-local (lazy) imports, decorator applications and arguments, parameter defaults, and functions passed by name are now all tracked as call/reference edges. #72
• Addedscaling_loop_depth and calls_in_scaling_loop signals — loops over constant/bounded ranges no longer inflate scaling-complexity or N+1 findings the way input-scaling loops do. #72
• AddedPython performs_io propagation — direct DB/network/file calls now propagate transitively across the call graph, matching the existing TypeScript pass. #72
• AddedPython extractor now classifies enums, data classes (@dataclass, attrs, Pydantic models, NamedTuple, TypedDict), and duck-typed abstract classes (methods that only raise NotImplementedError). #72
• FixPython virtualenvs and installed dependencies (.venv, site-packages, .tox, and similar) are no longer walked, parsed, or cached, cutting snapshot time on repos with a local virtualenv. #72
• ChangedGenerated/vendored path filtering widened to cover vendor/, openapi-gen/, third_party/, __generated__, and common codegen suffixes, keeping them out of performance analysis. #72

Gemfile-less Ruby repo detection

• AddedGemfile-less Ruby repositories now detected, with extensionless Ruby executables indexed via shebang detection. #71

gRPC support & expanded cacheVersion test coverage

• AddedgRPC support — proto RPCs modeled as routes, with Go server handlers bound via handled_by edges; grpc-go, connect-go, and struct-field-injected Go clients now detected as client-role routes. #70
• AddedTypeScript grpc-web and connect-es client call sites now recognized alongside Go clients. #70
• ChangedTest coverage extended — every cacheVersion case now covered by unit and golden tests, with an enforced coverage guard. #69

CLI version flag

• Added--version flag on the enola binary, printing the ldflags-stamped build version. #68

Snapshot receipts

• AddedSnapshot receipts — receipt.json now captures provenance (version, git ref, content fingerprint, config hash, output hash) and extraction-quality metrics; new snapshot_receipt and compare_receipts MCP tools added, with quality signals surfaced in llm_context. #67
• Addeddiff_snapshot comparability guard validates snapshot compatibility before comparison. #67
• FixSnapshot generation now requires an explicit fresh=true parameter, preventing silent data pollution when switching between projects. #67

Expanded cross-repo HTTP-client detection

• ChangedHTTP-client detection expanded — TypeScript options-object and openapi-fetch patterns, Swift endpoint enums with prefix resolution (plus request-wrapper and stored-method endpoint resolution), and Rails draw() scope prefixes now recognized. #66
• FixRails nested singular/plural resource route path handling corrected; import/shared-symbol false positives removed from cross-repo HTTP-client detection. #66

TypeScript & Kotlin extractor accuracy improvements

• FixTypeScript dead-code false positives reduced — JSX, import, and this-member references now tracked; framework-dispatched symbols correctly excluded from unused-code findings. #65
• PerfMinified bundle files now skipped during performance analysis — transitive performs_io propagation added to cut false positives. #65
• FixTypeScript interfaces now classified as data shapes and excluded from package metrics, at parity with type aliases; abstract classes properly tagged. #65
• FixKotlin dead-code false positives reduced — method kinds and call edge types (receiver, property, callable-reference) now emitted; framework, DI, override, and test entry points excluded from orphan detection. #64
• FixKotlin cross-module Groovy-namespace imports now resolved correctly in multi-module projects. #64

TypeScript monorepo aliases, Swift accuracy & Ruby on Rails graph

• FixTypeScript monorepo path aliases now resolve correctly — a root tsconfig.json without aliases no longer blocks alias discovery in nested packages; ~/ and #/ imports resolve against the correct package config. #61
• FixBarrel re-exports (export * from, export { X } from) now tracked as dependency facts — code accessible only through index files no longer appears unused. #61
• AddedPlain JavaScript framework detection — Vue, React, Svelte, Next.js, and Nuxt projects without TypeScript are now correctly identified. #61
• FixSwift extractor accuracy improved — false positive count in performance analysis reduced from 259 to 81 via bounded loop detection and recursion awareness; dead-code detector no longer flags methods in flattened types. #62
• ChangedSwift modules now tagged with roles (production / test / tooling); test bundles collapsed and excluded from the dependency graph. #62
• ChangedRuby on Rails graph improved — dead-code coverage extended to delegate, ivar, and string-dispatch call sites; mixin vs namespace module classification added with namespace-aware coupling resolution. #59

C/C++ macro parsing & Ruby dynamic dispatch

• ChangedC and C++ extractors improved — macro parsing, function pointer detection, field assignments, compound literals, and token pasting now handled; false positive rate reduced significantly. #57
• ChangedRuby extractor extended — callbacks, dynamic dispatch, chained no-arg calls, .rake file indexing, and predicate (method?) and bang (method!) style methods now captured. #58

Diff tool, C support & extractor improvements

• AddedArchitecture diff tool — compare two snapshots to detect structural changes between commits or branches. #56
• AddedC language extractor — first-class support for C source files alongside the existing C++ extractor. #56
• ChangedRuby on Rails graph improved — more accurate dependency extraction across Rails projects. #56
• FixC++ extractor bug fixed and snapshot comparison hardened. #56

PHP support

• AddedPHP extractor — classes, functions, and dependency edges indexed from PHP source, with WordPress framework detection. #55
• ChangedPHP support brought to parity with other language extractors, including framework-specific detection. #55

Svelte support, shared MCP result helpers & snapshot refresh fix

• AddedSvelte framework detection — Svelte components and SvelteKit routing now extracted and linked in the architectural graph; the $lib alias resolves to src/lib/ for correct internal dependency edges. #51
• ChangedMCP result-builder and output-cap helpers (jsonResult, textResult, token-budget capping) extracted to pkg/mcputil so out-of-module tools share one implementation instead of duplicating it. #52
• Fixquery_insights' repo filter matched by loose substring against the insight title, so filtering by repo="golf" could also return insights from unrelated sibling repos that merely share the token (golf-ui, my-golf-journal-ios). The filter now matches against the evidence path's repo segment on multi-repo snapshots, falling back to the title-substring heuristic only when a snapshot has no repo prefixes to match against. #53
• FixAuto-loaded facts no longer overwritten on snapshot refresh — append flag now handled correctly during cleanup. #54

JS/JSX support, query_insights tool & doc fixes

• Addedquery_insights tool — surfaces architectural insights including dead-route detection directly from queries. #50
• AddedTypeScript extractor now recognises .js and .jsx files — mixed JavaScript/TypeScript codebases are fully indexed. #49
• FixDocumentation corrections across tool descriptions and cross-repo capability wording. #50

Unused route detection in cross-repo environments & extended testing

• ChangedTesting strategy extended with broader coverage and linting fixes applied across the codebase. #47
• AddedServer-side inverse computation — unused routes are now identified across multi-repository graphs, surfacing dead endpoints that no client calls. #48
• ChangedCross-repo capability descriptions updated to reflect the expanded route analysis. #48

Coverage insights, HTTP client extraction & extended testing

• AddedHTTP outbound client extraction for Ruby (Net::HTTP, Faraday, HTTParty) — outbound API calls now appear as graph edges in Ruby projects. #45
• FixGo HTTP client extraction improved — more call patterns captured for outbound API edges. #45
• AddedCoverage insights — unresolved dependency counts now tracked for Swift, Kotlin, Go, and TypeScript extractors. #46
• FixJava and Python HTTP client extraction hardened with improved exception handling. #46
• FixCI configuration corrected — coverage explainer source files no longer excluded by .gitignore. #46

Extraction pipeline performance pass

• PerfScanning performance improved — first pass of optimisations across the extraction pipeline. #44

Security patch — CVE-2026-27896

• FixUpgraded modelcontextprotocol/go-sdk to 1.3.1 to remediate CVE-2026-27896 (improper handling of case sensitivity). #43

Architectural smell detection

• AddedFive new explainers — god classes, call-graph hotspots, deep dependency chains, large public surfaces, and complexity outliers. #42
• Changed--explain now includes architectural smell findings alongside the existing cycle and layer analysis. #42

Vue & Nuxt support, per-function complexity metadata & Python polyglot detection

• AddedVue and Nuxt framework detection — Vue SFC script block extraction, composable detection, and automatic Nuxt file-based route inference (e.g. pages/users/[id].vue → /users/[id]). #40
• AddedPer-function metadata — complexity and performance metrics now tracked for Go, Python, Ruby, Swift, Kotlin, TypeScript, and Java functions. #41
• FixKeyword matching and nested closure handling corrected across multiple extractors. #41
• FixDeep-nested project detection extended to Python repositories — pyproject.toml, setup.py, setup.cfg, and requirements.txt now trigger deeper TypeScript root search in polyglot repos. #39

Adaptive TypeScript project detection & Python symbol indexing

• ChangedTypeScript root detection now adapts search depth to repository structure — simple repos search 2 levels, Java/Gradle polyglot repos search up to 8 levels to find nested frontends (e.g. src/main/resources/ui). #38
• AddedJava project detection (pom.xml, build.gradle, build.gradle.kts) to trigger deeper TypeScript search in polyglot repositories. #38
• FixCommon build and dependency directories (node_modules, dist, .next, build, out, target, vendor) now skipped during TypeScript root search — reduces false positives and improves performance. #38
• ChangedPython extractor enhanced with two-pass symbol indexing — cross-file type resolution, typed parameter inference, and abstract-to-concrete implementation tracking. #35

--explain flag & multi-language fixes

• Added--explain flag — asks enola to explain the architectural reasoning behind query results. #34
• FixRuby dependency resolution improved — require and include statements now resolve correctly across modules. #37
• FixJava static import detection gap closed. #34
• FixSwift & Kotlin edge dependency resolution corrected; Kotlin internal module coupling now resolves accurately. #34
• ChangedArchitecture detection improved for more accurate pattern recognition. #36

C++, Java & Ruby tree-sitter rewrite

• AddedC++ extractor — classes, functions, and cross-repository edge detection. #31
• AddedJava extractor following the established multi-language extraction pattern. #32
• ChangedRuby extractor migrated from regex to a tree-sitter AST parser — more accurate class, method, and call-site extraction across Rails and plain Ruby projects. #33

Python tree-sitter rewrite

• AddedPython extractor rewritten on tree-sitter AST — adds Django support (models, class-based views, DRF serializers, URL patterns), decorator recognition, and improved call/instantiation edge detection. #28

TypeScript improvements, token economy & release tooling hardening

• ChangedTypeScript extractor improved with React component, hook, and route handler semantic classification. #27
• PerfToken economy improved across all tools — output budgets enforced, cross-repo summaries tightened. #29
• Fixfind_path improved — ambiguous node names handled correctly, cross-repo dependency traversal corrected. #29
• ChangedDocumentation restructured — a new ARCHITECTURE.md added, describing enola's fact/relation graph model and its core determinism invariant: every fact comes from a real parser or a deterministic algorithm, never inferred by a language model. #30
• FixRelease workflow and install script hardened — native ARM64 and Intel GitHub Actions runners replace cross-compilation on shared runners, workflow permissions scoped explicitly, and install.sh now falls back to shasum -a 256 when sha256sum isn't available (stock macOS). #26

First official release — Swift AST parser, HTTP client extraction & install script

• AddedSwift extractor upgraded from regex to a C-based AST parser (tree-sitter) — more accurate symbol extraction across SPM and Xcode projects. #24
• AddedHTTP client extraction for Kotlin (Retrofit), Swift (URLSession), and TypeScript (fetch/makeRequest) — outbound API calls now appear as graph edges. #25
• FixCall graph resolution improved across Go, Kotlin, and TypeScript — typed variable method calls and cross-module imports now resolve correctly. #23
• FixInstall script added with checksum verification and OS/arch auto-detection for Linux, macOS, and Windows. #25

Cross-repo resolution fixes & org migration

• FixCross-repository graph resolution corrected — edges between repositories now resolve accurately across all reference patterns. #21
• ChangedArchitectural node descriptions improved for clearer, more consistent output across graph types. #22
• ChangedTop-level inclusion refactored — modules can now be included at the project root without additional configuration. #20
• ChangedReferences migrated to the enola-labs GitHub organisation — all import paths, links, and identifiers updated. #19

Graph of graphs & first-response latency

• AddedGraph of graphs — multiple repository snapshots now connect into a single traversable graph. Cross-repo edges resolve correctly across module and service boundaries. #18
• PerfFirst-response latency reduced — top-level resolution object rebuilt to surface the most relevant context on the initial query without a second round-trip. #17

Rebrand to enola

• ChangedProject renamed from archmcp to enola. All identifiers, config keys, and MCP server registration names updated. Existing archmcp configs require a one-line rename. #11

Kotlin DI detection

• ChangedImproved dependency-injection detection in Kotlin — constructor, field, and setter injection are now captured as first-class graph edges. #10

OpenAPI integration

• AddedOpenAPI spec integration — routes and schemas from openapi.yaml are merged into the architectural graph. #9

Ruby extractor & memory improvements

• ChangedRuby extractor now captures method calls in addition to definitions — call-site edges appear in snapshots. #7
• PerfMemory handling overhauled — peak RSS reduced significantly on large repositories during indexing. #8

In-memory graph, query performance & Rails support

• AddedIn-memory knowledge graph — the full architectural graph is now held in memory for zero-latency snapshot queries. #6
• AddedRuby on Rails support — routes, controllers, and models are extracted and linked in the graph. #5
• PerfQuery efficiency improvements — snapshot generation is substantially faster on deep dependency graphs. #4

First public release

• AddedKotlin extractor — classes, functions, and dependency edges indexed from Kotlin source. #1
• AddedSwift extractor — types, protocols, and call-site edges indexed from Swift source. #2
• FixedTest coverage added across extractors; edge-case bugs in symbol resolution corrected. #3