superlocalmemory 3.6.23 → 3.7.0

package/src/superlocalmemory/cli/evidence_cmd.py

@@ -0,0 +1,103 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+
+"""CLI for versioned evidence export, verification, import, and rebuild."""
+
+from __future__ import annotations
+
+import json
+from argparse import Namespace
+from pathlib import Path
+
+
+def _database():
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.storage.database import DatabaseManager
+
+    config = SLMConfig.load()
+    return DatabaseManager(config.db_path)
+
+
+def _emit(value: dict, *, as_json: bool) -> None:
+    if as_json:
+        print(json.dumps(value, sort_keys=True))
+        return
+    for key, item in value.items():
+        print(f"{key}: {item}")
+
+
+def cmd_evidence(args: Namespace) -> None:
+    """Dispatch ``slm evidence`` without implicit destructive behavior."""
+    from superlocalmemory.core.evidence_bundle import (
+        export_evidence_bundle,
+        import_evidence_bundle,
+        rebuild_derived_state,
+        verify_evidence_bundle,
+    )
+
+    action = getattr(args, "evidence_command", None)
+    as_json = bool(getattr(args, "json", False))
+    profile = str(getattr(args, "profile", "default") or "default")
+
+    if action == "verify":
+        report = verify_evidence_bundle(args.bundle)
+        _emit({
+            "valid": report.valid,
+            "bundle_id": report.bundle_id,
+            "counts": report.counts,
+            "errors": list(report.errors),
+            "warnings": list(report.warnings),
+        }, as_json=as_json)
+        if not report.valid:
+            raise SystemExit(1)
+        return
+
+    if action == "export":
+        db = _database()
+        if not Path(db.db_path).is_file():
+            raise SystemExit(f"memory database not found: {db.db_path}")
+        manifest = export_evidence_bundle(db, profile, args.destination)
+        _emit({
+            "bundle_id": manifest["bundle_id"],
+            "profile_id": profile,
+            "destination": str(Path(args.destination).resolve()),
+            "unresolved_source_links": manifest["unresolved_source_links"],
+        }, as_json=as_json)
+        return
+
+    if action == "import":
+        if not bool(getattr(args, "execute", False)):
+            print(
+                "Dry run only. Verify the bundle, then re-run with --execute; "
+                "replacement also requires --rollback-dir."
+            )
+            return
+        report = import_evidence_bundle(
+            _database(),
+            args.bundle,
+            target_profile_id=profile,
+            replace=bool(getattr(args, "replace", False)),
+            rollback_dir=getattr(args, "rollback_dir", None),
+        )
+        _emit({
+            "valid": report.valid,
+            "bundle_id": report.bundle_id,
+            "profile_id": profile,
+            "counts": report.counts,
+        }, as_json=as_json)
+        return
+
+    if action == "rebuild":
+        if not bool(getattr(args, "execute", False)):
+            print(
+                "Dry run only. Re-run with --execute to rebuild derived lexical state."
+            )
+            return
+        result = rebuild_derived_state(_database(), profile)
+        _emit({"profile_id": profile, **result}, as_json=as_json)
+        return
+
+    raise SystemExit("choose an evidence subcommand: export, verify, import, or rebuild")
+
+
+__all__ = ["cmd_evidence"]

package/src/superlocalmemory/cli/ingest_cmd.py

@@ -24,10 +24,14 @@ from argparse import Namespace
 from datetime import datetime, timezone
 from pathlib import Path
 
+from superlocalmemory.infra.data_root import DynamicStatePath
+
 logger = logging.getLogger(__name__)
 
-MEMORY_DIR = Path.home() / ".superlocalmemory"
-MEMORY_DB = MEMORY_DIR / "memory.db"
+# Backward-compatible public paths that resolve at call time instead of
+# freezing Path.home() during module import.
+MEMORY_DIR = DynamicStatePath()
+MEMORY_DB = DynamicStatePath("memory.db")
 
 
 def cmd_ingest(args: Namespace) -> None:
@@ -278,7 +282,7 @@ def _write_tool_events(events: list[dict]) -> int:
     v3.4.10: Preserves input_summary, output_summary, and project_path
     from enriched sources (ECC observations, enriched hook).
     """
-    db_path = MEMORY_DB
+    db_path = Path(MEMORY_DB)
     if not db_path.exists():
         return 0
 

package/src/superlocalmemory/cli/main.py

@@ -28,18 +28,16 @@ from superlocalmemory.core.config import CANONICAL_RECALL_LIMIT
 
 _HELP_EPILOG = """\
 operating modes:
-  Mode A  Local Guardian — Zero cloud, zero LLM. All processing stays on
-          your machine. Full EU AI Act compliance. Best for privacy-first
-          use, air-gapped systems, and regulated environments.
-          Retrieval score: 74.8% on LoCoMo benchmark.
+  Mode A  Local Guardian — No model-provider call in the core memory path.
+          Optional integrations, backup, and downloads have separate network
+          behavior; assess the complete deployment for privacy requirements.
 
   Mode B  Smart Local — Uses a local Ollama LLM for summarization and
-          enrichment. Data never leaves your network. EU AI Act compliant.
-          Requires: ollama running locally with a model pulled.
+          enrichment. The Ollama endpoint and enabled integrations determine
+          the data path. Requires: ollama running with a model pulled.
 
   Mode C  Full Power — Uses a cloud LLM (OpenAI, Anthropic, etc.) for
-          maximum accuracy. Best retrieval quality, agentic multi-hop.
-          Retrieval score: 87.7% on LoCoMo benchmark.
+          provider-assisted enrichment and retrieval behavior.
 
 quick start:
   slm setup                   Interactive first-time setup
@@ -70,6 +68,34 @@ documentation:
 """
 
 
+_NO_DAEMON_COMMANDS = {
+    "setup", "mode", "provider", "connect", "migrate", "mcp", "warmup", "hooks", "codex",
+    "config", "evolve", "db",
+    # v3.4.22 escape hatches — never auto-start the daemon on these.
+    "disable", "enable", "clear-cache", "reconfigure", "benchmark",
+    "rotate-token",
+    "evidence",
+    "diagnostics",
+    # LLD-06 — agents launched through wrap start the daemon on demand.
+    "wrap",
+    # V3.6 Optimize commands that are config read/write only.
+    "optimize", "cache", "compress", "help-optimize",
+    # Lifecycle orchestration must run before any global auto-start hook.
+    "serve", "restart",
+}
+
+
+def _command_requires_daemon(args: argparse.Namespace) -> bool:
+    """Return whether global dispatch should ensure the daemon first.
+
+    All ``serve`` actions and ``restart`` own daemon inspection or mutation;
+    global dispatch must not race or duplicate those handlers.
+    """
+    if args.command in _NO_DAEMON_COMMANDS:
+        return False
+    return True
+
+
 def main() -> None:
     """Parse CLI arguments and dispatch to command handlers."""
     # Fast path: hook invocations bypass argparse entirely (stdlib only, ~30ms)
@@ -78,11 +104,20 @@ def main() -> None:
         handle_hook(sys.argv[2])
         return
 
+    # Metadata inspection is activation-free. Package managers, users, and CI
+    # must be able to inspect a newly installed executable without creating an
+    # SLM data root, config, version marker, daemon, hooks, or models.
+    _is_metadata_cmd = (
+        len(sys.argv) == 1
+        or any(arg in {"-h", "--help"} for arg in sys.argv[1:])
+        or (len(sys.argv) == 2 and sys.argv[1] in {"-v", "--version"})
+    )
+
     # WP-07: lazy first-run init — runs after hook/mcp fast-paths so stdout
     # is never polluted on those paths (CRIT-3, MCP JSON-RPC purity).
     # Guarded: any failure must not crash the CLI (AC4).
     _is_mcp_cmd = len(sys.argv) >= 2 and sys.argv[1] == "mcp"
-    if not _is_mcp_cmd:
+    if not _is_mcp_cmd and not _is_metadata_cmd:
         try:
             from superlocalmemory.cli._lazy_init import _ensure_initialized
             _ensure_initialized()
@@ -102,7 +137,7 @@ def main() -> None:
 
     # One-time post-upgrade banner — silent for fresh installs and
     # same-version runs. Guarded against I/O errors internally.
-    if not _is_mcp_stdio:
+    if not _is_mcp_stdio and not _is_metadata_cmd:
         from superlocalmemory.cli.version_banner import check_and_emit_upgrade_banner
         if check_and_emit_upgrade_banner(_ver):
             # First post-upgrade invocation: apply the data-dir migration if
@@ -110,7 +145,6 @@ def main() -> None:
             # we defer — the next daemon start picks it up.
             try:
                 import logging as _logging
-                from pathlib import Path as _P
                 from superlocalmemory.migrations.v3_4_25_to_v3_4_26 import (
                     migrate_if_safe as _migrate_if_safe,
                 )
@@ -176,8 +210,13 @@ def main() -> None:
     provider_p.add_argument(
         "action", nargs="?", choices=["set"], help="Action",
     )
+    provider_p.add_argument(
+        "provider", nargs="?",
+        choices=["openai", "anthropic", "azure", "ollama", "openrouter"],
+        help="Provider to configure; omit to use the interactive selector",
+    )
 
-    connect_p = sub.add_parser("connect", help="Auto-configure IDE integrations (17+ IDEs)")
+    connect_p = sub.add_parser("connect", help="Auto-configure a supported IDE integration")
     connect_p.add_argument("ide", nargs="?", help="Specific IDE to configure (e.g. cursor, codex, continue)")
     connect_p.add_argument(
         "--list", action="store_true", help="List all supported IDEs",
@@ -225,6 +264,17 @@ def main() -> None:
         "--dry-run", action="store_true",
         help="Report what would change without applying",
     )
+    db_scale_p = db_sub.add_parser(
+        "scale",
+        help="Safely stage and promote optional CozoDB/LanceDB projections",
+    )
+    db_scale_p.add_argument(
+        "scale_action",
+        choices=("status", "prepare", "verify", "promote", "rollback"),
+        help="Lifecycle action. Prepare and verify never mutate active projection paths.",
+    )
+    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")
 
     # -- Memory Operations ---------------------------------------------
     remember_p = sub.add_parser("remember", help="Store a memory (extracts facts, builds graph)")
@@ -247,7 +297,7 @@ def main() -> None:
 
     # v3.6.12 (parity-3): `search` is an alias of `recall` so the CLI has the
     # same search verb the MCP exposes (handlers dict maps both to cmd_recall).
-    recall_p = sub.add_parser("recall", aliases=["search"], help="Semantic search with 4-channel retrieval")
+    recall_p = sub.add_parser("recall", aliases=["search"], help="Multi-channel memory retrieval")
     recall_p.add_argument("query", help="Search query")
     recall_p.add_argument(
         "--limit", type=int, default=CANONICAL_RECALL_LIMIT,
@@ -256,8 +306,8 @@ def main() -> None:
     recall_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
     recall_p.add_argument(
         "--fast", action="store_true",
-        help="Skip SpreadingActivation 5th channel for sub-second response. "
-             "Other 4 channels (semantic, lexical, temporal, structural) still run. "
+        help="Skip spreading activation 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).",
     )
     # v3.6.15: shared memory is opt-in. Unset (None) → resolve the configured
@@ -386,7 +436,7 @@ def main() -> None:
     profile_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     # -- Active Memory (V3.1) ------------------------------------------
-    hooks_p = sub.add_parser("hooks", help="Manage Claude Code hooks for auto memory injection")
+    hooks_p = sub.add_parser("hooks", help="Manage additive Claude Code or Codex hooks")
     hooks_p.add_argument(
         "action", nargs="?", default="status",
         choices=["install", "remove", "status"], help="Action (default: status)",
@@ -395,6 +445,18 @@ def main() -> None:
         "--gate", action="store_true",
         help="Enable PreToolUse gate (experimental — blocks tools until session_init)",
     )
+    hooks_p.add_argument(
+        "--agent", choices=["claude", "codex"], default="claude",
+        help="Target agent (default: claude)",
+    )
+    hooks_p.add_argument(
+        "--dry-run", action="store_true",
+        help="Show whether the additive change is valid without writing files",
+    )
+
+    codex_p = sub.add_parser("codex", help="Install or inspect explicit Codex SLM add-ons")
+    codex_p.add_argument("action", nargs="?", default="status", choices=["install", "remove", "status"])
+    codex_p.add_argument("--dry-run", action="store_true", help="Validate without writing user files")
 
     ctx_p = sub.add_parser("session-context", help="Print session context (for hooks)")
     ctx_p.add_argument("query", nargs="?", default="", help="Optional context query")
@@ -568,6 +630,55 @@ def main() -> None:
         help="Emit JSON result instead of human-readable summary",
     )
 
+    evidence_p = sub.add_parser(
+        "evidence",
+        help="Export, verify, import, or rebuild versioned memory evidence",
+    )
+    evidence_sub = evidence_p.add_subparsers(
+        dest="evidence_command", title="evidence subcommands",
+    )
+    evidence_export = evidence_sub.add_parser(
+        "export", help="Write a deterministic checksummed JSONL bundle",
+    )
+    evidence_export.add_argument("destination")
+    evidence_export.add_argument("--profile", default="default")
+    evidence_export.add_argument("--json", action="store_true")
+    evidence_verify = evidence_sub.add_parser(
+        "verify", help="Verify checksums and source reconciliation",
+    )
+    evidence_verify.add_argument("bundle")
+    evidence_verify.add_argument("--json", action="store_true")
+    evidence_import = evidence_sub.add_parser(
+        "import", help="Import relational truth (dry-run unless --execute)",
+    )
+    evidence_import.add_argument("bundle")
+    evidence_import.add_argument("--profile", default="default")
+    evidence_import.add_argument("--replace", action="store_true")
+    evidence_import.add_argument("--rollback-dir", default=None)
+    evidence_import.add_argument("--execute", action="store_true")
+    evidence_import.add_argument("--json", action="store_true")
+    evidence_rebuild = evidence_sub.add_parser(
+        "rebuild", help="Rebuild derived lexical state (dry-run unless --execute)",
+    )
+    evidence_rebuild.add_argument("--profile", default="default")
+    evidence_rebuild.add_argument("--execute", action="store_true")
+    evidence_rebuild.add_argument("--json", action="store_true")
+
+    diagnostics_p = sub.add_parser(
+        "diagnostics",
+        help="Export bounded local operational aggregates (manual only)",
+    )
+    diagnostics_sub = diagnostics_p.add_subparsers(
+        dest="diagnostics_command", title="diagnostics subcommands",
+    )
+    diagnostics_export = diagnostics_sub.add_parser(
+        "export", help="Write a deterministic content-free JSON report",
+    )
+    diagnostics_export.add_argument("destination")
+    diagnostics_export.add_argument(
+        "--json", action="store_true", help="Output structured JSON",
+    )
+
     # S-M07: install-token rotation.
     sub.add_parser(
         "rotate-token",
@@ -676,21 +787,7 @@ def main() -> None:
     # V3.4.4: Auto-start daemon for all commands that need it.
     # SLM is always-on — close laptop, reboot, crash: daemon auto-recovers.
     # Cross-platform: macOS + Windows + Linux.
-    _NO_DAEMON_COMMANDS = {
-        "setup", "mode", "provider", "connect", "migrate", "mcp", "warmup",
-        "config", "evolve", "db",
-        # v3.4.22 escape hatches — never auto-start the daemon on these.
-        "disable", "enable", "clear-cache", "reconfigure", "benchmark",
-        "rotate-token",
-        # LLD-06 — `slm wrap` may launch the agent binary directly without
-        # needing the daemon running (the agent will start the daemon on
-        # first LLM call, or the wrap command can be --dry-run).
-        "wrap",
-        # V3.6 Optimize commands that are config read/write only (no daemon needed)
-        "optimize", "cache", "compress", "help-optimize",
-        # NOTE: "proxy" NOT here — proxy needs daemon running
-    }
-    if args.command not in _NO_DAEMON_COMMANDS:
+    if _command_requires_daemon(args):
         try:
             from superlocalmemory.cli.daemon import ensure_daemon
             ensure_daemon()  # Starts daemon if not running; no-op if already up

package/src/superlocalmemory/cli/pending_store.py

@@ -18,27 +18,27 @@ Uses a separate `pending.db` file — never touches memory.db directly.
 Stdlib only — no SLM imports (must be fast).
 
 Part of Qualixar | Author: Varun Pratap Bhardwaj
-License: Elastic-2.0
+License: AGPL-3.0-or-later
 """
 
 from __future__ import annotations
 
 import json
-import os
 import sqlite3
 import time
 from pathlib import Path
 
 
 def _default_dir() -> Path:
-    """Honor SLM_DATA_DIR so tests can isolate via tmp_path."""
-    return Path(os.environ.get("SLM_DATA_DIR") or Path.home() / ".superlocalmemory")
+    """Resolve the pending queue inside the canonical process namespace."""
+    from superlocalmemory.infra.data_root import canonical_data_root
+    return canonical_data_root()
 
 
 _PENDING_DB = "pending.db"
 _MAX_RETRIES = 3
 _STUCK_DAYS = 7
-_DEAD_LETTER_DAYS = 30
+_MAX_RETRY_DELAY_SECONDS = 3600
 
 _SCHEMA = """
 CREATE TABLE IF NOT EXISTS pending_memories (
@@ -49,7 +49,8 @@ CREATE TABLE IF NOT EXISTS pending_memories (
     created_at TEXT NOT NULL,
     status TEXT NOT NULL DEFAULT 'pending',
     error TEXT DEFAULT NULL,
-    retry_count INTEGER DEFAULT 0
+    retry_count INTEGER DEFAULT 0,
+    next_retry_at REAL DEFAULT 0
 );
 """
 
@@ -62,6 +63,24 @@ def _get_db(base_dir: Path | None = None) -> sqlite3.Connection:
     conn = sqlite3.connect(str(db_path), timeout=5)
     conn.execute("PRAGMA journal_mode=WAL")
     conn.execute(_SCHEMA)
+    columns = {
+        row[1]
+        for row in conn.execute("PRAGMA table_info(pending_memories)").fetchall()
+    }
+    if "next_retry_at" not in columns:
+        conn.execute(
+            "ALTER TABLE pending_memories ADD COLUMN "
+            "next_retry_at REAL DEFAULT 0"
+        )
+        conn.commit()
+    # Pre-V3.7 rows were terminally hidden after three failures. Restore them
+    # to the retry queue; M018 makes replay idempotent and no raw evidence may
+    # remain stranded solely because an older version exhausted its counter.
+    conn.execute(
+        "UPDATE pending_memories SET status='pending', next_retry_at=0 "
+        "WHERE status='failed'"
+    )
+    conn.commit()
     return conn
 
 
@@ -96,8 +115,9 @@ def get_pending(base_dir: Path | None = None, limit: int = 50) -> list[dict]:
         rows = conn.execute(
             "SELECT id, content, tags, metadata, created_at, retry_count "
             "FROM pending_memories WHERE status = 'pending' "
+            "AND COALESCE(next_retry_at, 0) <= ? "
             "ORDER BY id ASC LIMIT ?",
-            (limit,),
+            (time.time(), limit),
         ).fetchall()
         return [
             {"id": r[0], "content": r[1], "tags": r[2], "metadata": r[3],
@@ -124,20 +144,29 @@ def mark_done(row_id: int, base_dir: Path | None = None) -> None:
 def mark_failed(row_id: int, error: str, base_dir: Path | None = None) -> None:
     """Mark a pending memory as failed with error message.
 
-    v3.4.38: Now retry-aware. If retry_count < _MAX_RETRIES, keeps status as
-    'pending' so the materializer will retry on next iteration. Only marks
-    permanently failed after _MAX_RETRIES (3) attempts. The previous behavior
-    permanently lost 18 memories between April 15-26, 2026 to transient errors.
+    Unprocessed evidence is never deleted or terminally hidden. Failures stay
+    pending with bounded exponential backoff; M018 idempotency makes repeated
+    replay safe once the canonical operation has been created.
     """
     conn = _get_db(base_dir)
     try:
-        # Increment retry count and conditionally update status
+        row = conn.execute(
+            "SELECT retry_count FROM pending_memories WHERE id=?",
+            (row_id,),
+        ).fetchone()
+        if row is None:
+            return
+        next_count = int(row[0] or 0) + 1
+        delay = 0 if next_count == 1 else min(
+            2 ** min(next_count - 1, 12),
+            _MAX_RETRY_DELAY_SECONDS,
+        )
         conn.execute(
             "UPDATE pending_memories SET error = ?, "
             "retry_count = retry_count + 1, "
-            "status = CASE WHEN retry_count + 1 >= ? THEN 'failed' ELSE 'pending' END "
+            "status = 'pending', next_retry_at = ? "
             "WHERE id = ?",
-            (error, _MAX_RETRIES, row_id),
+            (error, time.time() + delay, row_id),
         )
         conn.commit()
     finally:
@@ -179,11 +208,8 @@ def cleanup_done(days: int = 7, base_dir: Path | None = None) -> int:
 def cleanup_stale(base_dir: Path | None = None) -> dict[str, int]:
     """Sweep stale rows from pending.db. Runs periodically from the daemon.
 
-    Removes:
-    - `done` rows older than 7 days (already processed)
-    - `failed` rows that exceeded max retries (moved to dead-letter via deletion)
-    - `pending` rows stuck more than 7 days (test pollution, crashed workers)
-    - Everything older than 30 days regardless of status (hard cap)
+    Deletes only completed receipts. Pending and failed raw evidence is retained
+    regardless of age so maintenance can never become a data-loss path.
     """
     conn = _get_db(base_dir)
     try:
@@ -192,28 +218,18 @@ def cleanup_stale(base_dir: Path | None = None) -> dict[str, int]:
             "AND created_at < datetime('now', ?)",
             (f"-{_STUCK_DAYS} days",),
         ).rowcount
-        failed = conn.execute(
-            "DELETE FROM pending_memories WHERE status = 'failed' "
-            "AND retry_count >= ?",
-            (_MAX_RETRIES,),
-        ).rowcount
-        stuck = conn.execute(
-            "DELETE FROM pending_memories WHERE status = 'pending' "
-            "AND created_at < datetime('now', ?)",
-            (f"-{_STUCK_DAYS} days",),
-        ).rowcount
-        hard_cap = conn.execute(
-            "DELETE FROM pending_memories "
-            "WHERE created_at < datetime('now', ?)",
-            (f"-{_DEAD_LETTER_DAYS} days",),
-        ).rowcount
+        retained = conn.execute(
+            "SELECT COUNT(*) FROM pending_memories "
+            "WHERE status != 'done'"
+        ).fetchone()[0]
         conn.commit()
         return {
             "done": done,
-            "failed_over_retries": failed,
-            "stuck_pending": stuck,
-            "hard_cap_expired": hard_cap,
-            "total": done + failed + stuck + hard_cap,
+            "failed_over_retries": 0,
+            "stuck_pending": 0,
+            "hard_cap_expired": 0,
+            "retained_unprocessed": int(retained),
+            "total": done,
         }
     finally:
         conn.close()

package/src/superlocalmemory/cli/scale_engine_cmd.py

@@ -0,0 +1,37 @@
+"""CLI surface for the staged Scale Engine lifecycle."""
+from __future__ import annotations
+
+import json
+from argparse import Namespace
+
+
+def cmd_db_scale(args: Namespace) -> int:
+    from superlocalmemory.core.config import SLMConfig
+    from superlocalmemory.core.scale_engine import ScaleEngineError, ScaleEngineManager
+
+    manager = ScaleEngineManager(SLMConfig.load())
+    action = args.scale_action
+    try:
+        if action == "status":
+            result = manager.status()
+        elif action == "prepare":
+            result = manager.prepare()
+        elif action == "verify":
+            if not args.stage_id:
+                raise ScaleEngineError("verify requires --stage-id (see `slm db scale status`)")
+            result = manager.verify(args.stage_id)
+        elif action == "promote":
+            if not args.stage_id:
+                raise ScaleEngineError("promote requires --stage-id (see `slm db scale status`)")
+            result = manager.promote(args.stage_id)
+        elif action == "rollback":
+            if not args.backup_id:
+                raise ScaleEngineError("rollback requires --backup-id (see `slm db scale status`)")
+            result = manager.rollback(args.backup_id)
+        else:
+            raise ScaleEngineError(f"unknown Scale Engine action: {action}")
+    except ScaleEngineError as exc:
+        print(f"Scale Engine: {exc}")
+        return 1
+    print(json.dumps(result, indent=2, sort_keys=True))
+    return 0