memware 0.2.1__tar.gz → 0.2.2__tar.gz

{memware-0.2.1 → memware-0.2.2}/CHANGELOG.md

@@ -6,6 +6,16 @@ All notable changes to this project are documented here. The format follows
 
 ## [Unreleased]
 
+## [0.2.2] - 2026-09-03
+
+### Fixed
+- Backup retention now **promotes**: a snapshot ages forward through the 1/3/7/14-day tiers
+  instead of being pruned between them. The previous rule pruned every snapshot at age ~2, so a
+  daily-backup loop only ever kept a 0- and 1-day-old and never built a 3/7/14-day-old. Retention
+  keeps the newest plus the oldest per age band, always has a fresh ~1-day-old, drifts within
+  older tiers, prunes past the largest tier, and stays bounded (~5). Verified with a 30-day loop.
+
+
 ## [0.2.1] - 2026-09-03
 
 ## [0.2.0] - 2026-09-03

{memware-0.2.1 → memware-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: memware
-Version: 0.2.1
+Version: 0.2.2
 Summary: Memory for AI agents that only remembers the latest truth: a bi-temporal belief ledger plus a transcript index, in one SQLite file.
 Project-URL: Homepage, https://github.com/ericwalisko/memware
 Project-URL: Issues, https://github.com/ericwalisko/memware/issues

{memware-0.2.1 → memware-0.2.2}/docs/backup.md

@@ -35,9 +35,12 @@ memware backup         # writes memware-YYYYMMDD-HHMMSS.db, prunes to the retent
                        # and (by default) mirrors transcripts into <dest>/transcripts
 ```
 
-**Retention** keeps the newest snapshot plus the newest one at least 1, 3, 7 and 14 days old —
-roughly a 1-, 3-, 7- and 14-day-old backup at all times, not an unbounded pile. Tune with
-`backup.keep_days`.
+**Retention promotes.** Because memware only ever *creates* fresh snapshots, retention lets a
+snapshot **age forward** through the tiers rather than pruning it in between: it keeps the newest
+snapshot and the oldest one in each age band `(0,1] (1,3] (3,7] (7,14]`, so the same file serves
+as the ~1-day-old, then the ~3-, ~7-, ~14-day-old as time passes. You always have a fresh
+~1-day-old; the older tiers drift a little (that is fine and expected); anything past the largest
+tier is pruned. The pile stays bounded (~5). Tune the tiers with `backup.keep_days`.
 
 **Transcripts.** `backup.include_transcripts` (on by default) mirrors your transcript source
 (default `~/.claude/projects`) into `<dest>/transcripts`, additively — an append-only archive

{memware-0.2.1 → memware-0.2.2}/src/memware/__init__.py

@@ -22,4 +22,4 @@ __all__ = [
     "history",
     "reject",
 ]
-__version__ = "0.2.1"
+__version__ = "0.2.2"

{memware-0.2.1 → memware-0.2.2}/src/memware/backup.py

@@ -62,24 +62,35 @@ def newest_age_hours(dest_dir: str | os.PathLike[str]) -> float | None:
     return (_now().timestamp() - _stamp(snaps[0]).timestamp()) / 3600.0
 
 
+def _age_days(p: Path, now: datetime) -> float:
+    return (now.timestamp() - _stamp(p).timestamp()) / 86400.0
+
+
 def apply_retention(dest_dir: str | os.PathLike[str], keep_days: list[int]) -> list[Path]:
-    """Tiered retention. Always keep the newest snapshot; then for each age bucket in
-    ``keep_days`` (e.g. [1,3,7,14]) keep the newest snapshot at least that old. Delete the
-    rest. Returns the deleted paths. This yields, over time, roughly one 1-, 3-, 7- and
-    14-day-old backup plus the latest — not an unbounded pile."""
-    snaps = list_snapshots(dest_dir)
+    """Promotion retention: since we only ever *create* fresh snapshots, a snapshot must be
+    allowed to **age forward** into the next tier rather than be pruned between tiers.
+
+    Bands are the contiguous intervals ``(0, d0], (d0, d1], …`` for sorted ``keep_days``
+    (default 1,3,7,14). We keep the newest snapshot overall (tomorrow's ~1-day-old) and the
+    *oldest* snapshot in each band — the oldest is the one on the leading edge, so as days
+    pass it crosses into the next band and stays kept, i.e. the same file serves as the ~1-,
+    then ~3-, ~7-, ~14-day-old. Everything else, and anything older than the largest tier,
+    is pruned. Result: always a ~1-day-old, roughly one per tier (they drift; that's fine),
+    and a bounded pile of ~len(keep_days)+1. Returns the deleted paths."""
+    snaps = list_snapshots(dest_dir)  # newest first
     if not snaps:
         return []
     now = _now()
-    keep: set[Path] = {snaps[0]}  # newest always
-    for days in sorted(set(keep_days)):
-        cutoff = now.timestamp() - days * 86400
-        aged = [p for p in snaps if _stamp(p).timestamp() <= cutoff]
-        if aged:
-            keep.add(aged[0])  # newest that is at least `days` old
+    days = sorted(set(int(d) for d in keep_days))
+    keep: set[Path] = {snaps[0]}  # always the freshest
+    edges = [0.0, *[float(d) for d in days]]
+    for lo, hi in zip(edges, edges[1:], strict=False):
+        band = [p for p in snaps if lo < _age_days(p, now) <= hi]
+        if band:
+            keep.add(band[-1])  # oldest in the band (snaps are newest-first) -> promotes forward
     deleted = []
     for p in snaps:
-        if p not in keep:
+        if p not in keep:  # includes anything older than the largest tier
             p.unlink(missing_ok=True)
             deleted.append(p)
     return deleted

{memware-0.2.1 → memware-0.2.2}/tests/test_backup.py

@@ -31,20 +31,60 @@ def test_snapshot_is_consistent_and_restore_round_trips(tmp_path):
         assert s.stats()["turns"] == 5
 
 
-def test_tiered_retention_keeps_one_per_bucket(tmp_path):
+def _age_all(dest):
+    """Rename every snapshot one day older — how we advance the clock against the real _now()."""
+    import datetime as dt
+
+    for p in sorted(dest.glob("memware-*.db")):
+        stamp = bk._stamp(p) - dt.timedelta(days=1)
+        p.rename(dest / f"memware-{stamp.strftime('%Y%m%d-%H%M%S')}.db")
+
+
+def _ages(dest):
+    import datetime as dt
+
+    now = dt.datetime.now(dt.UTC)
+    return sorted((now - bk._stamp(p)).total_seconds() / 86400.0 for p in bk.list_snapshots(dest))
+
+
+def test_retention_promotes_and_stays_bounded_over_a_daily_loop(tmp_path):
+    """The real usage pattern: one new snapshot per day, retention each day. A snapshot must age
+    forward through the tiers (not be pruned between them), there is always a ~1-day-old, the pile
+    stays small, and nothing lingers far past the largest tier. Files are dated in real time and
+    aged by renaming, so this exercises the true `_now()`-based logic."""
     import datetime as dt
 
     dest = tmp_path / "b"
     dest.mkdir()
-    now = dt.datetime.now(dt.UTC)
-    # one snapshot per day for 20 days
-    for age in range(20):
-        stamp = (now - dt.timedelta(days=age)).strftime("%Y%m%d-%H%M%S")
+    for _day in range(30):
+        _age_all(dest)  # yesterday's snapshots become a day older
+        stamp = dt.datetime.now(dt.UTC).strftime("%Y%m%d-%H%M%S")  # a fresh age-0 today
         (dest / f"memware-{stamp}.db").write_bytes(b"x")
+        bk.apply_retention(dest, [1, 3, 7, 14])
+
+    ages = _ages(dest)
+    assert min(ages) < 1  # always a fresh ~1-day-old
+    assert len(ages) <= 6  # bounded, not an unbounded pile
+    assert max(ages) <= 15  # nothing lingers far past the largest tier
+    assert any(2 <= a <= 9 for a in ages)  # a snapshot promoted into the mid tiers (drift ok)
+    assert any(a >= 10 for a in ages)  # and one aged into the oldest tier
+
+
+def test_retention_prunes_snapshots_older_than_the_largest_tier(tmp_path):
+    dest = tmp_path / "b"
+    dest.mkdir()
+    for age in (0, 2, 6, 13, 20, 40):  # 20 and 40 are past the 14-day tier
+        _write_dated(dest, age)
     bk.apply_retention(dest, [1, 3, 7, 14])
-    kept = bk.list_snapshots(dest)
-    # newest + one each at >=1,>=3,>=7,>=14 days = at most 5, far fewer than 20
-    assert 4 <= len(kept) <= 5
+    assert all(a <= 15 for a in _ages(dest))
+
+
+def _write_dated(dest, age_days):
+    import datetime as dt
+
+    dest.mkdir(parents=True, exist_ok=True)
+    stamp = (dt.datetime.now(dt.UTC) - dt.timedelta(days=age_days)).strftime("%Y%m%d-%H%M%S")
+    (dest / f"memware-{stamp}.db").write_bytes(b"x")
 
 
 def test_backup_cli_uses_config_dest_and_mirrors_transcripts(tmp_path, capsys, monkeypatch):