memorymaster 3.24.0__tar.gz → 3.25.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.24.0
+Version: 3.25.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-2230-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2232-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/)

{memorymaster-3.24.0 → memorymaster-3.25.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-2230-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2232-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/)

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

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

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

@@ -357,7 +357,7 @@ def probe_for_claim(
     metrics: dict[str, Any] = {
         "pairs_checked": 0, "contradictions": 0,
         "cache_hits": 0, "llm_calls": 0, "errors": 0,
-        "timed_out": False, "duration_ms": 0.0,
+        "timed_out": False, "budget_exhausted": False, "duration_ms": 0.0,
     }
     reasons: list[dict[str, Any]] = []
 
@@ -426,7 +426,11 @@ def probe_for_claim(
                 try:
                     verdict = _judge_llm(claim, peer)
                 except llm_budget.LLMBudgetExceeded:
-                    metrics["timed_out"] = True
+                    # Budget exhaustion is an expected guardrail, NOT a probe
+                    # failure — the steward must not count it toward the circuit
+                    # breaker (which would disable the probe for the rest of the
+                    # cycle). Flag it distinctly from a genuine timeout.
+                    metrics["budget_exhausted"] = True
                     break
                 metrics["llm_calls"] += 1
                 if verdict is None:

{memorymaster-3.24.0 → memorymaster-3.25.0}/memorymaster/rule_miner.py

@@ -158,12 +158,26 @@ def _build_window(assistant_content: str, user_content: str) -> str:
     return f"ASSISTANT: {asst}\nUSER: {user}"
 
 
+class TransientLLMError(RuntimeError):
+    """The LLM provider returned an empty response — almost always a transient
+    failure (outage, timeout, rate-limit returning ''), NOT a genuine "no
+    correction" verdict. Callers must distinguish the two: advancing the
+    watermark past a candidate that was never actually judged would permanently
+    skip real corrections during a provider outage. (audit:
+    mine-rules-silent-watermark-advance)"""
+
+
 def _extract_rule(window: str) -> dict[str, str] | None:
     """Ask the LLM to distill a rule. Returns ``{trigger, action, rationale}``
-    or ``None`` when there is no correction. May raise ``LLMBudgetExceeded``."""
+    or ``None`` when the model responded but found no correction.
+
+    Raises ``LLMBudgetExceeded`` if the per-cycle cap is hit, and
+    ``TransientLLMError`` if the provider returned nothing (so the caller can
+    avoid advancing the watermark). A non-empty response that simply doesn't
+    parse to a rule is a genuine "no correction" (``None``), not transient."""
     raw = llm_provider.call_llm(_CORRECTION_PROMPT, window)
     if not raw or not raw.strip():
-        return None
+        raise TransientLLMError("empty LLM response")
     for item in llm_provider.parse_json_response(raw):
         if not isinstance(item, dict):
             continue
@@ -300,6 +314,12 @@ def _process_candidate(
     except llm_budget.LLMBudgetExceeded as exc:
         stats["aborted_reason"] = exc.reason
         return "aborted"
+    except TransientLLMError:
+        # Provider returned empty (likely transient outage). Abort the run WITHOUT
+        # advancing the watermark past this row, so the candidate is retried next
+        # run instead of silently skipped. Stopping is safe: mining is a batch job.
+        stats["aborted_reason"] = "llm_transient_failure"
+        return "aborted"
 
     stats["llm_calls"] += 1
     if rule is None or _is_sensitive_rule(rule):
@@ -412,7 +432,10 @@ def mine_transcript_rules(
                 stats["windows"] += 1
                 try:
                     rule = _extract_rule(_build_window(asst_text, user_text))
-                except llm_budget.LLMBudgetExceeded:
+                except (llm_budget.LLMBudgetExceeded, TransientLLMError):
+                    # Budget hit or provider returned empty — stop this best-effort
+                    # Stop-hook pass. No watermark here, so nothing to skip; a
+                    # later session re-mines its own corrections.
                     break
                 stats["llm_calls"] += 1
                 if rule is None or _is_sensitive_rule(rule):

{memorymaster-3.24.0 → memorymaster-3.25.0}/memorymaster/steward.py

@@ -9,7 +9,7 @@ import subprocess
 import time
 from typing import Any, Literal
 
-from memorymaster import observability
+from memorymaster import llm_budget, observability
 from memorymaster.lifecycle import transition_claim
 from memorymaster.security import is_sensitive_claim
 from memorymaster.service import MemoryService
@@ -891,6 +891,14 @@ def _make_circuit_open_result(probe: ProbeSpec, probe_type: str, probe_failure_t
     )
 
 
+# Open ONE per-cycle LLM budget scope for the whole cycle so
+# MEMORYMASTER_MAX_LLM_CALLS_PER_CYCLE (and the token / provider-failure caps)
+# apply across every LLM-using probe this cycle — notably the contradiction
+# probe's judge. cycle_scope is a @contextmanager, so it doubles as a context
+# decorator and recreates a fresh scope per call. Without this the cap was a
+# no-op for the steward and probe_for_claim's LLMBudgetExceeded handler was dead
+# in production. (audit: probe-for-claim-budget-no-scope)
+@llm_budget.cycle_scope()
 def _run_cycle(
     service: MemoryService,
     *,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.24.0
+Version: 3.25.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-2230-green.svg)]()
+[![Tests](https://img.shields.io/badge/tests-2232-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/)

{memorymaster-3.24.0 → memorymaster-3.25.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.24.0"
+version = "3.25.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.24.0 → memorymaster-3.25.0}/tests/test_rule_miner.py

@@ -152,6 +152,27 @@ def test_no_correction_no_rule(env):
     assert _candidate_rules(svc) == []
 
 
+def test_transient_llm_failure_aborts_without_advancing_watermark(env):
+    """M3 regression: an EMPTY provider response (transient outage) must abort
+    without advancing the watermark, so the candidate is retried next run —
+    NOT silently skipped (which would permanently lose real corrections during
+    an outage). Contrast test_no_correction_no_rule, where a non-empty '{}'
+    response is a genuine no-correction and DOES advance the watermark."""
+    db, svc, holder = env
+    _seed(db, _PAIR)
+    holder["responses"] = [""]  # provider returns empty -> transient failure
+
+    stats = rule_miner.mine_rules(db, svc, provider="claude_cli")
+    assert stats["aborted_reason"] == "llm_transient_failure"
+    assert stats["ingested"] == 0
+    assert stats["last_id"] == 0, "watermark must NOT advance past an un-judged candidate"
+
+    # Re-run with a working provider: the same candidate is retried and ingested.
+    holder["responses"] = [_RULE_JSON]
+    retry = rule_miner.mine_rules(db, svc, provider="claude_cli")
+    assert retry["ingested"] == 1, "candidate must be retried after a transient failure, not skipped"
+
+
 def test_keyword_prefilter_skips_non_corrections(env):
     db, svc, holder = env
     _seed(db, [

{memorymaster-3.24.0 → memorymaster-3.25.0}/tests/test_steward_contradiction_phase.py

@@ -179,3 +179,73 @@ def test_report_includes_enable_contradiction_probe_flag() -> None:
     )
     assert report["enable_contradiction_probe"] is False
     assert report["run_metadata"]["probe_settings"]["enable_contradiction_probe"] is False
+
+
+def _seed_topical_trio(service, db):
+    """3 mutually-topical claims with distinct subject+predicate (so the
+    deterministic resolver doesn't own them) — each is a contradiction peer of
+    the others for the probe."""
+    ids = []
+    specs = [
+        ("api rate limit", "value", "The public API rate limit policy is documented here."),
+        ("api throttling", "state", "The public API rate limit behaviour is described here."),
+        ("api quota", "tier", "The public API rate limit tiers are listed here."),
+    ]
+    for i, (subj, pred, text) in enumerate(specs):
+        c = service.ingest(
+            text=text, citations=[CitationInput(source="d", locator=f"l{i}")],
+            subject=subj, predicate=pred, object_value=f"v{i}", confidence=0.4 + i * 0.1,
+        )
+        _force_status(db, c.id, "confirmed", f"2026-0{i + 1}-01T00:00:00+00:00")
+        ids.append(c.id)
+    return ids
+
+
+def test_budget_cap_enforced_across_cycle_and_not_a_circuit_failure(monkeypatch) -> None:
+    """M1: the steward now opens one llm_budget cycle_scope, so
+    MEMORYMASTER_MAX_LLM_CALLS_PER_CYCLE=1 caps the contradiction judge across
+    the WHOLE cycle (exactly 1 judge call; without the scope all distinct pairs
+    judge => 3). M2: budget exhaustion is flagged budget_exhausted (not
+    timed_out) and must NOT trip the circuit breaker even at threshold=1."""
+    db = _case_db("steward-budget")
+    workspace = _case_workspace("steward-budget-ws")
+    service = MemoryService(db, workspace_root=workspace)
+    service.init_db()
+
+    calls = {"n": 0}
+
+    def _always_contradict(prompt, body):
+        calls["n"] += 1
+        return json.dumps({"contradicts": True, "severity": "high", "reason": "conflict"})
+
+    monkeypatch.setitem(llm_provider._PROVIDERS, "google", _always_contradict)
+    monkeypatch.setenv("MEMORYMASTER_MAX_LLM_CALLS_PER_CYCLE", "1")
+    reset_config()
+    _seed_topical_trio(service, db)
+
+    report = run_steward(
+        service, mode="manual", max_cycles=1, max_claims=10, max_proposals=10,
+        max_probe_files=5, apply=False, probe_failure_threshold=1,
+        artifact_path=workspace / "artifacts" / "steward_report.json",
+        enable_semantic_probe=False, enable_tool_probe=False,
+        enable_contradiction_probe=True,
+    )
+
+    # M1: the per-cycle cap held across claims — exactly one judge call total.
+    assert calls["n"] == 1, f"expected 1 judge call under cap=1, got {calls['n']}"
+
+    cycle = report["cycles"][0]
+    totals = cycle["budget"]["accounting"]["probes"]
+    # M2: budget exhaustion was not counted as a timeout/error and did not open
+    # the circuit (threshold=1 would have tripped on the first counted failure).
+    assert totals["timed_out"] == 0
+    assert totals["errored"] == 0
+    assert totals["skipped_circuit_open"] == 0
+
+    # M2: at least one claim's contradiction probe recorded budget_exhausted.
+    saw_budget_exhausted = False
+    for d in cycle["decisions"]:
+        for p in d["probes"]:
+            if p["probe_type"] == "contradiction_probe" and p["metrics"].get("budget_exhausted"):
+                saw_budget_exhausted = True
+    assert saw_budget_exhausted, "expected a contradiction probe to flag budget_exhausted"