chore: release v0.18.0

Store hardening release combining two changes:

- feat(doctor): StoreIntegrityChecks category added to aur doctor with
  auto-repair under --fix (commit c5dd2ec).
- feat(core): tiered access-history compaction behind
  AURORA_COMPACT_ACCESS_HISTORY=1 flag, default off (commit 0640e5d).

See CHANGELOG.md and docs/02-features/memory/STORE_HARDENING.md.

Tests: 2709 passed / 3 skipped / 0 failed via make test.

Author: hamr0

CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.18.0] - 2026-04-14
+
+### Added
+
+- **`aur doctor` store integrity checks** — new `StoreIntegrityChecks` category runs alongside the existing six health-check categories. Detects silent corruption in the ACT-R store:
+  - FTS5 desync (missing/stale `chunks_fts` rows vs. `chunks`)
+  - Orphan code chunks (file_path no longer in `file_index`)
+  - Activation orphans (rows referencing deleted chunks, FK-bypass insurance)
+  - Reasoning-chunk growth warning above 10K (Record-phase unbounded caching signal)
+  - Retrieval roundtrip (end-to-end FTS sanity via highest-access seed chunk)
+  - Three mechanical failures (FTS desync, orphans, activation orphans) are auto-repaired under the existing `aur doctor --fix` flag.
+- **Tiered access-history compaction** behind `AURORA_COMPACT_ACCESS_HISTORY=1` flag (default off). Bounds the unbounded-growth path in `activations.access_history` by collapsing older access records into time buckets for storage only. BLA ranking preserved to <0.001 because the decay formula (ln Σ t_j^(-d)) already treats old records as negligible.
+  - Four tiers: 0–7d verbatim, 7–30d hourly buckets, 30–180d daily buckets, 180d+ aggregate.
+  - `AccessHistoryEntry` gains an optional `count: int = 1` field; BLA loop becomes `count * t^(-d)`. Fully backward compatible — pre-change callers unchanged.
+  - Lazy trigger at length > 200; common-path `record_access` unaffected.
+- Design doc: `docs/02-features/memory/STORE_HARDENING.md` covering both changes, rationale, math, and rollout plan.
+
+### Changed
+
+- `get_access_history()` docstring documents the new optional `count` key and the compaction flag.
+
 ## [0.17.6] - 2026-02-14
 
 ### Added

packages/cli/src/aurora_cli/health_checks.py

@@ -13,6 +13,7 @@
 import importlib
 import importlib.metadata
 import os
+import sqlite3
 import subprocess
 from pathlib import Path
 from typing import Any
@@ -1003,8 +1004,6 @@ def run_checks(self) -> list[HealthCheckResult]:
             )
             return results
 
-        import sqlite3
-
         try:
             conn = sqlite3.connect(str(db_path))
             conn.row_factory = sqlite3.Row
@@ -1245,8 +1244,6 @@ def get_fixable_issues(self) -> list[dict[str, Any]]:
         if not db_path.exists():
             return issues
 
-        import sqlite3
-
         try:
             conn = sqlite3.connect(str(db_path))
         except sqlite3.Error:
@@ -1319,8 +1316,6 @@ def _fix_fts_desync(self) -> None:
         Uses the same `(name, body, file_path)` extraction as sqlite._upsert_fts
         so repaired rows are indistinguishable from normally-written ones.
         """
-        import sqlite3
-
         db_path = Path(self.config.get_db_path())
         conn = sqlite3.connect(str(db_path))
         try:
@@ -1344,7 +1339,9 @@ def _fix_fts_desync(self) -> None:
 
             for chunk_id, chunk_type, content_raw in missing_chunks:
                 try:
-                    content = json.loads(content_raw) if isinstance(content_raw, str) else content_raw
+                    content = (
+                        json.loads(content_raw) if isinstance(content_raw, str) else content_raw
+                    )
                 except (json.JSONDecodeError, TypeError):
                     continue
                 if not isinstance(content, dict):
@@ -1370,8 +1367,6 @@ def _fix_orphan_chunks(self) -> None:
         Also removes matching FTS5 rows so a subsequent FTS consistency check
         doesn't immediately re-flag them as stale.
         """
-        import sqlite3
-
         db_path = Path(self.config.get_db_path())
         conn = sqlite3.connect(str(db_path))
         try:
@@ -1400,8 +1395,6 @@ def _fix_orphan_chunks(self) -> None:
 
     def _fix_activation_orphans(self) -> None:
         """Delete activation rows whose chunk_id no longer exists."""
-        import sqlite3
-
         db_path = Path(self.config.get_db_path())
         conn = sqlite3.connect(str(db_path))
         try:

packages/cli/src/aurora_cli/main.py

@@ -30,7 +30,7 @@
 console = Console()
 logger = logging.getLogger(__name__)
 
-AURORA_VERSION = "0.17.6"
+AURORA_VERSION = "0.18.0"
 
 
 def _version_callback(ctx: click.Context, param: click.Parameter, value: bool) -> None:

packages/cli/tests/unit/test_store_integrity_checks.py

@@ -11,8 +11,6 @@
 import sqlite3
 from pathlib import Path
 
-import pytest
-
 from aurora_cli.config import Config
 from aurora_cli.health_checks import StoreIntegrityChecks
 from aurora_core.store.schema import get_init_statements

packages/core/src/aurora_core/store/access_history.py

@@ -43,9 +43,9 @@
 
 # Tier boundaries in seconds. Kept as module constants so tests can reference
 # them without re-deriving.
-_TIER1_MAX_SECONDS = 7 * 24 * 3600          # 7 days
-_TIER2_MAX_SECONDS = 30 * 24 * 3600         # 30 days
-_TIER3_MAX_SECONDS = 180 * 24 * 3600        # 180 days
+_TIER1_MAX_SECONDS = 7 * 24 * 3600  # 7 days
+_TIER2_MAX_SECONDS = 30 * 24 * 3600  # 30 days
+_TIER3_MAX_SECONDS = 180 * 24 * 3600  # 180 days
 
 
 def _parse_timestamp(raw: Any) -> datetime | None:
@@ -113,9 +113,9 @@ def compact_access_history(
         now = now.replace(tzinfo=timezone.utc)
 
     # Split entries into tiers by age.
-    tier1: list[dict[str, Any]] = []       # kept verbatim
-    tier2_by_hour: dict[int, int] = {}     # hour_epoch -> total count
-    tier3_by_day: dict[int, int] = {}      # day_epoch -> total count
+    tier1: list[dict[str, Any]] = []  # kept verbatim
+    tier2_by_hour: dict[int, int] = {}  # hour_epoch -> total count
+    tier3_by_day: dict[int, int] = {}  # day_epoch -> total count
     tier4_count = 0
     tier4_earliest: datetime | None = None
 
@@ -187,9 +187,7 @@ def compact_access_history(
     # access and the tier 3/4 boundary, which is where tier 4 begins.
     if tier4_count > 0 and tier4_earliest is not None:
         tier4_boundary = now - timedelta(seconds=_TIER3_MAX_SECONDS)
-        midpoint_epoch = (
-            int(tier4_earliest.timestamp()) + int(tier4_boundary.timestamp())
-        ) // 2
+        midpoint_epoch = (int(tier4_earliest.timestamp()) + int(tier4_boundary.timestamp())) // 2
         midpoint = datetime.fromtimestamp(midpoint_epoch, tz=timezone.utc)
         output.append(
             {

packages/core/tests/integration/test_access_history_compaction_sqlite.py

@@ -15,12 +15,9 @@
 from __future__ import annotations
 
 import json
-import os
 import sqlite3
 from datetime import datetime, timedelta, timezone
 
-import pytest
-
 from aurora_core.chunks.code_chunk import CodeChunk
 from aurora_core.store.access_history import COMPACTION_TRIGGER_LENGTH
 from aurora_core.store.sqlite import SQLiteStore

packages/core/tests/unit/test_access_history_compaction.py

@@ -64,9 +64,7 @@ def test_empty_input_returns_empty(self):
     def test_output_length_bounded(self):
         """10K entries spanning 2 years must compact to a small bounded size."""
         random.seed(42)
-        entries = [
-            _entry(random.uniform(0, 720 * 86400)) for _ in range(10_000)
-        ]
+        entries = [_entry(random.uniform(0, 720 * 86400)) for _ in range(10_000)]
         out = compact_access_history(entries, now=NOW)
         # Tier 2 can have at most 23 * (30-7) ≈ 552 hourly buckets if every
         # hour in tiers 2 was hit. Tier 3 has at most (180-30) = 150 daily
@@ -78,9 +76,7 @@ def test_output_length_bounded(self):
     def test_total_count_preserved(self):
         """Compaction must not lose any access count — it's a reshape only."""
         random.seed(7)
-        entries = [
-            _entry(random.uniform(0, 365 * 86400)) for _ in range(500)
-        ]
+        entries = [_entry(random.uniform(0, 365 * 86400)) for _ in range(500)]
         expected = _total_count(entries)
         out = compact_access_history(entries, now=NOW)
         assert _total_count(out) == expected
@@ -161,10 +157,10 @@ def test_entry_400_days_old_is_tier4_aggregate(self):
 
     def test_mixed_tiers_all_represented(self):
         entries = [
-            _entry(3600),              # tier 1
-            _entry(10 * 86400),        # tier 2
-            _entry(100 * 86400),       # tier 3
-            _entry(200 * 86400),       # tier 4
+            _entry(3600),  # tier 1
+            _entry(10 * 86400),  # tier 2
+            _entry(100 * 86400),  # tier 3
+            _entry(200 * 86400),  # tier 4
         ]
         out = compact_access_history(entries, now=NOW)
         assert len(out) == 4
@@ -187,9 +183,7 @@ def test_single_recent_access_unchanged(self):
     def test_hot_chunk_365_day_history(self):
         """A chunk accessed 1000 times over a year: BLA must barely change."""
         random.seed(1)
-        entries = [
-            _entry(random.uniform(0, 365 * 86400)) for _ in range(1000)
-        ]
+        entries = [_entry(random.uniform(0, 365 * 86400)) for _ in range(1000)]
         bla_before = _bla_from_raw(entries)
         out = compact_access_history(entries, now=NOW)
         bla_after = _bla_from_raw(out)
@@ -201,9 +195,7 @@ def test_error_bound_holds_across_random_patterns(self):
         for seed in range(50):
             random.seed(seed)
             size = random.randint(50, 1500)
-            entries = [
-                _entry(random.uniform(0, 720 * 86400)) for _ in range(size)
-            ]
+            entries = [_entry(random.uniform(0, 720 * 86400)) for _ in range(size)]
             bla_before = _bla_from_raw(entries)
             out = compact_access_history(entries, now=NOW)
             bla_after = _bla_from_raw(out)
@@ -219,20 +211,15 @@ def test_ranking_preserved_top_k(self):
         chunks: list[tuple[str, list[dict]]] = []
         for i in range(20):
             size = random.randint(10, 500)
-            entries = [
-                _entry(random.uniform(0, 300 * 86400)) for _ in range(size)
-            ]
+            entries = [_entry(random.uniform(0, 300 * 86400)) for _ in range(size)]
             chunks.append((f"chunk-{i}", entries))
 
         # Rank before compaction.
         before = sorted(chunks, key=lambda c: _bla_from_raw(c[1]), reverse=True)
         before_ids = [c[0] for c in before]
 
         # Compact each chunk, re-rank.
-        after = [
-            (cid, compact_access_history(entries, now=NOW))
-            for cid, entries in chunks
-        ]
+        after = [(cid, compact_access_history(entries, now=NOW)) for cid, entries in chunks]
         after.sort(key=lambda c: _bla_from_raw(c[1]), reverse=True)
         after_ids = [c[0] for c in after]
 

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aurora-actr"
-version = "0.17.6"
+version = "0.18.0"
 description = "AURORA: Adaptive Unified Reasoning and Orchestration Architecture with MCP Integration"
 readme = "README.md"
 requires-python = ">=3.12"