sibyl-memory-cli 0.3.11__tar.gz → 0.3.15__tar.gz

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.3.11
+Version: 0.3.15
 Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sibyl-memory-cli"
-version = "0.3.11"
+version = "0.3.15"
 description = "Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke."
 authors = [{ name = "SIBYL, Sibyl Labs LLC", email = "sibyl@sibyllabs.org" }]
 license = { text = "MIT" }

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli/cli.py

@@ -516,6 +516,55 @@ def cmd_upgrade(args: argparse.Namespace) -> int:
 
 # ---- `sibyl status` ----------------------------------------------------
 
+def _discover_stores(primary_db: Path) -> list[dict[str, Any]]:
+    """Enumerate every memory.db an agent on this machine might resolve.
+
+    Beta reports (VRTX 2026-06-11) showed split-brain storage: the SDK / CLI /
+    MCP default (``~/.sibyl-memory/memory.db``), the Hermes adapter
+    (``$HERMES_HOME/sibyl/memory.db``), per-profile DBs
+    (``$HERMES_HOME/sibyl/profiles/<p>/memory.db``), and an MCP
+    ``SIBYL_MEMORY_DB`` override can each hold a disjoint set of memories, so a
+    user switching entry points sees memory "vanish". This surfaces all of
+    them in one place. Read-only: it never creates or moves anything (path
+    unification is a separate, migration-gated change).
+
+    Returns one dict per DISTINCT existing store, resolved + deduped:
+    ``{"label", "path", "size"}``.
+    """
+    candidates: list[tuple[str, Path]] = [("default (SDK/CLI/MCP)", primary_db)]
+
+    hermes_home_env = os.environ.get("HERMES_HOME")
+    hermes_home = Path(hermes_home_env).expanduser() if hermes_home_env else (Path.home() / ".hermes")
+    candidates.append(("hermes adapter", hermes_home / "sibyl" / "memory.db"))
+    profiles_dir = hermes_home / "sibyl" / "profiles"
+    if profiles_dir.is_dir():
+        for prof in sorted(profiles_dir.iterdir()):
+            db = prof / "memory.db"
+            if db.exists():
+                candidates.append((f"hermes profile · {prof.name}", db))
+
+    mcp_override = os.environ.get("SIBYL_MEMORY_DB")
+    if mcp_override:
+        candidates.append(("MCP SIBYL_MEMORY_DB", Path(mcp_override).expanduser()))
+
+    seen: set[str] = set()
+    stores: list[dict[str, Any]] = []
+    for label, path in candidates:
+        try:
+            resolved = str(path.resolve())
+        except OSError:
+            resolved = str(path)
+        if resolved in seen or not path.exists():
+            continue
+        seen.add(resolved)
+        try:
+            size = path.stat().st_size
+        except OSError:
+            size = 0
+        stores.append({"label": label, "path": str(path), "size": size})
+    return stores
+
+
 def cmd_status(args: argparse.Namespace) -> int:
     """Show local + server-side state without modifying anything.
 
@@ -552,10 +601,39 @@ def cmd_status(args: argparse.Namespace) -> int:
     else:
         print(a.kv("DB path", f"{db_path} (not created)"))
 
+    # All resolvable stores on this machine (split-brain visibility floor,
+    # VRTX beta report 2026-06-11). Read-only: lists what exists, moves
+    # nothing. A divergence warning fires when more than one store holds data,
+    # because that is exactly when an agent "loses" memory by switching the
+    # entry point it reads from.
+    stores = _discover_stores(db_path)
+    if len(stores) > 1:
+        print()
+        print(a.eyebrow("memory stores"))
+        for s in stores:
+            mb = s["size"] / (1024 * 1024)
+            print(a.kv(s["label"], f"{s['path']}  ({s['size']:,} bytes · {mb:.2f} MB)"))
+        with_data = [s for s in stores if s["size"] > 0]
+        if len(with_data) > 1:
+            print()
+            print(a.warn_line("Multiple memory stores hold data on this machine."))
+            print(a.dim("  Memory is NOT shared across these paths. An agent reads only the store"))
+            print(a.dim("  for its entry point (SDK/CLI vs Hermes vs profile vs MCP), so memory can"))
+            print(a.dim("  look 'missing' when you switch. Point every entry point at one path via"))
+            print(a.dim("  --db / SIBYL_MEMORY_DB, or back up and consolidate before relying on recall."))
+
     tier_cache = Path(args.tier_cache).expanduser()
     if tier_cache.exists():
         cache = json.loads(tier_cache.read_text(encoding="utf-8"))
-        print(a.kv("Tier cache", f"{cache.get('tier','?')} (checked {cache.get('checked_at','?')[:19]})"))
+        # checked_at is written by _capcheck.py as epoch seconds (float), but
+        # older caches / future formats may carry an ISO string. Render both;
+        # never index a float (TypeError on every `sibyl status` run with a
+        # populated tier cache; Discord report 2026-06-10).
+        checked = cache.get("checked_at")
+        if isinstance(checked, (int, float)) and not isinstance(checked, bool):
+            checked = time.strftime("%Y-%m-%dT%H:%M:%S", time.gmtime(checked))
+        checked = str(checked)[:19] if checked else "?"
+        print(a.kv("Tier cache", f"{cache.get('tier','?')} (checked {checked})"))
     else:
         print(a.kv("Tier cache", "—"))
 
@@ -1056,7 +1134,7 @@ def cmd_migrate(args: argparse.Namespace) -> int:
     io = _migrate_io()
     report = M.run_guided_setup(
         home=home, cwd=cwd, db_path=db_path, backup_parent=backup_parent,
-        io=io, debloat=not args.no_debloat,
+        io=io, debloat=not args.no_debloat, force=getattr(args, "force", False),
     )
 
     ph = report.get("phases", {})
@@ -1136,6 +1214,22 @@ def build_parser() -> argparse.ArgumentParser:
     p_h = sub.add_parser("health", help="Run the provider self-check")
     p_h.set_defaults(func=cmd_health)
 
+    p_mem = sub.add_parser("memory", help="Read-only inspection of your memory store (list / search / recall)")
+    mem_sub = p_mem.add_subparsers(dest="mem_cmd")
+    p_ml = mem_sub.add_parser("list", help="List entities (optionally filtered by category)")
+    p_ml.add_argument("category", nargs="?", default=None, help="Optional category to filter by")
+    p_ml.add_argument("--limit", type=int, default=50, help="Max rows (default 50)")
+    p_ml.set_defaults(func=cmd_memory)
+    p_ms = mem_sub.add_parser("search", help="Full-text search across entities + state + reference + journal")
+    p_ms.add_argument("query", help="Search query (matches stored text, not meaning)")
+    p_ms.add_argument("--limit", type=int, default=20, help="Max hits (default 20)")
+    p_ms.set_defaults(func=cmd_memory)
+    p_mr = mem_sub.add_parser("recall", help="Recall one entity by category + name")
+    p_mr.add_argument("category", help="Entity category")
+    p_mr.add_argument("name", help="Entity name")
+    p_mr.set_defaults(func=cmd_memory)
+    p_mem.set_defaults(func=cmd_memory)
+
     p_update = sub.add_parser(
         "update",
         help="Check for newer sibyl-memory-* releases on PyPI (use --apply to upgrade)",
@@ -1196,11 +1290,71 @@ def build_parser() -> argparse.ArgumentParser:
         "--yes", "-y", action="store_true",
         help="Skip the initial confirm (the trim step still always asks separately)",
     )
+    p_migrate.add_argument(
+        "--force", action="store_true",
+        help="Overwrite an existing non-sibyl memory provider when wiring a harness "
+             "(without this, migrate stops at that harness and tells you to re-run with --force)",
+    )
     p_migrate.set_defaults(func=cmd_migrate)
 
     return p
 
 
+def cmd_memory(args: argparse.Namespace) -> int:
+    """Read-only inspection of the local memory store (PKG-4, VRTX/deadguy beta).
+
+        sibyl memory list [category]    list entities
+        sibyl memory search <query>     full-text search across tiers
+        sibyl memory recall <cat> <nm>  recall one entity by category + name
+
+    Opens the resolved DB read-only via the SDK; never writes. Respects --db so
+    you can inspect any split-brain store that `sibyl status` surfaces.
+    """
+    from sibyl_memory_client import MemoryClient
+
+    db_path = Path(args.db).expanduser()
+    print()
+    if not db_path.exists():
+        print(a.warn_line(f"No memory store at {db_path}."))
+        print(a.dim("  Run `sibyl status` to see every store on this machine."))
+        return 1
+    client = MemoryClient.local(path=db_path)
+    op = getattr(args, "mem_cmd", None)
+    if op == "list":
+        rows = client.list_entities(category=args.category, limit=args.limit)
+        if not rows:
+            print(a.dim("(no entities)"))
+            return 0
+        print(a.eyebrow(f"entities ({len(rows)})"))
+        for r in rows:
+            print(a.kv(f"{r['category']}/{r['name']}", r.get("status") or "-"))
+        return 0
+    if op == "search":
+        hits = client.search(args.query, limit=args.limit)
+        if not hits:
+            print(a.dim(f"(no matches for {args.query!r})"))
+            return 0
+        print(a.eyebrow(f"matches ({len(hits)})"))
+        for h in hits:
+            snip = (h.get("snippet") or "").replace("\n", " ")[:100]
+            print(a.kv(f"[{h.get('tier') or '-'}] {h.get('key') or '-'}", snip))
+        return 0
+    if op == "recall":
+        try:
+            ent = client.get_entity(args.category, args.name)
+        except Exception as e:
+            print(a.warn_line(str(e)))
+            return 1
+        print(a.eyebrow(f"{ent['category']}/{ent['name']}"))
+        print(a.kv("status", ent.get("status") or "-"))
+        print(a.kv("updated", ent.get("updated_at") or "-"))
+        body = ent.get("body")
+        print(body if isinstance(body, str) else json.dumps(body, indent=2, ensure_ascii=False))
+        return 0
+    print(a.warn_line("Usage: sibyl memory {list|search|recall} ..."))
+    return 1
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = build_parser()
     args = parser.parse_args(argv)

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli/migrate.py

@@ -330,7 +330,7 @@ class GuidedIO:
 def run_guided_setup(*, home=None, cwd=None, db_path=None, backup_parent=None,
                      io: Optional[GuidedIO] = None, wirers: Optional[dict] = None,
                      extract_fn: Optional[Callable[[Path, Path], None]] = None,
-                     debloat: bool = True, now=None) -> dict:
+                     debloat: bool = True, force: bool = False, now=None) -> dict:
     """The assembled guided flow: backup -> auto-wire each harness (instructions on
     failure) -> extraction handoff -> verify -> confirmed debloat. Returns a structured
     report. `extract_fn(backup_dir, db_path)` performs/simulates extraction; default
@@ -367,7 +367,7 @@ def run_guided_setup(*, home=None, cwd=None, db_path=None, backup_parent=None,
         if w.current_state().get("wired_with_sibyl"):
             wire_report[name] = "already"
             continue
-        outcome = w.wire()
+        outcome = w.wire(force=force)
         wire_report[name] = outcome.status
         if outcome.status not in ("wired", "already"):
             io.say(f"{name}: auto-wire incomplete ({outcome.message}). Do this manually:")

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli/setup.py

@@ -222,6 +222,15 @@ class HermesWirer:
             loaded = yaml.safe_load(raw)
             if isinstance(loaded, dict):
                 cfg = loaded
+            elif loaded is not None:
+                # Fail fast: a non-mapping top level means the config is not
+                # something we can merge into. Silently reinitializing would
+                # destroy the user's existing Hermes settings.
+                raise ValueError(
+                    f"{self.config_path} top level is not a YAML mapping "
+                    f"(got {type(loaded).__name__}). Fix the file or move it "
+                    "aside and re-run; it was not modified."
+                )
         if not isinstance(cfg.get("memory"), dict):
             cfg["memory"] = {}
         cfg["memory"]["provider"] = "sibyl"
@@ -338,6 +347,7 @@ class ClaudeCodeWirer:
         settings_exists = self.settings_path.exists()
         mcp_servers: dict = {}
         sibyl_block: Optional[dict] = None
+        settings_parse_error: Optional[str] = None
         if settings_exists:
             try:
                 cfg = json.loads(self.settings_path.read_text(encoding="utf-8"))
@@ -346,8 +356,8 @@ class ClaudeCodeWirer:
                     if isinstance(raw_servers, dict):
                         mcp_servers = raw_servers
                         sibyl_block = mcp_servers.get("sibyl-memory")
-            except Exception:
-                pass
+            except Exception as e:
+                settings_parse_error = f"{type(e).__name__}: {e}"
         mcp_binary = self._mcp_binary_found()
         cli_registered = self._registered_via_cli()  # None when no `claude` CLI
         # Source of truth: when the claude CLI exists, trust `claude mcp get` (where
@@ -359,6 +369,7 @@ class ClaudeCodeWirer:
         return {
             "settings_path": str(self.settings_path),
             "settings_exists": settings_exists,
+            "settings_parse_error": settings_parse_error,
             "mcp_servers_count": len(mcp_servers),
             "sibyl_mcp": sibyl_block,
             "mcp_binary_found": mcp_binary,
@@ -493,12 +504,27 @@ class ClaudeCodeWirer:
     def _write_settings_with_sibyl(self) -> None:
         cfg: dict = {}
         if self.settings_path.exists():
-            try:
-                loaded = json.loads(self.settings_path.read_text(encoding="utf-8"))
+            raw = self.settings_path.read_text(encoding="utf-8")
+            if raw.strip():
+                try:
+                    loaded = json.loads(raw)
+                except ValueError as e:
+                    # Fail fast: never atomically replace a corrupt settings.json
+                    # with a sibyl-only file (that destroys the user's other
+                    # mcpServers, permissions, hooks, env).
+                    raise ValueError(
+                        f"{self.settings_path} is not valid JSON ({e}). "
+                        "Fix the file or move it aside and re-run setup; "
+                        "your settings were not modified."
+                    ) from e
                 if isinstance(loaded, dict):
                     cfg = loaded
-            except Exception:
-                cfg = {}
+                else:
+                    raise ValueError(
+                        f"{self.settings_path} top level is not a JSON object "
+                        f"(got {type(loaded).__name__}). Fix the file or move it "
+                        "aside and re-run setup; your settings were not modified."
+                    )
         if not isinstance(cfg.get("mcpServers"), dict):
             cfg["mcpServers"] = {}
         cfg["mcpServers"]["sibyl-memory"] = self.SIBYL_MCP_BLOCK

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sibyl-memory-cli
-Version: 0.3.11
+Version: 0.3.15
 Summary: Command-line interface for the Sibyl Memory Plugin. `sibyl init` activates, `sibyl upgrade` runs the staker / subscription flow, `sibyl status` shows current tier and DB stats, `sibyl whoami` gives a one-line account summary, `sibyl devices` lists active devices and supports per-device revoke.
 Author-email: "SIBYL, Sibyl Labs LLC" <sibyl@sibyllabs.org>
 License: MIT

{sibyl_memory_cli-0.3.11 → sibyl_memory_cli-0.3.15}/src/sibyl_memory_cli.egg-info/SOURCES.txt

@@ -14,8 +14,11 @@ src/sibyl_memory_cli.egg-info/requires.txt
 src/sibyl_memory_cli.egg-info/top_level.txt
 tests/test_hermes_install_args.py
 tests/test_init_perms_guard.py
+tests/test_memory_cmd_2026_06_16.py
 tests/test_migrate.py
 tests/test_migrate_adversarial.py
+tests/test_migrate_force_2026_06_05.py
 tests/test_orchestrator.py
 tests/test_setup.py
+tests/test_status_stores_2026_06_11.py
 tests/test_wiring_fix.py

sibyl_memory_cli-0.3.15/tests/test_memory_cmd_2026_06_16.py

@@ -0,0 +1,55 @@
+"""PKG-4 (VRTX/deadguy beta): read-only `sibyl memory list/search/recall` CLI.
+Lets a tester inspect what's actually stored without writing through an agent."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from sibyl_memory_client import MemoryClient
+from sibyl_memory_cli import cli
+
+
+def _store(tmp_path: Path) -> Path:
+    d = tmp_path / "memory.db"
+    c = MemoryClient.local(path=d)
+    c.set_entity("partner", "Blocktronics", {"stage": "active", "note": "token forensics suite"})
+    c.set_entity("partner", "Reppo", {"stage": "negotiation"})
+    return d
+
+
+def test_memory_list(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "list"])
+    out = capsys.readouterr().out
+    assert rc == 0
+    assert "Blocktronics" in out and "Reppo" in out
+
+
+def test_memory_list_category_filter(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "list", "partner", "--limit", "1"])
+    assert rc == 0
+
+
+def test_memory_search(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "search", "forensics"])
+    out = capsys.readouterr().out
+    assert rc == 0 and "Blocktronics" in out
+
+
+def test_memory_recall(tmp_path, capsys):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "recall", "partner", "Blocktronics"])
+    out = capsys.readouterr().out
+    assert rc == 0 and "forensics" in out
+
+
+def test_memory_recall_missing_returns_1(tmp_path):
+    d = _store(tmp_path)
+    rc = cli.main(["--db", str(d), "memory", "recall", "partner", "Nope"])
+    assert rc == 1
+
+
+def test_memory_no_store_returns_1(tmp_path):
+    rc = cli.main(["--db", str(tmp_path / "absent.db"), "memory", "list"])
+    assert rc == 1

sibyl_memory_cli-0.3.15/tests/test_migrate_force_2026_06_05.py

@@ -0,0 +1,67 @@
+"""Regression (bugflow 2026-06-05): `sibyl migrate --force` must reach the wirers.
+
+Onboarding dead-end: when a detected harness already had a non-sibyl memory
+provider, the wirer refused with "Use --force to overwrite." but
+`run_guided_setup` called `wire()` with no `force`, and `sibyl migrate` had no
+`--force` flag to pass. The flag now threads cli -> run_guided_setup(force=) ->
+wire(force=force).
+"""
+from __future__ import annotations
+
+from sibyl_memory_cli import migrate as M
+from sibyl_memory_cli.setup import WireOutcome
+from sibyl_memory_client import MemoryClient
+
+
+class _RecordingWirer:
+    """A fake harness wirer that records the `force` kwarg it was called with."""
+
+    name = "rec"
+
+    def __init__(self):
+        self.seen_force = None
+
+    def is_present(self):
+        return True
+
+    def current_state(self):
+        return {"wired_with_sibyl": False}
+
+    def wire(self, *, force: bool = False, dry_run: bool = False, prompt_fn=None):
+        self.seen_force = force
+        return WireOutcome(self.name, "wired", "ok")
+
+
+def _home_with_memory(tmp_path):
+    h = tmp_path / "home"
+    (h / "proj").mkdir(parents=True)
+    (h / "proj" / "CLAUDE.md").write_text("# memory\n- a fact worth keeping\n")
+    db = h / ".sibyl-memory" / "memory.db"
+    db.parent.mkdir(parents=True)
+    return h, db
+
+
+def _fake_extract(_backup_dir, db_path):
+    MemoryClient.local(str(db_path), tenant_id="qa").set_entity("f", "a", {"v": 1})
+
+
+def test_force_true_threads_to_wirer(tmp_path):
+    h, db = _home_with_memory(tmp_path)
+    rec = _RecordingWirer()
+    M.run_guided_setup(
+        home=h, cwd=h / "proj", db_path=db, backup_parent=tmp_path / "bk",
+        io=M.GuidedIO(scripted=["n"]), wirers={"rec": rec},
+        extract_fn=_fake_extract, force=True,
+    )
+    assert rec.seen_force is True
+
+
+def test_force_defaults_false(tmp_path):
+    h, db = _home_with_memory(tmp_path)
+    rec = _RecordingWirer()
+    M.run_guided_setup(
+        home=h, cwd=h / "proj", db_path=db, backup_parent=tmp_path / "bk",
+        io=M.GuidedIO(scripted=["n"]), wirers={"rec": rec},
+        extract_fn=_fake_extract,
+    )
+    assert rec.seen_force is False

sibyl_memory_cli-0.3.15/tests/test_status_stores_2026_06_11.py

@@ -0,0 +1,70 @@
+"""PKG-2/3 regression: `sibyl status` discovers + lists every memory store and
+warns on split-brain divergence (VRTX beta report 2026-06-11).
+
+Read-only: discovery never creates or moves a DB.
+"""
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from sibyl_memory_cli import cli
+
+
+@pytest.fixture
+def sandbox(monkeypatch):
+    d = Path(tempfile.mkdtemp())
+    primary = d / ".sibyl-memory" / "memory.db"
+    primary.parent.mkdir(parents=True)
+    hermes = d / ".hermes"
+    (hermes / "sibyl").mkdir(parents=True)
+    monkeypatch.setenv("HERMES_HOME", str(hermes))
+    monkeypatch.delenv("SIBYL_MEMORY_DB", raising=False)
+    return d, primary, hermes
+
+
+def test_discovers_default_hermes_and_profiles(sandbox):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 100)
+    (hermes / "sibyl" / "memory.db").write_bytes(b"y" * 200)
+    prof = hermes / "sibyl" / "profiles" / "alpha"
+    prof.mkdir(parents=True)
+    (prof / "memory.db").write_bytes(b"z" * 50)
+
+    stores = cli._discover_stores(primary)
+    labels = {s["label"] for s in stores}
+    assert "default (SDK/CLI/MCP)" in labels
+    assert "hermes adapter" in labels
+    assert any(l.startswith("hermes profile") for l in labels)
+    assert {s["size"] for s in stores} == {100, 200, 50}
+
+
+def test_skips_nonexistent_and_dedups(sandbox):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 10)
+    # hermes adapter db does not exist → excluded
+    stores = cli._discover_stores(primary)
+    assert [s["label"] for s in stores] == ["default (SDK/CLI/MCP)"]
+
+
+def test_mcp_override_included(sandbox, monkeypatch):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 10)
+    shadow = d / "shadow.db"
+    shadow.write_bytes(b"s" * 5)
+    monkeypatch.setenv("SIBYL_MEMORY_DB", str(shadow))
+    stores = cli._discover_stores(primary)
+    assert any(s["label"] == "MCP SIBYL_MEMORY_DB" for s in stores)
+
+
+def test_status_warns_on_divergence(sandbox, capsys):
+    d, primary, hermes = sandbox
+    primary.write_bytes(b"x" * 100)
+    (hermes / "sibyl" / "memory.db").write_bytes(b"y" * 200)
+
+    # Build the minimal args cmd_status reads. No credentials → early-return
+    # path, so drive discovery directly to assert the warning copy instead.
+    stores = cli._discover_stores(primary)
+    with_data = [s for s in stores if s["size"] > 0]
+    assert len(with_data) > 1  # divergence condition that triggers the warning