claude-smart 0.2.48 → 0.2.50

package/plugin/src/claude_smart/state.py

@@ -7,8 +7,13 @@ Each Claude Code session gets one file at
 - ``{"role": "Assistant", ...}`` — a finalized assistant turn
 - ``{"role": "Assistant_tool", ...}`` — a single tool invocation, attached
   to the next assistant turn at ``Stop`` time
-- ``{"published_up_to": N}`` — high-water mark so Stop / SessionEnd don't
-  re-publish rows already sent to reflexio
+- ``{"published_up_to": N, "request_id": "..."}`` — high-water mark so Stop /
+  SessionEnd don't re-publish rows already sent to reflexio; a confirmed
+  request ID preserves local learning lineage for the dashboard when available
+- ``{"retrieved_learning_refs": [...]}`` — identity pairs shown to the agent,
+  attached by event order to the next Assistant turn
+- ``{"publish_attempt": {"start": N, "end": M}}`` — frozen retry boundary for
+  one in-flight publish
 
 The buffer exists for offline resilience: when reflexio is unreachable,
 Stop appends without publishing and the next successful hook drains.
@@ -19,8 +24,9 @@ from __future__ import annotations
 import json
 import logging
 import os
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Any, Iterable
+from typing import Any
 
 try:
     import fcntl  # POSIX only — Windows hooks fall back to append-without-lock.
@@ -34,7 +40,12 @@ _DEFAULT_STATE_DIR = Path.home() / ".claude-smart" / "sessions"
 
 _TOOL_DATA_FIELD_MAX_LEN = 256
 
-_VALID_CITATION_KINDS = frozenset({"playbook", "profile"})
+_VALID_CITATION_KINDS = frozenset(
+    {"playbook", "profile", "user_playbook", "agent_playbook"}
+)
+_VALID_RETRIEVED_PLAYBOOK_KINDS = frozenset({"user_playbook", "agent_playbook"})
+_VALID_RETRIEVED_KINDS = _VALID_RETRIEVED_PLAYBOOK_KINDS | {"profile"}
+_RETRIEVED_LEARNINGS_PUBLISH_CAP = 1000
 
 
 def _truncate_tool_data_field(value: Any) -> Any:
@@ -81,17 +92,37 @@ def injected_path(session_id: str) -> Path:
     return state_dir() / f"{session_id}.injected.jsonl"
 
 
+def _normalize_registry_ref(entry: dict[str, Any]) -> dict[str, str] | None:
+    """Return the identity pair carried by one citation-registry entry."""
+
+    learning_id = entry.get("real_id")
+    kind = entry.get("kind")
+    if not isinstance(learning_id, str) or not learning_id:
+        return None
+    if kind == "profile":
+        wire_kind = "profile"
+    elif (
+        kind == "playbook"
+        and entry.get("source_kind") in _VALID_RETRIEVED_PLAYBOOK_KINDS
+    ):
+        wire_kind = entry["source_kind"]
+    else:
+        return None
+    return {"kind": wire_kind, "learning_id": learning_id}
+
+
 def append_injected(session_id: str, entries: Iterable[dict[str, Any]]) -> None:
-    """Append citation-registry entries to the per-session injected-items file.
+    """Record injected items for citations and the next Assistant publish.
 
-    Each entry maps a short ``id`` (4-hex-char) back to the skill or
-    preference it came from so the Stop hook can resolve citation ids into
-    human-readable titles for the dashboard.
-    Silently no-ops when ``entries`` is empty.
+    The citation sidecar keeps the display metadata used by Stop. The ordered
+    session event stores identity pairs only, so publishing never has to join
+    two files or infer event order from timestamps.
     """
+
     records = list(entries)
     if not records:
         return
+
     path = injected_path(session_id)
     path.parent.mkdir(parents=True, exist_ok=True)
     with path.open("a", encoding="utf-8") as fh:
@@ -100,8 +131,22 @@ def append_injected(session_id: str, entries: Iterable[dict[str, Any]]) -> None:
                 fcntl.flock(fh.fileno(), fcntl.LOCK_EX)
             except OSError as exc:
                 _LOGGER.debug("flock failed on %s: %s", path, exc)
-        for rec in records:
-            fh.write(json.dumps(rec, ensure_ascii=False) + "\n")
+        for record in records:
+            fh.write(json.dumps(record, ensure_ascii=False) + "\n")
+
+    refs: list[dict[str, str]] = []
+    seen: set[tuple[str, str]] = set()
+    for record in records:
+        ref = _normalize_registry_ref(record)
+        if ref is None:
+            continue
+        key = (ref["kind"], ref["learning_id"])
+        if key in seen:
+            continue
+        seen.add(key)
+        refs.append(ref)
+    if refs:
+        append(session_id, {"retrieved_learning_refs": refs})
 
 
 def read_injected(session_id: str) -> dict[str, dict[str, Any]]:
@@ -111,6 +156,7 @@ def read_injected(session_id: str) -> dict[str, dict[str, Any]]:
     (identical content produces the same hash-derived id, so the extra
     record only refreshes metadata).
     """
+
     path = injected_path(session_id)
     if not path.exists():
         return {}
@@ -206,13 +252,18 @@ def _to_wire_citations(cited_items: Any) -> list[dict[str, str]]:
         kind = item.get("kind")
         if not isinstance(real_id, str) or not real_id:
             continue
-        if kind not in _VALID_CITATION_KINDS:
+        wire_kind = kind
+        if kind == "playbook":
+            source_kind = item.get("source_kind")
+            if source_kind in {"user_playbook", "agent_playbook"}:
+                wire_kind = source_kind
+        if wire_kind not in _VALID_CITATION_KINDS:
             continue
         tag = item.get("id")
         title = item.get("title")
         out.append(
             {
-                "kind": kind,
+                "kind": wire_kind,
                 "real_id": real_id,
                 "tag": tag if isinstance(tag, str) else "",
                 "title": title if isinstance(title, str) else "",
@@ -221,44 +272,127 @@ def _to_wire_citations(cited_items: Any) -> list[dict[str, str]]:
     return out
 
 
+def published_record_offset(records: list[dict[str, Any]]) -> int:
+    """Return the highest valid publish watermark in the session buffer."""
+
+    limit = len(records)
+    return max(
+        (
+            value
+            for record in records
+            if isinstance((value := record.get("published_up_to")), int)
+            and 0 <= value <= limit
+        ),
+        default=0,
+    )
+
+
+def pending_publish_end(
+    records: list[dict[str, Any]], published: int
+) -> int | None:
+    """Return the frozen end of the current publish attempt, if any."""
+
+    for marker_index, record in enumerate(records[published:], start=published):
+        attempt = record.get("publish_attempt")
+        if not isinstance(attempt, dict):
+            continue
+        start = attempt.get("start")
+        end = attempt.get("end")
+        if (
+            start == published
+            and isinstance(end, int)
+            and published < end <= marker_index
+        ):
+            _, interactions = unpublished_slice(
+                records[:end], published_override=published
+            )
+            if interactions:
+                return end
+    return None
+
+
+def _wire_retrieved_ref(value: Any) -> dict[str, str] | None:
+    """Validate one identity pair read from the ordered session buffer."""
+
+    if not isinstance(value, dict):
+        return None
+    kind = value.get("kind")
+    learning_id = value.get("learning_id")
+    if kind not in _VALID_RETRIEVED_KINDS:
+        return None
+    if not isinstance(learning_id, str) or not learning_id:
+        return None
+    return {"kind": kind, "learning_id": learning_id}
+
+
+def safe_publish_end(records: list[dict[str, Any]], published: int) -> int:
+    """Stop before identity refs that do not yet have an Assistant target."""
+
+    unmatched_start: int | None = None
+    for index, record in enumerate(records[published:], start=published):
+        refs = record.get("retrieved_learning_refs")
+        if (
+            unmatched_start is None
+            and isinstance(refs, list)
+            and any(_wire_retrieved_ref(value) is not None for value in refs)
+        ):
+            unmatched_start = index
+        if record.get("role") == "Assistant":
+            unmatched_start = None
+    return len(records) if unmatched_start is None else unmatched_start
+
+
 def unpublished_slice(
     records: Iterable[dict[str, Any]],
+    *,
+    published_override: int | None = None,
 ) -> tuple[int, list[dict[str, Any]]]:
-    """Split records into (last-published index, unpublished turn records).
+    """Return the current watermark and wire-ready unpublished interactions.
 
-    Walks the records in order, tracking the most recent ``published_up_to``
-    marker and collecting turn records (anything with a ``role``) that come
-    after it. Tool records are folded into the closest following Assistant
-    turn's ``tools_used``.
-
-    Returns:
-        tuple[int, list[dict]]: ``(published_up_to, interactions)``. The
-            integer is the watermark after which all turns are unpublished;
-            the list is formatted for ``InteractionData`` construction.
+    Metadata records are interpreted by their numeric boundary rather than
+    their physical position in the append-only file. This preserves turns that
+    arrive while an earlier network request is in flight.
     """
-    published = 0
+
+    buffered = list(records)
+    if published_override is None:
+        published = published_record_offset(buffered)
+    elif 0 <= published_override <= len(buffered):
+        published = published_override
+    else:
+        raise ValueError("published_override is outside the supplied record range")
     pending_tools: list[dict[str, Any]] = []
+    pending_refs: list[dict[str, str]] = []
     turns: list[dict[str, Any]] = []
-    for idx, rec in enumerate(records):
-        if "published_up_to" in rec:
-            published = rec["published_up_to"]
-            pending_tools = []
-            turns = []
+    attached_total = skipped = truncated = 0
+
+    for index, record in enumerate(buffered):
+        if index < published:
             continue
-        if idx < published:
+
+        refs = record.get("retrieved_learning_refs")
+        if "role" not in record and isinstance(refs, list):
+            for value in refs:
+                ref = _wire_retrieved_ref(value)
+                if ref is None:
+                    skipped += 1
+                else:
+                    pending_refs.append(ref)
             continue
-        role = rec.get("role")
+
+        role = record.get("role")
         if role == "Assistant_tool":
-            tool_input = rec.get("tool_input") or {}
-            tool_output = rec.get("tool_output") or ""
+            tool_input = record.get("tool_input") or {}
+            tool_output = record.get("tool_output") or ""
             tool_entry: dict[str, Any] = {
-                "tool_name": rec.get("tool_name", ""),
-                "status": rec.get("status", "success"),
+                "tool_name": record.get("tool_name", ""),
+                "status": record.get("status", "success"),
             }
             tool_data: dict[str, Any] = {}
             if tool_input:
                 tool_data["input"] = {
-                    k: _truncate_tool_data_field(v) for k, v in tool_input.items()
+                    key: _truncate_tool_data_field(value)
+                    for key, value in tool_input.items()
                 }
             if tool_output:
                 tool_data["output"] = _truncate_tool_data_field(tool_output)
@@ -266,20 +400,45 @@ def unpublished_slice(
                 tool_entry["tool_data"] = tool_data
             pending_tools.append(tool_entry)
             continue
-        if role in {"User", "Assistant"}:
-            # ``cited_items`` is local-only metadata (dashboard "used" badge);
-            # map it onto the wire's ``citations`` field — reflexio uses those
-            # to drive skill/preference reflection in the publish flow.
-            turn = {
-                k: v for k, v in rec.items() if k not in {"role", "ts", "cited_items"}
-            }
-            turn["role"] = role
-            if role == "Assistant":
-                citations = _to_wire_citations(rec.get("cited_items"))
-                if citations:
-                    turn["citations"] = citations
-                if pending_tools:
-                    turn["tools_used"] = pending_tools
-                    pending_tools = []
-            turns.append(turn)
+
+        if role not in {"User", "Assistant"}:
+            continue
+
+        turn = {
+            key: value
+            for key, value in record.items()
+            if key not in {"role", "ts", "cited_items", "host"}
+        }
+        turn["role"] = role
+        if role == "Assistant":
+            citations = _to_wire_citations(record.get("cited_items"))
+            if citations:
+                turn["citations"] = citations
+            if pending_tools:
+                turn["tools_used"] = pending_tools
+                pending_tools = []
+
+            retrieved: list[dict[str, str]] = []
+            seen: set[tuple[str, str]] = set()
+            for ref in pending_refs:
+                key = (ref["kind"], ref["learning_id"])
+                if key in seen:
+                    continue
+                seen.add(key)
+                if attached_total >= _RETRIEVED_LEARNINGS_PUBLISH_CAP:
+                    truncated += 1
+                    continue
+                retrieved.append(ref)
+                attached_total += 1
+            pending_refs = []
+            if retrieved:
+                turn["retrieved_learnings"] = retrieved
+        turns.append(turn)
+
+    if skipped:
+        _LOGGER.debug("Skipped %d malformed retrieved-learning refs", skipped)
+    if truncated:
+        _LOGGER.warning(
+            "Dropped %d retrieved-learning refs at the publish request cap", truncated
+        )
     return published, turns

package/plugin/uv.lock

@@ -476,7 +476,7 @@ wheels = [
 
 [[package]]
 name = "claude-smart"
-version = "0.2.48"
+version = "0.2.50"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },
@@ -494,7 +494,7 @@ dev = [
 requires-dist = [
     { name = "chromadb", specifier = ">=0.5" },
     { name = "einops", specifier = ">=0.8.0" },
-    { name = "reflexio-ai", specifier = ">=0.2.27" },
+    { name = "reflexio-ai", specifier = ">=0.2.28" },
     { name = "sqlite-vec", specifier = ">=0.1.6" },
 ]
 
@@ -2760,7 +2760,7 @@ wheels = [
 
 [[package]]
 name = "reflexio-ai"
-version = "0.2.27"
+version = "0.2.28"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "aiohttp" },
@@ -2800,9 +2800,9 @@ dependencies = [
     { name = "websocket-client" },
     { name = "xlsxwriter" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/85/22/64429eb84ae74aaa6d36f0a2e0d91a27b35ee33ef17c18411d54f08706ba/reflexio_ai-0.2.27.tar.gz", hash = "sha256:e433209ca848245e957943c6476f2bba32581de8804d535d25ca0596b0da0afd", size = 1112139, upload-time = "2026-06-30T06:26:21.88Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/2a/e6/a59fc40136b37ea3e9b6878b600ef1f405c1baf7d1431a07e55c8e49c14e/reflexio_ai-0.2.28.tar.gz", hash = "sha256:49a35abf714ae293392277b278b895cde21ca50c14f10c97cbcf27c307e49fae", size = 1155554, upload-time = "2026-07-04T07:01:02.207Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/68/22/d65332c75b9072e8838d51f68354d8d17c7636aa1cf73a20cfc1147b4364/reflexio_ai-0.2.27-py3-none-any.whl", hash = "sha256:4598f4aaa61e3c755a04573ab9711a7b5673ebf268029b2cef21cdcd5d4abfcf", size = 1461400, upload-time = "2026-06-30T06:26:19.965Z" },
+    { url = "https://files.pythonhosted.org/packages/96/a6/c842d5e525f0f561fcd11ecf6543c9c52b3f4b665dbc2a8fe94adce9be1b/reflexio_ai-0.2.28-py3-none-any.whl", hash = "sha256:177e3a740afa2acb5a2a14a1e648c32c2d9e71ef9ff79b8ab2caec7e24ff5d88", size = 1558983, upload-time = "2026-07-04T07:01:00.69Z" },
 ]
 
 [[package]]

package/plugin/vendor/reflexio/.env.example

@@ -77,6 +77,19 @@ REFLEXIO_PUBLISH_LEARNING_WORKERS=
 # Inactivity delay in seconds before a quiet session is evaluated by agent-success
 # evaluation. (optional; default 600 = 10 minutes)
 GROUP_EVALUATION_DELAY_SECONDS=600
+# Opt-in background sweep that re-embeds interactions whose embedding failed at
+# ingest (empty vector, no vector row -> invisible to vector/hybrid search). Runs
+# per-org on the shared lineage-GC scheduler cadence. Off by default so the GC
+# scheduler's start conditions are unchanged unless you opt in.
+#   options: true | false  (optional; default false)
+REFLEXIO_MISSING_VECTOR_BACKFILL_ENABLED=false
+# Max interactions re-embedded per org per sweep tick (bounds embedding cost and
+# log volume). (optional; default 200; values <= 0 fall back to the default)
+REFLEXIO_MISSING_VECTOR_BACKFILL_CAP=200
+# Bounded per-tick org fan-out width for the lineage-GC / expiry-reclamation
+# scheduler. SQLite storage is pinned to serial (1) regardless of this value.
+# (optional; default 8; non-numeric or <=0 falls back to default)
+REFLEXIO_SCHEDULER_ORG_WORKERS=
 
 # =============================================================================
 # 5. TESTING & LOGGING

package/plugin/vendor/reflexio/reflexio/README.md

@@ -56,8 +56,9 @@ Description: Python SDK for interacting with Reflexio API remotely
 Remote API client for applications to:
 1. **Publish interactions** - Send user interactions to server for processing
 2. **Search/retrieve data** - Query profiles, interactions, playbooks, evaluations, and context
-3. **Manage profiles/playbooks** - Delete, regenerate, and update status where supported by API endpoints
-4. **Configure** - Set/get organization configuration
+3. **Track deferred learning** - Poll `get_learning_status(request_id)` after `publish_interaction(..., wait_for_response=False)` queues extraction
+4. **Manage profiles/playbooks** - Delete, regenerate, and update status where supported by API endpoints
+5. **Configure** - Set/get organization configuration
 
 #### Architecture Pattern
 Async HTTP client wrapping typed models from `models/api_schema/`. Automatically handles authentication via Bearer tokens.
@@ -123,6 +124,7 @@ client (Python SDK)
         -> services/generation_service.py (orchestrator)
           ├─> services/profile/ -> storage (BaseStorage)
           ├─> services/playbook/ (playbook extraction) -> storage (BaseStorage)
+          ├─> services/durable_learning/ -> learning_jobs queue -> deferred extraction
           └─> services/agent_success_evaluation/ -> storage (BaseStorage)
 ```
 
@@ -138,6 +140,7 @@ client (Python SDK)
   - `profile/` - Profile extraction & updates
   - `playbook/` - Playbook extraction, consolidation, and aggregation
   - `agent_success_evaluation/` - Success evaluation
+  - `durable_learning/` - Claim/drain durable `learning_jobs` for deferred extraction when `REFLEXIO_DURABLE_LEARNING_QUEUE` is enabled
   - `reflection/` - Post-horizon reflection extraction
   - `extraction/` - Resumable async extraction agent infrastructure
   - `shadow_comparison/` - Per-turn regular vs shadow verdict judge
@@ -146,9 +149,10 @@ client (Python SDK)
   - `braintrust/` - Braintrust eval export/sync support
   - `lineage/` - Resolve current records and schedule tombstone garbage collection for superseded profile/playbook rows
   - `governance/` - Subject-reference contracts and retention/barrier helpers used by storage and lineage
-  - `storage/` - Abstract layer (SQLite prod, LocalJSON test) with governance-aware write validation
+  - `storage/` - Abstract layer (SQLite prod, LocalJSON test) with governance-aware write validation and durable `learning_jobs` contracts
   - `pre_retrieval/` - Query rewriting and document expansion helpers
   - `configurator/` - YAML config loader
+- **`billing_meter.py`**: OSS usage-event facade for learning/search metering; keep imports function-local at call sites so enterprise emitters remain optional
 - **`site_var/`**: Global settings singleton
 
 ### Architecture Patterns

package/plugin/vendor/reflexio/reflexio/__init__.py

@@ -5,6 +5,13 @@ try:
 except PackageNotFoundError:
     __version__ = "0.0.0-dev"
 
+from reflexio.models.api_schema.eval_overview_schema import (
+    GradeOnDemandRequest,
+    GradeOnDemandResponse,
+    RegenerateRequest,
+    RegenerateStartResponse,
+    RegenerateStatusResponse,
+)
 from reflexio.models.api_schema.retriever_schema import (
     ConversationTurn,
     GetAgentPlaybooksViewResponse,
@@ -125,6 +132,8 @@ __all__ = [
     "DeleteProfilesByIdsRequest",
     "DeleteAgentPlaybooksByIdsRequest",
     "DeleteUserPlaybooksByIdsRequest",
+    "GradeOnDemandRequest",
+    "RegenerateRequest",
     # Response types (internal)
     "PublishUserInteractionResponse",
     "DeleteUserProfileResponse",
@@ -135,6 +144,9 @@ __all__ = [
     "SearchInteractionResponse",
     "SearchUserProfileResponse",
     "BulkDeleteResponse",
+    "GradeOnDemandResponse",
+    "RegenerateStartResponse",
+    "RegenerateStatusResponse",
     # View response types (user-facing)
     "GetInteractionsViewResponse",
     "GetProfilesViewResponse",

package/plugin/vendor/reflexio/reflexio/cli/README.md

@@ -78,6 +78,9 @@ When `REFLEXIO_EMBEDDING_PROVIDER=local_service` or
 `local/nomic-embed-text-v1.5`, and `local/minilm-l6-v2`. Local embedding
 requests allow extra time for model cold start; override with
 `REFLEXIO_EMBEDDING_SERVICE_TIMEOUT_MS` when needed.
+MiniLM cache corruption is retried once automatically. If recovery still fails,
+delete the cache directory named in the error message, restart Reflexio, and
+retry local embedding.
 
 ## Publishing interactions