memorius 0.4.1__tar.gz → 0.4.2__tar.gz

{memorius-0.4.1/memorius.egg-info → memorius-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorius
-Version: 0.4.1
+Version: 0.4.2
 Summary: Self-contained memory vault for any AI agent — vector search, session diaries, and agent-agnostic hooks.
 Author-email: dimonapatrick243 <dimona.patrick@gmail.com>
 License-Expression: MIT

{memorius-0.4.1 → memorius-0.4.2}/memorius/__init__.py

@@ -26,4 +26,4 @@ Architecture:
     memorius:  Main CLI — init, mine, search, diary, status, serve, hook
 """
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

{memorius-0.4.1 → memorius-0.4.2}/memorius/cli/main.py

@@ -16,6 +16,7 @@ Usage:
   memorius obsidian list     List notes in an Obsidian vault
   memorius obsidian import   Import Obsidian notes as memories
   memorius obsidian export   Export memories as Obsidian notes
+  memorius web <query>     Search the internet (web fallback)
 """
 
 from __future__ import annotations
@@ -29,6 +30,7 @@ from pathlib import Path
 from memorius import __version__
 from memorius.config import load_config, DEFAULT_CONFIG_DIR, DEFAULT_CONFIG_PATH
 from memorius.vault import VaultEngine
+from memorius.web_search import web_fallback_enabled, should_fallback
 
 logging.basicConfig(
     level=logging.WARNING,
@@ -82,6 +84,7 @@ def main():
     search_p.add_argument("--n", type=int, default=10, help="Number of results")
     search_p.add_argument("--vault", default=None, help="Filter by vault")
     search_p.add_argument("--shelf", default=None, help="Filter by shelf")
+    search_p.add_argument("--web", action="store_true", help="Fall back to web search if local recall is thin")
 
     mine_p = subparsers.add_parser("mine", help="Mine memories from a transcript")
     mine_p.add_argument("file", nargs="?", default=None, help="Transcript file path")
@@ -126,11 +129,18 @@ def main():
     factcheck_p = subparsers.add_parser("factcheck", help="Fact-check against stored memories")
     factcheck_p.add_argument("statement", nargs="?", default=None, help="Statement to verify")
     factcheck_p.add_argument("--vault", default=None, help="Filter by vault")
+    factcheck_p.add_argument("--web", action="store_true", help="Cross-check uncertain claims against the web")
 
     context_p = subparsers.add_parser("context", help="Get memory context for injection")
     context_p.add_argument("query", nargs="?", default=None, help="Topic to search for")
     context_p.add_argument("--vault", default=None, help="Filter by vault")
     context_p.add_argument("--max", type=int, default=5, help="Max items")
+    context_p.add_argument("--web", action="store_true", help="Augment with web results if no local context")
+
+    web_p = subparsers.add_parser("web", help="Search the internet (web fallback)")
+    web_p.add_argument("query", nargs="?", default=None, help="Search query")
+    web_p.add_argument("--max", type=int, default=5, help="Max results")
+    web_p.add_argument("--provider", default=None, help="Provider override (duckduckgo|mock)")
 
     profile_p = subparsers.add_parser("profile", help="Build session memory profile")
     profile_p.add_argument("session_id", nargs="?", default=None, help="Session ID")
@@ -194,6 +204,7 @@ def main():
         "extract": cmd_extract,
         "factcheck": cmd_factcheck,
         "context": cmd_context,
+        "web": cmd_web,
         "profile": cmd_profile,
         "stats": cmd_stats,
     }
@@ -331,6 +342,24 @@ def cmd_search(engine, args, config):
             print("   ...")
         print()
 
+    # Web fallback — only if local recall is thin ("if needed").
+    if web_fallback_enabled(args, config) and should_fallback(len(results), config):
+        from memorius.web_search import get_web_provider
+        provider = get_web_provider(config)
+        if provider:
+            web = provider.search(
+                query,
+                max_results=config.get("retrieval", {}).get("web_max_results", 5),
+            )
+            print("Web results (from internet):")
+            if not web:
+                print("  (no web results)")
+            for r in web:
+                print(f"  - {r.title}")
+                print(f"    {r.url}")
+                if r.snippet:
+                    print(f"    {r.snippet[:160]}")
+
 
 def cmd_mine(engine, args, config):
     """Mine memories from a transcript."""
@@ -503,6 +532,47 @@ def cmd_factcheck(engine, args, config):
         for m in result.contradicting_memories:
             print(f"    - [{m['vault']}/{m['shelf']}] {m['content'][:100]}")
 
+    # Web cross-check when the vault can't settle the claim.
+    if result.verdict in ("uncertain", "no_match") and web_fallback_enabled(args, config):
+        from memorius.web_search import get_web_provider
+        provider = get_web_provider(config)
+        if provider:
+            web = provider.search(
+                result.statement,
+                max_results=config.get("retrieval", {}).get("web_max_results", 5),
+            )
+            if web:
+                print("  Web cross-check:")
+                for r in web[:3]:
+                    print(f"    - {r.title}: {r.url}")
+
+
+def cmd_web(engine, args, config):
+    """Search the internet (web fallback primitive)."""
+    from memorius.web_search import get_web_provider
+
+    query = args.query
+    if not query:
+        query = sys.stdin.read().strip()
+    if not query:
+        print("Error: query required (pass as argument or pipe to stdin)")
+        return
+
+    provider = get_web_provider(config, provider=args.provider)
+    if not provider:
+        print("Error: no web provider available")
+        return
+
+    results = provider.search(query, max_results=args.max)
+    print(f'Web search: "{query}"')
+    print(f"Results: {len(results)}")
+    print()
+    for i, r in enumerate(results, 1):
+        print(f"{i}. {r.title}")
+        print(f"   {r.url}")
+        if r.snippet:
+            print(f"   {r.snippet[:200]}")
+
 
 def cmd_context(engine, args, config):
     """Get memory context for injection."""
@@ -516,6 +586,23 @@ def cmd_context(engine, args, config):
     context = engine.get_context(query, vault=args.vault, max_items=args.max)
     if context:
         print(context)
+    elif web_fallback_enabled(args, config):
+        from memorius.web_search import get_web_provider
+        provider = get_web_provider(config)
+        if provider:
+            web = provider.search(
+                query,
+                max_results=config.get("retrieval", {}).get("web_max_results", 5),
+            )
+            if web:
+                print("No matching memories. Web results (from internet):")
+                for r in web:
+                    print(f"- {r.title}")
+                    print(f"  {r.url}")
+                    if r.snippet:
+                        print(f"  {r.snippet[:160]}")
+            else:
+                print("No relevant memories or web results found.")
     else:
         print("No relevant memories found.")
 

{memorius-0.4.1 → memorius-0.4.2}/memorius/config.py

@@ -37,6 +37,12 @@ vault:
 hooks:
   enabled: true
   config: ~/.memorius/hooks.yaml
+
+retrieval:
+  web_fallback: false      # opt-in: augment thin local recall with web (local-first / privacy)
+  web_provider: duckduckgo  # duckduckgo (keyless) | mock (tests)
+  web_min_results: 1       # if ZERO local hits, fall back to web
+  web_max_results: 5       # max web results to return
 """
 
 
@@ -98,6 +104,12 @@ def _ensure_defaults(config: dict[str, Any]):
     vault_cfg.setdefault("default", "main")
     vault_cfg.setdefault("max_note_size", 1000)
 
+    retrieval = config.setdefault("retrieval", {})
+    retrieval.setdefault("web_fallback", False)
+    retrieval.setdefault("web_provider", "duckduckgo")
+    retrieval.setdefault("web_min_results", 1)
+    retrieval.setdefault("web_max_results", 5)
+
     hooks = config.setdefault("hooks", {})
     hooks.setdefault("enabled", True)
     hooks.setdefault("config", "~/.memorius/hooks.yaml")
@@ -112,6 +124,8 @@ def _apply_env_overrides(config: dict[str, Any]):
         "MEMORIUS_REST_PORT": ("server", "rest_port"),
         "MEMORIUS_HOST": ("server", "host"),
         "MEMORIUS_DEFAULT_VAULT": ("vault", "default"),
+        "MEMORIUS_WEB_FALLBACK": ("retrieval", "web_fallback"),
+        "MEMORIUS_WEB_PROVIDER": ("retrieval", "web_provider"),
     }
     for env_key, (section, key) in overrides.items():
         val = os.environ.get(env_key)

memorius-0.4.2/memorius/web_search.py

@@ -0,0 +1,191 @@
+"""Web search fallback for memorius.
+
+When local recall is thin, optionally augment retrieval with live web
+results. Local-first and opt-in: web fallback is OFF by default and
+must be enabled via config (``retrieval.web_fallback``) or the ``--web``
+flag — memorius never phones home unless you ask it to.
+
+2026-aligned design (hybrid / grounded retrieval):
+- Web results are returned as *cited* ``WebResult`` objects (title/url/snippet).
+- The default provider (DuckDuckGo lite) needs no API key and uses
+  only the stdlib, so it works out-of-the-box without secrets.
+- A ``MockProvider`` lets the full path be tested without network.
+"""
+
+from __future__ import annotations
+
+import html
+import logging
+import urllib.parse
+import urllib.request
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+
+logger = logging.getLogger("memorius.web")
+
+
+@dataclass
+class WebResult:
+    """A single cited web search result."""
+
+    title: str
+    url: str
+    snippet: str = ""
+
+    def __str__(self) -> str:
+        snippet = self.snippet[:160]
+        return f"- {self.title}\n  {self.url}\n  {snippet}"
+
+
+class WebSearchProvider(ABC):
+    """Pluggable web search backend."""
+
+    name = "base"
+
+    @abstractmethod
+    def search(self, query: str, max_results: int = 5) -> list[WebResult]:
+        """Return cited web results for ``query``."""
+        raise NotImplementedError
+
+
+class DuckDuckGoProvider(WebSearchProvider):
+    """Keyless DuckDuckGo *lite* scraper (stdlib only)."""
+
+    name = "duckduckgo"
+    _ENDPOINT = "https://lite.duckduckgo.com/lite/"
+
+    def __init__(
+        self,
+        timeout: float = 10.0,
+        user_agent: str = "memorius/0.4.2",
+    ):
+        self.timeout = timeout
+        self.user_agent = user_agent
+
+    def search(self, query: str, max_results: int = 5) -> list[WebResult]:
+        data = urllib.parse.urlencode({"q": query}).encode()
+        req = urllib.request.Request(
+            self._ENDPOINT,
+            data=data,
+            headers={
+                "User-Agent": self.user_agent,
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read().decode("utf-8", "replace")
+        except Exception as e:  # network/timeout — never crash the CLI
+            logger.warning("DuckDuckGo search failed: %s", e)
+            return []
+        return _parse_ddg_lite(raw, max_results)
+
+
+class MockProvider(WebSearchProvider):
+    """Test double: returns canned results from a ``query -> [WebResult]`` map."""
+
+    name = "mock"
+
+    def __init__(self, results: Optional[dict[str, list[WebResult]]] = None):
+        self.results = results or {}
+
+    def search(self, query: str, max_results: int = 5) -> list[WebResult]:
+        return self.results.get(query, [])[:max_results]
+
+
+def _parse_ddg_lite(html_text: str, max_results: int) -> list[WebResult]:
+    """Extract result links + snippets from DuckDuckGo lite HTML.
+
+    lite emits a table where each row has a ``<a class="result-link">``
+    title followed by a ``<td class="result-snippet">`` cell. We pair
+    link anchors with the snippet cell at the same index.
+    """
+    from html.parser import HTMLParser
+
+    class _Scraper(HTMLParser):
+        def __init__(self):
+            super().__init__()
+            self.links: list[tuple[str, str]] = []
+            self.snippets: list[str] = []
+            self._in_link = False
+            self._in_snippet = False
+            self._cur_text: list[str] = []
+            self._cur_href = ""
+            self._cur_snip: list[str] = []
+
+        def handle_starttag(self, tag, attrs):
+            d = dict(attrs)
+            cls = d.get("class", "")
+            if tag == "a" and "result-link" in cls:
+                self._in_link = True
+                self._cur_text = []
+                self._cur_href = d.get("href", "")
+            elif tag == "td" and "result-snippet" in cls:
+                self._in_snippet = True
+                self._cur_snip = []
+
+        def handle_endtag(self, tag):
+            if tag == "a" and self._in_link:
+                self._in_link = False
+                title = "".join(self._cur_text).strip()
+                if title and self._cur_href:
+                    self.links.append((title, self._cur_href))
+                self._cur_text = []
+            elif tag == "td" and self._in_snippet:
+                self._in_snippet = False
+                self.snippets.append("".join(self._cur_snip).strip())
+                self._cur_snip = []
+
+        def handle_data(self, data):
+            if self._in_link:
+                self._cur_text.append(data)
+            elif self._in_snippet:
+                self._cur_snip.append(data)
+
+    parser = _Scraper()
+    parser.feed(html_text)
+    out: list[WebResult] = []
+    for i, (title, url) in enumerate(parser.links[:max_results]):
+        snippet = html.unescape(parser.snippets[i]) if i < len(parser.snippets) else ""
+        out.append(
+            WebResult(
+                title=html.unescape(title),
+                url=url,
+                snippet=snippet,
+            )
+        )
+    return out
+
+
+def get_web_provider(
+    config: dict, provider: Optional[str] = None
+) -> Optional[WebSearchProvider]:
+    """Build the configured web provider, or ``None`` if unavailable."""
+    retrieval = config.get("retrieval", {}) if isinstance(config, dict) else {}
+    name = (provider or retrieval.get("web_provider", "duckduckgo")).lower()
+    if name == "mock":
+        return MockProvider()
+    if name == "duckduckgo":
+        return DuckDuckGoProvider()
+    logger.warning("Unknown web_provider %r; using duckduckgo", name)
+    return DuckDuckGoProvider()
+
+
+def web_fallback_enabled(args, config) -> bool:
+    """True if web fallback should be considered (``--web`` flag or config)."""
+    if getattr(args, "web", False):
+        return True
+    retrieval = config.get("retrieval", {}) if isinstance(config, dict) else {}
+    return bool(retrieval.get("web_fallback", False))
+
+
+def should_fallback(local_count: int, config: dict) -> bool:
+    """Decide whether local recall is too thin to skip the web.
+
+    Triggers when there are fewer local hits than ``web_min_results`` —
+    i.e. "search the internet *if needed*".
+    """
+    retrieval = config.get("retrieval", {}) if isinstance(config, dict) else {}
+    min_results = retrieval.get("web_min_results", 1)
+    return local_count < min_results

{memorius-0.4.1 → memorius-0.4.2/memorius.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorius
-Version: 0.4.1
+Version: 0.4.2
 Summary: Self-contained memory vault for any AI agent — vector search, session diaries, and agent-agnostic hooks.
 Author-email: dimonapatrick243 <dimona.patrick@gmail.com>
 License-Expression: MIT

{memorius-0.4.1 → memorius-0.4.2}/memorius.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ memorius/utils.py
 memorius/validation.py
 memorius/vault.py
 memorius/vector_store.py
+memorius/web_search.py
 memorius.egg-info/PKG-INFO
 memorius.egg-info/SOURCES.txt
 memorius.egg-info/dependency_links.txt
@@ -64,4 +65,5 @@ tests/test_graph.py
 tests/test_integration.py
 tests/test_polish_regressions.py
 tests/test_temporal.py
-tests/test_validation.py
+tests/test_validation.py
+tests/test_web_search.py

{memorius-0.4.1 → memorius-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "memorius"
-version = "0.4.1"
+version = "0.4.2"
 description = "Self-contained memory vault for any AI agent — vector search, session diaries, and agent-agnostic hooks."
 readme = "README.md"
 requires-python = ">=3.11"

{memorius-0.4.1 → memorius-0.4.2}/tests/test_integration.py

@@ -6,20 +6,37 @@ import shutil
 import subprocess
 import sys
 import tempfile
-import threading
 import time
 from pathlib import Path
 
 import pytest
 
 
+def _safe_rmtree(path):
+    """rmtree tolerant of Windows file locks.
+
+    On Windows, chroma keeps its index/data .bin files memory-mapped
+    open, so a naive cleanup races with the OS lock and raises
+    PermissionError (WinError 32). Retry briefly to let the lock
+    release, then force-ignore any stragglers (temp dir — safe to drop).
+    """
+    for _ in range(5):
+        try:
+            shutil.rmtree(path)
+            return
+        except PermissionError:
+            time.sleep(0.3)
+    shutil.rmtree(path, ignore_errors=True)
+
+
 @pytest.fixture
 def isolated_env():
     """Set up a temporary memorius environment."""
     old_home = os.environ.get("HOME", "")
     old_storage = os.environ.pop("MEMORIUS_STORAGE_PATH", None)
 
-    with tempfile.TemporaryDirectory() as tmpdir:
+    tmpdir = tempfile.mkdtemp()
+    try:
         # Sandbox HOME so memorius init writes to ~/.memorius inside tmpdir
         fake_home = Path(tmpdir) / "home"
         fake_home.mkdir()
@@ -27,13 +44,14 @@ def isolated_env():
         os.environ["MEMORIUS_STORAGE_PATH"] = str(Path(tmpdir) / "data")
 
         yield Path(tmpdir)
-
-    # Restore env
-    os.environ["HOME"] = old_home
-    if old_storage:
-        os.environ["MEMORIUS_STORAGE_PATH"] = old_storage
-    else:
-        os.environ.pop("MEMORIUS_STORAGE_PATH", None)
+    finally:
+        # Restore env
+        os.environ["HOME"] = old_home
+        if old_storage:
+            os.environ["MEMORIUS_STORAGE_PATH"] = old_storage
+        else:
+            os.environ.pop("MEMORIUS_STORAGE_PATH", None)
+        _safe_rmtree(tmpdir)
 
 
 def run_memorius(*args, env=None, input_text=None, timeout=120):

memorius-0.4.2/tests/test_web_search.py

@@ -0,0 +1,213 @@
+"""Tests for the hybrid retrieval / web-fallback feature.
+
+All web access is faked via ``MockProvider`` — no network required.
+"""
+
+import argparse
+from pathlib import Path
+
+from memorius.web_search import (
+    DuckDuckGoProvider,
+    MockProvider,
+    WebResult,
+    _parse_ddg_lite,
+    get_web_provider,
+    should_fallback,
+    web_fallback_enabled,
+)
+
+
+# Sample DuckDuckGo *lite* HTML (shape only) for parser coverage.
+_DDG_LITE_HTML = """
+<html><body>
+<table>
+  <tr class="result-link-row">
+    <td class="result-link">
+      <a class="result-link" href="https://example.com/a">Example Article A</a>
+    </td>
+    <td class="result-snippet">A short snippet about topic A.</td>
+  </tr>
+  <tr class="result-link-row">
+    <td class="result-link">
+      <a class="result-link" href="https://example.com/b">Example Article B</a>
+    </td>
+    <td class="result-snippet">A short snippet about topic B.</td>
+  </tr>
+</table>
+</body></html>
+"""
+
+
+def _cfg(**overrides):
+    cfg = {
+        "retrieval": {
+            "web_fallback": False,
+            "web_provider": "duckduckgo",
+            "web_min_results": 1,
+            "web_max_results": 5,
+        }
+    }
+    for k, v in overrides.items():
+        cfg["retrieval"][k] = v
+    return cfg
+
+
+def _args(web=False):
+    return argparse.Namespace(web=web)
+
+
+# ── Provider selection ────────────────────────────────────────────────────
+def test_get_web_provider_default_is_duckduckgo():
+    p = get_web_provider(_cfg())
+    assert isinstance(p, DuckDuckGoProvider)
+
+
+def test_get_web_provider_mock():
+    p = get_web_provider(_cfg(), provider="mock")
+    assert isinstance(p, MockProvider)
+
+
+def test_get_web_provider_unknown_falls_back_to_duckduckgo(caplog):
+    p = get_web_provider(_cfg(web_provider="bogus"))
+    assert isinstance(p, DuckDuckGoProvider)
+
+
+# ── Fallback decision ─────────────────────────────────────────────────────
+def test_should_fallback_true_when_local_empty():
+    assert should_fallback(0, _cfg()) is True
+
+
+def test_should_fallback_false_with_any_local_result():
+    # "if needed" = local found nothing; 1+ hit means no web fallback.
+    assert should_fallback(1, _cfg()) is False
+    assert should_fallback(5, _cfg()) is False
+
+
+def test_should_fallback_false_when_local_sufficient():
+    assert should_fallback(2, _cfg()) is False
+    assert should_fallback(5, _cfg()) is False
+
+
+def test_should_fallback_respects_min_results():
+    assert should_fallback(3, _cfg(web_min_results=4)) is True
+    assert should_fallback(4, _cfg(web_min_results=4)) is False
+
+
+# ── Flag / config gating (local-first, opt-in) ──────────────────────────
+def test_web_fallback_disabled_by_default():
+    assert web_fallback_enabled(_args(web=False), _cfg()) is False
+
+
+def test_web_fallback_enabled_via_flag():
+    assert web_fallback_enabled(_args(web=True), _cfg()) is True
+
+
+def test_web_fallback_enabled_via_config():
+    assert web_fallback_enabled(_args(web=False), _cfg(web_fallback=True)) is True
+
+
+# ── DuckDuckGo lite parser ──────────────────────────────────────────────
+def test_parse_ddg_lite_extracts_links_and_snippets():
+    provider = DuckDuckGoProvider()
+    results = _parse_ddg_lite(_DDG_LITE_HTML, 5)
+    assert len(results) == 2
+    assert results[0].title == "Example Article A"
+    assert results[0].url == "https://example.com/a"
+    assert "topic A" in results[0].snippet
+    assert results[1].url == "https://example.com/b"
+
+
+def test_parse_ddg_lite_respects_max_results():
+    provider = DuckDuckGoProvider()
+    results = _parse_ddg_lite(_DDG_LITE_HTML, 1)
+    assert len(results) == 1
+
+
+# ── MockProvider ─────────────────────────────────────────────────────────
+def test_mock_provider_returns_canned_results():
+    canned = {
+        "python 3.13": [
+            WebResult(title="Py 3.13 notes", url="https://docs/python/3.13"),
+        ]
+    }
+    p = MockProvider(canned)
+    out = p.search("python 3.13")
+    assert len(out) == 1
+    assert out[0].url == "https://docs/python/3.13"
+
+
+def test_mock_provider_empty_for_unknown_query():
+    p = MockProvider({})
+    assert p.search("anything") == []
+
+
+# ── CLI integration (no real vault / no network) ───────────────────────
+def test_cmd_web_uses_mock_provider(monkeypatch, capsys):
+    from memorius.cli.main import cmd_web
+
+    canned = {"python 3.13": [
+        WebResult(title="Py 3.13", url="https://docs/python/3.13", snippet="New in 3.13"),
+    ]}
+    monkeypatch.setattr(
+        "memorius.web_search.get_web_provider",
+        lambda config, provider=None: MockProvider(canned),
+    )
+
+    cmd_web(None, argparse.Namespace(query="python 3.13", max=5, provider="mock"), _cfg())
+    out = capsys.readouterr().out
+    assert "Py 3.13" in out
+    assert "https://docs/python/3.13" in out
+
+
+def test_cmd_search_web_fallback_when_local_empty(monkeypatch, capsys):
+    from memorius.cli.main import cmd_search
+
+    class FakeEngine:
+        def search(self, **kwargs):
+            return []  # thin local recall -> triggers fallback
+
+    canned = {"latest rust": [
+        WebResult(title="Rust 1.80", url="https://rust/1.80"),
+    ]}
+    monkeypatch.setattr(
+        "memorius.web_search.get_web_provider",
+        lambda config, provider=None: MockProvider(canned),
+    )
+
+    cmd_search(
+        FakeEngine(),
+        argparse.Namespace(query="latest rust", n=10, vault=None, shelf=None, web=True),
+        _cfg(),
+    )
+    out = capsys.readouterr().out
+    assert "Web results (from internet):" in out
+    assert "Rust 1.80" in out
+
+
+def test_cmd_search_no_web_when_local_present(monkeypatch, capsys):
+    from memorius.cli.main import cmd_search
+    from memorius.models import Memory
+
+    class FakeEngine:
+        def search(self, **kwargs):
+            return [Memory(id="m1", vault="main", shelf="default",
+                        folder="default", note="default",
+                        content="Rust 1.80 released June 2024")]
+
+    # Web provider would return something, but fallback must NOT trigger
+    # because local recall is sufficient.
+    monkeypatch.setattr(
+        "memorius.web_search.get_web_provider",
+        lambda config, provider=None: MockProvider(
+            {"latest rust": [WebResult(title="SHOULD NOT APPEAR", url="x")]}
+        ),
+    )
+
+    cmd_search(
+        FakeEngine(),
+        argparse.Namespace(query="latest rust", n=10, vault=None, shelf=None, web=True),
+        _cfg(),
+    )
+    out = capsys.readouterr().out
+    assert "SHOULD NOT APPEAR" not in out
+    assert "Web results" not in out