# Changelog

## Score

- CAI 53 → 52 (-0.5)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

## Lenses

- Code Health 76 → 76 (+0.0)
- Architecture 90 → 88 (-1.4)
- Maturity 41 → 41 (+0.0)
- Readiness 45 → 46 (+0.2)
- Security 84 → 77 (-6.5)

## Resolved (4)

- Inconsistent generic signature between Java and Kotlin versions of the same logical operation. The Java version uses raw type wildcard `Association<?, ID>` while the Kotlin version uses `Association<ID>`. This creates an inconsistency in how the API is consumed across languages, potentially causing interoperability issues or confusion about whether the association type parameter must match exactly.
- Inconsistent naming convention for identity access between Java and Kotlin. Java uses the standard getter `getId()`, while Kotlin exposes it as a property `id`. While this is idiomatic for each language, it represents a surface inconsistency in the conceptual API design if the library aims for a unified cross-language contract. More critically, the Java `Identifiable` interface uses `getId()` while the Kotlin `Identifiable` interface uses `id`. This is expected for language idioms, but combined with the `Association` inconsistency above, it highlights a lack of unified design strategy.
- Semantic ambiguity between 'for' and 'pointsTo' methods. 'forAggregate' and 'forId' appear to construct or identify an association, while 'pointsTo' appears to check a relationship. However, the naming convention is inconsistent: 'for' suggests creation/lookup, 'pointsTo' suggests a boolean check. It is unclear if 'forId' creates an association to an ID or checks if the current association points to that ID. Furthermore, having both 'forAggregate' and 'pointsTo(aggregate)' suggests overlapping intent (identifying the target aggregate).
- The `SimpleAssociation` type in Kotlin includes `equals`, `hashCode`, and `toString` methods explicitly, while the Java `Association` type does not show these. This suggests `SimpleAssociation` is a data class or value object in Kotlin, whereas `Association` in Java is an interface. This creates a semantic inconsistency: one is a concrete implementation with value semantics, the other is an interface. If `SimpleAssociation` is meant to be the Java equivalent, it should be an interface or abstract class, not a concrete class with value semantics.

## New (1)

- High interface indirection

## Architecture

- Unchanged — 0 containers · 2 contexts · 0 edges
