superlocalmemory 3.7.7 → 3.8.0

package/src/superlocalmemory/cli/commands.py

@@ -40,6 +40,14 @@ def _cmd_db_dispatch(args: Namespace) -> None:
     sys.exit(2)
 
 
+def _cmd_mesh_dispatch(args: Namespace) -> None:
+    """Route ``slm mesh ...`` inspection subcommands (M-03)."""
+    from superlocalmemory.cli.mesh_cmd import cmd_mesh
+    rc = cmd_mesh(args)
+    if rc:
+        sys.exit(rc)
+
+
 def _cmd_escape_disable(args: Namespace) -> None:
     from superlocalmemory.cli.escape_hatch import cmd_disable
     cmd_disable(args)
@@ -98,6 +106,11 @@ def _cmd_help_optimize(args: Namespace) -> None:
     cmd_help_optimize(args)
 
 
+def _cmd_loop(args: Namespace) -> None:
+    from superlocalmemory.cli.loop_cmd import cmd_loop
+    cmd_loop(args)
+
+
 # ---- end SLM v3.6 Optimize dispatch functions ----
 
 
@@ -201,6 +214,8 @@ def dispatch(args: Namespace) -> None:
         "context": _cmd_context_dispatch,
         # V3.4.22 LLD-06 additive schema migrations
         "db": _cmd_db_dispatch,
+        # V3.7.9 M-03 — terminal mesh inspection
+        "mesh": _cmd_mesh_dispatch,
         # V3.4.22 Stage 8 SB-5 — MASTER-PLAN §8 escape hatches.
         "disable": _cmd_escape_disable,
         "enable": _cmd_escape_enable,
@@ -218,6 +233,8 @@ def dispatch(args: Namespace) -> None:
         "compress": _cmd_compress,
         "proxy": _cmd_proxy,
         "help-optimize": _cmd_help_optimize,
+        # V3.8.0 bounded loops (gate-verified agent loops, SLM-backed ledger)
+        "loop": _cmd_loop,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -345,6 +362,11 @@ def cmd_serve(args: Namespace) -> None:
     else:
         from superlocalmemory.infra.data_root import state_path
         print(f"Failed to start daemon. Check {state_path('logs', 'daemon.log')}")
+        # INT-H-02: exit non-zero so callers can detect the failure. The plugin
+        # launcher (plugin/scripts/slm-launch) guards on this exit code and
+        # refuses to open a direct MCP writer against a broken daemon; without
+        # the non-zero exit that guard was a dead no-op.
+        sys.exit(1)
 
 
 # -- Ingestion Adapters (V3.4.3) ------------------------------------------
@@ -610,6 +632,8 @@ def cmd_config(args: Namespace) -> None:
     elif action == "set":
         _ALLOWED_CONFIG_KEYS = {
             "evolution.enabled", "evolution.backend", "evolution.max_evolutions_per_cycle",
+            "evolution.mutation_model", "evolution.verify_model",
+            "evolution.confirm_model",
             "mesh_enabled", "daemon_idle_timeout", "entity_compilation_enabled",
             "graph_backend", "vector_backend", "scale_engine_state",
             "scope.default_scope", "scope.recall_include_global",
@@ -677,6 +701,31 @@ def cmd_config(args: Namespace) -> None:
                 print(f"Error: {message}")
             sys.exit(1)
 
+        _MODEL_KEYS = {
+            "evolution.mutation_model", "evolution.verify_model",
+            "evolution.confirm_model",
+        }
+        if key in _MODEL_KEYS:
+            from superlocalmemory.evolution.model_selection import _MODEL_ALIASES
+
+            accepted = set(_MODEL_ALIASES) | {"", "auto"}
+            sval = str(parsed_value)
+            if sval not in accepted:
+                allowed = ", ".join(["auto", *sorted(_MODEL_ALIASES)])
+                message = f"{key} must be one of: {allowed}"
+                if use_json:
+                    from superlocalmemory.cli.json_output import json_print
+                    json_print("config", error={
+                        "code": "INVALID_VALUE", "message": message,
+                    })
+                else:
+                    print(f"Error: {message}")
+                sys.exit(1)
+            # Normalise the "auto" sentinel to the empty string the
+            # resolver treats as "pick the cheapest for the backend".
+            if sval == "auto":
+                parsed_value = ""
+
         if key.startswith("scope."):
             from superlocalmemory.cli.daemon import daemon_request, is_daemon_running
 
@@ -727,6 +776,18 @@ def cmd_config(args: Namespace) -> None:
             })
         else:
             print(f"{key}: {old_value} -> {parsed_value}")
+            if key == "evolution.enabled" and parsed_value is True:
+                print(
+                    "\n⚠  Skill evolution is now ON. It makes background "
+                    "LLM calls during consolidation\n"
+                    "   (capped at 10 calls/cycle, 3 cycles/day). It defaults "
+                    "to the lowest-cost model\n"
+                    "   for your backend (Claude → Haiku, Ollama → "
+                    "local/free).\n"
+                    "   Pick models: slm config set evolution.mutation_model "
+                    "<auto|haiku|sonnet|ollama>\n"
+                    "   Turn off:    slm config set evolution.enabled false"
+                )
 
     else:
         if use_json:
@@ -1271,10 +1332,12 @@ def cmd_recall(args: Namespace) -> None:
                 scope_qs += f"&include_global={str(include_global).lower()}"
             if include_shared is not None:
                 scope_qs += f"&include_shared={str(include_shared).lower()}"
+            _window = getattr(args, "window", "") or ""
+            window_qs = f"&window={quote(_window)}" if _window else ""
             result = daemon_request(
                 "GET",
                 f"/recall?q={quote(args.query)}&limit={args.limit}"
-                f"&session_id={quote(session_id)}{fast_qs}{scope_qs}",
+                f"&session_id={quote(session_id)}{fast_qs}{scope_qs}{window_qs}",
             )
             if result and "results" in result:
                 # Format daemon response same as engine response
@@ -1294,8 +1357,10 @@ def cmd_recall(args: Namespace) -> None:
                 for i, r in enumerate(result["results"], 1):
                     print(f"  {i}. [{r['score']:.2f}] {r['content']}")
                 return
-    except Exception:
-        pass  # Fall through to direct engine
+    except Exception as _exc:  # noqa: BLE001
+        logger.warning(
+            "Daemon recall failed, falling back to direct engine: %s", _exc
+        )
 
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.engine import MemoryEngine
@@ -1310,6 +1375,7 @@ def cmd_recall(args: Namespace) -> None:
             fast=getattr(args, "fast", False),
             include_global=include_global,
             include_shared=include_shared,
+            window=getattr(args, "window", "") or None,
         )
     except Exception as exc:
         if use_json:
@@ -1394,12 +1460,32 @@ def cmd_forget(args: Namespace) -> None:
     from superlocalmemory.core.config import SLMConfig
 
     use_json = getattr(args, 'json', False)
+    dry_run = getattr(args, 'dry_run', False)
+    raw_query = getattr(args, 'query', None)
+
+    # F3: `query` is optional so `slm forget --dry-run` can preview every memory.
+    # Deletion ALWAYS requires an explicit query — a bare `slm forget` must never
+    # mass-delete. In dry-run mode a missing query means "match all" (preview).
+    if raw_query is None and not dry_run:
+        msg = (
+            "A query is required to delete. Preview everything with "
+            "'slm forget --dry-run', or delete matches with 'slm forget <query>'."
+        )
+        if use_json:
+            from superlocalmemory.cli.json_output import json_print
+            json_print("forget", error={"code": "QUERY_REQUIRED", "message": msg})
+        else:
+            print(msg)
+        sys.exit(2)
+
+    query_lower = "" if raw_query is None else raw_query.lower()
+    query_label = raw_query if raw_query is not None else "*all*"
+
     try:
         config = SLMConfig.load()
         engine = MemoryEngine(config)
         engine.initialize()
         facts = engine._db.get_all_facts(engine.profile_id)
-        query_lower = args.query.lower()
         matches = [f for f in facts if query_lower in f.content.lower()]
     except Exception as exc:
         if use_json:
@@ -1408,8 +1494,6 @@ def cmd_forget(args: Namespace) -> None:
             sys.exit(1)
         raise
 
-    dry_run = getattr(args, 'dry_run', False)
-
     def delete_fact_authorized_for_cli(fact_id: str) -> None:
         from superlocalmemory.core.engine_ingestion import local_trusted_actor_id
         from superlocalmemory.core.mutations import delete_fact_authorized
@@ -1450,12 +1534,12 @@ def cmd_forget(args: Namespace) -> None:
                 "matches": match_items,
                 "hint": "Add --yes to confirm deletion",
             }, next_actions=[
-                {"command": f"slm forget '{args.query}' --json --yes", "description": "Confirm deletion"},
+                {"command": f"slm forget '{query_label}' --json --yes", "description": "Confirm deletion"},
             ])
         return
 
     if not matches:
-        print(f"No memories matching '{args.query}'")
+        print(f"No memories matching '{query_label}'")
         return
     print(f"Found {len(matches)} matching memories:")
     for f in matches[:10]:
@@ -1835,8 +1919,8 @@ def cmd_health(args: Namespace) -> None:
 
     print("Math Layer Health:")
     print(f"  Total facts: {len(facts)}")
-    print(f"  Fisher-Rao indexed: {fisher_count}/{len(facts)}")
-    print(f"  Langevin positioned: {langevin_count}/{len(facts)}")
+    print(f"  Math layer indexed: {fisher_count}/{len(facts)}")
+    print(f"  Lifecycle positioned: {langevin_count}/{len(facts)}")
     print(f"  Mode: {config.mode.value.upper()}")
 
 
@@ -1999,7 +2083,7 @@ def cmd_doctor(args: Namespace) -> None:
 
     # 3. Search deps
     search_mods = {"sentence_transformers": "sentence-transformers", "torch": "torch",
-                   "sklearn": "scikit-learn", "geoopt": "geoopt"}
+                   "sklearn": "scikit-learn"}
     search_ok = []
     for mod, pkg in search_mods.items():
         try:
@@ -2008,7 +2092,7 @@ def cmd_doctor(args: Namespace) -> None:
         except Exception:  # dependency import may fail after module discovery
             pass
     if len(search_ok) == len(search_mods):
-        _check("Search deps", "PASS", "sentence-transformers, torch, sklearn, geoopt")
+        _check("Search deps", "PASS", "sentence-transformers, torch, sklearn")
     else:
         missing = set(search_mods) - set(search_ok)
         _check("Search deps", "WARN", f"Missing: {', '.join(missing)}",

package/src/superlocalmemory/cli/compress_cmd.py

@@ -118,8 +118,13 @@ def cmd_compress_prose(args: Namespace) -> None:
     cfg = store.get()
 
     fields: dict = {"compress_prose": (value == "on")}
-    if value == "on" and not cfg.compress_enabled:
-        fields["compress_enabled"] = True
+    if value == "on":
+        # Prose (Layer 2) only fires in aggressive mode, so turning it on sets a
+        # COHERENT state — it can never be left enabled-but-inert in safe mode.
+        if not cfg.compress_enabled:
+            fields["compress_enabled"] = True
+        if cfg.compress_mode != "aggressive":
+            fields["compress_mode"] = "aggressive"
 
     try:
         cfg = dataclasses.replace(cfg, **fields)
@@ -129,13 +134,18 @@ def cmd_compress_prose(args: Namespace) -> None:
         sys.exit(1)
 
     if use_json:
-        print(json.dumps({"status": "ok", "compress_prose": value == "on"}))
+        print(json.dumps({
+            "status": "ok",
+            "compress_prose": value == "on",
+            "compress_mode": cfg.compress_mode,
+        }))
         return
 
     print(f"Prose compression (LLMLingua-2): {'ENABLED' if value == 'on' else 'DISABLED'}.")
     if value == "on":
-        print("  Requires: compress_mode=aggressive and llmlingua package installed.")
-        print("  Run: slm compress mode aggressive  (if not already set)")
-    if value == "on" and "compress_enabled" in fields:
-        print("  (also enabled global compress)")
+        if "compress_mode" in fields:
+            print("  Compression mode set to 'aggressive' (required for Layer 2).")
+        print("  Requires the llmlingua package for lossy prose compression.")
+        if "compress_enabled" in fields:
+            print("  (also enabled global compression)")
     print("Daemon hot-reload: active within 2s.")

package/src/superlocalmemory/cli/loop_cmd.py

@@ -0,0 +1,192 @@
+"""``slm loop`` — inspect and demonstrate bounded loops backed by SLM memory.
+
+Subcommands:
+
+* ``slm loop demo``            run a built-in, keyless convergence demo (stub
+                              proposer + deterministic gate) and persist every
+                              lap to SLM memory. Proves the engine + ledger
+                              end to end without a credentialed agent.
+* ``slm loop history [--name]`` list recorded loop runs from SLM memory.
+* ``slm loop show <run_id>``   show every lap of one run.
+
+The durable value here is that a loop's history lives in the same SLM data
+root as everything else the agent remembers — queryable via ``slm recall`` and
+visible in the dashboard. Reads and the demo run through an in-process engine
+store rooted at the active data root (``SLM_DATA_DIR`` or
+``~/.superlocalmemory``); point ``SLM_DATA_DIR`` elsewhere to sandbox a run.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from argparse import Namespace
+from pathlib import Path
+from typing import Any
+
+from superlocalmemory.loops import (
+    Bounds,
+    LapResult,
+    SLMMemoryLedger,
+    Verdict,
+    open_engine_store,
+    run_bounded_loop,
+)
+
+
+def _data_root() -> Path:
+    value = (
+        os.environ.get("SLM_DATA_DIR")
+        or os.environ.get("SL_MEMORY_PATH")
+        or os.environ.get("SLM_HOME")
+    )
+    return Path(value).expanduser() if value else Path.home() / ".superlocalmemory"
+
+
+class _FailOpenLedger:
+    """Wrap a ledger so a memory write hiccup never aborts a running loop.
+
+    A ledger is observability; the loop's correctness comes from the gate.
+    Write errors are counted and surfaced after the run rather than raised
+    mid-flight, so we never silently pretend they did not happen.
+    """
+
+    def __init__(self, inner: Any) -> None:
+        self._inner = inner
+        self.write_errors: list[str] = []
+
+    def record(self, entry: Any) -> None:
+        try:
+            self._inner.record(entry)
+        except Exception as exc:  # pragma: no cover - defensive path
+            self.write_errors.append(f"lap {getattr(entry, 'lap', '?')}: {exc}")
+
+    def laps(self, run_id: str) -> list:
+        return self._inner.laps(run_id)
+
+    def runs(self, name: str) -> list:
+        return self._inner.runs(name)
+
+
+def _open_ledger() -> tuple[SLMMemoryLedger, Any]:
+    store = open_engine_store(_data_root() / "memory.db")
+    return SLMMemoryLedger(store), store
+
+
+def cmd_loop(args: Namespace) -> None:
+    action = getattr(args, "loop_command", None)
+    if action == "demo":
+        _cmd_demo(args)
+    elif action == "history":
+        _cmd_history(args)
+    elif action == "show":
+        _cmd_show(args)
+    else:
+        print("Usage: slm loop {demo|history|show} [options]")
+
+
+def _cmd_demo(args: Namespace) -> None:
+    """Run the convergence demo: the gate fails twice, then passes on lap 3."""
+    iterations = int(getattr(args, "iterations", 10) or 10)
+    as_json = bool(getattr(args, "json", False))
+    pass_on = 3
+
+    ledger, store = _open_ledger()
+    guarded = _FailOpenLedger(ledger)
+    try:
+        outcome = run_bounded_loop(
+            "convergence-demo",
+            bounds=Bounds(max_iterations=iterations),
+            runner=lambda lap: LapResult(changed=True, tokens=8),
+            gate=lambda lap: Verdict(lap >= pass_on, f"demo gate: lap {lap}"),
+            ledger=guarded,
+        )
+        laps = guarded.laps(outcome.run_id)
+    finally:
+        store.close()
+
+    if as_json:
+        print(json.dumps({
+            "status": outcome.status.value,
+            "reason": outcome.reason,
+            "laps": outcome.laps,
+            "run_id": outcome.run_id,
+            "ledger": [
+                {"lap": e.lap, "decision": e.decision, "passed": e.passed}
+                for e in laps
+            ],
+            "write_errors": guarded.write_errors,
+        }, indent=2))
+        return
+
+    mark = "✓" if outcome.ok else "✗"
+    print(f"{mark} [{outcome.status.value}] {outcome.reason} (laps: {outcome.laps})")
+    for e in laps:
+        gate = "gate-pass" if e.passed else "gate-fail"
+        print(f"   lap {e.lap}: {e.decision:<8} {gate}  {e.detail}")
+    print(f"run_id: {outcome.run_id}  (recall with tag loop:convergence-demo)")
+    if guarded.write_errors:
+        print(f"WARNING: {len(guarded.write_errors)} ledger write error(s): "
+              f"{guarded.write_errors[0]}")
+
+
+def _cmd_history(args: Namespace) -> None:
+    name = getattr(args, "name", None) or "convergence-demo"
+    as_json = bool(getattr(args, "json", False))
+    ledger, store = _open_ledger()
+    try:
+        run_ids = ledger.runs(name)
+        rows = []
+        for rid in run_ids:
+            laps = ledger.laps(rid)
+            last = laps[-1] if laps else None
+            rows.append({
+                "run_id": rid,
+                "laps": len(laps),
+                "final": last.decision if last else "unknown",
+                "ts": last.ts if last else "",
+            })
+    finally:
+        store.close()
+
+    if as_json:
+        print(json.dumps({"name": name, "runs": rows}, indent=2))
+        return
+    if not rows:
+        print(f"No recorded runs for loop '{name}'.")
+        return
+    print(f"Runs for loop '{name}':")
+    for r in rows:
+        print(f"  {r['run_id']:<28} laps={r['laps']:<3} final={r['final']:<8} {r['ts']}")
+
+
+def _cmd_show(args: Namespace) -> None:
+    run_id = getattr(args, "run_id", None)
+    as_json = bool(getattr(args, "json", False))
+    if not run_id:
+        print("Usage: slm loop show <run_id>")
+        return
+    ledger, store = _open_ledger()
+    try:
+        laps = ledger.laps(run_id)
+    finally:
+        store.close()
+
+    if as_json:
+        print(json.dumps({
+            "run_id": run_id,
+            "laps": [
+                {"lap": e.lap, "ts": e.ts, "decision": e.decision,
+                 "passed": e.passed, "detail": e.detail, "budget": e.budget}
+                for e in laps
+            ],
+        }, indent=2))
+        return
+    if not laps:
+        print(f"No ledger entries for run '{run_id}'.")
+        return
+    print(f"Loop run {run_id} ({laps[0].name}):")
+    for e in laps:
+        gate = "gate-pass" if e.passed else "gate-fail"
+        print(f"  lap {e.lap}: {e.decision:<8} {gate}  {e.detail}  "
+              f"[tokens={e.budget.get('tokens', 0)}]")

package/src/superlocalmemory/cli/main.py

@@ -80,6 +80,8 @@ _NO_DAEMON_COMMANDS = {
     "wrap",
     # V3.6 Optimize commands that are config read/write only.
     "optimize", "cache", "compress", "help-optimize",
+    # Bounded loops use an in-process engine store, not the daemon.
+    "loop",
     # Lifecycle orchestration must run before any global auto-start hook.
     "serve", "restart",
 }
@@ -276,6 +278,14 @@ def main() -> None:
     db_scale_p.add_argument("--stage-id", help="Stage identifier required by verify/promote")
     db_scale_p.add_argument("--backup-id", help="Backup identifier required by rollback")
 
+    # -- Mesh inspection (v3.7.9, M-03) --------------------------------
+    mesh_p = sub.add_parser("mesh", help="Inspect the local agent mesh (status/peers)")
+    mesh_p.add_argument(
+        "mesh_action",
+        choices=("status", "peers"),
+        help="status: broker health + stats; peers: active peer sessions",
+    )
+
     # -- Memory Operations ---------------------------------------------
     remember_p = sub.add_parser("remember", help="Store a memory (extracts facts, builds graph)")
     remember_p.add_argument("content", help="Content to remember")
@@ -304,9 +314,15 @@ def main() -> None:
         help=f"Max results (default {CANONICAL_RECALL_LIMIT})",
     )
     recall_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
+    recall_p.add_argument(
+        "--window", default="",
+        help="Restrict results to an event-time range: a relative span "
+             "(24h, 7d, 30d, 1y) or an explicit range (2026-07-01..2026-07-31). "
+             "Default: no time filter.",
+    )
     recall_p.add_argument(
         "--fast", action="store_true",
-        help="Skip spreading activation and remote agentic verification for a "
+        help="Skip graph-assisted candidate expansion and remote agentic verification for a "
              "latency-bounded response. Other configured retrieval channels still run. "
              "Use when you need recall before a tool call (e.g. before WebSearch).",
     )
@@ -332,8 +348,8 @@ def main() -> None:
     )
 
     forget_p = sub.add_parser("forget", help="Delete memories matching a query (fuzzy)")
-    forget_p.add_argument("query", help="Query to match for deletion")
-    forget_p.add_argument("--dry-run", action="store_true", default=False, help="Preview matches without deleting")
+    forget_p.add_argument("query", nargs="?", default=None, help="Query to match for deletion. Optional with --dry-run (previews all memories).")
+    forget_p.add_argument("--dry-run", action="store_true", default=False, help="Preview matches without deleting. With no query, previews every memory.")
     forget_p.add_argument("--yes", "-y", action="store_true", help="Skip confirmation prompt")
     forget_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
@@ -361,7 +377,7 @@ def main() -> None:
         help="Show extended status: migration log, daemon port, disabled marker, last version",
     )
 
-    health_p = sub.add_parser("health", help="Math layer health (Fisher-Rao, Sheaf, Langevin)")
+    health_p = sub.add_parser("health", help="Math layer health (scoring, consistency, and lifecycle layers)")
     health_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     trace_p = sub.add_parser("trace", help="Recall with per-channel score breakdown")
@@ -774,6 +790,25 @@ def main() -> None:
 
     # ---- end SLM v3.6 Optimize subcommands ----
 
+    # slm loop demo|history|show — bounded, gate-verified agent loops (v3.8.0)
+    loop_p = sub.add_parser(
+        "loop",
+        help="Bounded loops: gate-verified agent loops with an SLM-backed ledger",
+    )
+    loop_sub = loop_p.add_subparsers(dest="loop_command", title="loop subcommands")
+    loop_demo_p = loop_sub.add_parser(
+        "demo", help="Run the keyless convergence demo (proves engine + ledger)")
+    loop_demo_p.add_argument(
+        "--iterations", type=int, default=10, help="Max iterations (default: 10)")
+    loop_hist_p = loop_sub.add_parser("history", help="List recorded loop runs")
+    loop_hist_p.add_argument(
+        "--name", default=None, help="Loop name (default: convergence-demo)")
+    loop_show_p = loop_sub.add_parser("show", help="Show every lap of one run")
+    loop_show_p.add_argument("run_id", help="Run id (from history)")
+    for _sp in loop_sub.choices.values():
+        _sp.add_argument("--json", action="store_true",
+                         help="Output structured JSON (agent-native)")
+
     args = parser.parse_args()
 
     if not args.command:

package/src/superlocalmemory/cli/mesh_cmd.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later
+"""`slm mesh` — inspect the local agent mesh from the terminal (M-03, v3.7.9).
+
+Before 3.7.9 the mesh was reachable only via MCP tools, the dashboard, and
+Claude Code skills — there was no terminal command to check broker health or
+list peer sessions. This is a thin, read-only wrapper over the same
+capability-authenticated `/mesh/*` daemon endpoints the MCP tools use.
+"""
+from __future__ import annotations
+
+import json
+from argparse import Namespace
+
+_ACTION_ENDPOINTS = {
+    "status": "/mesh/status",
+    "peers": "/mesh/peers",
+}
+
+
+def cmd_mesh(args: Namespace) -> int:
+    action = getattr(args, "mesh_action", None)
+    endpoint = _ACTION_ENDPOINTS.get(action)
+    if endpoint is None:
+        print("Usage: slm mesh {status|peers}")
+        return 2
+
+    from superlocalmemory.cli.daemon import daemon_request
+
+    result = daemon_request("GET", endpoint)
+    if result is None:
+        print(
+            "Mesh: cannot reach the daemon broker. Is the daemon running? "
+            "(slm serve start)"
+        )
+        return 1
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0

package/src/superlocalmemory/cli/optimize_cmd.py

@@ -98,6 +98,9 @@ def cmd_optimize_status(args: Namespace) -> None:
     print(f"  Compress:  {'enabled' if cfg.compress_enabled else 'disabled'}"
           f"  (mode: {cfg.compress_mode},"
           f" prose/L2: {'ON' if cfg.compress_prose else 'OFF'})")
+    if cfg.compress_prose or cfg.compress_mode == "aggressive":
+        print("             note: the live proxy applies LOSSLESS compression only;"
+              " lossy Layer-2 (prose) runs via the slm_compress tool.")
     proxy_status = f"running on :{OPTIMIZE_DEFAULT_PORT}" if proxy_running else "not running"
     print(f"  Proxy:     {proxy_status}")
     print(f"  Config:    ~/.superlocalmemory/optimize.json  (version {cfg.config_version})")