claude-smart 0.2.48 → 0.2.50

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

@@ -6,7 +6,7 @@ import re
 import time
 from typing import Any
 
-from claude_smart import state
+from claude_smart import runtime, state
 
 # Tool inputs are persisted locally and later published to reflexio, so we
 # apply a conservative redaction pass at ingestion time. Chosen to avoid
@@ -144,5 +144,6 @@ def handle(payload: dict[str, Any]) -> None:
         "tool_input": _redact(payload.get("tool_input") or {}),
         "tool_output": _redact_string(output_text) if output_text else "",
         "status": _derive_status(tool_response),
+        "host": runtime.attribution_host(),
     }
     state.append(session_id, record)

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 env_config, ids, publish, state
+from claude_smart import env_config, ids, publish, runtime, state
 from claude_smart.events.stop import (
     _read_transcript_entries,
     _scan_transcript_for_assistant_text,
@@ -119,6 +119,7 @@ def _maybe_synthesize_assistant_anchor(
             "content": assistant_text,
             "user_id": project_id,
             "synthesised_by": "session_end_anchor",
+            "host": runtime.attribution_host(),
         },
     )
     _LOGGER.info(

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

@@ -408,6 +408,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
                     "role": "User",
                     "content": decision_text,
                     "user_id": project_id,
+                    "host": runtime.attribution_host(),
                 },
             )
     elif prompt and not _has_unpublished_user_turn(session_id):
@@ -418,6 +419,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
                 "role": "User",
                 "content": prompt,
                 "user_id": project_id,
+                "host": runtime.attribution_host(),
             },
         )
 
@@ -426,6 +428,7 @@ def handle(payload: dict[str, Any]) -> tuple[publish.PublishStatus, int] | None:
         "role": "Assistant",
         "content": assistant_text,
         "user_id": project_id,
+        "host": runtime.attribution_host(),
     }
     if cited_items:
         record["cited_items"] = cited_items

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

@@ -28,7 +28,7 @@ import logging
 import time
 from typing import Any
 
-from claude_smart import context_inject, ids, state
+from claude_smart import context_inject, ids, runtime, state
 
 _LOGGER = logging.getLogger(__name__)
 _TOP_K = 3
@@ -58,6 +58,7 @@ def handle(payload: dict[str, Any]) -> None:
             "role": "User",
             "content": prompt,
             "user_id": project_id,
+            "host": runtime.attribution_host(),
         },
     )
 

package/plugin/src/claude_smart/internal_call.py

@@ -20,7 +20,8 @@ Two distinct sources of unwanted hook fires:
 
 Detection signals, OR'd:
   - ``CLAUDE_CODE_ENTRYPOINT`` is anything other than an interactive entrypoint
-    (``"cli"`` or Claude Desktop's ``"claude-desktop"``). Headless
+    (``"cli"``, Claude Desktop's ``"claude-desktop"``, or Claude Code IDE
+    entrypoints such as ``"claude-vscode"``/``"claude-jetbrains"``). 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
@@ -46,7 +47,9 @@ from typing import Any
 from claude_smart import runtime
 
 _ENTRYPOINT_VAR = "CLAUDE_CODE_ENTRYPOINT"
-_INTERACTIVE_ENTRYPOINTS = frozenset({"cli", "claude-desktop"})
+_INTERACTIVE_ENTRYPOINTS = frozenset(
+    {"cli", "claude-desktop", "claude-vscode", "claude-jetbrains"}
+)
 _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"

package/plugin/src/claude_smart/optimizer_assistant.py

@@ -4,6 +4,13 @@ Reflexio's ``LocalScriptAssistant`` sends one JSON payload on stdin and expects
 one JSON object on stdout. This module bridges that protocol to a guarded
 local CLI subprocess so candidate playbooks can be evaluated against the active
 host without re-entering claude-smart/reflexio hooks.
+
+Host CLI resolution: when ``CLAUDE_SMART_CLI_PATH`` is set in the environment
+(``backend-service.sh`` writes it for ``opencode`` and ``codex`` hosts so
+generation routes through the host-specific compatibility bridge instead of
+the real Claude CLI), this script honours that override. Falling back to
+``shutil.which("claude")`` preserves the legacy Claude Code host behaviour
+where no override is configured.
 """
 
 from __future__ import annotations
@@ -22,6 +29,20 @@ from claude_smart import internal_call, runtime
 _CLI_TIMEOUT_SECONDS = 300
 _READ_ONLY_TOOLS = "Read,Grep,Glob,LS"
 _MUTATING_TOOLS = "Bash,Edit,Write,MultiEdit,NotebookEdit"
+# Mirrors ``reflexio.server.llm.providers.claude_code_provider._ENV_CLI_PATH``
+# so backend-service.sh can route both the reflexio Claude CLI provider and
+# this assistant script through the same host-specific bridge.
+_ENV_CLI_PATH = "CLAUDE_SMART_CLI_PATH"
+_CLAUDE_SMART_COMPAT_BRIDGE_NAMES = frozenset(
+    {
+        "codex-claude-compat",
+        "codex-claude-compat.cmd",
+        "codex-claude-compat.js",
+        "opencode-claude-compat",
+        "opencode-claude-compat.cmd",
+        "opencode-claude-compat.js",
+    }
+)
 
 
 class OptimizerAssistantError(Exception):
@@ -142,26 +163,51 @@ def _run_local_cli(*, prompt: str, system_prompt: str) -> str:
     return _run_claude(prompt=prompt, system_prompt=system_prompt)
 
 
+def _resolve_claude_cli_path() -> str:
+    """Return the host CLI to invoke for evaluation rollouts.
+
+    When ``CLAUDE_SMART_CLI_PATH`` is set, prefer it so backend-service.sh can
+    route the assistant through the same bridge it uses for the reflexio
+    ``claude-code`` provider (e.g. ``opencode-claude-compat`` for the OpenCode
+    host). Falls back to ``shutil.which("claude")`` so Claude Code hosts — and
+    any environment that never set the override — continue to use the real
+    ``claude`` CLI.
+    """
+    override = os.environ.get(_ENV_CLI_PATH)
+    if override:
+        return override
+    return shutil.which("claude") or "claude"
+
+
+def _is_claude_smart_compat_bridge(cli_path: str) -> bool:
+    return Path(cli_path).name.lower() in _CLAUDE_SMART_COMPAT_BRIDGE_NAMES
+
+
 def _run_claude(*, prompt: str, system_prompt: str) -> str:
-    cli_path = shutil.which("claude") or "claude"
-    # This is an evaluation rollout, not a real user session: allow local
-    # inspection, but prevent filesystem, shell, MCP, and session mutations.
+    cli_path = _resolve_claude_cli_path()
     cmd = [
         cli_path,
         "-p",
         "--output-format",
         "json",
-        "--permission-mode",
-        "plan",
-        "--tools",
-        _READ_ONLY_TOOLS,
-        "--disallowedTools",
-        _MUTATING_TOOLS,
-        "--no-session-persistence",
-        "--mcp-config",
-        '{"mcpServers": {}}',
-        "--strict-mcp-config",
     ]
+    if not _is_claude_smart_compat_bridge(cli_path):
+        # This is an evaluation rollout, not a real user session: allow local
+        # inspection, but prevent filesystem, shell, MCP, and session mutations.
+        cmd.extend(
+            [
+                "--permission-mode",
+                "plan",
+                "--tools",
+                _READ_ONLY_TOOLS,
+                "--disallowedTools",
+                _MUTATING_TOOLS,
+                "--no-session-persistence",
+                "--mcp-config",
+                '{"mcpServers": {}}',
+                "--strict-mcp-config",
+            ]
+        )
     if system_prompt:
         cmd.extend(["--append-system-prompt", system_prompt])
 

package/plugin/src/claude_smart/publish.py

@@ -8,7 +8,8 @@ messaging without peeking at the adapter.
 
 from __future__ import annotations
 
-from typing import Literal
+import uuid
+from typing import Any, Literal
 
 from claude_smart import state
 from claude_smart.reflexio_adapter import Adapter
@@ -16,6 +17,50 @@ from claude_smart.reflexio_adapter import Adapter
 PublishStatus = Literal["nothing", "ok", "failed"]
 
 
+def _publish_request_id(session_id: str, start: int, end: int) -> str:
+    """Return a stable request ID for one buffered publish range."""
+
+    name = f"claude-smart:{session_id}:{start}:{end}"
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, name))
+
+
+def _prepare_publish_batch(
+    session_id: str,
+) -> tuple[int, int, list[dict[str, Any]]] | None:
+    """Freeze and return one canonical unpublished record range."""
+
+    while True:
+        records = state.read_all(session_id)
+        published, available = state.unpublished_slice(records)
+        if not available:
+            return None
+
+        publish_end = state.pending_publish_end(records, published)
+        if publish_end is None:
+            publish_end = state.safe_publish_end(records, published)
+            _, proposed = state.unpublished_slice(
+                records[:publish_end], published_override=published
+            )
+            if not proposed:
+                return None
+            state.append(
+                session_id,
+                {"publish_attempt": {"start": published, "end": publish_end}},
+            )
+
+        canonical = state.read_all(session_id)
+        if state.published_record_offset(canonical) != published:
+            continue
+        canonical_end = state.pending_publish_end(canonical, published)
+        if canonical_end is None:
+            continue
+        _, interactions = state.unpublished_slice(
+            canonical[:canonical_end], published_override=published
+        )
+        if interactions:
+            return published, canonical_end, interactions
+
+
 def publish_unpublished(
     *,
     session_id: str,
@@ -56,20 +101,27 @@ def publish_unpublished(
             was unreachable. On ``"failed"`` the watermark is not advanced,
             so the next hook retries the same batch.
     """
-    records = state.read_all(session_id)
-    _, interactions = state.unpublished_slice(records)
-    if not interactions:
+    batch = _prepare_publish_batch(session_id)
+    if batch is None:
         return ("nothing", 0)
+    published_record_offset, publish_end, interactions = batch
+
     client = adapter if adapter is not None else Adapter()
-    ok = client.publish(
+    request_id = _publish_request_id(session_id, published_record_offset, publish_end)
+    result = client.publish(
         session_id=session_id,
         project_id=project_id,
+        request_id=request_id,
         interactions=interactions,
         force_extraction=force_extraction,
         override_learning_stall=override_learning_stall,
         skip_aggregation=skip_aggregation,
     )
-    if ok:
-        state.append(session_id, {"published_up_to": len(records)})
+    if result:
+        marker: dict[str, Any] = {"published_up_to": publish_end}
+        confirmed_request_id = result.request_id
+        if isinstance(confirmed_request_id, str) and confirmed_request_id:
+            marker["request_id"] = confirmed_request_id
+        state.append(session_id, marker)
         return ("ok", len(interactions))
     return ("failed", len(interactions))

package/plugin/src/claude_smart/reflexio_adapter.py

@@ -20,7 +20,6 @@ _LOGGER = logging.getLogger(__name__)
 
 _ENV_URL = "REFLEXIO_URL"
 _ENV_API_KEY = "REFLEXIO_API_KEY"
-_DEFAULT_URL = "http://localhost:8071/"
 # Cap every HTTP round-trip from a hook so a hung backend can't stall the
 # Claude Code / Codex session. reflexio's client default is 300s, which is
 # fine for batch workloads but unacceptable on the hook path — a single
@@ -28,18 +27,48 @@ _DEFAULT_URL = "http://localhost:8071/"
 # in ``ids.py`` for short-lived hook HTTP calls.
 _HTTP_TIMEOUT_SECONDS = 5
 _SEARCH_MODE_HYBRID = "hybrid"  # reflexio.models.config_schema.SearchMode.HYBRID
+_SOURCE = "claude-smart"
 _UNIFIED_ENTITY_TYPES = ("profiles", "user_playbooks", "agent_playbooks")
 _AGENT_PLAYBOOK_APPROVAL_STATUSES = ("pending", "approved")
 _REJECTED_AGENT_PLAYBOOK_STATUS = "rejected"
+_LOCAL_8071_URLS = {
+    "http://localhost:8071",
+    "http://localhost:8071/",
+    "http://127.0.0.1:8071",
+    "http://127.0.0.1:8071/",
+}
+
+
+def _default_url() -> str:
+    return f"http://localhost:{os.environ.get('BACKEND_PORT', '8071')}/"
+
+
+def _configured_url() -> str:
+    url = os.environ.get(_ENV_URL, "")
+    backend_port = os.environ.get("BACKEND_PORT", "")
+    if url in _LOCAL_8071_URLS and backend_port not in {"", "8071"}:
+        return _default_url()
+    return url or _default_url()
+
+
+@dataclass(frozen=True)
+class PublishResult:
+    """Outcome and server-confirmed lineage for one publish call."""
+
+    ok: bool
+    request_id: str | None = None
+
+    def __bool__(self) -> bool:
+        return self.ok
 
 
 @dataclass
 class Adapter:
     """Wraps the reflexio client and absorbs connection errors.
 
-    All methods degrade to a neutral no-op return (empty list / False) on
-    connection failure so a missing or down reflexio server never crashes
-    a Claude Code hook.
+    All methods degrade to a neutral no-op result (an empty list or a falsey
+    result) on connection failure so a missing or down reflexio server never
+    crashes a host hook.
     """
 
     url: str = ""
@@ -48,7 +77,7 @@ class Adapter:
 
     def __post_init__(self) -> None:
         env_config.load_reflexio_env()
-        self.url = self.url or os.environ.get(_ENV_URL, _DEFAULT_URL)
+        self.url = self.url or _configured_url()
         self.api_key = self.api_key or os.environ.get(_ENV_API_KEY, "")
         self._client: Any | None = None
 
@@ -92,38 +121,96 @@ class Adapter:
         *,
         session_id: str,
         project_id: str,
+        request_id: str | None = None,
         interactions: Sequence[dict[str, Any]],
         force_extraction: bool = False,
         override_learning_stall: bool = False,
         skip_aggregation: bool = False,
-    ) -> bool:
-        """Publish buffered interactions to reflexio. Returns True on success."""
+    ) -> PublishResult:
+        """Publish interactions and return this call's confirmed request ID."""
         if not interactions:
-            return True
+            return PublishResult(True)
         client = self._get_client()
         if client is None:
-            return False
+            return PublishResult(False)
         try:
+            interaction_list = list(interactions)
+            raw_request = getattr(client, "_make_request", None)
+            supports_source = _supports_keyword(client.publish_interaction, "source")
+            if request_id is not None and callable(raw_request):
+                payload: dict[str, Any] = {
+                    "request_id": request_id,
+                    "user_id": project_id,
+                    "interaction_data_list": interaction_list,
+                    "agent_version": runtime.agent_version(),
+                    "session_id": session_id,
+                    "skip_aggregation": skip_aggregation,
+                    "force_extraction": force_extraction,
+                    "evaluation_only": False,
+                    "override_learning_stall": override_learning_stall,
+                }
+                if supports_source:
+                    payload["source"] = _SOURCE
+                try:
+                    raw_request(
+                        "POST",
+                        "/api/publish_interaction",
+                        json=payload,
+                        params=None,
+                    )
+                    return PublishResult(True, request_id)
+                except Exception as exc:  # noqa: BLE001
+                    if not _needs_raw_retrieved_learning_publish(interaction_list):
+                        raise
+                    _LOGGER.warning(
+                        "Could not confirm retrieved-learning links; retrying "
+                        "the base interaction with the same request ID: %s",
+                        exc,
+                    )
+                    fallback_payload = {
+                        **payload,
+                        "interaction_data_list": _without_retrieved_learnings(
+                            interaction_list
+                        ),
+                    }
+                    raw_request(
+                        "POST",
+                        "/api/publish_interaction",
+                        json=fallback_payload,
+                        params=None,
+                    )
+                    return PublishResult(True, request_id)
+            if _needs_raw_retrieved_learning_publish(interaction_list):
+                _LOGGER.warning(
+                    "Stable raw publishing is unavailable; publishing "
+                    "without optional retrieved-learning links"
+                )
+                interaction_list = _without_retrieved_learnings(interaction_list)
             kwargs = {
                 "user_id": project_id,
-                "interactions": list(interactions),
+                "interactions": interaction_list,
                 "agent_version": runtime.agent_version(),
                 "session_id": session_id,
                 "wait_for_response": False,
                 "force_extraction": force_extraction,
                 "skip_aggregation": skip_aggregation,
             }
+            if supports_source:
+                kwargs["source"] = _SOURCE
             if _supports_keyword(client.publish_interaction, "override_learning_stall"):
                 kwargs["override_learning_stall"] = override_learning_stall
             elif override_learning_stall:
                 _LOGGER.debug(
                     "publish_interaction client does not support override_learning_stall"
                 )
-            client.publish_interaction(**kwargs)
-            return True
+            response = client.publish_interaction(**kwargs)
+            response_request_id = getattr(response, "request_id", None)
+            if isinstance(response_request_id, str) and response_request_id:
+                return PublishResult(True, response_request_id)
+            return PublishResult(True)
         except Exception as exc:  # noqa: BLE001
             _LOGGER.warning("publish_interaction failed: %s", exc)
-            return False
+            return PublishResult(False)
 
     def apply_extraction_defaults(self, *, window_size: int, stride_size: int) -> bool:
         """Push claude-smart's preferred extraction defaults to the reflexio server.
@@ -340,7 +427,12 @@ class Adapter:
     # -----------------------------------------------------------------
 
     def search_all(
-        self, *, project_id: str, query: str, top_k: int = 5
+        self,
+        *,
+        project_id: str,
+        query: str,
+        top_k: int = 5,
+        session_id: str | None = None,
     ) -> tuple[list[Any], list[Any], list[Any]]:
         """Unified hybrid search → ``(user_playbooks, agent_playbooks, preferences)``.
 
@@ -354,6 +446,10 @@ class Adapter:
             project_id (str): reflexio ``user_id`` for this repo.
             query (str): Free-text query routed through BM25 + vector RRF.
             top_k (int): Cap on results per entity type.
+            session_id (str | None): Claude Code session id. When set, the
+                server skips results it already returned to this session
+                and backfills next-best matches, so repeated hook searches
+                within one session stop re-injecting the same rules.
 
         Returns:
             tuple[list[Any], list[Any], list[Any]]: ``(user_playbooks,
@@ -374,6 +470,7 @@ class Adapter:
                 enable_agent_answer=False,
                 top_k=top_k,
                 search_mode=_SEARCH_MODE_HYBRID,
+                session_id=session_id,
             )
         except Exception as exc:  # noqa: BLE001
             self._record_read_error("unified search", exc)
@@ -449,6 +546,32 @@ def _supports_keyword(callable_obj: Any, keyword: str) -> bool:
     return keyword in signature.parameters
 
 
+def _needs_raw_retrieved_learning_publish(
+    interactions: Sequence[dict[str, Any]],
+) -> bool:
+    """Return whether links require a caller-stable raw request.
+
+    The public client does not accept a caller-supplied request ID, and older
+    clients also strip this field. The authenticated helper preserves both.
+    """
+    return any(item.get("retrieved_learnings") for item in interactions)
+
+
+def _without_retrieved_learnings(
+    interactions: Sequence[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Copy interactions without the optional compatibility-only field."""
+
+    return [
+        {
+            key: value
+            for key, value in interaction.items()
+            if key != "retrieved_learnings"
+        }
+        for interaction in interactions
+    ]
+
+
 def _filter_rejected_agent_playbooks(items: list[Any]) -> list[Any]:
     """Drop rejected shared skills defensively, even if an older backend ignores filters."""
     return [

package/plugin/src/claude_smart/runtime.py

@@ -15,27 +15,36 @@ INTERNAL_ENV = "CLAUDE_SMART_INTERNAL"
 HOST_CLAUDE_CODE = "claude-code"
 HOST_CODEX = "codex"
 HOST_OPENCODE = "opencode"
+HOST_UNKNOWN = "unknown"
 VALID_HOSTS = frozenset({HOST_CLAUDE_CODE, HOST_CODEX, HOST_OPENCODE})
 
 _SHARED_AGENT_VERSION = "claude-code"
 _current_host: str | None = None
 
 
+def _resolve_host(value: str | None, fallback: str) -> str:
+    return value if value in VALID_HOSTS else fallback
+
+
 def set_host(value: str | None) -> str:
     """Set the current host, returning the normalized value."""
     global _current_host
-    host = value if value in VALID_HOSTS else HOST_CLAUDE_CODE
-    _current_host = host
+    _current_host = value if value is not None else HOST_UNKNOWN
+    host = _resolve_host(_current_host, HOST_CLAUDE_CODE)
     os.environ[HOST_ENV] = host
     return host
 
 
 def host() -> str:
     """Return the current host, defaulting to Claude Code for compatibility."""
-    if _current_host is not None:
-        return _current_host
-    value = os.environ.get(HOST_ENV)
-    return value if value in VALID_HOSTS else HOST_CLAUDE_CODE
+    value = _current_host if _current_host is not None else os.environ.get(HOST_ENV)
+    return _resolve_host(value, HOST_CLAUDE_CODE)
+
+
+def attribution_host() -> str:
+    """Return the explicitly selected record host, or unknown when unset."""
+    value = _current_host if _current_host is not None else os.environ.get(HOST_ENV)
+    return _resolve_host(value, HOST_UNKNOWN)
 
 
 def is_codex() -> bool: