superlocalmemory 3.6.16 → 3.6.18

package/src/superlocalmemory/hooks/copilot_adapter.py

@@ -8,9 +8,15 @@ LLD-05 §6. Verified (verification-2026-04-17.md claim 5): plain markdown,
 no frontmatter, soft 2 KB / hard 4 KB cap. Adapter is INACTIVE when the
 project has no ``.github/`` directory — we do not create it ourselves.
 
+v3.4.23 fix: the SLM-managed content is wrapped in
+``<!-- SLM-START -->`` / ``<!-- SLM-END -->`` markers and merged into the
+host file rather than overwriting it. ``.github/copilot-instructions.md``
+is typically a curated, project-specific document; destructive rewrites
+deleted the user's prose.
+
 Hard rules covered here:
   - A1 / A2 / A3 / A7: via ``adapter_base.atomic_write``.
-  - A4: soft 2 KB + hard 4 KB cap enforcement.
+  - A4: soft 2 KB + hard 4 KB cap enforcement on the SLM section.
 """
 
 from __future__ import annotations
@@ -39,6 +45,12 @@ from superlocalmemory.hooks.context_payload import (
     format_topics,
     truncate_payload_for_cap,
 )
+from superlocalmemory.hooks.memory_protocol import (
+    SLM_MARKER_END,
+    SLM_MARKER_START,
+    memory_protocol_markdown,
+    strip_slm_block as _strip_existing_block,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -52,20 +64,37 @@ _BODY_TEMPLATE = (
     "## Entities\n{entities}\n\n"
     "## Never do\n"
     "- Do not modify files under `.slm/`\n"
-    "- Do not commit `*.slm-cache.db`\n"
+    "- Do not commit `*.slm-cache.db`\n\n"
 )
 
 
 def render_copilot(payload: ContextPayload) -> bytes:
-    return _BODY_TEMPLATE.format(
+    # Two-stage assembly: format the dynamic header (which contains {}
+    # placeholders), then concatenate the static memory-protocol block
+    # verbatim. The memory-protocol block legitimately contains literal
+    # braces (JSON-shaped argument examples for the agent) which must not
+    # be interpreted as format fields.
+    header = _BODY_TEMPLATE.format(
         version=payload.version,
         topics=format_topics(payload),
         entities=format_entities(payload),
-    ).encode("utf-8")
+    )
+    return (header + memory_protocol_markdown()).encode("utf-8")
+
+
+def _wrap_managed(rendered: bytes) -> str:
+    """Wrap rendered SLM content in ``<!-- SLM-START -->`` markers."""
+    return (
+        f"{SLM_MARKER_START}\n"
+        "<!-- Managed by SuperLocalMemory. Edits between SLM-START and "
+        "SLM-END will be overwritten. -->\n\n"
+        f"{rendered.decode('utf-8')}\n"
+        f"{SLM_MARKER_END}\n"
+    )
 
 
 class CopilotAdapter:
-    """Project-scope Copilot adapter."""
+    """Project-scope Copilot adapter (marker-bounded merge)."""
 
     def __init__(
         self,
@@ -124,8 +153,39 @@ class CopilotAdapter:
             )
             rendered = truncate_to_cap(rendered, cap=self._hard_cap)
 
+        # Marker-bounded merge — preserve any user-curated content in the
+        # host file. Strip any prior SLM block(s) and re-append a fresh one.
+        existing = ""
+        if resolved.exists():
+            try:
+                existing = resolved.read_text(encoding="utf-8")
+            except OSError as exc:
+                logger.warning(
+                    "copilot: cannot read %s: %s", resolved, exc,
+                )
+                return False
+
+        # Orphaned start marker — refuse to write rather than corrupt.
+        if (SLM_MARKER_START in existing
+                and SLM_MARKER_END not in existing):
+            logger.warning(
+                "copilot: %s present but %s missing in %s; refusing to write",
+                SLM_MARKER_START, SLM_MARKER_END, resolved,
+            )
+            return False
+
+        stripped = _strip_existing_block(existing)
+        section = _wrap_managed(rendered)
+        if stripped:
+            if not stripped.endswith("\n"):
+                stripped += "\n"
+            # One blank line between user content and the managed section.
+            new_content = stripped + "\n" + section
+        else:
+            new_content = section
+
         result: WriteResult = atomic_write(
-            resolved, rendered,
+            resolved, new_content.encode("utf-8"),
             adapter_name=self.name,
             profile_id=self._profile_id,
             sync_log_db=self._sync_log_db,
@@ -137,11 +197,20 @@ class CopilotAdapter:
             resolved = self.target_path
         except PathTraversalError:
             return
+        # Marker-bounded strip — never delete the host file (user-owned).
         if resolved.exists():
             try:
-                resolved.unlink()
-            except OSError:  # pragma: no cover
-                pass
+                existing = resolved.read_text(encoding="utf-8")
+            except OSError:
+                existing = ""
+            stripped = _strip_existing_block(existing)
+            if stripped != existing:
+                try:
+                    resolved.write_text(stripped, encoding="utf-8")
+                except OSError as exc:  # pragma: no cover
+                    logger.warning(
+                        "copilot: failed to strip on disable: %s", exc,
+                    )
         record_disable(
             resolved,
             adapter_name=self.name,

package/src/superlocalmemory/hooks/hook_handlers.py

@@ -36,7 +36,32 @@ _LAST_CONSOLIDATION = os.path.join(
 )
 
 
-_DAEMON_URL = "http://127.0.0.1:8765"
+_DEFAULT_DAEMON_PORT = 8765
+
+
+def _daemon_url() -> str:
+    """Resolve the daemon base URL, preferring the per-user port file.
+
+    On a shared host each user runs their own daemon bound to a different
+    port; the active port is written to ``~/.superlocalmemory/daemon.port``
+    at startup. Reading it here keeps lifecycle hooks pointed at the
+    caller's own daemon instead of a hard-coded ``8765`` that may belong to
+    another user's instance. Falls back to the default port when the file is
+    absent or unreadable. Stdlib only — no SLM imports in the hot path.
+    """
+    port = _DEFAULT_DAEMON_PORT
+    try:
+        port_file = os.path.join(
+            os.path.expanduser("~"), ".superlocalmemory", "daemon.port",
+        )
+        with open(port_file) as fh:
+            port = int(fh.read().strip())
+    except Exception:
+        pass
+    return f"http://127.0.0.1:{port}"
+
+
+_DAEMON_URL = _daemon_url()
 
 
 def _daemon_post(path: str, body: dict, timeout: float = 3.0) -> bool:
@@ -95,6 +120,7 @@ def handle_hook(action: str) -> None:
         sys.exit(_main())
 
     handlers = {
+        "mandate": _hook_mandate,
         "start": _hook_start,
         "gate": _hook_gate,
         "init-done": _hook_init_done,
@@ -142,6 +168,38 @@ def _launch_post_session_evolution(
     )
 
 
+# ---------------------------------------------------------------------------
+# 0. MANDATE — first SessionStart hook; fires before start
+# ---------------------------------------------------------------------------
+
+_MANDATE_TEXT = """<MANDATORY_SESSION_INIT>
+BEFORE writing any text or calling any other tool, you MUST execute these two steps in order:
+
+STEP 1 — Load schema:
+  Call ToolSearch with query: "select:mcp__superlocalmemory__session_init"
+
+STEP 2 — Initialize memory brain:
+  Call mcp__superlocalmemory__session_init with:
+    project_path = your current working directory
+    query = a short description of the session topic (derive from user's first message)
+
+This is non-negotiable. SLM is the brain. Without session_init, you have no 6-channel memory context (Ebbinghaus decay, entity graph, FSRS, spreading activation all go cold).
+DO NOT output any text until session_init has completed.
+</MANDATORY_SESSION_INIT>"""
+
+
+def _hook_mandate() -> None:
+    """Print the session_init mandate. MUST be the FIRST SessionStart hook.
+
+    mcp__superlocalmemory__session_init is DEFERRED at session start — Claude
+    cannot call it without ToolSearch first loading the schema. This hook
+    fires before `slm hook start` and injects the two-step protocol into the
+    system-reminder block so Claude's first action is always ToolSearch →
+    session_init, not a text response with no memory context.
+    """
+    print(_MANDATE_TEXT)
+
+
 # ---------------------------------------------------------------------------
 # 1. SESSION START — SessionStart hook
 # ---------------------------------------------------------------------------

package/src/superlocalmemory/hooks/memory_protocol.py

@@ -0,0 +1,102 @@
+# 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
+
+"""Shared utilities for marker-bounded writes into agent instruction files.
+
+Adapters that inject SLM content into IDE/agent instruction files (e.g.
+``.github/copilot-instructions.md``) use the constants and helpers here to
+demarcate the SLM-managed section so user-curated content outside the
+markers is preserved on every sync.
+
+Marker contract
+---------------
+SLM wraps its content in a pair of HTML comments::
+
+    <!-- SLM-START -->
+    ... managed content ...
+    <!-- SLM-END -->
+
+``strip_slm_block`` removes all such pairs idempotently; adapters call it
+before re-writing so a fresh block replaces the old one in place.
+"""
+
+from __future__ import annotations
+
+import logging
+
+logger = logging.getLogger(__name__)
+
+#: Opening marker for the SLM-managed section.
+SLM_MARKER_START = "<!-- SLM-START -->"
+#: Closing marker for the SLM-managed section.
+SLM_MARKER_END = "<!-- SLM-END -->"
+
+
+def strip_slm_block(text: str) -> str:
+    """Remove all SLM-managed sections from *text*.
+
+    Idempotent — returns *text* unchanged when no markers are present.
+    Strips every ``SLM-START``/``SLM-END`` pair to handle files that
+    accumulated duplicates from a previous bug or a competing writer.
+
+    If a ``SLM-START`` marker has no matching ``SLM-END``, the file is
+    returned unchanged to avoid eating user content; the caller should
+    treat this as an orphaned-marker error and skip the write.
+    """
+    out = text
+    while True:
+        start_idx = out.find(SLM_MARKER_START)
+        if start_idx == -1:
+            return out
+        end_idx = out.find(SLM_MARKER_END, start_idx)
+        if end_idx == -1:
+            logger.warning(
+                "memory_protocol: %s found but %s missing; leaving file unchanged",
+                SLM_MARKER_START,
+                SLM_MARKER_END,
+            )
+            return text
+        cut_end = end_idx + len(SLM_MARKER_END)
+        if cut_end < len(out) and out[cut_end] == "\n":
+            cut_end += 1
+        # Pull back up to two leading newlines added as a boundary separator.
+        cut_start = start_idx
+        while cut_start > 0 and out[cut_start - 1] == "\n":
+            cut_start -= 1
+            if start_idx - cut_start >= 2:
+                break
+        out = out[:cut_start] + out[cut_end:]
+
+
+def memory_protocol_markdown() -> str:
+    """Return the agent-facing Markdown memory protocol block.
+
+    Embedded verbatim into Markdown instruction files such as
+    ``.github/copilot-instructions.md``.  Trailing newline included so
+    callers can concatenate without worrying about boundary whitespace.
+    """
+    return (
+        "## Memory protocol\n"
+        "SLM tools are available via the `slm-hub` MCP gateway. Use them to "
+        "make this brain context grow across sessions.\n\n"
+        "- **At the start of work on an unfamiliar area**, call "
+        "`hub__call_tool` with `tool=\"slm__recall\"` and "
+        "`arguments={\"query\": \"<topic>\"}` to surface prior decisions "
+        "and patterns.\n"
+        "- **At the end of a substantial task** (a fix, a decision, a "
+        "non-trivial change, a session conclusion), call `hub__call_tool` "
+        "with `tool=\"slm__remember\"` and `arguments={\"content\": "
+        "\"<one-paragraph summary of what was decided / changed / "
+        "learned>\", \"tags\": \"<comma-separated kebab-case keywords>\"}`.\n"
+        "- A \"substantial task\" is anything you would write a commit "
+        "message or handoff note about — not every tool call.\n"
+    )
+
+
+__all__ = (
+    "SLM_MARKER_START",
+    "SLM_MARKER_END",
+    "strip_slm_block",
+    "memory_protocol_markdown",
+)

package/src/superlocalmemory/hooks/post_tool_async_hook.py

@@ -30,6 +30,24 @@ _ALLOWED_DAEMON_HOSTS: frozenset[str] = frozenset({
     "127.0.0.1", "localhost", "::1", "[::1]",
 })
 
+_DEFAULT_DAEMON_PORT = 8765
+
+
+def _port_file_url() -> str:
+    """Loopback daemon URL from the per-user port file (default 8765).
+
+    On a shared host each user runs their own daemon on a different port,
+    written to ``~/.superlocalmemory/daemon.port`` at startup. Falling back
+    to this instead of a hard-coded ``8765`` keeps the hook pointed at the
+    caller's own daemon. Stdlib only.
+    """
+    port = _DEFAULT_DAEMON_PORT
+    try:
+        port = int((Path.home() / ".superlocalmemory" / "daemon.port").read_text().strip())
+    except Exception:
+        pass
+    return f"http://127.0.0.1:{port}"
+
 
 def _sanitised_daemon_url() -> str:
     """Return the configured daemon URL only if it's loopback-scoped.
@@ -38,21 +56,21 @@ def _sanitised_daemon_url() -> str:
     shell profile) could set ``SLM_HOOK_DAEMON_URL`` to a remote host
     and exfiltrate the install token via the ``X-SLM-Hook-Token``
     header. We refuse any non-loopback URL and fall back to the local
-    daemon.
+    daemon (resolved via the per-user port file, not a hard-coded port).
     """
     raw = os.environ.get("SLM_HOOK_DAEMON_URL", "").strip()
     if not raw:
-        return "http://127.0.0.1:8765"
+        return _port_file_url()
     try:
         from urllib.parse import urlparse
         parsed = urlparse(raw)
     except Exception:  # pragma: no cover — urllib always importable
-        return "http://127.0.0.1:8765"
+        return _port_file_url()
     if parsed.scheme not in ("http", "https"):
-        return "http://127.0.0.1:8765"
+        return _port_file_url()
     host = (parsed.hostname or "").lower()
     if host not in _ALLOWED_DAEMON_HOSTS:
-        return "http://127.0.0.1:8765"
+        return _port_file_url()
     # Preserve the scheme + port (user may bind daemon on a non-default port).
     port = f":{parsed.port}" if parsed.port else ""
     return f"{parsed.scheme}://{host}{port}"

package/src/superlocalmemory/infra/event_bus.py

@@ -32,6 +32,10 @@ VALID_EVENT_TYPES = frozenset([
     "memory.updated",       # Existing memory modified
     "memory.deleted",       # Memory removed
     "memory.recalled",      # Memory retrieved by an agent
+    "memory.observed",      # /observe accepted content into the debounce buffer
+    "memory.captured",      # AutoCapture matched a buffered observation
+    "memory.dropped",       # AutoCapture rejected a buffered observation
+    "memory.queued",        # /remember accepted content into pending.db (async)
     "graph.updated",        # Knowledge graph rebuilt
     "pattern.learned",      # New pattern detected
     "agent.connected",      # New agent connects

package/src/superlocalmemory/learning/feedback.py

@@ -41,6 +41,18 @@ SIGNAL_VALUES: Dict[str, float] = {
     "access_pattern": 0.6,
 }
 
+# Dashboard UI vocabulary -> (signal_type, signal_value). The dashboard speaks
+# thumbs_up/thumbs_down/pin (explicit) and dwell_positive/dwell_negative
+# (derived from modal dwell time). Unknown types fall back to a neutral
+# user_correction signal rather than being dropped.
+_DASHBOARD_SIGNAL_MAP: Dict[str, tuple[str, float]] = {
+    "thumbs_up": ("user_positive", 1.0),
+    "thumbs_down": ("user_negative", 0.0),
+    "pin": ("user_pin", 1.0),
+    "dwell_positive": ("dwell_positive", 0.6),
+    "dwell_negative": ("dwell_negative", 0.2),
+}
+
 _CREATE_TABLE = """
 CREATE TABLE IF NOT EXISTS learning_feedback (
     id           INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -219,6 +231,53 @@ class FeedbackCollector:
             finally:
                 conn.close()
 
+    # ------------------------------------------------------------------
+    # Public API: record dashboard feedback
+    # ------------------------------------------------------------------
+
+    def record_dashboard_feedback(
+        self,
+        memory_id: str,
+        query: str = "",
+        feedback_type: str = "",
+        profile_id: str = "default",
+    ) -> Optional[int]:
+        """Record an explicit feedback signal raised from the dashboard UI.
+
+        Maps the dashboard's vocabulary (``thumbs_up``/``thumbs_down``/``pin``
+        and the dwell-derived ``dwell_positive``/``dwell_negative``) onto a
+        stored ``(signal_type, signal_value)`` pair. ``memory_id`` is the fact
+        id; the raw ``query`` is hashed and never stored. Returns the inserted
+        row id, or ``None`` on missing ``memory_id``.
+
+        This method restores the dashboard feedback path: the HTTP routes in
+        ``server/routes/learning.py`` called it before it existed, so every
+        thumbs/pin/dwell write raised ``AttributeError`` (issues #53/#59).
+        """
+        if not memory_id:
+            return None
+        signal_type, value = _DASHBOARD_SIGNAL_MAP.get(
+            feedback_type, ("user_correction", 0.5),
+        )
+        qhash = _hash_query(query) if query else None
+        now = _utcnow_iso()
+
+        with self._lock:
+            conn = self._connect()
+            try:
+                cursor = conn.execute(
+                    "INSERT INTO learning_feedback "
+                    "(profile_id, fact_id, signal_type, signal_value, "
+                    "query_hash, created_at, metadata) "
+                    "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                    (profile_id or "default", str(memory_id), signal_type,
+                     value, qhash, now, None),
+                )
+                conn.commit()
+                return cursor.lastrowid
+            finally:
+                conn.close()
+
     # ------------------------------------------------------------------
     # Public API: read feedback
     # ------------------------------------------------------------------

package/src/superlocalmemory/learning/outcome_queue.py

@@ -207,11 +207,19 @@ def _worker_loop(memory_db_path: Path, interval_s: float) -> None:
     )
     import time as _time
     next_reap = _time.monotonic() + _REAP_INTERVAL_S
-    while not _stop_event.wait(interval_s):
+    # Adaptive idle back-off: poll at interval_s under load, but relax the wait
+    # (doubling, capped) when the queue drains empty so an idle daemon stops
+    # contending on the shared SQLite file every 0.25s (issue #53). Snaps back
+    # to interval_s the instant there is work again.
+    _idle_cap = max(interval_s, 2.0)
+    cur_wait = interval_s
+    while not _stop_event.wait(cur_wait):
         try:
-            _drain_once(memory_db_path)
+            drained = _drain_once(memory_db_path)
         except Exception as exc:  # pragma: no cover — defensive
             logger.warning("outcome_queue drain crashed: %s", exc)
+            drained = 0
+        cur_wait = interval_s if drained else min(cur_wait * 2.0, _idle_cap)
         # Periodic reaper for CLI/dashboard outcomes that no Stop hook
         # will ever finalize. Runs OFF the drain path so a busy queue
         # doesn't starve the reaper.

package/src/superlocalmemory/llm/backbone.py

@@ -295,7 +295,14 @@ class LLMBackbone:
         }
         if system:
             payload["system"] = system
-        return _ANTHROPIC_URL, headers, payload
+        # Respect custom base_url (e.g. Anthropic-compatible proxy).
+        # Append /v1/messages to the root URL, mirroring how _build_openai
+        # handles api_base. Falls back to the official Anthropic endpoint.
+        url = (
+            self._base_url.rstrip("/") + "/v1/messages"
+            if self._base_url else _ANTHROPIC_URL
+        )
+        return url, headers, payload
 
     def _build_azure(
         self, prompt: str, system: str, max_tokens: int, temperature: float,

package/src/superlocalmemory/retrieval/reranker.py

@@ -197,6 +197,11 @@ class CrossEncoderReranker:
                 "TOKENIZERS_PARALLELISM": "false",
                 "TORCH_DEVICE": "cpu",
                 "ORT_DISABLE_COREML": "1",
+                # Restore parallel OpenMP. The package caps OMP_NUM_THREADS
+                # globally to avoid a torch+lightgbm libomp SIGSEGV in the
+                # main process. This worker loads torch but never lightgbm,
+                # so there is no collision risk and full parallelism is safe.
+                "OMP_NUM_THREADS": str(os.cpu_count() or 4),
             }
             from superlocalmemory.core.platform_utils import popen_platform_kwargs
             self._worker_proc = subprocess.Popen(

package/src/superlocalmemory/server/routes/learning.py

@@ -325,6 +325,7 @@ async def record_feedback(data: dict):
 
         row_id = feedback.record_dashboard_feedback(
             memory_id=str(memory_id), query=query, feedback_type=feedback_type,
+            profile_id=get_active_profile() or "default",
         )
 
         return {
@@ -369,6 +370,7 @@ async def record_dwell(data: dict):
 
         row_id = feedback.record_dashboard_feedback(
             memory_id=str(memory_id), query=query, feedback_type=feedback_type,
+            profile_id=get_active_profile() or "default",
         )
 
         return {

package/src/superlocalmemory/server/routes/v3_api.py

@@ -441,6 +441,17 @@ def _validate_provider_url(url: str, client_host: str) -> str | None:
         return "Cloud metadata endpoints are not allowed"
     if client_host in ("127.0.0.1", "::1", "localhost"):
         return None  # local dashboard may target its own local/LAN endpoints
+    # SLM_REMOTE residue (#40): an allowlisted LAN dashboard is trusted exactly
+    # like the loopback one and may probe its own LAN LLM endpoint. This does
+    # NOT relax the SSRF guard for arbitrary remote callers —
+    # is_lan_client_allowed is False unless remote mode is ON *and* the client
+    # IP is in SLM_MCP_ALLOWED_HOSTS.
+    try:
+        from superlocalmemory.core.remote_mode import is_lan_client_allowed
+        if is_lan_client_allowed(client_host):
+            return None
+    except Exception:  # pragma: no cover — defensive, never weaken on import error
+        pass
     try:
         ip = ipaddress.ip_address(host)
     except ValueError:

package/src/superlocalmemory/server/unified_daemon.py

@@ -171,6 +171,33 @@ from superlocalmemory.core.recall_gate import (
 # daemon startup via engine._process_pending_memories().
 _engine = None
 
+
+def _emit_event(
+    event_type: str,
+    payload: dict | None = None,
+    *,
+    source_agent: str = "http_client",
+) -> None:
+    """Emit a best-effort EventBus event from an HTTP write path.
+
+    Mirrors mcp.shared.emit_event but tags source_protocol="http" so the
+    dashboard can distinguish HTTP traffic from MCP tool calls. Never raises
+    — a bus failure must not affect the caller's response.
+    """
+    try:
+        from superlocalmemory.infra.event_bus import EventBus
+        from superlocalmemory.server.routes.helpers import DB_PATH
+        bus = EventBus.get_instance(DB_PATH)
+        bus.emit(
+            event_type,
+            payload=payload,
+            source_agent=source_agent,
+            source_protocol="http",
+        )
+    except Exception as exc:
+        logger.debug("EventBus emit failed (%s): %s", event_type, exc)
+
+
 # v3.4.53: Limit concurrent full (non-fast) recalls. Without this, N parallel
 # /recall calls spawn N × 6-channel threads → Ollama serialises, reranker
 # lock queues, and total wall time is N × single-recall-time. 3 concurrent
@@ -240,6 +267,14 @@ class ObserveBuffer:
             self._timer = threading.Timer(self._debounce_sec, self._flush)
             self._timer.daemon = True
             self._timer.start()
+        _emit_event(
+            "memory.observed",
+            payload={
+                "content_hash": content_hash,
+                "content_preview": content[:120],
+                "buffer_size": buf_size,
+            },
+        )
         return {"captured": True, "queued": True, "buffer_size": buf_size}
 
     def _flush(self) -> None:
@@ -268,6 +303,22 @@ class ObserveBuffer:
                         # The prior 'processed N' counted skipped (capture=False)
                         # items as successes — a false-positive write count.
                         captured_count += 1
+                        _emit_event(
+                            "memory.captured",
+                            payload={
+                                "category": decision.category,
+                                "confidence": getattr(decision, "confidence", None),
+                                "content_preview": content[:120],
+                            },
+                        )
+                    else:
+                        _emit_event(
+                            "memory.dropped",
+                            payload={
+                                "reason": getattr(decision, "reason", "no patterns matched"),
+                                "content_preview": content[:120],
+                            },
+                        )
                 except Exception as exc:
                     failed_count += 1
                     logger.warning(
@@ -1784,6 +1835,15 @@ def _register_daemon_routes(application: FastAPI) -> None:
                     req.content, metadata=metadata,
                     scope=scope, shared_with=shared_with,
                 )
+                _emit_event(
+                    "memory.stored",
+                    payload={
+                        "fact_ids": list(fact_ids) if fact_ids else [],
+                        "count": len(fact_ids) if fact_ids else 0,
+                        "path": "remember_sync",
+                        "content_preview": req.content[:120],
+                    },
+                )
                 return {"ok": True, "fact_ids": fact_ids, "count": len(fact_ids)}
             except Exception as exc:
                 raise HTTPException(500, detail=str(exc))
@@ -1823,6 +1883,14 @@ def _register_daemon_routes(application: FastAPI) -> None:
             pending_id = store_pending(
                 req.content, tags=req.tags or "", metadata=meta,
             )
+            _emit_event(
+                "memory.queued",
+                payload={
+                    "pending_id": pending_id,
+                    "tags": req.tags or "",
+                    "content_preview": req.content[:120],
+                },
+            )
             return {
                 "ok": True,
                 "fact_ids": fact_ids,
@@ -2196,6 +2264,16 @@ def _start_pending_materializer() -> None:
                         )
                         engine.store_fact_direct(fact)
                         mark_done(item["id"])
+                        _emit_event(
+                            "memory.stored",
+                            payload={
+                                "pending_id": item["id"],
+                                "memory_id": mem_id,
+                                "path": "materializer_drain",
+                                "content_preview": content[:120],
+                            },
+                            source_agent="materializer",
+                        )
                     except Exception as exc:
                         logger.warning(
                             "Pending %d failed: %s", item["id"], exc,