claude-smart 0.2.49 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/governance/_subject_barrier.py

@@ -166,6 +166,7 @@ class SubjectBarrierMixin:
             "profiles",
             "user_playbooks",
             "agent_success_evaluation_result",
+            "retrieved_learning_evaluation",
         ):
             row = self.conn.execute(
                 f"""SELECT 1 FROM {table}
@@ -198,9 +199,14 @@ class SubjectBarrierMixin:
             request_id_column="request_id",
         ):
             return True
-        return self._legacy_user_id_rows_remain_locked(
+        if self._legacy_user_id_rows_remain_locked(
             table="agent_success_evaluation_result",
             subject_ref=subject_ref,
+        ):
+            return True
+        return self._legacy_user_id_rows_remain_locked(
+            table="retrieved_learning_evaluation",
+            subject_ref=subject_ref,
         )
 
     def begin_subject_erasure_barrier(

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/playbook/_agent.py

@@ -19,6 +19,9 @@ from reflexio.models.api_schema.service_schemas import (
     Status,
 )
 from reflexio.models.config_schema import SearchMode, SearchOptions
+from reflexio.server.services.storage.lifecycle_filters import (
+    validate_include_inactive,
+)
 from reflexio.server.services.storage.storage_base._playbook import (
     AGGREGATE_REASON_PREFIX,
 )
@@ -344,6 +347,46 @@ class AgentPlaybookStoreMixin:
             row = self._fetchone(sql, (agent_playbook_id,))
         return _row_to_agent_playbook(row) if row else None
 
+    @SQLiteStorageBase.handle_exceptions
+    def get_agent_playbooks_by_ids(
+        self,
+        agent_playbook_ids: list[int],
+        *,
+        status_filter: list[Status | None] | None = None,
+        playbook_status_filter: list[PlaybookStatus] | None = None,
+        include_inactive: bool = False,
+    ) -> list[AgentPlaybook]:
+        validate_include_inactive(
+            include_inactive=include_inactive,
+            status_filter=status_filter,
+            playbook_status_filter=playbook_status_filter,
+        )
+        if not agent_playbook_ids:
+            return []
+        unique_ids = list(dict.fromkeys(agent_playbook_ids))
+        rows: list[sqlite3.Row] = []
+        for start in range(0, len(unique_ids), 900):
+            chunk = unique_ids[start : start + 900]
+            placeholders = ",".join("?" for _ in chunk)
+            query = (
+                "SELECT * FROM agent_playbooks "
+                f"WHERE agent_playbook_id IN ({placeholders})"
+            )
+            params: list[Any] = list(chunk)
+            if not include_inactive:
+                if status_filter is not None:
+                    fragment, status_params = _build_status_sql(status_filter)
+                    query += f" AND {fragment}"
+                    params.extend(status_params)
+                else:
+                    query += " AND status IS NULL"
+                if playbook_status_filter:
+                    status_placeholders = ",".join("?" for _ in playbook_status_filter)
+                    query += f" AND playbook_status IN ({status_placeholders})"
+                    params.extend(status.value for status in playbook_status_filter)
+            rows.extend(self._fetchall(query, params))
+        return [_row_to_agent_playbook(row) for row in rows]
+
     @SQLiteStorageBase.handle_exceptions
     def delete_all_agent_playbooks(self) -> None:
         batch_request_id = uuid.uuid4().hex

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/playbook/_eval_results.py

@@ -1,16 +1,30 @@
 """Agent success evaluation result store methods for SQLite storage."""
 
 import sqlite3
+from datetime import UTC, datetime
 from typing import Any
 
 from reflexio.models.api_schema.service_schemas import (
     AgentSuccessEvaluationResult,
+    RetrievedLearningEvaluationResult,
 )
 
+from ...storage_base.retrieved_learning_state import (
+    CANONICAL_RETRIEVED_KINDS,
+    DEFAULT_TRANSCRIPT_CHAR_LIMIT,
+    TERMINAL_RETRIEVED_STATUSES,
+    BoundedRetrievedLearningSnapshot,
+    RetrievedLearningCommitResult,
+    SessionFingerprintBuilder,
+    append_bounded_snapshot_interaction,
+    build_retrieved_learning_state_key,
+)
 from .._base import (
     SQLiteStorageBase,
     _epoch_to_iso,
+    _iso_to_epoch,
     _json_dumps,
+    _json_loads,
     _row_to_eval_result,
 )
 
@@ -23,9 +37,12 @@ class AgentEvaluationResultStoreMixin:
     conn: sqlite3.Connection
     _execute: Any
     _fetchall: Any
+    _fetchone: Any
     _get_embedding: Any
     _subject_ref_for_user_id: Any
     _assert_subject_writable_locked: Any
+    _current_timestamp: Any
+    get_operation_state: Any
 
     # ------------------------------------------------------------------
     # Agent Success Evaluation methods
@@ -36,11 +53,12 @@ class AgentEvaluationResultStoreMixin:
         self, results: list[AgentSuccessEvaluationResult]
     ) -> None:
         for result in results:
-            embedding_text = f"{result.failure_type} {result.failure_reason}"
-            if embedding_text.strip():
-                result.embedding = self._get_embedding(embedding_text)
-            else:
-                result.embedding = []
+            if not result.embedding:
+                embedding_text = f"{result.failure_type} {result.failure_reason}"
+                if embedding_text.strip():
+                    result.embedding = self._get_embedding(embedding_text)
+                else:
+                    result.embedding = []
 
             created_at_iso = _epoch_to_iso(result.created_at)
             subject_ref = self._subject_ref_for_user_id(result.user_id)
@@ -187,3 +205,410 @@ class AgentEvaluationResultStoreMixin:
             list(result_ids),
         )
         return cur.rowcount
+
+    # ------------------------------------------------------------------
+    # Retrieved-learning evaluation methods
+    # ------------------------------------------------------------------
+    # Generation fencing + session-fingerprint CAS; see
+    # storage_base/retrieved_learning_state.py for the concurrency contract.
+    # All state reads/writes inside a transaction use raw self.conn.execute
+    # (never self._execute or self-committing helpers) so replacement stays
+    # atomic on the shared connection.
+
+    def _rle_state_row(self, state_key: str) -> dict[str, Any]:
+        cur = self.conn.execute(
+            "SELECT operation_state FROM _operation_state WHERE service_name = ?",
+            (state_key,),
+        )
+        row = cur.fetchone()
+        if not row:
+            return {}
+        return _json_loads(row["operation_state"]) or {}
+
+    def _rle_upsert_state(self, state_key: str, state: dict[str, Any]) -> None:
+        self.conn.execute(
+            """INSERT INTO _operation_state (service_name, operation_state, updated_at)
+               VALUES (?,?,?)
+               ON CONFLICT(service_name) DO UPDATE SET
+                 operation_state = excluded.operation_state,
+                 updated_at = excluded.updated_at""",
+            (state_key, _json_dumps(state), self._current_timestamp()),
+        )
+
+    def _rle_fingerprint_now(self, user_id: str, session_id: str) -> str:
+        """Recompute the session fingerprint from live rows (in-transaction)."""
+        cur = self.conn.execute(
+            """SELECT i.interaction_id, i.role,
+                      substr(i.content, 1, ?) AS content, i.retrieved_learnings
+               FROM interactions i JOIN requests r ON i.request_id = r.request_id
+               WHERE r.session_id = ? AND i.user_id = ?
+               ORDER BY i.created_at ASC, i.interaction_id ASC""",
+            (DEFAULT_TRANSCRIPT_CHAR_LIMIT, session_id, user_id),
+        )
+        builder = SessionFingerprintBuilder()
+        for row in cur:
+            builder.add(
+                int(row["interaction_id"]),
+                _parse_attachment_refs(row["retrieved_learnings"]),
+                row["role"] or "User",
+                row["content"] or "",
+            )
+        return builder.hexdigest()
+
+    def _rle_attached_refs(self, user_id: str, session_id: str) -> set[tuple[str, str]]:
+        """Canonical ``(kind, learning_id)`` refs attached to the live session."""
+        cur = self.conn.execute(
+            """SELECT i.retrieved_learnings
+               FROM interactions i JOIN requests r ON i.request_id = r.request_id
+               WHERE r.session_id = ? AND i.user_id = ?""",
+            (session_id, user_id),
+        )
+        attached: set[tuple[str, str]] = set()
+        for row in cur:
+            attached.update(_parse_attachment_refs(row["retrieved_learnings"]))
+        return attached
+
+    def _rle_resolvable_refs(
+        self, user_id: str, results: list[RetrievedLearningEvaluationResult]
+    ) -> set[tuple[str, str]]:
+        """Recheck original source rows for historical resolution (in-transaction)."""
+        by_kind: dict[str, list[str]] = {}
+        for r in results:
+            by_kind.setdefault(r.kind, []).append(r.learning_id)
+        resolvable: set[tuple[str, str]] = set()
+        for chunk in _chunked(by_kind.get("profile", [])):
+            ph = ",".join("?" for _ in chunk)
+            cur = self.conn.execute(
+                f"""SELECT profile_id FROM profiles
+                    WHERE user_id = ? AND profile_id IN ({ph})""",
+                (user_id, *chunk),
+            )
+            resolvable.update(("profile", str(row[0])) for row in cur.fetchall())
+        user_playbook_ids = [
+            i for i in (_as_int(x) for x in by_kind.get("user_playbook", [])) if i
+        ]
+        for chunk in _chunked(user_playbook_ids):
+            ph = ",".join("?" for _ in chunk)
+            cur = self.conn.execute(
+                f"""SELECT user_playbook_id FROM user_playbooks
+                    WHERE user_id = ? AND user_playbook_id IN ({ph})""",
+                (user_id, *chunk),
+            )
+            resolvable.update(("user_playbook", str(row[0])) for row in cur.fetchall())
+        agent_playbook_ids = [
+            i for i in (_as_int(x) for x in by_kind.get("agent_playbook", [])) if i
+        ]
+        for chunk in _chunked(agent_playbook_ids):
+            ph = ",".join("?" for _ in chunk)
+            cur = self.conn.execute(
+                f"""SELECT agent_playbook_id FROM agent_playbooks
+                    WHERE agent_playbook_id IN ({ph})""",
+                chunk,
+            )
+            resolvable.update(("agent_playbook", str(row[0])) for row in cur.fetchall())
+        return resolvable
+
+    @SQLiteStorageBase.handle_exceptions
+    def begin_retrieved_learning_evaluation_run(
+        self, user_id: str, session_id: str
+    ) -> int:
+        state_key = build_retrieved_learning_state_key(user_id, session_id)
+        subject_ref = self._subject_ref_for_user_id(user_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                state = self._rle_state_row(state_key)
+                generation = int(state.get("generation") or 0) + 1
+                state.update(
+                    {
+                        "user_id": user_id,
+                        "session_id": session_id,
+                        "generation": generation,
+                        "attempted_at": int(self._current_epoch()),
+                    }
+                )
+                state.setdefault("status", "pending")
+                state.setdefault("session_fingerprint", "")
+                self._rle_upsert_state(state_key, state)
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
+        return generation
+
+    @SQLiteStorageBase.handle_exceptions
+    def load_bounded_retrieved_learning_snapshot(
+        self,
+        user_id: str,
+        session_id: str,
+        raw_ref_limit: int = 5_000,
+        transcript_char_limit: int = DEFAULT_TRANSCRIPT_CHAR_LIMIT,
+    ) -> BoundedRetrievedLearningSnapshot:
+        snapshot = BoundedRetrievedLearningSnapshot()
+        row = self._fetchone(
+            """SELECT MIN(created_at) AS earliest FROM requests
+               WHERE session_id = ? AND user_id = ?""",
+            (session_id, user_id),
+        )
+        if row and row["earliest"]:
+            snapshot.earliest_request_created_at = _iso_to_epoch(row["earliest"])
+        row = self._fetchone(
+            """SELECT agent_version FROM requests
+               WHERE session_id = ? AND user_id = ?
+               ORDER BY created_at DESC LIMIT 1""",
+            (session_id, user_id),
+        )
+        if row:
+            snapshot.agent_version = row["agent_version"] or ""
+        cursor = self.conn.execute(
+            # ``fp_content`` is truncated to the fixed fingerprint limit,
+            # independent of the caller's ``transcript_char_limit`` snapshot
+            # budget, so the commit-side recompute (which has no such budget)
+            # produces an identical digest.
+            """SELECT i.interaction_id, i.role,
+                      substr(i.content, 1, ?) AS content,
+                      substr(i.content, 1, ?) AS fp_content,
+                      i.created_at, i.retrieved_learnings
+               FROM interactions i JOIN requests r ON i.request_id = r.request_id
+               WHERE r.session_id = ? AND i.user_id = ?
+               ORDER BY i.created_at ASC, i.interaction_id ASC""",
+            (transcript_char_limit, DEFAULT_TRANSCRIPT_CHAR_LIMIT, session_id, user_id),
+        )
+        builder = SessionFingerprintBuilder()
+        transcript_chars_remaining = transcript_char_limit
+        for r in cursor:
+            refs = _parse_attachment_refs(r["retrieved_learnings"])
+            snapshot.raw_attachment_count += len(refs)
+            builder.add(
+                int(r["interaction_id"]),
+                refs,
+                r["role"] or "User",
+                r["fp_content"] or "",
+            )
+            if snapshot.raw_attachment_count > raw_ref_limit:
+                snapshot.attachment_limit_exceeded = True
+                snapshot.interactions.clear()
+                transcript_chars_remaining = 0
+                continue
+            transcript_chars_remaining = append_bounded_snapshot_interaction(
+                snapshot,
+                interaction_id=int(r["interaction_id"]),
+                role=r["role"] or "User",
+                content=r["content"] or "",
+                created_at=_iso_to_epoch(r["created_at"]),
+                refs=refs,
+                transcript_chars_remaining=transcript_chars_remaining,
+            )
+        snapshot.precomputed_fingerprint = builder.hexdigest()
+        return snapshot
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_matching_retrieved_learning_terminal_state(
+        self, user_id: str, session_id: str, session_fingerprint: str
+    ) -> dict[str, Any] | None:
+        state_key = build_retrieved_learning_state_key(user_id, session_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                state = self._rle_state_row(state_key)
+                live_fingerprint = self._rle_fingerprint_now(user_id, session_id)
+                matched = (
+                    state.get("status") in TERMINAL_RETRIEVED_STATUSES
+                    and state.get("session_fingerprint") == session_fingerprint
+                    and live_fingerprint == session_fingerprint
+                )
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
+        return state if matched else None
+
+    @SQLiteStorageBase.handle_exceptions
+    def replace_retrieved_learning_evaluation_results(
+        self,
+        user_id: str,
+        session_id: str,
+        generation: int,
+        session_fingerprint: str,
+        proposed_status: str,
+        diagnostics: dict[str, Any],
+        results: list[RetrievedLearningEvaluationResult],
+    ) -> RetrievedLearningCommitResult:
+        if proposed_status not in ("complete", "degraded"):
+            raise ValueError(f"invalid proposed_status: {proposed_status}")
+        state_key = build_retrieved_learning_state_key(user_id, session_id)
+        subject_ref = self._subject_ref_for_user_id(user_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                self._assert_subject_writable_locked(subject_ref)
+                state = self._rle_state_row(state_key)
+                if int(state.get("generation") or 0) != generation:
+                    self.conn.rollback()
+                    return RetrievedLearningCommitResult(disposition="superseded")
+                if self._rle_fingerprint_now(user_id, session_id) != (
+                    session_fingerprint
+                ):
+                    self.conn.rollback()
+                    return RetrievedLearningCommitResult(disposition="stale")
+                # Persist only records that are still attached to the live
+                # session AND whose original row still exists. A duplicate identity is left
+                # to trip the UNIQUE index and roll back the commit — caller
+                # bugs fail loud rather than silently dropping data.
+                attached = self._rle_attached_refs(user_id, session_id)
+                resolvable = self._rle_resolvable_refs(user_id, results)
+                kept = [
+                    r
+                    for r in results
+                    if (r.kind, r.learning_id) in attached
+                    and (r.kind, r.learning_id) in resolvable
+                ]
+                final_status = proposed_status if kept else "not_applicable"
+                self.conn.execute(
+                    """DELETE FROM retrieved_learning_evaluation
+                       WHERE user_id = ? AND session_id = ?""",
+                    (user_id, session_id),
+                )
+                for r in kept:
+                    self.conn.execute(
+                        """INSERT INTO retrieved_learning_evaluation
+                           (user_id, session_id, agent_version, kind,
+                            learning_id, is_relevant, relevance_reason, impact,
+                            impact_reason, created_at, governance_subject_ref)
+                           VALUES (?,?,?,?,?,?,?,?,?,?,?)""",
+                        (
+                            user_id,
+                            session_id,
+                            r.agent_version,
+                            r.kind,
+                            r.learning_id,
+                            None if r.is_relevant is None else int(r.is_relevant),
+                            r.relevance_reason,
+                            r.impact,
+                            r.impact_reason,
+                            r.created_at,
+                            subject_ref,
+                        ),
+                    )
+                state.update(diagnostics)
+                state.update(
+                    {
+                        "user_id": user_id,
+                        "session_id": session_id,
+                        "generation": generation,
+                        "status": final_status,
+                        "session_fingerprint": session_fingerprint,
+                        "resolvable_count": len(resolvable),
+                        "committed_count": len(kept),
+                        "completed_at": int(self._current_epoch()),
+                    }
+                )
+                self._rle_upsert_state(state_key, state)
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
+        return RetrievedLearningCommitResult(
+            disposition="applied", status=final_status, committed_count=len(kept)
+        )
+
+    @SQLiteStorageBase.handle_exceptions
+    def finish_retrieved_learning_evaluation_run(
+        self,
+        user_id: str,
+        session_id: str,
+        generation: int,
+        status: str,
+        diagnostics: dict[str, Any],
+    ) -> None:
+        if status not in ("failed", "pending"):
+            raise ValueError(f"invalid finish status: {status}")
+        state_key = build_retrieved_learning_state_key(user_id, session_id)
+        with self._lock:
+            try:
+                self.conn.execute("BEGIN IMMEDIATE")
+                state = self._rle_state_row(state_key)
+                if int(state.get("generation") or 0) != generation:
+                    self.conn.rollback()
+                    return
+                state.update(diagnostics)
+                state["status"] = status
+                self._rle_upsert_state(state_key, state)
+                self.conn.commit()
+            except Exception:
+                self.conn.rollback()
+                raise
+
+    @SQLiteStorageBase.handle_exceptions
+    def get_retrieved_learning_evaluation_results(
+        self,
+        user_id: str | None = None,
+        session_id: str | None = None,
+        limit: int = 100,
+    ) -> list[RetrievedLearningEvaluationResult]:
+        sql = "SELECT * FROM retrieved_learning_evaluation"
+        clauses: list[str] = []
+        params: list[Any] = []
+        if user_id is not None:
+            clauses.append("user_id = ?")
+            params.append(user_id)
+        if session_id is not None:
+            clauses.append("session_id = ?")
+            params.append(session_id)
+        if clauses:
+            sql += " WHERE " + " AND ".join(clauses)
+        sql += " ORDER BY created_at DESC, result_id DESC LIMIT ?"
+        params.append(limit)
+        rows = self._fetchall(sql, params)
+        return [_row_to_retrieved_learning_result(r) for r in rows]
+
+    def _current_epoch(self) -> int:
+        return int(datetime.now(UTC).timestamp())
+
+
+def _parse_attachment_refs(raw: Any) -> list[tuple[str, str]]:
+    """Parse a stored retrieved_learnings JSON blob into (kind, learning_id) tuples."""
+    parsed = _json_loads(raw) if isinstance(raw, str) else raw
+    if not parsed or not isinstance(parsed, list):
+        return []
+    refs: list[tuple[str, str]] = []
+    for item in parsed:
+        if not isinstance(item, dict):
+            continue
+        kind = str(item.get("kind") or "")
+        learning_id = str(item.get("learning_id") or "")
+        if kind in CANONICAL_RETRIEVED_KINDS and learning_id:
+            refs.append((kind, learning_id))
+    return refs
+
+
+def _row_to_retrieved_learning_result(
+    row: sqlite3.Row,
+) -> RetrievedLearningEvaluationResult:
+    d = dict(row)
+    return RetrievedLearningEvaluationResult(
+        result_id=int(d["result_id"]),
+        user_id=d["user_id"],
+        session_id=d["session_id"],
+        agent_version=d.get("agent_version") or "",
+        kind=d["kind"],
+        learning_id=d["learning_id"],
+        is_relevant=None if d.get("is_relevant") is None else bool(d["is_relevant"]),
+        relevance_reason=d.get("relevance_reason") or "",
+        impact=d.get("impact"),
+        impact_reason=d.get("impact_reason") or "",
+        created_at=int(d["created_at"]),
+    )
+
+
+def _as_int(value: str) -> int | None:
+    try:
+        parsed = int(value)
+    except (TypeError, ValueError):
+        return None
+    return parsed if parsed > 0 else None
+
+
+def _chunked(items: list, size: int = 500) -> list[list]:
+    return [items[i : i + size] for i in range(0, len(items), size)]

package/plugin/vendor/reflexio/reflexio/server/services/storage/sqlite_storage/playbook/_user.py

@@ -10,6 +10,9 @@ from reflexio.models.api_schema.common import BlockingIssue
 from reflexio.models.api_schema.retriever_schema import SearchUserPlaybookRequest
 from reflexio.models.api_schema.service_schemas import Status, UserPlaybook
 from reflexio.models.config_schema import SearchMode, SearchOptions
+from reflexio.server.services.storage.lifecycle_filters import (
+    validate_include_inactive,
+)
 
 from .._base import (
     _TOMBSTONE_STATUS_VALUES,
@@ -97,12 +100,17 @@ class UserPlaybookStoreMixin:
         )
         return row
 
-    @SQLiteStorageBase.handle_exceptions
-    def save_user_playbooks(self, user_playbooks: list[UserPlaybook]) -> None:
-        for up in user_playbooks:
-            subject_ref = self._subject_ref_for_user_id(up.user_id)
-            with self._lock:
-                self._assert_subject_writable_locked(subject_ref)
+    def precompute_user_playbook_embeddings(
+        self, playbooks: list[UserPlaybook]
+    ) -> None:
+        """Populate ``.embedding`` / ``.expanded_terms`` in place; no DB write.
+
+        Extracted verbatim from the former ``save_user_playbooks`` prelude
+        (including the ``if embedding_text:`` guard) so the durable
+        compute/persist split can embed outside the writer transaction and then
+        persist with ``skip_embedding=True``.
+        """
+        for up in playbooks:
             embedding_text = up.trigger or up.content
             if embedding_text:
                 if self._should_expand_documents():
@@ -118,6 +126,24 @@ class UserPlaybookStoreMixin:
                 else:
                     up.embedding = self._get_embedding(embedding_text)
 
+    @SQLiteStorageBase.handle_exceptions
+    def save_user_playbooks(
+        self,
+        user_playbooks: list[UserPlaybook],
+        *,
+        skip_embedding: bool = False,
+    ) -> None:
+        for up in user_playbooks:
+            subject_ref = self._subject_ref_for_user_id(up.user_id)
+            with self._lock:
+                self._assert_subject_writable_locked(subject_ref)
+            # Default (skip_embedding=False) recomputes unconditionally, exactly
+            # as before — model_copy callers that change content while keeping
+            # the old embedding depend on this. The durable persist path opts
+            # out (embedding already set by precompute_user_playbook_embeddings).
+            if not skip_embedding:
+                self.precompute_user_playbook_embeddings([up])
+
             created_at_iso = _epoch_to_iso(up.created_at)
             with self._lock:
                 own_txn = self._own_transaction()
@@ -521,13 +547,25 @@ class UserPlaybookStoreMixin:
         user_id: str,
         user_playbook_ids: list[int],
         status_filter: list[Status | None] | None = None,
+        *,
+        include_inactive: bool = False,
     ) -> list[UserPlaybook]:
+        validate_include_inactive(
+            include_inactive=include_inactive, status_filter=status_filter
+        )
         if not user_playbook_ids:
             return []
+        ph = ",".join("?" for _ in user_playbook_ids)
+        if include_inactive:
+            rows = self._fetchall(
+                "SELECT * FROM user_playbooks "
+                f"WHERE user_id = ? AND user_playbook_id IN ({ph})",
+                (user_id, *user_playbook_ids),
+            )
+            return [_row_to_user_playbook(r) for r in rows]
         if status_filter is None:
             status_filter = [None]
         frag, sparams = _build_status_sql(status_filter)
-        ph = ",".join("?" for _ in user_playbook_ids)
         sql = (
             f"SELECT * FROM user_playbooks "
             f"WHERE user_id = ? AND user_playbook_id IN ({ph}) AND {frag}"