luminary-memory 0.2.3__tar.gz → 0.2.4__tar.gz

{luminary_memory-0.2.3 → luminary_memory-0.2.4}/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project are documented in this file. The format follows [Keep a Changelog](https://keepachangelog.com/), and the project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.2.4] - 2026-08-18
+
+### Added
+
+- **`MemoryClient.health_score()`** — store health report (0-100) across five dimensions: duplicate rate, staleness, importance, graph density, and size — plus actionable recommendations. Empty store scores 100.
+- **`luminary-memory health` CLI** — human-readable bar + `--json` output.
+- **Test coverage raised 82% → 90%** (roadmap DoD): config_schema standalone shim, enricher `_call_llm`/`review_memories` paths, maintenance CRUD edges, provider lifecycle/maintenance/shutdown, CLI whitelist/limit errors, recall strategy failure fallbacks.
+
+### Fixed
+
+- **`run_maintenance` bad-response detection** — `data.get("actions") or []` masked non-list responses as "no actions"; now correctly reports `{"error": "bad LLM response"}`.
+
 ## [0.2.3] - 2026-08-18
 
 ### Added

luminary_memory-0.2.4/PKG-INFO

@@ -0,0 +1,176 @@
+Metadata-Version: 2.5
+Name: luminary-memory
+Version: 0.2.4
+Summary: A lightweight, self-hosted memory layer for AI agents
+Project-URL: Homepage, https://github.com/alertxsto/luminary-memory
+Project-URL: Repository, https://github.com/alertxsto/luminary-memory
+Project-URL: Documentation, https://github.com/alertxsto/luminary-memory#readme
+Author: Dwiky Candra
+License: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.11
+Requires-Dist: fastembed>=0.4.0
+Requires-Dist: numpy>=1.26
+Requires-Dist: pgvector>=0.2.5
+Requires-Dist: psycopg[binary]>=3.1
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pdoc>=14; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Provides-Extra: hermes
+Description-Content-Type: text/markdown
+
+# 🌙 luminary-memory
+
+**A lightweight, self-hosted memory layer for AI agents.**
+
+[![PyPI version](https://img.shields.io/pypi/v/luminary-memory?color=8ab4e8&label=PyPI)](https://pypi.org/project/luminary-memory)
+[![Python](https://img.shields.io/pypi/pyversions/luminary-memory?color=8ab4e8)](https://pypi.org/project/luminary-memory)
+[![License](https://img.shields.io/github/license/alertxsto/luminary-memory?color=8ab4e8)](LICENSE)
+[![CI](https://img.shields.io/github/actions/workflow/status/alertxsto/luminary-memory/ci.yml?color=8ab4e8&label=CI)](https://github.com/alertxsto/luminary-memory/actions)
+[![Tests](https://img.shields.io/badge/tests-168%20passing-8ab4e8)](https://github.com/alertxsto/luminary-memory/actions)
+[![Coverage](https://img.shields.io/badge/coverage-85%25-8ab4e8)](https://github.com/alertxsto/luminary-memory)
+[![Stars](https://img.shields.io/github/stars/alertxsto/luminary-memory?color=8ab4e8)](https://github.com/alertxsto/luminary-memory)
+
+**Self-hosted · Private · Budget-aware · Self-maintaining**
+
+---
+
+## What your agent remembers is what it becomes.
+
+Agents are only as good as what they remember. A stateless agent re-learns the same context every session — paying the same tokens, making the same mistakes. luminary-memory closes that gap with a local memory store that persists between runs, retrieves the right context on demand, and keeps itself tidy over time.
+
+**Four retrieval strategies. One fused answer. Zero cloud.**
+
+- **Semantic** — ONNX embeddings (384-dim, CPU, no GPU needed)
+- **Keyword** — FTS5 BM25 (SQLite, zero config)
+- **Temporal** — recency decay × access count
+- **Graph** — entity co-occurrence with automatic curation
+
+Strategies run in parallel and fuse via **Reciprocal Rank Fusion (k=60)** → **Jaccard deduplication (0.85)** → **token budget (4096)**.
+
+---
+
+## Quickstart
+
+```bash
+pip install luminary-memory
+```
+
+```python
+from luminary_memory import MemoryClient
+
+client = MemoryClient(db_path="memory.db")
+
+# store a durable fact
+client.ingest("The deploy target is the staging cluster", tags=["deploy", "infra"])
+
+# recall — four strategies fused into one ranked answer
+result = client.recall("where do we deploy?")
+for memory, score in zip(result.memories, result.scores):
+    print(f"{score:.3f}  {memory.content}")
+# → 0.942  The deploy target is the staging cluster
+```
+
+```bash
+# CLI
+luminary-memory add "deploy target is staging" --tags deploy
+luminary-memory recall "where do we deploy?" --json
+luminary-memory list
+luminary-memory lifecycle
+luminary-memory stats
+```
+
+---
+
+## Hermes Agent — first-class memory provider
+
+Drop-in. Install the provider with `pip install "luminary-memory[hermes]"`, then add
+`memory.provider: luminary` to your Hermes config. That's it.
+
+From the next session: **auto-recall** injects relevant memories every turn,
+**auto-save** persists completed turns, and the model can call
+`luminary_recall` / `luminary_ingest` / `luminary_list` on demand.
+
+Two optional LLM-powered features keep the store sharp:
+
+- **`ingest_llm`** — evaluates every turn before saving: drops chit-chat, stores factual summaries instead of raw transcripts.
+- **`auto_maintain`** — reviews the store at session end: keeps current facts, updates changed ones, deletes stale or duplicate ones.
+
+18 settings are exposed in the [Hermes dashboard](https://alertxsto.github.io/luminary-memory) for zero-hassle tuning. See
+[hermes/README.md](hermes/README.md) for the one-shot installer and full configuration.
+
+---
+
+## Configuration
+
+Every setting has a `LUMINARY_*` env var or a `Settings` object.
+
+| Setting | Env var | Default |
+|---------|---------|---------|
+| `backend` | `LUMINARY_BACKEND` | `sqlite` |
+| `db_path` | `LUMINARY_DB_PATH` | `luminary_memory.db` |
+| `pg_dsn` | `LUMINARY_PG_DSN` | — (pgvector only) |
+| `embedding_model` | `LUMINARY_EMBEDDING_MODEL` | `BAAI/bge-small-en-v1.5` |
+| `embedding_dim` | `LUMINARY_EMBEDDING_DIM` | `384` |
+| `ingest_llm` | `LUMINARY_INGEST_LLM` | `false` |
+| `rrf_k` | `LUMINARY_RRF_K` | `60` |
+| `dedup_jaccard_threshold` | `LUMINARY_DEDUP_JACCARD_THRESHOLD` | `0.85` |
+| `token_budget` | `LUMINARY_TOKEN_BUDGET` | `4096` |
+| `ttl_default_seconds` | `LUMINARY_TTL_DEFAULT_SECONDS` | `null` |
+| `prune_min_importance` | `LUMINARY_PRUNE_MIN_IMPORTANCE` | `0.2` |
+| `consolidate_jaccard_threshold` | `LUMINARY_CONSOLIDATE_JACCARD_THRESHOLD` | `0.9` |
+
+See [hermes/SKILL.md](hermes/SKILL.md) for the full provider config table (18 settings).
+
+---
+
+## Architecture
+
+```
+ingest(text) ──► whitelist filter ──► (LLM curation) ──► embed ──► SQLite / pgvector
+
+recall(query) ──► semantic │ keyword │ temporal │ graph
+               ──► RRF fusion ──► Jaccard dedup ──► token budget ──► ranked results
+
+lifecycle() ──► cleanup (TTL) ──► consolidate (near-dupes) ──► prune (low-value)
+
+maintenance() ──► LLM reviews store ──► keep │ update │ delete stale facts
+```
+
+Built-in lifecycle keeps the store lean. LLM maintenance (optional) keeps it accurate. `health_score()` gives you a 0-100 checkup with actionable recommendations.
+
+---
+
+## Documentation
+
+| Section | |
+|---------|-----|
+| [Quickstart](docs/quickstart.md) | Install and first use |
+| [Architecture](docs/architecture.md) | Pipelines and data flow |
+| [Python API](docs/api.md) | `MemoryClient` reference |
+| [CLI](docs/cli.md) | All subcommands |
+| [Recall](docs/recall.md) | Four strategies + fusion |
+| [Lifecycle](docs/lifecycle.md) | Cleanup, consolidation, pruning, LLM maintenance |
+| [Backends](docs/backends.md) | SQLite vs pgvector |
+| [Hermes integration](docs/hermes-integration.md) | Provider, config, installer |
+| [Roadmap](ROADMAP.md) | v0.2.3 → v1.0.0 |
+| [Benchmarks](benchmarks/RESULTS.md) | 230 ms recall @ 5k, 0 LLM tokens |
+
+---
+
+## License
+
+[Apache-2.0](LICENSE) © 2026 Dwiky Candra

luminary_memory-0.2.4/PLAN-v0.2.4.md

@@ -0,0 +1,128 @@
+# PLAN v0.2.4 — Coverage 90% + Health Score
+
+**Version:** 0.2.4 · **Milestone:** Quality hardening + health introspection
+**Goal:** Raise test coverage from 82% → ≥90% (roadmap DoD) and ship
+`MemoryClient.health_score()` for store quality monitoring.
+
+---
+
+## Phase 1 — Coverage: test the untested (T1–T5)
+
+Targets identified by `pytest --cov --cov-report=term-missing`:
+
+| Module | Current | Target | Missing lines to cover |
+|--------|---------|--------|------------------------|
+| `hermes/config_schema.py` | 11% | ≥90% | Standalone fallback shim (no hermes runtime) |
+| `ingest/llm.py` | 68% | ≥90% | `review_memories`, `_call_llm` error/empty paths, enrich failures |
+| `api.py` | 75% | ≥90% | `run_maintenance` actions, `delete`/`update` edges, error handling |
+| `hermes/provider.py` | 81% | ≥90% | maintenance trigger, shutdown, prefetch guards, error paths |
+
+### T1 — config_schema standalone coverage
+- Test: import `config_schema.py` **without** hermes-agent runtime (simulate CI)
+- Assert `CONFIG_SCHEMA` shim exposes `name`, `label`, `storage`, 18 fields
+- Assert `auto_maintain` and `ingest_llm` fields present
+
+### T2 — llm.py enricher paths
+- Test `OpenAICompatibleEnricher.review_memories` with mocked `_call_llm`
+  - returns valid actions JSON → parsed
+  - returns `{}` → `{"skipped": ...}` handled by caller
+  - raises (network) → returns `{}` (best-effort, no crash)
+- Test `_call_llm` with mocked `urlopen`:
+  - 200 with choices → content returned
+  - 200 empty choices → `""`
+  - HTTPError → propagates to caller fallback
+- Test `enrich()` fallback when `base_url` empty → `EnrichedContent(content=text)`
+
+### T3 — api.py maintenance + CRUD edges
+- Test `run_maintenance`:
+  - no enricher → `{"skipped": ...}`
+  - empty store → `{"reviewed": 0, ...}`
+  - enricher returns delete/update/keep actions → applied correctly
+  - enricher returns malformed actions (not a list) → `{"error": "bad LLM response"}`
+  - enricher returns action for unknown id → skipped
+- Test `update()` with changed content → `updated_at` bumped, embedding recomputed
+- Test `delete()` on non-existent id → graceful (no raise)
+
+### T4 — provider.py lifecycle paths
+- Test `on_session_end` with `auto_maintain=true` + `ingest_llm=true` → `run_maintenance` called, logged
+- Test `on_session_end` with maintenance raising → exception logged, not propagated
+- Test `shutdown` writer-thread close (regression: no SQLite thread-affinity crash)
+- Test prefetch guards: `auto_recall=false`, `mode=tools`, shutdown flag → no prefetch
+
+### T5 — coverage gate
+- Add `--cov-fail-under=90` to CI workflow + `Makefile`/`pyproject` pytest config
+- Verify `pytest -q --cov=luminary_memory` ≥ 90% locally
+
+---
+
+## Phase 2 — Health score (T6–T8)
+
+### T6 — `health_score()` API in `api.py`
+
+```python
+def health_score(self) -> dict:
+    """Store health report: overall 0-100 + per-dimension breakdown."""
+```
+
+Dimensions (computed from existing store data — no new schema):
+
+| Dimension | Weight | Signal |
+|-----------|--------|--------|
+| `duplicate_rate` | 25% | % memories with a near-dupe (Jaccard > 0.85) — lower better |
+| `staleness` | 25% | % memories not accessed in 30d (decayed) — lower better |
+| `importance` | 20% | % memories above `prune_min_importance` — higher better |
+| `density` | 15% | memories with graph relations / total — higher better |
+| `size` | 15% | store size vs `token_budget` scale (0 = empty, 100 = healthy volume) |
+
+Score = weighted sum. Returns:
+
+```python
+{
+  "score": 87.5,
+  "dimensions": {
+    "duplicate_rate": {"value": 0.02, "weight": 0.25, "health": 98.0},
+    "staleness": {...}, "importance": {...}, "density": {...}, "size": {...}
+  },
+  "recommendations": ["2 stale memories older than 30d — run lifecycle prune"]
+}
+```
+
+`recommendations` — generated from low-scoring dimensions (≤70):
+- duplicates → "run lifecycle consolidate"
+- stale → "run lifecycle prune or LLM maintenance"
+- low importance → "raise prune_min_importance or review store"
+
+### T7 — CLI `health` subcommand
+
+```bash
+luminary-memory health --json
+luminary-memory health
+# 📊 Memory Health: 87.5/100
+#   • Duplicates: 2.0% ✅
+#   • Stale (>30d): 4.0% ✅
+#   • Importance: 92% ✅
+#   • Graph density: 33% ⚠️
+#   • Size: 60% ✅
+#   → 2 stale memories — run `luminary-memory lifecycle`
+```
+
+### T8 — health score tests + docs
+
+- Test: empty store → score 0? or 100? (decide: empty store = 100 "nothing wrong" — document)
+- Test: all duplicates → low duplicate_rate dimension
+- Test: all stale → low staleness dimension
+- Test: healthy mixed store → score ≥ 80
+- Test CLI `health` output shape (`--json` parseable)
+- Docs: `docs/lifecycle.md` + README (health section), CHANGELOG entry
+
+---
+
+## Definition of Done (v0.2.4)
+
+- [ ] `pytest -q` green (≥90% coverage, CI gate)
+- [ ] `ruff check src tests` clean
+- [ ] CLI smoke: `luminary-memory health` + `--json`
+- [ ] Health score verified against real store (`~/.hermes/luminary/memory.db`)
+- [ ] CHANGELOG 0.2.4 entry
+- [ ] Version bumped to 0.2.4
+- [ ] Tag + GitHub release + PyPI upload (auto-publish)

luminary_memory-0.2.4/README.md

@@ -0,0 +1,142 @@
+# 🌙 luminary-memory
+
+**A lightweight, self-hosted memory layer for AI agents.**
+
+[![PyPI version](https://img.shields.io/pypi/v/luminary-memory?color=8ab4e8&label=PyPI)](https://pypi.org/project/luminary-memory)
+[![Python](https://img.shields.io/pypi/pyversions/luminary-memory?color=8ab4e8)](https://pypi.org/project/luminary-memory)
+[![License](https://img.shields.io/github/license/alertxsto/luminary-memory?color=8ab4e8)](LICENSE)
+[![CI](https://img.shields.io/github/actions/workflow/status/alertxsto/luminary-memory/ci.yml?color=8ab4e8&label=CI)](https://github.com/alertxsto/luminary-memory/actions)
+[![Tests](https://img.shields.io/badge/tests-168%20passing-8ab4e8)](https://github.com/alertxsto/luminary-memory/actions)
+[![Coverage](https://img.shields.io/badge/coverage-85%25-8ab4e8)](https://github.com/alertxsto/luminary-memory)
+[![Stars](https://img.shields.io/github/stars/alertxsto/luminary-memory?color=8ab4e8)](https://github.com/alertxsto/luminary-memory)
+
+**Self-hosted · Private · Budget-aware · Self-maintaining**
+
+---
+
+## What your agent remembers is what it becomes.
+
+Agents are only as good as what they remember. A stateless agent re-learns the same context every session — paying the same tokens, making the same mistakes. luminary-memory closes that gap with a local memory store that persists between runs, retrieves the right context on demand, and keeps itself tidy over time.
+
+**Four retrieval strategies. One fused answer. Zero cloud.**
+
+- **Semantic** — ONNX embeddings (384-dim, CPU, no GPU needed)
+- **Keyword** — FTS5 BM25 (SQLite, zero config)
+- **Temporal** — recency decay × access count
+- **Graph** — entity co-occurrence with automatic curation
+
+Strategies run in parallel and fuse via **Reciprocal Rank Fusion (k=60)** → **Jaccard deduplication (0.85)** → **token budget (4096)**.
+
+---
+
+## Quickstart
+
+```bash
+pip install luminary-memory
+```
+
+```python
+from luminary_memory import MemoryClient
+
+client = MemoryClient(db_path="memory.db")
+
+# store a durable fact
+client.ingest("The deploy target is the staging cluster", tags=["deploy", "infra"])
+
+# recall — four strategies fused into one ranked answer
+result = client.recall("where do we deploy?")
+for memory, score in zip(result.memories, result.scores):
+    print(f"{score:.3f}  {memory.content}")
+# → 0.942  The deploy target is the staging cluster
+```
+
+```bash
+# CLI
+luminary-memory add "deploy target is staging" --tags deploy
+luminary-memory recall "where do we deploy?" --json
+luminary-memory list
+luminary-memory lifecycle
+luminary-memory stats
+```
+
+---
+
+## Hermes Agent — first-class memory provider
+
+Drop-in. Install the provider with `pip install "luminary-memory[hermes]"`, then add
+`memory.provider: luminary` to your Hermes config. That's it.
+
+From the next session: **auto-recall** injects relevant memories every turn,
+**auto-save** persists completed turns, and the model can call
+`luminary_recall` / `luminary_ingest` / `luminary_list` on demand.
+
+Two optional LLM-powered features keep the store sharp:
+
+- **`ingest_llm`** — evaluates every turn before saving: drops chit-chat, stores factual summaries instead of raw transcripts.
+- **`auto_maintain`** — reviews the store at session end: keeps current facts, updates changed ones, deletes stale or duplicate ones.
+
+18 settings are exposed in the [Hermes dashboard](https://alertxsto.github.io/luminary-memory) for zero-hassle tuning. See
+[hermes/README.md](hermes/README.md) for the one-shot installer and full configuration.
+
+---
+
+## Configuration
+
+Every setting has a `LUMINARY_*` env var or a `Settings` object.
+
+| Setting | Env var | Default |
+|---------|---------|---------|
+| `backend` | `LUMINARY_BACKEND` | `sqlite` |
+| `db_path` | `LUMINARY_DB_PATH` | `luminary_memory.db` |
+| `pg_dsn` | `LUMINARY_PG_DSN` | — (pgvector only) |
+| `embedding_model` | `LUMINARY_EMBEDDING_MODEL` | `BAAI/bge-small-en-v1.5` |
+| `embedding_dim` | `LUMINARY_EMBEDDING_DIM` | `384` |
+| `ingest_llm` | `LUMINARY_INGEST_LLM` | `false` |
+| `rrf_k` | `LUMINARY_RRF_K` | `60` |
+| `dedup_jaccard_threshold` | `LUMINARY_DEDUP_JACCARD_THRESHOLD` | `0.85` |
+| `token_budget` | `LUMINARY_TOKEN_BUDGET` | `4096` |
+| `ttl_default_seconds` | `LUMINARY_TTL_DEFAULT_SECONDS` | `null` |
+| `prune_min_importance` | `LUMINARY_PRUNE_MIN_IMPORTANCE` | `0.2` |
+| `consolidate_jaccard_threshold` | `LUMINARY_CONSOLIDATE_JACCARD_THRESHOLD` | `0.9` |
+
+See [hermes/SKILL.md](hermes/SKILL.md) for the full provider config table (18 settings).
+
+---
+
+## Architecture
+
+```
+ingest(text) ──► whitelist filter ──► (LLM curation) ──► embed ──► SQLite / pgvector
+
+recall(query) ──► semantic │ keyword │ temporal │ graph
+               ──► RRF fusion ──► Jaccard dedup ──► token budget ──► ranked results
+
+lifecycle() ──► cleanup (TTL) ──► consolidate (near-dupes) ──► prune (low-value)
+
+maintenance() ──► LLM reviews store ──► keep │ update │ delete stale facts
+```
+
+Built-in lifecycle keeps the store lean. LLM maintenance (optional) keeps it accurate. `health_score()` gives you a 0-100 checkup with actionable recommendations.
+
+---
+
+## Documentation
+
+| Section | |
+|---------|-----|
+| [Quickstart](docs/quickstart.md) | Install and first use |
+| [Architecture](docs/architecture.md) | Pipelines and data flow |
+| [Python API](docs/api.md) | `MemoryClient` reference |
+| [CLI](docs/cli.md) | All subcommands |
+| [Recall](docs/recall.md) | Four strategies + fusion |
+| [Lifecycle](docs/lifecycle.md) | Cleanup, consolidation, pruning, LLM maintenance |
+| [Backends](docs/backends.md) | SQLite vs pgvector |
+| [Hermes integration](docs/hermes-integration.md) | Provider, config, installer |
+| [Roadmap](ROADMAP.md) | v0.2.3 → v1.0.0 |
+| [Benchmarks](benchmarks/RESULTS.md) | 230 ms recall @ 5k, 0 LLM tokens |
+
+---
+
+## License
+
+[Apache-2.0](LICENSE) © 2026 Dwiky Candra

{luminary_memory-0.2.3 → luminary_memory-0.2.4}/docs/lifecycle.md

@@ -55,6 +55,42 @@ every session end:
 Results are recorded in the transparency log
 (`~/.hermes/luminary/luminary.log`): `maintenance {'reviewed': N, 'deleted': N, 'updated': N}`.
 
+## `health_score()` — store health report (v0.2.4+)
+
+Returns a 0-100 health score with a per-dimension breakdown, computed from
+existing store data (no new schema):
+
+| Dimension | Weight | What it measures |
+|-----------|--------|------------------|
+| `duplicate_rate` | 25% | Share of memories with a near-duplicate (Jaccard > threshold) |
+| `staleness` | 25% | Share of memories not accessed in 30 days |
+| `importance` | 20% | Share of memories above `prune_min_importance` |
+| `density` | 15% | Share of memories with graph relations |
+| `size` | 15% | Store volume (scales toward 100 at ~1k memories) |
+
+```python
+report = client.health_score()
+print(report["score"])            # 87.5
+print(report["recommendations"])  # actionable hints
+```
+
+CLI:
+
+```bash
+luminary-memory health           # human-readable bar
+luminary-memory health --json    # raw JSON
+```
+
+```
+📊 Memory Health: 87.5/100 █████████░
+  ✅ duplicate_rate: 98%
+  ⚠️ density: 33%
+  → 2 stale memories (>30d) — run lifecycle prune or LLM maintenance
+```
+
+Empty store scores 100 (nothing wrong); low-scoring dimensions produce
+recommendations.
+
 ## Scheduling
 
 Run via cron for a self-maintaining store:

{luminary_memory-0.2.3 → luminary_memory-0.2.4}/hermes/hooks/luminary-activity/handler.py

@@ -27,6 +27,16 @@ DB_PATH = os.getenv(
 )
 LOG_FILE = Path.home() / ".hermes" / "hooks" / "luminary-activity" / "hook.log"
 LOG_FILE.parent.mkdir(parents=True, exist_ok=True)
+STATE_FILE = LOG_FILE.parent / "state.json"
+
+def _last_shown_id() -> int:
+    try:
+        return int(json.loads(STATE_FILE.read_text())["last_id"])
+    except Exception:
+        return 0
+
+def _set_last_shown_id(mid: int) -> None:
+    STATE_FILE.write_text(json.dumps({"last_id": mid}))
 logging.basicConfig(
     filename=str(LOG_FILE), level=logging.INFO,
     format="%(asctime)s %(levelname)s %(message)s",
@@ -53,40 +63,43 @@ def _post(text: str) -> None:
 
 
 def _recent_activity(seconds: int = 30) -> str | None:
-    """Return a compact status line if the store was active recently."""
+    """Return a status line for *new* memories since last post (no repeats)."""
     if not Path(DB_PATH).exists():
         return None
     try:
         conn = sqlite3.connect(f"file:{DB_PATH}?mode=ro", uri=True)
         conn.row_factory = sqlite3.Row
-        cutoff = int(time.time()) - seconds
-        # created recently (recall updates last_accessed_at, ingest inserts new)
-        row = conn.execute(
-            "SELECT COUNT(*) AS n, "
-            "MAX(CASE WHEN strftime('%s', created_at) > ? THEN 1 ELSE 0 END) AS new_mem "
-            "FROM memories",
-            (cutoff,),
-        ).fetchone()
-        n = int(row["n"] or 0)
-        new_mem = bool(row["new_mem"])
-        if n == 0:
-            conn.close()
-            return None
-        label = "stored" if new_mem else "recalled"
-        noun = "memory" if n == 1 else "memories"
-        lines = [f"🌙 Luminary — {n} {noun} {label}"]
-        # Show the content of newly stored facts (transparency).
-        if new_mem:
+        last_id = _last_shown_id()
+        # First run after fix: only show the single newest to avoid spamming history
+        if last_id == 0:
+            row = conn.execute("SELECT MAX(id) as max_id FROM memories").fetchone()
+            max_id = int(row["max_id"] or 0)
+            if max_id == 0:
+                conn.close()
+                return None
+            new_rows = conn.execute(
+                "SELECT id, content FROM memories WHERE id = ?",
+                (max_id,),
+            ).fetchall()
+        else:
             new_rows = conn.execute(
-                "SELECT content FROM memories "
-                "WHERE strftime('%s', created_at) > ? "
-                "ORDER BY id DESC LIMIT 3",
-                (cutoff,),
+                "SELECT id, content FROM memories WHERE id > ? ORDER BY id ASC LIMIT 3",
+                (last_id,),
             ).fetchall()
-            for r in new_rows:
-                content = str(r["content"] or "").replace("\n", " ")[:90]
-                if content:
-                    lines.append(f"  • {content}")
+            if not new_rows:
+                conn.close()
+                return None
+        n_new = len(new_rows)
+        noun = "memory" if n_new == 1 else "memories"
+        lines = [f"🌙 Luminary — {n_new} {noun} stored"]
+        for r in new_rows:
+            content = str(r["content"] or "").replace("\n", " ").strip()
+            if len(content) > 120:
+                content = content[:120].rsplit(" ", 1)[0] + "…"
+            if content:
+                lines.append(f"  • {content}")
+        max_shown = max(int(r["id"]) for r in new_rows)
+        _set_last_shown_id(max_shown)
         conn.close()
         return "\n".join(lines)
     except Exception:

{luminary_memory-0.2.3 → luminary_memory-0.2.4}/hermes/install.sh

@@ -55,27 +55,33 @@ if [ "$DO_PROVIDER" -eq 1 ]; then
     log "no config.yaml found — creating minimal config with memory.provider"
     mkdir -p "$HERMES_HOME"
     printf 'memory:\n  provider: luminary\n' > "$CONFIG"
-  elif grep -q "provider:" "$CONFIG"; then
-    log "memory.provider already set — skipping config edit"
   else
-    log "enabling memory.provider = luminary ..."
-    # Insert under the memory: section if present, else append a memory block.
-    if [ -f "$CONFIG" ] && grep -q "^memory:" "$CONFIG"; then
-      python3 - "$CONFIG" <<'PY'
+    # Use Python to inspect ONLY the ^memory: block — never match a
+    # `provider:` line elsewhere (e.g. provider: command-code in the
+    # models section), which would wrongly skip the edit.
+    python3 - "$CONFIG" <<'PY'
 import re, sys
 p = sys.argv[1]
 s = open(p).read()
-if re.search(r"(?m)^memory:\s*$", s) and "provider:" not in s.split("memory:")[1].split("\n\n")[0]:
-    s = s.replace("memory:", "memory:\n    provider: luminary", 1)
-    open(p, "w").write(s)
-    print("  inserted memory.provider under existing memory: block")
+
+def memory_block(text):
+    m = re.search(r"(?m)^memory:\s*(.*?)(?=^\S|\Z)", text, re.S)
+    return m.group(1) if m else ""
+
+block = memory_block(s)
+if "provider:" in block:
+    print("memory.provider already set in memory: block — skipping")
+    raise SystemExit(0)
+
+if re.search(r"(?m)^memory:\s*$", s):
+    # memory: block exists but has no provider — insert under it
+    s = re.sub(r"(?m)^memory:\s*$", "memory:\n  provider: luminary", s, count=1)
+    print("inserted memory.provider under existing memory: block")
 else:
-    print("  memory block unchanged (provider may already exist)")
+    s += "\nmemory:\n  provider: luminary\n"
+    print("appended memory: block to config.yaml")
+open(p, "w").write(s)
 PY
-    else
-      printf '\nmemory:\n  provider: luminary\n' >> "$CONFIG"
-      log "appended memory: block to config.yaml"
-    fi
   fi
 fi
 

{luminary_memory-0.2.3 → luminary_memory-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "luminary-memory"
-version = "0.2.3"
+version = "0.2.4"
 description = "A lightweight, self-hosted memory layer for AI agents"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{luminary_memory-0.2.3 → luminary_memory-0.2.4}/src/luminary_memory/__init__.py

@@ -1,4 +1,4 @@
 from luminary_memory.api import MemoryClient
 
-__version__ = "0.2.3"
+__version__ = "0.2.4"
 __all__ = ["MemoryClient", "__version__"]