nexo-brain 7.14.0 → 7.15.0

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.14.0",
+  "version": "7.15.0",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,9 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.14.0` is the current packaged-runtime line. Minor release over v7.13.9 — Brain closes the install/reliability loop with update-path venv recovery, platform-gated wheels, WSL Desktop-managed flag preservation, startup memory authority warnings, legacy MEMORY write blocking, post-action real-world verification, and stale followup triage.
+Version `7.15.0` is the current packaged-runtime line. Minor release over v7.14.0 — Brain unifies sent-email continuity across send paths, moves cognitive recall to multilingual embeddings, forces tagged learnings into context, hardens email loop guards and headless runners, exposes learning creation dates, and adds AUTO-N burst postmortems.
+
+Previously in `7.14.0`: minor release — Brain closes the install/reliability loop with update-path venv recovery, platform-gated wheels, WSL Desktop-managed flag preservation, startup memory authority warnings, legacy MEMORY write blocking, post-action real-world verification, and stale followup triage.
 
 Previously in `7.13.9`: patch release — Brain moves aside an existing managed `.venv` when it was created with unsupported Python <3.10, then recreates it with the supported interpreter prepared by Desktop.
 
@@ -383,7 +385,7 @@ That keeps the core Ebbinghaus model, but makes decay more individual and less p
 
 ### Semantic Search (Finding by Meaning)
 
-NEXO Brain doesn't search by keywords. It searches by **meaning** using vector embeddings (fastembed, 768 dimensions).
+NEXO Brain doesn't search by keywords. It searches by **meaning** using multilingual vector embeddings (fastembed, 384 dimensions).
 
 Example: If you search for "deploy problems", NEXO Brain will find a memory about "SSH connection timeout on production server" — even though they share zero words. This is how human associative memory works.
 
@@ -601,7 +603,7 @@ NEXO Brain was evaluated on [LoCoMo](https://github.com/snap-research/locomo) (A
 - 93.3% adversarial rejection rate — reliably says "I don't know" when information isn't available
 - 74.9% recall across 1,986 questions
 - Open-domain F1: 0.637 | Multi-hop F1: 0.333 | Temporal F1: 0.326
-- Runs on CPU with 768-dim embeddings (BAAI/bge-base-en-v1.5) — no GPU required
+- Runs on CPU with local multilingual embeddings — no GPU required
 - First MCP memory server benchmarked on a peer-reviewed dataset
 
 Full results in [`benchmarks/locomo/results/`](benchmarks/locomo/results/).
@@ -1447,7 +1449,7 @@ See [benchmarks/results/memory-recall-vs-static.md](benchmarks/results/memory-re
 
 ### v0.9.0 — Cognitive Memory (2026-03-15)
 - Atkinson-Shiffrin memory model (STM → LTM promotion)
-- Semantic RAG with fastembed (BAAI/bge-base-en-v1.5, 768 dims)
+- Semantic RAG with pinned local multilingual fastembed models
 - Trust scoring, sentiment detection, adaptive personality modes
 - Ebbinghaus decay, sister detection, quarantine system
 

package/bin/nexo-brain.js

@@ -24,7 +24,26 @@ const readline = require("readline");
 require = createRequire(path.join(__dirname, "nexo-brain.js"));
 const { runViaWsl } = require("./windows-wsl-bridge");
 
-if (process.platform === "win32") {
+function isCliEntrypoint() {
+  const invoked = process.argv && process.argv[1] ? String(process.argv[1]) : "";
+  if (!invoked) return false;
+
+  const normalize = (candidate) => {
+    try {
+      return fs.realpathSync.native(candidate);
+    } catch {
+      try {
+        return fs.realpathSync(candidate);
+      } catch {
+        return path.resolve(candidate);
+      }
+    }
+  };
+
+  return normalize(invoked) === normalize(__filename);
+}
+
+if (process.platform === "win32" && isCliEntrypoint()) {
   const bridged = runViaWsl({
     scriptPath: __filename,
     args: process.argv.slice(2),
@@ -4983,8 +5002,10 @@ async function main() {
   }
 }
 
-main().catch((err) => {
-  closeReadline();
-  console.error("Setup failed:", err.message);
-  process.exit(1);
-});
+if (isCliEntrypoint()) {
+  Promise.resolve(main()).catch((err) => {
+    closeReadline();
+    console.error("Setup failed:", err.message);
+    process.exit(1);
+  });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.14.0",
+  "version": "7.15.0",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/agent_runner.py

@@ -4,6 +4,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import paths
 import shlex
 import shutil
@@ -385,6 +386,79 @@ def _headless_env(env: dict | None = None) -> dict:
     return merged
 
 
+_MUTATING_TOOL_NAMES = frozenset({
+    "write",
+    "edit",
+    "multiedit",
+    "notebookedit",
+    "delete",
+    "bash",
+    "shell",
+})
+
+
+def _runner_mutating_tools_allowed(allowed_tools: str) -> bool:
+    text = str(allowed_tools or "").strip().lower()
+    if not text:
+        return True
+    parts = {part.strip().split(":", 1)[0].lower() for part in re.split(r"[,;\s]+", text) if part.strip()}
+    return bool(parts & _MUTATING_TOOL_NAMES)
+
+
+def _extract_runner_guard_paths(prompt: str, cwd: Path) -> list[str]:
+    found: set[str] = set()
+    text = str(prompt or "")
+    for match in re.findall(r"(?<![A-Za-z0-9_])(?:/[^\s'\"`<>]+|[A-Za-z]:\\[^\s'\"`<>]+)", text):
+        cleaned = match.rstrip(".,);:]")
+        if cleaned:
+            found.add(cleaned)
+    for match in re.findall(r"(?<![A-Za-z0-9_])(?:src|scripts|tests|docs|lib|renderer|app)/[A-Za-z0-9_./-]+\.[A-Za-z0-9]+", text):
+        found.add(str((cwd / match.rstrip(".,);:]")).resolve()))
+    try:
+        resolved_cwd = cwd.resolve()
+    except Exception:
+        resolved_cwd = cwd
+    runtime_core = NEXO_HOME / "core"
+    try:
+        if resolved_cwd == runtime_core or runtime_core in resolved_cwd.parents:
+            found.add(str(resolved_cwd))
+    except Exception:
+        pass
+    return sorted(found)
+
+
+def _run_headless_runner_guard(*, caller: str, cwd: Path, prompt: str, allowed_tools: str) -> dict:
+    if not _runner_mutating_tools_allowed(allowed_tools):
+        return {"blocked": False, "skipped": "read_only_tools"}
+    guard_paths = _extract_runner_guard_paths(prompt, cwd)
+    if not guard_paths:
+        return {"blocked": False, "skipped": "no_explicit_paths"}
+    try:
+        runtime_root = str(NEXO_HOME)
+        if runtime_root and runtime_root not in sys.path:
+            sys.path.insert(0, runtime_root)
+        from plugins.guard import handle_guard_check  # type: ignore
+
+        output = handle_guard_check(
+            files=",".join(guard_paths),
+            area=f"runner:{caller or 'headless'}",
+            project_hint=f"headless runner caller={caller or 'unknown'} cwd={cwd}",
+            include_schemas="true",
+        )
+    except Exception as exc:
+        return {
+            "blocked": True,
+            "summary": f"Runner guard unavailable: {exc}",
+            "paths": guard_paths,
+        }
+    blocked = "BLOCKING RULES" in str(output or "")
+    return {
+        "blocked": blocked,
+        "summary": str(output or ""),
+        "paths": guard_paths,
+    }
+
+
 def _load_client_bootstrap_prompt(client: str) -> str:
     try:
         from bootstrap_docs import load_bootstrap_prompt
@@ -1000,6 +1074,18 @@ def run_automation_prompt(
         reasoning_effort=reasoning_effort,
         preferences=prefs,
     )
+    guard_result = _run_headless_runner_guard(
+        caller=caller,
+        cwd=cwd_path,
+        prompt=prompt,
+        allowed_tools=allowed_tools,
+    )
+    if guard_result.get("blocked"):
+        stderr = "NEXO runner guard blocked this automation before editing shared files.\n"
+        summary = str(guard_result.get("summary") or "").strip()
+        if summary:
+            stderr = _append_stderr(stderr, summary)
+        return subprocess.CompletedProcess(["nexo-runner-guard"], 2, "", stderr)
     started_at = time.perf_counter()
 
     if selected_backend == CLIENT_CLAUDE_CODE:

package/src/claim_graph.py

@@ -22,13 +22,28 @@ def _get_db():
 
 
 def _embed(text: str) -> np.ndarray:
-    import cognitive
-    return cognitive.embed(text)
+    try:
+        import cognitive
+        return cognitive.embed(text)
+    except Exception:
+        try:
+            import cognitive
+            dim = int(getattr(cognitive, "EMBEDDING_DIM", 384) or 384)
+        except Exception:
+            dim = 768
+        return np.zeros(dim, dtype=np.float32)
 
 
 def _cosine_similarity(a, b) -> float:
-    import cognitive
-    return cognitive.cosine_similarity(a, b)
+    try:
+        import cognitive
+        return cognitive.cosine_similarity(a, b)
+    except Exception:
+        norm_a = np.linalg.norm(a)
+        norm_b = np.linalg.norm(b)
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+        return float(np.dot(a, b) / (norm_a * norm_b))
 
 
 def _array_to_blob(arr: np.ndarray) -> bytes:

package/src/cognitive/_core.py

@@ -3,8 +3,10 @@
 import base64
 import json
 import math
+import hashlib
 import os
 import re
+import shutil
 import sqlite3
 import numpy as np
 from datetime import datetime, timedelta
@@ -18,7 +20,19 @@ _cognitive_dir = paths.cognitive_dir()
 _cognitive_dir.mkdir(parents=True, exist_ok=True)
 
 COGNITIVE_DB = str(_cognitive_dir / "cognitive.db")
-EMBEDDING_DIM = 768
+def _configured_embedding_dim() -> int:
+    try:
+        from local_models import get_local_model_spec
+
+        dim = int(get_local_model_spec("bge-base-embeddings").dimension or 0)
+        if dim > 0:
+            return dim
+    except Exception:
+        pass
+    return 384
+
+
+EMBEDDING_DIM = _configured_embedding_dim()
 LAMBDA_STM = 0.004126   # half-life = ln(2) / (7 * 24) ≈ 7 days
 LAMBDA_LTM = 0.000481  # half-life = ln(2) / (60 * 24) ≈ 60 days
 DEFAULT_MEMORY_STABILITY = 1.0
@@ -307,20 +321,37 @@ def _migrate_memory_personalization(conn: sqlite3.Connection):
 
 
 def _auto_migrate_embeddings(conn: sqlite3.Connection):
-    """Auto-detect old 384-dim embeddings and re-embed to 768-dim. Transparent to user."""
+    """Re-embed when vector dimension or pinned embedding model changes."""
     try:
-        row = conn.execute("SELECT embedding FROM stm_memories LIMIT 1").fetchone()
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS embedding_model_state (
+                key TEXT PRIMARY KEY,
+                value TEXT NOT NULL,
+                updated_at TEXT DEFAULT (datetime('now'))
+            )
+        """)
+        current_marker = _current_embedding_model_marker()
+        stored = conn.execute(
+            "SELECT value FROM embedding_model_state WHERE key = 'embedding_model_marker'"
+        ).fetchone()
+        stored_marker = stored["value"] if stored else ""
+
+        row = None
+        for table in ("stm_memories", "ltm_memories", "quarantine"):
+            row = conn.execute(f"SELECT embedding FROM {table} LIMIT 1").fetchone()
+            if row:
+                break
         if not row:
-            return  # Empty DB, nothing to migrate
+            _write_embedding_model_marker(conn, current_marker)
+            return
 
         vec = np.frombuffer(row["embedding"], dtype=np.float32)
-        if len(vec) == EMBEDDING_DIM:
-            return  # Already correct dimension
-
-        if len(vec) != 384:
-            return  # Unknown dimension, don't touch
+        dimension_matches = len(vec) == EMBEDDING_DIM
+        model_matches = stored_marker == current_marker
+        if dimension_matches and model_matches:
+            return
 
-        # Need migration: 384 → 768
+        _backup_cognitive_db_for_embedding_migration(stored_marker, current_marker)
         model = _get_model()
 
         for table in ("stm_memories", "ltm_memories", "quarantine"):
@@ -333,14 +364,75 @@ def _auto_migrate_embeddings(conn: sqlite3.Connection):
 
             embeddings = list(model.embed(contents))
             for mem_id, emb in zip(ids, embeddings):
-                blob = np.array(emb, dtype=np.float32).tobytes()
+                arr = np.array(emb, dtype=np.float32)
+                if len(arr) != EMBEDDING_DIM:
+                    raise ValueError(f"embedding dimension mismatch: {len(arr)} != {EMBEDDING_DIM}")
+                blob = arr.tobytes()
                 conn.execute(f"UPDATE {table} SET embedding = ? WHERE id = ?", (blob, mem_id))
 
+        _write_embedding_model_marker(conn, current_marker)
         conn.commit()
     except Exception:
         pass  # Don't break startup if migration fails
 
 
+def _current_embedding_model_marker() -> str:
+    try:
+        from local_models import get_local_model_spec
+
+        spec = get_local_model_spec("bge-base-embeddings")
+        return "|".join([
+            spec.name,
+            spec.kind,
+            spec.model_id,
+            spec.source_repo,
+            spec.revision,
+            str(EMBEDDING_DIM),
+        ])
+    except Exception:
+        return f"unknown|{EMBEDDING_DIM}"
+
+
+def _write_embedding_model_marker(conn: sqlite3.Connection, marker: str) -> None:
+    conn.execute(
+        """
+        INSERT INTO embedding_model_state (key, value, updated_at)
+        VALUES ('embedding_model_marker', ?, datetime('now'))
+        ON CONFLICT(key) DO UPDATE SET
+            value = excluded.value,
+            updated_at = excluded.updated_at
+        """,
+        (marker,),
+    )
+    conn.commit()
+
+
+def _backup_cognitive_db_for_embedding_migration(old_marker: str, new_marker: str) -> None:
+    db_path = Path(COGNITIVE_DB)
+    if not db_path.exists():
+        return
+    stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    backup = db_path.with_name(f"{db_path.name}.bak-embedding-{stamp}")
+    meta = backup.with_suffix(backup.suffix + ".json")
+    try:
+        shutil.copy2(db_path, backup)
+        meta.write_text(
+            json.dumps(
+                {
+                    "old_marker": old_marker,
+                    "new_marker": new_marker,
+                    "created_at": datetime.now().isoformat(timespec="seconds"),
+                },
+                indent=2,
+                ensure_ascii=True,
+                sort_keys=True,
+            ) + "\n",
+            encoding="utf-8",
+        )
+    except Exception:
+        pass
+
+
 def _init_tables(conn: sqlite3.Connection):
     """Create tables if they don't exist."""
     conn.executescript("""
@@ -558,6 +650,8 @@ def _get_model():
     """Lazy-load fastembed TextEmbedding model."""
     global _model
     if _model is None:
+        if _model_download_disabled():
+            raise RuntimeError("cognitive model loading disabled for this environment")
         from local_models import build_fastembed_embedding
 
         _model = build_fastembed_embedding("bge-base-embeddings")
@@ -577,6 +671,22 @@ def _get_reranker():
     return _reranker if _reranker is not False else None
 
 
+def _model_download_disabled() -> bool:
+    return os.environ.get("NEXO_SKIP_COGNITIVE_MODEL_DOWNLOAD", "").strip().lower() in {"1", "true", "yes"}
+
+
+def _deterministic_fallback_embedding(text: str) -> np.ndarray:
+    """Return a stable vector for tests/offline fallback paths."""
+    digest = hashlib.sha256(str(text or "").encode("utf-8", errors="ignore")).digest()
+    arr = np.zeros(EMBEDDING_DIM, dtype=np.float32)
+    for index, byte in enumerate(digest):
+        arr[index] = (float(byte) / 255.0) - 0.5
+    norm = np.linalg.norm(arr)
+    if norm > 0:
+        arr = arr / norm
+    return arr.astype(np.float32)
+
+
 def rerank_results(query: str, results: list[dict], top_k: int = 5) -> list[dict]:
     """Rerank search results using cross-encoder for precise top-k.
 
@@ -603,9 +713,11 @@ def rerank_results(query: str, results: list[dict], top_k: int = 5) -> list[dict
 
 
 def embed(text: str) -> np.ndarray:
-    """Embed text into a 768-dim float32 vector. Returns zeros for empty text."""
+    """Embed text into a float32 vector. Returns zeros for empty text."""
     if not text or not text.strip():
         return np.zeros(EMBEDDING_DIM, dtype=np.float32)
+    if _model_download_disabled():
+        return _deterministic_fallback_embedding(text)
     model = _get_model()
     embeddings = list(model.embed([text]))
     return np.array(embeddings[0], dtype=np.float32)

package/src/cognitive/_search.py

@@ -4,6 +4,7 @@ import os
 import re
 import sqlite3
 import time
+import unicodedata
 import numpy as np
 from datetime import datetime, timezone
 
@@ -357,6 +358,145 @@ def _result_confidence(score: float) -> str:
     return "low"
 
 
+_LEARNING_CONTEXT_MIN_TERM_CHARS = 3
+_LEARNING_CONTEXT_STOP_TERMS = frozenset({
+    "all", "any", "the", "and", "for", "from", "with", "sin", "con", "para",
+    "por", "que", "del", "las", "los", "una", "uno", "learning", "learn",
+})
+
+
+def _context_norm(text: object) -> str:
+    value = unicodedata.normalize("NFKD", str(text or "").lower())
+    value = "".join(ch for ch in value if not unicodedata.combining(ch))
+    return re.sub(r"\s+", " ", value.replace("_", " ").strip())
+
+
+def _context_tokens(text: object) -> set[str]:
+    tokens = set()
+    for token in re.findall(r"[a-z0-9][a-z0-9.-]*", _context_norm(text)):
+        token = token.strip(".-")
+        if len(token) >= _LEARNING_CONTEXT_MIN_TERM_CHARS and token not in _LEARNING_CONTEXT_STOP_TERMS:
+            tokens.add(token)
+            if "-" in token:
+                tokens.add(token.replace("-", " "))
+                tokens.update(part for part in token.split("-") if len(part) >= _LEARNING_CONTEXT_MIN_TERM_CHARS)
+    return tokens
+
+
+def _learning_context_terms(row: dict) -> set[str]:
+    terms: set[str] = set()
+    for field in ("domain", "tags"):
+        raw = row.get(field, "")
+        for chunk in re.split(r"[,;#\n]+", str(raw or "")):
+            normalized = _context_norm(chunk)
+            if len(normalized) >= _LEARNING_CONTEXT_MIN_TERM_CHARS and normalized not in _LEARNING_CONTEXT_STOP_TERMS:
+                terms.add(normalized)
+                if "-" in normalized:
+                    terms.add(normalized.replace("-", " "))
+            terms.update(_context_tokens(chunk))
+    source_id = _context_norm(row.get("source_id", ""))
+    if re.fullmatch(r"l\d+", source_id):
+        terms.add(source_id)
+    return terms
+
+
+def _learning_context_match(query_text: str, row: dict) -> str:
+    query_norm = _context_norm(query_text)
+    if not query_norm:
+        return ""
+    query_padded = f" {query_norm} "
+    query_tokens = _context_tokens(query_norm)
+    for term in sorted(_learning_context_terms(row), key=len, reverse=True):
+        if " " in term or "-" in term or "." in term:
+            variants = {term, term.replace("-", " "), term.replace(" ", "-")}
+            if any(f" {variant} " in query_padded for variant in variants):
+                return term
+            continue
+        if term in query_tokens:
+            return term
+    return ""
+
+
+def _learning_floor_entry(store: str, row: dict, matched_term: str) -> dict:
+    strength = max(1.0, float(row.get("strength") or 0.0))
+    entry = {
+        "store": store,
+        "id": row["id"],
+        "content": row["content"],
+        "source_type": row["source_type"],
+        "source_id": row["source_id"],
+        "source_title": row["source_title"],
+        "domain": row["domain"],
+        "created_at": row["created_at"],
+        "strength": strength,
+        "access_count": row["access_count"],
+        "score": 1.0,
+        "learning_context_floor": True,
+        "learning_context_match": matched_term,
+        "lifecycle_state": row.get("lifecycle_state") or "active",
+    }
+    if store == "ltm":
+        entry["tags"] = row.get("tags", "")
+    return entry
+
+
+def _learning_context_floor_results(
+    query_text: str,
+    *,
+    stores: str = "both",
+    source_type_filter: str = "",
+    include_archived: bool = False,
+    top_k: int = 10,
+) -> list[dict]:
+    if source_type_filter and source_type_filter != "learning":
+        return []
+    db = _get_db()
+    results: list[dict] = []
+    store_specs = []
+    if stores in ("both", "stm"):
+        store_specs.append(("stm", "stm_memories", "promoted_to_ltm = 0"))
+    if stores in ("both", "ltm"):
+        store_specs.append(("ltm", "ltm_memories", "is_dormant = 0"))
+    lifecycle = "AND (lifecycle_state IS NULL OR lifecycle_state = 'active' OR lifecycle_state = 'pinned'"
+    if include_archived:
+        lifecycle += " OR lifecycle_state = 'archived'"
+    lifecycle += ")"
+    for store, table, base_where in store_specs:
+        rows = db.execute(
+            f"SELECT * FROM {table} WHERE {base_where} AND source_type = 'learning' {lifecycle} "
+            "ORDER BY strength DESC, access_count DESC, created_at DESC LIMIT ?",
+            (max(10, int(top_k) * 8),),
+        ).fetchall()
+        for row in rows:
+            row_dict = dict(row)
+            matched = _learning_context_match(query_text, row_dict)
+            if matched:
+                results.append(_learning_floor_entry(store, row_dict, matched))
+    results.sort(key=lambda r: (r.get("strength", 0), r.get("access_count", 0), r.get("created_at", "")), reverse=True)
+    return results[: max(1, int(top_k))]
+
+
+def _merge_learning_context_floor(results: list[dict], floor_results: list[dict], top_k: int | None = None) -> list[dict]:
+    if not floor_results:
+        return results
+    by_key = {(r.get("store"), r.get("id")): r for r in results}
+    for floor in floor_results:
+        key = (floor.get("store"), floor.get("id"))
+        current = by_key.get(key)
+        if current is None:
+            results.append(floor.copy())
+            by_key[key] = results[-1]
+            continue
+        current["score"] = max(float(current.get("score") or 0.0), 1.0)
+        current["strength"] = max(float(current.get("strength") or 0.0), 1.0)
+        current["learning_context_floor"] = True
+        current["learning_context_match"] = floor.get("learning_context_match", "")
+    results.sort(key=lambda x: x.get("score", 0), reverse=True)
+    if top_k is not None:
+        return results[: max(1, int(top_k))]
+    return results
+
+
 # ============================================================================
 # FEATURE 0.5: Knowledge Graph Boost
 # Memories connected to more KG nodes (files, areas, other learnings) are
@@ -1146,6 +1286,17 @@ def search(
     # warnings about painful areas more aggressively.
     results = _somatic_boost_results(results)
 
+    # Deterministic learning floor: category/tag/source-id matches must surface
+    # even when semantic similarity alone would miss the operational context.
+    learning_floor_results = _learning_context_floor_results(
+        query_text,
+        stores=stores,
+        source_type_filter=source_type_filter,
+        include_archived=include_archived,
+        top_k=top_k,
+    )
+    results = _merge_learning_context_floor(results, learning_floor_results)
+
     # Sort by score descending, take top-20 for reranking
     results.sort(key=lambda x: x.get("score", 0), reverse=True)
 
@@ -1154,6 +1305,7 @@ def search(
         results = rerank_results(query_text, results[:top_k * 4], top_k=top_k)
     else:
         results = results[:top_k]
+    results = _merge_learning_context_floor(results, learning_floor_results, top_k=top_k)
 
     # Spreading activation: boost co-activated neighbors (Feature 2)
     co_activation_applied = False
@@ -1213,6 +1365,8 @@ def search(
             results.sort(key=lambda x: x["score"], reverse=True)
             results = results[:top_k]
 
+    results = _merge_learning_context_floor(results, learning_floor_results, top_k=top_k)
+
     # Add rank explanations
     for rank, r in enumerate(results, 1):
         score = r["score"]
@@ -1233,6 +1387,8 @@ def search(
             parts.append(f"kg_boost=+{r['kg_boost']:.3f} ({r.get('kg_connections', 0)} edges)")
         if r.get("co_activation_boost"):
             parts.append(f"co_activation_boost=+{r['co_activation_boost']:.3f}")
+        if r.get("learning_context_floor"):
+            parts.append(f"learning_context_floor=1.000 match={r.get('learning_context_match', '')}")
         if use_hyde is None and resolved_use_hyde:
             parts.append("hyde=auto")
         if spreading_depth is None and resolved_spreading_depth > 0:

package/src/db/_learnings.py

@@ -146,18 +146,30 @@ def search_learnings(query: str, category: str = None) -> list[dict]:
     return [dict(r) for r in rows]
 
 
-def list_learnings(category: str = None) -> list[dict]:
-    """List all learnings, optionally filtered by category."""
+def list_learnings(
+    category: str = None,
+    created_after: float | None = None,
+    created_before: float | None = None,
+) -> list[dict]:
+    """List all learnings, optionally filtered by category and creation time."""
     conn = _core().get_db()
+    where = []
+    params: list[object] = []
     if category:
-        rows = conn.execute(
-            "SELECT * FROM learnings WHERE category = ? ORDER BY updated_at DESC",
-            (category,)
-        ).fetchall()
-    else:
-        rows = conn.execute(
-            "SELECT * FROM learnings ORDER BY category ASC, updated_at DESC"
-        ).fetchall()
+        where.append("category = ?")
+        params.append(category)
+    if created_after is not None:
+        where.append("created_at >= ?")
+        params.append(float(created_after))
+    if created_before is not None:
+        where.append("created_at <= ?")
+        params.append(float(created_before))
+    where_sql = f"WHERE {' AND '.join(where)}" if where else ""
+    order_sql = "updated_at DESC" if category else "category ASC, updated_at DESC"
+    rows = conn.execute(
+        f"SELECT * FROM learnings {where_sql} ORDER BY {order_sql}",
+        tuple(params),
+    ).fetchall()
     return [dict(r) for r in rows]