superlocalmemory 3.5.7 → 3.6.0

package/src/superlocalmemory/cli/commands.py

@@ -64,6 +64,36 @@ def _cmd_escape_rotate_token(args: Namespace) -> None:
     cmd_rotate_token(args)
 
 
+# ---- SLM v3.6 Optimize dispatch functions (additive) ----
+
+def _cmd_optimize(args: Namespace) -> None:
+    from superlocalmemory.cli.optimize_cmd import cmd_optimize
+    cmd_optimize(args)
+
+
+def _cmd_cache(args: Namespace) -> None:
+    from superlocalmemory.cli.cache_cmd import cmd_cache
+    cmd_cache(args)
+
+
+def _cmd_compress(args: Namespace) -> None:
+    from superlocalmemory.cli.compress_cmd import cmd_compress
+    cmd_compress(args)
+
+
+def _cmd_proxy(args: Namespace) -> None:
+    from superlocalmemory.cli.proxy_cmd import cmd_proxy
+    cmd_proxy(args)
+
+
+def _cmd_help_optimize(args: Namespace) -> None:
+    from superlocalmemory.cli.help_cmd import cmd_help_optimize
+    cmd_help_optimize(args)
+
+
+# ---- end SLM v3.6 Optimize dispatch functions ----
+
+
 def dispatch(args: Namespace) -> None:
     """Route CLI command to the appropriate handler."""
     # Auto-install/upgrade hooks on version change (single file read, ~0.1ms)
@@ -126,6 +156,14 @@ def dispatch(args: Namespace) -> None:
         "reconfigure": _cmd_escape_reconfigure,
         "benchmark": _cmd_escape_benchmark,
         "rotate-token": _cmd_escape_rotate_token,
+        # LLD-06 — `slm wrap <agent> [args...]` activates the Optimize proxy.
+        "wrap": _cmd_wrap,
+        # V3.6 Optimize subcommands (additive)
+        "optimize": _cmd_optimize,
+        "cache": _cmd_cache,
+        "compress": _cmd_compress,
+        "proxy": _cmd_proxy,
+        "help-optimize": _cmd_help_optimize,
     }
     handler = handlers.get(args.command)
     if handler:
@@ -135,6 +173,39 @@ def dispatch(args: Namespace) -> None:
         sys.exit(1)
 
 
+def _cmd_wrap(args: Namespace) -> None:
+    """LLD-06 §6.6 — `slm wrap <agent> [args...]` activates the Optimize proxy.
+
+    Routes the Optimize layer's per-agent launch/activation. See
+    optimize.adapters._agent_registry for the full agent table.
+    """
+    if getattr(args, "list", False):
+        from superlocalmemory.optimize.adapters.wrap import list_agents
+        from superlocalmemory.optimize.adapters._agent_registry import AGENT_REGISTRY
+        print("Registered agents for `slm wrap`:")
+        for key in list_agents():
+            spec = AGENT_REGISTRY.get(key, {})
+            mech = spec.get("mechanism", "unknown")
+            print(f"  {key:20s}  mechanism={mech}")
+        return
+
+    agent = getattr(args, "agent", None)
+    if not agent:
+        print("Usage: slm wrap <agent> [args...]\n"
+              "       slm wrap --list\n"
+              "       slm wrap --help")
+        sys.exit(2)
+
+    agent_args = list(getattr(args, "agent_args", []) or [])
+    persistent = bool(getattr(args, "persistent", False))
+    dry_run = bool(getattr(args, "dry_run", False))
+
+    from superlocalmemory.optimize.adapters.wrap import wrap_agent
+    rc = wrap_agent(agent, agent_args, persistent=persistent, dry_run=dry_run)
+    if rc:
+        sys.exit(rc)
+
+
 # -- Daemon serve mode (V3.3.21) ------------------------------------------
 
 def cmd_serve(args: Namespace) -> None:
@@ -1661,6 +1732,26 @@ def cmd_trace(args: Namespace) -> None:
 
 def cmd_mcp(_args: Namespace) -> None:
     """Start the V3 MCP server (stdio transport for IDE integration)."""
+    # SINGLETON GUARD (v3.5.8): Reap fresh orphans before binding stdio.
+    # Root cause: every IDE session spawns a new `slm mcp`; dead sessions'
+    # processes survive indefinitely (~400 MB each) because the reaper's
+    # 1-hour age gate misses them. Fix: run find_orphans with age_threshold=0
+    # so any `slm mcp` whose parent IDE/Claude process has died is killed
+    # immediately. Only orphans (dead parent) are killed — live sessions safe.
+    # CRITICAL: No stdout anywhere below — MCP stdio transport, any print
+    # corrupts the JSON-RPC protocol.
+    try:
+        from superlocalmemory.infra.process_reaper import (
+            ReaperConfig,
+            find_orphans,
+            kill_orphan,
+        )
+        _reaper_cfg = ReaperConfig(orphan_age_threshold_hours=0.0)
+        for _orphan in find_orphans(_reaper_cfg):
+            kill_orphan(_orphan.pid, graceful_timeout_seconds=1.0)
+    except Exception:
+        pass  # Never block MCP startup on cleanup failure
+
     # Auto-install hooks on MCP startup (fast path: ~0.1ms if already current)
     # CRITICAL: No stdout — MCP uses stdio transport, any print corrupts protocol
     try:
@@ -2553,6 +2644,11 @@ def cmd_reap(args: Namespace) -> None:
     """Find and kill orphaned SLM processes."""
     use_json = getattr(args, "json", False)
     dry_run = not getattr(args, "force", False)
+    # V3.5.9: --all bypasses orphan detection and kills every slm mcp process
+    # except the current one. Use after switching IDEs to clear stale sessions.
+    use_force_all = getattr(args, "all", False)
+    if use_force_all:
+        dry_run = False  # --all always kills; --force is implied
 
     try:
         from superlocalmemory.infra.process_reaper import (
@@ -2561,7 +2657,7 @@ def cmd_reap(args: Namespace) -> None:
         )
 
         config = ReaperConfig()
-        result = cleanup_all_orphans(config, dry_run=dry_run)
+        result = cleanup_all_orphans(config, dry_run=dry_run, force=use_force_all)
     except Exception as exc:
         if use_json:
             from superlocalmemory.cli.json_output import json_print
@@ -2580,7 +2676,8 @@ def cmd_reap(args: Namespace) -> None:
             "killed": result.get("killed", 0),
             "skipped": result.get("skipped", 0),
         }, next_actions=[
-            {"command": "slm reap --force --json", "description": "Kill orphans"},
+            {"command": "slm reap --force --json", "description": "Kill orphan processes"},
+            {"command": "slm reap --all --json", "description": "Kill ALL slm mcp sessions (IDE switch)"},
             {"command": "slm status --json", "description": "Check status"},
         ])
         return
@@ -2600,3 +2697,4 @@ def cmd_reap(args: Namespace) -> None:
     print(f"  Skipped:             {skipped}")
     if dry_run and orphans > 0:
         print("\n  Use --force to kill orphaned processes.")
+        print("  Use --all to kill ALL slm mcp sessions (after IDE switch).")

package/src/superlocalmemory/cli/compress_cmd.py

@@ -0,0 +1,179 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Handlers for ``slm compress status|mode|code|prose|ccr``."""
+
+from __future__ import annotations
+
+import dataclasses
+import json
+import sys
+from argparse import Namespace
+
+from superlocalmemory.cli.optimize_constants import AGGRESSIVE_MODE_WARNING
+
+
+def _get_store():
+    from superlocalmemory.optimize.config.store import ConfigStore
+    return ConfigStore()
+
+
+def _get_cache_db():
+    from superlocalmemory.optimize.storage.db import CacheDB
+    return CacheDB()
+
+
+def _write_config(**fields) -> None:
+    """5-step immutable config-write."""
+    store = _get_store()
+    cfg = store.get()
+    try:
+        cfg = dataclasses.replace(cfg, **fields)
+        store.save(cfg)
+    except ValueError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except OSError as e:
+        print(f"Error writing config: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+def cmd_compress(args: Namespace) -> None:
+    """Top-level dispatcher for ``slm compress <subcommand>``."""
+    sub = getattr(args, "compress_command", None)
+    _dispatch = {
+        "status": cmd_compress_status,
+        "mode": cmd_compress_mode,
+        "code": cmd_compress_code,
+        "prose": cmd_compress_prose,
+        "ccr": cmd_compress_ccr,
+        "align": cmd_compress_align,
+    }
+    handler = _dispatch.get(sub or "")
+    if handler:
+        handler(args)
+    else:
+        print("Usage: slm compress status|mode|code|prose|ccr [options]")
+        sys.exit(0)
+
+
+def cmd_compress_status(args: Namespace) -> None:
+    """Print compression status."""
+    use_json = getattr(args, "json", False)
+    cfg = _get_store().get()
+
+    if use_json:
+        data = {
+            "status": "ok",
+            "compress_enabled": cfg.compress_enabled,
+            "compress_mode": cfg.compress_mode,
+            "compress_code": cfg.compress_code,
+            "compress_prose": cfg.compress_prose,
+            "compress_ccr": cfg.compress_ccr,
+        }
+        print(json.dumps(data, indent=2))
+        return
+
+    print("Compression status:")
+    print(f"  Enabled:  {'yes' if cfg.compress_enabled else 'no'}")
+    print(f"  Mode:     {cfg.compress_mode}")
+    print(f"  Code:     {'ON' if cfg.compress_code else 'OFF'}"
+          "  (extractive JSON/code — lossless structure)")
+    print(f"  Prose:    {'ON' if cfg.compress_prose else 'OFF'}")
+    print(f"  CCR:      {'ON' if cfg.compress_ccr else 'OFF'}"
+          " (reversible context retrieval)")
+
+
+def cmd_compress_mode(args: Namespace) -> None:
+    """Set compression mode to safe or aggressive."""
+    use_json = getattr(args, "json", False)
+    mode_value = getattr(args, "mode_value", "safe")
+
+    if mode_value == "aggressive":
+        print(AGGRESSIVE_MODE_WARNING)
+
+    _write_config(compress_mode=mode_value)
+
+    if use_json:
+        print(json.dumps({"status": "ok", "compress_mode": mode_value}))
+        return
+
+    print(f"Compression mode set to: {mode_value}.")
+    print("Daemon hot-reload: active within 2s. No restart required.")
+
+
+def cmd_compress_code(args: Namespace) -> None:
+    """Enable or disable code/JSON compression."""
+    use_json = getattr(args, "json", False)
+    value = getattr(args, "code_value", "on")
+
+    _write_config(compress_code=(value == "on"))
+
+    if use_json:
+        print(json.dumps({"status": "ok", "compress_code": value == "on"}))
+        return
+
+    print(f"Code compression: {'ENABLED' if value == 'on' else 'DISABLED'}.")
+    print("Daemon hot-reload: active within 2s.")
+
+
+def cmd_compress_prose(args: Namespace) -> None:
+    """Enable or disable prose compression."""
+    use_json = getattr(args, "json", False)
+    value = getattr(args, "prose_value", "off")
+
+    store = _get_store()
+    cfg = store.get()
+
+    fields: dict = {"compress_prose": (value == "on")}
+    if value == "on" and not cfg.compress_enabled:
+        fields["compress_enabled"] = True
+
+    try:
+        cfg = dataclasses.replace(cfg, **fields)
+        store.save(cfg)
+    except (ValueError, OSError) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+    if use_json:
+        print(json.dumps({"status": "ok", "compress_prose": value == "on"}))
+        return
+
+    print(f"Prose compression: {'ENABLED' if value == 'on' else 'DISABLED'}.")
+    if value == "on" and "compress_enabled" in fields:
+        print("  (also enabled global compress)")
+    print("Daemon hot-reload: active within 2s.")
+
+
+def cmd_compress_align(args: Namespace) -> None:
+    """Enable or disable alignment compression."""
+    use_json = getattr(args, "json", False)
+    value = getattr(args, "align_value", "on")
+
+    _write_config(compress_align=(value == "on"))
+
+    if use_json:
+        print(json.dumps({"status": "ok", "compress_align": value == "on"}))
+        return
+
+    print(f"Alignment compression: {'ENABLED' if value == 'on' else 'DISABLED'}.")
+    print("Daemon hot-reload: active within 2s.")
+
+
+def cmd_compress_ccr(args: Namespace) -> None:
+    """Enable or disable CCR (Compressed Context Retrieval)."""
+    use_json = getattr(args, "json", False)
+    value = getattr(args, "ccr_value", "off")
+
+    _write_config(compress_ccr=(value == "on"))
+
+    if use_json:
+        print(json.dumps({"status": "ok", "compress_ccr": value == "on"}))
+        return
+
+    print(f"CCR (Compressed Context Retrieval): {'ENABLED' if value == 'on' else 'DISABLED'}.")
+    if value == "on":
+        print("Originals stored in llmcache.db for reversible retrieval.")
+    print("Daemon hot-reload: active within 2s.")

package/src/superlocalmemory/cli/help_cmd.py

@@ -0,0 +1,197 @@
+# Copyright (c) 2026 Varun Pratap Bhardwaj / Qualixar
+# Licensed under AGPL-3.0-or-later - see LICENSE file
+# Part of SuperLocalMemory V3 | https://qualixar.com | https://varunpratap.com
+
+"""Handler for ``slm help-optimize``."""
+
+from __future__ import annotations
+
+import sys
+from argparse import Namespace
+
+_HELP_SECTIONS: dict[str, str] = {
+    "header": """\
+SLM v3.6 Optimize — Developer Reference
+========================================
+Every feature is configurable via CLI. UI provides the same controls for
+non-technical users. All CLI commands write config at runtime — daemon
+hot-reloads within 2 seconds. No restart required.
+""",
+    "optimize": """\
+slm optimize — Optimize module control
+---------------------------------------
+  slm optimize status              Show all Optimize settings
+  slm optimize on                  Enable cache + compress
+  slm optimize off                 Disable cache + compress (proxy keeps running)
+  slm optimize savings [--since N] Token/cost savings report (default: 7 days)
+    --since N                      Days to look back (integer, default 7)
+    --provider P                   Filter by: anthropic|openai|gemini
+  All: --json                      Machine-readable JSON output
+""",
+    "cache": """\
+slm cache — Cache control
+--------------------------
+  slm cache status                 Entry count, DB size, TTLs, hit rate
+  slm cache clear                  Delete all entries for this tenant
+  slm cache invalidate --tag <t>   Delete entries whose tag array contains <t>
+  slm cache ttl --set <s>          Set exact-cache TTL (seconds)
+           --semantic <s>          Set semantic-cache TTL (seconds)
+  slm cache semantic on|off        Enable/disable semantic cache
+  All: --json  --tenant <id>
+
+  TTL examples:
+    slm cache ttl --set 3600        # 1 hour exact cache
+    slm cache ttl --set 86400       # 24 hour exact cache (default)
+    slm cache ttl --semantic 7200   # 2 hour semantic cache
+""",
+    "compress": """\
+slm compress — Compression control
+-----------------------------------
+  slm compress status              Show compression mode, per-channel state
+  slm compress mode safe|aggressive  Set compression aggressiveness
+  slm compress code on|off         Enable/disable code/JSON compression
+  slm compress prose on|off        Enable/disable prose compression
+  slm compress ccr on|off          Enable/disable Compressed Context Retrieval
+  All: --json
+""",
+    "safety": """\
+COMPRESSION SAFETY WARNING
+---------------------------
+  Safe mode (default):
+    - Code/JSON compression: extractive, structure-preserving, lossless.
+    - Prose compression: DISABLED in safe mode. Enable manually.
+    - CCR: DISABLED by default. Originals stored for reversible retrieval.
+    - This mode is production-safe for all use cases.
+
+  Aggressive mode:
+    !!  RISK: May reduce output fidelity. Use with caution.  !!
+    - Prose compression: LLMLingua-2-style extractive summarization.
+    - May omit nuance, hedges, or low-salience context.
+    - DO NOT use for:
+        - Code generation or code review
+        - Legal, compliance, or regulatory text
+        - Math, formulas, or structured data generation
+        - Any task requiring exact reproduction of input
+    - Suitable for:
+        - Open-ended brainstorming
+        - Summarization of long documents
+        - Casual conversation and exploration
+    - To revert: slm compress mode safe
+""",
+    "proxy": """\
+slm proxy — Optimization proxy
+--------------------------------
+  slm proxy [--port P] [--provider anthropic|openai|gemini]
+            [--no-compress] [--semantic] [--json]
+
+  Starts the SLM proxy (or reports existing). Proxy intercepts LLM calls,
+  applies cache lookup, and optionally compresses context before forwarding.
+
+  Default port: 8765
+  Anthropic surface:  http://127.0.0.1:8765
+  OpenAI surface:     http://127.0.0.1:8765/v1
+""",
+    "agents": """\
+PER-AGENT SETUP RECIPES
+------------------------
+
+--- Claude Code (ANTHROPIC_BASE_URL) ---
+  The simplest redirect. Set this env var before launching Claude Code.
+
+  Option A — environment variable (per-session):
+    export ANTHROPIC_BASE_URL=http://127.0.0.1:8765
+    claude                        # Claude Code picks up the env var
+
+  Option B — slm wrap (one command, recommended):
+    slm wrap claude               # starts proxy + sets env + launches claude
+
+  Option C — permanent (add to ~/.zshrc or ~/.bashrc):
+    echo 'export ANTHROPIC_BASE_URL=http://127.0.0.1:8765' >> ~/.zshrc
+    source ~/.zshrc
+
+  Verify: slm optimize status  ->  look for "proxy: running on :8765"
+
+--- Antigravity (config.toml base_url) ---
+  Antigravity reads base_url from its config.toml.
+  Default config location: ~/.config/antigravity/config.toml
+
+  Add or update this line under the [api] section:
+    [api]
+    base_url = "http://127.0.0.1:8765"
+
+  Or use slm wrap (if supported in your version):
+    slm wrap antigravity
+
+  Verify: antigravity --debug  ->  look for "base_url: http://127.0.0.1:8765"
+
+--- Generic OpenAI-compatible clients (Cline, Cursor, Aider, OpenCode) ---
+  Any client that accepts an OpenAI base_url can use the /v1 surface:
+    base_url = http://127.0.0.1:8765/v1
+    api_key  = (use your real provider key — proxy forwards it)
+
+  Aider:
+    aider --openai-api-base http://127.0.0.1:8765/v1
+
+  Cline (VS Code settings.json):
+    "cline.openAiBaseUrl": "http://127.0.0.1:8765/v1"
+
+  Cursor (Settings > Models > Base URL):
+    http://127.0.0.1:8765/v1
+
+  OpenCode / other CLI tools:
+    OPENAI_BASE_URL=http://127.0.0.1:8765/v1 opencode
+
+  Or use slm wrap:
+    slm wrap aider [-- <aider args>]
+    slm wrap cursor
+    slm wrap opencode
+
+--- SDK adapters (Python) ---
+  from superlocalmemory.optimize.adapters.openai_adapter import withSLM
+  from openai import OpenAI
+  client = withSLM(OpenAI())        # same interface as OpenAI() — zero API change
+
+  from superlocalmemory.optimize.adapters.anthropic_adapter import withSLM
+  from anthropic import Anthropic
+  client = withSLM(Anthropic())
+
+  NOTE: withSLM() is a pass-through when optimize is OFF.
+  No behavioral change until you run: slm optimize on
+""",
+    "footer": """\
+More commands:
+  slm help-optimize cache      Cache subcommand reference
+  slm help-optimize compress   Compress reference + safety warning
+  slm help-optimize agents     Per-agent setup recipes
+  slm help-optimize safety     Compression safety warning only
+
+Documentation: https://superlocalmemory.com
+GitHub:        https://github.com/qualixar/superlocalmemory
+AI Reliability Engineering by @varunPbhardwaj — https://qualixar.com
+""",
+}
+
+
+def cmd_help_optimize(args: Namespace) -> None:
+    """Print the full slm help-optimize page or a topic-specific section."""
+    topic = getattr(args, "topic", None)
+    no_pager = getattr(args, "no_pager", False)
+
+    if topic and topic not in _HELP_SECTIONS:
+        print(f"Unknown topic: {topic}."
+              f" Topics: {' '.join(k for k in _HELP_SECTIONS if k != 'footer')}")
+        sys.exit(1)
+
+    if topic:
+        text = _HELP_SECTIONS[topic]
+    else:
+        text = "\n".join(_HELP_SECTIONS.values())
+
+    if no_pager or not sys.stdout.isatty():
+        print(text)
+    else:
+        try:
+            import pydoc
+            pydoc.pager(text)
+        except Exception:
+            print(text)

package/src/superlocalmemory/cli/main.py

@@ -240,6 +240,28 @@ def main() -> None:
         help="Run only the fast checks (deps + config); skip daemon/embedding probes",
     )
 
+    # LLD-06 §6.6 — `slm wrap <agent> [args...]` activates the Optimize
+    # proxy for a specific agent. Supported agents: claude, claude-settings,
+    # codex, aider, cline, generic, etc. See optimize.adapters._agent_registry.
+    wrap_p = sub.add_parser(
+        "wrap",
+        help="Activate Optimize proxy for a specific agent (claude, codex, aider, ...)",
+    )
+    wrap_p.add_argument(
+        "--list", action="store_true",
+        help="List all registered agents and their mechanisms",
+    )
+    wrap_p.add_argument(
+        "--persistent", action="store_true",
+        help="Persist env vars to the agent's config file (~/.claude/settings.json) instead of launching",
+    )
+    wrap_p.add_argument(
+        "--dry-run", action="store_true",
+        help="Print the action that would be taken without executing it",
+    )
+    wrap_p.add_argument("agent", nargs="?", default=None, help="Agent key (run `slm wrap --list` to see all)")
+    wrap_p.add_argument("agent_args", nargs=argparse.REMAINDER, help="Args passed to the agent binary")
+
     # -- Services ------------------------------------------------------
     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)")
@@ -349,6 +371,10 @@ def main() -> None:
         "--force", action="store_true",
         help="Kill orphans (default: dry run only)",
     )
+    reap_p.add_argument(
+        "--all", action="store_true", dest="all",
+        help="Kill ALL slm mcp processes regardless of orphan status (use after IDE switch)",
+    )
     reap_p.add_argument("--json", action="store_true", help="Output structured JSON (agent-native)")
 
     # V3.4.3: Ingestion adapters
@@ -445,6 +471,95 @@ def main() -> None:
         help="Rotate the SLM install token (run `slm restart` afterwards)",
     )
 
+    # ---- SLM v3.6 Optimize subcommands (additive, never modify above) ----
+
+    # slm optimize status|on|off|savings
+    opt_p = sub.add_parser("optimize", help="Optimize module control (cache + compress)")
+    opt_sub = opt_p.add_subparsers(dest="opt_command", title="optimize subcommands")
+    opt_sub.add_parser("status", help="Show Optimize status")
+    opt_sub.add_parser("on", help="Enable cache + compress")
+    opt_sub.add_parser("off", help="Disable cache + compress")
+    savings_p = opt_sub.add_parser("savings", help="Token/cost savings report")
+    savings_p.add_argument("--since", type=int, default=7, help="Days to look back (default 7)")
+    savings_p.add_argument("--provider", default=None,
+                           choices=["anthropic", "openai", "gemini"],
+                           help="Filter by provider")
+    for _sp in opt_sub.choices.values():
+        if not any(a.option_strings == ["--json"] for a in _sp._actions):
+            _sp.add_argument("--json", action="store_true",
+                             help="Output structured JSON (agent-native)")
+
+    # slm cache status|clear|invalidate|ttl|semantic
+    cache_p = sub.add_parser("cache", help="Cache control (TTL, clear, invalidate, semantic)")
+    cache_sub = cache_p.add_subparsers(dest="cache_command", title="cache subcommands")
+    cache_sub.add_parser("status", help="Show cache state")
+    cache_sub.add_parser("clear", help="Delete all entries for tenant")
+    cache_inv_p = cache_sub.add_parser("invalidate", help="Delete entries by tag")
+    cache_inv_p.add_argument("--tag", required=True, help="Tag string to match")
+    cache_ttl_p = cache_sub.add_parser("ttl", help="Set cache TTL in seconds")
+    cache_ttl_p.add_argument("--set", dest="ttl_set", type=int, default=None,
+                             help="Exact-cache TTL (seconds, >0)")
+    cache_ttl_p.add_argument("--semantic", dest="ttl_semantic", type=int, default=None,
+                             help="Semantic-cache TTL (seconds, >0)")
+    cache_sem_p = cache_sub.add_parser("semantic", help="Enable/disable semantic cache")
+    cache_sem_p.add_argument("semantic_value", choices=["on", "off"], help="on or off")
+    for _sp in cache_sub.choices.values():
+        if not any(a.option_strings == ["--json"] for a in _sp._actions):
+            _sp.add_argument("--json", action="store_true",
+                             help="Output structured JSON (agent-native)")
+        if not any(a.option_strings == ["--tenant"] for a in _sp._actions):
+            _sp.add_argument("--tenant", default="default", help="Tenant ID (default: 'default')")
+
+    # slm compress status|mode|code|prose|ccr
+    compress_p = sub.add_parser("compress", help="Compression control (mode, code, prose, CCR)")
+    comp_sub = compress_p.add_subparsers(dest="compress_command", title="compress subcommands")
+    comp_sub.add_parser("status", help="Show compression state")
+    comp_mode_p = comp_sub.add_parser("mode", help="Set compression mode")
+    comp_mode_p.add_argument("mode_value", choices=["safe", "aggressive"],
+                             help="safe (default) or aggressive")
+    comp_code_p = comp_sub.add_parser("code", help="Enable/disable code compression")
+    comp_code_p.add_argument("code_value", choices=["on", "off"], help="on or off")
+    comp_prose_p = comp_sub.add_parser("prose", help="Enable/disable prose compression")
+    comp_prose_p.add_argument("prose_value", choices=["on", "off"], help="on or off")
+    comp_ccr_p = comp_sub.add_parser("ccr", help="Enable/disable CCR")
+    comp_ccr_p.add_argument("ccr_value", choices=["on", "off"], help="on or off")
+    comp_align_p = comp_sub.add_parser("align", help="Enable/disable alignment compression")
+    comp_align_p.add_argument("align_value", choices=["on", "off"], help="on or off")
+    for _sp in comp_sub.choices.values():
+        if not any(a.option_strings == ["--json"] for a in _sp._actions):
+            _sp.add_argument("--json", action="store_true",
+                             help="Output structured JSON (agent-native)")
+
+    # slm proxy
+    proxy_p = sub.add_parser("proxy", help="Start SLM optimization proxy (Anthropic + OpenAI)")
+    proxy_p.add_argument("--port", type=int, default=8765, help="Port (default: 8765)")
+    proxy_p.add_argument("--provider", default="anthropic",
+                         choices=["anthropic", "openai", "gemini"],
+                         help="Target provider (default: anthropic)")
+    proxy_p.add_argument("--no-compress", action="store_true", dest="no_compress",
+                         help="Disable compression for this session")
+    proxy_p.add_argument("--semantic", action="store_true",
+                         help="Enable semantic cache for this session")
+    proxy_p.add_argument("--json", action="store_true",
+                         help="Output structured JSON (agent-native)")
+
+    # slm help-optimize
+    help_opt_p = sub.add_parser(
+        "help-optimize",
+        help="Full Optimize reference: subcommands + agent recipes + safety notes",
+    )
+    help_opt_p.add_argument(
+        "topic", nargs="?", default=None,
+        choices=["cache", "compress", "optimize", "proxy", "agents", "safety"],
+        help="Topic to display (default: all)",
+    )
+    help_opt_p.add_argument(
+        "--no-pager", action="store_true", dest="no_pager", default=False,
+        help="Print to stdout instead of piping through a pager",
+    )
+
+    # ---- end SLM v3.6 Optimize subcommands ----
+
     args = parser.parse_args()
 
     if not args.command:
@@ -464,6 +579,13 @@ def main() -> None:
         # 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:
         try: