dulus 3.13.4__tar.gz → 3.13.5__tar.gz

{dulus-3.13.4/dulus.egg-info → dulus-3.13.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.13.4
+Version: 3.13.5
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author-email: KevRojo <dev@dulus.ai>
 Maintainer-email: KevRojo <dev@dulus.ai>

{dulus-3.13.4 → dulus-3.13.5}/agent.py

@@ -206,6 +206,19 @@ def run(
         except Exception:
             _api_source, _lb_meta = state.messages, {"enabled": False, "truncated": False}
 
+        # Strip GUI/REPL baseline display blobs (soul/gold/welcome). The model
+        # already has them via system prompt; leaving them as role:assistant
+        # made web-history consolidate drop everything before the last
+        # assistant (= the gold blob itself) on first turn.
+        try:
+            from memory import is_baseline_display_message
+            _api_source = [
+                m for m in _api_source
+                if not is_baseline_display_message(m)
+            ]
+        except Exception:
+            pass
+
         # Sanitize message contents before sending to API (surrogate safety)
         _safe_messages = []
         for m in _api_source:

{dulus-3.13.4 → dulus-3.13.5}/compaction.py

@@ -678,6 +678,13 @@ def save_loopback_archive(messages: list, state=None, config: dict | None = None
     Writes ~/.dulus/loopback_archives/archive_<session>.json and binds
     config["_loopback_archive_path"] + config["_loopback_archive"] (in-memory
     copy) for the Loopback tool. Returns the path or None on failure.
+
+    CRITICAL — second-/Nth-compact guard:
+    A later ``/compact`` runs against an *already slimmed* ``state.messages``.
+    Naively rewriting the archive would overwrite the original full history
+    with the post-compact crumbs. We NEVER shrink a durable archive: if an
+    in-memory or on-disk copy is longer than ``messages``, keep the longer one
+    and only refresh the binding.
     """
     if not messages:
         return None
@@ -685,6 +692,29 @@ def save_loopback_archive(messages: list, state=None, config: dict | None = None
         LOOPBACK_ARCHIVE_DIR.mkdir(parents=True, exist_ok=True)
         sid = _session_key(state, config)
         path = LOOPBACK_ARCHIVE_DIR / f"archive_{sid}.json"
+
+        # Resolve the longest known full archive for this session.
+        prev: list = []
+        if isinstance(config, dict):
+            live = config.get("_loopback_archive")
+            if isinstance(live, list) and live:
+                prev = live
+        if not prev and path.exists():
+            try:
+                disk = json.loads(path.read_text(encoding="utf-8"))
+                disk_msgs = disk.get("messages") if isinstance(disk, dict) else None
+                if isinstance(disk_msgs, list) and disk_msgs:
+                    prev = disk_msgs
+            except Exception:
+                prev = []
+
+        if prev and len(prev) > len(messages):
+            # Refuse to shrink. Keep the fuller archive as the durable source.
+            if isinstance(config, dict):
+                config["_loopback_archive"] = prev
+                config["_loopback_archive_path"] = str(path)
+            return path
+
         payload = {
             "session_id": sid,
             "timestamp": time.strftime("%Y%m%d_%H%M%S"),

{dulus-3.13.4 → dulus-3.13.5}/context.py

@@ -442,12 +442,28 @@ def _resolve_reply_language(config: dict | None) -> str:
     return raw
 
 
+
+def _append_baseline_fragments(prompt: str) -> str:
+    """Attach soul + gold system fragments (always-on baseline)."""
+    try:
+        from memory import soul_system_fragment, gold_system_fragment
+        _soul = soul_system_fragment()
+        if _soul:
+            prompt += "\n\n" + _soul
+        _gold = gold_system_fragment()
+        if _gold:
+            prompt += "\n\n" + _gold
+    except Exception:
+        pass
+    return prompt
+
+
 def build_system_prompt(config: dict | None = None) -> str:
     import platform
     model_lower = (config.get("model", "") if config else "").lower()
     is_deepseek_r1 = "deepseek-r1" in model_lower or "deepseek-reasoner" in model_lower
     if is_deepseek_r1 and config and config.get("deep_override", False):
-        return _build_ollama_system_prompt(config)
+        return _append_baseline_fragments(_build_ollama_system_prompt(config))
 
     auto_show = "ON" if (not config or config.get("auto_show", True)) else "OFF"
     lite = bool(config and config.get("lite_mode"))
@@ -470,8 +486,12 @@ def build_system_prompt(config: dict | None = None) -> str:
         dulus_md="" if lite else get_dulus_md(),
     )
 
+    # Soul + Gold baseline ALWAYS (even in lite) — model source of truth.
+    # Display copies in chat are GUI-only and get stripped before the API call.
+    prompt = _append_baseline_fragments(prompt)
+
     if lite:
-        # Bail early — minimal prompt only.
+        # Bail early — minimal prompt only (baseline already attached).
         return prompt
 
     try:

{dulus-3.13.4 → dulus-3.13.5}/docs/CHANGELOG.md

@@ -7,6 +7,18 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.13.5] - 2026-08-31
+
+### Fixed
+- **Gold / short_memory baseline**: curated gold memories (incl. `short_memory`) and soul now ride in `build_system_prompt` every turn — always-on, **not** gated by `/mem_palace`
+- **First-turn amnesia**: agent + lookback strip GUI/REPL gold/soul/welcome *display* blobs before the provider call, so web-history consolidate no longer treats gold as “last assistant reply” and drops real context
+- **MemPalace dual-path noise**: per-turn inject (CLI + WebChat) skips `short_memory` / soul — already in the system prompt
+- **Second `/compact` archive wipe**: `save_loopback_archive` refuses to shrink; Loopback keeps the full pre-compact history across N compacts
+- **WebChat gold preload**: session seeds gold *display* copies for the transcript; model source of truth is still the system prompt (public GUI stays as-is — this is server/engine, not an Interant GUI port)
+
+### Tests
+- `test_gold_memory_preload` + `test_lookback_compact` (11 passed)
+
 ## [3.13.4] - 2026-08-31
 
 ### Fixed

{dulus-3.13.4 → dulus-3.13.5}/docs/news.md

@@ -2,6 +2,8 @@
  
 ## 🔥🔥🔥 News (Pacific Time)
 
+- August 31, 2026 (**v3.13.5**): **🏆 short_memory stopped vanishing.** Gold memories + soul now live in the **system prompt** every turn (always-on — `/mem_palace off` no longer starves them). WebChat seeds gold for the transcript; the agent/lookback strip those display blobs before the provider call so first-turn consolidate can’t eat your context. Second `/compact` no longer wipes the Loopback archive. Engine + WebChat fix — not a desktop-GUI rewrite. `pip install -U dulus`. 🦅
+
 - August 31, 2026 (**v3.13.4**): **Context windows are honest again.** `token_budget` ships so compaction knows Claude is 200k, Gemini is 1M, DeepSeek is 64k — not a flat 128k for everyone. Quality CI: **925 passed**. `pip install -U dulus`. 🦅
 
 - August 31, 2026 (**v3.13.3**): **`/compact` got serious.** Full archive → disk for Loopback, live context → ~0 with a dense hint card, and **lookback is forced ON** for that session even if it was off — so quality does not fall off a cliff after compact. `pip install -U dulus`. 🦅

{dulus-3.13.4 → dulus-3.13.5/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: dulus
-Version: 3.13.4
+Version: 3.13.5
 Summary: Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS.
 Author-email: KevRojo <dev@dulus.ai>
 Maintainer-email: KevRojo <dev@dulus.ai>

{dulus-3.13.4 → dulus-3.13.5}/dulus.egg-info/SOURCES.txt

@@ -332,6 +332,7 @@ tests/test_diff_visualization.py
 tests/test_display_blocks.py
 tests/test_dulus_account.py
 tests/test_export_import.py
+tests/test_gold_memory_preload.py
 tests/test_grok_usage.py
 tests/test_hook_engine.py
 tests/test_injection_fix.py

{dulus-3.13.4 → dulus-3.13.5}/dulus.py

@@ -395,7 +395,7 @@ try:
     from importlib.metadata import version as _pkg_version
     VERSION = _pkg_version("dulus")
 except Exception:
-    VERSION = "3.13.4"  # dev fallback — keep in sync with pyproject.toml
+    VERSION = "3.13.5"  # dev fallback — keep in sync with pyproject.toml
 
 # ── Machine-readable protocol output (`--output json`) ─────────────────────
 # Dulus is increasingly run as a child process by another agent runtime (an
@@ -3570,6 +3570,8 @@ def cmd_mem_palace(args: str, _state, config) -> bool:
     config["mem_palace"] = not config.get("mem_palace", True)
     state_str = "ON" if config["mem_palace"] else "OFF"
     ok(f"MemPalace auto-injection: {state_str}")
+    if not config["mem_palace"]:
+        info("Gold memories (incl. short_memory) still load at session start.")
     save_config(config)
     return True
 
@@ -12227,18 +12229,21 @@ def repl(config: dict, initial_prompt: str | None = None):
         except Exception as e:
             startup_status_msgs.append(clr(f"  ⚠ Schema inject skip: {e}", "yellow"))
 
-    # ── Gold Memories Auto-Load ───────────────────────────────────────────────
-    # Memories marked with `gold: true` (via /memory permanent) are injected
-    # at startup the same way as Soul.
+    # ── Gold Memories Auto-Load (GUI/REPL display copies) ─────────────────────
+    # Model source of truth is build_system_prompt → gold_system_fragment().
+    # These assistant-role copies are for the transcript/GUI only and get
+    # stripped before the provider call (agent.py + lookback). Never gated
+    # by /mem_palace (that toggle is only for per-turn semantic search).
     try:
-        from memory import load_index
-        gold_entries = [e for e in load_index("all") if getattr(e, "gold", False)]
-        for e in gold_entries:
-            state.messages.append({
-                "role": "assistant",
-                "content": f"[Golden Memory Loaded: {e.name}]\n\n{e.content}",
-            })
-            startup_status_msgs.append(clr(f"  🏆 Gold memory loaded: {e.name}", "yellow", "bold"))
+        from memory import gold_context_messages, gold_system_fragment
+        _gold_in_system = bool(gold_system_fragment())
+        for _msg in gold_context_messages():
+            state.messages.append(_msg)
+            _gold_name = _msg["content"].split("]", 1)[0].removeprefix("[Golden Memory Loaded: ")
+            _where = "system+GUI" if _gold_in_system else "GUI only"
+            startup_status_msgs.append(
+                clr(f"  🏆 Gold memory loaded ({_where}): {_gold_name}", "yellow", "bold")
+            )
     except Exception:
         pass
 
@@ -12735,6 +12740,18 @@ def repl(config: dict, initial_prompt: str | None = None):
                                 for _h in _raw_hits:
                                     _mp_log(f"  hit: score={float(_h.get('keyword_score', 0.0)):.3f}  {_h.get('name','?')}", "dim")
                             _kept = [h for h in _raw_hits if float(h.get("keyword_score", 0.0)) >= _MIN_SCORE]
+                            # Skip short_memory/soul — already in system-prompt baseline.
+                            try:
+                                from memory import is_baseline_memory_name
+                                _kept = [
+                                    h for h in _kept
+                                    if not is_baseline_memory_name(h.get("name"))
+                                    and not is_baseline_memory_name(
+                                        (h.get("description") or "").split()[:1][0] if h.get("description") else None
+                                    )
+                                ]
+                            except Exception:
+                                pass
                             # ── Dedup: skip memories already injected earlier in this session.
                             # Key by content hash (not name) because mempalace often returns
                             # generic names like "palace" for every hit in a wing — name-based

{dulus-3.13.4 → dulus-3.13.5}/lookback.py

@@ -155,6 +155,25 @@ def find_lookback_start(messages: list, turns: int) -> int:
     return start
 
 
+
+def _strip_baseline_display(messages: list) -> list:
+    """Drop soul/gold/welcome GUI display blobs from an API window.
+
+    Those ride in the system prompt now (see memory.gold_system_fragment /
+    soul_system_fragment). Keeping them as role:assistant in the API payload
+    made web-history consolidate treat gold as "last assistant reply".
+    """
+    if not messages:
+        return messages
+    try:
+        from memory import is_baseline_display_message
+    except Exception:
+        return messages
+    out = [m for m in messages if not is_baseline_display_message(m)]
+    # Preserve identity when nothing was stripped (callers/tests rely on it).
+    return messages if len(out) == len(messages) else out
+
+
 def apply_lookback_window(
     messages: list,
     config: dict | None = None,
@@ -166,6 +185,9 @@ def apply_lookback_window(
 
     Full ``messages`` is never mutated. When disabled or small enough, the
     original list is returned (same object) with meta.truncated=False.
+
+    Baseline display blobs (soul/gold/welcome) are always stripped from the
+    returned API window — they live in the system prompt, not chat turns.
     """
     msgs = messages or []
     on = lookback_enabled(config) if enabled is None else bool(enabled)
@@ -186,9 +208,20 @@ def apply_lookback_window(
         "start_index": 0,
         "hidden_messages": 0,
     }
+    def _api_window(window: list, meta: dict[str, Any]) -> tuple[list, dict[str, Any]]:
+        """Strip baseline display blobs and refresh window counts."""
+        cleaned = _strip_baseline_display(window)
+        if cleaned is window:
+            return window, meta
+        meta = dict(meta)
+        meta["window_messages"] = len(cleaned)
+        meta["window_user_turns"] = count_user_turns(cleaned)
+        meta["baseline_stripped"] = len(window) - len(cleaned)
+        return cleaned, meta
+
     if not on or total == 0:
         _clear_anchor(config)
-        return msgs, meta
+        return _api_window(msgs, meta)
 
     # Hysteresis: reuse the previous start (anchor) while its window still
     # holds n..n+slack user turns. The API prefix then stays append-only
@@ -211,7 +244,7 @@ def apply_lookback_window(
 
     if start <= 0:
         _clear_anchor(config)
-        return msgs, meta
+        return _api_window(msgs, meta)
 
     # Cache-aware gate: only truncate when the head we'd hide is meaningfully
     # bigger than the window we'd keep. Otherwise dropping the front busts the
@@ -242,7 +275,7 @@ def apply_lookback_window(
         "window_user_turns": count_user_turns(window),
         "hidden_messages": start,
     })
-    return window, meta
+    return _api_window(window, meta)
 
 
 def lookback_system_note(meta: dict[str, Any]) -> str:

{dulus-3.13.4 → dulus-3.13.5}/memory/__init__.py

@@ -57,7 +57,18 @@ from .types import (  # noqa: F401
     WHAT_NOT_TO_SAVE,
 )
 from .consolidator import consolidate_session, mine_files, snapshot_memory_files, new_memory_files  # noqa: F401
-from .palace import ensure_memory_palace, ensure_short_memory  # noqa: F401
+from .palace import (  # noqa: F401
+    ensure_memory_palace,
+    ensure_short_memory,
+    gold_context_messages,
+    gold_system_fragment,
+    soul_system_fragment,
+    is_baseline_display_message,
+    is_baseline_memory_name,
+    GOLD_MARKER,
+    SOUL_MARKER,
+    BASELINE_DISPLAY_MARKERS,
+)
 from .mempalace_bridge import (  # noqa: F401
     schedule_mempalace_mine,
     wait_pending_mines,

{dulus-3.13.4 → dulus-3.13.5}/memory/palace.py

@@ -13,6 +13,7 @@ from pathlib import Path
 
 from .store import (
     MemoryEntry,
+    USER_MEMORY_DIR,
     get_memory_dir,
     has_stacked_frontmatter,
     parse_frontmatter,
@@ -267,6 +268,158 @@ def seed_insight_memories() -> bool:
     return changed
 
 
+
+# ── Baseline display markers (GUI/REPL transcript only) ─────────────────────
+# These role:assistant blobs are for the human to see in the chat UI. The model
+# source of truth is gold_system_fragment() / soul_system_fragment() in the
+# system prompt. Agent + lookback strip these markers from the API payload.
+GOLD_MARKER = "[Golden Memory Loaded:"
+SOUL_MARKER = "[Identity Essence Loaded:"
+SOUL_RELOAD_MARKER = "[Identity Essence Reloaded:"
+WELCOME_MARKER = "<!-- dulus:welcome -->"
+BASELINE_DISPLAY_MARKERS = (
+    GOLD_MARKER,
+    SOUL_MARKER,
+    SOUL_RELOAD_MARKER,
+    WELCOME_MARKER,
+)
+
+
+def is_baseline_display_message(msg: dict | None) -> bool:
+    """True if *msg* is a GUI/REPL display blob for soul/gold/welcome."""
+    if not isinstance(msg, dict):
+        return False
+    content = msg.get("content") or ""
+    if not isinstance(content, str):
+        return False
+    s = content.lstrip()
+    return any(s.startswith(m) for m in BASELINE_DISPLAY_MARKERS)
+
+
+def is_baseline_memory_name(name: str | None) -> bool:
+    """True for memories that already ride in the system-prompt baseline.
+
+    MemPalace per-turn inject must skip these — re-injecting a truncated
+    ``short_memory`` on top of the full system copy is pure noise.
+    """
+    if not name:
+        return False
+    key = str(name).strip().lower().replace("-", "_").replace(" ", "_")
+    key = key.rsplit("/", 1)[-1].rsplit("\\", 1)[-1].rsplit(".", 1)[0]
+    if key in {"short_memory", "shortmemory", "soul"}:
+        return True
+    if key.startswith("golden_memory") or "short_memory" in key:
+        return True
+    return False
+
+
+def _clamp_body(body: str, max_chars: int) -> str:
+    body = (body or "").strip()
+    if not body or len(body) <= max_chars:
+        return body
+    head = max_chars * 3 // 4
+    return (
+        body[:head]
+        + "\n\n[... gold memory clipped — file is oversized; "
+        "re-curate it with MemorySave ...]\n\n"
+        + body[-(max_chars - head):]
+    )
+
+
+def _iter_gold_entries(max_chars: int = 8000):
+    """Yield (name, body) for every gold memory, short_memory first."""
+    try:
+        ensure_short_memory(force_gold=True)
+    except Exception:
+        pass
+    try:
+        from .store import load_index
+        entries = [e for e in load_index("all") if getattr(e, "gold", False)]
+    except Exception:
+        return
+    def _sort_key(e):
+        name = (getattr(e, "name", "") or "").lower()
+        return (0 if name == "short_memory" else 1, name)
+
+    for entry in sorted(entries, key=_sort_key):
+        body = _clamp_body(getattr(entry, "content", "") or "", max_chars)
+        if not body:
+            continue
+        yield (getattr(entry, "name", "gold") or "gold", body)
+
+
+def gold_system_fragment(max_chars: int = 8000, max_total: int = 12000) -> str:
+    """Gold memories as a stable system-prompt block (model source of truth).
+
+    This is how the model actually *receives* short_memory and other gold
+    entries — not as ``role:assistant`` chat turns (those break web-history
+    consolidate, Anthropic role alternation, and lookback).
+
+    Deliberately NOT gated by ``mem_palace``. Called every turn from
+    ``build_system_prompt`` so edits to short_memory.md show up immediately.
+    """
+    parts: list[str] = []
+    total = 0
+    for name, body in _iter_gold_entries(max_chars=max_chars):
+        block = f"[Golden Memory Loaded: {name}]\n\n{body}"
+        if total and total + len(block) > max_total:
+            break
+        parts.append(block)
+        total += len(block) + 2
+    if not parts:
+        return ""
+    return (
+        "# ── Golden Memory (always-on baseline — NOT gated by /mem_palace) ──\n"
+        "These are curated essentials. Treat short_memory as the live scratchpad "
+        "of where we left off; do not ask the user to re-explain it.\n\n"
+        + "\n\n".join(parts)
+    )
+
+
+def soul_system_fragment(max_chars: int = 8000) -> str:
+    """Soul identity as a system-prompt block (same rationale as gold)."""
+    try:
+        path = USER_MEMORY_DIR / "soul.md"
+        if not path.exists():
+            return ""
+        raw = path.read_text(encoding="utf-8", errors="replace")
+        body = raw
+        if raw.lstrip().startswith("---"):
+            try:
+                from .store import parse_frontmatter
+                _, body = parse_frontmatter(raw)
+            except Exception:
+                body = raw
+        body = _clamp_body(body, max_chars)
+        if not body:
+            return ""
+        return (
+            "# ── Identity Essence (soul) ──\n"
+            f"[Identity Essence Loaded: soul]\n\n{body}"
+        )
+    except Exception:
+        return ""
+
+
+def gold_context_messages(max_chars: int = 8000) -> list[dict[str, str]]:
+    """GUI/REPL *display* copies of gold memories (NOT the model source of truth).
+
+    Kept as ``role:assistant`` so `/api/chat/history` and the desktop GUI can
+    render "🏆 Gold memory loaded" in the transcript. The agent loop strips
+    these markers before the provider call; the real baseline rides in the
+    system prompt via ``gold_system_fragment()``.
+
+    Deliberately NOT gated by the ``mem_palace`` config toggle.
+    """
+    messages: list[dict[str, str]] = []
+    for name, body in _iter_gold_entries(max_chars=max_chars):
+        messages.append({
+            "role": "assistant",
+            "content": f"[Golden Memory Loaded: {name}]\n\n{body}",
+        })
+    return messages
+
+
 def ensure_memory_palace() -> bool:
     """Initialize missing core buckets + always ensure gold short_memory.
 

{dulus-3.13.4 → dulus-3.13.5}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "3.13.4"
+version = "3.13.5"
 description = "Provider-independent agent runtime for the terminal — cloud and local models, real tools, MCP, plugins, memory, sub-agents, and Dulus OS."
 readme = "README.md"
 requires-python = ">=3.10"

dulus-3.13.5/tests/test_gold_memory_preload.py

@@ -0,0 +1,151 @@
+"""Gold memory (incl. short_memory) must survive `/mem_palace off`.
+
+`/mem_palace` is a cost knob for per-turn *semantic search*. It was silently
+also starving the model of the curated `short_memory` scratchpad, and the
+GUI/WebChat surfaces never loaded gold memories at all — only the CLI REPL
+did. These tests lock the contract:
+
+1. `gold_context_messages()` returns gold entries regardless of any config.
+2. WebChat's `_preload_gold_memories` seeds a fresh session even when
+   `mem_palace=False` (GUI *display* copies).
+3. The preload is idempotent (re-entry must not double-inject).
+4. Model source of truth is the system prompt via `gold_system_fragment` /
+   `soul_system_fragment` — always present, even under lite mode.
+5. API path strips baseline display blobs (soul/gold/welcome).
+6. MemPalace per-turn inject skips short_memory / soul (no dual-path noise).
+"""
+from __future__ import annotations
+
+from agent import AgentState
+
+
+def test_gold_context_messages_includes_short_memory() -> None:
+    from memory import gold_context_messages
+    from memory.store import is_short_memory_name
+
+    msgs = gold_context_messages()
+    assert msgs, "gold_context_messages returned nothing — short_memory missing?"
+    for m in msgs:
+        assert m["role"] == "assistant"  # GUI display copy
+        assert m["content"].startswith("[Golden Memory Loaded:")
+    assert any(
+        is_short_memory_name(
+            m["content"].split("]", 1)[0].removeprefix("[Golden Memory Loaded: ").strip()
+        )
+        for m in msgs
+    ), "short_memory must always be among the gold preload"
+
+
+def test_gold_system_fragment_is_model_source_of_truth() -> None:
+    """System prompt fragment carries short_memory — not chat turns."""
+    from memory import gold_system_fragment
+
+    frag = gold_system_fragment()
+    assert frag, "gold_system_fragment empty — short_memory not in system baseline"
+    assert "short_memory" in frag or "Short Memory" in frag
+    assert "[Golden Memory Loaded:" in frag
+    assert "always-on baseline" in frag.lower() or "Golden Memory" in frag
+
+
+def test_build_system_prompt_embeds_gold_and_soul() -> None:
+    from context import build_system_prompt
+
+    prompt = build_system_prompt({"model": "test-model", "lite_mode": True})
+    assert "[Golden Memory Loaded:" in prompt or "short_memory" in prompt.lower()
+    # Soul may or may not exist on a fresh machine; gold short_memory is forced.
+
+
+def test_preload_runs_with_mem_palace_off() -> None:
+    """The bug this guards: `/mem_palace off` used to also blind the model to gold."""
+    import webchat_server as ws
+
+    state = AgentState()
+    cfg = {"mem_palace": False}
+
+    ws._preload_gold_memories(state, cfg)
+
+    assert state.messages, "gold preload skipped while mem_palace was off"
+    assert any(
+        m["content"].startswith(ws._GOLD_MARKER) for m in state.messages
+    )
+
+
+def test_preload_is_idempotent() -> None:
+    import webchat_server as ws
+
+    state = AgentState()
+    cfg: dict = {"mem_palace": True}
+
+    ws._preload_gold_memories(state, cfg)
+    first = len(state.messages)
+    assert first >= 1
+
+    ws._preload_gold_memories(state, cfg)
+    assert len(state.messages) == first, "gold preload double-injected"
+
+
+def test_baseline_display_message_detector() -> None:
+    from memory import is_baseline_display_message, is_baseline_memory_name
+
+    assert is_baseline_display_message({
+        "role": "assistant",
+        "content": "[Golden Memory Loaded: short_memory]\n\nhello",
+    })
+    assert is_baseline_display_message({
+        "role": "assistant",
+        "content": "[Identity Essence Loaded: soul]\n\nI am Dulus",
+    })
+    assert is_baseline_display_message({
+        "role": "assistant",
+        "content": "<!-- dulus:welcome -->\nWelcome",
+    })
+    assert not is_baseline_display_message({
+        "role": "assistant",
+        "content": "Normal reply about OVH",
+    })
+    assert is_baseline_memory_name("short_memory")
+    assert is_baseline_memory_name("short-memory")
+    assert is_baseline_memory_name("soul")
+    assert not is_baseline_memory_name("ovh_le_beast")
+
+
+def test_lookback_strips_baseline_from_api_window() -> None:
+    from lookback import apply_lookback_window
+
+    msgs = [
+        {"role": "assistant", "content": "[Golden Memory Loaded: short_memory]\n\nOVH stuck"},
+        {"role": "assistant", "content": "[Identity Essence Loaded: soul]\n\nI am Dulus"},
+        {"role": "user", "content": "klk"},
+        {"role": "assistant", "content": "Klk papi"},
+    ]
+    window, meta = apply_lookback_window(msgs, {"lookback": False})
+    assert all(
+        not (m.get("content") or "").startswith("[Golden Memory Loaded:")
+        for m in window
+    )
+    assert all(
+        not (m.get("content") or "").startswith("[Identity Essence Loaded:")
+        for m in window
+    )
+    assert any(m.get("content") == "klk" for m in window)
+    assert meta.get("baseline_stripped", 0) >= 2 or len(window) == 2
+
+
+def test_is_baseline_memory_name_filters_mempalace_hits() -> None:
+    from memory import is_baseline_memory_name
+
+    hits = [
+        {"name": "short_memory", "content": "OVH", "keyword_score": 0.9},
+        {"name": "palace", "content": "# Short Memory (gold)\n...", "keyword_score": 0.8},
+        {"name": "ovh_notes", "content": "le-beast IP", "keyword_score": 0.7},
+        {"name": "soul", "content": "I am Dulus", "keyword_score": 0.6},
+    ]
+    kept = [
+        h for h in hits
+        if not is_baseline_memory_name(h.get("name"))
+    ]
+    names = {h["name"] for h in kept}
+    assert "short_memory" not in names
+    assert "soul" not in names
+    assert "ovh_notes" in names
+    assert "palace" in names  # generic palace name stays; content filter is separate