memor-cli 0.3.0__tar.gz → 0.4.1__tar.gz

{memor_cli-0.3.0/memor_cli.egg-info → memor_cli-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memor-cli
-Version: 0.3.0
+Version: 0.4.1
 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-179%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/)
 
@@ -290,7 +290,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 179 tests
+pytest  # 215 tests
 ```
 
 ---

{memor_cli-0.3.0 → memor_cli-0.4.1}/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-179%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/)
 
@@ -253,7 +253,7 @@ cd memor-ai
 python3 -m venv .venv && source .venv/bin/activate
 pip install -e ".[dev]"
 
-pytest  # 179 tests
+pytest  # 215 tests
 ```
 
 ---

memor_cli-0.4.1/memor/__init__.py

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

{memor_cli-0.3.0 → memor_cli-0.4.1}/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.3.0 → memor_cli-0.4.1}/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.3.0 → memor_cli-0.4.1}/memor/dashboard/static/index.html

@@ -172,6 +172,7 @@
     background: var(--surface); border: 1px solid var(--border);
     border-radius: var(--radius); padding: 22px 24px;
     box-shadow: var(--card-shadow);
+    display: flex; flex-direction: column;
   }
   .chart-header {
     display: flex; align-items: center; justify-content: space-between;
@@ -199,7 +200,7 @@
 
   .bar-chart {
     display: flex; align-items: flex-end; gap: 4px;
-    height: 180px; padding-top: 8px;
+    flex: 1; min-height: 180px; padding-top: 8px;
     border-bottom: 1px solid var(--border-light);
   }
   .bar-group {
@@ -207,15 +208,16 @@
     align-items: center; gap: 0; height: 100%;
     justify-content: flex-end;
   }
-  .bar-stack { display: flex; flex-direction: column-reverse; gap: 1px; width: 100%; max-width: 22px; }
-  .bar-hits { background: var(--accent); border-radius: 2px 2px 0 0; min-height: 0; transition: height 0.3s; }
-  .bar-miss { background: var(--surface3); border-radius: 2px 2px 0 0; min-height: 0; transition: height 0.3s; }
+  .bar-stack { display: flex; flex-direction: column-reverse; gap: 2px; width: 100%; max-width: 28px; flex: 1; align-items: center; justify-content: flex-end; }
+  .bar-cell { width: 16px; height: 10px; border-radius: 2px; transition: opacity 0.3s; }
+  .bar-cell-hit { background: var(--accent); }
+  .bar-cell-miss { background: var(--surface3); }
   .bar-label {
     font-size: 9px; color: var(--text-muted); margin-top: 6px;
     text-align: center; white-space: nowrap;
   }
 
-  .bar-group:hover .bar-hits { background: #f0a030; }
+  .bar-group:hover .bar-cell-hit { background: #f0a030; }
   .bar-group { cursor: default; position: relative; }
   .bar-tooltip {
     display: none; position: absolute; bottom: calc(100% + 8px);
@@ -378,6 +380,33 @@
     </div>
   </section>
 
+  <!-- ── Token ROI hero ─────────────────────────────────── -->
+  <section>
+    <div class="chart-card" id="roi-card" style="display:none;">
+      <div style="display:flex;align-items:center;gap:20px;flex-wrap:wrap;">
+        <div>
+          <div class="chart-title" style="margin-bottom:4px;">Token ROI</div>
+          <div style="font-size:32px;font-weight:700;color:var(--ok);letter-spacing:-1px;" id="roi-value">&ndash;</div>
+          <div style="font-size:12px;color:var(--text-muted);margin-top:2px;" id="roi-desc">fewer tool calls when Memor injects context</div>
+        </div>
+        <div style="display:flex;gap:24px;flex:1;justify-content:flex-end;">
+          <div style="text-align:center;">
+            <div style="font-size:18px;font-weight:600;color:var(--text);" id="roi-tools-with">&ndash;</div>
+            <div style="font-size:10px;color:var(--text-muted);">avg tools/turn<br>with recall</div>
+          </div>
+          <div style="text-align:center;">
+            <div style="font-size:18px;font-weight:600;color:var(--text);" id="roi-tools-without">&ndash;</div>
+            <div style="font-size:10px;color:var(--text-muted);">avg tools/turn<br>without recall</div>
+          </div>
+          <div style="text-align:center;">
+            <div style="font-size:18px;font-weight:600;color:var(--text);" id="roi-turns">&ndash;</div>
+            <div style="font-size:10px;color:var(--text-muted);" id="roi-turns-sub">turns measured</div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </section>
+
   <!-- ── Recall trend chart ─────────────────────────────── -->
   <section>
     <div class="chart-grid">
@@ -513,7 +542,7 @@
   function badge(status) {
     var map = {
       ok:              ['badge-ok',        'Success'],
-      extractive_only: ['badge-extractive','Extractive'],
+      extractive_only: ['badge-extractive','No Distill'],
       no_hits:         ['badge-no_hits',   'No Hits'],
     };
     var m = map[status] || ['badge-no_hits', status];
@@ -643,21 +672,20 @@
     var recallsByDay = data.map(function(d) { return d.recalls; });
     renderMiniBars('mb-recalls', recallsByDay);
 
+    var maxCells = 30;
     data.forEach(function(d) {
-      var pct = (d.recalls / maxRecalls) * 100;
-      var hitPct = d.hits ? (d.hits / d.recalls) * 100 : 0;
-      var missPct = 100 - hitPct;
-      var hitH = Math.max(0, pct * hitPct / 100);
-      var missH = Math.max(0, pct * missPct / 100);
+      var totalCells = Math.max(1, Math.round((d.recalls / maxRecalls) * maxCells));
+      var hitCells = Math.round((d.hits / d.recalls) * totalCells);
+      var missCells = totalCells - hitCells;
 
       var dayStr = d.day.slice(5);
       var group = el('div', {class: 'bar-group'});
+      var cells = '';
+      for (var i = 0; i < hitCells; i++) cells += '<div class="bar-cell bar-cell-hit"></div>';
+      for (var i = 0; i < missCells; i++) cells += '<div class="bar-cell bar-cell-miss"></div>';
       group.innerHTML =
         '<div class="bar-tooltip">' + esc(d.day) + '<br>' + d.recalls + ' recalls · ' + (d.hits||0) + ' hits</div>' +
-        '<div class="bar-stack">' +
-          '<div class="bar-hits" style="height:' + hitH + '%"></div>' +
-          '<div class="bar-miss" style="height:' + missH + '%"></div>' +
-        '</div>' +
+        '<div class="bar-stack">' + cells + '</div>' +
         '<div class="bar-label">' + dayStr + '</div>';
       container.appendChild(group);
     });
@@ -699,7 +727,7 @@
       document.getElementById('th-col3').textContent = 'Avg Score';
       document.getElementById('th-col4').textContent = 'OK';
       document.getElementById('th-col5').textContent = 'No Hits';
-      document.getElementById('th-col6').textContent = 'Extractive';
+      document.getElementById('th-col6').textContent = 'No Distill';
     }
 
     sorted.forEach(function(row) {
@@ -781,6 +809,32 @@
       msg.innerHTML = 'Status: <strong>' + esc(status) + '</strong>. Run <code>memor help</code> for guidance.';
   }
 
+  /* ── ROI renderer ─────────────────────────────────────── */
+  function renderROI(data) {
+    var card = document.getElementById('roi-card');
+    var roiValue = document.getElementById('roi-value');
+    var roiDesc = document.getElementById('roi-desc');
+
+    document.getElementById('roi-tools-with').textContent = data.avg_tools_with_recall;
+    document.getElementById('roi-tools-without').textContent = data.avg_tools_without_recall;
+    var totalTurns = data.turns_with_recall + data.turns_without_recall;
+    document.getElementById('roi-turns').textContent = totalTurns.toLocaleString();
+    document.getElementById('roi-turns-sub').textContent =
+      data.turns_with_recall + ' with · ' + data.turns_without_recall + ' without';
+
+    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';
+      roiValue.style.color = 'var(--ok)';
+      roiDesc.textContent = 'fewer tool calls when Memor injects context';
+      card.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...';
+      card.style.display = 'block';
+    }
+  }
+
   /* ── 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 +842,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 +851,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.3.0 → memor_cli-0.4.1}/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.3.0 → memor_cli-0.4.1}/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.3.0 → memor_cli-0.4.1}/memor/feedback.py

@@ -2,7 +2,12 @@
 
 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."""
+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
@@ -12,6 +17,7 @@ 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]:
@@ -55,8 +61,25 @@ def _text_was_used(memory_text: str, assistant_texts: list[str]) -> bool:
     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
+    store: SqliteStore, session_id: str, transcript_path: Path,
+    *, embedder=None,
 ) -> int:
     recalled_ids = set()
     rows = store.db.execute("""
@@ -88,11 +111,16 @@ def analyze_session_feedback(
         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 art and _text_was_used(art["text"], assistant_texts):
+        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:

{memor_cli-0.3.0 → memor_cli-0.4.1}/memor/hook_server.py

@@ -11,19 +11,15 @@ SOCK_PATH = Path.home() / ".memor" / "hook.sock"
 PID_PATH = Path.home() / ".memor" / "hook.pid"
 DEFAULT_DB = str(Path.home() / ".memor" / "memor.db")
 IDLE_TIMEOUT_S = 600
-MIN_QUERY_WORDS = 10
-_TRIVIAL_PATTERNS = frozenset({
-    "yes", "no", "ok", "okay", "sure", "thanks", "thank you", "ty",
-    "looks good", "lgtm", "continue", "go ahead", "do it", "proceed",
-    "correct", "right", "yep", "yup", "nope", "agreed", "sounds good",
-    "perfect", "great", "nice", "cool", "done", "got it", "k",
-})
 
 _embedder = None
 _last_activity = 0.0
 _session_injected: dict[str, set[str]] = {}
 _MAX_TRACKED_SESSIONS = 50
 
+from memor.session_context import SessionContextWindow
+_session_ctx = SessionContextWindow(max_queries=5, max_sessions=_MAX_TRACKED_SESSIONS)
+
 _UNSET = object()  # sentinel for "auto-discover embedder"
 
 
@@ -62,9 +58,10 @@ def handle_request(req: dict, *, db_path: str = DEFAULT_DB,
             }
         }
 
-    query_stripped = query.strip().rstrip("?!.,").strip().lower()
-    query_word_count = len(query.split())
-    if query_word_count < MIN_QUERY_WORDS and query_stripped in _TRIVIAL_PATTERNS:
+    from memor.query_complexity import route_query, Tier
+
+    tier = route_query(query)
+    if tier == Tier.SKIP:
         msg = "Memor: skipped — trivial prompt"
         if Path(db_path).exists():
             try:
@@ -85,18 +82,23 @@ def handle_request(req: dict, *, db_path: str = DEFAULT_DB,
         }
 
     try:
-        max_tokens = max(0, int(os.environ.get("MEMOR_MAX_TOKENS", "1500")))
+        env_max = int(os.environ.get("MEMOR_MAX_TOKENS", "0"))
     except (ValueError, TypeError):
-        max_tokens = 1500
+        env_max = 0
+    max_tokens = env_max if env_max > 0 else tier.max_tokens
     try:
         min_similarity = float(os.environ.get("MEMOR_MIN_SIMILARITY", "0.0"))
     except (ValueError, TypeError):
         min_similarity = 0.0
+    retrieval_query = _session_ctx.enrich(query, session_id) if session_id else query
     already_injected = _session_injected.get(session_id, set()) if session_id else set()
-    result = recall(query, project, db_path, embedder=embedder, k=8, threshold=0.15,
-                    max_tokens=max_tokens, min_similarity=min_similarity,
+    result = recall(retrieval_query, project, db_path, embedder=embedder, k=tier.k,
+                    threshold=0.15, max_tokens=max_tokens, min_similarity=min_similarity,
                     exclude_ids=already_injected or None, session_id=session_id)
 
+    if session_id:
+        _session_ctx.record(session_id, query)
+
     if session_id and result.hit_ids:
         _session_injected.setdefault(session_id, set()).update(result.hit_ids)
         if len(_session_injected) > _MAX_TRACKED_SESSIONS:

memor_cli-0.4.1/memor/query_complexity.py

@@ -0,0 +1,92 @@
+"""Query complexity scoring and budget routing.
+
+Scores queries by word count, identifier density, path references, and
+question structure. Routes to budget tiers so trivial prompts skip recall,
+simple follow-ups get a light budget, and complex queries get full retrieval.
+"""
+from __future__ import annotations
+
+import enum
+import re
+
+_IDENTIFIER_RE = re.compile(
+    r"[A-Z][a-z]+[A-Z]"           # camelCase/PascalCase
+    r"|[a-z]+_[a-z]+"             # snake_case
+    r"|[A-Z]{2,}"                 # SCREAMING_CASE (min 2 chars)
+    r"|\b\w+\.\w+\.\w+"          # dotted.path.ref
+    r"|\w+::\w+"                  # C++ scope
+)
+
+_PATH_RE = re.compile(
+    r"[a-zA-Z0-9_\-]+/"           # path components with /
+    r"|\.\w{1,5}\b"               # file extensions (.py, .ts, .yml)
+)
+
+_QUESTION_RE = re.compile(r"\?\s*$")
+
+_ERROR_RE = re.compile(
+    r"(Error|Exception|Traceback|FAIL|panic|segfault|undefined|NaN|null|nil)\b",
+    re.I,
+)
+
+_TRIVIAL_PATTERNS = frozenset({
+    "yes", "no", "ok", "okay", "sure", "thanks", "thank you", "ty",
+    "looks good", "lgtm", "continue", "go ahead", "do it", "proceed",
+    "correct", "right", "yep", "yup", "nope", "agreed", "sounds good",
+    "perfect", "great", "nice", "cool", "done", "got it", "k",
+    "yes please", "no thanks",
+})
+
+
+class Tier(enum.Enum):
+    SKIP = (0, 0)
+    LIGHT = (4, 500)
+    FULL = (8, 1500)
+
+    def __init__(self, k: int, max_tokens: int):
+        self.k = k
+        self.max_tokens = max_tokens
+
+
+def score_query(query: str) -> float:
+    """Score query complexity on [0, 1]. Higher = more context needed."""
+    text = query.strip()
+    if not text:
+        return 0.0
+
+    normalized = text.rstrip("?!.,").strip().lower()
+    if normalized in _TRIVIAL_PATTERNS:
+        return 0.0
+
+    words = text.split()
+    n = len(words)
+
+    word_score = min(1.0, n * n / (n * n + 36))
+
+    id_matches = len(_IDENTIFIER_RE.findall(text))
+    id_score = min(id_matches / 3.0, 1.0)
+
+    path_matches = len(_PATH_RE.findall(text))
+    path_score = min(path_matches / 2.0, 1.0)
+
+    question_score = 0.1 if _QUESTION_RE.search(text) else 0.0
+    error_score = 0.15 if _ERROR_RE.search(text) else 0.0
+
+    raw = (
+        0.45 * word_score
+        + 0.20 * id_score
+        + 0.20 * path_score
+        + question_score
+        + error_score
+    )
+    return min(raw, 1.0)
+
+
+def route_query(query: str) -> Tier:
+    """Route a query to a retrieval budget tier based on its complexity."""
+    s = score_query(query)
+    if s < 0.05:
+        return Tier.SKIP
+    if s < 0.45:
+        return Tier.LIGHT
+    return Tier.FULL

memor_cli-0.4.1/memor/session_context.py

@@ -0,0 +1,42 @@
+"""Session context window — tracks recent queries per session to enrich
+sparse follow-up prompts with conversational context for retrieval.
+
+When a user types "try the other approach" after discussing OAuth2, the
+retriever gets the enriched query "implement OAuth2 PKCE flow ... try the
+other approach" instead of searching on 5 bare words.
+"""
+from __future__ import annotations
+
+from collections import OrderedDict
+
+from memor.query_complexity import score_query
+
+_SPARSE_THRESHOLD = 0.35
+
+
+class SessionContextWindow:
+    def __init__(self, *, max_queries: int = 5, max_sessions: int = 50):
+        self._max_queries = max_queries
+        self._max_sessions = max_sessions
+        self._windows: OrderedDict[str, list[str]] = OrderedDict()
+
+    def record(self, session_id: str, query: str) -> None:
+        if session_id not in self._windows:
+            if len(self._windows) >= self._max_sessions:
+                self._windows.popitem(last=False)
+            self._windows[session_id] = []
+        else:
+            self._windows.move_to_end(session_id)
+        buf = self._windows[session_id]
+        buf.append(query)
+        if len(buf) > self._max_queries:
+            del buf[0]
+
+    def enrich(self, query: str, session_id: str) -> str:
+        if score_query(query) >= _SPARSE_THRESHOLD:
+            return query
+        history = self._windows.get(session_id)
+        if not history:
+            return query
+        context = " | ".join(history[-2:])
+        return f"{context} | {query}"