# Changelog

## Score

- CAI 57 → 60 (+3.1)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.

## Lenses

- Code Health 64 → 64 (+0.0)
- Architecture 99 → 99 (-0.1)
- Maturity 38 → 51 (+12.4)
- Readiness 75 → 64 (-10.4)
- Security 79 → 73 (-6.2)

## Resolved (16)

- Ambiguous naming convention for existence check vs retrieval. `command?` suggests a boolean predicate (is there a command named X?), while `command` suggests retrieval. However, in many Ruby libraries, `method?` is a predicate and `method` is the accessor. If `command?` returns a boolean and `command` returns the command object, this is consistent. But if `command?` returns the command (truthy/falsy) and `command` also returns the command, it's redundant. Given the context of `Spring` being a registry, `command?(name)` likely checks existence, while `command(name)` retrieves. This is a minor naming convention inconsistency if `command?` is intended to be a predicate but might be confused with a getter that returns nil/false.
- Bang method ambiguity. In Ruby, `state!` often implies a side effect or a stricter validation than `state`. However, `state` usually implies a getter. If `state(val)` is a setter, `state!(val)` might be a setter with validation or side effects. If `state` is a getter, `state!` is unusual. The presence of both suggests a lack of clear convention for state mutation vs retrieval. Typically, setters are named `state=` or `set_state`. Using `state(val)` as a setter is non-idiomatic.
- Duplicate intent for execution entry points. `Run.call(args)` is the standard Ruby interface for executing an object (like a command). `Run.run()` is also present. In many command patterns, `call` is the primary entry point. Having both `run` and `call` on the same object suggests either one is an alias (redundant) or they serve different purposes (e.g., `run` for the full lifecycle, `call` for a specific step). Without bodies, it's hard to tell, but typically `call` is the preferred idiom for 'execute this command'.
- Flaky test: AcceptanceTest#test_code_changes_in_pre-referenced_app_files_are_picked_up
- Floating git dependency: debug
- Floating git dependency: prism
- Floating git dependency: reline
- Floating git dependency: vterm
- Floating git dependency: yamatanooroti
- Further sole-owners (lower concentration)
- Off-boarding risk: anonymized user #1
- Outdated: minitest
- Outdated: rake
- Outdated: web-console
- Overlapping lifecycle termination methods. `terminate`, `exit`, and `exit_if_finished` all suggest ending the application's lifecycle. `exit_if_finished` is conditional, but `terminate` and `exit` are ambiguous. Does `exit` call `terminate`? Does `terminate` call `exit`? This creates a confusing API for users trying to shut down the application.
- Redundant/Confusing accessor for watcher configuration. `Spring.watcher` is a property/method returning the watcher instance. `Spring.watch_method` and `watch_method=` are used to configure the strategy (e.g., polling vs inotify). However, `Spring.Watcher` is also a namespace/module. The distinction between the *instance* of the watcher (`watcher`) and the *strategy* (`watch_method`) is clear internally but the API surface exposes both as top-level Spring methods, which can be confusing. More critically, `Spring.watcher` (method) and `Spring.Watcher` (module) share the same root name, which is acceptable in Ruby but adds cognitive load.

## New (1)

- Off-boarding risk: anonymized user #1
