superlocalmemory 3.8.0 → 3.8.2

package/src/superlocalmemory/mcp/server.py

@@ -203,7 +203,7 @@ class _FilteredServer:
     """
     __slots__ = ("_server", "_allowed")
 
-    def __init__(self, real_server: FastMCP, allowed: frozenset[str]) -> None:
+    def __init__(self, real_server: SLMFastMCP, allowed: frozenset[str]) -> None:
         self._server = real_server
         self._allowed = allowed
 
@@ -265,29 +265,20 @@ from superlocalmemory.mcp.tools_loops import register_loop_tools
 register_loop_tools(_target, get_engine)  # v3.8.0: bounded-loop tools (CLI+command+MCP)
 
 
-# V3.3.21: Eager engine warmup — start initializing BEFORE first tool call.
-# The MCP server process starts when the IDE launches. Previously, the engine
-# was lazy-loaded on first tool call → 23s cold start for the user.
-# Now: engine starts warming in a background thread immediately. By the time
-# the first tool call arrives (1-2s later), the engine is already warm.
-# This applies to ALL IDEs: Claude Code, Cursor, Antigravity, Gemini CLI, etc.
+# Keep stdio MCP processes thin until a tool truly needs a local LIGHT engine.
+# Every open IDE/task owns a stdio process; eagerly opening memory.db in all of
+# them multiplied RAM and SQLite writers on machines with many long-lived
+# sessions. The shared daemon owns model warmup and common remember/recall work.
 def _eager_warmup() -> None:
-    """Pre-warm LIGHT engine + ensure daemon is running + auto-register mesh.
+    """Ensure the shared daemon is running without opening a per-client engine.
 
-    LIGHT engine init is cheap (DB only, ~100 ms). The real reason this
-    stays in a background thread is the follow-on side effects
-    (``ensure_daemon``, ``auto_register_mesh``) which do I/O.
+    Mesh registration is intentionally lazy: a local stdio session is not a
+    remote peer, and heartbeat writes should begin only after a mesh tool is
+    actually used.
     """
-    import logging
     _logger = logging.getLogger(__name__)
-    try:
-        get_engine()
-        _logger.info("MCP engine pre-warmed successfully")
-    except Exception as exc:
-        _logger.warning("MCP engine pre-warmup failed: %s", exc)
 
-    # Measurement / test harnesses set this to skip daemon-start and
-    # mesh-register. The LIGHT engine init above still runs.
+    # Measurement / test harnesses set this to skip daemon-start.
     if _os.environ.get("SLM_DISABLE_WARMUP_SIDE_EFFECTS") == "1":
         return
 
@@ -300,22 +291,12 @@ def _eager_warmup() -> None:
     except Exception as exc:
         _logger.warning("Daemon auto-start failed: %s", exc)
 
-    # V3.4.6: Auto-register this MCP session as a mesh peer immediately.
-    # Previously, registration was lazy (only on first mesh tool call).
-    # Now every Claude session appears on the mesh from startup.
-    try:
-        from superlocalmemory.mcp.tools_mesh import auto_register_mesh
-        auto_register_mesh()
-        _logger.info("Mesh peer auto-registered at startup")
-    except Exception as exc:
-        _logger.warning("Mesh auto-register failed: %s", exc)
-
 import threading
 
 # v3.6.7: Suppress standalone-process behaviours when the MCP server is
 # imported inside the daemon (SLM_MCP_EMBEDDED=1). Three threads are safe
 # to run in a dedicated `slm mcp` subprocess but harmful inside the daemon:
-#   mcp-warmup      — creates a LIGHT engine duplicate; daemon has a FULL one.
+#   mcp-warmup      — ensures the shared daemon only; never creates an engine.
 #   parent-watchdog — calls os._exit(0) if its parent IDE quits, which would
 #                     kill the daemon along with it.
 #   stdin-eof-monitor — monitors stdin pipe; meaningless inside the daemon.

package/src/superlocalmemory/mcp/tools_active.py

@@ -227,7 +227,7 @@ def register_active_tools(server, get_engine: Callable) -> None:
                 # thread so the async MCP event loop is not stalled — same
                 # fix class as #34 mesh tools deadlock.
                 response = await asyncio.to_thread(
-                    pool_recall, search_query, limit=max_results, fast=False,
+                    pool_recall, search_query, limit=max_results, fast=None,
                 )
             except (PoolError, Exception) as exc:
                 logger.warning(

package/src/superlocalmemory/mcp/tools_core.py

@@ -84,8 +84,9 @@ def _record_recall_hits(
             enqueue_shown_flip,
         )
 
-        engine = get_engine()
-        pid = profile_id or engine.profile_id
+        pid = profile_id
+        if not pid:
+            pid = get_engine().profile_id
         slm_dir = canonical_data_root()
 
         shown_ids = [r.get("fact_id", "") for r in results[:10]
@@ -121,7 +122,7 @@ def _record_recall_hits(
 def register_core_tools(server, get_engine: Callable) -> None:
     """Register the 13 core MCP tools on *server*."""
 
-    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @server.tool()
     async def remember(
         content: str, tags: str = "", project: str = "",
         importance: int = 5, session_id: str = "",
@@ -281,13 +282,28 @@ def register_core_tools(server, get_engine: Callable) -> None:
     @server.tool(annotations=ToolAnnotations(readOnlyHint=True))
     async def recall(
         query: str, limit: int = CANONICAL_RECALL_LIMIT, agent_id: str = "mcp_client",
-        session_id: str = "", fast: bool = False,
+        session_id: str = "", fast: bool | None = None,
         include_global: bool | None = None,
         include_shared: bool | None = None,
         window: str = "",
     ) -> dict:
         """Search memories through hybrid retrieval, RRF fusion, and reranking.
 
+        Fast local retrieval (six channels + reranker) returns in ~1-2s. This
+        tool does NOT run an internal LLM reformulation round — YOU (the calling
+        model) are the reasoner. Drive refinement using the confidence signals
+        in the response:
+          • ``no_confident_match: true`` → nothing cleared the evidence floor.
+            Do NOT invent a memory. Rewrite the query into 1-3 more specific
+            sub-queries (split multi-hop questions; try entity names, synonyms,
+            or a broader phrasing) and call ``recall`` again before concluding
+            the information is unknown.
+          • ``answer_confidence`` low / ``abstained: true`` → the top hit is
+            weak. Re-query with a sharper phrasing, or widen with
+            ``include_shared=true`` / ``include_global=true`` if appropriate.
+          • Confident match → use it directly; no second call needed.
+        One extra targeted recall is cheap and beats a wrong "not found".
+
         Optional ``session_id`` threads through to the
         engine's outcome-queue so PostToolUse / Stop hooks can attach
         engagement signals to this recall. Claude Code should pass its
@@ -356,7 +372,7 @@ def register_core_tools(server, get_engine: Callable) -> None:
             # block behind a single threading.Lock. See worker_pool.py.
             result = await asyncio.to_thread(
                 pool.recall, query, limit=limit, session_id=effective_sid,
-                fast=bool(fast),
+                fast=fast,
                 include_global=include_global,
                 include_shared=include_shared,
                 window=window or None,

package/src/superlocalmemory/mcp/tools_learning.py

@@ -143,7 +143,7 @@ def register_learning_tools(server, get_engine: Callable) -> None:
             logger.debug("get_assertions failed: %s", exc)
             return {"assertions": [], "count": 0, "error": str(exc)}
 
-    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @server.tool()
     async def reinforce_assertion(assertion_id: str) -> dict:
         """Reinforce a behavioral assertion (increase confidence).
 
@@ -171,7 +171,7 @@ def register_learning_tools(server, get_engine: Callable) -> None:
         except Exception as exc:
             return {"success": False, "error": str(exc)}
 
-    @server.tool(annotations=ToolAnnotations(idempotentHint=True))
+    @server.tool()
     async def contradict_assertion(assertion_id: str) -> dict:
         """Contradict a behavioral assertion (decrease confidence).
 

package/src/superlocalmemory/retrieval/bridge_discovery.py

@@ -27,6 +27,7 @@ License: AGPL-3.0-or-later
 from __future__ import annotations
 
 import logging
+import time
 from typing import TYPE_CHECKING
 
 from superlocalmemory.retrieval.scope_policy import (
@@ -71,6 +72,7 @@ class BridgeDiscovery:
         *,
         include_global: bool = False,
         include_shared: bool = False,
+        time_budget_s: float = 0.4,
     ) -> list[tuple[str, float]]:
         """Find bridge facts connecting seed results.
 
@@ -110,9 +112,19 @@ class BridgeDiscovery:
 
         bridges: list[tuple[str, float]] = []
         seen = set(seed_ids)
+        # v3.8.2: bound the per-entity get_facts_by_entity fan-out. On a dense
+        # entity graph (M5: 3.3k entities / 208k edges) a single recall could
+        # issue 200+ DB round-trips here — the primary 3.8 full-mode latency
+        # spike (observed 7.6s). Bridges are a SUPPLEMENTARY post-fusion boost
+        # (score x0.8, only added if not already found), so truncating them
+        # under a wall-clock budget is quality-safe: the ranked channels have
+        # already returned the core results.
+        deadline = time.monotonic() + time_budget_s
 
         # Check consecutive pairs for entity overlap
         for i in range(len(seed_ids) - 1):
+            if time.monotonic() > deadline:
+                break
             fact_a = seed_facts.get(seed_ids[i])
             fact_b = seed_facts.get(seed_ids[i + 1])
             if not fact_a or not fact_b:
@@ -128,6 +140,8 @@ class BridgeDiscovery:
             # Strategy 1: Entity bridge (union minus intersection)
             bridge_entities = (entities_a | entities_b) - (entities_a & entities_b)
             for eid in bridge_entities:
+                if time.monotonic() > deadline:
+                    break
                 entity_facts = self._db.get_facts_by_entity(
                     eid,
                     profile_id,

package/src/superlocalmemory/retrieval/engine.py

@@ -679,32 +679,47 @@ class RetrievalEngine:
         fused: list,
         ch_results: dict[str, list[tuple[str, float]]],
         effective_limit: int,
-        min_per_channel: int = 2,
     ) -> list:
-        """Ensure structure channels (entity_graph) get representation.
-
-        V3.4.11: entity_graph finds valid results but RRF scores them low
-        because they don't overlap with semantic/bm25 results. This interleaves
-        top entity_graph facts into positions 3-4 of the final output instead
-        of appending at the end where they'd never be seen.
+        """Keep strong lexical and structure evidence visible in the result cap.
+
+        A semantic channel with a larger weight can fill a small result limit
+        even when BM25 has an exact, high-signal hit. That broke the
+        ``queryable now`` ingestion contract: a freshly inserted FTS row could
+        exist durably but remain invisible to immediate recall. Reserve one
+        capped slot for a strong BM25 hit and two for a structure channel when
+        such candidates exist, without returning more than ``effective_limit``.
         """
-        structure_channels = ["entity_graph"]
+        channel_minimums = (
+            ("bm25", 1, 0.0),
+            ("entity_graph", 2, 0.0),
+        )
         top_ids = {fr.fact_id for fr in top}
 
         promoted = []
-        for ch_name in structure_channels:
+        for ch_name, minimum, score_floor in channel_minimums:
             ch_items = ch_results.get(ch_name, [])
             if not ch_items:
                 continue
 
-            present = sum(1 for fid, _ in ch_items if fid in top_ids)
-            if present >= min_per_channel:
+            eligible_ids = {
+                fid
+                for fid, score in ch_items
+                if (
+                    float(score) > score_floor
+                    if ch_name == "bm25"
+                    else float(score) >= score_floor
+                )
+            }
+            if not eligible_ids:
+                continue
+
+            present = sum(1 for fid in eligible_ids if fid in top_ids)
+            if present >= minimum:
                 continue
 
-            needed = min_per_channel - present
-            ch_fids = {fid for fid, _ in ch_items}
+            needed = minimum - present
             for fr in fused:
-                if fr.fact_id in ch_fids and fr.fact_id not in top_ids:
+                if fr.fact_id in eligible_ids and fr.fact_id not in top_ids:
                     promoted.append(fr)
                     top_ids.add(fr.fact_id)
                     needed -= 1
@@ -714,10 +729,15 @@ class RetrievalEngine:
         if not promoted:
             return top
 
-        # Append as safety net — with proper RRF weights (strategy.py),
-        # entity_graph facts should already rank naturally in the top-k.
-        # This only fires when they're still missing despite weight boost.
-        return list(top) + promoted
+        selected = promoted[:effective_limit]
+        result = list(top[:effective_limit])
+        free_slots = max(0, effective_limit - len(result))
+        result.extend(selected[:free_slots])
+        remaining = selected[free_slots:]
+        if remaining:
+            keep = max(0, effective_limit - len(remaining))
+            result = result[:keep] + remaining
+        return result[:effective_limit]
 
     # -- Channel execution --------------------------------------------------
 
@@ -853,14 +873,26 @@ class RetrievalEngine:
                 q_emb, profile_id, self._config.bm25_top_k,
             )
 
-        # Collect results as channels complete.
+        # Each local channel gets a strict latency budget.  A slow graph walk
+        # must not make an interactive recall wait 30 seconds; completed
+        # channels still participate in fusion and the timeout is observable.
+        channel_timeout_seconds = 1.0
+        # One shared deadline keeps parallel dispatch genuinely bounded.  A
+        # per-future timeout here would serialise the wait and turn five slow
+        # channels into five seconds of UI latency.
+        done, pending = concurrent.futures.wait(
+            futures.values(), timeout=channel_timeout_seconds,
+        )
         for name, fut in futures.items():
+            if fut in pending:
+                logger.warning("Channel %s exceeded %.1fs latency budget", name, channel_timeout_seconds)
+                continue
             try:
-                ch_name, result = fut.result(timeout=30)
+                ch_name, result = fut.result()
                 if result:
                     out[ch_name] = result
             except Exception as exc:
-                logger.warning("Channel %s timed out or failed: %s", name, exc)
+                logger.warning("Channel %s failed: %s", name, exc)
 
         # Apply registered post-retrieval filters (forgetting filter, etc.)
         if hasattr(self, '_registry') and self._registry._filters:

package/src/superlocalmemory/retrieval/reranker.py

@@ -25,9 +25,8 @@ import sys
 import threading
 import time
 import weakref
-from typing import Any
-
 from pathlib import Path
+from typing import Any
 
 from superlocalmemory.infra.data_root import state_path
 from superlocalmemory.storage.models import AtomicFact
@@ -57,9 +56,9 @@ _live_rerankers: set[weakref.ref] = set()
 
 logger = logging.getLogger(__name__)
 
-_IDLE_TIMEOUT_SECONDS = 300  # V3.4.37: 5 min (was 30) — balance cold-start vs RAM.
+_IDLE_TIMEOUT_SECONDS = 1800  # V3.8.1: keep interactive sessions warm.
 # V3.3.12: Configurable via SLM_RERANKER_IDLE_TIMEOUT env var.
-# V3.4.19: Bumped from 120 → 1800 in lock-step with the embedding worker.
+# Low-RAM installations can retain aggressive recycling through the override.
 # Set ``SLM_RERANKER_IDLE_TIMEOUT=120`` + ``slm restart`` to revert.
 _IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_RERANKER_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
 _SUBPROCESS_RESPONSE_TIMEOUT = 15  # v3.4.52: 15s (was 180s). Long timeout blocked the

package/src/superlocalmemory/retrieval/spreading_activation.py

@@ -139,14 +139,19 @@ class SpreadingActivation:
             )
             # Owner-partitioned vector indexes cannot discover opted-in peers.
             # Add visible external embeddings with the same cosine seed signal.
-            try:
-                external_facts = self._db.get_external_visible_facts(
-                    profile_id,
-                    include_global=include_global,
-                    include_shared=include_shared,
-                )
-            except Exception:
-                external_facts = []
+            # v3.8.2 perf: external (global/shared) facts only matter for a
+            # cross-scope read. For the default personal scope this query always
+            # returns [] — skip it to remove a per-recall DB round-trip.
+            external_facts: list = []
+            if include_global or include_shared:
+                try:
+                    external_facts = self._db.get_external_visible_facts(
+                        profile_id,
+                        include_global=include_global,
+                        include_shared=include_shared,
+                    )
+                except Exception:
+                    external_facts = []
             q_vec = np.array(query, dtype=np.float32)
             q_norm = float(np.linalg.norm(q_vec))
             combined = {fact_id: score for fact_id, score in seed_results}
@@ -162,18 +167,26 @@ class SpreadingActivation:
                     continue
                 score = (float(np.dot(q_vec, fact_vec) / denominator) + 1.0) / 2.0
                 combined[fact.fact_id] = max(combined.get(fact.fact_id, 0.0), score)
-            allowed_seeds = authorized_fact_ids(
-                self._db,
-                combined,
-                profile_id,
-                include_global=include_global,
-                include_shared=include_shared,
-            )
-            seed_results = [
-                (fact_id, score)
-                for fact_id, score in combined.items()
-                if fact_id in allowed_seeds
-            ]
+            # v3.8.2 perf: seeds come from this profile's own vector index /
+            # get_all_facts(profile_id), so for personal scope they are already
+            # authorized. Only re-authorize when a cross-scope read merged in
+            # global/shared candidates. filter_authorized_results below remains the
+            # security net on the returned set.
+            if include_global or include_shared:
+                allowed_seeds = authorized_fact_ids(
+                    self._db,
+                    combined,
+                    profile_id,
+                    include_global=include_global,
+                    include_shared=include_shared,
+                )
+                seed_results = [
+                    (fact_id, score)
+                    for fact_id, score in combined.items()
+                    if fact_id in allowed_seeds
+                ]
+            else:
+                seed_results = list(combined.items())
             if not seed_results:
                 return []
 
@@ -186,13 +199,18 @@ class SpreadingActivation:
             )
             cached = self._get_cached_results(query_hash, profile_id)
             if cached:
-                return filter_authorized_results(
-                    self._db,
-                    cached,
-                    profile_id,
-                    include_global=include_global,
-                    include_shared=include_shared,
-                )[:top_k]
+                # v3.8.2 perf: cached activations were produced from this profile's
+                # own propagation; personal-scope hits need no re-authorization.
+                # Cross-scope hits still pass the fail-closed filter.
+                if include_global or include_shared:
+                    return filter_authorized_results(
+                        self._db,
+                        cached,
+                        profile_id,
+                        include_global=include_global,
+                        include_shared=include_shared,
+                    )[:top_k]
+                return cached[:top_k]
 
             # Run 5-step spreading activation
             activations = self._propagate(
@@ -312,7 +330,15 @@ class SpreadingActivation:
                 if activation < 0.001:
                     continue
 
-                # Get neighbors from BOTH tables (Rule 13) — cached per node
+                # Get neighbors from BOTH tables (Rule 13) — cached per node.
+                # v3.8.2 perf-fix: _get_unified_neighbors already filters edges by
+                # the scope predicate (graph_edges via _scope_where; association_edges
+                # by profile_id), so for the default personal scope the returned
+                # neighbors are inherently authorized. The per-node re-authorization
+                # (2 DB round-trips/node, ~30–60 per recall — the primary 3.8 latency
+                # regression) is only required when a cross-scope read can surface
+                # global/shared neighbors. filter_authorized_results() on the returned
+                # set remains the security net for every scope.
                 if node_id not in neighbor_cache:
                     raw_neighbors = self._get_unified_neighbors(
                         node_id,
@@ -320,16 +346,20 @@ class SpreadingActivation:
                         include_global=include_global,
                         include_shared=include_shared,
                     )
-                    allowed_neighbors = authorized_fact_ids(
-                        self._db,
-                        (neighbor_id for neighbor_id, _weight in raw_neighbors),
-                        profile_id,
-                        include_global=include_global,
-                        include_shared=include_shared,
-                    )
-                    neighbor_cache[node_id] = [
-                        item for item in raw_neighbors if item[0] in allowed_neighbors
-                    ]
+                    if include_global or include_shared:
+                        allowed_neighbors = authorized_fact_ids(
+                            self._db,
+                            (neighbor_id for neighbor_id, _weight in raw_neighbors),
+                            profile_id,
+                            include_global=include_global,
+                            include_shared=include_shared,
+                        )
+                        neighbor_cache[node_id] = [
+                            item for item in raw_neighbors
+                            if item[0] in allowed_neighbors
+                        ]
+                    else:
+                        neighbor_cache[node_id] = raw_neighbors
                 neighbors = neighbor_cache[node_id]
 
                 # Out-degree for fan effect normalization

package/src/superlocalmemory/server/config_file.py

@@ -0,0 +1,90 @@
+"""Process-safe, durable read/modify/write access to ``config.json``."""
+
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import threading
+from contextlib import contextmanager
+from pathlib import Path
+from typing import Callable, Iterator
+
+_PROCESS_LOCK = threading.RLock()
+
+
+@contextmanager
+def _file_lock(path: Path) -> Iterator[None]:
+    """Serialize config access across daemon, CLI, and worker processes."""
+    lock_path = path.with_name(f".{path.name}.lock")
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with _PROCESS_LOCK, lock_path.open("a+b") as handle:
+        if os.name == "nt":
+            import msvcrt
+
+            handle.seek(0)
+            handle.write(b"\0")
+            handle.flush()
+            handle.seek(0)
+            msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+        try:
+            yield
+        finally:
+            if os.name == "nt":
+                handle.seek(0)
+                msvcrt.locking(handle.fileno(), msvcrt.LK_UNLCK, 1)
+            else:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
+
+
+def _read_unlocked(path: Path) -> dict:
+    if not path.exists():
+        return {}
+    value = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(value, dict):
+        raise ValueError("config root must be a JSON object")
+    return value
+
+
+def read_config(path: Path) -> dict:
+    """Return one coherent config snapshot under the interprocess lock."""
+    with _file_lock(path):
+        return _read_unlocked(path)
+
+
+def update_config(path: Path, update: Callable[[dict], None]) -> dict:
+    """Atomically update and durably replace a config JSON object."""
+    with _file_lock(path):
+        data = _read_unlocked(path)
+        update(data)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        descriptor, temp_name = tempfile.mkstemp(
+            prefix=f".{path.name}.",
+            suffix=".tmp",
+            dir=path.parent,
+        )
+        temp_path = Path(temp_name)
+        try:
+            with os.fdopen(descriptor, "w", encoding="utf-8") as stream:
+                json.dump(data, stream, indent=2)
+                stream.write("\n")
+                stream.flush()
+                os.fsync(stream.fileno())
+            os.chmod(temp_path, 0o600)
+            os.replace(temp_path, path)
+            if hasattr(os, "O_DIRECTORY"):
+                directory_fd = os.open(path.parent, os.O_RDONLY | os.O_DIRECTORY)
+                try:
+                    os.fsync(directory_fd)
+                finally:
+                    os.close(directory_fd)
+        finally:
+            temp_path.unlink(missing_ok=True)
+        return data
+
+
+__all__ = ("read_config", "update_config")

package/src/superlocalmemory/server/origin.py

@@ -0,0 +1,50 @@
+"""Exact browser-origin validation for the local dashboard."""
+
+from __future__ import annotations
+
+from urllib.parse import urlsplit
+
+
+_LOOPBACK_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
+
+
+def origin_is_loopback(origin: str) -> bool:
+    """Return whether an Origin is absent or an exact HTTP(S) loopback URL."""
+    if not origin:
+        return True
+    try:
+        parsed = urlsplit(origin)
+        # Accessing port validates malformed/non-numeric port values.
+        _ = parsed.port
+    except (TypeError, ValueError):
+        return False
+    return (
+        parsed.scheme in {"http", "https"}
+        and parsed.hostname is not None
+        and parsed.hostname.lower() in _LOOPBACK_HOSTS
+        and parsed.username is None
+        and parsed.password is None
+        and parsed.path in {"", "/"}
+        and not parsed.query
+        and not parsed.fragment
+    )
+
+
+def origin_is_daemon(origin: str, *, port: int) -> bool:
+    """Return whether ``origin`` is one of this daemon's loopback aliases.
+
+    A loopback host alone is not a browser trust boundary: another local web
+    server can run on a different port.  Credentialless dashboard writes are
+    therefore limited to the port owned by this daemon.  Authenticated local
+    integrations are handled separately by the write-identity boundary.
+    """
+    if not origin_is_loopback(origin):
+        return False
+    try:
+        parsed = urlsplit(origin)
+        return parsed.port == port
+    except (TypeError, ValueError):
+        return False
+
+
+__all__ = ("origin_is_daemon", "origin_is_loopback")