memor-cli 0.2.0__tar.gz → 0.4.0__tar.gz

{memor_cli-0.2.0/memor_cli.egg-info → memor_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memor-cli
-Version: 0.2.0
+Version: 0.4.0
 Summary: Measured memory for coding agents. Fire and forget — no API keys needed.
 Author-email: Nimit Bhandari <nimitbhandari17@gmail.com>
 License-Expression: MIT
@@ -46,7 +46,7 @@ Dynamic: license-file
 ```
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-153%20passing-brightgreen.svg)]()
+[![Tests](https://img.shields.io/badge/tests-215%20passing-brightgreen.svg)]()
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memor-cli.svg)](https://pypi.org/project/memor-cli/)
 
@@ -65,7 +65,10 @@ pipx install memor-cli
 # Install the Claude Code hook + download embedding model (~60MB)
 memor install-hook
 
-# Start the background daemon
+# Start as a background service (macOS/Linux)
+memor service install
+
+# Or run in the foreground
 memor daemon
 ```
 
@@ -92,7 +95,13 @@ memor dashboard
   Embed query locally (model2vec, ~2ms)
       |
       v
-  Hybrid scoring: similarity + recency + kind weight + quality
+  Hybrid retrieval: dense vectors + lexical BM25, fused (RRF)
+      |
+      v
+  Relevance gate drops off-topic matches (inject nothing if nothing fits)
+      |
+      v
+  Rank: similarity + recency + kind weight + quality
       |
       v
   Inject relevant context into prompt
@@ -104,20 +113,31 @@ memor dashboard
 
 **Two background processes:**
 
-1. **Daemon** — polls `~/.claude/projects/` for transcripts, embeds chunks, runs distillation, analyzes feedback, compacts duplicates. All local.
+1. **Daemon** — polls `~/.claude/projects/` for transcripts, embeds chunks, runs distillation, analyzes feedback, compacts duplicates, tracks session-level token usage. All local.
 2. **Hook** — fires on every prompt, recalls relevant memories, injects them as context. Sub-15ms.
 
 **No API keys required.** Embeddings run locally via [model2vec](https://github.com/MinishLab/model2vec) (potion-base-8M, 256-dim). Vectors stored in [sqlite-vec](https://github.com/asg017/sqlite-vec). Everything runs on your machine.
 
 ---
 
-## Hybrid Scoring
+## Hybrid Retrieval
+
+Memor retrieves over two channels and fuses them, so it catches both semantic matches and exact terms:
+
+- **Dense** — local vector similarity (model2vec) for semantic recall.
+- **Lexical** — SQLite FTS5 / BM25 over the raw text, to recover exact identifiers, error strings, and API names that static embeddings blur together.
+
+The two rankings are combined with **Reciprocal Rank Fusion (RRF)**. A **relevance gate** drops anti-correlated (off-topic) candidates *before* ranking, so an unrelated prompt injects nothing rather than the least-bad guess. The lexical channel only activates when the dense channel finds the query on-topic, preventing generic words from pulling in noise.
+
+> Tunable via `MEMOR_MIN_SIMILARITY` (relevance floor, default 0.0) and `MEMOR_MAX_TOKENS` (injection budget, default 1500).
+
+## Scoring
 
-Memor doesn't just match keywords. Each memory is scored by four signals:
+Surviving candidates are ranked by four signals:
 
 | Signal | Weight | How it works |
 |---|---|---|
-| **Semantic similarity** | 50% | Vector cosine distance between query and memory |
+| **Semantic similarity** | 50% | Dense + lexical relevance, fused via RRF |
 | **Recency** | 25% | Exponential decay with 14-day half-life — recent decisions rank higher |
 | **Kind weight** | 15% | Distilled memories (1.3x) rank above raw session chunks (1.0x) |
 | **Quality** | 10% | Bayesian score from implicit feedback — memories the agent actually uses rank higher |
@@ -147,10 +167,11 @@ Memories are automatically classified as `decision`, `bugfix`, `lesson`, `snippe
 memor dashboard
 ```
 
-Shows:
-- **Memory bank** — session chunks, distilled memories, projects tracked
-- **Context efficiency** — overhead %, recall precision, quality scores per session
-- **Per-project breakdown** — which projects have the most context
+Dark fintech-inspired UI showing:
+- **Hero metrics** — total memories, recall count, avg latency, coverage — with sparkline bars
+- **Daily recall activity** — stacked bar chart of hits vs misses over time
+- **Session efficiency** — real token savings measured from API usage data (avg tokens/turn with vs without recall)
+- **Per-project breakdown** — artifact counts, token totals, last activity
 - **Recent recalls** — every hook event with scores, latency, and status
 
 ---
@@ -162,6 +183,11 @@ memor help                           Print the full manual
 memor install-hook                   Install Claude Code hook + download model
 memor daemon                         Auto-ingest + distill (background watcher)
 memor dashboard                      Web dashboard on localhost:8420
+memor version                        Print installed version
+memor service install                Run daemon as background service (launchd/systemd)
+memor service stop                   Stop the background service
+memor service uninstall              Remove the background service
+memor service status                 Check if the service is running
 memor query <text>                   Search memories from the CLI
 memor reingest                       Wipe DB and re-ingest everything
 memor reingest --project <name>      Re-ingest only one project
@@ -193,16 +219,17 @@ memor/
 +-- feedback.py           Implicit feedback analyzer (usage detection)
 |
 +-- retrieve/
-|   +-- retriever.py      Hybrid scoring: similarity + recency + kind + quality
+|   +-- retriever.py      Hybrid retrieval (dense + BM25, RRF) + relevance gate + scoring
 |
 +-- store/
-|   +-- sqlite_store.py   SQLite + sqlite-vec (WAL mode, dimension safety)
+|   +-- sqlite_store.py   SQLite + sqlite-vec + FTS5 (WAL mode, dimension safety)
 |
 +-- embed/
 |   +-- local.py          model2vec (potion-base-8M, 256-dim, ~60MB)
 |   +-- api.py            OpenAI-compatible embedding API (optional)
 |   +-- fake.py           Deterministic SHA-256 embedder (tests)
 |
++-- service.py            Background service management (launchd/systemd)
 +-- dashboard/
 |   +-- server.py         FastAPI dashboard backend
 |   +-- static/index.html Self-contained dashboard (no CDN deps)
@@ -227,7 +254,7 @@ skill/recall.py            Standalone recall script
 **Nothing leaves your machine.** In the default configuration:
 
 - **No telemetry, no analytics, no phone-home.** Zero outbound network calls.
-- **Embeddings run locally** via model2vec ONNX (one-time model download from HuggingFace — no user data sent).
+- **Embeddings run locally** via model2vec static token embeddings — no inference runtime, no GPU (one-time model download from HuggingFace — no user data sent).
 - **Hook transport is a Unix socket** (`~/.memor/hook.sock`), not a network port.
 - **Dashboard binds localhost only.**
 
@@ -263,7 +290,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 153 tests
+pytest  # 215 tests
 ```
 
 ---

{memor_cli-0.2.0 → memor_cli-0.4.0}/README.md

@@ -9,7 +9,7 @@
 ```
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
-[![Tests](https://img.shields.io/badge/tests-153%20passing-brightgreen.svg)]()
+[![Tests](https://img.shields.io/badge/tests-215%20passing-brightgreen.svg)]()
 [![Python](https://img.shields.io/badge/python-3.11%2B-blue.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memor-cli.svg)](https://pypi.org/project/memor-cli/)
 
@@ -28,7 +28,10 @@ pipx install memor-cli
 # Install the Claude Code hook + download embedding model (~60MB)
 memor install-hook
 
-# Start the background daemon
+# Start as a background service (macOS/Linux)
+memor service install
+
+# Or run in the foreground
 memor daemon
 ```
 
@@ -55,7 +58,13 @@ memor dashboard
   Embed query locally (model2vec, ~2ms)
       |
       v
-  Hybrid scoring: similarity + recency + kind weight + quality
+  Hybrid retrieval: dense vectors + lexical BM25, fused (RRF)
+      |
+      v
+  Relevance gate drops off-topic matches (inject nothing if nothing fits)
+      |
+      v
+  Rank: similarity + recency + kind weight + quality
       |
       v
   Inject relevant context into prompt
@@ -67,20 +76,31 @@ memor dashboard
 
 **Two background processes:**
 
-1. **Daemon** — polls `~/.claude/projects/` for transcripts, embeds chunks, runs distillation, analyzes feedback, compacts duplicates. All local.
+1. **Daemon** — polls `~/.claude/projects/` for transcripts, embeds chunks, runs distillation, analyzes feedback, compacts duplicates, tracks session-level token usage. All local.
 2. **Hook** — fires on every prompt, recalls relevant memories, injects them as context. Sub-15ms.
 
 **No API keys required.** Embeddings run locally via [model2vec](https://github.com/MinishLab/model2vec) (potion-base-8M, 256-dim). Vectors stored in [sqlite-vec](https://github.com/asg017/sqlite-vec). Everything runs on your machine.
 
 ---
 
-## Hybrid Scoring
+## Hybrid Retrieval
+
+Memor retrieves over two channels and fuses them, so it catches both semantic matches and exact terms:
+
+- **Dense** — local vector similarity (model2vec) for semantic recall.
+- **Lexical** — SQLite FTS5 / BM25 over the raw text, to recover exact identifiers, error strings, and API names that static embeddings blur together.
+
+The two rankings are combined with **Reciprocal Rank Fusion (RRF)**. A **relevance gate** drops anti-correlated (off-topic) candidates *before* ranking, so an unrelated prompt injects nothing rather than the least-bad guess. The lexical channel only activates when the dense channel finds the query on-topic, preventing generic words from pulling in noise.
+
+> Tunable via `MEMOR_MIN_SIMILARITY` (relevance floor, default 0.0) and `MEMOR_MAX_TOKENS` (injection budget, default 1500).
+
+## Scoring
 
-Memor doesn't just match keywords. Each memory is scored by four signals:
+Surviving candidates are ranked by four signals:
 
 | Signal | Weight | How it works |
 |---|---|---|
-| **Semantic similarity** | 50% | Vector cosine distance between query and memory |
+| **Semantic similarity** | 50% | Dense + lexical relevance, fused via RRF |
 | **Recency** | 25% | Exponential decay with 14-day half-life — recent decisions rank higher |
 | **Kind weight** | 15% | Distilled memories (1.3x) rank above raw session chunks (1.0x) |
 | **Quality** | 10% | Bayesian score from implicit feedback — memories the agent actually uses rank higher |
@@ -110,10 +130,11 @@ Memories are automatically classified as `decision`, `bugfix`, `lesson`, `snippe
 memor dashboard
 ```
 
-Shows:
-- **Memory bank** — session chunks, distilled memories, projects tracked
-- **Context efficiency** — overhead %, recall precision, quality scores per session
-- **Per-project breakdown** — which projects have the most context
+Dark fintech-inspired UI showing:
+- **Hero metrics** — total memories, recall count, avg latency, coverage — with sparkline bars
+- **Daily recall activity** — stacked bar chart of hits vs misses over time
+- **Session efficiency** — real token savings measured from API usage data (avg tokens/turn with vs without recall)
+- **Per-project breakdown** — artifact counts, token totals, last activity
 - **Recent recalls** — every hook event with scores, latency, and status
 
 ---
@@ -125,6 +146,11 @@ memor help                           Print the full manual
 memor install-hook                   Install Claude Code hook + download model
 memor daemon                         Auto-ingest + distill (background watcher)
 memor dashboard                      Web dashboard on localhost:8420
+memor version                        Print installed version
+memor service install                Run daemon as background service (launchd/systemd)
+memor service stop                   Stop the background service
+memor service uninstall              Remove the background service
+memor service status                 Check if the service is running
 memor query <text>                   Search memories from the CLI
 memor reingest                       Wipe DB and re-ingest everything
 memor reingest --project <name>      Re-ingest only one project
@@ -156,16 +182,17 @@ memor/
 +-- feedback.py           Implicit feedback analyzer (usage detection)
 |
 +-- retrieve/
-|   +-- retriever.py      Hybrid scoring: similarity + recency + kind + quality
+|   +-- retriever.py      Hybrid retrieval (dense + BM25, RRF) + relevance gate + scoring
 |
 +-- store/
-|   +-- sqlite_store.py   SQLite + sqlite-vec (WAL mode, dimension safety)
+|   +-- sqlite_store.py   SQLite + sqlite-vec + FTS5 (WAL mode, dimension safety)
 |
 +-- embed/
 |   +-- local.py          model2vec (potion-base-8M, 256-dim, ~60MB)
 |   +-- api.py            OpenAI-compatible embedding API (optional)
 |   +-- fake.py           Deterministic SHA-256 embedder (tests)
 |
++-- service.py            Background service management (launchd/systemd)
 +-- dashboard/
 |   +-- server.py         FastAPI dashboard backend
 |   +-- static/index.html Self-contained dashboard (no CDN deps)
@@ -190,7 +217,7 @@ skill/recall.py            Standalone recall script
 **Nothing leaves your machine.** In the default configuration:
 
 - **No telemetry, no analytics, no phone-home.** Zero outbound network calls.
-- **Embeddings run locally** via model2vec ONNX (one-time model download from HuggingFace — no user data sent).
+- **Embeddings run locally** via model2vec static token embeddings — no inference runtime, no GPU (one-time model download from HuggingFace — no user data sent).
 - **Hook transport is a Unix socket** (`~/.memor/hook.sock`), not a network port.
 - **Dashboard binds localhost only.**
 
@@ -226,7 +253,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 153 tests
+pytest  # 215 tests
 ```
 
 ---

memor_cli-0.4.0/memor/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

{memor_cli-0.2.0 → memor_cli-0.4.0}/memor/daemon.py

@@ -146,7 +146,7 @@ def distill_new_sessions(
     return distilled
 
 
-COMPACT_SIM_THRESHOLD = 0.90
+COMPACT_SIM_THRESHOLD = 0.85
 
 
 def compact_memories(store: SqliteStore, embedder) -> int:
@@ -239,12 +239,34 @@ def run_poll_cycle(
         for path, project in pending:
             session_id = path.stem
             try:
-                used = analyze_session_feedback(store, session_id, path)
+                used = analyze_session_feedback(store, session_id, path, embedder=embedder)
                 if used > 0:
                     print(f"  feedback: {used} memories confirmed used in {session_id[:12]}...")
             except Exception:
                 pass
 
+    # Turn-level metrics: parse tool calls per turn, correlate with recalls
+    if new_ingested:
+        from memor.turn_metrics import parse_turn_metrics, correlate_with_recalls
+        for path, project in pending:
+            session_id = path.stem
+            try:
+                metrics = parse_turn_metrics(path, session_id)
+                if metrics:
+                    metrics = correlate_with_recalls(metrics, store, session_id)
+                    store.save_turn_metrics(session_id, project, metrics)
+            except Exception:
+                pass
+
+    # Soft quality decay: unused memories lose quality over time
+    if new_ingested:
+        try:
+            decayed = store.decay_quality(stale_days=14, factor=0.5, deactivate_floor=0.03)
+            if decayed > 0:
+                print(f"  decayed quality for {decayed} stale memories")
+        except Exception:
+            pass
+
     # Compact near-duplicate memories (run occasionally, not every cycle)
     if new_ingested:
         try:

{memor_cli-0.2.0 → memor_cli-0.4.0}/memor/dashboard/server.py

@@ -134,6 +134,11 @@ def create_app(db_path: str | None = None) -> FastAPI:
         """, (f"-{days}",)).fetchall()
         return [dict(r) for r in rows]
 
+    @app.get("/api/roi")
+    def roi(project: str | None = Query(None)):
+        store = _store()
+        return store.get_token_roi(project=project)
+
     @app.get("/api/health")
     def health():
         store = _store()

{memor_cli-0.2.0 → memor_cli-0.4.0}/memor/dashboard/static/index.html

@@ -410,9 +410,9 @@
             <div class="side-stat-sub" id="e-avg-input-sub">across all sessions</div>
           </div>
           <div class="side-stat">
-            <div class="side-stat-label">Recall Precision</div>
-            <div class="side-stat-value" id="e-precision">&ndash;</div>
-            <div class="side-stat-sub">% of prompts with relevant context</div>
+            <div class="side-stat-label">Recall Coverage</div>
+            <div class="side-stat-value" id="e-coverage">&ndash;</div>
+            <div class="side-stat-sub">% of prompts where context was injected</div>
           </div>
           <div class="side-stat">
             <div class="side-stat-label">Avg Latency</div>
@@ -426,6 +426,32 @@
           </div>
         </div>
       </div>
+      <div class="chart-card">
+        <div class="chart-header">
+          <div class="chart-title">Token ROI</div>
+        </div>
+        <div id="roi-banner" style="display:none;background:var(--ok-dim);border:1px solid rgba(61,214,140,0.2);border-radius:var(--radius-sm);padding:12px 14px;margin-bottom:14px;">
+          <div style="font-size:22px;font-weight:700;color:var(--ok);letter-spacing:-0.5px;" id="roi-value">&ndash;</div>
+          <div style="font-size:11px;color:var(--text-muted);margin-top:2px;" id="roi-desc">fewer tool calls when Memor injects context</div>
+        </div>
+        <div class="side-stats" id="roi-side">
+          <div class="side-stat">
+            <div class="side-stat-label">Avg Tools / Turn (with recall)</div>
+            <div class="side-stat-value" id="roi-tools-with">&ndash;</div>
+            <div class="side-stat-sub">when Memor injected context</div>
+          </div>
+          <div class="side-stat">
+            <div class="side-stat-label">Avg Tools / Turn (without)</div>
+            <div class="side-stat-value" id="roi-tools-without">&ndash;</div>
+            <div class="side-stat-sub">when no context was injected</div>
+          </div>
+          <div class="side-stat">
+            <div class="side-stat-label">Turns Measured</div>
+            <div class="side-stat-value" id="roi-turns">&ndash;</div>
+            <div class="side-stat-sub" id="roi-turns-sub">with vs. without recall</div>
+          </div>
+        </div>
+      </div>
     </div>
   </section>
 
@@ -581,7 +607,7 @@
 
   /* ── Efficiency ────────────────────────────────────────── */
   function renderEfficiency(data) {
-    document.getElementById('e-precision').textContent = fmtPct(data.precision * 100);
+    document.getElementById('e-coverage').textContent = fmtPct(data.coverage * 100);
   }
 
   function renderSessionEfficiency(data) {
@@ -781,6 +807,38 @@
       msg.innerHTML = 'Status: <strong>' + esc(status) + '</strong>. Run <code>memor help</code> for guidance.';
   }
 
+  /* ── ROI renderer ─────────────────────────────────────── */
+  function renderROI(data) {
+    document.getElementById('roi-tools-with').textContent = data.avg_tools_with_recall;
+    document.getElementById('roi-tools-without').textContent = data.avg_tools_without_recall;
+    document.getElementById('roi-turns').textContent =
+      (data.turns_with_recall + data.turns_without_recall).toLocaleString();
+    document.getElementById('roi-turns-sub').textContent =
+      data.turns_with_recall + ' with recall · ' + data.turns_without_recall + ' without';
+
+    var banner = document.getElementById('roi-banner');
+    var roiValue = document.getElementById('roi-value');
+    var roiDesc = document.getElementById('roi-desc');
+    banner.style.display = 'none';
+    banner.style.background = 'var(--ok-dim)';
+    banner.style.borderColor = 'rgba(61,214,140,0.2)';
+    roiValue.style.color = 'var(--ok)';
+    roiValue.textContent = '–';
+    roiDesc.textContent = 'fewer tool calls when Memor injects context';
+
+    if (data.tool_call_reduction_pct > 0 && data.turns_with_recall >= 5 && data.turns_without_recall >= 5) {
+      roiValue.textContent = data.tool_call_reduction_pct + '% fewer';
+      banner.style.display = 'block';
+    } else if (data.tool_call_reduction_pct < 0 && data.turns_with_recall >= 5) {
+      roiValue.textContent = Math.abs(data.tool_call_reduction_pct) + '% more';
+      roiValue.style.color = 'var(--warn)';
+      roiDesc.textContent = 'tool calls with recall — investigating...';
+      banner.style.display = 'block';
+      banner.style.background = 'var(--warn-dim)';
+      banner.style.borderColor = 'rgba(232,147,32,0.2)';
+    }
+  }
+
   /* ── Data loaders ──────────────────────────────────────── */
   async function loadSummary()    { try { renderSummary(await api('/api/summary')); } catch(e) { console.warn('summary',e); } }
   async function loadProjects()   { try { renderProjects(await api('/api/projects')); } catch(e) { console.warn('projects',e); } }
@@ -788,6 +846,7 @@
   async function loadSessionEfficiency() { try { renderSessionEfficiency(await api('/api/session-efficiency')); } catch(e) { console.warn('session-efficiency',e); } }
   async function loadHealth()     { try { renderHealth(await api('/api/health')); } catch(e) { console.warn('health',e); } }
   async function loadTrend()      { try { renderTrend(await api('/api/recall-trend?days=30')); } catch(e) { console.warn('trend',e); } }
+  async function loadROI()        { try { renderROI(await api('/api/roi')); } catch(e) { console.warn('roi',e); } }
   async function loadRecalls() {
     try {
       var url = '/api/recalls?limit=50' + (projectFilter ? '&project=' + encodeURIComponent(projectFilter) : '');
@@ -796,7 +855,7 @@
   }
 
   async function refresh() {
-    await Promise.allSettled([loadSummary(), loadProjects(), loadEfficiency(), loadSessionEfficiency(), loadHealth(), loadTrend(), loadRecalls()]);
+    await Promise.allSettled([loadSummary(), loadProjects(), loadEfficiency(), loadSessionEfficiency(), loadHealth(), loadTrend(), loadRecalls(), loadROI()]);
     document.getElementById('last-updated').textContent = new Date().toLocaleTimeString();
 
     renderMiniBars('mb-chunks', null);

{memor_cli-0.2.0 → memor_cli-0.4.0}/memor/distill/distiller.py

@@ -99,11 +99,14 @@ class ExtractiveDistiller:
     def distill_session(
         self, session_id: str, chunks: list[Artifact], project: str
     ) -> list[str]:
-        from memor.distill.extractive import classify_chunk
+        from memor.distill.extractive import classify_chunk, score_chunks, MIN_MEMORY_SIGNAL
         key_chunks = extract_key_chunks(chunks, self.embedder)
+        scores = score_chunks(key_chunks)
         created = max((c.created_at for c in chunks), default=0.0)
         new_ids: list[str] = []
-        for c in key_chunks:
+        for c, score in zip(key_chunks, scores):
+            if score < MIN_MEMORY_SIGNAL:
+                continue
             mem_type = classify_chunk(c.text)
             mid = _store_memory(self.store, self.embedder, c.text, mem_type,
                                 session_id, project, created, [c])

{memor_cli-0.2.0 → memor_cli-0.4.0}/memor/distill/extractive.py

@@ -132,13 +132,13 @@ def _cluster_select(chunks: list[Artifact], embedder, max_clusters: int) -> list
     return selected
 
 
-def extract_key_chunks(
-    chunks: list[Artifact], embedder, *, max_extracts: int = MAX_EXTRACTS
-) -> list[Artifact]:
-    """Select the highest-signal chunks from a session. Pure local, no LLM."""
+MIN_MEMORY_SIGNAL = 0.3
+
+
+def score_chunks(chunks: list[Artifact]) -> list[float]:
+    """Score each chunk by TF-IDF + heuristic. Returns parallel list of scores."""
     if not chunks:
         return []
-    # Score each chunk: TF-IDF + heuristic
     tfidf = _tfidf_scores(chunks)
     max_tf = max(tfidf) or 1.0
     combined = []
@@ -148,6 +148,16 @@ def extract_key_chunks(
             combined.append(-999.0)
             continue
         combined.append((tfidf[i] / max_tf) + h)
+    return combined
+
+
+def extract_key_chunks(
+    chunks: list[Artifact], embedder, *, max_extracts: int = MAX_EXTRACTS
+) -> list[Artifact]:
+    """Select the highest-signal chunks from a session. Pure local, no LLM."""
+    if not chunks:
+        return []
+    combined = score_chunks(chunks)
     # Pre-filter: drop anything scored below 0
     viable_idx = [i for i, s in enumerate(combined) if s > 0]
     if not viable_idx:

{memor_cli-0.2.0 → memor_cli-0.4.0}/memor/eval/runner.py

@@ -72,7 +72,8 @@ def run_ablation(*, query, project, relevant_ids, store, embedder, k=8):
                      "ndcg@k": ndcg_at_k(ids, relevant_ids, k)}
     return out
 
-def run_contradiction_eval(*, query, project, stale_id, current_id, store, embedder, k=8):
-    r = Retriever(store, embedder, k=k, edge_expand=True)
+def run_contradiction_eval(*, query, project, stale_id, current_id, store, embedder,
+                           k=8, min_similarity=0.0):
+    r = Retriever(store, embedder, k=k, edge_expand=True, min_similarity=min_similarity)
     ids = [h.artifact.id for h in r.query(query, Scope(project=project)).hits]
     return (current_id in ids) and (stale_id not in ids)

memor_cli-0.4.0/memor/feedback.py

@@ -0,0 +1,129 @@
+"""Feedback analyzer — detects whether recalled memories were used by the agent.
+
+After a session ends, cross-references recall_log with the transcript to see
+if the agent's responses referenced recalled content. Updates memory_quality
+scores accordingly.
+
+Two matching strategies:
+1. N-gram overlap (fast, catches verbatim reuse)
+2. Semantic similarity via embeddings (catches paraphrased reuse)
+"""
+from __future__ import annotations
+import json
+import math
+from pathlib import Path
+from memor.store.sqlite_store import SqliteStore
+
+_NGRAM_SIZE = 3
+_MIN_WORDS = 4
+_MATCH_RATIO = 0.10
+_SEMANTIC_SIM_THRESHOLD = 0.45
+
+
+def _extract_assistant_texts(transcript_path: Path) -> list[str]:
+    texts = []
+    for line in transcript_path.read_text().splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        try:
+            rec = json.loads(line)
+        except json.JSONDecodeError:
+            continue
+        if rec.get("type") != "assistant":
+            continue
+        msg = rec.get("message", {})
+        content = msg.get("content", "")
+        if isinstance(content, str):
+            texts.append(content.lower())
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict) and block.get("type") == "text":
+                    texts.append(block.get("text", "").lower())
+    return texts
+
+
+def _text_was_used(memory_text: str, assistant_texts: list[str]) -> bool:
+    words = memory_text.lower().split()
+    if len(words) < _MIN_WORDS:
+        return False
+    ngrams = []
+    for i in range(len(words) - _NGRAM_SIZE + 1):
+        ngrams.append(" ".join(words[i:i + _NGRAM_SIZE]))
+    if not ngrams:
+        return False
+    matches = 0
+    for phrase in ngrams:
+        for text in assistant_texts:
+            if phrase in text:
+                matches += 1
+                break
+    return matches >= max(1, math.ceil(len(ngrams) * _MATCH_RATIO))
+
+
+def _cosine(a: list[float], b: list[float]) -> float:
+    dot = sum(x * y for x, y in zip(a, b))
+    na = math.sqrt(sum(x * x for x in a))
+    nb = math.sqrt(sum(x * x for x in b))
+    return dot / (na * nb) if na and nb else 0.0
+
+
+def _semantic_match(memory_text: str, response_text: str, embedder) -> bool:
+    """Check if memory content appears in the response via embedding similarity.
+    Catches paraphrased reuse that n-gram matching misses."""
+    if len(memory_text.split()) < _MIN_WORDS:
+        return False
+    vecs = embedder.embed([memory_text, response_text])
+    return _cosine(vecs[0], vecs[1]) >= _SEMANTIC_SIM_THRESHOLD
+
+
+def analyze_session_feedback(
+    store: SqliteStore, session_id: str, transcript_path: Path,
+    *, embedder=None,
+) -> int:
+    recalled_ids = set()
+    rows = store.db.execute("""
+        SELECT q.artifact_id FROM memory_quality q
+        JOIN artifacts a ON a.id = q.artifact_id
+        WHERE a.active = 1
+          AND a.project = (
+              SELECT project FROM recall_log
+              WHERE session_id = ? AND hits_count > 0
+              LIMIT 1
+          )
+          AND q.last_recalled >= (
+              SELECT MIN(timestamp) FROM recall_log
+              WHERE session_id = ? AND hits_count > 0
+          )
+          AND q.last_recalled <= (
+              SELECT MAX(timestamp) FROM recall_log
+              WHERE session_id = ? AND hits_count > 0
+          ) + 5
+    """, (session_id, session_id, session_id)).fetchall()
+    for row in rows:
+        recalled_ids.add(row["artifact_id"])
+
+    if not recalled_ids:
+        return 0
+
+    assistant_texts = _extract_assistant_texts(transcript_path)
+    if not assistant_texts:
+        return 0
+
+    used_ids = []
+    combined_response = " ".join(assistant_texts) if embedder else ""
+    for aid in recalled_ids:
+        art = store.db.execute(
+            "SELECT text FROM artifacts WHERE id=?", (aid,)
+        ).fetchone()
+        if not art:
+            continue
+        if _text_was_used(art["text"], assistant_texts):
+            used_ids.append(aid)
+        elif embedder and _semantic_match(art["text"], combined_response, embedder):
+            used_ids.append(aid)
+
+    if used_ids:
+        store.record_usage(used_ids)
+
+    return len(used_ids)