claude-smart 0.2.48 → 0.2.50

package/plugin/scripts/smart-install.sh

@@ -85,6 +85,8 @@ write_failure() {
   local reason fp_hash
   reason="$1"
   fp_hash="$(claude_smart_install_fingerprint_hash "$PLUGIN_ROOT" "$HERE" 2>/dev/null || true)"
+  # bin/claude-smart.js reads this marker too: first line is the user-facing
+  # failure reason, and fingerprint=... marks which install attempt produced it.
   {
     printf '%s\n' "$reason"
     if [ -n "$fp_hash" ]; then
@@ -97,6 +99,22 @@ write_failure() {
   exit 0
 }
 
+verify_windows_local_embedding_runtime() {
+  claude_smart_is_windows || return 0
+  [ "${CLAUDE_SMART_USE_LOCAL_EMBEDDING:-1}" = "1" ] || return 0
+  if claude_smart_python_imports "$PLUGIN_ROOT" onnxruntime; then
+    return 0
+  fi
+  write_failure "Windows local embedding requires Microsoft Visual C++ Redistributable for onnxruntime; install the x64 redistributable from https://aka.ms/vs/17/release/vc_redist.x64.exe and rerun claude-smart install."
+}
+
+if [ "${1:-}" = "verify-windows-embedding" ]; then
+  # Node bootstrap runs this after uv sync so install-failed markers stay
+  # consistent with the shell installer path.
+  verify_windows_local_embedding_runtime
+  exit 0
+fi
+
 install_fingerprint() {
   claude_smart_install_fingerprint "$PLUGIN_ROOT" "$HERE"
 }
@@ -112,6 +130,7 @@ install_complete() {
     grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_CLI=' "$HOME/.claude-smart/.env" || return 1
     grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$HOME/.claude-smart/.env" || return 1
     grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_READ_ONLY=' "$HOME/.claude-smart/.env" || return 1
+    grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_HOST=' "$HOME/.claude-smart/.env" || return 1
   fi
   if [ -d "$PLUGIN_ROOT/dashboard" ]; then
     [ -d "$PLUGIN_ROOT/dashboard/.next" ] || [ -f "$MARKER_DIR/dashboard-build.pid" ] || [ -f "$(claude_smart_dashboard_unavailable_marker)" ] || return 1
@@ -130,7 +149,21 @@ install_vendored_reflexio() {
   local VENDORED_REFLEXIO PLUGIN_PYTHON
 
   VENDORED_REFLEXIO="$PLUGIN_ROOT/vendor/reflexio"
-  [ -f "$VENDORED_REFLEXIO/pyproject.toml" ] || return 0
+  if [ ! -f "$VENDORED_REFLEXIO/pyproject.toml" ]; then
+    # A host plugin cache (~/.claude/plugins/cache/..., ~/.codex/plugins/cache/...)
+    # is only ever populated from the npm package, which always carries the
+    # vendored runtime. Missing it there means the plugin was installed straight
+    # from the GitHub marketplace, where the bundle is gitignored — the backend
+    # could never start. Fail here, at Setup, rather than at first session.
+    case "$PLUGIN_ROOT" in
+      */plugins/cache/*)
+        write_failure "bundled Reflexio runtime is missing from $VENDORED_REFLEXIO. This happens when claude-smart is installed from the GitHub marketplace, which does not carry the generated runtime. Install with: npx claude-smart install"
+        ;;
+    esac
+    # A source checkout legitimately has no vendor bundle (it is generated at
+    # pack time); reflexio comes from the plugin venv instead.
+    return 0
+  fi
 
   if claude_smart_is_windows; then
     PLUGIN_PYTHON="$PLUGIN_ROOT/.venv/Scripts/python.exe"
@@ -196,7 +229,7 @@ install_private_node() {
   local NODE_MIN_MAJOR NODE_MIN_MINOR NODE_LTS_MAJOR
   local node_os archive_ext reason node_arch node_platform base_url node_root
   local tmp_dir shasums_path archive_name ext_re install_dir archive_path
-  local expected_hash actual_hash archive_win dest_win candidate_path next_link
+  local expected_hash actual_hash archive_win dest_win candidate_path next_link old_current
 
   NODE_MIN_MAJOR=20
   NODE_MIN_MINOR=9
@@ -361,19 +394,57 @@ install_private_node() {
     return 1
   fi
 
-  next_link="$node_root/current.next.$$"
-  if ln -s "$install_dir" "$next_link" 2>/dev/null; then
-    if mv -Tf "$next_link" "$node_root/current" 2>/dev/null; then
-      :
-    elif mv -hf "$next_link" "$node_root/current" 2>/dev/null; then
-      :
+  if claude_smart_is_windows; then
+    # Windows cannot rely on the POSIX symlink swap path; keep current recoverable.
+    old_current="$node_root/current.old.$$"
+    rm -rf "$old_current" 2>/dev/null || true
+    if [ -e "$node_root/current" ] || [ -L "$node_root/current" ]; then
+      if ! mv "$node_root/current" "$old_current"; then
+        rm -rf "$tmp_dir" "$install_dir"
+        reason="could not stage existing private Node.js install for replacement"
+        echo "[claude-smart] WARNING: $reason" >&2
+        claude_smart_write_dashboard_unavailable "$reason"
+        return 1
+      fi
+    fi
+    if mv "$install_dir" "$node_root/current"; then
+      rm -rf "$old_current" 2>/dev/null || true
     else
-      rm -rf "$node_root/current"
-      mv "$next_link" "$node_root/current"
+      reason="could not activate private Node.js install at $node_root/current"
+      if [ -e "$node_root/current" ] || [ -L "$node_root/current" ]; then
+        if ! rm -rf "$node_root/current"; then
+          reason="could not remove failed private Node.js install at $node_root/current; previous install remains at $old_current for manual recovery"
+          rm -rf "$tmp_dir" "$install_dir"
+          echo "[claude-smart] WARNING: $reason" >&2
+          claude_smart_write_dashboard_unavailable "$reason"
+          return 1
+        fi
+      fi
+      if [ -e "$old_current" ] || [ -L "$old_current" ]; then
+        if ! mv "$old_current" "$node_root/current"; then
+          reason="could not restore previous private Node.js install from $old_current after activation failure; previous install remains at $old_current for manual recovery"
+        fi
+      fi
+      rm -rf "$tmp_dir" "$install_dir"
+      echo "[claude-smart] WARNING: $reason" >&2
+      claude_smart_write_dashboard_unavailable "$reason"
+      return 1
     fi
   else
-    rm -rf "$next_link" "$node_root/current"
-    mv "$install_dir" "$node_root/current"
+    next_link="$node_root/current.next.$$"
+    if ln -s "$install_dir" "$next_link" 2>/dev/null; then
+      if mv -Tf "$next_link" "$node_root/current" 2>/dev/null; then
+        :
+      elif mv -hf "$next_link" "$node_root/current" 2>/dev/null; then
+        :
+      else
+        rm -rf "$node_root/current"
+        mv "$next_link" "$node_root/current"
+      fi
+    else
+      rm -rf "$next_link" "$node_root/current"
+      mv "$install_dir" "$node_root/current"
+    fi
   fi
 
   rm -rf "$tmp_dir"
@@ -399,6 +470,7 @@ fi
 preflight_supported_runtime_platform
 
 if install_complete; then
+  verify_windows_local_embedding_runtime
   start_backend_service
   claude_smart_emit_continue
   exit 0
@@ -489,7 +561,7 @@ fi
 # claude-smart's backend loads ~/.claude-smart/.env (backend-service.sh exports
 # REFLEXIO_ENV_FILE so reflexio's CLI reads it instead of ~/.reflexio/.env);
 # append our opt-in flags there so `reflexio services start` picks them up. Keep
-# this path in sync with env_config.REFLEXIO_ENV_PATH and backend-service.sh.
+# this path in sync with env_config.CLAUDE_SMART_ENV_PATH and backend-service.sh.
 REFLEXIO_ENV="$HOME/.claude-smart/.env"
 mkdir -p "$(dirname "$REFLEXIO_ENV")"
 claude_smart_env_quote() {
@@ -562,6 +634,9 @@ claude_smart_prune_managed_env_keys_for_local() {
 }
 
 claude_smart_ensure_local_env_defaults() {
+  local local_cli_default local_embedding_default
+  local_cli_default="${CLAUDE_SMART_USE_LOCAL_CLI:-1}"
+  local_embedding_default="${CLAUDE_SMART_USE_LOCAL_EMBEDDING:-1}"
   [ -z "${REFLEXIO_API_KEY:-}" ] || return 0
   mkdir -p "$(dirname "$REFLEXIO_ENV")"
   touch "$REFLEXIO_ENV"
@@ -569,23 +644,29 @@ claude_smart_ensure_local_env_defaults() {
   claude_smart_prune_managed_env_keys_for_local
   unset REFLEXIO_URL REFLEXIO_API_KEY REFLEXIO_USER_ID CLAUDE_SMART_MANAGED_SETUP
   if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_CLI=' "$REFLEXIO_ENV"; then
-    printf '# Route reflexio generation through the local Claude Code CLI\n' >> "$REFLEXIO_ENV"
-    claude_smart_env_append_raw_if_missing CLAUDE_SMART_USE_LOCAL_CLI "1"
-    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_CLI=1 to $REFLEXIO_ENV" >&2
+    printf '# Route reflexio generation through the configured local host CLI\n' >> "$REFLEXIO_ENV"
+    claude_smart_env_append_raw_if_missing CLAUDE_SMART_USE_LOCAL_CLI "$local_cli_default"
+    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_CLI=$local_cli_default to $REFLEXIO_ENV" >&2
   fi
   if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_USE_LOCAL_EMBEDDING=' "$REFLEXIO_ENV"; then
     printf '# Use the in-process ONNX embedder (chromadb) - no API key for semantic search\n' >> "$REFLEXIO_ENV"
-    claude_smart_env_append_raw_if_missing CLAUDE_SMART_USE_LOCAL_EMBEDDING "1"
-    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=1 to $REFLEXIO_ENV" >&2
+    claude_smart_env_append_raw_if_missing CLAUDE_SMART_USE_LOCAL_EMBEDDING "$local_embedding_default"
+    echo "[claude-smart] appended CLAUDE_SMART_USE_LOCAL_EMBEDDING=$local_embedding_default to $REFLEXIO_ENV" >&2
   fi
   if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_READ_ONLY=' "$REFLEXIO_ENV"; then
     claude_smart_env_upsert CLAUDE_SMART_READ_ONLY "0"
     echo "[claude-smart] appended CLAUDE_SMART_READ_ONLY=0 to $REFLEXIO_ENV" >&2
   fi
+  if ! grep -qE '^(export[[:space:]]+)?CLAUDE_SMART_HOST=' "$REFLEXIO_ENV"; then
+    claude_smart_env_upsert CLAUDE_SMART_HOST "claude-code"
+    echo "[claude-smart] appended CLAUDE_SMART_HOST=claude-code to $REFLEXIO_ENV" >&2
+  fi
   chmod 600 "$REFLEXIO_ENV"
 }
 
 claude_smart_ensure_local_env_defaults
+# No-op outside Git Bash/MSYS/Cygwin; non-Windows installs must not depend on it.
+verify_windows_local_embedding_runtime
 
 # Migrate stale REFLEXIO_URL from reflexio's library default (8081) to the
 # plugin backend port (8071). Matches the quoted and unquoted forms but
@@ -599,9 +680,23 @@ if [ -f "$REFLEXIO_ENV" ] && grep -qE '^REFLEXIO_URL=("http://localhost:8081/?"|
   echo "[claude-smart] migrated REFLEXIO_URL 8081 → 8071 in $REFLEXIO_ENV (backup at $REFLEXIO_ENV.bak)" >&2
 fi
 
-if ! command -v claude >/dev/null 2>&1; then
-  echo "[claude-smart] WARNING: 'claude' CLI not on PATH — reflexio extractors will have no LLM until it's installed" >&2
-fi
+case "${CLAUDE_SMART_HOST:-claude-code}" in
+  opencode)
+    if [ -z "${CLAUDE_SMART_OPENCODE_PATH:-}" ] && ! command -v opencode >/dev/null 2>&1; then
+      echo "[claude-smart] WARNING: 'opencode' CLI not on PATH and CLAUDE_SMART_OPENCODE_PATH is not set — reflexio extractors will have no LLM until OpenCode is installed" >&2
+    fi
+    ;;
+  codex)
+    if ! command -v codex >/dev/null 2>&1; then
+      echo "[claude-smart] WARNING: 'codex' CLI not on PATH — reflexio extractors will have no LLM until Codex is installed" >&2
+    fi
+    ;;
+  *)
+    if ! command -v claude >/dev/null 2>&1; then
+      echo "[claude-smart] WARNING: 'claude' CLI not on PATH — reflexio extractors will have no LLM until Claude Code is installed" >&2
+    fi
+    ;;
+esac
 
 LEGACY_CS_CITE="$HOME/.claude-smart/bin/cs-cite"
 if [ -e "$LEGACY_CS_CITE" ]; then

package/plugin/src/README.md

@@ -28,7 +28,7 @@ Description: Python package powering the claude-smart plugin — hook handlers t
 
 | File | Purpose |
 |------|---------|
-| `env_config.py` | Parses `~/.claude-smart/.env` (`REFLEXIO_URL`, `REFLEXIO_API_KEY`, `CLAUDE_SMART_READ_ONLY`, local embedding/CLI flags). |
+| `env_config.py` | Parses `~/.claude-smart/.env` (`REFLEXIO_URL`, `REFLEXIO_API_KEY`, `CLAUDE_SMART_READ_ONLY`, `CLAUDE_SMART_HOST`, local embedding/CLI flags). |
 | `runtime.py` | Host detection (Claude Code vs Codex); shared agent version. |
 | `ids.py` | Session / project ID generation and resolution. |
 | `context_inject.py`, `context_format.py`, `query_compose.py`, `cs_cite.py` | Build search queries, format learned skills as markdown, inject into context, format citations. |

package/plugin/src/claude_smart/cli.py

@@ -37,10 +37,14 @@ from pathlib import Path
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
-from claude_smart import context_format, cs_cite, env_config, ids, publish, state
+from claude_smart import context_format, cs_cite, env_config, ids, publish, runtime, state
 from claude_smart.reflexio_adapter import Adapter
 
-_REFLEXIO_ENV_PATH = env_config.REFLEXIO_ENV_PATH
+_HOST_CLAUDE_CODE = runtime.HOST_CLAUDE_CODE
+_HOST_CODEX = runtime.HOST_CODEX
+_HOST_OPENCODE = runtime.HOST_OPENCODE
+_HOST_CHOICES = (_HOST_CLAUDE_CODE, _HOST_CODEX, _HOST_OPENCODE)
+_CLAUDE_SMART_ENV_PATH = env_config.CLAUDE_SMART_ENV_PATH
 _MANAGED_REFLEXIO_URL = env_config.MANAGED_REFLEXIO_URL
 _PLUGIN_SPEC = "claude-smart@reflexioai"
 _CODEX_MARKETPLACE_NAME = "reflexioai"
@@ -99,6 +103,7 @@ _DEFAULT_STORAGE_ROOT = _REFLEXIO_DIR / "data"
 _REFLEXIO_ORG_ID = "claude-smart"
 _REFLEXIO_CONFIG_PATH = _REFLEXIO_DIR / "configs" / f"config_{_REFLEXIO_ORG_ID}.json"
 _LOCAL_STORAGE_ENV = "LOCAL_STORAGE_PATH"
+_OPENCODE_PATH_ENV = "CLAUDE_SMART_OPENCODE_PATH"
 _CODEX_REQUIRED_FILES = (
     Path(".agents/plugins/marketplace.json"),
     Path("plugin/.codex-plugin/plugin.json"),
@@ -927,15 +932,20 @@ def _register_codex_marketplace(root: Path) -> tuple[bool, str]:
     return False, output or "Codex CLI does not expose plugin marketplace commands"
 
 
-def _configure_reflexio_setup() -> bool:
+def _configure_reflexio_setup(host: str = _HOST_CLAUDE_CODE) -> bool:
     """Load setup state and ensure local defaults when unmanaged.
 
+    Args:
+        host: Host integration being installed. Persisted in local mode so
+            later backend restarts can wire the same extraction bridge even
+            when the host plugin server is not the process launcher.
+
     Returns:
         bool: Whether read-only mode is enabled.
     """
-    env_config.load_reflexio_env(_REFLEXIO_ENV_PATH)
+    env_config.load_reflexio_env(_CLAUDE_SMART_ENV_PATH)
     try:
-        env_text = _REFLEXIO_ENV_PATH.read_text()
+        env_text = _CLAUDE_SMART_ENV_PATH.read_text()
     except OSError:
         env_text = ""
     read_only_value = ""
@@ -975,9 +985,9 @@ def _configure_reflexio_setup() -> bool:
         os.environ.pop(env_config.REFLEXIO_API_KEY_ENV, None)
         os.environ.pop("REFLEXIO_USER_ID", None)
         os.environ.pop("CLAUDE_SMART_MANAGED_SETUP", None)
-        added = env_config.ensure_local_env_defaults(_REFLEXIO_ENV_PATH)
+        added = env_config.ensure_local_env_defaults(_CLAUDE_SMART_ENV_PATH, host=host)
         if added:
-            sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
+            sys.stdout.write(f"Seeded {_CLAUDE_SMART_ENV_PATH} with {', '.join(added)}.\n")
     return read_only
 
 
@@ -1174,7 +1184,7 @@ def _patch_opencode_plugin_config(
 
 
 def _has_extraction_provider() -> bool:
-    env_config.load_reflexio_env(_REFLEXIO_ENV_PATH)
+    env_config.load_reflexio_env(_CLAUDE_SMART_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()
@@ -1182,7 +1192,7 @@ def _has_extraction_provider() -> bool:
         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"))
+    return bool(shutil.which("claude") or shutil.which("codex") or _resolve_opencode_path())
 
 
 def _extraction_provider_error() -> str:
@@ -1193,6 +1203,41 @@ def _extraction_provider_error() -> str:
     )
 
 
+def _has_opencode_cli() -> bool:
+    return _resolve_opencode_path() is not None
+
+
+def _resolve_opencode_path() -> str | None:
+    opencode_path = os.environ.get(_OPENCODE_PATH_ENV, "").strip()
+    if opencode_path:
+        resolved = Path(opencode_path).expanduser()
+        if resolved.is_file() and os.access(resolved, os.X_OK):
+            return str(resolved)
+    return shutil.which("opencode")
+
+
+def _persist_opencode_path() -> list[str]:
+    resolved = _resolve_opencode_path()
+    if not resolved:
+        return []
+    os.environ[_OPENCODE_PATH_ENV] = resolved
+    return env_config.set_env_vars(_CLAUDE_SMART_ENV_PATH, {_OPENCODE_PATH_ENV: resolved})
+
+
+def _opencode_prerequisite_error() -> str | None:
+    if not _has_opencode_cli():
+        return (
+            "error: OpenCode CLI not found on PATH. Install OpenCode first, "
+            "or set CLAUDE_SMART_OPENCODE_PATH to the OpenCode executable.\n"
+        )
+    if os.name == "nt" and not _resolve_bash():
+        return (
+            "error: Git Bash is required for claude-smart OpenCode support on Windows. "
+            "Install Git for Windows and ensure bash.exe is on PATH, or run OpenCode from WSL.\n"
+        )
+    return None
+
+
 def _opencode_install_supported_from_this_package() -> bool:
     return (_SCRIPTS_DIR / "smart-install.sh").is_file()
 
@@ -1332,7 +1377,12 @@ def cmd_install_opencode(args: argparse.Namespace) -> int:
             "Run `npx claude-smart install --host opencode`.\n"
         )
         return 1
-    read_only = _configure_reflexio_setup()
+    prerequisite_error = _opencode_prerequisite_error()
+    if prerequisite_error:
+        sys.stderr.write(prerequisite_error)
+        return 1
+    read_only = _configure_reflexio_setup(host=_HOST_OPENCODE)
+    _persist_opencode_path()
     if not _has_extraction_provider():
         sys.stderr.write(_extraction_provider_error())
         return 1
@@ -1387,7 +1437,7 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
             "error: 'uv' not found on PATH. Install uv or restart your shell.\n"
         )
         return 1
-    read_only = _configure_reflexio_setup()
+    read_only = _configure_reflexio_setup(host=_HOST_CODEX)
 
     missing = _missing_codex_marketplace_files(_REPO_ROOT)
     if missing:
@@ -1485,9 +1535,9 @@ def cmd_install(args: argparse.Namespace) -> int:
     Returns:
         int: 0 on success, non-zero if the ``claude`` CLI is missing or fails.
     """
-    if getattr(args, "host", "claude-code") == "codex":
+    if getattr(args, "host", _HOST_CLAUDE_CODE) == _HOST_CODEX:
         return cmd_install_codex(args)
-    if getattr(args, "host", "claude-code") == "opencode":
+    if getattr(args, "host", _HOST_CLAUDE_CODE) == _HOST_OPENCODE:
         return cmd_install_opencode(args)
 
     if not shutil.which("claude"):
@@ -1496,7 +1546,7 @@ def cmd_install(args: argparse.Namespace) -> int:
             "Install Claude Code first: https://claude.com/claude-code\n"
         )
         return 1
-    read_only = _configure_reflexio_setup()
+    read_only = _configure_reflexio_setup(host=_HOST_CLAUDE_CODE)
 
     refresh_existing = bool(getattr(args, "refresh_existing", False))
     for cmd in (
@@ -1559,16 +1609,16 @@ def cmd_update(args: argparse.Namespace) -> int:
     Returns:
         int: 0 on success, non-zero if the host CLI is missing or install fails.
     """
-    if getattr(args, "host", "claude-code") == "codex":
+    if getattr(args, "host", _HOST_CLAUDE_CODE) == _HOST_CODEX:
         return cmd_update_codex(args)
-    if getattr(args, "host", "claude-code") == "opencode":
+    if getattr(args, "host", _HOST_CLAUDE_CODE) == _HOST_OPENCODE:
         return cmd_update_opencode(args)
 
     _run_service(_DASHBOARD_SCRIPT, "stop")
     _run_service(_BACKEND_SCRIPT, "stop")
     sys.stdout.write("Updating claude-smart by reinstalling from this package...\n")
     install_args = argparse.Namespace(**vars(args), refresh_existing=True)
-    install_args.host = "claude-code"
+    install_args.host = _HOST_CLAUDE_CODE
     return cmd_install(install_args)
 
 
@@ -1585,7 +1635,7 @@ def cmd_update_codex(_args: argparse.Namespace) -> int:
         "Updating claude-smart Codex support by reinstalling from this package...\n"
     )
     install_args = argparse.Namespace(**vars(_args))
-    install_args.host = "codex"
+    install_args.host = _HOST_CODEX
     return cmd_install_codex(install_args)
 
 
@@ -1596,7 +1646,7 @@ def cmd_update_opencode(args: argparse.Namespace) -> int:
         "Updating claude-smart OpenCode support by reinstalling from this package...\n"
     )
     install_args = argparse.Namespace(**vars(args))
-    install_args.host = "opencode"
+    install_args.host = _HOST_OPENCODE
     return cmd_install_opencode(install_args)
 
 
@@ -1612,9 +1662,9 @@ def cmd_uninstall(_args: argparse.Namespace) -> int:
     Returns:
         int: 0 on success, non-zero if the ``claude`` CLI is missing or fails.
     """
-    if getattr(_args, "host", "claude-code") == "codex":
+    if getattr(_args, "host", _HOST_CLAUDE_CODE) == _HOST_CODEX:
         return cmd_uninstall_codex(_args)
-    if getattr(_args, "host", "claude-code") == "opencode":
+    if getattr(_args, "host", _HOST_CLAUDE_CODE) == _HOST_OPENCODE:
         return cmd_uninstall_opencode(_args)
 
     if not shutil.which("claude"):
@@ -1761,7 +1811,7 @@ def _reflexio_show_footer() -> str:
         str: A leading-separator markdown footer ending in a newline.
     """
     return (
-        f"\n---\n⭐ claude-smart is powered by [reflexio]({cs_cite.REFLEXIO_REPO_URL})"
+        f"\n---\nclaude-smart is powered by [reflexio]({cs_cite.REFLEXIO_REPO_URL})"
         f" — if it helps you, [star it on GitHub]({cs_cite.REFLEXIO_REPO_URL}).\n"
     )
 
@@ -1949,7 +1999,7 @@ def _resolve_absolute_path(raw_path: str | Path, *, source: str) -> Path:
 def _effective_storage_root() -> Path:
     raw = os.environ.get(_LOCAL_STORAGE_ENV, "").strip()
     if not raw:
-        raw = _read_dotenv_value(_REFLEXIO_ENV_PATH, _LOCAL_STORAGE_ENV) or ""
+        raw = _read_dotenv_value(_CLAUDE_SMART_ENV_PATH, _LOCAL_STORAGE_ENV) or ""
     return _resolve_absolute_path(
         raw or _DEFAULT_STORAGE_ROOT, source=_LOCAL_STORAGE_ENV
     )
@@ -2135,6 +2185,20 @@ def cmd_restart(args: argparse.Namespace) -> int:
         return 0
 
     if do_backend:
+        # Preparing the replacement can reinstall the vendored Reflexio if its
+        # version drifted, so this both validates and repairs. It must succeed
+        # before we stop anything: a backend we cannot replace is better left
+        # running.
+        sys.stdout.write("Preparing reflexio backend replacement…\n")
+        preflight_rc = _run_service(_BACKEND_SCRIPT, "preflight")
+        if preflight_rc != 0:
+            sys.stderr.write(
+                "error: reflexio backend replacement failed preflight; "
+                "existing services were not changed.\n"
+                "Repair the bundled runtime with: npx claude-smart update\n"
+            )
+            return preflight_rc
+
         sys.stdout.write("Stopping reflexio backend…\n")
         _run_service(_BACKEND_SCRIPT, "stop")
     if do_dashboard:
@@ -2449,8 +2513,8 @@ def _build_parser() -> argparse.ArgumentParser:
     inst = sub.add_parser("install", help="Install claude-smart")
     inst.add_argument(
         "--host",
-        choices=("claude-code", "codex", "opencode"),
-        default="claude-code",
+        choices=_HOST_CHOICES,
+        default=_HOST_CLAUDE_CODE,
         help="Install target host",
     )
     inst.add_argument(
@@ -2464,8 +2528,8 @@ def _build_parser() -> argparse.ArgumentParser:
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
     upd.add_argument(
         "--host",
-        choices=("claude-code", "codex", "opencode"),
-        default="claude-code",
+        choices=_HOST_CHOICES,
+        default=_HOST_CLAUDE_CODE,
         help="Update target host",
     )
     upd.add_argument(
@@ -2479,8 +2543,8 @@ def _build_parser() -> argparse.ArgumentParser:
     uni = sub.add_parser("uninstall", help="Remove claude-smart")
     uni.add_argument(
         "--host",
-        choices=("claude-code", "codex", "opencode"),
-        default="claude-code",
+        choices=_HOST_CHOICES,
+        default=_HOST_CLAUDE_CODE,
         help="Uninstall target host",
     )
     uni.add_argument(

package/plugin/src/claude_smart/context_inject.py

@@ -59,6 +59,9 @@ def emit_context(
         project_id=project_id,
         query=query,
         top_k=top_k,
+        # Scopes server-side dedup: rules already injected into this session
+        # are not returned again; next-best matches backfill instead.
+        session_id=session_id or None,
     )
     renderer = (
         context_format.render_inline_compact_with_registry

package/plugin/src/claude_smart/env_config.py

@@ -13,17 +13,26 @@ from __future__ import annotations
 import os
 from pathlib import Path
 
-REFLEXIO_ENV_PATH = Path.home() / ".claude-smart" / ".env"
+from claude_smart import runtime
+
+CLAUDE_SMART_ENV_PATH = Path.home() / ".claude-smart" / ".env"
+# Deprecated internal alias kept so older imports do not fail abruptly.
+REFLEXIO_ENV_PATH = CLAUDE_SMART_ENV_PATH
 MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/"
 REFLEXIO_URL_ENV = "REFLEXIO_URL"
 REFLEXIO_API_KEY_ENV = "REFLEXIO_API_KEY"
 CLAUDE_SMART_READ_ONLY_ENV = "CLAUDE_SMART_READ_ONLY"
 CLAUDE_SMART_USE_LOCAL_CLI_ENV = "CLAUDE_SMART_USE_LOCAL_CLI"
 CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
+CLAUDE_SMART_HOST_ENV = "CLAUDE_SMART_HOST"
+DEFAULT_CLAUDE_SMART_HOST = runtime.HOST_CLAUDE_CODE
 
 _LOCAL_DEFAULT_ENTRIES = (
     (
-        "# Route reflexio generation through the local Claude Code CLI",
+        "# Set to 1 to route reflexio generation through the active host CLI "
+        "(claude for Claude Code, the host compatibility bridge for OpenCode/Codex). "
+        "Set to 0 to disable that provider so reflexio auto-detects a cloud LLM "
+        "key (anthropic, minimax, openai, etc.) from ~/.claude-smart/.env instead.",
         CLAUDE_SMART_USE_LOCAL_CLI_ENV,
         "1",
     ),
@@ -33,7 +42,12 @@ _LOCAL_DEFAULT_ENTRIES = (
         "1",
     ),
     (None, CLAUDE_SMART_READ_ONLY_ENV, "0"),
+    (None, CLAUDE_SMART_HOST_ENV, DEFAULT_CLAUDE_SMART_HOST),
 )
+_ENV_OVERRIDABLE_LOCAL_DEFAULT_KEYS = {
+    CLAUDE_SMART_USE_LOCAL_CLI_ENV,
+    CLAUDE_SMART_USE_LOCAL_EMBEDDING_ENV,
+}
 _LOCAL_MODE_PRUNE_KEYS = {
     REFLEXIO_URL_ENV,
     REFLEXIO_API_KEY_ENV,
@@ -69,7 +83,7 @@ def parse_env_line(line: str) -> tuple[str, str] | None:
 
 def load_reflexio_env(path: Path | None = None) -> None:
     """Load ``~/.claude-smart/.env`` into ``os.environ`` without overriding values."""
-    path = path or REFLEXIO_ENV_PATH
+    path = path or CLAUDE_SMART_ENV_PATH
     try:
         text = path.read_text()
     except OSError:
@@ -118,14 +132,19 @@ def set_env_vars(path: Path, values: dict[str, str]) -> list[str]:
     return added
 
 
-def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
+def ensure_local_env_defaults(
+    path: Path | None = None,
+    host: str = DEFAULT_CLAUDE_SMART_HOST,
+) -> list[str]:
     """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
-    ``CLAUDE_SMART_READ_ONLY=1``.
+    Existing active assignments win except ``CLAUDE_SMART_HOST``, which is
+    install-selected state and must follow the host currently being installed.
+    This repairs first installs and deleted env files without clobbering
+    explicit user overrides such as ``CLAUDE_SMART_READ_ONLY=1``.
     """
-    path = path or REFLEXIO_ENV_PATH
+    install_host = host
+    path = path or CLAUDE_SMART_ENV_PATH
     path.parent.mkdir(parents=True, exist_ok=True)
     try:
         existing = path.read_text()
@@ -135,6 +154,8 @@ def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
     present: set[str] = set()
     kept_lines: list[str] = []
     pruned = False
+    changed = False
+    host_written = False
     for line in existing.splitlines():
         parsed = parse_env_line(line)
         if parsed is not None:
@@ -142,6 +163,19 @@ def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
             if key in _LOCAL_MODE_PRUNE_KEYS:
                 pruned = True
                 continue
+            if key == CLAUDE_SMART_HOST_ENV:
+                present.add(key)
+                if not host_written:
+                    replacement = (
+                        f"{CLAUDE_SMART_HOST_ENV}={_escape_env_value(install_host)}"
+                    )
+                    kept_lines.append(replacement)
+                    host_written = True
+                    if line != replacement or _value != install_host:
+                        changed = True
+                else:
+                    changed = True
+                continue
             present.add(key)
         kept_lines.append(line)
 
@@ -150,15 +184,16 @@ def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
     for comment, key, value in _LOCAL_DEFAULT_ENTRIES:
         if key in present:
             continue
+        effective_value = _resolve_local_env_default(key, value, install_host)
         if comment:
             additions.append(comment)
         if key == CLAUDE_SMART_READ_ONLY_ENV:
-            additions.append(f'{key}="{_escape_env_value(value)}"')
+            additions.append(f'{key}="{_escape_env_value(effective_value)}"')
         else:
-            additions.append(f"{key}={_escape_env_value(value)}")
+            additions.append(f"{key}={_escape_env_value(effective_value)}")
         added_keys.append(key)
 
-    if additions or pruned:
+    if additions or pruned or changed:
         content = "\n".join(kept_lines)
         if additions:
             prefix = "" if not content or content.endswith("\n") else "\n"
@@ -171,6 +206,16 @@ def ensure_local_env_defaults(path: Path | None = None) -> list[str]:
     return added_keys
 
 
+def _resolve_local_env_default(key: str, fallback: str, install_host: str) -> str:
+    if key == CLAUDE_SMART_HOST_ENV:
+        return install_host
+    if key in _ENV_OVERRIDABLE_LOCAL_DEFAULT_KEYS:
+        explicit = os.environ.get(key, "").strip()
+        if explicit:
+            return explicit
+    return fallback
+
+
 def env_truthy(name: str) -> bool:
     """Return True when an environment flag is explicitly enabled."""
     return os.environ.get(name, "").strip().lower() in {"1", "true", "yes", "on"}