claude-smart 0.2.48 → 0.2.50

package/plugin/vendor/reflexio/reflexio/server/llm/providers/local_embedding_provider.py

@@ -18,9 +18,23 @@ from __future__ import annotations
 import importlib.util
 import logging
 import os
+import shutil
 import threading
+from collections.abc import Iterator
+from contextlib import contextmanager
+from pathlib import Path
 from typing import Any
 
+try:
+    import fcntl
+except ImportError:  # pragma: no cover - Windows only
+    fcntl = None  # type: ignore[assignment]
+
+try:
+    import msvcrt
+except ImportError:  # pragma: no cover - POSIX only
+    msvcrt = None  # type: ignore[assignment]
+
 _LOGGER = logging.getLogger(__name__)
 
 _ENV_ENABLE = "CLAUDE_SMART_USE_LOCAL_EMBEDDING"
@@ -36,6 +50,17 @@ _TARGET_DIM = 512
 # ValueError that ONNXMiniLM_L6_V2 throws on over-length input.
 _MAX_CHARS = 800
 
+# Chroma keeps this file list private inside ONNXMiniLM_L6_V2's download helper.
+# Keep this in sync with chromadb's all-MiniLM-L6-v2 extracted archive layout.
+_MINILM_EXPECTED_FILES = (
+    "config.json",
+    "model.onnx",
+    "special_tokens_map.json",
+    "tokenizer_config.json",
+    "tokenizer.json",
+    "vocab.txt",
+)
+
 
 class LocalEmbedderError(RuntimeError):
     """Raised when the local embedder is called without chromadb installed."""
@@ -49,7 +74,17 @@ class LocalEmbedder:
 
     def __init__(self) -> None:
         self._ef: Any | None = None
+        # Guards lazy construction / cache-recovery swaps of ``self._ef``.
         self._ef_lock = threading.Lock()
+        # Serializes the actual encode call. The shared ONNX embedding function
+        # is NOT thread-safe — concurrent ``ef(...)`` calls interleave and
+        # corrupt each other's padding/attention buffers (observed in prod as
+        # tensor-shape mismatches). ``threading.Lock`` is non-reentrant, so this
+        # is a SEPARATE lock from ``_ef_lock`` (the recovery path re-acquires
+        # ``_ef_lock`` while we hold this one): fixed order is ``_encode_lock``
+        # outer, ``_ef_lock`` inner, which cannot deadlock. NOTE: this lock is
+        # not FIFO-fair — do not turn it into a fairness queue without measuring.
+        self._encode_lock = threading.Lock()
 
     @classmethod
     def get(cls) -> LocalEmbedder:
@@ -96,11 +131,61 @@ class LocalEmbedder:
                 ``_TARGET_DIM`` (512) floats with the last 128 positions
                 zero-padded.
         """
-        ef = self._load()
         safe_inputs = [(text or "")[:_MAX_CHARS] for text in texts]
-        raw = ef(safe_inputs)
+        # Serialize the encode: the shared ONNX embedder is not thread-safe.
+        # ``_load()`` and ``_retry_embed_after_cache_clear()`` both acquire
+        # ``_ef_lock`` internally; running them under ``_encode_lock`` fixes the
+        # lock order (``_encode_lock`` outer) so recovery can never deadlock.
+        with self._encode_lock:
+            ef = self._load()
+            try:
+                raw = ef(safe_inputs)
+            except Exception as exc:  # noqa: BLE001 - Chroma raises varied cache errors.
+                raw = self._retry_embed_after_cache_clear(ef, exc, safe_inputs)
         return [_pad(vec) for vec in raw]
 
+    def _retry_embed_after_cache_clear(
+        self, failed_ef: Any, exc: Exception, safe_inputs: list[str]
+    ) -> Any:
+        with self._ef_lock:
+            if self._ef is not None and self._ef is not failed_ef:
+                return self._ef(safe_inputs)
+
+            embedding_cls = type(failed_ef)
+            recovery = _recoverable_minilm_cache(embedding_cls, exc)
+            if recovery is None:
+                raise exc
+            cache_path, cache_was_complete = recovery
+
+            with _exclusive_file_lock(_minilm_cache_lock_path(cache_path)):
+                if _should_clear_minilm_cache(
+                    embedding_cls, cache_path, exc, cache_was_complete
+                ):
+                    shutil.rmtree(cache_path, ignore_errors=True)
+                    recovery_action = "clearing"
+                    _LOGGER.warning(
+                        "Failed to use local MiniLM embedder; cleared cache %s "
+                        "and retrying once",
+                        cache_path,
+                        exc_info=True,
+                    )
+                else:
+                    recovery_action = "waiting for another process to refresh"
+                    _LOGGER.info(
+                        "MiniLM cache %s was refreshed by another process; retrying",
+                        cache_path,
+                    )
+                try:
+                    fresh_ef = embedding_cls()
+                    self._ef = fresh_ef
+                    return fresh_ef(safe_inputs)
+                except Exception as retry_exc:
+                    raise LocalEmbedderError(
+                        "Local MiniLM cache recovery failed after "
+                        f"{recovery_action} {cache_path}. Delete this cache "
+                        "directory, restart Reflexio, and retry local embedding."
+                    ) from retry_exc
+
 
 def _pad(vec: Any) -> list[float]:
     """Zero-pad a 384-dim vector to ``_TARGET_DIM`` as a plain list[float]."""
@@ -113,6 +198,118 @@ def _pad(vec: Any) -> list[float]:
     return floats + [0.0] * (_TARGET_DIM - len(floats))
 
 
+def _recoverable_minilm_cache(
+    embedding_cls: Any, exc: Exception
+) -> tuple[Path, bool] | None:
+    cache_path = _minilm_cache_path(embedding_cls)
+    if cache_path is None:
+        return None
+    cache_was_complete = _minilm_cache_complete(embedding_cls, cache_path)
+    if cache_was_complete and not _complete_minilm_cache_error_identifies_cache(
+        embedding_cls, cache_path, exc
+    ):
+        return None
+
+    return cache_path, cache_was_complete
+
+
+def _minilm_cache_path(embedding_cls: Any) -> Path | None:
+    download_path = getattr(embedding_cls, "DOWNLOAD_PATH", None)
+    if not download_path:
+        return None
+
+    model_name = getattr(embedding_cls, "MODEL_NAME", None)
+    cache_path = Path(str(download_path)).expanduser()
+    if not model_name or cache_path.name != model_name:
+        return None
+
+    return cache_path
+
+
+def _minilm_cache_lock_path(cache_path: Path) -> Path:
+    return cache_path.parent / f".{cache_path.name}.lock"
+
+
+@contextmanager
+def _exclusive_file_lock(lock_path: Path) -> Iterator[None]:
+    lock_path.parent.mkdir(parents=True, exist_ok=True)
+    with lock_path.open("a+b") as lock_file:
+        lock_file.seek(0)
+        if lock_file.read(1) == b"":
+            lock_file.write(b"\0")
+            lock_file.flush()
+        lock_file.seek(0)
+
+        if fcntl is not None:
+            fcntl.flock(lock_file.fileno(), fcntl.LOCK_EX)
+            try:
+                yield
+            finally:
+                fcntl.flock(lock_file.fileno(), fcntl.LOCK_UN)
+        elif msvcrt is not None:
+            msvcrt.locking(  # type: ignore[reportAttributeAccessIssue]
+                lock_file.fileno(),
+                msvcrt.LK_LOCK,  # type: ignore[reportAttributeAccessIssue]
+                1,
+            )
+            try:
+                yield
+            finally:
+                lock_file.seek(0)
+                msvcrt.locking(  # type: ignore[reportAttributeAccessIssue]
+                    lock_file.fileno(),
+                    msvcrt.LK_UNLCK,  # type: ignore[reportAttributeAccessIssue]
+                    1,
+                )
+        else:
+            yield
+
+
+def _should_clear_minilm_cache(
+    embedding_cls: Any, cache_path: Path, exc: Exception, cache_was_complete: bool
+) -> bool:
+    cache_is_complete = _minilm_cache_complete(embedding_cls, cache_path)
+    if not cache_is_complete:
+        return True
+
+    if not cache_was_complete:
+        return False
+
+    return _complete_minilm_cache_error_identifies_cache(embedding_cls, cache_path, exc)
+
+
+def _complete_minilm_cache_error_identifies_cache(
+    embedding_cls: Any, cache_path: Path, exc: Exception
+) -> bool:
+    chain = _exception_chain(exc)
+    archive_name = str(getattr(embedding_cls, "ARCHIVE_FILENAME", ""))
+    messages = "\n".join(str(chain_exc) for chain_exc in chain)
+    return (
+        str(cache_path) in messages
+        or bool(archive_name and archive_name in messages)
+        or "does not match expected SHA256" in messages
+    )
+
+
+def _minilm_cache_complete(embedding_cls: Any, cache_path: Path) -> bool:
+    extracted_folder = str(getattr(embedding_cls, "EXTRACTED_FOLDER_NAME", "onnx"))
+    return all(
+        (cache_path / extracted_folder / file_name).exists()
+        for file_name in _MINILM_EXPECTED_FILES
+    )
+
+
+def _exception_chain(exc: Exception) -> list[BaseException]:
+    chain: list[BaseException] = []
+    seen: set[int] = set()
+    current: BaseException | None = exc
+    while current is not None and id(current) not in seen:
+        seen.add(id(current))
+        chain.append(current)
+        current = current.__cause__ or current.__context__
+    return chain
+
+
 _REGISTERED = False
 
 

package/plugin/vendor/reflexio/reflexio/server/llm/providers/nomic_embedding_provider.py

@@ -63,12 +63,64 @@ _MAX_CHARS = 32_000
 _DEFAULT_ENCODE_BATCH_SIZE = 4
 _ENV_BATCH_SIZE = "REFLEXIO_EMBED_BATCH_SIZE"
 
+# D7 (Phase 2 prep): optionally pin torch intra-op thread count so the embedder
+# does not oversubscribe CPU under bounded concurrency. Unset (the default) =
+# leave torch untouched, i.e. zero behaviour change. Applies at Nomic model load
+# (both the in-process fallback and the shared daemon run NomicEmbedder). Note the
+# chromadb/minilm LocalEmbedder path uses onnxruntime, not torch, so this knob does
+# not affect it.
+_ENV_TORCH_THREADS = "REFLEXIO_EMBED_TORCH_THREADS"
+_torch_threads_pinned = False
+_torch_threads_lock = threading.Lock()
+
 
 def _encode_batch_size() -> int:
     """Resolve the encode mini-batch size from env, defaulting to 4."""
     return positive_int_env(_ENV_BATCH_SIZE, _DEFAULT_ENCODE_BATCH_SIZE, _LOGGER)
 
 
+def _maybe_pin_torch_threads() -> None:
+    """Pin torch intra-op threads to ``REFLEXIO_EMBED_TORCH_THREADS`` if set.
+
+    Dormant by default: when the env var is unset (or blank) this is a no-op and
+    ``torch.set_num_threads`` is never called, so torch keeps its default
+    autodetected thread count. When set to a positive int it is applied exactly
+    once per process (guarded against re-calling). A non-positive or non-integer
+    value is ignored with a warning.
+    """
+    global _torch_threads_pinned
+    if _torch_threads_pinned:
+        return
+    raw = os.environ.get(_ENV_TORCH_THREADS)
+    if not raw:
+        return
+    try:
+        n = int(raw)
+    except ValueError:
+        _LOGGER.warning(
+            "%s must be a positive integer; got %r — leaving torch threads at "
+            "their default.",
+            _ENV_TORCH_THREADS,
+            raw,
+        )
+        return
+    if n < 1:
+        _LOGGER.warning(
+            "%s must be >= 1; got %d — leaving torch threads at their default.",
+            _ENV_TORCH_THREADS,
+            n,
+        )
+        return
+    with _torch_threads_lock:
+        if _torch_threads_pinned:
+            return
+        import torch
+
+        torch.set_num_threads(n)
+        _torch_threads_pinned = True
+        _LOGGER.info("Pinned torch intra-op threads to %d (%s)", n, _ENV_TORCH_THREADS)
+
+
 class NomicEmbedderError(RuntimeError):
     """Raised when the Nomic embedder is requested but its deps are missing."""
 
@@ -118,6 +170,7 @@ class NomicEmbedder:
                     "sentence-transformers is required for the Nomic local "
                     "embedder. Install with `uv add sentence-transformers`."
                 ) from exc
+            _maybe_pin_torch_threads()
             _LOGGER.info(
                 "Loading Nomic embedding model %s — first call may download "
                 "~550 MB to %s",
@@ -157,15 +210,30 @@ class NomicEmbedder:
         """
         model = self._load()
         safe = [(t or "")[:_MAX_CHARS] for t in texts]
-        # show_progress_bar=False so server logs stay clean during ingest
-        # batches. convert_to_numpy=True returns a numpy ndarray; we slice
-        # and renormalise per-row before converting to plain Python lists.
-        raw = model.encode(
-            safe,
-            batch_size=_encode_batch_size(),
-            show_progress_bar=False,
-            convert_to_numpy=True,
-        )
+        # The sentence-transformers model is NOT thread-safe: nomic-bert's
+        # rotary-embedding code mutates instance attrs (``_cos_cached`` /
+        # ``_sin_cached``) on every forward pass, so two concurrent
+        # ``encode()`` calls on this shared singleton corrupt each other's
+        # buffers (observed in prod as "size of tensor a (N) must match tensor
+        # b (M)" and "'NoneType' object is not subscriptable"). Serialize the
+        # encode so every caller — daemon, in-process fallback, prewarm,
+        # regeneration — is safe by construction. ``_load()`` acquires and
+        # releases ``_model_lock`` and returns before we re-acquire it here, so
+        # there is no nesting/deadlock. NOTE: ``threading.Lock`` is not FIFO-fair
+        # — do not "improve" this into a fairness queue without measuring; the
+        # micro-batch coalescing in ``embedding_service`` is where throughput
+        # comes from, not parallel encodes on one model.
+        with self._model_lock:
+            # show_progress_bar=False so server logs stay clean during ingest
+            # batches. convert_to_numpy=True returns a numpy ndarray; we slice
+            # and renormalise per-row (below, outside the lock) before
+            # converting to plain Python lists.
+            raw = model.encode(
+                safe,
+                batch_size=_encode_batch_size(),
+                show_progress_bar=False,
+                convert_to_numpy=True,
+            )
         return [_truncate_and_renormalise(vec.tolist()) for vec in raw]
 
 

package/plugin/vendor/reflexio/reflexio/server/org_fanout.py

@@ -0,0 +1,184 @@
+"""Bounded parallel org iteration for org-walking daemon ticks.
+
+Replaces serial ``for org_id in org_ids`` loops in daemon ticks with a
+bounded per-tick thread pool (spec section 6.1). The pool is created per call
+and abandoned (not joined) at the end so a stuck org cannot eat a slot across
+ticks; stragglers finish in the background. Python cannot kill threads —
+"timeout" means stop waiting + log, and the caller escalates repeats.
+
+Each org's actual start/end time is tracked, so timeout classification is
+honest about queue-wait vs. run-time: an org that never got a worker before
+its wait elapsed is STARVED (not counted as a timeout, not retried); an org
+that has run for less than the budget gets one more wait for the remaining
+budget; only an org that has genuinely run for >= the budget is reported as
+timed out. Each future is waited on for at most ~2x the budget.
+
+Abandonment is per-tick, not process-wide: ``ThreadPoolExecutor`` worker
+threads are non-daemon, so CPython still joins ALL of them at interpreter
+exit — a forever-hung ``fn`` can block graceful process shutdown until the
+orchestrator's kill grace expires; ``shutdown(wait=False)`` here only frees
+the NEXT tick's capacity, not exit-time joining.
+
+Error isolation is the caller's contract: ``fn`` must catch its own per-org
+exceptions (LineageGC's sweep body already does); this helper only
+backstop-logs unexpected escapes.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections.abc import Callable, Iterable
+from concurrent.futures import Future, ThreadPoolExecutor
+from concurrent.futures import TimeoutError as FuturesTimeoutError
+
+logger = logging.getLogger(__name__)
+
+
+def iterate_orgs_bounded(
+    org_ids: Iterable[str],
+    fn: Callable[[str], None],
+    *,
+    max_workers: int,
+    per_org_timeout_seconds: float,
+    stop_event: threading.Event | None = None,
+) -> list[str]:
+    """Run ``fn(org_id)`` for each org with bounded concurrency and a per-org timeout.
+
+    Args:
+        org_ids (Iterable[str]): Orgs to process this tick.
+        fn (Callable[[str], None]): Per-org work body; must handle its own errors.
+        max_workers (int): Pool width; ``<= 1`` runs serially with no pool.
+        per_org_timeout_seconds (float): Run-time budget per org (not
+            queue-wait time). An org that never got a worker before its wait
+            elapsed is logged as ``event=org_sweep_starved`` and excluded
+            from the result (not timed out, not retried). An org that has
+            actually run for less than the budget is given one more wait for
+            the remaining budget; only once it has genuinely run for at
+            least the budget is it logged as ``event=org_sweep_timeout`` and
+            moved on (the straggler thread keeps running in the background).
+        stop_event (threading.Event | None): When set, stop submitting new
+            orgs; in-flight orgs finish (matches serial-loop shutdown semantics).
+
+    Returns:
+        list[str]: Org ids that genuinely timed out this call (ran for at
+        least the budget without finishing); starved orgs are excluded.
+        Callers track repeats across ticks and escalate.
+    """
+    timed_out: list[str] = []
+    if max_workers <= 1:
+        for org_id in org_ids:
+            if stop_event is not None and stop_event.is_set():
+                break
+            fn(org_id)
+        return timed_out
+
+    starts: dict[str, float] = {}
+    ends: dict[str, float] = {}
+    record_lock = threading.Lock()
+
+    def _tracked(org_id: str) -> None:
+        with record_lock:
+            starts[org_id] = time.monotonic()
+        try:
+            fn(org_id)
+        finally:
+            with record_lock:
+                ends[org_id] = time.monotonic()
+
+    executor = ThreadPoolExecutor(
+        max_workers=max_workers, thread_name_prefix="org-fanout"
+    )
+    futures: list[tuple[str, Future[None]]] = []
+    try:
+        for org_id in org_ids:
+            if stop_event is not None and stop_event.is_set():
+                break
+            futures.append((org_id, executor.submit(_tracked, org_id)))
+        for org_id, future in futures:
+            if _wait_for_org(
+                org_id,
+                future,
+                per_org_timeout_seconds=per_org_timeout_seconds,
+                starts=starts,
+                ends=ends,
+                lock=record_lock,
+            ):
+                timed_out.append(org_id)
+    finally:
+        # Per-tick pool, abandoned not joined (spec 6.1): stragglers finish in
+        # the background; the NEXT tick gets a fresh pool and full width.
+        executor.shutdown(wait=False)
+    return timed_out
+
+
+def _wait_for_org(
+    org_id: str,
+    future: Future[None],
+    *,
+    per_org_timeout_seconds: float,
+    starts: dict[str, float],
+    ends: dict[str, float],
+    lock: threading.Lock,
+) -> bool:
+    """Wait for one org's future; return True iff it genuinely timed out.
+
+    Classifies a ``FuturesTimeoutError`` honestly instead of treating
+    queue-wait as run time: an org with no recorded start never got a
+    worker (STARVED — logged, not counted as a timeout, no further wait); an
+    org that has run for less than the budget gets one more wait for the
+    remaining budget. Total wait per org is bounded to ~2x the budget.
+
+    Args:
+        org_id (str): The org this future belongs to.
+        future (Future[None]): The submitted future for ``org_id``.
+        per_org_timeout_seconds (float): The run-time budget for this org.
+        starts (dict[str, float]): Monotonic start times, keyed by org id.
+        ends (dict[str, float]): Monotonic end times, keyed by org id.
+        lock (threading.Lock): Guards ``starts``/``ends``.
+
+    Returns:
+        bool: True if the org genuinely timed out (ran >= the budget without
+        finishing); False if it completed, was starved, or raised an
+        unexpected error.
+    """
+    try:
+        future.result(timeout=per_org_timeout_seconds)
+        return False
+    except FuturesTimeoutError:
+        pass
+    except Exception:
+        # fn owns error isolation; anything escaping is a bug — log, never
+        # let one org's escape skip the remaining result waits.
+        logger.exception("event=org_fanout_unexpected_error org_id=%s", org_id)
+        return False
+
+    with lock:
+        start = starts.get(org_id)
+        finished = org_id in ends
+    if finished:
+        # Completed between the timeout firing and this check — not a timeout.
+        return False
+    if start is None:
+        logger.warning("event=org_sweep_starved org_id=%s", org_id)
+        return False
+
+    elapsed_running = time.monotonic() - start
+    remaining = per_org_timeout_seconds - elapsed_running
+    if remaining > 0:
+        try:
+            future.result(timeout=remaining)
+            return False
+        except FuturesTimeoutError:
+            pass
+        except Exception:
+            logger.exception("event=org_fanout_unexpected_error org_id=%s", org_id)
+            return False
+
+    logger.warning(
+        "event=org_sweep_timeout org_id=%s timeout_seconds=%s",
+        org_id,
+        per_org_timeout_seconds,
+    )
+    return True

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/document_expansion/v1.0.0.prompt.md

@@ -1,5 +1,5 @@
 ---
-active: true
+active: false
 description: "Extracts key terms and generates synonyms for document FTS expansion"
 variables:
   - content

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/document_expansion/v1.1.0.prompt.md

@@ -0,0 +1,32 @@
+---
+active: true
+description: "Extracts key terms, synonyms, and fact-key phrasings for document FTS expansion"
+changelog: "v1.1.0: also emit fact-key phrasings — (attribute: value) paraphrases and category names for brands/tools/proper nouns — so paraphrased queries hit via FTS"
+variables:
+  - content
+---
+Given this document content, produce expansion terms that make the document findable by paraphrased searches. Output valid JSON only, nothing else — a single object mapping each key concept to 2-4 related search phrasings.
+
+Include BOTH kinds of expansion:
+1. Synonyms / closely related terms for each key concept.
+2. Fact-key phrasings: when the content states a fact (subject-attribute-value), add the attribute/category words a person would search with. In particular, map brands, products, tools, and proper nouns to their CATEGORY ("Coke" → "soda", "soft drink"; "Alembic" → "database migration tool"; "Thrive Market" → "grocery service").
+
+Example:
+Input: "User always orders Coke at restaurants"
+Output:
+{{
+  "Coke": ["soda", "soft drink", "beverage"],
+  "orders at restaurants": ["drink preference", "dining habit"]
+}}
+
+Example:
+Input: "User reports backup failure with S3 timeout on large datasets"
+Output:
+{{
+  "backup": ["sync", "replication", "data backup"],
+  "failure": ["error", "crash", "issue"],
+  "S3": ["cloud storage", "AWS", "object storage"],
+  "timeout": ["latency", "delay", "slow response"]
+}}
+
+Content: {content}

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_consolidation/v2.3.3.prompt.md

@@ -1,5 +1,5 @@
 ---
-active: true
+active: false
 description: "Reconcile newly-extracted playbooks against existing storage. Decides per-candidate whether each one unifies with one-or-more existing rows (growing a coherent multi-rule skill, mixed do/avoid rules allowed), is rejected as redundant against an existing row, should differentiate (refine both triggers), or is independent."
 changelog: "v2.3.3: adds antecedent-not-reaction trigger guidance for unified and differentiated triggers. (in-place 2026-06-15: adds concise anti-overmerge guard for concrete operational surfaces; restates the numeric id fields (`superseded_by_existing_id`, `existing_id`, `archive_existing_ids`) as EXISTING list-position integers — e.g. emit `0` for `[EXISTING-0]` — superseding the prior 'bare DB id, labels never valid' framing.) v2.3.2: tightens schema guidance for integer id fields and compact unify content; forbids display-label strings in numeric fields. v2.3.1: replaces schema example-style output prompting with compact format guidance for the four decision shapes. v2.3.0: `unify` now COMPOSES — it may grow a broader multi-rule skill from coherent related fragments (related sub-aspects of one task), not only same-trigger duplicates. A skill MAY hold mixed-polarity rules (do-rules and avoid-rules for different sub-aspects). Replaced the mechanical single-orientation/same-polarity contract with an LLM-judged no-self-contradiction guard: do NOT unify if combining the rules would make the skill contradict itself on the same situation (same trigger/condition with opposite advice) — route those to `differentiate` or `reject_new`. Re-synthesis (fewest/most-general rules, preserve avoid-detail) and the over-budget `differentiate` preference are unchanged. v2.2.0: `unify` re-synthesizes leaner, more general content (MDL / simplify-in-place) instead of concatenating — fewest, most general rules that still cover all inputs; drop redundant/subsumed wording. Asymmetric fidelity: compress/generalize success guidance, but preserve every distinct avoidance/failure detail verbatim — never soften a named pitfall into a vague platitude. Prefer `differentiate` over `unify` when merging would force an over-long, low-cohesion rule. v2.1.0: `unify` no longer emits a `polarity` field — the unified row's orientation is derived from its wording (recommendation vs avoidance) by the apply-path polarity validator. Same-trigger opposite-orientation rules still must not unify; express orientation through the rule wording. v2.0.0: collapsed 5-kind union → 4-kind. `unify` subsumes `duplicate`+`prefer_new`; `reject_new` replaces `prefer_existing`. Output schema is structurally incompatible with v1.x."
 variables:

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/playbook_consolidation/v2.4.0.prompt.md

@@ -0,0 +1,63 @@
+---
+active: true
+description: "Reconcile newly-extracted playbooks against existing storage. Decides per-candidate whether each one unifies with one-or-more existing rows (growing a coherent multi-rule skill, mixed do/avoid rules allowed), is rejected as redundant against an existing row, should differentiate (refine both triggers), or is independent."
+changelog: "v2.4.0: makes the NEW-id partition contract explicit. Decisions must cover every NEW id exactly once; multi-NEW unify/reject_new/independent decisions may list multiple NEW labels when one decision consumes multiple rows, and archive_existing_ids is clarified as EXISTING-only. Body also tightened ~45% (deduplicated the partition contract and no-self-contradiction statements; compressed the kind definitions, unify-writing rules, and output guidance) with no behavioral rule removed. v2.3.3: adds antecedent-not-reaction trigger guidance for unified and differentiated triggers. (in-place 2026-06-15: adds concise anti-overmerge guard for concrete operational surfaces; restates the numeric id fields (`superseded_by_existing_id`, `existing_id`, `archive_existing_ids`) as EXISTING list-position integers — e.g. emit `0` for `[EXISTING-0]` — superseding the prior 'bare DB id, labels never valid' framing.) v2.3.2: tightens schema guidance for integer id fields and compact unify content; forbids display-label strings in numeric fields. v2.3.1: replaces schema example-style output prompting with compact format guidance for the four decision shapes. v2.3.0: `unify` now COMPOSES — it may grow a broader multi-rule skill from coherent related fragments (related sub-aspects of one task), not only same-trigger duplicates. A skill MAY hold mixed-polarity rules (do-rules and avoid-rules for different sub-aspects). Replaced the mechanical single-orientation/same-polarity contract with an LLM-judged no-self-contradiction guard: do NOT unify if combining the rules would make the skill contradict itself on the same situation (same trigger/condition with opposite advice) — route those to `differentiate` or `reject_new`. Re-synthesis (fewest/most-general rules, preserve avoid-detail) and the over-budget `differentiate` preference are unchanged. v2.2.0: `unify` re-synthesizes leaner, more general content (MDL / simplify-in-place) instead of concatenating — fewest, most general rules that still cover all inputs; drop redundant/subsumed wording. Asymmetric fidelity: compress/generalize success guidance, but preserve every distinct avoidance/failure detail verbatim — never soften a named pitfall into a vague platitude. Prefer `differentiate` over `unify` when merging would force an over-long, low-cohesion rule. v2.1.0: `unify` no longer emits a `polarity` field — the unified row's orientation is derived from its wording (recommendation vs avoidance) by the apply-path polarity validator. Same-trigger opposite-orientation rules still must not unify; express orientation through the rule wording. v2.0.0: collapsed 5-kind union → 4-kind. `unify` subsumes `duplicate`+`prefer_new`; `reject_new` replaces `prefer_existing`. Output schema is structurally incompatible with v1.x."
+variables:
+  - new_playbook_count
+  - new_playbooks
+  - existing_playbooks
+---
+You are reconciling newly-extracted playbooks against the related existing playbook rows already in storage. Decide each new candidate's relationship to the existing rows.
+
+Each rendered row carries `Content`, `Trigger`, `Rationale`, `Name`, `Source`, and `Last Modified`. Read a rule's orientation (do-this vs avoid-this) from its `Content`/`Rationale` wording; differing orientation alone is not a reason to avoid merging. Compare rules primarily by `Trigger` plus the actual situation each rule addresses.
+
+Write every final `trigger`, `refined_new_trigger`, and `refined_existing_trigger` as the antecedent situation where a future agent can act before the mistake recurs, not as the user's later repair request — e.g. "When editing one AWS deployment doc for an env-var/secret/port change", not "When syncing two AWS deployment docs."
+
+[New playbooks (count: {new_playbook_count})]
+{new_playbooks}
+
+[Existing related playbooks]
+{existing_playbooks}
+
+# Decision kinds
+
+Your decisions must cover every NEW id exactly once: each rendered NEW label appears in exactly one decision, and one decision may consume several NEW rows when that reflects the final outcome.
+
+- **unify** — the NEW belongs in the same skill as one or more EXISTING rows: either dedup/supersede (same rule, or stronger/broader/more specific evidence) or compose (a related sub-aspect of the same task grows a broader multi-rule skill instead of forcing `reject_new`/`independent`). Provide the final `content`, `trigger`, and `rationale`. `archive_existing_ids` only refers to rows from the EXISTING list; it never consumes NEW rows (use an empty list when none are absorbed). If the unified rule uses facts or details from more than one NEW row, `new_id` MUST list all of those labels, e.g. `"new_id": ["NEW-0", "NEW-1"]`. A skill MAY hold mixed do/avoid rules for **different** sub-aspects of the one task; only unify fragments that genuinely share the same task scope.
+
+- **reject_new** — an EXISTING row already covers NEW or makes it redundant. Name the winner's list position via `superseded_by_existing_id` (for `[EXISTING-0]`, emit `0`).
+
+- **differentiate** — both rules are valid in distinct contexts (typically same trigger, opposite advice, differing contexts). Set `refined_new_trigger` and `refined_existing_trigger` strictly narrower than the originals AND mutually exclusive. Handles exactly one NEW row.
+
+- **independent** — different topic or task from every existing row; insert NEW as-is, no archive.
+
+`new_id` may be a list for `unify`, `reject_new`, and `independent` when one decision intentionally consumes several NEW rows. Example multi-NEW unify (the final rule uses details from both NEW rows, so both labels are consumed by the one decision):
+
+```json
+{{"decisions": [{{"kind": "unify", "new_id": ["NEW-0", "NEW-1"], "archive_existing_ids": [], "content": "<merged rule>", "trigger": "<antecedent situation>", "rationale": "<why both rows merged>"}}]}}
+```
+
+# How to write a unified skill (re-synthesis, not concatenation)
+
+- Produce the fewest, most general rules that still cover all the inputs; drop redundant or subsumed wording. Keep each rule a clean, self-contained do-rule or avoid-rule for its own sub-aspect — do not blur distinct rules into one.
+- Asymmetric fidelity: compress and generalize the success guidance, but preserve every distinct avoidance/failure detail in its specific form — never collapse a named pitfall, concrete error, or specific anti-pattern into a vague platitude.
+- Preserve concrete operational surfaces (target groups, SGs, health checks, task defs); do not merge fanout rules into generic sweep/audit rules unless those surfaces remain explicit.
+- Keep the final `content` compact enough to store directly. Prefer `differentiate` (or `independent`) over `unify` when merging would force an over-long, low-cohesion skill or lose distinct failure detail — two focused rules beat one bloated skill.
+
+# Hard constraints
+
+- No self-contradiction: a skill must never hold opposite advice for the SAME situation (same trigger/condition). Mixed do/avoid rules for different sub-aspects are fine and expected. A NEW + EXISTING pair with same-situation opposite advice MUST route to `differentiate` or `reject_new` — never `unify`, never `independent`. When such a stalemate is balanced, default to `reject_new`; storage stability wins ties.
+- `differentiate.refined_new_trigger` and `refined_existing_trigger` MUST be non-empty and strictly narrower than the originals.
+- Numeric id fields MUST contain bare EXISTING list-position integers (for `[EXISTING-3]`, emit `3`), never bracketed labels or label strings.
+- Every NEW label MUST appear exactly once across the full `decisions` array. If one decision consumes several NEW rows, put those labels in that decision's `new_id` list and do not emit separate decisions for them.
+
+# Output format
+
+Respond ONLY with a valid JSON object matching `PlaybookConsolidationOutput`: `{{"decisions": [<decision objects that together cover every NEW id exactly once>]}}`. Every decision includes `kind` and `new_id` (a NEW label string, or a list of labels for multi-NEW `unify`/`reject_new`/`independent`); an optional `reason` may explain any decision.
+
+- `unify`: `archive_existing_ids` (list of EXISTING position integers) plus final compact `content`, `trigger`, and `rationale`.
+- `reject_new`: `superseded_by_existing_id` (EXISTING position integer).
+- `differentiate`: `existing_id` (EXISTING position integer) plus non-empty `refined_new_trigger` and `refined_existing_trigger`.
+- `independent`: only `kind` and `new_id`.
+
+Do not emit markdown, prose, comments, chain-of-thought, or top-level keys other than `decisions`. Do not include fields from another decision kind.

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/query_reformulation/v1.0.0.prompt.md

@@ -1,5 +1,5 @@
 ---
-active: true
+active: false
 description: "Reformulates a user search query into clean, standalone natural language"
 variables:
   - query