memorymaster 3.19.0__tar.gz → 3.22.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.19.0
+Version: 3.22.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-1953-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2214-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/)
@@ -87,6 +87,11 @@ recent PR status, and sensitivity-filter invariants.
 - **Hybrid retrieval**: vector (sentence-transformers / Gemini) + FTS5 + freshness + confidence
 - **Context optimizer**: `query_for_context(budget=4000)` returns auto-curated memory that fits your token budget
 - **Entity graph** with typed relationships and alias resolution
+- **Rule-shaped claims** (new in v3.21.0): prescriptive `when <trigger>, do <action> because <rationale>` claims (`ingest_rule` / `query_rules`) — the shape an agent needs to actually change behaviour next time, not just recall a fact
+- **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
 - **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
@@ -187,7 +192,7 @@ For zero-cost offline use, install [Ollama](https://ollama.com), `ollama pull ll
 }
 ```
 
-22 MCP tools: `init_db`, `ingest_claim`, `run_cycle`, `run_steward`, `classify_query`, `query_memory`, `query_for_context`, `list_claims`, `redact_claim_payload`, `pin_claim`, `compact_memory`, `list_events`, `search_verbatim`, `open_dashboard`, `list_steward_proposals`, `resolve_steward_proposal`, `extract_entities`, `entity_stats`, `find_related_claims`, `quality_scores`, `recompute_tiers`, `federated_query`.
+24 MCP tools: `init_db`, `ingest_claim`, `ingest_rule`, `query_rules`, `run_cycle`, `run_steward`, `classify_query`, `query_memory`, `query_for_context`, `list_claims`, `redact_claim_payload`, `pin_claim`, `compact_memory`, `list_events`, `search_verbatim`, `open_dashboard`, `list_steward_proposals`, `resolve_steward_proposal`, `extract_entities`, `entity_stats`, `find_related_claims`, `quality_scores`, `recompute_tiers`, `federated_query`.
 
 See [`.mcp.json.example`](.mcp.json.example) for the full template.
 

{memorymaster-3.19.0 → memorymaster-3.22.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-1953-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2214-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/)
@@ -41,6 +41,11 @@ recent PR status, and sensitivity-filter invariants.
 - **Hybrid retrieval**: vector (sentence-transformers / Gemini) + FTS5 + freshness + confidence
 - **Context optimizer**: `query_for_context(budget=4000)` returns auto-curated memory that fits your token budget
 - **Entity graph** with typed relationships and alias resolution
+- **Rule-shaped claims** (new in v3.21.0): prescriptive `when <trigger>, do <action> because <rationale>` claims (`ingest_rule` / `query_rules`) — the shape an agent needs to actually change behaviour next time, not just recall a fact
+- **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
 - **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
@@ -141,7 +146,7 @@ For zero-cost offline use, install [Ollama](https://ollama.com), `ollama pull ll
 }
 ```
 
-22 MCP tools: `init_db`, `ingest_claim`, `run_cycle`, `run_steward`, `classify_query`, `query_memory`, `query_for_context`, `list_claims`, `redact_claim_payload`, `pin_claim`, `compact_memory`, `list_events`, `search_verbatim`, `open_dashboard`, `list_steward_proposals`, `resolve_steward_proposal`, `extract_entities`, `entity_stats`, `find_related_claims`, `quality_scores`, `recompute_tiers`, `federated_query`.
+24 MCP tools: `init_db`, `ingest_claim`, `ingest_rule`, `query_rules`, `run_cycle`, `run_steward`, `classify_query`, `query_memory`, `query_for_context`, `list_claims`, `redact_claim_payload`, `pin_claim`, `compact_memory`, `list_events`, `search_verbatim`, `open_dashboard`, `list_steward_proposals`, `resolve_steward_proposal`, `extract_entities`, `entity_stats`, `find_related_claims`, `quality_scores`, `recompute_tiers`, `federated_query`.
 
 See [`.mcp.json.example`](.mcp.json.example) for the full template.
 

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

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

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

@@ -23,7 +23,9 @@ from memorymaster.cli_handlers_curation import COMMAND_HANDLERS
 from memorymaster.cli_handlers_basic import (
     _handle_decay,
     _handle_entity_graph_export,
+    _handle_export_delta,
     _handle_ingest_daydream,
+    _handle_migrate,
     _handle_recompute_confidence_priors,
     _handle_wiki_suggest_links,
     handle_mcp_usage_report,
@@ -38,6 +40,8 @@ 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)
 )
+COMMAND_HANDLERS["migrate"] = _handle_migrate
+COMMAND_HANDLERS["export-delta"] = _handle_export_delta
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -51,6 +55,11 @@ def build_parser() -> argparse.ArgumentParser:
 
     sub.add_parser("init-db", help="Create schema in SQLite database")
 
+    migrate = sub.add_parser("migrate", help="Apply pending versioned schema migrations (v3.20.0+)")
+    migrate_mode = migrate.add_mutually_exclusive_group()
+    migrate_mode.add_argument("--list", action="store_true", help="List known migrations without touching the DB")
+    migrate_mode.add_argument("--status", action="store_true", help="Report applied vs pending per migration")
+
     sub.add_parser("stealth-status", help="Show whether stealth mode is active and which DB is in use")
 
     ingest = sub.add_parser("ingest", help="Ingest a raw claim with citations")
@@ -176,6 +185,7 @@ def build_parser() -> argparse.ArgumentParser:
     query.add_argument("--scope-allowlist", default="", help="Comma-separated scopes to include (e.g. project,team_x)")
     query.add_argument("--as-of", default="", help="Temporal query: show claims valid at this ISO timestamp")
     query.add_argument("--auto-classify", action="store_true", help="Auto-classify query type and use optimal retrieval mode")
+    query.add_argument("--explain", action="store_true", help="Show per-stage score attribution (relevance vs. boosts, floor-gate status) for each result")
 
     context = sub.add_parser("context", help="Pack relevant claims into a token-budgeted context block for AI agents")
     context.add_argument("text", help="Query text describing what context is needed")
@@ -447,6 +457,20 @@ def build_parser() -> argparse.ArgumentParser:
     mine_cmd.add_argument("--scope", default="project", help="Scope for ingested claims")
     mine_cmd.add_argument("--max", type=int, default=100, help="Max claims to ingest")
 
+    mine_rules_cmd = sub.add_parser("mine-rules", help="Mine verbatim corrections into rule-shaped claims (v3.21.0-R1b)")
+    mine_rules_cmd.add_argument("--since-id", dest="since_id", type=int, default=None, help="Override the stored watermark; start scanning after this verbatim id")
+    mine_rules_cmd.add_argument("--limit", type=int, default=None, help="Max candidate windows to examine this run (caps LLM calls)")
+    mine_rules_cmd.add_argument("--batch-size", dest="batch_size", type=int, default=200, help="Rows fetched per SQL pre-filter page (default: 200)")
+    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)")
+
+    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)")
+    detect_contra.add_argument("--sim-low", dest="sim_low", type=float, default=0.60, help="Lower similarity-band bound (below = unrelated)")
+    detect_contra.add_argument("--sim-high", dest="sim_high", type=float, default=0.92, help="Upper similarity-band bound (at/above = near-duplicates, dedup's job)")
+    detect_contra.add_argument("--apply", action="store_true", help="Flag the lower-confidence claim of each contradicting pair as conflicted (reversible)")
+
     verify_cmd = sub.add_parser("verify-claims", help="Cross-check claims against current codebase")
     verify_cmd.add_argument("--scope", default="", help="Scope filter")
     verify_cmd.add_argument("--limit", type=int, default=200, help="Max claims to check")
@@ -504,6 +528,13 @@ def build_parser() -> argparse.ArgumentParser:
     merge_cmd = sub.add_parser("merge-db", help="Merge claims from a remote memorymaster DB (bidirectional sync)")
     merge_cmd.add_argument("--source", required=True, help="Path to source DB file to merge from")
 
+    delta_cmd = sub.add_parser(
+        "export-delta",
+        help="Export claims changed since a watermark into a small SQLite delta file (incremental sync)",
+    )
+    delta_cmd.add_argument("--since", default="", help="ISO-8601 watermark; export claims with updated_at after this (empty = full export)")
+    delta_cmd.add_argument("--output", required=True, help="Path to write the delta SQLite file (overwritten if it exists)")
+
     daily = sub.add_parser("daily-note", help="Generate a daily note summarizing today's activity")
     daily.add_argument("--date", default="", help="Date to generate for (YYYY-MM-DD, default: today)")
     daily.add_argument("--output", default="", help="Directory to save .md file (default: print to stdout)")
@@ -556,7 +587,7 @@ def main(argv: list[str] | None = None) -> int:
     effective_db = _resolve_db_path(args)
 
     # Commands that don't need MemoryService run first; service is lazy-created once for all others.
-    _NO_SERVICE_COMMANDS = {"stealth-status", "export-metrics", "wiki-freshness", "mcp-usage-report"}
+    _NO_SERVICE_COMMANDS = {"stealth-status", "export-metrics", "wiki-freshness", "mcp-usage-report", "export-delta"}
 
     try:
         handler = COMMAND_HANDLERS.get(args.command)

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

@@ -832,6 +832,25 @@ def _handle_run_cycle(args: argparse.Namespace, service, parser: argparse.Argume
     return 0
 
 
+def _print_score_explanation(breakdown: dict | None) -> None:
+    """Render per-stage score attribution for `query --explain`.
+
+    Shows query-relevance vs. the metadata boost terms and whether the
+    floor-ratio gate suppressed the boosts for this result.
+    """
+    if not breakdown:
+        print("    explain: (no breakdown — legacy retrieval mode)")
+        return
+    terms = breakdown.get("boost_terms", {})
+    w = breakdown.get("weights", (0, 0, 0, 0))
+    applied = breakdown.get("boosts_applied", True)
+    gate = "applied" if applied else f"GATED (relevance < floor={breakdown.get('floor', 0.0):.3f})"
+    term_str = " ".join(f"{k}={v:+.3f}" for k, v in terms.items())
+    print(f"    explain: relevance={breakdown.get('relevance', 0.0):.3f} "
+          f"boosts={breakdown.get('boosts_total', 0.0):+.3f} [{gate}] -> final={breakdown.get('final', 0.0):.3f}")
+    print(f"             weights(l,c,f,v)={tuple(round(x, 2) for x in w)}  boost_terms: {term_str}")
+
+
 def _handle_query(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
     resolve_allow_sensitive_access(allow_sensitive=args.allow_sensitive, context="cli.query")
     if getattr(args, "as_of", ""):
@@ -876,6 +895,8 @@ def _handle_query(args: argparse.Namespace, service, parser: argparse.ArgumentPa
                   f"vec={sc['vector_score']:.3f} "
                   f"active={int(bool(ann.get('active')))} stale={int(bool(ann.get('stale')))} "
                   f"conflicted={int(bool(ann.get('conflicted')))} pinned={int(bool(ann.get('pinned')))}")
+            if getattr(args, "explain", False):
+                _print_score_explanation(row.get("breakdown"))
         print(f"rows={len(rows_data)}")
     return 0
 
@@ -1357,3 +1378,95 @@ def _handle_check_staleness(args: argparse.Namespace, service, parser: argparse.
     return 0
 
 
+def _handle_migrate(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
+    """v3.20.0-S1: apply pending schema migrations, or report status.
+
+    Default (no flags): apply every pending migration in version order.
+    --list: dump known migrations (version + description) without touching the DB.
+    --status: query the DB and show applied vs pending per migration.
+    """
+    from memorymaster.migrations import (
+        MigrationRunner,
+        discover_migrations,
+    )
+    from memorymaster.store_factory import is_postgres_dsn
+
+    # --list works without a DB connection at all.
+    if getattr(args, "list", False):
+        migrations = discover_migrations()
+        if args.json_output:
+            payload = [{"version": m.version, "description": m.description} for m in migrations]
+            print(_json_envelope(payload))
+        else:
+            print(f"known migrations ({len(migrations)}):")
+            for m in migrations:
+                print(f"  v{m.version:04d}  {m.description}")
+        return 0
+
+    backend = "postgres" if is_postgres_dsn(effective_db) else "sqlite"
+    store = service.store
+    with store.connect() as conn:
+        runner = MigrationRunner(conn, backend=backend)
+
+        if getattr(args, "status", False):
+            entries = runner.status()
+            if args.json_output:
+                payload = [
+                    {
+                        "version": e.version,
+                        "description": e.description,
+                        "applied": e.applied,
+                        "applied_at": e.applied_at,
+                    }
+                    for e in entries
+                ]
+                print(_json_envelope(payload))
+            else:
+                print(f"backend={backend} db={effective_db}")
+                for e in entries:
+                    marker = "[applied]" if e.applied else "[pending]"
+                    when = f" applied_at={e.applied_at}" if e.applied_at else ""
+                    print(f"  v{e.version:04d}  {marker} {e.description}{when}")
+            return 0
+
+        # Default: apply pending
+        newly = runner.apply_pending()
+        if args.json_output:
+            print(_json_envelope({"applied": newly, "backend": backend}))
+        else:
+            if not newly:
+                print(f"migrate: nothing to apply (backend={backend}, db={effective_db})")
+            else:
+                print(f"migrate: applied {len(newly)} migration(s) on backend={backend}:")
+                for v in newly:
+                    print(f"  v{v:04d}")
+    return 0
+
+
+def _handle_export_delta(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
+    """Export claims changed since a watermark into a small SQLite delta file.
+
+    The delta file is a valid `merge-db --source` input. Prints (or JSON-emits)
+    the export counts and the new watermark — callers should record
+    `max_updated_at` and pass it as `--since` on the next run.
+    """
+    from memorymaster.delta_sync import export_delta
+
+    t0 = time.perf_counter()
+    result = export_delta(effective_db, args.since, args.output)
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        since_label = result["since"] or "(full export)"
+        print(
+            f"export-delta: {result['exported']} claims + {result['citations']} citations "
+            f"since {since_label} -> {args.output}"
+        )
+        if result["max_updated_at"]:
+            print(f"  next watermark (--since): {result['max_updated_at']}")
+        else:
+            print("  delta is empty — nothing changed since the watermark")
+    return 0
+
+

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

@@ -343,6 +343,60 @@ def _handle_mine_transcript(args: argparse.Namespace, service, parser: argparse.
     return 0
 
 
+def _handle_mine_rules(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
+    from memorymaster.rule_miner import mine_rules
+    t0 = time.perf_counter()
+    result = mine_rules(
+        effective_db,
+        service,
+        since_id=getattr(args, "since_id", None),
+        limit=getattr(args, "limit", None),
+        batch_size=getattr(args, "batch_size", 200),
+        provider=getattr(args, "provider", "claude_cli"),
+        reset=getattr(args, "reset", False),
+    )
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        abort = f", ABORTED ({result['aborted_reason']})" if result.get("aborted_reason") else ""
+        print(
+            f"Mined rules: {result['candidates']} candidates, {result['llm_calls']} llm calls, "
+            f"{result['ingested']} ingested, {result['duplicates']} dupes, {result['skipped']} skipped "
+            f"(watermark={result['last_id']}{abort}, {elapsed_ms:.0f}ms)"
+        )
+    return 0
+
+
+def _handle_detect_contradictions(args: argparse.Namespace, service, parser: argparse.ArgumentParser, effective_db: str) -> int:
+    from memorymaster.contradiction_probe import run_probe
+    t0 = time.perf_counter()
+    result = run_probe(
+        effective_db, service,
+        limit=getattr(args, "limit", 200),
+        sample=getattr(args, "sample", 50),
+        sim_low=getattr(args, "sim_low", 0.60),
+        sim_high=getattr(args, "sim_high", 0.92),
+        apply=getattr(args, "apply", False),
+    )
+    elapsed_ms = (time.perf_counter() - t0) * 1000
+    if args.json_output:
+        print(_json_envelope(result, query_ms=elapsed_ms))
+    else:
+        ci = result["rate_ci"]
+        abort = f", ABORTED ({result['aborted_reason']})" if result.get("aborted_reason") else ""
+        print(
+            f"Contradictions: {result['contradictions']}/{result['judged']} judged "
+            f"(rate={result['rate']:.2f} CI95=[{ci[0]:.2f},{ci[1]:.2f}]) from "
+            f"{result['candidate_pairs']} candidate pairs; cache_hits={result['cache_hits']}, "
+            f"errors={result['judge_errors']}, flagged={result['flagged_conflicted']}{abort} ({elapsed_ms:.0f}ms)"
+        )
+        for f in result["found"][:20]:
+            print(f"  [{f['severity']}] claims {f['claim_a_id']} <> {f['claim_b_id']} "
+                  f"(sim={f['similarity']}): {f['reason']}")
+    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()
@@ -703,6 +757,8 @@ COMMAND_HANDLERS: dict[str, object] = {
     "wiki-freshness": _handle_wiki_freshness,
     "bases-generate": _handle_bases_generate,
     "mine-transcript": _handle_mine_transcript,
+    "mine-rules": _handle_mine_rules,
+    "detect-contradictions": _handle_detect_contradictions,
     "verify-claims": _handle_verify_claims,
     "extract-entities": _handle_extract_entities,
     "entity-stats": _handle_entity_stats,

{memorymaster-3.19.0 → memorymaster-3.22.0}/memorymaster/config.py

@@ -222,6 +222,11 @@ class Config:
     llm_rerank: bool = False
     rrf_tiebreaker_enabled: bool = False
     rrf_tiebreaker_threshold: float = 0.01
+    # Floor-ratio gate (gbrain v0.35.6 "hybrid.floor_ratio"): metadata boosts
+    # (confidence/freshness/tier/pinned) only apply to candidates whose
+    # query-relevance (lexical+vector) is >= boost_floor_ratio * top relevance.
+    # 0.0 = disabled (boosts always apply) — preserves pre-v3.22 behaviour.
+    boost_floor_ratio: float = 0.0
 
     # --- Initial confidence priors calibrated from validator outcomes ---
     default_initial_confidence: float = DEFAULT_INITIAL_CONFIDENCE
@@ -397,6 +402,7 @@ def load_config(config_path: str | Path | None = None) -> Config:
     _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")
+    _apply_env_float(overrides, "MEMORYMASTER_BOOST_FLOOR_RATIO", "boost_floor_ratio")
     _apply_env_retrieval_profiles(overrides)
 
     # Filter to only valid Config fields

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

@@ -180,6 +180,27 @@ Only: bug root causes, decisions, gotchas, constraints. Never: credentials, IPs,
         pass
 
 
+def _run_rule_extraction(transcript_path, cwd):
+    """R1b ongoing: mine the latest correction in this session into a rule claim.
+
+    Reuses memorymaster.rule_miner.mine_transcript_rules (single source of truth
+    for the correction->rule prompt + ingest path). Bounded to one window per
+    stop to keep the hook fast; rules land as low-confidence candidates."""
+    try:
+        if not transcript_path or not os.path.exists(transcript_path) or not os.path.exists(DB_PATH):
+            return
+        from memorymaster.rule_miner import mine_transcript_rules
+        from memorymaster.service import MemoryService
+
+        scope = "project:" + os.path.basename(cwd).lower().replace(" ", "-") if cwd else "global"
+        svc = MemoryService(DB_PATH, workspace_root=Path(cwd or PROJECT_ROOT))
+        stats = mine_transcript_rules(transcript_path, svc, scope=scope, max_windows=1)
+        if stats.get("ingested"):
+            sys.stderr.write(f"[MemoryMaster] mined {stats['ingested']} rule(s) from corrections\n")
+    except Exception:
+        pass
+
+
 def main():
     try:
         data = json.loads(sys.stdin.read() or "{}")
@@ -232,6 +253,9 @@ def main():
     # Not time to block — run passive Gemini extraction
     _run_gemini_extraction(transcript_path, cwd)
 
+    # R1b: mine the latest correction in this session into a rule claim
+    _run_rule_extraction(transcript_path, cwd)
+
     sys.stdout.write(json.dumps({"decision": "approve"}))