superlocalmemory 3.8.13 → 4.0.0

package/src/superlocalmemory/__init__.py

@@ -32,7 +32,7 @@ if "OMP_NUM_THREADS" not in os.environ:
     os.environ["OMP_NUM_THREADS"] = "2"
 # ---------------------------------------------------------------------------
 
-__version__ = "3.8.13"
+__version__ = "4.0.0"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/commands.py

@@ -270,6 +270,12 @@ def _cmd_loop(args: Namespace) -> None:
     cmd_loop(args)
 
 
+def _cmd_ops(args: Namespace) -> None:
+    """Wave-3: operational recovery & admin remediation commands."""
+    from superlocalmemory.cli.ops_cmd import cmd_ops
+    cmd_ops(args)
+
+
 # ---- end SLM v3.6 Optimize dispatch functions ----
 
 
@@ -399,6 +405,8 @@ def dispatch(args: Namespace) -> None:
         "loop": _cmd_loop,
         # V3.8.2 super-help — grouped overview of every command + topics
         "help": cmd_help,
+        # Wave-3: operational recovery & admin remediation
+        "ops": _cmd_ops,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -982,6 +990,10 @@ def cmd_evolve(args: Namespace) -> None:
     if not session_id:
         return  # Silent exit — nothing to do without a session
 
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.EVOLVE_SKILL)
+
     # Check if evolution is enabled via config.json
     config_path = state_path("config.json")
     try:
@@ -1059,6 +1071,11 @@ def cmd_mode(args: Namespace) -> None:
 
     config = SLMConfig.load()
 
+    if args.value:
+        from superlocalmemory.core.admission import gate_cli_mutation
+        from superlocalmemory.core.operation_request import OperationKind
+        gate_cli_mutation(OperationKind.MODE_CHANGE)
+
     if getattr(args, 'json', False):
         from superlocalmemory.cli.json_output import json_print
         if args.value:
@@ -1431,6 +1448,9 @@ def cmd_recall(args: Namespace) -> None:
     # produces True/False here.
     include_global = getattr(args, 'include_global', None)
     include_shared = getattr(args, 'include_shared', None)
+    # Phase-1/D2: clamp cross-profile scope flags before forwarding to daemon.
+    from superlocalmemory.core.admission import enforce_read_scope
+    include_global, include_shared = enforce_read_scope(include_global, include_shared)
 
     # V3.3.21: Route through daemon for instant response (no cold start).
     # S9-DASH-02: pass a stable session_id derived from the shell's
@@ -1453,10 +1473,23 @@ def cmd_recall(args: Namespace) -> None:
                 scope_qs += f"&include_shared={str(include_shared).lower()}"
             _window = getattr(args, "window", "") or ""
             window_qs = f"&window={quote(_window)}" if _window else ""
+            _as_of = getattr(args, "as_of", "") or ""
+            if _as_of:
+                from superlocalmemory.retrieval.temporal_utils import normalize_as_of
+                _as_of_norm = normalize_as_of(_as_of)
+                if _as_of_norm is None:
+                    import sys as _sys
+                    _sys.stderr.write(
+                        f"Error: invalid --as-of value: {_as_of!r}\n"
+                        "Expected ISO 8601 UTC datetime, e.g. '2024-01-01T00:00:00Z'.\n"
+                    )
+                    _sys.exit(1)
+                _as_of = _as_of_norm
+            as_of_qs = f"&as_of={quote(_as_of)}" if _as_of else ""
             result = daemon_request(
                 "GET",
                 f"/recall?q={quote(args.query)}&limit={args.limit}"
-                f"&session_id={quote(session_id)}{fast_qs}{scope_qs}{window_qs}",
+                f"&session_id={quote(session_id)}{fast_qs}{scope_qs}{window_qs}{as_of_qs}",
             )
             if result and "results" in result:
                 # Format daemon response same as engine response
@@ -1522,6 +1555,10 @@ def _cli_record_signals(config, query, results):
 
 def cmd_forget(args: Namespace) -> None:
     """Delete daemon-queried memories matching a query."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.FORGET)
+
     import urllib.parse
 
     from superlocalmemory.cli.daemon import (
@@ -1644,6 +1681,10 @@ def cmd_forget(args: Namespace) -> None:
 
 def cmd_delete(args: Namespace) -> None:
     """Delete a specific memory by exact fact ID."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.FORGET)
+
     import urllib.parse
 
     from superlocalmemory.cli.daemon import (
@@ -1711,6 +1752,10 @@ def cmd_delete(args: Namespace) -> None:
 
 def cmd_update(args: Namespace) -> None:
     """Update the content of a specific memory by exact fact ID."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.CORRECT)
+
     import urllib.parse
 
     from superlocalmemory.cli.daemon import (
@@ -1863,7 +1908,7 @@ def cmd_status(args: Namespace) -> None:
         ])
         return
 
-    print("SuperLocalMemory V3")
+    print("SuperLocalMemory V4")
     print(f"  Mode: {config.mode.value.upper()}")
     print(f"  Provider: {config.llm.provider or 'none'}")
     print(
@@ -2023,14 +2068,36 @@ def _gather_optimize_surface_b() -> dict:
 def _readline_with_timeout(
     stream, timeout_sec: float,
 ) -> tuple[str | None, Exception | None]:
-    """Read one line from a pipe-like stream without POSIX-only select().
+    """Read one line from a pipe-like stream with a deadline.
 
-    Windows select() only accepts sockets, not subprocess pipes. A bounded
-    helper thread keeps the embedding-worker probe cross-platform while
-    preserving the existing timeout behavior.
+    Prefer a selector poll of the stream's file descriptor on POSIX so a
+    timeout never abandons a thread blocked in readline() (thread + FD leak).
+    Windows select() only accepts sockets, not subprocess pipes — fall back
+    to a bounded helper thread there and for streams without a usable fileno.
     """
+    import selectors
     import threading
 
+    timeout_sec = max(0.0, float(timeout_sec))
+    fd: int | None
+    try:
+        raw_fd = stream.fileno()
+        fd = raw_fd if isinstance(raw_fd, int) else None
+    except (AttributeError, OSError, ValueError, TypeError):
+        fd = None
+
+    if fd is not None and sys.platform != "win32":
+        try:
+            with selectors.DefaultSelector() as sel:
+                sel.register(fd, selectors.EVENT_READ)
+                events = sel.select(timeout=timeout_sec)
+            if not events:
+                return None, None
+            line = stream.readline()
+            return (line if isinstance(line, str) else None), None
+        except (OSError, ValueError) as exc:
+            return None, exc
+
     result: dict[str, object] = {}
 
     def _read() -> None:
@@ -2091,6 +2158,7 @@ _COMMAND_GROUPS: list[tuple[str, list[tuple[str, str]]]] = [
     ("Health & self-healing", [
         ("doctor", "Full pre-flight check (add --fix to auto-repair)"),
         ("health", "Quick math/retrieval layer status"),
+        ("ops", "List/resolve stuck, dead-lettered, or degraded operations (admin)"),
         ("diagnostics", "Export a local diagnostics bundle"),
         ("evidence", "Build/inspect evidence bundles"),
         ("rotate-token", "Rotate the local dashboard install token"),
@@ -2207,7 +2275,7 @@ def cmd_help(args: Namespace) -> None:
         return
 
     from superlocalmemory.cli.json_output import _get_version
-    print(f"SuperLocalMemory V3 ({_get_version()}) — command overview")
+    print(f"SuperLocalMemory V4 ({_get_version()}) — command overview")
     print("=" * 58)
     print("Run any command with -h for its options, e.g.  slm recall -h\n")
     for title, rows in _COMMAND_GROUPS:
@@ -2254,7 +2322,7 @@ def cmd_doctor(args: Namespace) -> None:
             print(line)
 
     if not use_json:
-        print("SuperLocalMemory V3 — Doctor (Pre-flight Check)")
+        print("SuperLocalMemory V4 — Doctor (Pre-flight Check)")
         print("=" * 50)
         print()
 
@@ -2286,6 +2354,32 @@ def cmd_doctor(args: Namespace) -> None:
             if not use_json:
                 print(f"  auto-repair error: {_fix_exc}\n")
 
+        # H5 — stale-artifact reap (additive; runs after component healer).
+        # Removes provably-dead lock/PID files so the doctor report below
+        # reflects the healed state.  Fail-open — never blocks doctor.
+        try:
+            from superlocalmemory.infra.self_heal import reap_stale_artifacts
+            from superlocalmemory.infra.data_root import canonical_data_root
+
+            _sh_report = reap_stale_artifacts(canonical_data_root())
+            if not use_json:
+                if _sh_report["removed"]:
+                    print(
+                        f"  Cleaned {len(_sh_report['removed'])} stale"
+                        " lock/pid file(s):"
+                    )
+                    for _item in _sh_report["removed"]:
+                        print(
+                            f"    - {Path(_item['path']).name}"
+                            f" ({_item['reason']})"
+                        )
+                else:
+                    print("  No stale lock/pid files found.")
+                print()
+        except Exception as _sh_exc:
+            if not use_json:
+                print(f"  stale-artifact cleanup skipped: {_sh_exc}\n")
+
     # 1. Python version
     v = sys.version_info
     if v >= (3, 11):
@@ -2884,7 +2978,7 @@ def cmd_warmup(_args: Namespace) -> None:
     """
     import superlocalmemory.core.embeddings as _emb_mod
 
-    print("SuperLocalMemory V3 — Embedding Model Warmup")
+    print("SuperLocalMemory V4 — Embedding Model Warmup")
     print("=" * 50)
     print(f"  Python: {sys.executable}")
     print(f"  Model:  nomic-ai/nomic-embed-text-v1.5 (~500MB)")
@@ -2994,10 +3088,10 @@ def cmd_dashboard(args: Namespace) -> None:
 
     port = getattr(args, "port", None) or _get_port()
 
-    print("  SuperLocalMemory V3 — Web Dashboard")
+    print("  SuperLocalMemory V4 — Web Dashboard")
     print(f"  Starting daemon if needed...")
 
-    if not ensure_daemon():
+    if not ensure_daemon(port=port):
         print("  ✗ Could not start daemon. Run `slm doctor` to diagnose.")
         sys.exit(1)
 
@@ -3057,6 +3151,12 @@ def cmd_profile(args: Namespace) -> None:
     Writes to BOTH SQLite and profiles.json so CLI, Dashboard, and
     MCP all see the same profiles.
     """
+    action = getattr(args, "action", "list")
+    if action in ("switch", "create"):
+        from superlocalmemory.core.admission import gate_cli_mutation
+        from superlocalmemory.core.operation_request import OperationKind
+        gate_cli_mutation(OperationKind.PROFILE_SWITCH)
+
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.storage.database import DatabaseManager
     from superlocalmemory.storage import schema
@@ -3598,6 +3698,10 @@ def cmd_observe(args: Namespace) -> None:
         print("No content to observe.")
         return
 
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.REMEMBER)
+
     # V3.3.28: Route through daemon (singleton engine, single embedding worker).
     # This is the P0 fix for the memory blast incident of April 7, 2026.
     try:
@@ -3665,6 +3769,9 @@ def cmd_observe(args: Namespace) -> None:
 
 def cmd_decay(args: Namespace) -> None:
     """Run Ebbinghaus forgetting decay cycle."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.CONSOLIDATE)
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.engine import MemoryEngine
 
@@ -3721,6 +3828,9 @@ def cmd_decay(args: Namespace) -> None:
 
 def cmd_quantize(args: Namespace) -> None:
     """Run EAP embedding quantization cycle."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.CONSOLIDATE)
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.engine import MemoryEngine
 
@@ -3779,6 +3889,10 @@ def cmd_quantize(args: Namespace) -> None:
 
 def cmd_consolidate(args: Namespace) -> None:
     """Run cognitive consolidation pipeline."""
+    from superlocalmemory.core.admission import gate_cli_mutation
+    from superlocalmemory.core.operation_request import OperationKind
+    gate_cli_mutation(OperationKind.CONSOLIDATE)
+
     from superlocalmemory.core.config import SLMConfig
     from superlocalmemory.core.engine import MemoryEngine
 

package/src/superlocalmemory/cli/daemon.py

@@ -508,9 +508,13 @@ def _start_daemon_subprocess() -> bool:
     return _wait_for_daemon(timeout=60)
 
 
-def ensure_daemon() -> bool:
+def ensure_daemon(*, port: int | None = None) -> bool:
     """Start daemon if not running. Returns True if daemon is ready.
 
+    ``port`` — when supplied, the daemon is started (or verified) on this port
+    instead of the configured default.  The dashboard passes its own ``--port``
+    here so the bind authority matches the URL shown to the user.
+
     v3.4.4 BULLETPROOF:
       1. If PID alive → return True immediately (even if warming up)
       2. File lock prevents two callers from starting concurrent daemons

package/src/superlocalmemory/cli/main.py

@@ -179,7 +179,7 @@ def main() -> None:
 
     parser = argparse.ArgumentParser(
         prog="slm",
-        description=f"SuperLocalMemory V3 ({_ver}) — AI agent memory with mathematical foundations",
+        description=f"SuperLocalMemory V4 ({_ver}) — AI agent memory with mathematical foundations",
         epilog=_HELP_EPILOG,
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
@@ -388,6 +388,12 @@ def main() -> None:
              "(24h, 7d, 30d, 1y) or an explicit range (2026-07-01..2026-07-31). "
              "Default: no time filter.",
     )
+    recall_p.add_argument(
+        "--as-of", dest="as_of", default="",
+        help="Point-in-time recall: an ISO-8601 timestamp "
+             "(2026-01-01T00:00:00+00:00) that pins retrieval to a temporal "
+             "snapshot. Default: current-state recall.",
+    )
     recall_p.add_argument(
         "--fast", action="store_true",
         help="Force-skip the internal agentic verification round (all six retrieval "
@@ -513,7 +519,7 @@ def main() -> None:
     sub.add_parser("mcp", help="Start MCP server (stdio transport for IDE integration)")
     sub.add_parser("warmup", help="Pre-download embedding model (~500MB, one-time)")
 
-    dashboard_p = sub.add_parser("dashboard", help="Open 17-tab web dashboard")
+    dashboard_p = sub.add_parser("dashboard", help="Open web dashboard")
     dashboard_p.add_argument(
         "--port", type=int, default=8765, help="Port (default 8765)",
     )
@@ -903,6 +909,33 @@ def main() -> None:
         _sp.add_argument("--json", action="store_true",
                          help="Output structured JSON (agent-native)")
 
+    # Wave-3: operational recovery & admin remediation
+    ops_p = sub.add_parser(
+        "ops",
+        help="Operational recovery: list failures, resolve stuck ops, check status",
+    )
+    ops_sub = ops_p.add_subparsers(dest="ops_command", title="ops subcommands")
+    ops_list_p = ops_sub.add_parser(
+        "list", help="List all failed, stuck, or degraded operations (admin)")
+    ops_list_p.add_argument(
+        "--profile", default=None, metavar="PROFILE",
+        help="Filter results to a specific profile (default: all)")
+    ops_list_p.add_argument(
+        "--json", action="store_true", help="Output structured JSON (agent-native)")
+    ops_resolve_p = ops_sub.add_parser(
+        "resolve", help="Admin action: retry / force-reconcile / cancel a stuck op")
+    ops_resolve_p.add_argument("operation_id", help="Operation ID from slm ops list")
+    ops_resolve_p.add_argument(
+        "--action", required=True,
+        choices=["retry", "force_reconcile", "cancel"],
+        help="Remediation action to apply")
+    ops_resolve_p.add_argument(
+        "--json", action="store_true", help="Output structured JSON (agent-native)")
+    ops_status_p = ops_sub.add_parser(
+        "status", help="Quick failure count + writer stall overview")
+    ops_status_p.add_argument(
+        "--json", action="store_true", help="Output structured JSON (agent-native)")
+
     args = parser.parse_args()
 
     if not args.command:

package/src/superlocalmemory/cli/ops_cmd.py

@@ -0,0 +1,281 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V4 | https://qualixar.com | https://varunpratap.com
+
+"""``slm ops`` — operational recovery & admin remediation.
+
+Subcommands:
+
+* ``slm ops list [--profile P]``
+      Show all failed, stuck, or degraded operations grouped by category.
+      Proxies GET /operations/failed on the running daemon.
+
+* ``slm ops resolve <id> --action {retry|force_reconcile|cancel}``
+      Admin action on a specific operation.
+      Proxies POST /operations/<id>/resolve on the running daemon.
+
+* ``slm ops status``
+      Quick overview: failure counts + writer stall state from /status.
+      No authentication required (status is public).
+
+RBAC: list / resolve require OWNER or ADMIN role on the daemon.
+Unauthenticated users see a clear permission error.
+
+Part of Qualixar | Author: Varun Pratap Bhardwaj
+"""
+
+from __future__ import annotations
+
+import json as _json
+import sys
+import urllib.error as _uerr
+import urllib.request as _urq
+from argparse import Namespace
+from typing import Any
+
+
+_VALID_ACTIONS = ("retry", "force_reconcile", "cancel")
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _get_daemon_port() -> int:
+    """Return the active daemon port (default 8765)."""
+    try:
+        from superlocalmemory.cli.daemon import _get_port
+        return _get_port()
+    except Exception:
+        return 8765
+
+
+def _daemon_get(path: str, timeout_s: float = 10.0) -> dict | None:
+    """HTTP GET to the daemon; return parsed JSON or None on failure."""
+    port = _get_daemon_port()
+    url = f"http://127.0.0.1:{port}{path}"
+    try:
+        with _urq.urlopen(url, timeout=timeout_s) as resp:  # noqa: S310
+            raw = resp.read().decode()
+        return _json.loads(raw)
+    except _uerr.HTTPError as exc:
+        if exc.code == 403:
+            _die(
+                "Permission denied: list/resolve requires OWNER or ADMIN role.\n"
+                "Check your SLM credentials or ask your administrator."
+            )
+        body = exc.read().decode(errors="replace") if hasattr(exc, "read") else str(exc)
+        _die(f"Daemon returned HTTP {exc.code}: {body}")
+    except _uerr.URLError as exc:
+        _die(
+            f"Could not reach SLM daemon at {url}: {exc.reason}\n"
+            "Make sure the daemon is running: slm serve"
+        )
+    return None  # unreachable; _die exits
+
+
+def _daemon_post(path: str, body: dict, timeout_s: float = 10.0) -> dict | None:
+    """HTTP POST to the daemon; return parsed JSON or None on failure."""
+    port = _get_daemon_port()
+    url = f"http://127.0.0.1:{port}{path}"
+    try:
+        req = _urq.Request(
+            url,
+            data=_json.dumps(body).encode(),
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with _urq.urlopen(req, timeout=timeout_s) as resp:  # noqa: S310
+            raw = resp.read().decode()
+        return _json.loads(raw)
+    except _uerr.HTTPError as exc:
+        if exc.code == 403:
+            _die(
+                "Permission denied: resolve requires OWNER or ADMIN role.\n"
+                "Check your SLM credentials or ask your administrator."
+            )
+        if exc.code == 400:
+            body_txt = exc.read().decode(errors="replace") if hasattr(exc, "read") else str(exc)
+            _die(f"Bad request: {body_txt}")
+        body_txt = exc.read().decode(errors="replace") if hasattr(exc, "read") else str(exc)
+        _die(f"Daemon returned HTTP {exc.code}: {body_txt}")
+    except _uerr.URLError as exc:
+        _die(
+            f"Could not reach SLM daemon at {url}: {exc.reason}\n"
+            "Make sure the daemon is running: slm serve"
+        )
+    return None  # unreachable; _die exits
+
+
+def _die(message: str) -> None:
+    print(f"error: {message}", file=sys.stderr)
+    sys.exit(1)
+
+
+def _print_json(data: Any) -> None:
+    print(_json.dumps(data, indent=2, default=str))
+
+
+# ---------------------------------------------------------------------------
+# Subcommand handlers
+# ---------------------------------------------------------------------------
+
+def _cmd_ops_list(args: Namespace) -> None:
+    """List all failed, stuck, or degraded operations."""
+    profile = getattr(args, "profile", None)
+    path = "/operations/failed"
+    if profile:
+        path = f"{path}?profile={profile}"
+
+    data = _daemon_get(path)
+    if data is None:
+        return
+
+    if getattr(args, "json", False):
+        _print_json(data)
+        return
+
+    total: int = data.get("total", 0)
+    if total == 0:
+        print("All operations healthy. No failures detected.")
+        return
+
+    print(f"Failed operations: {total} total\n")
+
+    dead_letter = data.get("dead_letter", [])
+    if dead_letter:
+        print(f"--- Dead-letter (ingestion exhausted, {len(dead_letter)}) ---")
+        for entry in dead_letter:
+            print(
+                f"  [{entry.get('operation_id', '?')}] "
+                f"type={entry.get('operation_type', '?')} "
+                f"attempts={entry.get('attempts', '?')} "
+                f"profile={entry.get('profile_id', '?')}"
+            )
+            if entry.get("error"):
+                print(f"    error: {entry['error']}")
+        print()
+
+    degraded = data.get("degraded_manifests", [])
+    if degraded:
+        print(f"--- Degraded manifests ({len(degraded)}) ---")
+        for entry in degraded:
+            print(
+                f"  [{entry.get('operation_id', '?')}] "
+                f"state={entry.get('state', '?')} "
+                f"profile={entry.get('profile_id', '?')}"
+            )
+        print()
+
+    exhausted = data.get("exhausted_obligations", [])
+    if exhausted:
+        print(f"--- Exhausted projection obligations ({len(exhausted)}) ---")
+        for entry in exhausted:
+            print(
+                f"  [{entry.get('operation_id', '?')}] "
+                f"kind={entry.get('kind', '?')} "
+                f"attempts={entry.get('attempts', '?')} "
+                f"profile={entry.get('profile_id', '?')}"
+            )
+        print()
+
+    print("Use `slm ops resolve <id> --action cancel|retry|force_reconcile` to remediate.")
+
+
+def _cmd_ops_resolve(args: Namespace) -> None:
+    """Admin action on a specific operation."""
+    operation_id: str = args.operation_id
+    action: str = args.action
+
+    if action not in _VALID_ACTIONS:
+        _die(f"--action must be one of: {', '.join(_VALID_ACTIONS)}")
+
+    result = _daemon_post(
+        f"/operations/{operation_id}/resolve",
+        {"action": action},
+    )
+    if result is None:
+        return
+
+    if getattr(args, "json", False):
+        _print_json(result)
+        return
+
+    success = result.get("success", False)
+    if success:
+        print(
+            f"OK: operation {operation_id!r} resolved with action={action!r}. "
+            f"{result.get('message', '')}"
+        )
+    else:
+        reason = result.get("reason") or result.get("error") or "unknown reason"
+        print(f"Resolve failed: {reason}", file=sys.stderr)
+        sys.exit(1)
+
+
+def _cmd_ops_status(args: Namespace) -> None:
+    """Quick ops-focused health status from the daemon."""
+    data = _daemon_get("/status")
+    if data is None:
+        return
+
+    fields = {
+        "dead_letter_count": data.get("dead_letter_count", 0),
+        "degraded_operations": data.get("degraded_operations", 0),
+        "exhausted_obligations": data.get("exhausted_obligations", 0),
+        "writer_stalled": data.get("writer_stalled", False),
+        "writer_stalled_op_id": data.get("writer_stalled_op_id"),
+        "writer_stalled_age_s": data.get("writer_stalled_age_s"),
+    }
+
+    if getattr(args, "json", False):
+        _print_json(fields)
+        return
+
+    total_issues = (
+        fields["dead_letter_count"]
+        + fields["degraded_operations"]
+        + fields["exhausted_obligations"]
+    )
+    stalled = fields["writer_stalled"]
+
+    if total_issues == 0 and not stalled:
+        print("Operations status: HEALTHY — no failures detected.")
+        return
+
+    print("Operations status: DEGRADED\n")
+    if fields["dead_letter_count"]:
+        print(f"  dead-letter entries    : {fields['dead_letter_count']}")
+    if fields["degraded_operations"]:
+        print(f"  degraded manifests     : {fields['degraded_operations']}")
+    if fields["exhausted_obligations"]:
+        print(f"  exhausted obligations  : {fields['exhausted_obligations']}")
+    if stalled:
+        op_id = fields["writer_stalled_op_id"] or "?"
+        age = fields["writer_stalled_age_s"]
+        age_str = f" (age {age:.1f}s)" if age is not None else ""
+        print(f"  writer STALLED         : op={op_id}{age_str}")
+    print("\nRun `slm ops list` to see details, or check the dashboard.")
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+def cmd_ops(args: Namespace) -> None:
+    """Dispatch ``slm ops`` subcommands."""
+    sub = getattr(args, "ops_command", None)
+    handlers = {
+        "list": _cmd_ops_list,
+        "resolve": _cmd_ops_resolve,
+        "status": _cmd_ops_status,
+    }
+    handler = handlers.get(sub)
+    if handler:
+        handler(args)
+    else:
+        print("Usage: slm ops <list|resolve|status> [options]")
+        print("  slm ops list [--profile P] [--json]")
+        print("  slm ops resolve <id> --action {retry|force_reconcile|cancel} [--json]")
+        print("  slm ops status [--json]")
+        sys.exit(1)

package/src/superlocalmemory/cli/setup_wizard.py

@@ -410,7 +410,7 @@ def run_wizard(auto: bool = False) -> None:
 
     print()
     print("╔══════════════════════════════════════════════════════════╗")
-    print("║  SuperLocalMemory V3 — The Unified Brain               ║")
+    print("║  SuperLocalMemory V4 — The Unified Brain               ║")
     print("║  by Varun Pratap Bhardwaj / Qualixar                   ║")
     print("╚══════════════════════════════════════════════════════════╝")
     print()