memorymaster 3.15.1__tar.gz → 3.17.0__tar.gz

{memorymaster-3.15.1/memorymaster.egg-info → memorymaster-3.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.15.1
+Version: 3.17.0
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT

{memorymaster-3.15.1 → memorymaster-3.17.0}/memorymaster/cli.py

@@ -23,6 +23,7 @@ from memorymaster.cli_handlers_curation import COMMAND_HANDLERS
 from memorymaster.cli_handlers_basic import (
     _handle_decay,
     _handle_entity_graph_export,
+    _handle_ingest_daydream,
     _handle_recompute_confidence_priors,
     _handle_wiki_suggest_links,
     handle_mcp_usage_report,
@@ -33,6 +34,7 @@ COMMAND_HANDLERS["entity-graph-export"] = _handle_entity_graph_export
 COMMAND_HANDLERS["recompute-confidence-priors"] = _handle_recompute_confidence_priors
 COMMAND_HANDLERS["wiki-suggest-links"] = _handle_wiki_suggest_links
 COMMAND_HANDLERS["decay"] = _handle_decay
+COMMAND_HANDLERS["ingest-daydream"] = _handle_ingest_daydream
 COMMAND_HANDLERS["mcp-usage-report"] = (
     lambda args, service, parser, effective_db: handle_mcp_usage_report(args, effective_db)
 )
@@ -66,6 +68,12 @@ def build_parser() -> argparse.ArgumentParser:
     ingest.add_argument("--valid-from", default=None, help="ISO-8601 timestamp: start of the claim validity window")
     ingest.add_argument("--valid-until", default=None, help="ISO-8601 timestamp: end of the validity window (omit if still current)")
 
+    ingest_daydream = sub.add_parser("ingest-daydream", help="Ingest daydream insights as candidate hypothesis claims")
+    ingest_daydream.add_argument("insights_dir", help="Daydreams directory containing insight JSON or Markdown files")
+    ingest_daydream.add_argument("--min-score", type=float, default=7.0, help="Minimum average score to ingest")
+    ingest_daydream.add_argument("--scope", default="user", help="Claim scope (default: user)")
+    ingest_daydream.add_argument("--dry-run", action="store_true", help="Preview ingest without writing claims")
+
     import_whatsapp = sub.add_parser("import-whatsapp", help="Import WhatsApp messages from a wacli JSON/JSONL export")
     import_whatsapp.add_argument("--input", required=True, help="Path to wacli JSON or JSONL export")
     import_whatsapp.add_argument("--display-name", default="WhatsApp", help="External source display name")

{memorymaster-3.15.1 → memorymaster-3.17.0}/memorymaster/cli_handlers_basic.py

@@ -324,6 +324,29 @@ def _handle_ingest(args: argparse.Namespace, service, parser: argparse.ArgumentP
     return 0
 
 
+def _handle_ingest_daydream(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
+    from memorymaster.jobs.daydream_ingest import ingest_insights
+
+    t0 = time.perf_counter()
+    result = ingest_insights(
+        service,
+        Path(args.insights_dir),
+        min_score=args.min_score,
+        scope=args.scope,
+        dry_run=args.dry_run,
+    )
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        tag = " [DRY RUN]" if args.dry_run else ""
+        print(
+            f"ingest-daydream{tag}: ingested={result['ingested']} "
+            f"skipped={result['skipped']} errors={len(result['errors'])}"
+        )
+    return 0
+
+
 def _handle_import_whatsapp(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
     from memorymaster.atlas_contract import atlas_meta
     from memorymaster.connectors.whatsapp import import_wacli_json

{memorymaster-3.15.1 → memorymaster-3.17.0}/memorymaster/config.py

@@ -8,7 +8,11 @@ Environment variables
 ---------------------
 MEMORYMASTER_RETRIEVAL_WEIGHTS
     Comma-separated floats for hybrid ranking: lexical,confidence,freshness,vector.
-    Default: ``0.45,0.30,0.15,0.10``
+    Default: ``0.30,0.20,0.10,0.40``
+
+MEMORYMASTER_W_LEX, MEMORYMASTER_W_CONF, MEMORYMASTER_W_FRESH, MEMORYMASTER_W_VEC
+    Individual overrides for the four hybrid ranking weights. These take
+    precedence over ``MEMORYMASTER_RETRIEVAL_WEIGHTS`` when set.
 
 MEMORYMASTER_RETRIEVAL_WEIGHTS_NO_VECTOR
     Weights when vector search is disabled: lexical,confidence,freshness.
@@ -55,6 +59,14 @@ MEMORYMASTER_LLM_RERANK
     Enable Gemini cross-encoder reranking over the top retrieval candidates.
     Default: ``0``
 
+MEMORYMASTER_RRF_TIEBREAKER
+    Enable RRF near-tie reordering after linear retrieval ranking.
+    Default: ``0``
+
+MEMORYMASTER_RRF_TIEBREAKER_THRESHOLD
+    Maximum adjacent score gap considered a near tie.
+    Default: ``0.01``
+
 MEMORYMASTER_CONFIG_FILE
     Path to a JSON config file. Keys match attribute names on ``Config``.
 """
@@ -159,10 +171,10 @@ class Config:
     """Immutable configuration for tunable MemoryMaster constants."""
 
     # --- Retrieval ranking weights (hybrid mode with vector) ---
-    retrieval_weight_lexical: float = 0.45
-    retrieval_weight_confidence: float = 0.30
-    retrieval_weight_freshness: float = 0.15
-    retrieval_weight_vector: float = 0.10
+    retrieval_weight_lexical: float = 0.30
+    retrieval_weight_confidence: float = 0.20
+    retrieval_weight_freshness: float = 0.10
+    retrieval_weight_vector: float = 0.40
 
     # --- Retrieval ranking weights (hybrid mode without vector) ---
     retrieval_weight_lexical_no_vector: float = 0.55
@@ -197,6 +209,8 @@ class Config:
     pinned_bonus: float = 0.03
     session_diversity_cap: int = 3
     llm_rerank: bool = False
+    rrf_tiebreaker_enabled: bool = False
+    rrf_tiebreaker_threshold: float = 0.01
 
     # --- Initial confidence priors calibrated from validator outcomes ---
     default_initial_confidence: float = DEFAULT_INITIAL_CONFIDENCE
@@ -310,6 +324,10 @@ def load_config(config_path: str | Path | None = None) -> Config:
         "retrieval_weight_freshness",
         "retrieval_weight_vector",
     ])
+    _apply_env_float(overrides, "MEMORYMASTER_W_LEX", "retrieval_weight_lexical")
+    _apply_env_float(overrides, "MEMORYMASTER_W_CONF", "retrieval_weight_confidence")
+    _apply_env_float(overrides, "MEMORYMASTER_W_FRESH", "retrieval_weight_freshness")
+    _apply_env_float(overrides, "MEMORYMASTER_W_VEC", "retrieval_weight_vector")
     _apply_env_floats(overrides, "MEMORYMASTER_RETRIEVAL_WEIGHTS_NO_VECTOR", 3, [
         "retrieval_weight_lexical_no_vector",
         "retrieval_weight_confidence_no_vector",
@@ -343,6 +361,8 @@ def load_config(config_path: str | Path | None = None) -> Config:
     _apply_env_float(overrides, "MEMORYMASTER_PINNED_BONUS", "pinned_bonus")
     _apply_env_int(overrides, "MEMORYMASTER_SESSION_DIVERSITY_CAP", "session_diversity_cap")
     _apply_env_bool(overrides, "MEMORYMASTER_LLM_RERANK", "llm_rerank")
+    _apply_env_bool(overrides, "MEMORYMASTER_RRF_TIEBREAKER", "rrf_tiebreaker_enabled")
+    _apply_env_float(overrides, "MEMORYMASTER_RRF_TIEBREAKER_THRESHOLD", "rrf_tiebreaker_threshold")
 
     # Filter to only valid Config fields
     valid_fields = {f.name for f in Config.__dataclass_fields__.values()}

memorymaster-3.17.0/memorymaster/jobs/daydream_ingest.py

@@ -0,0 +1,331 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import json
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from memorymaster.models import CitationInput
+from memorymaster.service import MemoryService
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass(slots=True)
+class _DaydreamInsight:
+    title: str
+    connection: str
+    synthesis: str
+    implication: str
+    average: float | None
+    date: str
+    references: list[dict[str, str]]
+    path: Path
+
+
+def ingest_insights(
+    service: MemoryService,
+    insights_dir: Path,
+    *,
+    min_score: float = 7.0,
+    scope: str = "user",
+    dry_run: bool = False,
+) -> dict:
+    """Ingest accepted daydream insights as candidate hypothesis claims."""
+    root = Path(insights_dir)
+    result: dict[str, Any] = {"ingested": 0, "skipped": 0, "errors": []}
+    if not root.exists() or not root.is_dir():
+        raise ValueError(f"insights_dir does not exist or is not a directory: {root}")
+
+    for path in _iter_insight_files(root):
+        insight = _load_insight(path)
+        if insight is None:
+            result["skipped"] += 1
+            result["errors"].append(f"{path}: could not parse daydream insight")
+            continue
+
+        if insight.average is None or insight.average < min_score:
+            result["skipped"] += 1
+            continue
+
+        idempotency_key = _idempotency_key(insight)
+        if _claim_exists(service, idempotency_key):
+            result["skipped"] += 1
+            continue
+
+        if dry_run:
+            result["ingested"] += 1
+            continue
+
+        claim = service.ingest(
+            text=insight.synthesis,
+            citations=_citations_for(insight),
+            idempotency_key=idempotency_key,
+            claim_type="hypothesis",
+            subject=insight.title or _subject_from_connection(insight.connection),
+            scope=scope,
+            volatility="medium",
+            confidence=0.5,
+            source_agent="daydream",
+        )
+        if claim.idempotency_key == idempotency_key:
+            result["ingested"] += 1
+        else:
+            result["skipped"] += 1
+
+    return result
+
+
+def _iter_insight_files(root: Path) -> list[Path]:
+    files = [path for path in root.rglob("*.json") if path.is_file()]
+    files.extend(
+        path
+        for path in root.rglob("*.md")
+        if path.is_file() and "digests" not in {part.lower() for part in path.parts}
+    )
+    return sorted(files)
+
+
+def _load_insight(path: Path) -> _DaydreamInsight | None:
+    try:
+        if path.suffix.lower() == ".json":
+            return _load_json_insight(path)
+        if path.suffix.lower() == ".md":
+            return _load_markdown_insight(path)
+    except Exception as exc:
+        logger.warning("Skipping daydream insight %s: %s", path, exc)
+    return None
+
+
+def _load_json_insight(path: Path) -> _DaydreamInsight | None:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if isinstance(data, list):
+        logger.warning("Skipping daydream manifest-like JSON %s", path)
+        return None
+    if not isinstance(data, dict):
+        return None
+
+    metadata = _dict_value(data.get("metadata"))
+    scores = _dict_value(metadata.get("scores"))
+    average = _float_value(
+        data.get("avg_score")
+        or data.get("average")
+        or scores.get("average")
+        or scores.get("avg_score")
+    )
+    title = _text_value(data.get("title") or data.get("suggested_title"))
+    connection = _text_value(data.get("connection"))
+    synthesis = _text_value(data.get("synthesis"))
+    implication = _text_value(data.get("implication"))
+    if not synthesis:
+        return None
+
+    references = _references_from_json(data, metadata)
+    date = _normalize_date(
+        data.get("date")
+        or data.get("created_date")
+        or metadata.get("date")
+        or metadata.get("created_date")
+        or _date_from_filename(path)
+    )
+    return _DaydreamInsight(
+        title=title or _subject_from_connection(connection),
+        connection=connection,
+        synthesis=synthesis,
+        implication=implication,
+        average=average,
+        date=date,
+        references=references,
+        path=path,
+    )
+
+
+def _load_markdown_insight(path: Path) -> _DaydreamInsight | None:
+    raw = path.read_text(encoding="utf-8")
+    frontmatter, body = _split_frontmatter(raw)
+    if frontmatter.get("type") != "daydream":
+        return None
+    title = _first_heading(body) or path.stem
+    average = _float_value(frontmatter.get("scores.average"))
+    if average is None:
+        average = _float_value(frontmatter.get("average"))
+    connection = _blockquote_connection(body)
+    synthesis = _section_before(body, "## Implication").strip()
+    if title:
+        synthesis = re.sub(rf"^\s*#\s+{re.escape(title)}\s*", "", synthesis).strip()
+    synthesis = re.sub(r"^>\s*Connection.*$", "", synthesis, flags=re.MULTILINE).strip()
+    implication = _section_between(body, "## Implication", "## Critic")
+    if not synthesis:
+        return None
+    date = _normalize_date(frontmatter.get("created_date") or _date_from_filename(path))
+    return _DaydreamInsight(
+        title=title,
+        connection=connection,
+        synthesis=synthesis,
+        implication=implication,
+        average=average,
+        date=date,
+        references=_references_from_frontmatter(frontmatter),
+        path=path,
+    )
+
+
+def _references_from_json(data: dict[str, Any], metadata: dict[str, Any]) -> list[dict[str, str]]:
+    raw_refs = metadata.get("references") or data.get("references") or []
+    references: list[dict[str, str]] = []
+    if isinstance(raw_refs, list):
+        for item in raw_refs:
+            if isinstance(item, dict):
+                locator = _text_value(item.get("path") or item.get("locator") or item.get("file"))
+                title = _text_value(item.get("title") or item.get("name"))
+            else:
+                locator = _text_value(item)
+                title = ""
+            if locator:
+                references.append({"path": locator, "title": title})
+    for side in ("a", "b"):
+        locator = _text_value(data.get(f"path_{side}"))
+        title = _text_value(data.get(f"title_{side}"))
+        if locator and not any(ref["path"] == locator for ref in references):
+            references.append({"path": locator, "title": title})
+    return references
+
+
+def _references_from_frontmatter(frontmatter: dict[str, str]) -> list[dict[str, str]]:
+    references: list[dict[str, str]] = []
+    for value in frontmatter.get("source_notes", "").splitlines():
+        cleaned = _clean_wikilink(value.strip().lstrip("-").strip().strip("'\""))
+        if cleaned:
+            references.append({"path": cleaned, "title": cleaned})
+    return references
+
+
+def _citations_for(insight: _DaydreamInsight) -> list[CitationInput]:
+    citations = [
+        CitationInput(source="daydream", locator=ref["path"], excerpt=ref.get("title") or None)
+        for ref in insight.references
+        if ref.get("path")
+    ]
+    if citations:
+        return citations
+    return [
+        CitationInput(
+            source="daydream",
+            locator=str(insight.path),
+            excerpt=insight.connection or insight.title,
+        )
+    ]
+
+
+def _claim_exists(service: MemoryService, idempotency_key: str) -> bool:
+    getter = getattr(service.store, "get_claim_by_idempotency_key", None)
+    return bool(getter and getter(idempotency_key, include_citations=False))
+
+
+def _idempotency_key(insight: _DaydreamInsight) -> str:
+    title = re.sub(r"\s+", " ", insight.title.strip().lower())
+    return f"daydream:{insight.date}:{title}"
+
+
+def _subject_from_connection(connection: str) -> str:
+    words = re.findall(r"[A-Za-z0-9_]+", connection)
+    return " ".join(words[:3]) if words else "daydream insight"
+
+
+def _dict_value(value: Any) -> dict[str, Any]:
+    return value if isinstance(value, dict) else {}
+
+
+def _text_value(value: Any) -> str:
+    return str(value).strip() if value is not None else ""
+
+
+def _float_value(value: Any) -> float | None:
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _normalize_date(value: Any) -> str:
+    text = _clean_wikilink(_text_value(value))
+    match = re.search(r"(\d{4})-?(\d{2})-?(\d{2})", text)
+    if match:
+        return f"{match.group(1)}-{match.group(2)}-{match.group(3)}"
+    return "unknown-date"
+
+
+def _date_from_filename(path: Path) -> str:
+    return _normalize_date(path.stem)
+
+
+def _clean_wikilink(value: str) -> str:
+    value = value.strip()
+    match = re.fullmatch(r"\[\[([^|\]]+)(?:\|[^\]]+)?\]\]", value)
+    return match.group(1).strip() if match else value
+
+
+def _split_frontmatter(raw: str) -> tuple[dict[str, str], str]:
+    if not raw.startswith("---"):
+        return {}, raw
+    parts = raw.split("---", 2)
+    if len(parts) < 3:
+        return {}, raw
+    return _parse_frontmatter(parts[1]), parts[2]
+
+
+def _parse_frontmatter(raw: str) -> dict[str, str]:
+    data: dict[str, str] = {}
+    current_list: str | None = None
+    current_map: str | None = None
+    for line in raw.splitlines():
+        if not line.strip():
+            continue
+        if line.startswith("  -") and current_list:
+            existing = data.get(current_list, "")
+            data[current_list] = f"{existing}\n{line.strip()}".strip()
+            continue
+        if line.startswith("  ") and current_map and ":" in line:
+            key, value = line.strip().split(":", 1)
+            data[f"{current_map}.{key.strip()}"] = value.strip().strip("'\"")
+            continue
+        current_map = None
+        current_list = None
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        key = key.strip()
+        value = value.strip().strip("'\"")
+        data[key] = value
+        if not value:
+            current_list = key
+            current_map = key
+    return data
+
+
+def _first_heading(body: str) -> str:
+    match = re.search(r"^#\s+(.+)$", body, flags=re.MULTILINE)
+    return match.group(1).strip() if match else ""
+
+
+def _blockquote_connection(body: str) -> str:
+    match = re.search(r"^>\s*(.+)$", body, flags=re.MULTILINE)
+    return match.group(1).strip() if match else ""
+
+
+def _section_before(body: str, heading: str) -> str:
+    index = body.find(heading)
+    return body if index < 0 else body[:index]
+
+
+def _section_between(body: str, start: str, end_prefix: str) -> str:
+    start_index = body.find(start)
+    if start_index < 0:
+        return ""
+    content_start = start_index + len(start)
+    end_match = re.search(rf"^{re.escape(end_prefix)}.*$", body[content_start:], flags=re.MULTILINE)
+    if not end_match:
+        return body[content_start:].strip()
+    return body[content_start:content_start + end_match.start()].strip()

{memorymaster-3.15.1 → memorymaster-3.17.0}/memorymaster/retrieval.py

@@ -8,6 +8,7 @@ from typing import Callable, Mapping
 
 from memorymaster.config import get_config
 from memorymaster.models import Claim
+from memorymaster.recall_fusion import RRF_K_DEFAULT, rrf_fuse
 
 RETRIEVAL_MODES = ("legacy", "hybrid")
 
@@ -136,12 +137,12 @@ def rank_claims(
 def _compute_claim_score(claim: Claim, lexical: float, confidence: float, freshness: float, vector: float, vector_enabled: bool, semantic_vectors: bool) -> float:
     """Compute relevance score for a claim."""
     cfg = get_config()
+    w_l, w_c, w_f, w_v = cfg.retrieval_weights
     if vector_enabled and semantic_vectors:
-        # Real semantic embeddings: vector is the primary relevance signal
-        score = (0.30 * lexical) + (0.20 * confidence) + (0.10 * freshness) + (0.40 * vector)
+        # Real semantic embeddings use the same configurable blend as other
+        # vector-enabled ranking so env sweeps affect both paths.
+        score = (w_l * lexical) + (w_c * confidence) + (w_f * freshness) + (w_v * vector)
     elif vector_enabled:
-        # Hash-based vectors: limited semantic value, keep lexical dominant
-        w_l, w_c, w_f, w_v = cfg.retrieval_weights
         score = (w_l * lexical) + (w_c * confidence) + (w_f * freshness) + (w_v * vector)
     else:
         w_l, w_c, w_f = cfg.retrieval_weights_no_vector
@@ -180,6 +181,69 @@ def apply_session_diversity_cap(ranked: list[RankedClaim], cap: int) -> list[Ran
     return result
 
 
+def _component_rankings(rows: list[RankedClaim]) -> dict[str, list[int]]:
+    original_positions = {row.claim.id: index for index, row in enumerate(rows)}
+
+    def ranked_ids(score_attr: str) -> list[int]:
+        ordered = sorted(
+            rows,
+            key=lambda row: (
+                -float(getattr(row, score_attr)),
+                original_positions[row.claim.id],
+            ),
+        )
+        return [row.claim.id for row in ordered]
+
+    return {
+        "lexical": ranked_ids("lexical_score"),
+        "vector": ranked_ids("vector_score"),
+        "confidence": ranked_ids("confidence_score"),
+        "freshness": ranked_ids("freshness_score"),
+    }
+
+
+def apply_rrf_tiebreaker(
+    ranked: list[RankedClaim],
+    *,
+    threshold: float = 0.01,
+    k: int = RRF_K_DEFAULT,
+    enabled: bool = True,
+) -> list[RankedClaim]:
+    if not enabled or len(ranked) < 2:
+        return ranked
+
+    threshold = max(0.0, threshold)
+    threshold_epsilon = 1e-12
+    head_count = min(10, len(ranked))
+    result = list(ranked)
+    index = 0
+
+    while index < head_count:
+        group_end = index + 1
+        while (
+            group_end < head_count
+            and abs(ranked[group_end - 1].score - ranked[group_end].score)
+            <= threshold + threshold_epsilon
+        ):
+            group_end += 1
+
+        if group_end - index > 1:
+            group = ranked[index:group_end]
+            original_positions = {row.claim.id: offset for offset, row in enumerate(group)}
+            rrf_scores = rrf_fuse(_component_rankings(group), k=k)
+            result[index:group_end] = sorted(
+                group,
+                key=lambda row: (
+                    -rrf_scores.get(row.claim.id, 0.0),
+                    original_positions[row.claim.id],
+                ),
+            )
+
+        index = group_end
+
+    return result
+
+
 def rank_claim_rows(
     query_text: str,
     claims: list[Claim],
@@ -262,5 +326,11 @@ def rank_claim_rows(
         ),
         reverse=True,
     )
+    cfg = get_config()
+    ranked = apply_rrf_tiebreaker(
+        ranked,
+        threshold=cfg.rrf_tiebreaker_threshold,
+        enabled=cfg.rrf_tiebreaker_enabled,
+    )
     ranked = apply_session_diversity_cap(ranked, get_config().session_diversity_cap)
     return ranked[:limit]

{memorymaster-3.15.1 → memorymaster-3.17.0/memorymaster.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.15.1
+Version: 3.17.0
 Summary: Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration.
 Author: wolverin0
 License: MIT

{memorymaster-3.15.1 → memorymaster-3.17.0}/memorymaster.egg-info/SOURCES.txt

@@ -127,6 +127,7 @@ memorymaster/jobs/__init__.py
 memorymaster/jobs/calibration.py
 memorymaster/jobs/compact_summaries.py
 memorymaster/jobs/compactor.py
+memorymaster/jobs/daydream_ingest.py
 memorymaster/jobs/decay.py
 memorymaster/jobs/dedup.py
 memorymaster/jobs/deterministic.py
@@ -236,6 +237,7 @@ tests/test_dashboard_coverage.py
 tests/test_dashboard_latency.py
 tests/test_dashboard_lineage.py
 tests/test_dashboard_review_queue.py
+tests/test_daydream_ingest.py
 tests/test_db_merge_confidence_conflict.py
 tests/test_db_merge_coverage_v2.py
 tests/test_decay_coverage.py
@@ -306,6 +308,8 @@ tests/test_recall_vector_fallback.py
 tests/test_reliability_hardening.py
 tests/test_resolvers_concurrent_supersede.py
 tests/test_retrieval_profile.py
+tests/test_retrieval_rrf_tiebreaker.py
+tests/test_retrieval_weights.py
 tests/test_review.py
 tests/test_rl_trainer.py
 tests/test_rrf_auto_gate.py

{memorymaster-3.15.1 → memorymaster-3.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.15.1"
+version = "3.17.0"
 description = "Production-grade memory reliability system for AI coding agents. Lifecycle-managed claims with citations, conflict detection, steward governance, and MCP integration."
 license = {text = "MIT"}
 authors = [{name = "wolverin0"}]

{memorymaster-3.15.1 → memorymaster-3.17.0}/tests/test_config.py

@@ -22,7 +22,7 @@ def _reset():
 class TestConfigDefaults:
     def test_default_retrieval_weights(self):
         cfg = Config()
-        assert cfg.retrieval_weights == (0.45, 0.30, 0.15, 0.10)
+        assert cfg.retrieval_weights == (0.30, 0.20, 0.10, 0.40)
 
     def test_default_no_vector_weights(self):
         cfg = Config()
@@ -58,6 +58,12 @@ class TestConfigEnvOverrides:
         cfg = load_config()
         assert cfg.retrieval_weights == (0.40, 0.25, 0.20, 0.15)
 
+    def test_individual_retrieval_weight_env(self, monkeypatch):
+        monkeypatch.setenv("MEMORYMASTER_RETRIEVAL_WEIGHTS", "0.40,0.25,0.20,0.15")
+        monkeypatch.setenv("MEMORYMASTER_W_LEX", "0.55")
+        cfg = load_config()
+        assert cfg.retrieval_weights == (0.55, 0.25, 0.20, 0.15)
+
     def test_retrieval_weights_no_vector_env(self, monkeypatch):
         monkeypatch.setenv("MEMORYMASTER_RETRIEVAL_WEIGHTS_NO_VECTOR", "0.60,0.25,0.15")
         cfg = load_config()