memorymaster 3.22.0__tar.gz → 3.24.0__tar.gz

{memorymaster-3.22.0/memorymaster.egg-info → memorymaster-3.24.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.22.0
+Version: 3.24.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
@@ -52,7 +52,7 @@ Lifecycle-managed claims with citations, conflict detection, steward governance,
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-2214-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2230-green.svg)]()
 [![MCP Tools](https://img.shields.io/badge/MCP%20tools-24-purple.svg)]()
 [![CLI Commands](https://img.shields.io/badge/CLI%20commands-86-orange.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memorymaster.svg)](https://pypi.org/project/memorymaster/)
@@ -91,7 +91,8 @@ recent PR status, and sensitivity-filter invariants.
 - **Correction mining** (new in v3.21.0): `mine-rules` scans the verbatim transcript archive for user corrections and distills them into rule claims; the Stop hook also mines each session's latest correction automatically
 - **Versioned schema migrations** (new in v3.20.0): `migrate` applies SQLite/Postgres migrations with sha256 drift detection; incremental `export-delta` ships small claim deltas for cheap cross-machine sync
 - **Retrieval quality** (new in v3.22.0): floor-ratio boost gate (`MEMORYMASTER_BOOST_FLOOR_RATIO`) stops fresh-but-wrong claims outranking the true match; `query --explain` shows per-stage score attribution; an opt-in correctness-safe query cache (`MEMORYMASTER_QUERY_CACHE`) with a generation gate
-- **Semantic contradiction probe** (new in v3.22.0): `detect-contradictions` finds claims that genuinely contradict each other (beyond the deterministic same-subject conflict check) via an LLM judge with a Wilson-CI rate and verdict cache
+- **Semantic contradiction probe** (new in v3.22.0, wired as a steward phase in v3.23.0): `detect-contradictions` finds claims that genuinely contradict each other (beyond the deterministic same-subject conflict check) via an LLM judge with a Wilson-CI rate and verdict cache; in v3.23 the same probe runs inside `run-steward` and emits paste-ready `conflicted` proposals
+- **Verbatim archive cleanup** (new in v3.23.0): `verbatim-cleanup` dedups the raw-transcript table and optionally purges pre-#128 junk rows, with a dry-run default and FTS5 mirror sync
 - **Steward governance**: multi-probe validators (filesystem, format, citation, semantic, tool) with proposal review
 - **Conflict resolution**: 5-tier auto (confidence > freshness > citations > LLM > manual)
 - **Auto-redaction** at ingest: JWT, GitHub tokens, Bearer, AWS keys, SSH keys, custom patterns

{memorymaster-3.22.0 → memorymaster-3.24.0}/README.md

@@ -6,7 +6,7 @@ Lifecycle-managed claims with citations, conflict detection, steward governance,
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
-[![Tests](https://img.shields.io/badge/tests-2214-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2230-green.svg)]()
 [![MCP Tools](https://img.shields.io/badge/MCP%20tools-24-purple.svg)]()
 [![CLI Commands](https://img.shields.io/badge/CLI%20commands-86-orange.svg)]()
 [![PyPI](https://img.shields.io/pypi/v/memorymaster.svg)](https://pypi.org/project/memorymaster/)
@@ -45,7 +45,8 @@ recent PR status, and sensitivity-filter invariants.
 - **Correction mining** (new in v3.21.0): `mine-rules` scans the verbatim transcript archive for user corrections and distills them into rule claims; the Stop hook also mines each session's latest correction automatically
 - **Versioned schema migrations** (new in v3.20.0): `migrate` applies SQLite/Postgres migrations with sha256 drift detection; incremental `export-delta` ships small claim deltas for cheap cross-machine sync
 - **Retrieval quality** (new in v3.22.0): floor-ratio boost gate (`MEMORYMASTER_BOOST_FLOOR_RATIO`) stops fresh-but-wrong claims outranking the true match; `query --explain` shows per-stage score attribution; an opt-in correctness-safe query cache (`MEMORYMASTER_QUERY_CACHE`) with a generation gate
-- **Semantic contradiction probe** (new in v3.22.0): `detect-contradictions` finds claims that genuinely contradict each other (beyond the deterministic same-subject conflict check) via an LLM judge with a Wilson-CI rate and verdict cache
+- **Semantic contradiction probe** (new in v3.22.0, wired as a steward phase in v3.23.0): `detect-contradictions` finds claims that genuinely contradict each other (beyond the deterministic same-subject conflict check) via an LLM judge with a Wilson-CI rate and verdict cache; in v3.23 the same probe runs inside `run-steward` and emits paste-ready `conflicted` proposals
+- **Verbatim archive cleanup** (new in v3.23.0): `verbatim-cleanup` dedups the raw-transcript table and optionally purges pre-#128 junk rows, with a dry-run default and FTS5 mirror sync
 - **Steward governance**: multi-probe validators (filesystem, format, citation, semantic, tool) with proposal review
 - **Conflict resolution**: 5-tier auto (confidence > freshness > citations > LLM > manual)
 - **Auto-redaction** at ingest: JWT, GitHub tokens, Bearer, AWS keys, SSH keys, custom patterns

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "3.22.0"
+__version__ = "3.24.0"

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/cli.py

@@ -332,6 +332,7 @@ def build_parser() -> argparse.ArgumentParser:
     steward.add_argument("--probe-failure-threshold", type=int, default=3, help="Open circuit breaker for a probe type after this many timeout/error failures")
     steward.add_argument("--disable-semantic-probe", action="store_true", help="Disable semantic retrieval probe in steward planner")
     steward.add_argument("--disable-tool-probe", action="store_true", help="Disable tool/storage probe in steward planner")
+    steward.add_argument("--disable-contradiction-probe", action="store_true", help="Disable semantic contradiction probe in steward planner (v3.23)")
     steward.add_argument("--allow-sensitive", action="store_true", help="Include sensitive claims in stewardship scan")
     steward.add_argument("--apply", action="store_true", help="Apply proposed status transitions")
     steward.add_argument("--artifact-json", default="artifacts/steward/steward_report.json", help="Path to steward JSON report artifact")
@@ -464,6 +465,12 @@ def build_parser() -> argparse.ArgumentParser:
     mine_rules_cmd.add_argument("--provider", default="claude_cli", help="LLM provider for this run (default: claude_cli)")
     mine_rules_cmd.add_argument("--reset", action="store_true", help="Clear the stored watermark before running (re-scan from the start)")
 
+    verbatim_clean = sub.add_parser("verbatim-cleanup", help="Dedup the verbatim archive + optionally purge pre-#128 capture-bug junk (v3.23)")
+    verbatim_clean.add_argument("--analyze-only", dest="analyze_only", action="store_true", help="Report composition only; do not delete")
+    verbatim_clean.add_argument("--apply", action="store_true", help="Actually delete (default is dry-run)")
+    verbatim_clean.add_argument("--no-dedup", dest="no_dedup", action="store_true", help="Skip the (session_id, content) exact-dup pass")
+    verbatim_clean.add_argument("--purge-junk", dest="purge_junk", action="store_true", help="Also delete rows matching known pre-#128 junk prefixes (wiki-absorb prompt, etc.)")
+
     detect_contra = sub.add_parser("detect-contradictions", help="Find semantic contradictions between topically-similar claims via an LLM judge (v3.22)")
     detect_contra.add_argument("--limit", type=int, default=200, help="Max claims to load for pair sampling")
     detect_contra.add_argument("--sample", type=int, default=50, help="Max candidate pairs to judge this run (caps LLM calls)")

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/cli_handlers_basic.py

@@ -1228,6 +1228,7 @@ def _handle_run_steward(args: argparse.Namespace, service, parser: argparse.Argu
         probe_failure_threshold=args.probe_failure_threshold,
         enable_semantic_probe=not args.disable_semantic_probe,
         enable_tool_probe=not args.disable_tool_probe,
+        enable_contradiction_probe=not getattr(args, "disable_contradiction_probe", False),
         artifact_path=Path(args.artifact_json),
     )
     elapsed_ms = (time.perf_counter() - t0) * 1000

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/cli_handlers_curation.py

@@ -397,6 +397,42 @@ def _handle_detect_contradictions(args: argparse.Namespace, service, parser: arg
     return 0
 
 
+def _handle_verbatim_cleanup(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
+    from memorymaster.verbatim_cleanup import analyze, cleanup
+    t0 = time.perf_counter()
+    if getattr(args, "analyze_only", False):
+        result = analyze(effective_db)
+    else:
+        result = cleanup(
+            effective_db,
+            dedup=not getattr(args, "no_dedup", False),
+            purge_junk=getattr(args, "purge_junk", False),
+            dry_run=not getattr(args, "apply", False),
+        )
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        if not result.get("verbatim_present", True):
+            print("verbatim-cleanup: verbatim_memories table not present; nothing to do")
+        elif "before_total" in result:  # cleanup result
+            tag = "(dry-run)" if result["dry_run"] else "(applied)"
+            print(
+                f"verbatim-cleanup {tag}: dedup_deleted={result['dedup_deleted']}, "
+                f"junk_deleted={result['junk_deleted']}, "
+                f"before={result['before_total']} -> after={result['after_total']} "
+                f"({elapsed_ms:.0f}ms)"
+            )
+        else:  # analyze result
+            print(
+                f"verbatim analyze: total={result['total']}, distinct={result['distinct_content']}, "
+                f"duplicate_extras={result['duplicate_extras']}, "
+                f"empty_role={result['empty_role_rows']}, junk_prefix={result['junk_prefix_rows']} "
+                f"({elapsed_ms:.0f}ms)"
+            )
+    return 0
+
+
 def _handle_wiki_breakdown(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
     from memorymaster.wiki_engine import breakdown
     t0 = time.perf_counter()
@@ -759,6 +795,7 @@ COMMAND_HANDLERS: dict[str, object] = {
     "mine-transcript": _handle_mine_transcript,
     "mine-rules": _handle_mine_rules,
     "detect-contradictions": _handle_detect_contradictions,
+    "verbatim-cleanup": _handle_verbatim_cleanup,
     "verify-claims": _handle_verify_claims,
     "extract-entities": _handle_extract_entities,
     "entity-stats": _handle_entity_stats,

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/config_templates/hooks/memorymaster-auto-ingest.py

@@ -10,9 +10,8 @@ import json
 import os
 import sys
 import re
-import sqlite3
 import hashlib
-from datetime import datetime, timezone
+from datetime import datetime
 from pathlib import Path
 
 PROJECT_ROOT = "__MEMORYMASTER_PROJECT_ROOT__"
@@ -139,43 +138,40 @@ Only: bug root causes, decisions, gotchas, constraints. Never: credentials, IPs,
             return
 
         scope = "project:" + os.path.basename(cwd).lower().replace(" ", "-") if cwd else "global"
-        now = datetime.now(timezone.utc).isoformat()
 
-        conn = sqlite3.connect(DB_PATH)
+        # Route through MemoryService.ingest instead of raw SQL so claims gain
+        # the canonical ingest path: sensitivity sanitize (defense-in-depth on
+        # top of the _is_sensitive_claim drop above), content-hash + idempotency
+        # dedup, entity resolution, auto-citation, observability, and webhook.
+        # Mirrors _run_rule_extraction, which already uses the service.
+        from memorymaster.service import MemoryService
+        from memorymaster.models import CitationInput
+
+        svc = MemoryService(DB_PATH, workspace_root=Path(cwd or PROJECT_ROOT))
+        ingested = 0
         for c in claims:
             text = c.get("text", "")
             if not text or len(text) < 10:
                 continue
-            # Duplicate check by content hash
             text_hash = hashlib.sha256(text.strip().lower().encode()).hexdigest()[:16]
-            idem = f"llm-stop-{text_hash}"
-            if conn.execute("SELECT id FROM claims WHERE idempotency_key = ?", (idem,)).fetchone():
-                continue
-            cur = conn.execute(
-                """INSERT INTO claims (text, idempotency_key, normalized_text, claim_type,
-                   subject, predicate, scope, status, confidence,
-                   source_agent, created_at, updated_at, tier, version, visibility,
-                   valid_from)
-                   VALUES (?, ?, ?, ?, ?, ?, ?, 'candidate', 0.6,
-                   'llm-stop-hook', ?, ?, 'working', 1, 'public', ?)""",
-                (text, idem, text.lower(), c.get("claim_type", "fact"),
-                 c.get("subject", "codebase"), c.get("predicate", "observation"),
-                 scope, now, now, now),
-            )
-            # Auto-citation: steward's min_citations>=1 gate requires at least one
-            # row per claim. Without this, every llm-stop-hook claim is born
-            # unpromotable. Source is the hook itself; locator = scope for
-            # traceability; excerpt preserves the first 200 chars of the claim.
-            conn.execute(
-                """INSERT INTO citations (claim_id, source, locator, excerpt, created_at)
-                   VALUES (?, 'llm-stop-hook', ?, ?, ?)""",
-                (cur.lastrowid, scope, text[:200], now),
-            )
-        conn.commit()
-        conn.close()
+            try:
+                svc.ingest(
+                    text=text,
+                    citations=[CitationInput(source="llm-stop-hook", locator=scope, excerpt=text[:200])],
+                    idempotency_key=f"llm-stop-{text_hash}",
+                    claim_type=c.get("claim_type", "fact"),
+                    subject=c.get("subject", "codebase"),
+                    predicate=c.get("predicate", "observation"),
+                    scope=scope,
+                    confidence=0.6,
+                    source_agent="llm-stop-hook",
+                )
+                ingested += 1
+            except Exception:
+                continue  # one bad claim must not abort the rest
 
         provider = os.environ.get("MEMORYMASTER_LLM_PROVIDER", "google")
-        sys.stderr.write(f"[MemoryMaster] {provider} extracted {len(claims)} learnings\n")
+        sys.stderr.write(f"[MemoryMaster] {provider} extracted {ingested} learnings\n")
     except Exception:
         pass
 

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/contradiction_probe.py

@@ -26,6 +26,7 @@ import logging
 import math
 import os
 import sqlite3
+import time
 from datetime import datetime, timezone
 from typing import Any
 
@@ -33,6 +34,7 @@ from memorymaster import llm_budget, llm_provider
 from memorymaster.embeddings import EmbeddingProvider, cosine_similarity, create_best_provider
 from memorymaster.lifecycle import transition_claim
 from memorymaster.models import Claim
+from memorymaster.security import redact_text
 
 logger = logging.getLogger(__name__)
 
@@ -324,3 +326,130 @@ def run_probe(
         lo, hi = wilson_interval(stats["contradictions"], n)
         stats["rate_ci"] = [round(lo, 4), round(hi, 4)]
     return stats
+
+
+# ---------------------------------------------------------------------------
+# Per-claim steward-phase entry point (v3.23)
+# ---------------------------------------------------------------------------
+
+
+def probe_for_claim(
+    service: Any,
+    claim: Any,
+    *,
+    sim_low: float = 0.60,
+    sim_high: float = 0.92,
+    max_pairs: int = 5,
+    peer_limit: int = 20,
+) -> dict[str, Any]:
+    """Per-claim contradiction probe for the steward cycle.
+
+    Finds topically-similar peers for ``claim`` via the existing hybrid
+    retrieval (so we reuse the embedder + ranker + cache), excludes pairs the
+    deterministic resolver / supersession owns, judges remaining candidates
+    against the verdict cache + LLM, and returns a normalized result dict the
+    steward wraps in a ``ProbeResult``.
+
+    Returns ``{passed, reasons: [...], metrics: {...}}``. ``passed`` is False
+    iff at least one contradiction was found.
+    """
+    started = time.monotonic()
+    metrics: dict[str, Any] = {
+        "pairs_checked": 0, "contradictions": 0,
+        "cache_hits": 0, "llm_calls": 0, "errors": 0,
+        "timed_out": False, "duration_ms": 0.0,
+    }
+    reasons: list[dict[str, Any]] = []
+
+    def _done(passed: bool) -> dict[str, Any]:
+        metrics["duration_ms"] = round((time.monotonic() - started) * 1000.0, 3)
+        return {"passed": passed, "reasons": reasons, "metrics": metrics}
+
+    if claim.status in _SKIP_STATUSES or not (claim.text or "").strip():
+        return _done(True)
+
+    try:
+        peers_rows = service.query_rows(
+            query_text=claim.text or "",
+            limit=peer_limit,
+            retrieval_mode="hybrid",
+            include_candidates=True,
+            include_stale=True,
+            include_conflicted=True,
+        )
+    except Exception as exc:
+        reasons.append({
+            "code": "contradiction_probe.peer_fetch.error",
+            "severity": "low",
+            "detail": f"peer fetch failed: {type(exc).__name__}",
+            "evidence": {},
+        })
+        return _done(False)
+
+    candidates: list[tuple[Any, float]] = []
+    for row in peers_rows:
+        peer = row.get("claim")
+        if peer is None or peer.id == claim.id:
+            continue
+        if peer.status in _SKIP_STATUSES:
+            continue
+        if _same_subject_predicate(claim, peer):
+            continue  # deterministic resolver's domain
+        if _already_linked(claim, peer):
+            continue
+        vs = float(row.get("vector_score") or 0.0)
+        # If vectors are present, only accept pairs in the contradiction band.
+        # If absent (pure-lexical hybrid), accept all topical peers.
+        if vs > 0.0 and not (sim_low <= vs < sim_high):
+            continue
+        candidates.append((peer, vs))
+        if len(candidates) >= max_pairs:
+            break
+
+    if not candidates:
+        return _done(True)
+
+    db_path = getattr(service.store, "db_path", None)
+    if not db_path or "://" in str(db_path):
+        return _done(True)  # verdict cache requires SQLite; skip silently on PG
+
+    conn = sqlite3.connect(str(db_path))
+    try:
+        _ensure_verdict_table(conn)
+        model = _model_key()
+        for peer, sim in candidates:
+            metrics["pairs_checked"] += 1
+            verdict = _cache_get(conn, claim.id, peer.id, model)
+            if verdict is not None:
+                metrics["cache_hits"] += 1
+            else:
+                try:
+                    verdict = _judge_llm(claim, peer)
+                except llm_budget.LLMBudgetExceeded:
+                    metrics["timed_out"] = True
+                    break
+                metrics["llm_calls"] += 1
+                if verdict is None:
+                    metrics["errors"] += 1
+                    continue
+                _cache_put(conn, claim.id, peer.id, model, verdict)
+            if not verdict.get("contradicts"):
+                continue
+            verdict_reason = verdict.get("reason", "")
+            _, leaks = redact_text(verdict_reason)
+            if leaks:
+                continue  # drop rather than surface a sensitive judge-reason
+            metrics["contradictions"] += 1
+            reasons.append({
+                "code": "contradiction_probe.semantic_pair",
+                "severity": verdict.get("severity", "medium"),
+                "detail": f"Semantic contradiction with claim {peer.id}: {verdict_reason}",
+                "evidence": {
+                    "peer_claim_id": int(peer.id),
+                    "similarity": round(float(sim), 4),
+                    "from_cache": bool(verdict.get("cached")),
+                },
+            })
+    finally:
+        conn.close()
+    return _done(metrics["contradictions"] == 0)

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/query_cache.py

@@ -84,11 +84,31 @@ def current_generation(conn: sqlite3.Connection) -> int:
     return int(row[0]) if row else 0
 
 
+def read_generation(db_path: str) -> int:
+    """Return the current corpus generation, or 0 on any error.
+
+    Callers capture this BEFORE reading the corpus they are about to compute a
+    result from, then pass it to ``write()`` — see the TOCTOU note there."""
+    try:
+        conn = _connect(db_path)
+    except sqlite3.Error as exc:
+        logger.warning("query_cache.read_generation connect failed: %s", exc)
+        return 0
+    try:
+        return current_generation(conn)
+    except (sqlite3.Error, ValueError) as exc:
+        logger.warning("query_cache.read_generation failed: %s", exc)
+        return 0
+    finally:
+        conn.close()
+
+
 def read(db_path: str, cache_key: str) -> list[dict] | None:
     """Return cached result stubs if present AND still fresh (generation match)."""
     try:
         conn = _connect(db_path)
-    except sqlite3.Error:
+    except sqlite3.Error as exc:
+        logger.warning("query_cache.read connect failed: %s", exc)
         return None
     try:
         gen = current_generation(conn)
@@ -99,20 +119,31 @@ def read(db_path: str, cache_key: str) -> list[dict] | None:
         if row is None or int(row["generation"]) != gen:
             return None
         return json.loads(row["result_json"])
-    except (sqlite3.Error, json.JSONDecodeError, ValueError):
+    except (sqlite3.Error, json.JSONDecodeError, ValueError) as exc:
+        logger.warning("query_cache.read failed (cache disabled for this query): %s", exc)
         return None
     finally:
         conn.close()
 
 
-def write(db_path: str, cache_key: str, stub_rows: list[dict]) -> None:
-    """Store result stubs tagged with the current generation. Best-effort."""
+def write(db_path: str, cache_key: str, stub_rows: list[dict], generation: int) -> None:
+    """Store result stubs tagged with ``generation``. Best-effort.
+
+    TOCTOU correctness: ``generation`` MUST be the corpus generation captured by
+    the caller BEFORE it read the candidates it computed ``stub_rows`` from. If
+    we re-read the generation here instead, a claim write that raced in between
+    the caller's corpus read and this write would have bumped the counter, and
+    we would tag a stale (generation-G) result as the new generation (G+1) — so
+    a subsequent read at G+1 would serve the stale ranking, defeating the
+    generation gate. Tagging with the compute-time generation guarantees any
+    racing write correctly invalidates this entry. (audit: qc-generation-toctou)
+    """
     try:
         conn = _connect(db_path)
-    except sqlite3.Error:
+    except sqlite3.Error as exc:
+        logger.warning("query_cache.write connect failed: %s", exc)
         return
     try:
-        gen = current_generation(conn)
         conn.execute(
             """INSERT INTO query_cache (cache_key, result_json, generation, created_at)
                VALUES (?, ?, ?, ?)
@@ -120,10 +151,10 @@ def write(db_path: str, cache_key: str, stub_rows: list[dict]) -> None:
                    result_json = excluded.result_json,
                    generation = excluded.generation,
                    created_at = excluded.created_at""",
-            (cache_key, json.dumps(stub_rows), gen, datetime.now(timezone.utc).isoformat()),
+            (cache_key, json.dumps(stub_rows), generation, datetime.now(timezone.utc).isoformat()),
         )
         conn.commit()
-    except (sqlite3.Error, TypeError, ValueError):
-        pass
+    except (sqlite3.Error, TypeError, ValueError) as exc:
+        logger.warning("query_cache.write failed (result not cached): %s", exc)
     finally:
         conn.close()

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/security.py

@@ -157,6 +157,8 @@ class SanitizedClaimInput:
     is_sensitive: bool
     findings: list[str]
     encrypted_payload: str | None
+    subject: str | None = None
+    predicate: str | None = None
 
 
 def _as_bool(value: object, *, field: str) -> bool:
@@ -320,6 +322,8 @@ def sanitize_claim_input(
     text: str,
     object_value: str | None,
     citations: list[CitationInput],
+    subject: str | None = None,
+    predicate: str | None = None,
 ) -> SanitizedClaimInput:
     redacted_text, findings = _redact(text)
     redacted_object = object_value
@@ -328,6 +332,19 @@ def sanitize_claim_input(
         redacted_object, object_findings = _redact(object_value)
         findings.extend(object_findings)
 
+    # subject/predicate are structured-claim fields that reach the store
+    # alongside text/object_value. They are exposed MCP ingest parameters, so a
+    # secret placed there must be caught by the ingest filter — the last line of
+    # defense — not only at display time. (audit: ingest-subject-skips-filter)
+    redacted_subject = subject
+    if subject:
+        redacted_subject, subject_findings = _redact(subject)
+        findings.extend(subject_findings)
+    redacted_predicate = predicate
+    if predicate:
+        redacted_predicate, predicate_findings = _redact(predicate)
+        findings.extend(predicate_findings)
+
     sanitized_citations: list[CitationInput] = []
     citation_findings: list[str] = []
     for cite in citations:
@@ -344,6 +361,8 @@ def sanitize_claim_input(
         {
             "text": text,
             "object_value": object_value,
+            "subject": subject,
+            "predicate": predicate,
             "citations": [asdict(c) for c in citations],
         }
     ) if is_sensitive else None
@@ -355,6 +374,8 @@ def sanitize_claim_input(
         is_sensitive=is_sensitive,
         findings=dedup_findings,
         encrypted_payload=encrypted_payload,
+        subject=redacted_subject,
+        predicate=redacted_predicate,
     )
 
 

{memorymaster-3.22.0 → memorymaster-3.24.0}/memorymaster/service.py

@@ -251,9 +251,15 @@ class MemoryService:
             text=text.strip(),
             object_value=object_value,
             citations=citations,
+            subject=subject,
+            predicate=predicate,
         )
         if not sanitized.citations:
             raise ValueError("At least one citation is required.")
+        # Use the sanitized subject/predicate everywhere downstream so a secret
+        # placed in those fields is redacted at rest, not just at display time.
+        subject = sanitized.subject
+        predicate = sanitized.predicate
         # Resolve subject → canonical entity (GBrain-inspired entity registry)
         # and mine text for pattern-based entities (#127 Wave 3).
         entity_id = 0
@@ -667,6 +673,11 @@ class MemoryService:
                     rows = self._rehydrate_cached_rows(cached)
                     self._record_accesses(rows, query_text=query_text)
                     return rows
+        # Capture the corpus generation BEFORE reading candidates so the cache
+        # entry is tagged with the generation it was actually computed against,
+        # not whatever it is after ranking/LLM-rerank (which a concurrent claim
+        # write could have bumped). See query_cache.write TOCTOU note.
+        cache_generation = query_cache.read_generation(cache_path) if cache_path else 0
         candidate_limit = max(limit * 6, 60, 50 if use_llm_rerank else 0)
         candidates = self.store.list_claims(
             limit=candidate_limit,
@@ -733,7 +744,7 @@ class MemoryService:
                     "breakdown": r.get("breakdown"),
                 }
                 for r in results if r.get("claim") is not None
-            ])
+            ], cache_generation)
         return results
 
     def _rehydrate_cached_rows(self, stubs: list[dict[str, Any]]) -> list[dict[str, Any]]: