memorymaster 3.17.0__tar.gz → 3.18.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.17.0
+Version: 3.18.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.17.0 → memorymaster-3.18.0}/memorymaster/config.py

@@ -67,6 +67,17 @@ MEMORYMASTER_RRF_TIEBREAKER_THRESHOLD
     Maximum adjacent score gap considered a near tie.
     Default: ``0.01``
 
+MEMORYMASTER_RETRIEVAL_PROFILE_<TYPE>
+    Per-question-type retrieval weight override. ``<TYPE>`` is the
+    upper-snake-case form of the question type (LongMemEval-S labels:
+    SINGLE_SESSION_USER, SINGLE_SESSION_ASSISTANT, SINGLE_SESSION_PREFERENCE,
+    TEMPORAL_REASONING, KNOWLEDGE_UPDATE, MULTI_SESSION). Value format
+    matches ``MEMORYMASTER_RETRIEVAL_WEIGHTS``: comma-separated floats
+    ``lex,conf,fresh,vec``. When set, ``Config.retrieval_profile(qtype)``
+    returns the profile and ``retrieval._compute_claim_score`` consumes it
+    instead of the default weights. Profiles are opt-in; missing types fall
+    back to the global ``cfg.retrieval_weights``.
+
 MEMORYMASTER_CONFIG_FILE
     Path to a JSON config file. Keys match attribute names on ``Config``.
 """
@@ -218,6 +229,15 @@ class Config:
         default_factory=lambda: dict(INITIAL_CONFIDENCE_BY_TYPE)
     )
 
+    # --- Per-question-type retrieval weight profiles (S3, opt-in) ---
+    # Maps the canonical question_type slug (lowercase, hyphens preserved,
+    # e.g. "single-session-preference") to a (W_LEX, W_CONF, W_FRESH, W_VEC)
+    # tuple. Populated by env vars MEMORYMASTER_RETRIEVAL_PROFILE_<TYPE>.
+    # Empty by default — retrieval falls back to ``retrieval_weights``.
+    retrieval_profiles: Dict[str, tuple[float, float, float, float]] = field(
+        default_factory=dict
+    )
+
     # --- Derived convenience dicts ---
 
     @property
@@ -270,6 +290,20 @@ class Config:
             self.lexical_weight_prefix,
         )
 
+    def retrieval_profile(
+        self, question_type: str | None
+    ) -> tuple[float, float, float, float] | None:
+        """Per-question-type weight override, or None to fall back to default.
+
+        Accepts the canonical bench label (e.g. ``single-session-preference``)
+        or the classifier output (e.g. ``preference``) — both lookup forms are
+        normalized to lowercase before lookup. Returning None signals the
+        caller to use ``retrieval_weights`` as usual.
+        """
+        if not question_type:
+            return None
+        return self.retrieval_profiles.get(question_type.strip().lower())
+
 
 # ---------------------------------------------------------------------------
 # Module-level singleton
@@ -363,6 +397,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_retrieval_profiles(overrides)
 
     # Filter to only valid Config fields
     valid_fields = {f.name for f in Config.__dataclass_fields__.values()}
@@ -404,3 +439,29 @@ def _apply_env_bool(overrides: dict[str, object], env_var: str, key: str) -> Non
     if not raw:
         return
     overrides[key] = raw in {"1", "true", "yes", "on"}
+
+
+_PROFILE_PREFIX = "MEMORYMASTER_RETRIEVAL_PROFILE_"
+
+
+def _apply_env_retrieval_profiles(overrides: dict[str, object]) -> None:
+    """Collect per-type profile overrides from env into a single dict.
+
+    Scans every env var starting with ``MEMORYMASTER_RETRIEVAL_PROFILE_``.
+    The suffix becomes the question_type slug (lowercased, underscores
+    converted to hyphens to match the LongMemEval-S canonical labels like
+    ``single-session-preference``).
+    """
+    profiles: dict[str, tuple[float, float, float, float]] = {}
+    for key, raw in os.environ.items():
+        if not key.startswith(_PROFILE_PREFIX):
+            continue
+        raw = raw.strip()
+        if not raw:
+            continue
+        suffix = key[len(_PROFILE_PREFIX):]
+        qtype = suffix.lower().replace("_", "-")
+        values = _parse_floats(raw, 4)
+        profiles[qtype] = (values[0], values[1], values[2], values[3])
+    if profiles:
+        overrides["retrieval_profiles"] = profiles

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

@@ -130,14 +130,42 @@ def rank_claims(
     limit: int = 20,
     vector_hook: VectorSearchHook | None = None,
     semantic_vectors: bool = False,
+    query_type: str | None = None,
 ) -> list[Claim]:
-    return [row.claim for row in rank_claim_rows(query_text, claims, mode=mode, limit=limit, vector_hook=vector_hook, semantic_vectors=semantic_vectors)]
-
-
-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."""
+    return [
+        row.claim
+        for row in rank_claim_rows(
+            query_text,
+            claims,
+            mode=mode,
+            limit=limit,
+            vector_hook=vector_hook,
+            semantic_vectors=semantic_vectors,
+            query_type=query_type,
+        )
+    ]
+
+
+def _compute_claim_score(
+    claim: Claim,
+    lexical: float,
+    confidence: float,
+    freshness: float,
+    vector: float,
+    vector_enabled: bool,
+    semantic_vectors: bool,
+    query_type: str | None = None,
+) -> float:
+    """Compute relevance score for a claim.
+
+    When ``query_type`` matches a configured per-type profile
+    (``cfg.retrieval_profile(query_type)``), the profile's 4-tuple replaces
+    ``cfg.retrieval_weights`` for vector-enabled paths. The no-vector path
+    is unchanged — profiles only override the hybrid blend.
+    """
     cfg = get_config()
-    w_l, w_c, w_f, w_v = cfg.retrieval_weights
+    profile = cfg.retrieval_profile(query_type) if query_type else None
+    w_l, w_c, w_f, w_v = profile if profile is not None else cfg.retrieval_weights
     if vector_enabled and semantic_vectors:
         # Real semantic embeddings use the same configurable blend as other
         # vector-enabled ranking so env sweeps affect both paths.
@@ -252,6 +280,7 @@ def rank_claim_rows(
     limit: int = 20,
     vector_hook: VectorSearchHook | None = None,
     semantic_vectors: bool = False,
+    query_type: str | None = None,
 ) -> list[RankedClaim]:
     if mode not in RETRIEVAL_MODES:
         raise ValueError(f"Unknown retrieval mode: {mode}")
@@ -289,7 +318,16 @@ def rank_claim_rows(
         freshness = _freshness_score(claim)
         vector = max(0.0, min(1.0, float(vector_scores.get(claim.id, 0.0))))
 
-        score = _compute_claim_score(claim, lexical, confidence, freshness, vector, vector_enabled, semantic_vectors)
+        score = _compute_claim_score(
+            claim,
+            lexical,
+            confidence,
+            freshness,
+            vector,
+            vector_enabled,
+            semantic_vectors,
+            query_type=query_type,
+        )
 
         ranked.append(
             RankedClaim(

{memorymaster-3.17.0 → memorymaster-3.18.0}/memorymaster/service.py

@@ -426,6 +426,7 @@ class MemoryService:
         retrieval_profile: str | None = None,
         allow_sensitive: bool = False,
         scope_allowlist: list[str] | None = None,
+        query_type: str | None = None,
     ) -> list[Claim]:
         rows = self.query_rows(
             query_text=query_text,
@@ -438,6 +439,7 @@ class MemoryService:
             retrieval_profile=retrieval_profile,
             allow_sensitive=allow_sensitive,
             scope_allowlist=scope_allowlist,
+            query_type=query_type,
         )
         return [row["claim"] for row in rows]
 
@@ -552,6 +554,7 @@ class MemoryService:
         scope_allowlist: list[str] | None = None,
         enrich_with_entities: bool = False,
         requesting_agent: str | None = None,
+        query_type: str | None = None,
     ) -> list[dict[str, Any]]:
         if limit <= 0:
             return []
@@ -603,6 +606,7 @@ class MemoryService:
             limit=rank_limit,
             vector_hook=vector_hook,
             semantic_vectors=semantic,
+            query_type=query_type,
         )
         ranked_rows = _rerank_with_profile(
             ranked_rows,

{memorymaster-3.17.0 → memorymaster-3.18.0}/memorymaster/steward.py

@@ -1625,5 +1625,27 @@ def run_steward(
         },
         "artifact_path": str(Path(artifact_path)),
     }
+    import os
+
+    daydream_dir = os.environ.get("MEMORYMASTER_DAYDREAM_INGEST_DIR")
+    if daydream_dir:
+        try:
+            import logging
+
+            from memorymaster.jobs.daydream_ingest import ingest_insights
+
+            verbose = os.environ.get("MEMORYMASTER_DAYDREAM_VERBOSE") == "1"
+            path = Path(daydream_dir)
+            if path.is_dir():
+                summary = ingest_insights(service, path, dry_run=False)
+                report["daydream"] = summary
+                if verbose:
+                    logging.getLogger(__name__).info("daydream auto-ingest: %s", summary)
+            else:
+                report["daydream"] = {"skipped": "dir-not-found", "path": str(path)}
+        except Exception as exc:
+            report["daydream"] = {"error": str(exc)[:200]}
+            if os.environ.get("MEMORYMASTER_DAYDREAM_VERBOSE") == "1":
+                logging.getLogger(__name__).warning("daydream auto-ingest failed: %s", exc)
     _write_artifact(Path(artifact_path), report)
     return report

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memorymaster
-Version: 3.17.0
+Version: 3.18.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.17.0 → memorymaster-3.18.0}/memorymaster.egg-info/SOURCES.txt

@@ -308,6 +308,7 @@ 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_profiles.py
 tests/test_retrieval_rrf_tiebreaker.py
 tests/test_retrieval_weights.py
 tests/test_review.py
@@ -331,6 +332,7 @@ tests/test_staleness.py
 tests/test_stealth_mode.py
 tests/test_steward.py
 tests/test_steward_classifier.py
+tests/test_steward_daydream_hook.py
 tests/test_steward_features.py
 tests/test_steward_features_v3.py
 tests/test_steward_resolution_parity.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "memorymaster"
-version = "3.17.0"
+version = "3.18.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.17.0 → memorymaster-3.18.0}/tests/bench_longmemeval.py

@@ -37,6 +37,7 @@ OPENAI_CHAT_URL = "https://api.openai.com/v1/chat/completions"
 GEMINI_GENERATE_URL = "https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
 OPENAI_JUDGE_MODEL = "gpt-4o"
 GEMINI_FALLBACK_MODEL = "gemini-2.5-flash"
+CLAUDE_CLI_JUDGE_MODEL = "claude-haiku-4-5-20251001"
 DEFAULT_JUDGE = "sonnet"
 DEFAULT_JUDGE_PACING_SECONDS = 1.0
 DEFAULT_QA_MAX_SECONDS = 90 * 60
@@ -126,6 +127,8 @@ class JudgeClient:
             if not self.openai_api_key:
                 raise RuntimeError("OPENAI_API_KEY is not set")
             return call_openai_chat(prompt, self.openai_api_key, max_tokens=max_tokens, temperature=temperature)
+        if provider == "claude_cli":
+            return call_claude_cli_judge(prompt, max_tokens=max_tokens, temperature=temperature)
         raise ValueError(f"Unknown judge provider: {provider}")
 
     def _record(self, response: LLMResponse) -> None:
@@ -148,6 +151,8 @@ class JudgeClient:
             return "gemini-2.5-flash"
         if self.models_used == {ANTHROPIC_JUDGE_MODEL}:
             return "sonnet"
+        if self.models_used == {CLAUDE_CLI_JUDGE_MODEL}:
+            return "claude_cli"
         return "mixed"
 
     @staticmethod
@@ -158,6 +163,10 @@ class JudgeClient:
             return ["gpt-4o", "gemini", "sonnet"]
         if primary == "gemini":
             return ["gemini", "sonnet", "gpt-4o"]
+        if primary == "claude_cli":
+            # OAuth-only via local Claude Code binary; no API keys needed.
+            # Fall back to API providers only if explicit keys are present.
+            return ["claude_cli", "gpt-4o", "gemini", "sonnet"]
         raise ValueError(f"Unknown judge: {primary}")
 
     @staticmethod
@@ -166,6 +175,8 @@ class JudgeClient:
             return ANTHROPIC_JUDGE_MODEL
         if provider == "gemini":
             return GEMINI_FALLBACK_MODEL
+        if provider == "claude_cli":
+            return CLAUDE_CLI_JUDGE_MODEL
         return OPENAI_JUDGE_MODEL
 
 
@@ -256,7 +267,13 @@ def ingest_haystack(service: MemoryService, item: dict[str, Any], *, chunk_chars
             )
 
 
-def query_memory(service: MemoryService, question: str, top_k: int = 10) -> list[dict[str, Any]]:
+def query_memory(
+    service: MemoryService,
+    question: str,
+    top_k: int = 10,
+    *,
+    query_type: str | None = None,
+) -> list[dict[str, Any]]:
     service_limit = top_k if llm_rerank_available() else top_k * 3
     return service.query_rows(
         query_text=question,
@@ -265,6 +282,7 @@ def query_memory(service: MemoryService, question: str, top_k: int = 10) -> list
         retrieval_mode="hybrid",
         scope_allowlist=[BENCH_SCOPE],
         allow_sensitive=True,
+        query_type=query_type,
     )
 
 
@@ -370,7 +388,12 @@ def run_retrieval(
             service = init_ephemeral_service(Path(tmp), embedding_provider=embedding_provider)
             try:
                 ingest_haystack(service, item, chunk_chars=chunk_chars)
-                rows = query_memory(service, str(item["question"]), top_k=10)
+                rows = query_memory(
+                    service,
+                    str(item["question"]),
+                    top_k=10,
+                    query_type=str(item.get("question_type") or "") or None,
+                )
                 results.append(score_retrieval(item, rows))
             finally:
                 del service
@@ -632,6 +655,43 @@ def call_anthropic_sonnet_requests(
     )
 
 
+def call_claude_cli_judge(
+    prompt: str,
+    *,
+    max_tokens: int,
+    temperature: float = 0.0,
+) -> LLMResponse:
+    """OAuth-via-CLI judge — wraps memorymaster.llm_provider._call_claude_cli.
+
+    Routes the judge prompt through the user's local `claude --print` binary so
+    the bench runs against a Claude Code subscription instead of api.anthropic.com.
+    No ANTHROPIC_API_KEY required. Per-call cold-start latency ~3-15s; budget
+    accordingly for full runs (~500 questions × 2 calls each).
+
+    `max_tokens` and `temperature` are accepted for signature parity with the
+    HTTP providers; the CLI does not honour them per-call (model defaults apply).
+    """
+    # Local import — keeps the bench importable even if memorymaster is
+    # partially broken during dev. The provider helper handles binary discovery,
+    # timeouts, and Windows console suppression.
+    from memorymaster.llm_provider import _call_claude_cli
+
+    # Pin the model the bench reports via env, so judge_used_label stays stable.
+    os.environ.setdefault("MEMORYMASTER_LLM_MODEL", CLAUDE_CLI_JUDGE_MODEL)
+    text = _call_claude_cli(prompt, "").strip()
+    if not text:
+        raise RuntimeError(
+            "claude_cli judge returned empty output — check claude binary on PATH "
+            "and OAuth session validity"
+        )
+    return LLMResponse(
+        text=text,
+        model=CLAUDE_CLI_JUDGE_MODEL,
+        provider="claude_cli",
+        tokens=0,
+    )
+
+
 def answer_question(question: str, contexts: list[str], judge: JudgeClient) -> str:
     prompt = "\n\n".join(
         [
@@ -669,7 +729,8 @@ def run_full(
     anthropic_key = os.environ.get("ANTHROPIC_API_KEY", "").strip()
     openai_key = os.environ.get("OPENAI_API_KEY", "").strip()
     gemini_key = os.environ.get("GEMINI_API_KEY", "").strip()
-    if not anthropic_key and not openai_key and not gemini_key:
+    # claude_cli judge runs entirely via local OAuth — no API keys required.
+    if judge_name != "claude_cli" and not anthropic_key and not openai_key and not gemini_key:
         print("[full] no ANTHROPIC_API_KEY, OPENAI_API_KEY, or GEMINI_API_KEY; deferring QA")
         return {
             "mode": mode,
@@ -849,9 +910,9 @@ def parse_args() -> argparse.Namespace:
     parser.add_argument("--qa-output", type=Path, default=QA_OUTPUT, help="QA-only output JSON path")
     parser.add_argument(
         "--judge",
-        choices=["sonnet", "gpt-4o", "gemini"],
+        choices=["sonnet", "gpt-4o", "gemini", "claude_cli"],
         default=DEFAULT_JUDGE,
-        help="Primary judge model; default sonnet",
+        help="Primary judge model; default sonnet. claude_cli uses local OAuth (no API key)",
     )
     parser.add_argument(
         "--judge-pacing-seconds",

memorymaster-3.18.0/tests/test_retrieval_profiles.py

@@ -0,0 +1,142 @@
+"""S3 regression tests — per-question-type retrieval weight profiles.
+
+Verifies:
+1. With NO profile env var set, query_type is a no-op (back-compat).
+2. With a per-type profile env var set, _compute_claim_score swaps the
+   weight tuple for queries of that type.
+3. query_type that does NOT match any configured profile falls back to
+   the global retrieval_weights (default behaviour preserved).
+4. The env-var slug mapping (UPPER_SNAKE -> lower-hyphen) round-trips
+   correctly so LongMemEval-S labels like 'single-session-preference'
+   are reachable via MEMORYMASTER_RETRIEVAL_PROFILE_SINGLE_SESSION_PREFERENCE.
+"""
+from __future__ import annotations
+
+import pytest
+
+from memorymaster.config import reset_config, get_config
+from memorymaster.models import Claim
+from memorymaster.retrieval import rank_claim_rows
+
+
+@pytest.fixture(autouse=True)
+def _reset_config():
+    reset_config()
+    yield
+    reset_config()
+
+
+def _claim() -> Claim:
+    return Claim(
+        id=1,
+        text="alpha beta retrieval target",
+        idempotency_key=None,
+        normalized_text=None,
+        claim_type=None,
+        subject=None,
+        predicate=None,
+        object_value=None,
+        scope="project",
+        volatility="medium",
+        status="confirmed",
+        confidence=0.8,
+        pinned=False,
+        supersedes_claim_id=None,
+        replaced_by_claim_id=None,
+        created_at="2999-01-01T00:00:00+00:00",
+        updated_at="2999-01-01T00:00:00+00:00",
+        last_validated_at=None,
+        archived_at=None,
+    )
+
+
+def _rank(*, semantic_vectors: bool, query_type: str | None = None):
+    def vector_hook(query, claims):
+        return {c.id: 0.6 for c in claims}
+
+    return rank_claim_rows(
+        "alpha beta",
+        [_claim()],
+        mode="hybrid",
+        limit=1,
+        vector_hook=vector_hook,
+        semantic_vectors=semantic_vectors,
+        query_type=query_type,
+    )[0]
+
+
+def test_query_type_without_profile_is_noop():
+    """Passing query_type when no profile env var is set must not change
+    scores — back-compat with all existing callers."""
+    default = _rank(semantic_vectors=False)
+    typed = _rank(semantic_vectors=False, query_type="single-session-preference")
+    assert typed.score == pytest.approx(default.score)
+
+
+def test_profile_env_var_overrides_default_weights(monkeypatch):
+    """When a profile env var matches the query_type, weights swap.
+
+    Default vec-enabled weights: (lex=0.30, conf=0.20, fresh=0.10, vec=0.40).
+    Profile under test: (lex=0.10, conf=0.10, fresh=0.10, vec=0.70) — heavy
+    on vector, which is the predicted direction for ``single-session-preference``
+    where lexical matching is structurally weak (preferences are paraphrased).
+    """
+    monkeypatch.setenv(
+        "MEMORYMASTER_RETRIEVAL_PROFILE_SINGLE_SESSION_PREFERENCE",
+        "0.10,0.10,0.10,0.70",
+    )
+    reset_config()
+
+    cfg = get_config()
+    assert cfg.retrieval_profile("single-session-preference") == (0.10, 0.10, 0.10, 0.70)
+
+    default = _rank(semantic_vectors=False)
+    typed = _rank(semantic_vectors=False, query_type="single-session-preference")
+    assert typed.score != default.score
+
+
+def test_profile_does_not_leak_to_other_query_types(monkeypatch):
+    """Profile under one type must not affect queries with a different type
+    (or with no type at all)."""
+    monkeypatch.setenv(
+        "MEMORYMASTER_RETRIEVAL_PROFILE_SINGLE_SESSION_PREFERENCE",
+        "0.10,0.10,0.10,0.70",
+    )
+    reset_config()
+
+    default = _rank(semantic_vectors=False)
+    other_type = _rank(semantic_vectors=False, query_type="multi-session")
+    none_type = _rank(semantic_vectors=False, query_type=None)
+
+    assert other_type.score == pytest.approx(default.score)
+    assert none_type.score == pytest.approx(default.score)
+
+
+def test_profile_slug_round_trips_underscores_to_hyphens(monkeypatch):
+    """Env var SINGLE_SESSION_PREFERENCE must be reachable as the canonical
+    bench label 'single-session-preference'."""
+    monkeypatch.setenv(
+        "MEMORYMASTER_RETRIEVAL_PROFILE_TEMPORAL_REASONING",
+        "0.20,0.10,0.40,0.30",
+    )
+    reset_config()
+
+    cfg = get_config()
+    assert cfg.retrieval_profile("temporal-reasoning") == (0.20, 0.10, 0.40, 0.30)
+    # And the env-form lookup (uppercased, underscored) finds nothing — only
+    # the canonical lower-hyphen form is the key.
+    assert cfg.retrieval_profile("TEMPORAL_REASONING") is None
+
+
+def test_profile_works_in_semantic_path(monkeypatch):
+    """The semantic_vectors=True branch must also honour the profile —
+    same blend formula, just different signal source."""
+    monkeypatch.setenv(
+        "MEMORYMASTER_RETRIEVAL_PROFILE_SINGLE_SESSION_PREFERENCE",
+        "0.10,0.10,0.10,0.70",
+    )
+    reset_config()
+
+    default = _rank(semantic_vectors=True)
+    typed = _rank(semantic_vectors=True, query_type="single-session-preference")
+    assert typed.score != default.score

memorymaster-3.18.0/tests/test_steward_daydream_hook.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from memorymaster.service import MemoryService
+from memorymaster.steward import run_steward
+
+
+@pytest.fixture()
+def service(tmp_path: Path) -> MemoryService:
+    svc = MemoryService(tmp_path / "memorymaster.db", workspace_root=tmp_path / "workspace")
+    svc.init_db()
+    return svc
+
+
+def _run_clean_steward(service: MemoryService, tmp_path: Path) -> dict:
+    return run_steward(
+        service,
+        mode="manual",
+        max_cycles=1,
+        max_claims=10,
+        max_proposals=10,
+        max_probe_files=10,
+        artifact_path=tmp_path / "steward_report.json",
+    )
+
+
+def _write_insight(directory: Path) -> None:
+    directory.mkdir(parents=True, exist_ok=True)
+    (directory / "20260516-linking-patterns.md").write_text(
+        """---
+type: daydream
+created_date: 2026-05-16
+scores:
+  average: 8.5
+source_notes:
+  - [[notes/source-a]]
+---
+# Linking Patterns
+
+> Connection between steward output and daydream insight closure
+
+Steward cycles can close the loop by ingesting high-scoring daydream insights.
+
+## Implication
+
+Accepted insights become candidate hypotheses for later validation.
+""",
+        encoding="utf-8",
+    )
+
+
+def test_no_env_no_op(service: MemoryService, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.delenv("MEMORYMASTER_DAYDREAM_INGEST_DIR", raising=False)
+
+    report = _run_clean_steward(service, tmp_path)
+
+    assert report["cycles_completed"] == 1
+    assert "daydream" not in report
+
+
+def test_env_set_dir_missing_no_crash(
+    service: MemoryService,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    missing = tmp_path / "missing-daydreams"
+    monkeypatch.setenv("MEMORYMASTER_DAYDREAM_INGEST_DIR", str(missing))
+
+    report = _run_clean_steward(service, tmp_path)
+
+    assert report["cycles_completed"] == 1
+    assert report["daydream"] == {"skipped": "dir-not-found", "path": str(missing)}
+
+
+def test_env_set_dir_with_insights_ingests(
+    service: MemoryService,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    insights_dir = tmp_path / "Daydreams"
+    _write_insight(insights_dir)
+    monkeypatch.setenv("MEMORYMASTER_DAYDREAM_INGEST_DIR", str(insights_dir))
+
+    report = _run_clean_steward(service, tmp_path)
+
+    assert report["daydream"]["ingested"] == 1
+    claims = service.list_claims(status="candidate", limit=20, allow_sensitive=True)
+    assert len(claims) == 1
+    assert claims[0].source_agent == "daydream"
+    assert claims[0].claim_type == "hypothesis"
+
+
+def test_ingest_exception_does_not_break_steward(
+    service: MemoryService,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    insights_dir = tmp_path / "Daydreams"
+    insights_dir.mkdir()
+    monkeypatch.setenv("MEMORYMASTER_DAYDREAM_INGEST_DIR", str(insights_dir))
+
+    def raise_ingest(*_args: object, **_kwargs: object) -> dict:
+        raise RuntimeError("boom from daydream ingest")
+
+    monkeypatch.setattr("memorymaster.jobs.daydream_ingest.ingest_insights", raise_ingest)
+
+    report = _run_clean_steward(service, tmp_path)
+
+    assert report["cycles_completed"] == 1
+    assert report["cycles"][0]["budget"]["claims_scanned"] == 0
+    assert json.dumps(report["cycles"])
+    assert report["daydream"] == {"error": "boom from daydream ingest"}