claude-smart 0.2.45 → 0.2.46

package/plugin/vendor/reflexio/reflexio/server/services/evaluation_overview/group_aggregation.py

@@ -1,192 +0,0 @@
-"""Pure aggregation helpers for F2's session-level A/B groups.
-
-These functions are deliberately DB-free and LLM-free so they can be unit
-tested in milliseconds and exercised by mutmut. The storage layer hands
-in raw tuples; we hand back SuccessRateTrendByGroup.
-"""
-
-from __future__ import annotations
-
-import math
-from collections import defaultdict
-from collections.abc import Iterable
-from enum import StrEnum
-from typing import Any
-
-from reflexio.models.api_schema.eval_overview_schema import (
-    SuccessRateTrendByGroup,
-    TrendPoint,
-)
-
-# Z-value for a 95% Wald CI on a binomial proportion (two-sided).
-_Z_95 = 1.96
-
-# Cap on the lift CI half-width. With very small sample sizes the Wald CI
-# computes to absurd widths (e.g., ±70pp), and rendering that on a
-# dashboard implies false precision. 0.5 (= ±50pp) is the product-meaningful
-# threshold: any wider than that, the user should think "we don't know"
-# and the frontend should consider rendering a low-confidence indicator.
-_MAX_CI_HALF_WIDTH = 0.5
-
-
-class GroupAssignment(StrEnum):
-    """Group label derived from `Request.metadata.reflexio_retrieval_enabled`."""
-
-    TREATMENT = "treatment"
-    CONTROL = "control"
-    UNTAGGED = "untagged"
-
-
-def assign_group_from_metadata(metadata: dict[str, Any]) -> GroupAssignment:
-    """
-    Bucket a session by its first request's metadata.
-
-    Reads ``metadata.reflexio_retrieval_enabled`` as a true bool. Anything
-    else (missing, string, int, None) maps to UNTAGGED — we never silently
-    coerce non-bool values, so customers see how many of their sessions
-    are tagged inconsistently.
-
-    Args:
-        metadata (dict[str, Any]): The first request's metadata dict. Non-dict
-            input is tolerated and routed to UNTAGGED (defensive — the caller
-            may pass a value read from a JSON column with no type guarantee).
-
-    Returns:
-        GroupAssignment: TREATMENT, CONTROL, or UNTAGGED.
-    """
-    if not isinstance(metadata, dict):
-        return GroupAssignment.UNTAGGED
-    value = metadata.get("reflexio_retrieval_enabled")
-    if value is True:
-        return GroupAssignment.TREATMENT
-    if value is False:
-        return GroupAssignment.CONTROL
-    return GroupAssignment.UNTAGGED
-
-
-def group_session_outcomes_by_metadata(
-    outcomes: Iterable[tuple[str, int, bool, dict[str, Any]]],
-) -> dict[GroupAssignment, list[tuple[str, int, bool]]]:
-    """
-    Split (session_id, ts, is_success, metadata) tuples into three groups.
-
-    Args:
-        outcomes (Iterable[tuple[str, int, bool, dict[str, Any]]]): Tuples of
-            (session_id, ts, is_success, first_request_metadata).
-
-    Returns:
-        dict[GroupAssignment, list[tuple[str, int, bool]]]: Dict keyed by every
-        GroupAssignment member (TREATMENT, CONTROL, UNTAGGED) — always present,
-        possibly empty list — with values being (session_id, ts, is_success)
-        tuples (metadata dropped after binning).
-    """
-    out: dict[GroupAssignment, list[tuple[str, int, bool]]] = {
-        GroupAssignment.TREATMENT: [],
-        GroupAssignment.CONTROL: [],
-        GroupAssignment.UNTAGGED: [],
-    }
-    for session_id, ts, is_success, metadata in outcomes:
-        group = assign_group_from_metadata(metadata)
-        out[group].append((session_id, ts, is_success))
-    return out
-
-
-def bucket_outcomes(
-    outcomes: Iterable[tuple[str, int, bool]],
-    bucket_seconds: int,
-) -> list[dict[str, int]]:
-    """
-    Bucket outcomes by time, returning one dict per bucket.
-
-    Args:
-        outcomes (Iterable[tuple[str, int, bool]]): Tuples of (session_id, ts,
-            is_success). ``session_id`` is unused at this stage; kept for future
-            per-session breakdowns.
-        bucket_seconds (int): Bucket width in seconds (e.g., 86400 for daily,
-            604800 for weekly). Must be positive.
-
-    Returns:
-        list[dict[str, int]]: List of ``{"ts": bucket_start, "n": int,
-        "successes": int}``, sorted by ``ts`` ascending. Empty buckets are
-        omitted.
-
-    Raises:
-        ValueError: When ``bucket_seconds`` is not positive.
-    """
-    if bucket_seconds <= 0:
-        raise ValueError(f"bucket_seconds must be positive, got {bucket_seconds}")
-    counts: dict[int, dict[str, int]] = defaultdict(lambda: {"n": 0, "successes": 0})
-    for _, ts, is_success in outcomes:
-        bucket_start = (ts // bucket_seconds) * bucket_seconds
-        counts[bucket_start]["n"] += 1
-        if is_success:
-            counts[bucket_start]["successes"] += 1
-    return [
-        {"ts": bucket_start, "n": d["n"], "successes": d["successes"]}
-        for bucket_start, d in sorted(counts.items())
-    ]
-
-
-def compute_trend_by_group(
-    outcomes: Iterable[tuple[str, int, bool, dict[str, Any]]],
-    bucket_seconds: int,
-) -> SuccessRateTrendByGroup:
-    """
-    Build the dual+untagged-curve trend payload from raw session outcomes.
-
-    Args:
-        outcomes (Iterable[tuple[str, int, bool, dict[str, Any]]]): Tuples of
-            (session_id, ts, is_success, first_request_metadata).
-        bucket_seconds (int): Bucket width passed to :func:`bucket_outcomes`.
-
-    Returns:
-        SuccessRateTrendByGroup: Three curves (any of which may be empty).
-    """
-    grouped = group_session_outcomes_by_metadata(outcomes)
-    return SuccessRateTrendByGroup(
-        treatment=_to_trend_points(grouped[GroupAssignment.TREATMENT], bucket_seconds),
-        control=_to_trend_points(grouped[GroupAssignment.CONTROL], bucket_seconds),
-        untagged=_to_trend_points(grouped[GroupAssignment.UNTAGGED], bucket_seconds),
-    )
-
-
-def _to_trend_points(
-    outcomes: list[tuple[str, int, bool]],
-    bucket_seconds: int,
-) -> list[TrendPoint]:
-    """Convert raw outcomes into bucketed TrendPoints; omit empty buckets."""
-    return [
-        TrendPoint(ts=b["ts"], rate=b["successes"] / b["n"], n=b["n"])
-        for b in bucket_outcomes(outcomes, bucket_seconds)
-        if b["n"] > 0
-    ]
-
-
-def compute_lift_with_ci(
-    n_t: int, p_t: float, n_c: int, p_c: float
-) -> tuple[float | None, float | None]:
-    """
-    Compute success-rate lift (treatment − control) and a 95% CI half-width.
-
-    Uses the Wald approximation for the difference of two binomial
-    proportions. Returns ``(None, None)`` if either group has zero samples —
-    surfaces honest "no estimate" rather than fake zeros.
-
-    Args:
-        n_t (int): Treatment group size.
-        p_t (float): Treatment success rate, in ``[0.0, 1.0]``.
-        n_c (int): Control group size.
-        p_c (float): Control success rate, in ``[0.0, 1.0]``.
-
-    Returns:
-        tuple[float | None, float | None]: ``(lift, ci_half_width)`` — both in
-        proportion units (e.g., 0.14 for 14pp), or ``(None, None)`` when there
-        isn't enough data.
-    """
-    if n_t <= 0 or n_c <= 0:
-        return None, None
-    lift = p_t - p_c
-    var = (p_t * (1 - p_t)) / n_t + (p_c * (1 - p_c)) / n_c
-    ci_half = _Z_95 * math.sqrt(var)
-    ci_half = min(ci_half, _MAX_CI_HALF_WIDTH)
-    return lift, ci_half

package/plugin/vendor/reflexio/reflexio/server/services/extraction/invariants.py

@@ -1,303 +0,0 @@
-"""Plan-level invariants for the agentic-v2 extraction pipeline.
-
-Invariants are pure functions over ``ExtractionCtx``. Hard violations drop
-offending ops from the commit; soft violations are logged and applied.
-See spec §6 for the full catalog and severity policy.
-"""
-
-from __future__ import annotations
-
-import logging
-
-from reflexio.server.services.extraction.plan import (
-    CommitResult,
-    CreateUserPlaybookOp,
-    CreateUserProfileOp,
-    DeleteUserPlaybookOp,
-    DeleteUserProfileOp,
-    ExtractionCtx,
-    Violation,
-)
-
-logger = logging.getLogger(__name__)
-
-PLAN_SIZE_CAP = 30
-
-
-# --- Hard invariants ---
-
-
-def inv_A_search_before_create(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """Every CreateOp must be preceded by ≥1 search_* call this run."""
-    create_indices = [
-        i
-        for i, op in enumerate(ctx.plan)
-        if isinstance(op, (CreateUserProfileOp, CreateUserPlaybookOp))
-    ]
-    if create_indices and ctx.search_count == 0:
-        return [
-            Violation(
-                code="A",
-                severity="hard",
-                affected_op_indices=create_indices,
-                msg="Plan has create ops but no search was performed this run",
-            )
-        ]
-    return []
-
-
-def inv_B_delete_known_id(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """Every DeleteOp(id) must reference an id in ctx.known_ids.
-
-    known_ids is populated by search/get/create tool handlers — so deletes
-    targeting hallucinated ids (agent never saw them) are rejected.
-    """
-    violations: list[Violation] = []
-    for i, op in enumerate(ctx.plan):
-        if (
-            isinstance(op, (DeleteUserProfileOp, DeleteUserPlaybookOp))
-            and op.id not in ctx.known_ids
-        ):
-            violations.append(
-                Violation(
-                    code="B",
-                    severity="hard",
-                    affected_op_indices=[i],
-                    msg=f"Delete of unknown id {op.id!r}",
-                )
-            )
-    return violations
-
-
-def inv_D_plan_size_cap(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """Plan cannot exceed PLAN_SIZE_CAP ops — guards runaway loops."""
-    if len(ctx.plan) > PLAN_SIZE_CAP:
-        overflow = list(range(PLAN_SIZE_CAP, len(ctx.plan)))
-        return [
-            Violation(
-                code="D",
-                severity="hard",
-                affected_op_indices=overflow,
-                msg=f"Plan size {len(ctx.plan)} exceeds cap {PLAN_SIZE_CAP}",
-            )
-        ]
-    return []
-
-
-def inv_F_no_duplicate_deletes(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """Same id cannot be deleted twice in one plan."""
-    seen: set[str] = set()
-    violations: list[Violation] = []
-    for i, op in enumerate(ctx.plan):
-        if isinstance(op, (DeleteUserProfileOp, DeleteUserPlaybookOp)):
-            if op.id in seen:
-                violations.append(
-                    Violation(
-                        code="F",
-                        severity="hard",
-                        affected_op_indices=[i],
-                        msg=f"Duplicate delete of id {op.id!r}",
-                    )
-                )
-            else:
-                seen.add(op.id)
-    return violations
-
-
-def inv_J_scope_match(_ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """User_id scope is primarily enforced at the storage layer (handlers inject
-    ctx.user_id). This invariant is a placeholder for future cross-user checks;
-    for v1 it is a no-op."""
-    return []
-
-
-HARD_INVARIANTS = (
-    inv_A_search_before_create,
-    inv_B_delete_known_id,
-    inv_D_plan_size_cap,
-    inv_F_no_duplicate_deletes,
-    inv_J_scope_match,
-)
-
-
-# --- Soft invariants ---
-
-
-def inv_E_no_duplicate_creates(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """Two CreateOps with identical content in one plan = oscillation smell."""
-    seen: dict[str, int] = {}
-    violations: list[Violation] = []
-    for i, op in enumerate(ctx.plan):
-        key = None
-        if isinstance(op, CreateUserProfileOp):
-            key = f"profile::{op.content}"
-        elif isinstance(op, CreateUserPlaybookOp):
-            key = f"playbook::{op.trigger}::{op.content}"
-        if key is None:
-            continue
-        if key in seen:
-            violations.append(
-                Violation(
-                    code="E",
-                    severity="soft",
-                    affected_op_indices=[i],
-                    msg=f"Duplicate create content at op {i}",
-                )
-            )
-        else:
-            seen[key] = i
-    return violations
-
-
-def inv_H_source_span_present(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """CreateOps must have non-whitespace source_span.
-
-    Schema enforces min_length=1, but whitespace-only slips through —
-    this is the secondary guard.
-    """
-    violations: list[Violation] = []
-    for i, op in enumerate(ctx.plan):
-        if (
-            isinstance(op, (CreateUserProfileOp, CreateUserPlaybookOp))
-            and not op.source_span.strip()
-        ):
-            violations.append(
-                Violation(
-                    code="H",
-                    severity="soft",
-                    affected_op_indices=[i],
-                    msg=f"Empty/whitespace source_span on create op {i}",
-                )
-            )
-    return violations
-
-
-def inv_K_deletes_without_creates(ctx: ExtractionCtx) -> list[Violation]:  # noqa: N802
-    """Plan with deletes but no creates is unusual — worth logging."""
-    has_delete = any(
-        isinstance(op, (DeleteUserProfileOp, DeleteUserPlaybookOp)) for op in ctx.plan
-    )
-    has_create = any(
-        isinstance(op, (CreateUserProfileOp, CreateUserPlaybookOp)) for op in ctx.plan
-    )
-    if has_delete and not has_create:
-        indices = [
-            i
-            for i, op in enumerate(ctx.plan)
-            if isinstance(op, (DeleteUserProfileOp, DeleteUserPlaybookOp))
-        ]
-        return [
-            Violation(
-                code="K",
-                severity="soft",
-                affected_op_indices=indices,
-                msg="Plan contains deletes without any matching creates",
-            )
-        ]
-    return []
-
-
-SOFT_INVARIANTS = (
-    inv_E_no_duplicate_creates,
-    inv_H_source_span_present,
-    inv_K_deletes_without_creates,
-)
-
-
-# --- Oscillation resolver ---
-
-
-def resolve_tentative_oscillations(plan: list) -> set[int]:
-    """Return plan indices to drop: create+delete-tentative pairs cancel.
-
-    When the agent creates an entity (issuing a tentative_id) and later
-    deletes that same tentative_id within the same plan, both ops are
-    dropped before invariants fire. This is the "oscillated self-correction"
-    pattern — the agent changed its mind mid-run.
-
-    The tentative_id format is ``tentative::<kind>::<plan_index_at_issue_time>``,
-    matching ``_next_tentative_id`` in tools.py which uses ``len(ctx.plan)``
-    (the plan length BEFORE the op is appended, i.e. the future index of the op).
-
-    Args:
-        plan: The accumulated list of PlanOp instances from ctx.plan.
-
-    Returns:
-        Set of plan indices to exclude from apply. Both the create and the
-        delete are dropped when a matching pair is found.
-    """
-    drop: set[int] = set()
-    pending_creates: dict[str, int] = {}
-    for i, op in enumerate(plan):
-        if isinstance(op, CreateUserProfileOp):
-            tentative_id = f"tentative::profile::{i}"
-            pending_creates[tentative_id] = i
-        elif isinstance(op, CreateUserPlaybookOp):
-            tentative_id = f"tentative::user_playbook::{i}"
-            pending_creates[tentative_id] = i
-        elif isinstance(op, (DeleteUserProfileOp, DeleteUserPlaybookOp)):
-            if op.id.startswith("tentative::") and op.id in pending_creates:
-                drop.add(pending_creates.pop(op.id))
-                drop.add(i)
-    return drop
-
-
-# --- commit_plan ---
-
-
-def commit_plan(
-    ctx: ExtractionCtx,
-    storage: object,
-    *,
-    outcome: str,  # Literal["finish_tool","max_steps","error"]
-) -> CommitResult:
-    """Run all invariants, then apply surviving ops atomically.
-
-    Args:
-        ctx: Populated ExtractionCtx from the agent loop.
-        storage: BaseStorage handle for apply.
-        outcome: How the loop terminated.
-
-    Returns:
-        CommitResult containing applied ops + all violations (hard + soft).
-    """
-    # Error outcome — discard everything, do not apply
-    if outcome == "error":
-        return CommitResult(applied=[], violations=[], outcome="error")
-
-    violations: list[Violation] = []
-    for check in HARD_INVARIANTS:
-        violations.extend(check(ctx))
-    for check in SOFT_INVARIANTS:
-        violations.extend(check(ctx))
-
-    dropped: set[int] = set()
-    # Oscillation resolver runs first: matching create+delete-tentative pairs
-    # cancel before invariants decide what to keep.
-    dropped.update(resolve_tentative_oscillations(ctx.plan))
-    for v in violations:
-        if v.severity == "hard":
-            dropped.update(v.affected_op_indices)
-
-    ops_to_apply = [op for i, op in enumerate(ctx.plan) if i not in dropped]
-
-    for v in violations:
-        logger.info(
-            "invariant_violation user_id=%s code=%s severity=%s op_indices=%s msg=%s",
-            ctx.user_id,
-            v.code,
-            v.severity,
-            v.affected_op_indices,
-            v.msg,
-        )
-
-    # Delegate actual storage writes to the tool-handler module (Task 5 wires this in).
-    # Lazy import so Task 3 can land before tools.py exists.
-    from reflexio.server.services.extraction.tools import (
-        apply_plan_op,  # noqa: PLC0415  # type: ignore[import-not-found]
-    )
-
-    for op in ops_to_apply:
-        apply_plan_op(op, storage, ctx)
-
-    return CommitResult(applied=ops_to_apply, violations=violations, outcome=outcome)  # type: ignore[arg-type]

package/plugin/vendor/reflexio/reflexio/server/services/extraction/plan.py

@@ -1,138 +0,0 @@
-"""Plan-op types, ExtractionCtx, HandlerBundle, and commit-result types for the agentic-v2 pipeline.
-
-Tool handlers append PlanOp instances to ``ctx.plan`` rather than hitting
-storage directly. A deterministic commit stage at ``finish`` (or on
-``max_steps``) runs invariants and applies the valid ops atomically.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Annotated, Literal
-
-from pydantic import BaseModel, ConfigDict, Field
-
-# Mirrors ProfileTimeToLive — kept as Literal to avoid circular import on enum.
-ProfileTTL = Literal[
-    "one_day", "one_week", "one_month", "one_quarter", "one_year", "infinity"
-]
-
-PlaybookStrength = Literal["hard", "soft"]
-
-
-class _BasePlanOp(BaseModel):
-    """Base class for all PlanOp variants. Discriminated union via ``op``."""
-
-    model_config = ConfigDict(frozen=True)
-
-
-class CreateUserProfileOp(_BasePlanOp):
-    op: Literal["create_user_profile"] = "create_user_profile"
-    content: Annotated[str, Field(min_length=1)]
-    ttl: ProfileTTL
-    source_span: Annotated[str, Field(min_length=1)]
-
-
-class DeleteUserProfileOp(_BasePlanOp):
-    op: Literal["delete_user_profile"] = "delete_user_profile"
-    id: Annotated[str, Field(min_length=1)]
-
-
-class CreateUserPlaybookOp(_BasePlanOp):
-    op: Literal["create_user_playbook"] = "create_user_playbook"
-    trigger: Annotated[str, Field(min_length=1)]
-    content: Annotated[str, Field(min_length=1)]
-    rationale: str = ""
-    strength: PlaybookStrength = "soft"
-    source_span: Annotated[str, Field(min_length=1)]
-
-
-class DeleteUserPlaybookOp(_BasePlanOp):
-    op: Literal["delete_user_playbook"] = "delete_user_playbook"
-    id: Annotated[str, Field(min_length=1)]
-
-
-PlanOp = Annotated[
-    CreateUserProfileOp
-    | DeleteUserProfileOp
-    | CreateUserPlaybookOp
-    | DeleteUserPlaybookOp,
-    Field(discriminator="op"),
-]
-
-
-@dataclass
-class ExtractionCtx:
-    """Per-run state for the extraction agent.
-
-    Attributes:
-        user_id: Authenticated user the run is scoped to.
-        agent_version: Agent version from the active config.
-        request_id: Source publish_interaction request UUID — embedded into
-            every profile/playbook this run creates so retrieval can trace
-            back to the originating session. Empty string when called from
-            test contexts that don't have a publish request.
-        plan: Accumulated PlanOps awaiting commit.
-        known_ids: Ids the agent has legitimately seen (from search/get/create
-            handlers). Invariant B checks delete ids against this set.
-        search_count: Number of search_* tool calls. Invariant A gates on this.
-        finished: True once the agent calls the ``finish`` tool.
-    """
-
-    user_id: str
-    agent_version: str
-    request_id: str = ""
-    plan: list = field(
-        default_factory=list
-    )  # list[PlanOp] — type-erased to avoid forward-ref issues
-    known_ids: set[str] = field(default_factory=set)
-    search_count: int = 0
-    finished: bool = False
-    search_answer: str | None = None
-    agent_playbook_status_filter: list[str] | None = None
-    # Compressed rehydration excerpts captured by `read_session_text` calls
-    # during the agent loop. Surfaced verbatim on the response so callers can
-    # include them in downstream context without going through the search
-    # agent's natural-language `finish(answer=…)` synthesis (which paraphrases
-    # operands and loses fidelity).
-    rehydrated_excerpts: list[str] = field(default_factory=list)
-
-
-@dataclass(slots=True)
-class HandlerBundle:
-    """Glue so tool handlers can access shared services through one param.
-
-    The run_tool_loop primitive passes a single ``ctx`` param to tool handlers;
-    handlers in tools.py need access to BaseStorage and an ExtractionCtx. A few
-    handlers (e.g., the rehydration tool) additionally call back into the LLM
-    layer for in-tool denoising — those receive ``llm_client`` and
-    ``prompt_manager`` here. The tool-loop caller builds one of these before
-    driving the loop.
-
-    Args:
-        storage: BaseStorage handle.
-        ctx: ExtractionCtx with per-run state.
-        llm_client: Optional LiteLLMClient for in-tool LLM calls (e.g.
-            compression). ``None`` in test paths that don't exercise tools
-            requiring LLM completions.
-        prompt_manager: Optional PromptManager for rendering in-tool prompts.
-            Same ``None`` semantics as ``llm_client``.
-    """
-
-    storage: object
-    ctx: ExtractionCtx
-    llm_client: object | None = None
-    prompt_manager: object | None = None
-
-
-class Violation(BaseModel):
-    code: Literal["A", "B", "D", "E", "F", "H", "J", "K"]
-    severity: Literal["hard", "soft"]
-    affected_op_indices: list[int]
-    msg: str
-
-
-class CommitResult(BaseModel):
-    applied: list[PlanOp]
-    violations: list[Violation]
-    outcome: Literal["finish_tool", "max_steps", "error"]