Aiki programming language tightens grammar authority and tooling in alpha milestone 26

Aiki milestone 26 shifts grammar authority from ad-hoc parser logic into a declarative grammar file. Every consumer, parser, formatter, linter, evaluator, now reads the same source of truth. This eliminates the risk that a change in one tool silently breaks another. The trade-off is that grammar changes must be more deliberate; a tweak to newline rules now requires explicit updates to the grammar rather than a quick edit in parser internals.

The work exposed latent inconsistencies. Some tokens that looked like continuations were actually resolved as new expressions, while others were unambiguously blocked. These edge cases are now visible design questions rather than hidden parser behavior. The same pass also revealed redundant derivations: multiple tools were independently walking the grammar to compute the same facts. Those derivations are now cached, reducing both duplication and the chance of drift.

Tooling robustness improved by making failure explicit. Negative parser specimens are now declared with a pragma, preventing malformed code from being silently skipped by formatter or linter. Recursive formatting and lint preflight now propagate errors to the shell instead of discarding them. This change forces tools to fail visibly rather than mask problems, but it also means engineers must handle errors at every layer rather than relying on silent fallbacks.

A separate module-resolution inconsistency surfaced when lint began traversing more source. Runtime and lint previously used different rules for public package resolution, causing valid code to fail lint. Lint now uses the same registry model as the runtime, eliminating the drift. The fix demonstrates how centralising authority can prevent subtle bugs, but it also means lint must now maintain a registry, increasing its operational complexity.

The update reflects a broader principle: facts should have one authority. Consumers may transform or represent those facts differently, but they should not independently reconstruct them. This reduces drift but requires upfront investment in declarative infrastructure. Engineers adopting similar patterns in their own projects will need to weigh the long-term consistency benefits against the immediate cost of refactoring.