claude-smart 0.2.44 → 0.2.46

package/plugin/src/claude_smart/cli.py

@@ -3,7 +3,7 @@
 Exposes the following subcommands:
 
 - ``install``: register the GitHub marketplace and install the plugin into
-  Claude Code, then seed ``~/.reflexio/.env`` with the local-provider flags.
+  Claude Code, then seed ``~/.claude-smart/.env`` with the local-provider flags.
 - ``update``: update the plugin to the latest version via the native Claude
   Code plugin CLI.
 - ``uninstall``: remove the plugin from Claude Code via the native plugin
@@ -56,6 +56,8 @@ _CODEX_PLUGIN_CACHE_DIR = (
     / "claude-smart"
 )
 _CODEX_CLI_TIMEOUT_SECONDS = 30
+_OPENCODE_PLUGIN_SPEC = "claude-smart"
+_OPENCODE_CONFIG_NAMES = ("opencode.json", "opencode.jsonc")
 _REFLEXIO_UNREACHABLE_MSG = (
     "Failed to reach reflexio. Check ~/.claude-smart/backend.log "
     "or restart Claude Code.\n"
@@ -83,7 +85,12 @@ _LOCAL_DATA_NOTICE = (
 _INSTALL_FAILURE_MARKER = _STATE_DIR / "install-failed"
 _SERVICE_STATUS_PROBE_FAILED = "probe_failed"
 _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
-_REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / "config_self-host-org.json"
+# Org id claude-smart's backend runs under (set via REFLEXIO_DEFAULT_ORG_ID in
+# backend-service.sh). reflexio names the config file config_<org>.json, so this
+# must stay in sync with that export; using our own org keeps us off the
+# enterprise self-host backend's config_self-host-org.json.
+_REFLEXIO_ORG_ID = "claude-smart"
+_REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / f"config_{_REFLEXIO_ORG_ID}.json"
 _LOCAL_STORAGE_ENV = "LOCAL_STORAGE_PATH"
 _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
@@ -92,6 +99,9 @@ _CODEX_REQUIRED_FILES = (
     Path("plugin/scripts/codex-claude-compat"),
     Path("plugin/scripts/codex-claude-compat.cmd"),
     Path("plugin/scripts/codex-claude-compat.js"),
+    Path("plugin/scripts/opencode-claude-compat"),
+    Path("plugin/scripts/opencode-claude-compat.cmd"),
+    Path("plugin/scripts/opencode-claude-compat.js"),
     Path("plugin/scripts/codex-hook.js"),
     Path("plugin/scripts/backend-log-runner.sh"),
     Path("plugin/scripts/_codex_env.sh"),
@@ -963,6 +973,237 @@ def _configure_reflexio_setup() -> bool:
     return read_only
 
 
+def _strip_jsonc(text: str) -> str:
+    """Remove JSONC comments and trailing commas without touching strings."""
+
+    def skip_trivia(index: int) -> int:
+        while index < len(text):
+            while index < len(text) and text[index].isspace():
+                index += 1
+            if text[index : index + 2] == "//":
+                index += 2
+                while index < len(text) and text[index] not in "\r\n":
+                    index += 1
+                continue
+            if text[index : index + 2] == "/*":
+                index += 2
+                while index + 1 < len(text) and text[index : index + 2] != "*/":
+                    index += 1
+                index = min(index + 2, len(text))
+                continue
+            break
+        return index
+
+    out: list[str] = []
+    in_string = False
+    escaped = False
+    i = 0
+    while i < len(text):
+        ch = text[i]
+        nxt = text[i + 1] if i + 1 < len(text) else ""
+        if in_string:
+            out.append(ch)
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_string = False
+            i += 1
+            continue
+        if ch == '"':
+            in_string = True
+            out.append(ch)
+            i += 1
+            continue
+        if ch == "/" and nxt == "/":
+            while i < len(text) and text[i] not in "\r\n":
+                i += 1
+            continue
+        if ch == "/" and nxt == "*":
+            i += 2
+            while i + 1 < len(text) and not (text[i] == "*" and text[i + 1] == "/"):
+                i += 1
+            i += 2
+            continue
+        if ch == ",":
+            j = skip_trivia(i + 1)
+            if j < len(text) and text[j] in "}]":
+                i += 1
+                continue
+        out.append(ch)
+        i += 1
+    return "".join(out)
+
+
+def _read_jsonc_object(path: Path) -> dict[str, object]:
+    try:
+        text = path.read_text() if path.exists() else "{}"
+        parsed = json.loads(_strip_jsonc(text or "{}"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise ValueError(f"could not parse OpenCode config {path}: {exc}") from exc
+    if not isinstance(parsed, dict):
+        raise ValueError(f"OpenCode config {path} must be a JSON object")
+    return parsed
+
+
+def _opencode_global_config_dir() -> Path:
+    xdg = os.environ.get("XDG_CONFIG_HOME", "").strip()
+    base = Path(xdg) if xdg else Path.home() / ".config"
+    return base / "opencode"
+
+
+def _opencode_config_path(*, global_config: bool = False, cwd: Path | None = None) -> Path:
+    if global_config:
+        config_dir = _opencode_global_config_dir()
+        for name in _OPENCODE_CONFIG_NAMES:
+            candidate = config_dir / name
+            if candidate.exists():
+                return candidate
+        return config_dir / "opencode.json"
+    base = cwd or Path.cwd()
+    candidates = [
+        *(base / name for name in _OPENCODE_CONFIG_NAMES),
+        *(base / ".opencode" / name for name in _OPENCODE_CONFIG_NAMES),
+    ]
+    for candidate in candidates:
+        if candidate.exists():
+            return candidate
+    return base / "opencode.json"
+
+
+def _opencode_plugin_spec(entry: object) -> str | None:
+    if isinstance(entry, str):
+        return entry
+    if isinstance(entry, list) and entry and isinstance(entry[0], str):
+        return entry[0]
+    return None
+
+
+def _patch_opencode_plugin_config(
+    config_path: Path, *, install: bool
+) -> tuple[bool, Path]:
+    data = _read_jsonc_object(config_path)
+    for field in ("plugins", "plugin"):
+        value = data.get(field)
+        if value is not None and not isinstance(value, list):
+            raise ValueError(
+                f'OpenCode config {config_path} field "{field}" must be a JSON array'
+            )
+    current_plugin = data.get("plugin")
+    plugins: list[object] = []
+    if isinstance(current_plugin, list):
+        plugins.extend(current_plugin)
+    legacy_plugins = data.get("plugins")
+    if isinstance(legacy_plugins, list):
+        plugins.extend(legacy_plugins)
+    kept = [
+        item
+        for item in plugins
+        if _opencode_plugin_spec(item) != _OPENCODE_PLUGIN_SPEC
+    ]
+    next_plugins = [*kept, _OPENCODE_PLUGIN_SPEC] if install else kept
+    if isinstance(current_plugin, list):
+        changed = ("plugins" in data) or next_plugins != current_plugin
+    else:
+        changed = ("plugins" in data) or (install and bool(next_plugins))
+    if not changed:
+        return False, config_path
+    if config_path.exists():
+        original = config_path.read_text()
+        if original.strip() and original != _strip_jsonc(original):
+            config_path.with_suffix(config_path.suffix + ".bak").write_text(original)
+    data["plugin"] = next_plugins
+    data.pop("plugins", None)
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(json.dumps(data, indent=2) + "\n")
+    return True, config_path
+
+
+def _has_extraction_provider() -> bool:
+    env_config.load_reflexio_env(_REFLEXIO_ENV_PATH)
+    if os.environ.get(env_config.REFLEXIO_API_KEY_ENV, "").strip():
+        return True
+    cli_path = os.environ.get("CLAUDE_SMART_CLI_PATH", "").strip()
+    if cli_path:
+        resolved = Path(cli_path).expanduser()
+        if resolved.is_file() and os.access(resolved, os.X_OK):
+            return True
+    return bool(shutil.which("claude") or shutil.which("codex") or shutil.which("opencode"))
+
+
+def _extraction_provider_error() -> str:
+    return (
+        "error: OpenCode support needs a working learning/extraction provider.\n"
+        "Run `npx claude-smart setup` to configure Reflexio, or install "
+        "OpenCode, Claude Code, or Codex so local extraction can use a supported CLI.\n"
+    )
+
+
+def _opencode_install_supported_from_this_package() -> bool:
+    return (_SCRIPTS_DIR / "smart-install.sh").is_file()
+
+
+def _bootstrap_opencode_install(read_only: bool) -> tuple[bool, str]:
+    if not _opencode_install_supported_from_this_package():
+        return (
+            False,
+            "OpenCode install is supported from the npm package. "
+            "Run `npx claude-smart install --host opencode`.",
+        )
+    try:
+        _force_plugin_root(_PLUGIN_ROOT)
+    except OSError as exc:
+        return False, str(exc)
+    bash = _resolve_bash()
+    if not bash:
+        return False, "bash is required to bootstrap claude-smart dependencies"
+    result = subprocess.run([bash, str(_SCRIPTS_DIR / "smart-install.sh")], cwd=_PLUGIN_ROOT)
+    if result.returncode != 0:
+        return False, f"smart-install.sh failed in {_PLUGIN_ROOT}"
+    if _INSTALL_FAILURE_MARKER.is_file():
+        first_line = _INSTALL_FAILURE_MARKER.read_text().splitlines()
+        reason = (first_line[0].strip() if first_line else "") or "unknown error"
+        return False, reason
+    if read_only:
+        _prune_publish_hooks_for_read_only(_PLUGIN_ROOT)
+    return True, str(_PLUGIN_ROOT)
+
+
+def cmd_install_opencode(args: argparse.Namespace) -> int:
+    if not _opencode_install_supported_from_this_package():
+        sys.stderr.write(
+            "error: OpenCode install is supported from the npm package. "
+            "Run `npx claude-smart install --host opencode`.\n"
+        )
+        return 1
+    read_only = _configure_reflexio_setup()
+    if not _has_extraction_provider():
+        sys.stderr.write(_extraction_provider_error())
+        return 1
+    bootstrapped, message = _bootstrap_opencode_install(read_only)
+    if not bootstrapped:
+        sys.stderr.write(
+            f"error: claude-smart OpenCode setup failed during dependency bootstrap: {message}\n"
+        )
+        return 1
+    config_path = _opencode_config_path(
+        global_config=bool(getattr(args, "global_config", False))
+    )
+    try:
+        changed, config_path = _patch_opencode_plugin_config(config_path, install=True)
+    except ValueError as exc:
+        sys.stderr.write(f"error: {exc}\n")
+        return 1
+    action = "Updated" if changed else "OpenCode config already includes"
+    sys.stdout.write(
+        f"{action} `{_OPENCODE_PLUGIN_SPEC}` in {config_path}.\n"
+        f"Prepared claude-smart runtime at {message}.\n"
+        "Restart OpenCode in your project so it loads the plugin.\n"
+    )
+    return 0
+
+
 def cmd_install_codex(args: argparse.Namespace) -> int:
     """Install the claude-smart plugin marketplace for Codex.
 
@@ -1073,7 +1314,7 @@ def cmd_install(args: argparse.Namespace) -> int:
 
     Runs ``claude plugin marketplace add`` (pointed at the bundled marketplace
     at ``_REPO_ROOT``) followed by ``claude plugin install``, then appends the
-    local-provider flags to ``~/.reflexio/.env`` so reflexio can route
+    local-provider flags to ``~/.claude-smart/.env`` so reflexio can route
     generation through the local Claude Code CLI.
 
     Args:
@@ -1084,6 +1325,8 @@ def cmd_install(args: argparse.Namespace) -> int:
     """
     if getattr(args, "host", "claude-code") == "codex":
         return cmd_install_codex(args)
+    if getattr(args, "host", "claude-code") == "opencode":
+        return cmd_install_opencode(args)
 
     if not shutil.which("claude"):
         sys.stderr.write(
@@ -1156,6 +1399,8 @@ def cmd_update(args: argparse.Namespace) -> int:
     """
     if getattr(args, "host", "claude-code") == "codex":
         return cmd_update_codex(args)
+    if getattr(args, "host", "claude-code") == "opencode":
+        return cmd_update_opencode(args)
 
     _run_service(_DASHBOARD_SCRIPT, "stop")
     _run_service(_BACKEND_SCRIPT, "stop")
@@ -1182,6 +1427,17 @@ def cmd_update_codex(_args: argparse.Namespace) -> int:
     return cmd_install_codex(install_args)
 
 
+def cmd_update_opencode(args: argparse.Namespace) -> int:
+    _run_service(_DASHBOARD_SCRIPT, "stop")
+    _run_service(_BACKEND_SCRIPT, "stop")
+    sys.stdout.write(
+        "Updating claude-smart OpenCode support by reinstalling from this package...\n"
+    )
+    install_args = argparse.Namespace(**vars(args))
+    install_args.host = "opencode"
+    return cmd_install_opencode(install_args)
+
+
 def cmd_uninstall(_args: argparse.Namespace) -> int:
     """Uninstall claude-smart from Claude Code via the native plugin CLI.
 
@@ -1196,6 +1452,8 @@ def cmd_uninstall(_args: argparse.Namespace) -> int:
     """
     if getattr(_args, "host", "claude-code") == "codex":
         return cmd_uninstall_codex(_args)
+    if getattr(_args, "host", "claude-code") == "opencode":
+        return cmd_uninstall_opencode(_args)
 
     if not shutil.which("claude"):
         sys.stderr.write(
@@ -1256,6 +1514,28 @@ def cmd_uninstall_codex(_args: argparse.Namespace) -> int:
     return 0
 
 
+def cmd_uninstall_opencode(args: argparse.Namespace) -> int:
+    _run_service(_DASHBOARD_SCRIPT, "stop")
+    _run_service(_BACKEND_SCRIPT, "stop")
+    config_path = _opencode_config_path(
+        global_config=bool(getattr(args, "global_config", False))
+    )
+    try:
+        changed, config_path = _patch_opencode_plugin_config(config_path, install=False)
+    except ValueError as exc:
+        sys.stderr.write(f"error: {exc}\n")
+        return 1
+    if changed:
+        sys.stdout.write(f"Removed `{_OPENCODE_PLUGIN_SPEC}` from {config_path}.\n")
+    else:
+        sys.stdout.write(f"OpenCode config did not include `{_OPENCODE_PLUGIN_SPEC}`.\n")
+    sys.stdout.write(
+        "Restart OpenCode to apply. "
+        f"{_LOCAL_DATA_NOTICE}"
+    )
+    return 0
+
+
 def cmd_show(args: argparse.Namespace) -> int:
     """Print this project's skills + preferences, plus globally-shared skills.
 
@@ -1981,28 +2261,46 @@ def _build_parser() -> argparse.ArgumentParser:
     inst = sub.add_parser("install", help="Install claude-smart")
     inst.add_argument(
         "--host",
-        choices=("claude-code", "codex"),
+        choices=("claude-code", "codex", "opencode"),
         default="claude-code",
         help="Install target host",
     )
+    inst.add_argument(
+        "--global",
+        dest="global_config",
+        action="store_true",
+        help="For OpenCode, patch ~/.config/opencode instead of the project config",
+    )
     inst.set_defaults(func=cmd_install)
 
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
     upd.add_argument(
         "--host",
-        choices=("claude-code", "codex"),
+        choices=("claude-code", "codex", "opencode"),
         default="claude-code",
         help="Update target host",
     )
+    upd.add_argument(
+        "--global",
+        dest="global_config",
+        action="store_true",
+        help="For OpenCode, patch ~/.config/opencode instead of the project config",
+    )
     upd.set_defaults(func=cmd_update)
 
     uni = sub.add_parser("uninstall", help="Remove claude-smart")
     uni.add_argument(
         "--host",
-        choices=("claude-code", "codex"),
+        choices=("claude-code", "codex", "opencode"),
         default="claude-code",
         help="Uninstall target host",
     )
+    uni.add_argument(
+        "--global",
+        dest="global_config",
+        action="store_true",
+        help="For OpenCode, patch ~/.config/opencode instead of the project config",
+    )
     uni.set_defaults(func=cmd_uninstall)
 
     sh = sub.add_parser(

package/plugin/src/claude_smart/env_config.py

@@ -1,11 +1,19 @@
-"""Shared ``~/.reflexio/.env`` helpers for claude-smart."""
+"""Shared ``~/.claude-smart/.env`` helpers for claude-smart.
+
+claude-smart keeps its env under ``~/.claude-smart`` (not ``~/.reflexio``) so an
+OSS reflexio backend sharing this machine never leaks its ``.env`` into
+claude-smart. The data directory stays shared at ``~/.reflexio/data``. This path
+must stay in sync with the ``REFLEXIO_ENV_FILE`` export in
+``scripts/backend-service.sh`` and the source path in
+``scripts/_lib.sh`` (``claude_smart_source_reflexio_env``).
+"""
 
 from __future__ import annotations
 
 import os
 from pathlib import Path
 
-REFLEXIO_ENV_PATH = Path.home() / ".reflexio" / ".env"
+REFLEXIO_ENV_PATH = Path.home() / ".claude-smart" / ".env"
 MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/"
 REFLEXIO_URL_ENV = "REFLEXIO_URL"
 REFLEXIO_API_KEY_ENV = "REFLEXIO_API_KEY"
@@ -60,7 +68,7 @@ def parse_env_line(line: str) -> tuple[str, str] | None:
 
 
 def load_reflexio_env(path: Path | None = None) -> None:
-    """Load ``~/.reflexio/.env`` into ``os.environ`` without overriding values."""
+    """Load ``~/.claude-smart/.env`` into ``os.environ`` without overriding values."""
     path = path or REFLEXIO_ENV_PATH
     try:
         text = path.read_text()
@@ -111,7 +119,7 @@ def set_env_vars(path: Path, values: dict[str, str]) -> list[str]:
 
 
 def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
-    """Create or augment ``~/.reflexio/.env`` for claude-smart local mode.
+    """Create or augment ``~/.claude-smart/.env`` for claude-smart local mode.
 
     Existing active assignments win. This repairs first installs and deleted
     env files without clobbering explicit user overrides such as

package/plugin/src/claude_smart/events/session_start.py

@@ -5,8 +5,10 @@ from __future__ import annotations
 import json
 import os
 import sys
+from contextlib import suppress
 from pathlib import Path
 from typing import Any
+from urllib.parse import urlparse
 
 from claude_smart import hook
 from claude_smart.reflexio_adapter import Adapter
@@ -41,10 +43,12 @@ def _int_env(name: str, default: int) -> int:
 
 _CLAUDE_SMART_WINDOW_SIZE = _int_env("CLAUDE_SMART_WINDOW_SIZE", 5)
 _CLAUDE_SMART_STRIDE_SIZE = _int_env("CLAUDE_SMART_STRIDE_SIZE", 3)
-# Optimizer is on by default. Set this env var to "0" to skip pushing the
-# claude-smart optimizer defaults on SessionStart (kill switch).
-_DISABLE_OPTIMIZER_ENV = "CLAUDE_SMART_ENABLE_OPTIMIZER"
+# Optimizer defaults are local-only by default because they store an absolute
+# path to the claude-smart helper process. Set this env var to "1" to force
+# enabling against a non-local Reflexio URL, or "0" to disable everywhere.
+_OPTIMIZER_ENV = "CLAUDE_SMART_ENABLE_OPTIMIZER"
 _OPTIMIZER_TIMEOUT_SECONDS = 300
+_LOCAL_REFLEXIO_HOSTS = {"", "localhost", "127.0.0.1", "::1"}
 
 
 def _adapter() -> Adapter:
@@ -109,7 +113,7 @@ def handle(payload: dict[str, Any]) -> None:
         window_size=_CLAUDE_SMART_WINDOW_SIZE,
         stride_size=_CLAUDE_SMART_STRIDE_SIZE,
     )
-    if os.environ.get(_DISABLE_OPTIMIZER_ENV) != "0":
+    if _should_apply_optimizer_defaults(adapter):
         adapter.apply_optimizer_defaults(
             script_path=_optimizer_assistant_path(),
             timeout_seconds=_OPTIMIZER_TIMEOUT_SECONDS,
@@ -131,13 +135,28 @@ def handle(payload: dict[str, Any]) -> None:
     )
     sys.stdout.write("\n")
 
-    try:
+    with suppress(Exception):
         adapter.mark_stall_notified()
-    except Exception:  # noqa: BLE001 — telemetry must not break session.
-        pass
 
 
 def _optimizer_assistant_path() -> str:
     executable = Path(sys.executable)
     suffix = ".exe" if os.name == "nt" else ""
     return str(executable.with_name(f"claude-smart-optimizer-assistant{suffix}"))
+
+
+def _should_apply_optimizer_defaults(adapter: Any) -> bool:
+    flag = os.environ.get(_OPTIMIZER_ENV, "").strip().lower()
+    if flag in {"0", "false", "no", "off"}:
+        return False
+    if flag in {"1", "true", "yes", "on"}:
+        return True
+    return _is_local_reflexio_url(getattr(adapter, "url", ""))
+
+
+def _is_local_reflexio_url(url: str) -> bool:
+    if not url:
+        return True
+    parsed = urlparse(url)
+    host = parsed.hostname if parsed.scheme else url.split(":", 1)[0]
+    return (host or "").lower() in _LOCAL_REFLEXIO_HOSTS

package/plugin/src/claude_smart/events/stop.py

@@ -377,7 +377,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     last_assistant_message = payload.get("last_assistant_message")
     assistant_text = (
         last_assistant_message
-        if runtime.is_codex()
+        if (runtime.is_codex() or runtime.is_opencode())
         and isinstance(last_assistant_message, str)
         and last_assistant_message
         else _scan_transcript_for_assistant_text(entries)

package/plugin/src/claude_smart/ids.py

@@ -77,7 +77,7 @@ def resolve_user_id(cwd: str | os.PathLike[str] | None = None) -> str:
     Honors the ``REFLEXIO_USER_ID`` env var as an explicit override (e.g. so a
     user can point multiple projects at a single Reflexio identity), and
     otherwise falls back to :func:`resolve_project_id`. The env var is
-    loaded from ``~/.reflexio/.env`` before reading the process environment so
+    loaded from ``~/.claude-smart/.env`` before reading the process environment so
     CLI commands and hooks use the same identity resolution.
 
     Args:

package/plugin/src/claude_smart/reflexio_adapter.py

@@ -6,16 +6,15 @@ Exists so hook handlers (a) don't import reflexio directly at module scope
 
 from __future__ import annotations
 
+import inspect
 import logging
 import os
-import inspect
 from collections.abc import Sequence
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from typing import Any
 
-from claude_smart import env_config
-from claude_smart import runtime
+from claude_smart import env_config, runtime
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -174,8 +173,9 @@ class Adapter:
 
         Idempotent compare-then-write: reads ``Config``, only issues a
         ``set_config`` when the server-side values differ from the desired
-        dict below. Called unconditionally from SessionStart; the caller's
-        only escape hatch is ``CLAUDE_SMART_ENABLE_OPTIMIZER=0``.
+        dict below. SessionStart calls this only for local Reflexio URLs by
+        default; ``CLAUDE_SMART_ENABLE_OPTIMIZER=1`` forces hosted URLs, and
+        ``CLAUDE_SMART_ENABLE_OPTIMIZER=0`` disables it everywhere.
         """
         client = self._get_client()
         if client is None:

package/plugin/src/claude_smart/runtime.py

@@ -14,7 +14,8 @@ INTERNAL_ENV = "CLAUDE_SMART_INTERNAL"
 
 HOST_CLAUDE_CODE = "claude-code"
 HOST_CODEX = "codex"
-VALID_HOSTS = frozenset({HOST_CLAUDE_CODE, HOST_CODEX})
+HOST_OPENCODE = "opencode"
+VALID_HOSTS = frozenset({HOST_CLAUDE_CODE, HOST_CODEX, HOST_OPENCODE})
 
 _SHARED_AGENT_VERSION = "claude-code"
 _current_host: str | None = None
@@ -42,6 +43,11 @@ def is_codex() -> bool:
     return host() == HOST_CODEX
 
 
+def is_opencode() -> bool:
+    """True when the current hook invocation came from OpenCode."""
+    return host() == HOST_OPENCODE
+
+
 def agent_version() -> str:
     """Reflexio agent version used for shared learning across hosts."""
     return _SHARED_AGENT_VERSION

package/plugin/uv.lock

@@ -476,7 +476,7 @@ wheels = [
 
 [[package]]
 name = "claude-smart"
-version = "0.2.44"
+version = "0.2.46"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },