claude-smart 0.2.42 → 0.2.44

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

@@ -0,0 +1,179 @@
+"""Process-local concurrency limiters for latency-sensitive operations."""
+
+from __future__ import annotations
+
+import os
+import threading
+import time
+from collections.abc import Callable
+from contextlib import contextmanager
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from fastapi import HTTPException, status
+
+from reflexio.server.usage_metrics import record_usage_event
+
+OperationName = Literal["search", "publish", "aggregation"]
+
+_DEFAULT_LIMITS: dict[OperationName, int] = {
+    "search": 8,
+    "publish": 4,
+    "aggregation": 1,
+}
+_DEFAULT_TIMEOUT_SECONDS: dict[OperationName, float] = {
+    "search": 2.0,
+    "publish": 5.0,
+    "aggregation": 1.0,
+}
+
+
+@dataclass
+class _LimiterState:
+    semaphore: threading.BoundedSemaphore
+    limit: int
+    waiting: int = 0
+
+
+_limiters: dict[tuple[str, OperationName], _LimiterState] = {}
+_limiters_lock = threading.Lock()
+
+
+def _env_key(operation: OperationName, suffix: str) -> str:
+    return f"REFLEXIO_{operation.upper()}_CONCURRENCY_{suffix}"
+
+
+def _limit_for(operation: OperationName) -> int:
+    raw = os.getenv(_env_key(operation, "LIMIT"), "").strip()
+    if raw.isdigit():
+        return max(1, int(raw))
+    return _DEFAULT_LIMITS[operation]
+
+
+def _timeout_for(operation: OperationName) -> float:
+    raw = os.getenv(_env_key(operation, "TIMEOUT_SECONDS"), "").strip()
+    if raw:
+        try:
+            return max(0.0, float(raw))
+        except ValueError:
+            pass
+    return _DEFAULT_TIMEOUT_SECONDS[operation]
+
+
+def _state_for(org_id: str, operation: OperationName) -> _LimiterState:
+    key = (str(org_id), operation)
+    desired_limit = _limit_for(operation)
+    with _limiters_lock:
+        state = _limiters.get(key)
+        if state is None or state.limit != desired_limit:
+            state = _LimiterState(
+                semaphore=threading.BoundedSemaphore(desired_limit),
+                limit=desired_limit,
+            )
+            _limiters[key] = state
+        return state
+
+
+def _record_limiter_event(
+    *,
+    org_id: str,
+    operation: OperationName,
+    event_name: str,
+    outcome: str,
+    wait_ms: int,
+    waiting: int,
+    limit: int,
+) -> None:
+    record_usage_event(
+        org_id=org_id,
+        event_name=event_name,
+        event_category="limiter",
+        pipeline=operation,
+        outcome=outcome,
+        duration_ms=wait_ms,
+        metadata={
+            "operation": operation,
+            "waiting": waiting,
+            "limit": limit,
+        },
+    )
+
+
+@contextmanager
+def operation_limit(
+    org_id: str,
+    operation: OperationName,
+    *,
+    timeout_seconds: float | None = None,
+) -> Any:
+    """Acquire the per-org limiter for an operation, recording wait metrics."""
+    state = _state_for(org_id, operation)
+    timeout = _timeout_for(operation) if timeout_seconds is None else timeout_seconds
+    start = time.perf_counter()
+    with _limiters_lock:
+        state.waiting += 1
+        waiting = state.waiting
+    acquired = False
+    try:
+        acquired = state.semaphore.acquire(timeout=timeout)
+        wait_ms = int((time.perf_counter() - start) * 1000)
+        with _limiters_lock:
+            state.waiting -= 1
+            waiting_after = state.waiting
+        if not acquired:
+            _record_limiter_event(
+                org_id=org_id,
+                operation=operation,
+                event_name="limiter_acquire_timeout",
+                outcome="timeout",
+                wait_ms=wait_ms,
+                waiting=waiting_after,
+                limit=state.limit,
+            )
+            raise TimeoutError(
+                f"{operation} concurrency limit reached for org {org_id}"
+            )
+        _record_limiter_event(
+            org_id=org_id,
+            operation=operation,
+            event_name="limiter_acquired",
+            outcome="acquired",
+            wait_ms=wait_ms,
+            waiting=waiting,
+            limit=state.limit,
+        )
+        yield
+    finally:
+        if acquired:
+            state.semaphore.release()
+
+
+def run_with_operation_limit[T](
+    *,
+    org_id: str,
+    operation: OperationName,
+    fn: Callable[[], T],
+    timeout_seconds: float | None = None,
+) -> T:
+    with operation_limit(org_id, operation, timeout_seconds=timeout_seconds):
+        return fn()
+
+
+def limiter_http_exception(operation: OperationName) -> HTTPException:
+    """Return the API error used when an operation limiter is saturated."""
+    retry_after = str(max(1, int(_timeout_for(operation))))
+    status_code = (
+        status.HTTP_429_TOO_MANY_REQUESTS
+        if operation == "search"
+        else status.HTTP_503_SERVICE_UNAVAILABLE
+    )
+    return HTTPException(
+        status_code=status_code,
+        detail=f"{operation} concurrency limit reached",
+        headers={"Retry-After": retry_after},
+    )
+
+
+def reset_operation_limiters_for_tests() -> None:
+    with _limiters_lock:
+        _limiters.clear()

package/plugin/vendor/reflexio/reflexio/server/prompt/_dispatchers.py

@@ -0,0 +1,54 @@
+"""Heuristic question-shape classifiers for conditional prompt rendering.
+
+The search-agent prompt is split: the main prompt covers Patterns A-H dispatch
+plus all pattern recipes EXCEPT Pattern D. Pattern D's recipe lives in a
+separate prompt file and is appended only when the question is classified as
+list-shape. This isolation prevents Pattern D rule changes from bleeding into
+non-list questions (the dominant regression mode in v1.20.0/v1.21.0/v1.22.0/
+v1.23.0 search iterations).
+
+False negatives fall through to Pattern A behaviour (safe default — the
+main prompt's dispatch test still routes the agent to the correct pattern).
+False positives are tolerable: Pattern D recipe in context but the agent's
+own dispatch test still picks the right pattern.
+"""
+
+from __future__ import annotations
+
+import re
+
+# Patterns that signal list/enumeration shape.
+# Order matters only for early-exit; any match returns True.
+_LIST_PATTERNS: tuple[re.Pattern[str], ...] = (
+    # "Which sports", "what books", "which TV series", "which fantasy novels"
+    # — plural noun (≥4 chars to avoid matching short verbs like "is", "was",
+    # "does"), optionally preceded by up to 2 intermediate words (adjectives /
+    # short qualifiers like "TV", "other").
+    re.compile(r"\b(which|what)\s+(?:\w+\s+){0,2}\w{3,}s\b", re.IGNORECASE),
+    # Counting / total / list-all operators
+    re.compile(
+        r"\b(how many|how much|total|list (all|every)|all the|every|count)\b",
+        re.IGNORECASE,
+    ),
+    # Exclusion-shaped lists ("besides X", "other than Y", "not Z-related")
+    re.compile(r"\b(besides|other than)\b", re.IGNORECASE),
+    # "What other places", "what other movies"
+    re.compile(r"\bother\s+\w+s?\b", re.IGNORECASE),
+    # Superlatives over a category
+    re.compile(r"\b(most|least|highest|lowest|best|worst)\s+\w+", re.IGNORECASE),
+)
+
+
+def is_pattern_d_question(query: str) -> bool:
+    """Return True when the question's shape suggests Pattern D (list/aggregation).
+
+    Args:
+        query (str): The user question text.
+
+    Returns:
+        bool: True if any list/enumeration heuristic matches; False otherwise.
+    """
+    return any(p.search(query) for p in _LIST_PATTERNS)
+
+
+__all__ = ["is_pattern_d_question"]

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/README.md

@@ -0,0 +1,121 @@
+# prompt_bank
+
+File-based versioned prompt templates for LLM operations.
+
+> Part of the [Reflexio Server](../../README.md). See also the [Playbook Service](../../services/playbook/README.md) for prompt usage in playbook extraction.
+
+## Main Entry Points
+
+- **Manager**: `../prompt_manager.py` — `PromptManager`
+- **Templates**: Each subdirectory is a `prompt_id`
+
+## Directory Structure
+
+```
+prompt_bank/
+├── README.md
+├── playbook_aggregation/
+│   ├── v1.0.0.prompt.md
+│   ├── v1.1.0.prompt.md
+│   └── v2.1.0.prompt.md      ← active: true in frontmatter
+├── query_reformulation/
+│   └── v1.0.0.prompt.md      ← active: true (only version)
+└── ...
+```
+
+## File Format
+
+Each `.prompt.md` file is self-contained with YAML frontmatter:
+
+```markdown
+---
+active: true
+description: "What this prompt does"
+changelog: "Why this version was created"
+variables:
+  - var1
+  - var2
+---
+
+Your prompt content with {var1} and {var2} placeholders.
+```
+
+### Frontmatter Fields
+
+| Field | Type | Required | Purpose |
+|-------|------|----------|---------|
+| `active` | bool | No | `true` on the active version. Exactly one per prompt_id |
+| `description` | string | No | What this prompt does. Include on all versions for context |
+| `changelog` | string | No | Why this version was created — what changed from the previous version |
+| `variables` | list[str] | Yes | Required template variables for validation |
+
+## Usage
+
+```python
+# Access via request_context
+rendered = request_context.prompt_manager.render_prompt(
+    "profile_update_main",
+    {"variable1": "value1", "variable2": "value2"}
+)
+```
+
+## Adding a New Prompt
+
+1. Create directory: `mkdir prompt_bank/my_new_prompt/`
+2. Create `v1.0.0.prompt.md` with frontmatter and `{variable}` placeholders
+3. Set `active: true` in frontmatter
+
+## Version Naming Convention
+
+File names: `v{MAJOR}.{MINOR}.{PATCH}.prompt.md`
+
+- **MAJOR**: Breaking changes that introduce a different set of variables
+- **MINOR**: Significant updates without changing variables
+- **PATCH**: Minor tweaks to prompt content
+
+## Deactivating a Prompt Version
+
+When creating a replacement version, deactivate the old version by **removing** the `active: true` line from its frontmatter. Do NOT add `active: false` — simply omit the field. Prompts without the `active` field default to `active: false` (see `prompt_manager.py` line 211: `meta.get("active", False)`). Only the new replacement version should have `active: true`.
+
+**Before** (old version `v1.0.0.prompt.md`):
+```yaml
+---
+active: true
+description: "Original prompt"
+variables:
+  - var1
+---
+```
+
+**After** (old version `v1.0.0.prompt.md` — `active` line removed):
+```yaml
+---
+description: "Original prompt"
+variables:
+  - var1
+---
+```
+
+**New version** (`v2.0.0.prompt.md`):
+```yaml
+---
+active: true
+description: "Improved prompt"
+changelog: "Replaced v1.0.0 with better instructions"
+variables:
+  - var1
+---
+```
+
+## Key Rules
+
+- **Prompt ID** = Directory name
+- **Variables** use `{variable_name}` syntax in prompt body
+- **Exactly one** version per prompt must have `active: true`
+- **Deactivate old versions** by removing the `active: true` line — never add `active: false`
+- **NEVER hardcode prompts** — always use `PromptManager`
+
+## See Also
+
+- [Server README](../../README.md) -- FastAPI backend component overview
+- [Playbook Service README](../../services/playbook/README.md) -- how prompts are used in playbook extraction and aggregation

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

@@ -0,0 +1,58 @@
+---
+active: true
+description: "Evaluates agent success based on user interactions"
+variables:
+  - agent_context_prompt
+  - success_definition_prompt
+  - tool_can_use
+  - metadata_definition_prompt
+  - interactions
+---
+
+[Instruction]
+Given the interactions above, evaluate if the agent has successfully completed the user's primary requested task by the end of the session, based on the success definition below.
+The agent may make mistakes or take wrong actions during the session. The user may provide corrections or ask the agent to try differently. These mid-session errors do NOT constitute failure — focus on the final outcome. As long as the user's primary task is completed successfully by the end of the session, set is_success to True.
+Step 1: Identify the user's primary task from the interactions. Then determine if the agent has fulfilled this task by the end of the session based on the success definition. If so, return with is_success equals to True, else set is_success to False and continue to next step.
+Step 2: If the agent did not complete the primary task by the end of the session, determine what is the failure type and failure reason.
+There are four types of failures:
+- 'missing_tool': Agent does not have the right tool or action that it can take to get the sufficient information to answer user's request.
+- 'wrong_tool': Tools or actions are available, but agent should use the right tool or performed the right action.
+- 'insufficient_info_from_tool': Agent has performed the right action and tool use, but the tool or action does not have enough/right information to successfully answer user's request
+- 'wrong_answer': Agent has enough information but still didn't successfully answer user's request
+Step 3: Determine if the user was escalated (handed off to a human agent or another agent). Set is_escalated to True if so, False otherwise. Escalation typically means the agent could not resolve the issue itself. Note: escalated sessions are likely unsuccessful, but unsuccessful sessions are not necessarily escalated.
+
+[Context]
+{agent_context_prompt}
+
+[Success definition]
+{success_definition_prompt}
+
+[Interactions]
+User and agent interactions:
+{interactions}
+
+[Tools]
+{tool_can_use}
+
+[Metadata Definition]
+{metadata_definition_prompt}
+
+[Output]
+Generate the output in valid JSON format using the following schema
+# success case example
+```json
+{{
+    "is_success": true,
+    "is_escalated": false
+}}
+```
+
+# failure case example
+```json
+{{
+    "is_success": false,
+    "failure_type": "missing_tool" or "wrong_tool" or "insufficient_info_from_tool" or "wrong_answer",
+    "failure_reason": "explain reason for failure, what agent need to do differently",
+    "is_escalated": true
+}}
+```

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

@@ -0,0 +1,76 @@
+---
+active: false
+description: "DEPRECATED — session-level shadow comparison combined prompt (F1 cleanup). The session-level approach suffers from trajectory contamination: user turns 2+ react to the regular response, not the shadow, so the two trajectories are not apples-to-apples. Replaced by the per-turn shadow_comparison prompt. Kept as a historical record so any v1.0.0 verdicts produced under this prompt can still be located in audit logs."
+variables:
+  - agent_context_prompt
+  - success_definition_prompt
+  - request_1_interactions
+  - request_2_interactions
+  - tool_can_use
+  - metadata_definition_prompt
+---
+
+[Instruction]
+You have two versions of an agent-user interaction: Request 1 and Request 2.
+Perform two tasks:
+Task 1: Evaluate if the Request 1 agent has successfully responded to the user based on the success definition below.
+Task 2: Compare Request 1 and Request 2 to determine which better satisfies the success definition.
+
+For Task 1 (evaluate Request 1):
+Evaluate if the agent has successfully completed the user's primary requested task by the end of the session.
+The agent may make mistakes or take wrong actions during the session. The user may provide corrections or ask the agent to try differently. These mid-session errors do NOT constitute failure — focus on the final outcome. As long as the user's primary task is completed successfully by the end of the session, set is_success to True.
+Step 1: Identify the user's primary task from the interactions. Then determine if the agent has fulfilled this task by the end of the session based on the success definition. If so, return with is_success equals to True, else set is_success to False and continue to next step.
+Step 2: If the agent did not complete the primary task by the end of the session, determine what is the failure type and failure reason.
+There are four types of failures:
+- 'missing_tool': Agent does not have the right tool or action that it can take to get the sufficient information to answer user's request.
+- 'wrong_tool': Tools or actions are available, but agent should use the right tool or performed the right action.
+- 'insufficient_info_from_tool': Agent has performed the right action and tool use, but the tool or action does not have enough/right information to successfully answer user's request
+- 'wrong_answer': Agent has enough information but still didn't successfully answer user's request
+Step 3: Determine if the user was escalated (handed off to a human agent or another agent). Set is_escalated to True if so, False otherwise. Escalation typically means the agent could not resolve the issue itself. Note: escalated sessions are likely unsuccessful, but unsuccessful sessions are not necessarily escalated.
+
+For Task 2 (compare Request 1 vs Request 2):
+Determine which request better satisfies the success definition and whether the difference is significant.
+
+[Context]
+{agent_context_prompt}
+
+[Success definition]
+{success_definition_prompt}
+
+[Request 1]
+{request_1_interactions}
+
+[Request 2]
+{request_2_interactions}
+
+[Tools]
+{tool_can_use}
+
+[Metadata Definition]
+{metadata_definition_prompt}
+
+[Output]
+Generate the output in valid JSON format using the following schema:
+# Task 1 success case:
+```json
+{{
+    "is_success": true,
+    "is_escalated": false,
+    "better_request": "1" or "2" or "tie",
+    "is_significantly_better": true or false,
+    "comparison_reason": "brief explanation"
+}}
+```
+
+# Task 1 failure case:
+```json
+{{
+    "is_success": false,
+    "failure_type": "missing_tool" or "wrong_tool" or "insufficient_info_from_tool" or "wrong_answer",
+    "failure_reason": "explain reason for failure, what agent need to do differently",
+    "is_escalated": true,
+    "better_request": "1" or "2" or "tie",
+    "is_significantly_better": true or false,
+    "comparison_reason": "brief explanation"
+}}
+```

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/answer_synthesis/v1.5.2.prompt.md

@@ -0,0 +1,88 @@
+---
+active: true
+description: "Answer-LLM system prompt for memory-grounded user questions. Triages retrieved profiles into direct-answer / preference / arithmetic categories, applies counting / date / instance-disambiguation rules, and cites profile_ids as Sources."
+variables: []
+---
+You are an AI assistant answering questions about a user based on their past conversations. The context below contains:
+
+1. **Retrieved Memories** — extracted profiles (`[profile_id]`-tagged); facts about the user.
+2. **Original Session Excerpts** (when present) — verbatim transcripts of the most relevant past conversations. Excerpts include BOTH user and assistant turns, so they're the authoritative source when the question asks what YOU previously told the user (e.g. "remind me what you said about X", "what did you recommend for Y"). Profiles often miss assistant statements. When you find the answer in an excerpt, still cite the matching profile_ids in `Sources:` (the excerpt itself has no id).
+
+Reasoning template — apply to EVERY question before answering:
+
+1. Triage the retrieved profiles:
+   a. Profiles that DIRECTLY answer the question (a fact whose subject and predicate match what's being asked).
+   b. Profiles carrying GENERALIZABLE preferences or lifestyle context that could shape an answer (preferences from a past conversation that apply to a new query — e.g., a stored preference about hotel features that can inform a hotel question in a new city; a stored lifestyle constraint that informs a recommendation; a stored role/domain that shapes what's relevant).
+   c. Profiles whose DATES OR COUNTS matter for arithmetic (date subtraction, item counting, recency comparison).
+
+2. Compose the answer:
+   - If category (a) is non-empty, the question is direct recall; answer using the matching profile and cite its profile_id.
+   - If (a) is empty but (b) suggests a tailored answer, apply the preferences and answer. Do NOT refuse just because the specific entity (city, venue, time, person) wasn't mentioned before — generalize the preference, not the entity.
+   - If (c) provides values for arithmetic, compute and show the work.
+
+3. **Do not say "I don't have X" without first using everything available.** Refusal is a last resort, not a default. Before declaring absence:
+   - Check whether ANY retrieved profile names the topic. If yes, your answer should describe what the profiles DO say and surface what's missing concretely. The user can use partial information; a flat refusal forfeits it.
+   - For questions asking the assistant to recall a previous answer ("what did you tell me about X", "remind me of that recommendation"), search retrieved profiles for any phrasing that credits an agent statement (`agent recommended`, `agent said`, `agent described`). The relevant atom may be in a profile that doesn't share keywords with the question's specific noun. If no profile has the literal answer, describe the closest related context the user gave you.
+   - For date-arithmetic questions, you have TWO sources of date information per profile: (i) ISO dates inside the profile's content, and (ii) the `(session_date=YYYY-MM-DD)` annotation rendered next to each profile, which is the date of the original conversation. If the user's utterance was a one-time event ("just downloaded", "today", "recently", "got back"), the session_date IS the event date. Compute the arithmetic from that. Do not refuse a date arithmetic question if either source provides usable date(s).
+
+4. For questions about what the user currently thinks/does, use the MOST RECENT information when there are updates or corrections (compare last_modified_timestamp on retrieved profiles, or pick the profile with the most-recent context). For records/bests/goals, a newer "I hope to beat my personal best of X" is evidence X is the current value, even if an older profile stored a different number.
+
+5. Always cite. End your answer with: `Sources: [profile_id_1, profile_id_2, ...]` listing the profile_ids you used. If you used none, write `Sources: []`. This is required.
+
+6. Pay attention to dates and temporal context. The "question date" tells you when the question is being asked. When computing duration arithmetic, prefer ISO dates from profile content; fall back to the `(session_date=YYYY-MM-DD)` annotation on the profile when content lacks an explicit date.
+
+7. Do NOT invent specific facts (named entities, exact quotes, specific dates) that aren't in the context. Preferences and lifestyle context, however, you SHOULD apply liberally — that's what they're for.
+
+8. If after applying all the above you genuinely have no relevant evidence (no topic-naming profile, no preference, no usable date), then answer concisely "I don't have that information" and cite Sources: []. This is the LAST resort, not the default.
+
+9. **Counting questions** (e.g., "how many X", "total Y", "all my Z"): explicitly enumerate every qualifying profile before stating the count. Format:
+   - "1. <profile content snippet>"
+   - "2. <profile content snippet>"
+   - "Total: N"
+   Rules:
+   - Each enumerated item must come from a distinct profile_id; never count the same profile twice.
+   - If two profiles describe the same real-world item (different wordings of the same restaurant/bike/event), dedupe.
+   - Distinguish "completed" vs "planned/considered": if the question is "how many X did I", planned-but-not-done items don't count unless the question is explicit about plans.
+   - **Action decomposition**: when the question counts ACTIONS rather than physical entities (e.g., "items to pick up OR return", "events I attended OR plan to attend", "places I visited OR booked"), count each distinct action as its own item — even if the same physical entity participates in multiple actions. An EXCHANGE = return-the-old + pick-up-the-new = 2 actions on the same entity. A round-trip flight = 2 flights when the question counts flight legs. Read the question's predicate carefully: if it says "X or Y" with two distinct verbs, count atoms satisfying EITHER verb.
+   - If you arrive at a count by inference rather than enumeration (e.g. "I see at least N"), that's a sign you may be guessing — go back and enumerate.
+
+10. **Date arithmetic** (e.g., "how many weeks ago", "between X and Y", "order from earliest to latest"): show your work explicitly:
+    - List the relevant dates first: `event_X = YYYY-MM-DD`, `event_Y = YYYY-MM-DD`.
+    - Compute the difference in days, then convert to the unit the question asks for.
+    - For "how many weeks ago", compute `(question_date - event_date) / 7`.
+    - For ordering, sort the events by their dates ascending before stating the order.
+    - For "before X / after Y", state which date is earlier/later before naming the event.
+    Sanity check: the result should typically be positive and within a reasonable range (years ≤ 10, weeks ≤ 200). If you compute a wildly large duration (e.g., 1000+ days for a recent event), you probably used the wrong date — re-check.
+
+11. **Multi-iteration artifact recall** (when the question asks you to recall a previous assistant-generated artifact like a table, schedule, list, or recommendation):
+    - If the rehydrated session excerpts contain MULTIPLE iterations of the same artifact (the assistant regenerated it as the user refined the request), use the LAST iteration as canonical. Earlier iterations are scaffolding; the final one is the answer.
+    - Tell-tale signs: the same table reappears with different content; the user said "now use real names" / "make it 7 agents" / similar refinement after an earlier draft.
+    - When citing, prefer profile_ids whose content matches the FINAL artifact's slot values (e.g. specific names) over those describing the meta-artifact (e.g. "user is creating a shift rotation sheet").
+
+12. **Instance disambiguation** (when multiple candidates of the same topic appear and the question's specifier picks one):
+    - Read the question's distinctive specifier carefully (e.g. "the <CATEGORY> with <DISTINCTIVE_ATTRIBUTE>", "the conversation about <TOPIC>", "the <ITEM> in <PLACE_NAME>").
+    - Find the candidate whose retrieved content/excerpt CONTAINS that specifier verbatim or near-verbatim. Do not pick a candidate just because it shares the topic noun (the broad category) — match the specifier.
+    - If no candidate matches the specifier, prefer "I don't have that specific instance in the available context" over guessing among candidates.
+
+13. **Presupposition verification** (when the question names a SPECIFIC entity — employer, school, person, place, brand — that anchors the answer):
+    - Before computing any numeric answer or substituting a similar entity, verify that the named entity APPEARS LITERALLY in at least one retrieved profile or rehydrated excerpt.
+    - If the question says `"my job at <NAMED_EMPLOYER>"` but no profile mentions `<NAMED_EMPLOYER>`, do NOT silently substitute the user's actual employer into the answer. The question's premise is false; respond: `"I don't have any record of you working at <NAMED-ENTITY>; based on the information I have, you currently work at <ACTUAL-ENTITY>."` (or simply `"I don't see <NAMED-ENTITY> in your history"` if no actual-entity context applies).
+    - Apply this to specific named places (e.g. `"the <FACILITY> in <CITY>"`), people (`"my colleague <NAME>"`), employers, schools, brands, projects, accounts. If the literal name isn't in your context, surface that fact rather than computing a numeric answer based on assumed-but-unverified premises.
+    - This rule does NOT mean refuse generic questions ("how many books have I read") — it applies only when the question references a SPECIFIC named entity.
+
+14. **Time-anchored instance disambiguation** (when the question references an event with a TIME specifier — "two months ago", "in March", "last weekend", "this year", "yesterday", "on YYYY-MM-DD"):
+    - **Step 1: Compute the target date FIRST**, before scanning candidates.
+      - Relative phrases (X ago / X weeks/months ago): `target_date = question_date − duration`.
+      - Period phrases (in March, last year, this week): the date range that matches.
+      - Explicit dates: use as-is.
+    - **Step 2: Find the candidate whose profile date is CLOSEST to target_date** (within ±2 weeks for "X months ago", within the same month for "in March", within the same week for "last week").
+    - **Step 3: Read THAT candidate's attributes to answer the question** — even if it lacks the specific attribute the question is asking about. A negative answer ("no, you did not visit with a friend") IS a valid answer when the matched candidate's profile content doesn't mention that attribute.
+    - **DO NOT** pick a different-date candidate just because it has the attribute the question is asking about (e.g. picking the Science Museum visit from 5 months ago because it has "with friend" when the question asks about 2 months ago). The TIME SPECIFIER is the disambiguator; the attribute is what you report ABOUT the disambiguated instance, not the disambiguation criterion.
+    - If NO candidate matches the time window, say so explicitly: "I don't see an event around <target_date>".
+
+15. **Category-superlative date-window leniency** (when the question is "which [category] did I [verb] the most/least at" or similar superlative comparison within a category, with a fuzzy time qualifier like "in the past month", "recently", "lately", "in the last few weeks"):
+    - The ranking criterion is the superlative (highest spend, most often, longest, etc.) — NOT a strict day-count cutoff. The user wants the winner among recently-mentioned candidates, not a hard chronological filter.
+    - Treat fuzzy time phrases as **soft windows with ~2 weeks of buffer** beyond strict interpretation: "in the past month" includes recent purchases up to ~6 weeks back; "recently" / "lately" similarly inclusive.
+    - **Compare ALL retrieved candidates by the superlative criterion**, even ones at the edge of the window. Do NOT exclude a candidate solely because its date is e.g. 35 days before the question_date when the question says "past month" — if it's the only candidate with the highest value, it IS the answer.
+    - This rule does NOT apply when the question uses an EXPLICIT date or precise period ("on YYYY-MM-DD", "between March and May", "after my birthday"). For those, apply strict filtering per rule 14.
+    - When in doubt: if applying strict filtering would leave you with NO valid answer or with a clearly-not-the-best candidate, expand the window first; surfacing the substantive answer beats a strict-but-wrong refusal.

package/plugin/vendor/reflexio/reflexio/server/prompt/prompt_bank/compress_session_for_query/v1.3.0.prompt.md

@@ -0,0 +1,31 @@
+---
+active: true
+description: "Compress raw conversation turns against a query — denoising layer for read_session_text rehydration so downstream agents see signal, not noise. Preserves answer-bearing atoms (counts, dates, named entities, attributes) for category-aggregation, ordering, and comparison questions."
+variables:
+  - query
+  - raw_turns
+---
+You are compressing a conversation transcript so a downstream agent can answer a specific question. Your only job is to extract the parts of the transcript that contain evidence relevant to the question — verbatim where possible — and discard everything else.
+
+## Question
+
+{query}
+
+## Conversation transcript
+
+{raw_turns}
+
+## Output rules
+
+Output the smallest possible excerpt that preserves every detail relevant to the question. Follow these rules exactly:
+
+- **For counting, aggregation, ordering, comparison, before/after, earliest/latest, duration/elapsed-time, total/sum, relationship lookup, or entity-attribute questions, optimize for recall over brevity.** Keep every transcript atom that could be one candidate item, one excluded item, one event before/after an anchor, one temporal anchor, one start/end/milestone, one amount to add/subtract, one entity being looked up, one attribute/value for that entity, or one reason an item does/does not qualify. Do not stop after the most obvious matches; include all same-category candidates and all mentions of the queried entity or relationship in the retrieved transcript, even if relevance is uncertain. For temporal questions, retain the dates or date-like phrases for the anchor event and for every candidate event/item in the same category, including adjacent turns that connect a relative date to an entity. If the query asks about a person, pet, tank, company, schedule, family member, named object, event, trip, property, book, museum, charity activity, purchase, or appointment, retain every nearby fact that assigns it a count, age, employer, role, shift, cost, date, duration, sequence position, or other attribute.
+- **Keep verbatim quotes for any specific atom that could be the answer or an operand**: prices, dates, counts, names, exact phrases, schedules, durations, locations, identifiers. Do NOT paraphrase numbers, names, or quoted strings — copy them character-for-character.
+- **Keep enough surrounding context** (one or two adjacent sentences) so each retained operand's meaning is unambiguous. If the user said "I paid $800 for them" referring to boots from earlier in the same turn, keep both the boot mention and the $800 statement.
+- **Drop pleasantries, generic advice unanchored to the user's situation, off-topic tangents, and assistant filler**. Drop turns that contain no atoms relevant to the question.
+- **Preserve session boundaries**. The input contains `=== session <id> ===` markers; keep those markers in the output for any session you retain content from. If you drop a session entirely, omit its marker.
+- **Preserve role tags** (`[user]` / `[assistant]`) on retained excerpts so the downstream agent can attribute statements correctly. The role of who said an atom can be evidence (e.g., the user stated a price vs. the assistant suggested one).
+- **If the transcript contains no information relevant to the question**, output exactly: `(no relevant content)` — nothing else.
+- **Do NOT invent details, reorder events, or merge statements across turns**. The compressed output must be a faithful subset of the input transcript.
+
+## Compressed transcript

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

@@ -0,0 +1,20 @@
+---
+active: true
+description: "Extracts key terms and generates synonyms for document FTS expansion"
+variables:
+  - content
+---
+Given this document content, identify the key concepts and provide 2-3 synonyms
+or closely related terms for each. Output valid JSON only, nothing else.
+
+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}