claude-smart 0.2.49 → 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.49"
+version = "0.2.50"
 source = { editable = "." }
 dependencies = [
     { name = "chromadb" },

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/client/client.py

@@ -15,6 +15,13 @@ import requests
 from pydantic import ConfigDict
 
 from reflexio.defaults import DEFAULT_AGENT_VERSION
+from reflexio.models.api_schema.eval_overview_schema import (
+    GradeOnDemandRequest,
+    GradeOnDemandResponse,
+    RegenerateRequest,
+    RegenerateStartResponse,
+    RegenerateStatusResponse,
+)
 from reflexio.models.api_schema.retriever_schema import (
     ConversationTurn,
     GetAgentPlaybooksRequest,
@@ -26,6 +33,8 @@ from reflexio.models.api_schema.retriever_schema import (
     GetProfilesViewResponse,
     GetRequestsRequest,
     GetRequestsViewResponse,
+    GetRetrievedLearningEvaluationResultsRequest,
+    GetRetrievedLearningEvaluationResultsResponse,
     GetUserPlaybooksRequest,
     GetUserPlaybooksViewResponse,
     GetUserProfilesRequest,
@@ -306,9 +315,8 @@ class ReflexioClient:
         if headers:
             request_headers.update(headers)
 
-        self.session.headers.update(request_headers)
         kwargs.setdefault("timeout", self.timeout)
-        response = self.session.request(method, url, **kwargs)
+        response = self.session.request(method, url, headers=request_headers, **kwargs)
         response.raise_for_status()
 
         # Empty body on a successful response (e.g. 204 No Content).
@@ -1920,6 +1928,116 @@ class ReflexioClient:
         )
         return GetEvaluationResultsViewResponse(**response)
 
+    def get_retrieved_learning_evaluation_results(
+        self,
+        request: GetRetrievedLearningEvaluationResultsRequest | dict | None = None,
+        *,
+        user_id: str | None = None,
+        session_id: str | None = None,
+        limit: int | None = None,
+    ) -> GetRetrievedLearningEvaluationResultsResponse:
+        """Get per-learning relevance and impact verdicts for retrieved context."""
+        req = self._build_request(
+            request,
+            GetRetrievedLearningEvaluationResultsRequest,
+            user_id=user_id,
+            session_id=session_id,
+            limit=limit,
+        )
+        response = self._make_request(
+            "POST",
+            "/api/get_retrieved_learning_evaluation_results",
+            json=req.model_dump(),
+        )
+        return GetRetrievedLearningEvaluationResultsResponse(**response)
+
+    def regenerate_evaluations(
+        self,
+        request: RegenerateRequest | dict | None = None,
+        *,
+        from_ts: int | None = None,
+        to_ts: int | None = None,
+        evaluation_name: str | None = None,
+    ) -> RegenerateStartResponse:
+        """Start a replay-the-judge regeneration job over a time window.
+
+        Args:
+            request: Optional ``RegenerateRequest`` or dict. If omitted,
+                keyword arguments are used.
+            from_ts: Inclusive lower bound of the window as Unix seconds.
+            to_ts: Inclusive upper bound of the window as Unix seconds.
+            evaluation_name: Deprecated compatibility field accepted by the
+                API but ignored by the singleton evaluator.
+
+        Returns:
+            RegenerateStartResponse: The job id and number of queued sessions.
+        """
+        req = self._build_request(
+            request,
+            RegenerateRequest,
+            from_ts=from_ts,
+            to_ts=to_ts,
+            evaluation_name=evaluation_name,
+        )
+        response = self._make_request(
+            "POST",
+            "/api/evaluations/regenerate",
+            json=req.model_dump(),
+        )
+        return RegenerateStartResponse(**response)
+
+    def get_evaluation_regeneration_status(
+        self, job_id: str
+    ) -> RegenerateStatusResponse:
+        """Get status for an evaluation regeneration job."""
+        response = self._make_request(
+            "GET",
+            f"/api/evaluations/regenerate/{job_id}",
+        )
+        return RegenerateStatusResponse(**response)
+
+    def cancel_evaluation_regeneration(self, job_id: str) -> dict[str, str]:
+        """Request cancellation for an evaluation regeneration job."""
+        return self._make_request(
+            "DELETE",
+            f"/api/evaluations/regenerate/{job_id}",
+        )
+
+    def grade_on_demand(
+        self,
+        request: GradeOnDemandRequest | dict | None = None,
+        *,
+        session_id: str | None = None,
+        agent_version: str | None = None,
+        evaluation_name: str | None = None,
+    ) -> GradeOnDemandResponse:
+        """Grade a single session synchronously.
+
+        Args:
+            request: Optional ``GradeOnDemandRequest`` or dict. If omitted,
+                keyword arguments are used.
+            session_id: Session to grade.
+            agent_version: Agent version to grade.
+            evaluation_name: Deprecated compatibility field accepted by the
+                API but ignored by the singleton evaluator.
+
+        Returns:
+            GradeOnDemandResponse: Result id, cache flag, or skipped reason.
+        """
+        req = self._build_request(
+            request,
+            GradeOnDemandRequest,
+            session_id=session_id,
+            agent_version=agent_version,
+            evaluation_name=evaluation_name,
+        )
+        response = self._make_request(
+            "POST",
+            "/api/evaluations/grade_on_demand",
+            json=req.model_dump(),
+        )
+        return GradeOnDemandResponse(**response)
+
     def _poll_operation_status(
         self,
         service_name: str,
@@ -2399,7 +2517,12 @@ class ReflexioClient:
                 "profiles", "user_playbooks", "agent_playbooks".
             agent_playbook_status_filter (Optional[list[Union[PlaybookStatus, str]]]):
                 Agent-playbook approval statuses to include.
-            enable_reformulation (Optional[bool]): Enable LLM query reformulation (default: False)
+            enable_reformulation (Optional[bool]): Enable the pre-search LLM
+                query reformulation call (default: False). Besides rewriting
+                the query, it extracts temporal signals — time windows
+                ("this week"), as-of boundaries, and current-value intent —
+                that make retrieval time-sensitive (window filters,
+                freshness-preferred ranking for superseded facts).
             enable_agent_answer (Optional[bool]): Enable agentic answer synthesis when
                 the configured search backend supports it (default: False).
             conversation_history (Optional[list[ConversationTurn] | list[dict]]): Prior conversation turns for context-aware query reformulation. Accepts ConversationTurn objects or dicts with "role" and "content" keys.

package/plugin/vendor/reflexio/reflexio/integrations/openclaw/plugin/src/openclaw_smart/state.py

@@ -36,7 +36,9 @@ _DEFAULT_STATE_DIR = Path.home() / ".openclaw-smart" / "sessions"
 
 _TOOL_DATA_FIELD_MAX_LEN = 256
 
-_VALID_CITATION_KINDS = frozenset({"playbook", "profile"})
+_VALID_CITATION_KINDS = frozenset(
+    {"playbook", "profile", "user_playbook", "agent_playbook"}
+)
 
 
 def _truncate_tool_data_field(value: Any) -> Any:
@@ -240,13 +242,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 "",