claude-smart 0.2.35 → 0.2.37

package/plugin/src/claude_smart/cli.py

@@ -30,7 +30,6 @@ import shutil
 import subprocess
 import sys
 import time
-import uuid
 from dataclasses import dataclass
 from pathlib import Path
 
@@ -120,59 +119,6 @@ def _latest_session_id() -> str | None:
     return files[0].stem
 
 
-def _seed_reflexio_env() -> list[str]:
-    """Append the two local-provider flags to ``~/.reflexio/.env``, idempotently.
-
-    Returns:
-        list[str]: Flag names that were newly appended (empty if already present).
-    """
-    _REFLEXIO_ENV_PATH.parent.mkdir(parents=True, exist_ok=True)
-    _REFLEXIO_ENV_PATH.touch(exist_ok=True)
-    existing = _REFLEXIO_ENV_PATH.read_text()
-    flags = (
-        "CLAUDE_SMART_USE_LOCAL_CLI",
-        "CLAUDE_SMART_USE_LOCAL_EMBEDDING",
-    )
-    missing = [f for f in flags if f"{f}=" not in existing]
-    if not missing:
-        return []
-    prefix = "" if not existing or existing.endswith("\n") else "\n"
-    with _REFLEXIO_ENV_PATH.open("a") as fh:
-        fh.write(prefix + "\n".join(f"{f}=1" for f in missing) + "\n")
-    _REFLEXIO_ENV_PATH.chmod(0o600)
-    return missing
-
-
-def _seed_managed_reflexio_env(*, api_key: str, reflexio_url: str) -> list[str]:
-    """Write managed Reflexio connection settings to ``~/.reflexio/.env``."""
-    user_id = _read_reflexio_env_value(env_config.REFLEXIO_USER_ID_ENV) or str(
-        uuid.uuid4()
-    )
-    return env_config.set_env_vars(
-        _REFLEXIO_ENV_PATH,
-        {
-            env_config.REFLEXIO_URL_ENV: reflexio_url,
-            env_config.REFLEXIO_API_KEY_ENV: api_key,
-            env_config.REFLEXIO_USER_ID_ENV: user_id,
-        },
-    )
-
-
-def _read_reflexio_env_value(key: str) -> str:
-    try:
-        text = _REFLEXIO_ENV_PATH.read_text()
-    except OSError:
-        return ""
-    for line in text.splitlines():
-        parsed = env_config.parse_env_line(line)
-        if parsed is None:
-            continue
-        parsed_key, value = parsed
-        if parsed_key == key:
-            return value
-    return ""
-
-
 def _semver_tuple(path: Path) -> tuple[int, int, int] | None:
     parts = path.name.split(".", 2)
     if len(parts) != 3:
@@ -328,6 +274,69 @@ def _prepare_codex_local_marketplace() -> Path:
     return marketplace_root
 
 
+def _command_is_publish_hook(command: object) -> bool:
+    if not isinstance(command, str):
+        return False
+    return bool(
+        re.search(
+            r"hook_entry\.sh\b[\s\"']+(?:codex|claude-code)[\s\"']+(?:stop|session-end)\b",
+            command,
+        )
+        or re.search(
+            r"codex-hook\.js\"?(?:\s+\"?hook\"?){1}\s+\"?(?:stop|session-end)\"?",
+            command,
+        )
+    )
+
+
+def _prune_publish_hooks_for_read_only(plugin_root: Path) -> None:
+    """Remove publish-to-reflexio hook commands from a copied/installed plugin."""
+    for hook_file in ("hooks.json", "codex-hooks.json"):
+        hook_path = plugin_root / "hooks" / hook_file
+        if not hook_path.is_file():
+            continue
+        parsed = json.loads(hook_path.read_text())
+        hooks_by_event = parsed.get("hooks")
+        if not isinstance(hooks_by_event, dict):
+            continue
+        for event in list(hooks_by_event):
+            blocks = []
+            for block in hooks_by_event.get(event) or []:
+                if not isinstance(block, dict):
+                    continue
+                kept_hooks = [
+                    hook
+                    for hook in block.get("hooks") or []
+                    if not _command_is_publish_hook(
+                        hook.get("command") if isinstance(hook, dict) else None
+                    )
+                ]
+                if kept_hooks:
+                    next_block = dict(block)
+                    next_block["hooks"] = kept_hooks
+                    blocks.append(next_block)
+            if blocks:
+                hooks_by_event[event] = blocks
+            else:
+                del hooks_by_event[event]
+        hook_path.write_text(json.dumps(parsed, indent=2) + "\n")
+
+
+def _restore_publish_hooks_from_source(plugin_root: Path) -> None:
+    """Restore full hook manifests before applying the current read-only state."""
+    source_hooks_dir = _PLUGIN_ROOT / "hooks"
+    target_hooks_dir = plugin_root / "hooks"
+    for hook_file in ("hooks.json", "codex-hooks.json"):
+        source_path = source_hooks_dir / hook_file
+        target_path = target_hooks_dir / hook_file
+        if (
+            source_path.is_file()
+            and target_path.is_file()
+            and source_path.resolve() != target_path.resolve()
+        ):
+            shutil.copyfile(source_path, target_path)
+
+
 def _run_codex(args: list[str]) -> subprocess.CompletedProcess[str]:
     """Invoke the ``codex`` CLI with a hard timeout.
 
@@ -795,23 +804,54 @@ 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(args: argparse.Namespace) -> None:
-    api_key = (getattr(args, "api_key", "") or "").strip()
+def _configure_reflexio_setup() -> bool:
+    """Load setup state from ``~/.reflexio/.env`` without writing local defaults.
+
+    Returns:
+        bool: Whether read-only mode is enabled.
+    """
+    env_config.load_reflexio_env(_REFLEXIO_ENV_PATH)
+    try:
+        env_text = _REFLEXIO_ENV_PATH.read_text()
+    except OSError:
+        env_text = ""
+    read_only_value = ""
+    file_api_key = ""
+    file_url = ""
+    for line in env_text.splitlines():
+        parsed = env_config.parse_env_line(line)
+        if parsed is None:
+            continue
+        key, value = parsed
+        if key == env_config.REFLEXIO_API_KEY_ENV:
+            file_api_key = value
+        elif key == env_config.REFLEXIO_URL_ENV:
+            file_url = value
+        elif key == "REFLEXIO_USER_ID":
+            os.environ[key] = value
+        elif key == env_config.CLAUDE_SMART_READ_ONLY_ENV:
+            read_only_value = value
+    api_key = (
+        file_api_key or os.environ.get(env_config.REFLEXIO_API_KEY_ENV, "")
+    ).strip()
+    read_only = read_only_value.strip().lower() in {"1", "true", "yes", "on"}
     if api_key:
         reflexio_url = (
-            getattr(args, "reflexio_url", "") or _MANAGED_REFLEXIO_URL
+            file_url
+            or os.environ.get(env_config.REFLEXIO_URL_ENV, _MANAGED_REFLEXIO_URL)
         ).strip()
-        added = _seed_managed_reflexio_env(api_key=api_key, reflexio_url=reflexio_url)
-        changed = ", ".join(added) if added else "managed Reflexio settings"
+        os.environ[env_config.REFLEXIO_URL_ENV] = reflexio_url
+        os.environ[env_config.REFLEXIO_API_KEY_ENV] = api_key
+        os.environ["CLAUDE_SMART_MANAGED_SETUP"] = "1"
         sys.stdout.write(
-            f"Configured {_REFLEXIO_ENV_PATH} for managed Reflexio "
-            f"({changed}; API key {env_config.mask_secret(api_key)}).\n"
+            f"Using managed Reflexio at {reflexio_url} "
+            f"(API key {env_config.mask_secret(api_key)}).\n"
         )
-        return
-
-    added = _seed_reflexio_env()
-    if added:
-        sys.stdout.write(f"Seeded {_REFLEXIO_ENV_PATH} with {', '.join(added)}.\n")
+    else:
+        os.environ.pop(env_config.REFLEXIO_URL_ENV, None)
+        os.environ.pop(env_config.REFLEXIO_API_KEY_ENV, None)
+        os.environ.pop("CLAUDE_SMART_MANAGED_SETUP", None)
+    return read_only
 
 
 def cmd_install_codex(args: argparse.Namespace) -> int:
@@ -835,7 +875,7 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
             "error: 'uv' not found on PATH. Install uv or restart your shell.\n"
         )
         return 1
-    _configure_reflexio_setup(args)
+    read_only = _configure_reflexio_setup()
 
     missing = _missing_codex_marketplace_files(_REPO_ROOT)
     if missing:
@@ -846,6 +886,8 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
         )
         return 1
     marketplace_root = _prepare_codex_local_marketplace()
+    if read_only:
+        _prune_publish_hooks_for_read_only(marketplace_root / _CODEX_LOCAL_PLUGIN_PATH)
 
     hooks_ok, hooks_msg = _enable_codex_plugin_hooks()
     if hooks_ok:
@@ -869,6 +911,10 @@ def cmd_install_codex(args: argparse.Namespace) -> int:
         )
         if installed:
             sys.stdout.write(f"{install_msg}.\n")
+            if read_only:
+                sys.stdout.write(
+                    "Installed read-only hook manifest; publish interactions hooks are disabled.\n"
+                )
             trusted, trust_msg = _trust_codex_plugin_hooks(Path.cwd())
             if not trusted:
                 # The app-server can race against the just-installed cache.
@@ -936,7 +982,7 @@ def cmd_install(args: argparse.Namespace) -> int:
             "Install Claude Code first: https://claude.com/claude-code\n"
         )
         return 1
-    _configure_reflexio_setup(args)
+    read_only = _configure_reflexio_setup()
 
     for cmd in (
         ["claude", "plugin", "marketplace", "add", args.source],
@@ -957,6 +1003,12 @@ def cmd_install(args: argparse.Namespace) -> int:
             "Fix the issue above, then run /claude-smart:restart or restart Claude Code to retry.\n"
         )
         return 1
+    _restore_publish_hooks_from_source(Path(message))
+    if read_only:
+        _prune_publish_hooks_for_read_only(Path(message))
+        sys.stdout.write(
+            "Installed read-only hook manifest; publish interactions hooks are disabled.\n"
+        )
     sys.stdout.write(f"Prepared claude-smart runtime at {message}.\n")
 
     sys.stdout.write(
@@ -984,6 +1036,7 @@ def cmd_update(args: argparse.Namespace) -> int:
         )
         return 1
 
+    read_only = _configure_reflexio_setup()
     cmd = ["claude", "plugin", "update", _PLUGIN_SPEC]
     try:
         subprocess.run(cmd, check=True)
@@ -992,8 +1045,14 @@ def cmd_update(args: argparse.Namespace) -> int:
         return exc.returncode or 1
 
     sys.stdout.write("\nclaude-smart updated. Restart Claude Code to apply.\n")
-    if getattr(args, "api_key", ""):
-        _configure_reflexio_setup(args)
+    plugin_root = _find_claude_code_plugin_root()
+    if plugin_root is not None:
+        _restore_publish_hooks_from_source(plugin_root)
+        if read_only:
+            _prune_publish_hooks_for_read_only(plugin_root)
+            sys.stdout.write(
+                "Installed read-only hook manifest; publish interactions hooks are disabled.\n"
+            )
     return 0
 
 
@@ -1086,7 +1145,7 @@ def cmd_show(args: argparse.Namespace) -> int:
     Returns:
         int: 0 on success.
     """
-    project_id = args.project or ids.resolve_project_id()
+    project_id = args.project or ids.resolve_user_id()
     adapter = Adapter()
     user_playbooks, agent_playbooks, profiles = adapter.fetch_all(
         project_id=project_id,
@@ -1135,11 +1194,17 @@ def cmd_learn(args: argparse.Namespace) -> int:
         int: 0 on success or no-op (no active session, or nothing to
             publish), 1 if reflexio is unreachable.
     """
+    if env_config.env_truthy(env_config.CLAUDE_SMART_READ_ONLY_ENV):
+        sys.stdout.write(
+            "claude-smart is in read-only mode (CLAUDE_SMART_READ_ONLY=1); "
+            "skipping publish.\n"
+        )
+        return 0
     session_id = args.session or _latest_session_id()
     if not session_id:
         sys.stdout.write("No active claude-smart session buffer found.\n")
         return 0
-    project_id = args.project or ids.resolve_project_id()
+    project_id = args.project or ids.resolve_user_id()
 
     note = (args.note or "").strip()
     if note:
@@ -1769,29 +1834,9 @@ def _build_parser() -> argparse.ArgumentParser:
         default=_DEFAULT_MARKETPLACE_SOURCE,
         help="Marketplace ref — GitHub owner/repo, or a local directory path",
     )
-    inst.add_argument(
-        "--api-key",
-        default="",
-        help="Configure managed Reflexio with this API key instead of local mode",
-    )
-    inst.add_argument(
-        "--reflexio-url",
-        default=_MANAGED_REFLEXIO_URL,
-        help="Managed Reflexio URL used only when --api-key is provided",
-    )
     inst.set_defaults(func=cmd_install)
 
     upd = sub.add_parser("update", help="Update claude-smart to the latest version")
-    upd.add_argument(
-        "--api-key",
-        default="",
-        help="Configure managed Reflexio with this API key after updating",
-    )
-    upd.add_argument(
-        "--reflexio-url",
-        default=_MANAGED_REFLEXIO_URL,
-        help="Managed Reflexio URL used only when --api-key is provided",
-    )
     upd.set_defaults(func=cmd_update)
 
     uni = sub.add_parser("uninstall", help="Remove claude-smart")

package/plugin/src/claude_smart/env_config.py

@@ -9,7 +9,7 @@ REFLEXIO_ENV_PATH = Path.home() / ".reflexio" / ".env"
 MANAGED_REFLEXIO_URL = "https://www.reflexio.ai/"
 REFLEXIO_URL_ENV = "REFLEXIO_URL"
 REFLEXIO_API_KEY_ENV = "REFLEXIO_API_KEY"
-REFLEXIO_USER_ID_ENV = "REFLEXIO_USER_ID"
+CLAUDE_SMART_READ_ONLY_ENV = "CLAUDE_SMART_READ_ONLY"
 
 
 def parse_env_line(line: str) -> tuple[str, str] | None:
@@ -89,6 +89,11 @@ def set_env_vars(path: Path, values: dict[str, str]) -> list[str]:
     return added
 
 
+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"}
+
+
 def mask_secret(value: str) -> str:
     """Return a display-safe API key preview."""
     if not value:

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

@@ -36,7 +36,7 @@ def handle(payload: dict[str, Any]) -> None:
         hook.emit_continue()
         return
 
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
     try:
         emitted = context_inject.emit_context(
             session_id=session_id,

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

@@ -21,7 +21,7 @@ import time
 from pathlib import Path
 from typing import Any
 
-from claude_smart import ids, publish, state
+from claude_smart import env_config, ids, publish, state
 from claude_smart.events.stop import (
     _read_transcript_entries,
     _scan_transcript_for_assistant_text,
@@ -51,13 +51,16 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     session_id = payload.get("session_id")
     if not session_id:
         return None
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
 
     _maybe_synthesize_assistant_anchor(
         session_id=session_id,
         project_id=project_id,
         transcript_path=payload.get("transcript_path"),
     )
+    if env_config.env_truthy(env_config.CLAUDE_SMART_READ_ONLY_ENV):
+        state.mark_all_published(session_id)
+        return ("nothing", 0)
 
     # ``force_extraction=True`` makes the reflexio server run the
     # extractor synchronously for this publish, so by the time the HTTP

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

@@ -9,7 +9,15 @@ import time
 from pathlib import Path
 from typing import Any
 
-from claude_smart import cs_cite, ids, internal_call, publish, runtime, state
+from claude_smart import (
+    cs_cite,
+    env_config,
+    ids,
+    internal_call,
+    publish,
+    runtime,
+    state,
+)
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -354,7 +362,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     # without this placeholder, those tools would be misattributed to the
     # next assistant turn.
     transcript_path = payload.get("transcript_path")
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
 
     entries: list[dict[str, Any]] = []
     if transcript_path:
@@ -362,9 +370,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
         if path.is_file():
             entries = _load_transcript_with_retry(path)
 
-    prompt = payload.get("prompt") or (
-        _scan_transcript_for_user_text(entries) if runtime.is_codex() else ""
-    )
+    prompt = payload.get("prompt") or _scan_transcript_for_user_text(entries)
     if runtime.is_codex() and internal_call.is_codex_internal_prompt(prompt):
         return None
 
@@ -393,13 +399,24 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     plan_decisions = _scan_transcript_for_plan_decisions(entries)
 
     now = int(time.time())
-    for decision_text in plan_decisions:
+    if plan_decisions:
+        for decision_text in plan_decisions:
+            state.append(
+                session_id,
+                {
+                    "ts": now,
+                    "role": "User",
+                    "content": decision_text,
+                    "user_id": project_id,
+                },
+            )
+    elif prompt and not _has_unpublished_user_turn(session_id):
         state.append(
             session_id,
             {
                 "ts": now,
                 "role": "User",
-                "content": decision_text,
+                "content": prompt,
                 "user_id": project_id,
             },
         )
@@ -413,6 +430,9 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
     if cited_items:
         record["cited_items"] = cited_items
     state.append(session_id, record)
+    if env_config.env_truthy(env_config.CLAUDE_SMART_READ_ONLY_ENV):
+        state.mark_all_published(session_id)
+        return ("nothing", 0)
     return publish.publish_unpublished(
         session_id=session_id,
         project_id=project_id,

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

@@ -50,7 +50,7 @@ def handle(payload: dict[str, Any]) -> None:
     if not session_id or not prompt:
         return
 
-    project_id = ids.resolve_project_id(payload.get("cwd"))
+    project_id = ids.resolve_user_id(payload.get("cwd"))
     state.append(
         session_id,
         {

package/plugin/src/claude_smart/hook.py

@@ -24,7 +24,7 @@ from contextlib import redirect_stdout
 from io import StringIO
 from typing import Any
 
-from claude_smart import hook_log, ids, runtime
+from claude_smart import env_config, hook_log, ids, runtime
 from claude_smart.internal_call import is_internal_invocation
 
 _LOGGER = logging.getLogger(__name__)
@@ -68,7 +68,26 @@ def _read_stdin_json() -> dict[str, Any]:
     except json.JSONDecodeError as exc:
         _LOGGER.debug("stdin JSON decode failed: %s", exc)
         return {}
-    return parsed if isinstance(parsed, dict) else {}
+    return _normalize_payload_keys(parsed) if isinstance(parsed, dict) else {}
+
+
+def _normalize_payload_keys(payload: dict[str, Any]) -> dict[str, Any]:
+    """Accept both classic Claude Code and Desktop/Cowork hook key shapes."""
+    aliases = {
+        "sessionId": "session_id",
+        "transcriptPath": "transcript_path",
+        "toolName": "tool_name",
+        "toolInput": "tool_input",
+        "toolResponse": "tool_response",
+        "lastAssistantMessage": "last_assistant_message",
+        "workingDirectory": "cwd",
+        "currentWorkingDirectory": "cwd",
+    }
+    normalized = dict(payload)
+    for source, target in aliases.items():
+        if target not in normalized and source in normalized:
+            normalized[target] = normalized[source]
+    return normalized
 
 
 def emit_continue() -> None:
@@ -94,6 +113,7 @@ def main(argv: list[str] | None = None) -> int:
     argv = argv if argv is not None else sys.argv[1:]
     host, event = _parse_args(argv)
     runtime.set_host(host)
+    env_config.load_reflexio_env()
     if not event:
         _LOGGER.warning("hook dispatcher called with no event name")
         emit_continue()

package/plugin/src/claude_smart/hook_log.py

@@ -163,8 +163,8 @@ def log_path() -> Path:
 
     Resolution order:
 
-    1. ``CLAUDE_SMART_HOOK_LOG`` env var — escape hatch for tests and
-       advanced users who want the log elsewhere.
+    1. ``CLAUDE_SMART_HOOK_LOG`` env var — boolean-like values enable the
+       default log, while path-like values redirect it.
     2. ``_LOG_PATH`` module attribute — what monkeypatched tests override.
     3. ``~/.claude-smart/hook.log`` — the default.
 
@@ -173,6 +173,11 @@ def log_path() -> Path:
     """
     override = os.environ.get("CLAUDE_SMART_HOOK_LOG")
     if override:
+        override = override.strip()
+        if not override:
+            return _LOG_PATH
+        if override.lower() in {"1", "true", "yes", "on"}:
+            return _LOG_PATH
         return Path(override)
     return _LOG_PATH
 

package/plugin/src/claude_smart/ids.py

@@ -19,21 +19,20 @@ from __future__ import annotations
 import logging
 import os
 import subprocess  # noqa: S404 — git invocation with a fixed flag set.
-import uuid
 from pathlib import Path
 
 from claude_smart import env_config
 
 _LOGGER = logging.getLogger(__name__)
 
+_USER_ID_OVERRIDE_ENV = "REFLEXIO_USER_ID"
+
 
 def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     """Return a stable project identifier for the given working directory.
 
-    Managed Reflexio installs are user-scoped instead of project-scoped:
-    when ``REFLEXIO_API_KEY`` is configured, the persisted
-    ``REFLEXIO_USER_ID`` UUID is returned. Local installs without an API key
-    keep using the git/project name.
+    Local and managed/API-key installs both use the git/project name as
+    Reflexio's ``user_id``.
 
     Prefers the basename of the git toplevel (so worktrees, submodules, and
     `cd src/` all still map to the same project). Falls back to the cwd
@@ -45,10 +44,6 @@ def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     Returns:
         str: A non-empty identifier. Never raises.
     """
-    managed_user_id = _managed_user_id()
-    if managed_user_id:
-        return managed_user_id
-
     base = Path(cwd) if cwd is not None else Path.cwd()
     try:
         result = subprocess.run(  # noqa: S603, S607 — fixed argv, cwd is a Path.
@@ -68,21 +63,23 @@ def resolve_project_id(cwd: str | os.PathLike[str] | None = None) -> str:
     return base.name or "unknown-project"
 
 
-def _managed_user_id() -> str:
-    env_config.load_reflexio_env()
-    if not os.environ.get(env_config.REFLEXIO_API_KEY_ENV):
-        return ""
-    user_id = os.environ.get(env_config.REFLEXIO_USER_ID_ENV, "").strip()
-    if user_id:
-        return user_id
+def resolve_user_id(cwd: str | os.PathLike[str] | None = None) -> str:
+    """Return the Reflexio ``user_id`` for the given working directory.
 
-    user_id = str(uuid.uuid4())
-    try:
-        env_config.set_env_vars(
-            env_config.REFLEXIO_ENV_PATH,
-            {env_config.REFLEXIO_USER_ID_ENV: user_id},
-        )
-    except OSError as exc:
-        _LOGGER.debug("could not persist managed Reflexio user id: %s", exc)
-    os.environ[env_config.REFLEXIO_USER_ID_ENV] = user_id
-    return user_id
+    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
+    CLI commands and hooks use the same identity resolution.
+
+    Args:
+        cwd: Working directory to resolve when falling back to the project id.
+
+    Returns:
+        str: The override value if set and non-empty, else the project id.
+    """
+    env_config.load_reflexio_env()
+    override = os.environ.get(_USER_ID_OVERRIDE_ENV, "").strip()
+    if override:
+        return override
+    return resolve_project_id(cwd)

package/plugin/src/claude_smart/internal_call.py

@@ -19,10 +19,10 @@ Two distinct sources of unwanted hook fires:
    tool..."`` into reflexio as a fake user interaction.
 
 Detection signals, OR'd:
-  - ``CLAUDE_CODE_ENTRYPOINT`` is anything other than ``"cli"`` —
-    the interactive REPL sets ``cli``; headless ``claude -p`` sets
-    ``sdk-cli`` (and the SDKs may set other values). This catches
-    case (2) for any third-party tool, not just claude-mem.
+  - ``CLAUDE_CODE_ENTRYPOINT`` is anything other than an interactive entrypoint
+    (``"cli"`` or Claude Desktop's ``"claude-desktop"``). Headless
+    ``claude -p`` sets ``sdk-cli`` (and the SDKs may set other values). This
+    catches case (2) for any third-party tool, not just claude-mem.
   - Env var ``CLAUDE_SMART_INTERNAL=1``, set by reflexio's provider
     before spawning ``claude``. Belt-and-suspenders for case (1) in
     case the entrypoint check ever misses a future SDK variant.
@@ -46,7 +46,7 @@ from typing import Any
 from claude_smart import runtime
 
 _ENTRYPOINT_VAR = "CLAUDE_CODE_ENTRYPOINT"
-_INTERACTIVE_ENTRYPOINT = "cli"
+_INTERACTIVE_ENTRYPOINTS = frozenset({"cli", "claude-desktop"})
 _CODEX_TITLE_PROMPT_PREFIX = (
     "You are a helpful assistant. You will be presented with a user prompt, "
     "and your job is to provide a short title for a task"
@@ -92,7 +92,7 @@ def is_internal_invocation(payload: dict[str, Any]) -> bool:
     if runtime.is_internal_invocation_env():
         return True
     entrypoint = os.environ.get(_ENTRYPOINT_VAR)
-    if entrypoint and entrypoint != _INTERACTIVE_ENTRYPOINT:
+    if entrypoint and entrypoint not in _INTERACTIVE_ENTRYPOINTS:
         return True
     if runtime.is_codex() and is_codex_internal_prompt(payload.get("prompt")):
         return True

package/plugin/src/claude_smart/publish.py

@@ -29,11 +29,10 @@ def publish_unpublished(
 
     Args:
         session_id (str): Claude Code session id, attached to each interaction.
-        project_id (str): Stable user-scope id resolved by ``ids``. Local mode
-            uses the project name; managed/API-key mode uses the persisted
-            ``REFLEXIO_USER_ID`` UUID. ``agent_version`` is hardcoded to
-            ``"claude-code"`` in the adapter so skills roll up
-            globally per agent rather than per project.
+        project_id (str): Stable user-scope id resolved by ``ids`` from the
+            project name. ``agent_version`` is hardcoded to ``"claude-code"``
+            in the adapter so skills roll up globally per agent rather than
+            per project.
         force_extraction (bool): Whether to ask reflexio to run extraction
             synchronously instead of queuing for the next sweep.
         override_learning_stall (bool): Whether to bypass a recorded