superlocalmemory 3.7.8 → 3.8.0

package/src/superlocalmemory/core/recall_worker.py

@@ -62,6 +62,7 @@ def _get_engine():
 def _handle_recall(
     query: str, limit: int, session_id: str = "", fast: bool = False,
     include_global: bool | None = None, include_shared: bool | None = None,
+    window: str | None = None,
 ) -> dict:
     engine = _get_engine()
     # v3.6.15 multi-scope: None flags let engine.recall resolve the configured
@@ -70,11 +71,19 @@ def _handle_recall(
     response = engine.recall(
         query, limit=limit, session_id=session_id or None, fast=bool(fast),
         include_global=include_global, include_shared=include_shared,
+        window=window or None,
     )
 
-    # Batch-fetch original memory text for all results
+    # Batch-fetch original memory text for all results. Retrieval already
+    # enforced scope, so resolve content for everything it returned (own +
+    # global + shared-with-me); another tenant's PRIVATE content still can't
+    # resolve. Using the raw (possibly-None) recall flags here would drop
+    # content for legitimately-recalled global/shared memories.
     memory_ids = list({r.fact.memory_id for r in response.results[:limit] if r.fact.memory_id})
-    memory_map = engine._db.get_memory_content_batch(memory_ids) if memory_ids else {}
+    memory_map = engine._db.get_memory_content_batch(
+        memory_ids, engine.profile_id,
+        include_global=True, include_shared=True,
+    ) if memory_ids else {}
 
     # v3.6.6: same shared chokepoint as the daemon HTTP route + CLI fallback,
     # so the MCP WorkerPool subprocess path returns identical budgeted output.
@@ -172,11 +181,15 @@ def _handle_store(content: str, metadata: dict) -> dict:
 def _handle_get_memory_facts(memory_id: str) -> dict:
     engine = _get_engine()
     pid = engine.profile_id
-    # Get original memory content
-    mem_map = engine._db.get_memory_content_batch([memory_id])
+    # Get original memory content (C4: tenant-scoped; global/shared resolvable)
+    mem_map = engine._db.get_memory_content_batch(
+        [memory_id], pid, include_global=True, include_shared=True,
+    )
     original = mem_map.get(memory_id, "")
-    # Get child facts
-    facts = engine._db.get_facts_by_memory_id(memory_id, pid)
+    # Get child facts — same scope as the content fetch so a shared/global
+    # memory's facts are not silently empty.
+    facts = engine._db.get_facts_by_memory_id(
+        memory_id, pid, include_global=True, include_shared=True)
     fact_list = []
     for f in facts:
         fact_list.append({
@@ -308,6 +321,7 @@ def _worker_main() -> None:
                     req.get("session_id", ""), bool(req.get("fast", False)),
                     include_global=req.get("include_global"),
                     include_shared=req.get("include_shared"),
+                    window=req.get("window"),
                 )
                 _respond(result)
             elif cmd == "store":

package/src/superlocalmemory/core/scale_engine.py

@@ -116,6 +116,13 @@ class ScaleEngineManager:
             # This command reads persisted state, not the live daemon. Never
             # turn a last-known backend row into a present-tense routing claim.
             "active": {"cozo": False, "lance": False},
+            # LOW-2 (3.7.9): after promote the daemon must restart before the
+            # backends actually serve; surface that explicitly so `status` isn't
+            # mistaken for "promotion failed".
+            "daemon_must_restart_to_activate": (
+                state == "promoted"
+                and not any(v == "active" for v in runtime.values())
+            ),
             "last_daemon_observation": runtime,
             "paths_present": paths_present,
             "retrieval_routing": (
@@ -319,6 +326,8 @@ class ScaleEngineManager:
                 raise ScaleEngineError(
                     f"projection parity failed: canonical={canonical}, observed={observed}"
                 )
+            with self._readonly_connection() as conn:
+                self._verify_content_sample(conn, cozo, canonical)
             manifest.update({"state": "verified", "verified_at": _utc_now(), "observed": observed})
             self._write_manifest(stage_dir, manifest)
             self.config.scale_engine_state = "verified"
@@ -510,7 +519,31 @@ class ScaleEngineManager:
         ).fetchone()[0]
         edges = count_logical_edges(conn, self.profile_id)
         vectors = count_canonical_vectors(conn, self.profile_id)
-        return {"entities": int(nodes), "edges": int(edges), "vectors": int(vectors)}
+        fact_entity = self._count_fact_entity_links(conn)
+        return {
+            "entities": int(nodes),
+            "edges": int(edges),
+            "vectors": int(vectors),
+            "fact_entity": int(fact_entity),
+        }
+
+    def _count_fact_entity_links(self, conn: sqlite3.Connection) -> int:
+        """Count fact->entity bridge rows exactly as ``bulk_import_from_sqlite``
+        projects them: dedup entity IDs per fact, drop empties. This bridge is
+        what lets Cozo map a query seed into the fact graph; if its import
+        silently fails, count parity on entities/edges/vectors still passes but
+        entity recall returns empty — so it must be verified explicitly."""
+        total = 0
+        for (raw,) in conn.execute(
+            "SELECT canonical_entities_json FROM atomic_facts WHERE profile_id=?",
+            (self.profile_id,),
+        ):
+            try:
+                entity_ids = json.loads(raw or "[]")
+            except (TypeError, ValueError, json.JSONDecodeError):
+                continue
+            total += sum(1 for eid in dict.fromkeys(entity_ids) if eid)
+        return total
 
     def _observed_counts(self, cozo: Any, lance: Any) -> dict[str, int]:
         graph = cozo.health_check()
@@ -521,8 +554,34 @@ class ScaleEngineManager:
             "entities": int(graph["entities"]),
             "edges": int(graph["edges"]),
             "vectors": int(vector["vectors"]),
+            "fact_entity": int(graph.get("fact_entity", 0)),
         }
 
+    def _verify_content_sample(
+        self, conn: sqlite3.Connection, cozo: Any, canonical: dict[str, int]
+    ) -> None:
+        """Content parity: count equality does not prove the import reproduced
+        the correct rows. Compare the projected entity-ID set against canonical
+        SQLite (bounded), catching a projection that has the right entity count
+        but the wrong identities."""
+        getter = getattr(cozo, "entity_ids", None)
+        n = int(canonical.get("entities", 0))
+        if not callable(getter) or n == 0:
+            return  # backend cannot sample, or nothing to compare
+        observed_ids = set(getter(limit=n))
+        rows = conn.execute(
+            "SELECT entity_id FROM canonical_entities WHERE profile_id=?",
+            (self.profile_id,),
+        ).fetchall()
+        expected_ids = {r[0] for r in rows}
+        if expected_ids != observed_ids:
+            missing = sorted(expected_ids - observed_ids)[:5]
+            extra = sorted(observed_ids - expected_ids)[:5]
+            raise ScaleEngineError(
+                "projection content parity failed: entity IDs diverged "
+                f"(missing sample={missing}, unexpected sample={extra})"
+            )
+
     def _projection_fingerprint(
         self, conn: sqlite3.Connection, counts: dict[str, int]
     ) -> str:

package/src/superlocalmemory/core/security_primitives.py

@@ -399,6 +399,35 @@ def redact_secrets(text: str, *, entropy_threshold: float = 4.5,
 # ---------------------------------------------------------------------------
 
 
+def harden_db_perms(db_path: str | Path) -> None:
+    """Restrict a database file (and its WAL/SHM sidecars) to owner-only 0600
+    and its parent directory to 0700 (C4 encryption-at-rest defense-in-depth).
+
+    Best-effort and POSIX-only: on Windows or if the file does not exist yet
+    this is a silent no-op. The daemon's data dir is already 0700, but the DB
+    files themselves shipped 0644 (world-readable); on a shared host that is a
+    real exposure even with full-disk encryption at rest.
+    """
+    if _is_windows():
+        return
+    try:
+        p = Path(db_path)
+        parent = p.parent
+        try:
+            os.chmod(parent, 0o700)
+        except OSError:
+            pass
+        for suffix in ("", "-wal", "-shm"):
+            f = Path(str(p) + suffix)
+            if f.exists():
+                try:
+                    os.chmod(f, 0o600)
+                except OSError:
+                    pass
+    except Exception:  # pragma: no cover — never block DB open on a chmod
+        pass
+
+
 def _install_token_path() -> Path:  # pragma: no cover — monkeypatched in tests
     """Default install-token location — override in tests via monkeypatch."""
     from superlocalmemory.infra.data_root import state_path
@@ -598,8 +627,17 @@ def run_subprocess_safe(
       - Restricted environment by default — only a minimal set of safe keys.
       - Callers may pass an explicit ``env`` to add specific variables.
 
-    This is the ONE place in the codebase allowed to call ``subprocess.run``.
-    Grep guard in CI enforces this (LLD-07 §7 SEC-HR-06).
+    This is the PREFERRED wrapper for any subprocess whose ``argv`` includes
+    dynamic or externally-influenced values — routing them through here keeps
+    ``shell=False``, a mandatory timeout, and a restricted environment.
+
+    It is not the *only* ``subprocess.run`` call site: a small set of vetted
+    callers invoke ``subprocess.run`` directly where they need inherited stdio
+    for live progress, a long-lived managed process, or process-group control
+    (e.g. model downloads in ``cli/setup_wizard.py``, ``infra/process_reaper``,
+    ``cli/service_installer``). Those pass only fixed/argv-quoted values — never
+    a shell string. Do not read this wrapper as a guarantee that no other
+    subprocess call exists; audit new call sites individually. (L-01, 3.7.9)
     """
     if not isinstance(argv, list):
         raise TypeError("argv must be list[str], shell=False only")

package/src/superlocalmemory/core/store_pipeline.py

@@ -208,21 +208,33 @@ def run_store(
     if not pre_authorized:
         hooks.run_pre("store", hook_ctx)
 
-    if entropy_gate and not entropy_gate.should_pass(content):
+    # Admission gates apply to FRESH submissions only. A materialization pass
+    # re-runs this pipeline for content whose queryable projection was already
+    # committed at submit (``queryable_fact_ids`` is set). Re-applying admission
+    # here — the entropy near-duplicate gate especially — would discard that
+    # already-committed fact (return []) and wedge the operation in an endless
+    # materialize retry loop ("materialization produced no final facts"). The
+    # near-duplicate verdict is expected at materialize: the submitted
+    # projection itself is in the gate's window. Admission was already decided
+    # at submit (store_fast enforces the same gates), so skip it here.
+    is_materialization = bool(queryable_fact_ids)
+
+    if entropy_gate and not is_materialization and not entropy_gate.should_pass(content):
         return []
 
     # v3.5.0: store-side quality gate (H3). Reject prompt-template leakage,
     # empty placeholders, and other non-memory content BEFORE it enters the
     # DB. Uses the shared is_low_quality from core/injection so both store
     # AND injection filter by identical rules. Saves DB IO + recall pollution.
-    try:
-        from superlocalmemory.core.injection import is_low_quality
-        if is_low_quality(content):
-            logger.debug("Store rejected (low-quality content): %s...",
-                         content[:80].replace("\n", " "))
-            return []
-    except Exception:
-        pass  # Best-effort gate; store succeeds if import fails
+    if not is_materialization:
+        try:
+            from superlocalmemory.core.injection import is_low_quality
+            if is_low_quality(content):
+                logger.debug("Store rejected (low-quality content): %s...",
+                             content[:80].replace("\n", " "))
+                return []
+        except Exception:
+            pass  # Best-effort gate; store succeeds if import fails
 
     from superlocalmemory.encoding.temporal_parser import TemporalParser
     parser = temporal_parser or TemporalParser()
@@ -583,14 +595,26 @@ def run_store(
                     fact.fact_id, exc,
                 )
 
+        # Phase 4b: fact-augmented key expansion (T3b). Index entity aliases /
+        # canonical names as BM25 alt-keys so paraphrased queries match. Mode A
+        # (entity graph) is zero-LLM and safe on the hot store path; LLM
+        # paraphrase enrichment (Mode B/C) is left to background consolidation.
+        try:
+            from superlocalmemory.core.key_expander import KeyExpander
+            _alt_keys = KeyExpander(db).expand(fact, profile_id, mode="a")
+            if _alt_keys:
+                db.upsert_fact_expansion(fact.fact_id, _alt_keys)
+        except Exception as exc:
+            logger.debug("Key expansion skipped for %s: %s", fact.fact_id, exc)
+
         if observation_builder:
             for eid in fact.canonical_entities:
                 observation_builder.update_profile(eid, fact, profile_id)
 
-        # Increment fact_count for each linked canonical entity
+        # Increment fact_count for each linked canonical entity (scoped to profile).
         for eid in fact.canonical_entities:
             try:
-                db.increment_entity_fact_count(eid)
+                db.increment_entity_fact_count(eid, profile_id)
             except Exception:
                 pass  # Non-critical — entity may have been deleted
         if scene_builder:

package/src/superlocalmemory/core/worker_pool.py

@@ -70,6 +70,7 @@ class WorkerPool:
         fast: bool = False,
         include_global: bool | None = None,
         include_shared: bool | None = None,
+        window: str | None = None,
     ) -> dict:
         """Run recall in worker subprocess. Returns result dict.
 
@@ -91,6 +92,8 @@ class WorkerPool:
             msg["include_global"] = bool(include_global)
         if include_shared is not None:
             msg["include_shared"] = bool(include_shared)
+        if window:
+            msg["window"] = window
         return self._send(msg)
 
     def store(self, content: str, metadata: dict | None = None) -> dict:
@@ -291,15 +294,27 @@ class WorkerPool:
             self._idle_timer.cancel()
             self._idle_timer = None
         if self._proc is not None:
-            pid = self._proc.pid
+            proc = self._proc
+            pid = proc.pid
             try:
-                self._proc.stdin.write('{"cmd":"quit"}\n')
-                self._proc.stdin.flush()
-                self._proc.wait(timeout=3)
+                proc.stdin.write('{"cmd":"quit"}\n')
+                proc.stdin.flush()
+                proc.wait(timeout=3)
             except Exception:
                 try:
-                    self._proc.kill()
-                    self._proc.wait(timeout=2)
+                    proc.kill()
+                    proc.wait(timeout=2)
+                except Exception:
+                    pass
+            # L-CONC-1: deterministically close the pipe fds rather than leaving
+            # them to GC. This releases the OS handles immediately and unblocks
+            # any orphaned _readline_with_timeout reader thread (its readline
+            # returns/raises on the closed pipe), so repeated request timeouts
+            # cannot accumulate reader threads or file descriptors. Cross-platform.
+            for stream in (proc.stdin, proc.stdout, proc.stderr):
+                try:
+                    if stream is not None:
+                        stream.close()
                 except Exception:
                     pass
             self._proc = None

package/src/superlocalmemory/encoding/entity_reflexion.py

@@ -0,0 +1,200 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Reflexion self-review over LLM-extracted entities (Wave Q1).
+
+After primary LLM extraction (Mode B/C only), one bounded self-review pass
+audits the extracted entities against the source text and:
+
+  - drops hallucinated entities (not supported by the source), and
+  - adds clearly-missed entities (whose exact text appears in the source).
+
+This closes the two distinct extraction failure modes the market leaders
+separate: coverage (missed) and grounding (hallucinated). Coverage is the
+"gleaning" idea (re-present what was extracted, ask for misses); grounding is
+the "reflexion" idea (verify each extracted entity is real).
+
+Design guarantees:
+  - Mode A never reaches here — the caller gates on Mode B/C + LLM available.
+  - Fail-open: any error, unavailable LLM, or unparseable output returns the
+    input facts unchanged. This module NEVER raises.
+  - Immutable: corrected facts are new objects; inputs are not mutated.
+  - Bounded: one LLM call, capped facts reviewed, capped entities per fact.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+License: AGPL-3.0-or-later
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import re
+from dataclasses import replace
+from typing import Any
+
+from superlocalmemory.storage.models import AtomicFact
+
+logger = logging.getLogger(__name__)
+
+_MAX_ENTITIES_PER_FACT = 12
+_MIN_ENTITY_LEN = 2
+
+_SYSTEM = (
+    "You are a precise information-extraction auditor. You verify that "
+    "entities extracted from text are actually supported by that text, and "
+    "you catch clearly-named entities that were missed. You never invent "
+    "entities. You reply with JSON only."
+)
+
+
+class EntityReflexion:
+    """Bounded, fail-open reflexion pass over extracted entities."""
+
+    def __init__(
+        self,
+        llm: Any,
+        max_facts: int = 8,
+        max_tokens: int = 512,
+    ) -> None:
+        self._llm = llm
+        self._max_facts = max(1, int(max_facts))
+        self._max_tokens = max(64, int(max_tokens))
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def refine(
+        self, source_text: str, facts: list[AtomicFact],
+    ) -> list[AtomicFact]:
+        """Return facts with entity lists corrected, or unchanged on failure."""
+        if not self._llm or not facts or not source_text or not source_text.strip():
+            return facts
+        try:
+            is_avail = getattr(self._llm, "is_available", None)
+            if callable(is_avail) and not is_avail():
+                return facts
+        except Exception:
+            return facts
+
+        subject = facts[: self._max_facts]
+        try:
+            raw = self._invoke(source_text, subject)
+        except Exception as exc:
+            logger.debug("EntityReflexion LLM call failed: %s", exc)
+            return facts
+
+        corrections = self._parse(raw)
+        if not corrections:
+            return facts
+        try:
+            return self._apply(facts, corrections, source_text)
+        except Exception as exc:
+            logger.debug("EntityReflexion apply failed: %s", exc)
+            return facts
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    def _invoke(self, source_text: str, subject: list[AtomicFact]) -> str:
+        lines = []
+        for i, f in enumerate(subject):
+            lines.append(f'{i}: "{f.content}" entities={list(f.entities)}')
+        facts_block = "\n".join(lines)
+        prompt = (
+            "Audit the extracted entities for each fact against the SOURCE "
+            "text below.\n"
+            "For each fact, report:\n"
+            "- drop: entities in the fact's list that are NOT supported by the "
+            "source (hallucinated).\n"
+            "- add: named entities clearly present in the source but missing "
+            "from the fact's list. Only add entities whose exact text appears "
+            "in the source.\n\n"
+            f"--- SOURCE ---\n{source_text}\n--- END ---\n\n"
+            f"--- FACTS ---\n{facts_block}\n--- END ---\n\n"
+            'Respond with ONLY a JSON array: '
+            '[{"index": <int>, "drop": [..], "add": [..]}]. '
+            "Use [] for an empty list. Omit facts that need no change."
+        )
+        out = self._llm.generate(
+            prompt=prompt,
+            system=_SYSTEM,
+            temperature=0.0,
+            max_tokens=self._max_tokens,
+        )
+        return out if isinstance(out, str) else str(out or "")
+
+    @staticmethod
+    def _parse(raw: str) -> list[dict]:
+        if not raw or not raw.strip():
+            return []
+        match = re.search(r"\[.*\]", raw, re.DOTALL)
+        if not match:
+            return []
+        try:
+            data = json.loads(match.group())
+        except (json.JSONDecodeError, ValueError):
+            return []
+        if not isinstance(data, list):
+            return []
+        return [d for d in data if isinstance(d, dict)]
+
+    def _apply(
+        self,
+        facts: list[AtomicFact],
+        corrections: list[dict],
+        source_text: str,
+    ) -> list[AtomicFact]:
+        by_index: dict[int, dict] = {}
+        for c in corrections:
+            idx = c.get("index")
+            if isinstance(idx, int) and 0 <= idx < self._max_facts:
+                by_index[idx] = c
+
+        src_low = source_text.lower()
+        out: list[AtomicFact] = []
+        for i, fact in enumerate(facts):
+            c = by_index.get(i)
+            if c is None:
+                out.append(fact)
+                continue
+
+            ents = list(fact.entities)
+            drop = {
+                str(d).strip().lower()
+                for d in _as_list(c.get("drop"))
+                if str(d).strip()
+            }
+            if drop:
+                ents = [e for e in ents if e.strip().lower() not in drop]
+
+            seen = {e.strip().lower() for e in ents}
+            for a in _as_list(c.get("add")):
+                cand = str(a).strip()
+                low = cand.lower()
+                if len(cand) < _MIN_ENTITY_LEN or low in seen:
+                    continue
+                # Grounding guard: only add entities literally present in source.
+                if low not in src_low:
+                    continue
+                ents.append(cand)
+                seen.add(low)
+                if len(ents) >= _MAX_ENTITIES_PER_FACT:
+                    break
+
+            if ents != list(fact.entities):
+                out.append(replace(fact, entities=ents))
+            else:
+                out.append(fact)
+        return out
+
+
+def _as_list(value: Any) -> list:
+    if isinstance(value, list):
+        return value
+    if value is None:
+        return []
+    return [value]

package/src/superlocalmemory/encoding/entity_resolver.py

@@ -283,22 +283,22 @@ class EntityResolver:
             entity = self._db.get_entity_by_name(name, profile_id)
             if entity is not None:
                 resolution[raw] = entity.entity_id
-                self._touch_last_seen(entity.entity_id)
+                self._touch_last_seen(entity.entity_id, profile_id)
                 continue
 
             # Tier b: alias match (case-insensitive, indexed)
             entity_id = self._alias_lookup(name, profile_id)
             if entity_id is not None:
                 resolution[raw] = entity_id
-                self._touch_last_seen(entity_id)
+                self._touch_last_seen(entity_id, profile_id)
                 continue
 
             # Tier c: fuzzy match via Jaro-Winkler
             match_id, score = self._fuzzy_match(name, profile_id)
             if match_id is not None and score >= JARO_WINKLER_AUTO_MERGE:
                 resolution[raw] = match_id
-                self._persist_alias(match_id, name, score, "jaro_winkler")
-                self._touch_last_seen(match_id)
+                self._persist_alias(match_id, name, score, "jaro_winkler", profile_id)
+                self._touch_last_seen(match_id, profile_id)
                 continue
 
             # Candidate zone (0.70–0.85): queue for LLM in Mode B/C
@@ -384,7 +384,7 @@ class EntityResolver:
         and removes the merged entity record.
         """
         # Move aliases from merge -> keep
-        aliases = self._db.get_aliases_for_entity(entity_id_merge)
+        aliases = self._db.get_aliases_for_entity(entity_id_merge, profile_id)
         for alias in aliases:
             new_alias = EntityAlias(
                 alias_id=_new_id(),
@@ -393,7 +393,7 @@ class EntityResolver:
                 confidence=alias.confidence,
                 source=f"merge_from:{entity_id_merge}",
             )
-            self._db.store_alias(new_alias)
+            self._db.store_alias(new_alias, profile_id)
 
         # Also add the merged entity's canonical name as an alias of keep
         merged = self._db.get_entity_by_name("", "")  # placeholder
@@ -403,7 +403,7 @@ class EntityResolver:
         )
         if rows:
             merged_name = str(dict(rows[0])["canonical_name"])
-            self._persist_alias(entity_id_keep, merged_name, 1.0, "merge")
+            self._persist_alias(entity_id_keep, merged_name, 1.0, "merge", profile_id)
 
         # Update atomic_facts: replace entity_id_merge with entity_id_keep
         # in canonical_entities_json column
@@ -435,14 +435,14 @@ class EntityResolver:
             except (json.JSONDecodeError, TypeError):
                 continue
 
-        # Delete the merged entity
+        # Delete the merged entity (tenant-scoped)
         self._db.execute(
-            "DELETE FROM entity_aliases WHERE entity_id = ?",
-            (entity_id_merge,),
+            "DELETE FROM entity_aliases WHERE entity_id = ? AND profile_id = ?",
+            (entity_id_merge, profile_id),
         )
         self._db.execute(
-            "DELETE FROM canonical_entities WHERE entity_id = ?",
-            (entity_id_merge,),
+            "DELETE FROM canonical_entities WHERE entity_id = ? AND profile_id = ?",
+            (entity_id_merge, profile_id),
         )
         logger.info(
             "Merged entity %s into %s (profile=%s)",
@@ -526,7 +526,7 @@ class EntityResolver:
         self._db.store_entity(entity)
 
         # Store name as its own alias for uniform lookup
-        self._persist_alias(entity.entity_id, name, 1.0, "canonical")
+        self._persist_alias(entity.entity_id, name, 1.0, "canonical", profile_id)
 
         logger.debug(
             "Created entity '%s' [%s] (type=%s, profile=%s)",
@@ -540,13 +540,16 @@ class EntityResolver:
         alias_text: str,
         confidence: float,
         source: str,
+        profile_id: str,
     ) -> None:
-        """Store an alias, skipping duplicates."""
-        # Check if alias already exists for this entity
+        """Store an alias under a profile, skipping duplicates within it."""
+        # Check if alias already exists for this entity IN THIS PROFILE. The
+        # dedup must be profile-scoped or one profile's alias suppresses
+        # another profile's identical alias for a same-id entity.
         existing = self._db.execute(
             "SELECT alias_id FROM entity_aliases "
-            "WHERE entity_id = ? AND LOWER(alias) = LOWER(?)",
-            (entity_id, alias_text),
+            "WHERE entity_id = ? AND profile_id = ? AND LOWER(alias) = LOWER(?)",
+            (entity_id, profile_id, alias_text),
         )
         if existing:
             return
@@ -557,13 +560,20 @@ class EntityResolver:
             confidence=confidence,
             source=source,
         )
-        self._db.store_alias(alias)
+        self._db.store_alias(alias, profile_id)
 
-    def _touch_last_seen(self, entity_id: str) -> None:
-        """Update last_seen timestamp on a canonical entity."""
+    def _touch_last_seen(self, entity_id: str, profile_id: str = "default") -> None:
+        """Update last_seen timestamp on a canonical entity scoped to profile.
+
+        L-01 fix: the original query had no profile_id guard. Since entity_ids are
+        UUIDs today the blast radius is theoretical, but the guard is required for
+        defense-in-depth against future import/sharing features that could introduce
+        UUID collisions across profiles.
+        """
         self._db.execute(
-            "UPDATE canonical_entities SET last_seen = ? WHERE entity_id = ?",
-            (_now(), entity_id),
+            "UPDATE canonical_entities SET last_seen = ? "
+            "WHERE entity_id = ? AND profile_id = ?",
+            (_now(), entity_id, profile_id),
         )
 
     # -- Internal: LLM disambiguation (Mode B/C) ---------------------------
@@ -621,9 +631,9 @@ class EntityResolver:
                     entity_id = known[name_str]
                     resolved[mention_str] = entity_id
                     self._persist_alias(
-                        entity_id, mention_str, 0.9, "llm",
+                        entity_id, mention_str, 0.9, "llm", profile_id,
                     )
-                    self._touch_last_seen(entity_id)
+                    self._touch_last_seen(entity_id, profile_id)
                 # If LLM says it's itself, leave for caller to create
             return resolved