codespy-ai 2.0.2__tar.gz → 2.1.1__tar.gz

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespy-ai
-Version: 2.0.2
+Version: 2.1.1
 Summary: Code review agent powered by DSPy
 License: MIT
 License-File: LICENSE
@@ -23,7 +23,7 @@ Requires-Dist: cloudpickle (>=3.1.2,<4.0.0)
 Requires-Dist: ddgs (>=8.0.0)
 Requires-Dist: dspy[mcp] (>=3.3.0,<4.0.0)
 Requires-Dist: gitpython (>=3.1.42)
-Requires-Dist: hindsight-api-slim (>=0.10.1)
+Requires-Dist: hindsight-api-slim (>=1.0.0,<2)
 Requires-Dist: httpx (>=0.28.0)
 Requires-Dist: json-repair (>=0.60.1)
 Requires-Dist: litellm (>=1.84.0,<2.0.0)

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codespy-ai"
-version = "2.0.2"
+version = "2.1.1"
 description = "Code review agent powered by DSPy"
 readme = "README.md"
 license = "MIT"
@@ -53,7 +53,7 @@ beautifulsoup4 = ">=4.12.0"
 markdownify = ">=0.15.0"
 ddgs = ">=8.0.0"
 pg0-embedded = ">=0.15"
-hindsight-api-slim = ">=0.10.1"
+hindsight-api-slim = ">=1.0.0,<2"
 
 [tool.poetry.group.dev.dependencies]
 pytest = ">=8.0.0"

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/__init__.py

@@ -1,3 +1,3 @@
 """codespy - Code review agent powered by DSPy."""
 
-__version__ = "2.0.2"
+__version__ = "2.1.1"

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/agents/memory/cerebral/cerebral.py

@@ -33,7 +33,7 @@ HINDSIGHT_SCHEMA_DEFAULT = "semantic"
 # needs sentence-transformers and emits a misleading startup warning
 # (hindsight_api/config.py _validate). That config is built and cached at IMPORT
 # time — the `from hindsight_api import MemoryEngine` below pulls in
-# engine.llm_wrapper, whose module-level _get_raw_config() calls
+# engine.llm_wrapper, which builds Hindsight's cached config via
 # HindsightConfig.from_env(). So these env vars MUST be set before that import
 # line, not in Cerebral.__init__ (too late). We inject our own LiteLLM-SDK
 # embeddings and an RRF-passthrough cross-encoder in Cerebral.__init__, so the
@@ -61,20 +61,12 @@ from hindsight_api.extensions.builtin.tenant import DefaultTenantExtension
 from hindsight_api.models import RequestContext
 from hindsight_api.worker.exceptions import DeferOperation
 
-# Install delta operations coercion shim for string-encoded operations
-# (see delta_ops_compat.py for details)
-from codespy.agents.memory.cerebral.delta_ops_compat import install_delta_ops_coercion
-
-install_delta_ops_coercion()
-
-# Install native structured output support and Bedrock schema sanitizer
+# Register native structured output for Bedrock models litellm's map lacks the flag for
 from codespy.agents.memory.cerebral.structured_output import (
-    install_bedrock_schema_sanitizer,
     register_native_structured_output_overrides,
 )
 
 register_native_structured_output_overrides()
-install_bedrock_schema_sanitizer()
 
 
 class _SchemaSyncTaskBackend(SyncTaskBackend):
@@ -233,7 +225,6 @@ from codespy.agents.memory.cerebral.cost import (
     MeteredLiteLLMSDKEmbeddings,
     register_cerebral_cost_recorder,
 )
-from codespy.agents.memory.cerebral.routines import ensure_maintenance_routines
 from codespy.agents.memory.prefrontal.reach import (
     TAG_ORG,
     TAG_PROJECT_SCOPE,
@@ -283,17 +274,23 @@ HINDSIGHT_SCHEMA = HINDSIGHT_SCHEMA_DEFAULT
 # - include_chunks=False: Observation text only (no file chunks)
 # - reflect_search_observations_max_tokens=3000: Down from 5000 default
 # - reflect_search_observations_include_entities=False: Exclude entity metadata
+# - budget=low: a refresh gets reflect_max_iterations // 2 iterations, like Prefrontal
+#   reflect (Hindsight treats a null budget as MID for refreshes)
+# - keep_trace=True: store the refresh trace with the briefing
+# Key names must be exact: create_mental_model stores the dict without validating it.
 _BRIEFING_TRIGGER_STATIC = {
     "mode": "delta",
     "exclude_mental_models": True,
     "include_chunks": False,
     "reflect_search_observations_max_tokens": 3000,
     "reflect_search_observations_include_entities": False,
+    "budget": "low",
+    "keep_trace": True,
 }
 
-# Content Hindsight's HTTP API gives a mental model before its first refresh.
-# Prefrontal skips briefings that still hold it.
-MENTAL_MODEL_PLACEHOLDER = "Generating content..."
+# Content pre-1.0 Hindsight gave a mental model before its first refresh.
+# Only used to clear it from upgraded rows (see Cerebral._clear_legacy_placeholders).
+_LEGACY_PLACEHOLDER = "Generating content..."
 
 # Generic (not code-review specific) question each briefing answers.
 MENTAL_MODEL_SOURCE_QUERY = (
@@ -465,19 +462,19 @@ class Cerebral:
         # Install two-step structured output fallback when extraction model is configured
         if extraction_llm_model:
             try:
-                from hindsight_api.engine.llm_wrapper import LLMConfig
+                from hindsight_api.engine.llm_wrapper import LLMProvider
                 from codespy.agents.memory.cerebral.structured_output import (
                     install_two_step_structured_output,
                 )
 
-                extraction_cfg = LLMConfig(
+                extraction_llm = LLMProvider(
                     provider="litellm",
                     model=extraction_llm_model,
                     api_key=extraction_llm_api_key,
                     base_url=extraction_llm_base_url or "",
                     reasoning_effort=None,
                 )
-                extraction_impl = extraction_cfg._provider_impl
+                extraction_impl = extraction_llm._provider_impl
                 install_two_step_structured_output(self._engine, extraction_impl)
             except Exception:
                 logger.warning(
@@ -488,11 +485,6 @@ class Cerebral:
 
         self._run_async(self._engine.initialize())
 
-        # One-time repair: install maintenance routines if missing.
-        # This is idempotent and only needed for databases that were migrated
-        # before HINDSIGHT_API_DATABASE_SCHEMA was set to "semantic" (upstream #2638).
-        self._run_async(ensure_maintenance_routines(self._engine, HINDSIGHT_SCHEMA))
-
         # Repair orphaned pending operations left by inline SyncTaskBackend
         from codespy.agents.memory.cerebral.orphans import repair_orphaned_operations
 
@@ -596,14 +588,11 @@ class Cerebral:
                 # pending rows from blocking scoped submissions).
                 "enable_auto_consolidation": False,
             }
-            # Per-scope observation cap (not bank-wide; -1 means unlimited)
-            if self._max_observations_per_scope >= 0:
-                updates["observation_scope_limits"] = [
-                    {
-                        "scope": [f"{TAG_ORG}*", f"{TAG_REPO}*", f"{TAG_PROJECT_SCOPE}*"],
-                        "limit": self._max_observations_per_scope,
-                    }
-                ]
+            # Per-scope observation cap (never the bank-wide max_observations_per_scope).
+            # Sent unconditionally so -1 (unlimited) lifts a previously stored cap.
+            updates["consolidation_strategies"] = self._consolidation_strategies()
+            # Tombstone the deprecated key (bank config merges with `config || $1`).
+            updates["observation_scope_limits"] = None
             self._run_async(
                 self._engine.update_bank_config(
                     self._bank_id,
@@ -611,10 +600,58 @@ class Cerebral:
                     request_context=ctx,
                 )
             )
+            self._clear_legacy_placeholders(ctx)
         except Exception:
             logger.warning("cerebral: failed to configure bank %s", self._bank_id, exc_info=True)
         self._bank_ensured = True
 
+    def _consolidation_strategies(self) -> list[dict[str, Any]]:
+        """``consolidation_strategies`` payload carrying the per-scope observation cap."""
+        return [
+            {
+                "scopes": [
+                    {
+                        "tags": [f"{TAG_ORG}*", f"{TAG_REPO}*", f"{TAG_PROJECT_SCOPE}*"],
+                        "tags_match": "exact",
+                    }
+                ],
+                "max_observations_per_scope": self._max_observations_per_scope,
+            }
+        ]
+
+    def _clear_legacy_placeholders(self, ctx: RequestContext) -> int:
+        """Empty briefings that still hold the pre-1.0 placeholder. Returns the count.
+
+        Pages through every mental model of the bank and rewrites legacy rows
+        with ``content=""`` (what Hindsight 1.0 creates pages with).
+        """
+        cleared = 0
+        offset = 0
+        while True:
+            page = self._run_async(
+                self._engine.list_mental_models(
+                    self._bank_id,
+                    detail="full",
+                    limit=100,
+                    offset=offset,
+                    request_context=ctx,
+                )
+            )
+            for item in page.items:
+                if (item.get("content") or "").strip().startswith(_LEGACY_PLACEHOLDER):
+                    self._run_async(
+                        self._engine.update_mental_model(
+                            self._bank_id, item["id"], content="", request_context=ctx
+                        )
+                    )
+                    cleared += 1
+            offset += len(page.items)
+            if not page.items or offset >= page.total:
+                break
+        if cleared:
+            logger.info("cerebral: cleared legacy placeholder from %d briefing(s)", cleared)
+        return cleared
+
     @staticmethod
     def _mutation_lines(episode: Episode) -> list[str]:
         """Build observation lines from episode mutations.
@@ -943,7 +980,7 @@ class Cerebral:
                                 self._bank_id,
                                 self._mental_model_name(tags),
                                 self._mental_model_source_query(tags),
-                                MENTAL_MODEL_PLACEHOLDER,
+                                "",
                                 mental_model_id=mm_id,
                                 tags=sorted(tags),
                                 max_tokens=self._max_mental_model_tokens,
@@ -965,12 +1002,12 @@ class Cerebral:
                             self._engine.get_mental_model(self._bank_id, mm_id, request_context=ctx)
                         )
                 else:
-                    # Existing briefing: update trigger if it differs
+                    # Existing briefing: update trigger if it differs. Stored triggers
+                    # are merged supersets (update_mental_model patches), so compare
+                    # only the keys codespy sends.
                     current_trigger = existing.get("trigger") or {}
-                    needs_update = (
-                        current_trigger.get("refresh_after_consolidation") != self._mental_models
-                        or current_trigger.get("exclude_mental_models") is not True
-                        or current_trigger.get("mode", "delta") != "delta"
+                    needs_update = any(
+                        current_trigger.get(k) != v for k, v in desired_trigger.items()
                     )
                     if needs_update:
                         self._run_async(
@@ -1280,10 +1317,10 @@ class Cerebral:
                     summary.rewrite = True
 
         # Count iterations from agent_<n> scopes (excluding _err variants)
-        # +1 if there's any final scope (map, reduce, or rewrite)
+        # +1 if there's any final scope (map, reduce, rewrite, or Hindsight 1.0's closing_done)
         agent_scopes = {s for s in scope_names if s.startswith("agent_") and not s.endswith("_err")}
         summary.iterations = len(agent_scopes)
-        if any(s.startswith("final") for s in scope_names):
+        if any(s.startswith("final") or s == "closing_done" for s in scope_names):
             summary.iterations += 1
 
         # Tools from tool_trace (list of ToolCallTrace with output dict)

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/agents/memory/cerebral/cost.py

@@ -117,6 +117,7 @@ class CerebralCostRecorder:
         scope: str = "",
         input_tokens: int = 0,
         output_tokens: int = 0,
+        thoughts_tokens: int | None = 0,
         error: Exception | None = None,
         duration: float = 0.0,
         **_: Any,
@@ -127,7 +128,10 @@ class CerebralCostRecorder:
             model: Full litellm model string (e.g., "bedrock/converse/moonshotai.kimi-k2.5")
             scope: Hindsight scope (e.g., "retain_extract_facts", "consolidation")
             input_tokens: Input/prompt token count
-            output_tokens: Output/completion token count
+            output_tokens: Visible output/completion token count
+            thoughts_tokens: Reasoning tokens. Hindsight >=0.10.2 reports them apart
+                from ``output_tokens``; they are billed as output, so they are
+                folded into the output count used for pricing and tracking.
             error: Exception if the call failed
             duration: Duration of the call in seconds
             **_: Ignored extra kwargs for forward compatibility
@@ -137,21 +141,23 @@ class CerebralCostRecorder:
             and errored calls that reached the provider (with billed usage).
         """
         try:
+            billed_output = output_tokens + (thoughts_tokens or 0)
+
             # Skip calls with no tokens (includes failed calls that never reached provider)
-            if input_tokens == 0 and output_tokens == 0:
+            if input_tokens == 0 and billed_output == 0:
                 return
 
             # Price the call using litellm
-            prompt_cost, completion_cost = self._price_call_split(model, input_tokens, output_tokens)
+            prompt_cost, completion_cost = self._price_call_split(model, input_tokens, billed_output)
             cost = prompt_cost + completion_cost
-            tokens = input_tokens + output_tokens
+            tokens = input_tokens + billed_output
 
             # Determine bucket: an active recall wins over the scope/task tag,
             # because Hindsight scopes cannot tell a reflect apart
             # from a mental-model refresh.
             usage = current_recall_usage.get()
             if usage is not None:
-                usage.add_llm(model, input_tokens, output_tokens, prompt_cost, completion_cost)
+                usage.add_llm(model, input_tokens, billed_output, prompt_cost, completion_cost)
                 bucket = BUCKET_MEMORY_RECALL
             else:
                 bucket = _llm_bucket(scope)
@@ -166,7 +172,7 @@ class CerebralCostRecorder:
                 tokens=tokens,
                 calls=1,
                 input_tokens=input_tokens,
-                output_tokens=output_tokens,
+                output_tokens=billed_output,
                 input_cost=prompt_cost,
                 output_cost=completion_cost,
                 duration=duration,

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/agents/memory/cerebral/structured_output.py

@@ -3,7 +3,6 @@
 Provides:
 - Native structured output registration for Bedrock models that support it
   but lack the flag in litellm's model map.
-- JSON schema sanitization for Bedrock's structured output constraints.
 - Two-step structured output fallback for models that don't enforce schemas.
 
 See: .kilo/plans/1790926015516-retain-facts-string-coercion.md
@@ -11,7 +10,6 @@ See: .kilo/plans/1790926015516-retain-facts-string-coercion.md
 
 from __future__ import annotations
 
-import copy
 import logging
 from typing import Any, Callable
 
@@ -25,10 +23,6 @@ _NATIVE_STRUCTURED_OUTPUT_OVERRIDES: dict[str, str] = {
     "nvidia.nemotron-super-3-120b": "bedrock_converse",
 }
 
-# Marker for idempotent wrapper installation
-_SCHEMA_SANITIZER_MARKER = "_codespy_schema_sanitizer"
-
-
 def register_native_structured_output_overrides() -> None:
     """Register native structured output capability for known-capable models.
 
@@ -89,198 +83,6 @@ def _verify_registration(model: str) -> None:
         logger.warning("Could not verify native structured output for %s: %s", model, e)
 
 
-def _strip_disallowed_keywords(schema: dict[str, Any]) -> dict[str, Any]:
-    """Recursively strip JSON Schema keywords disallowed by Bedrock.
-
-    Bedrock's structured output accepts a subset of Draft 2020-12.
-    Disallowed keywords are silently rejected with a 400.
-
-    Strips:
-    - minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf
-    - minLength, maxLength, pattern
-    - maxItems
-    - minItems with value > 1 (minItems: 0 or 1 is allowed)
-    - format values outside: date-time, time, date, duration, email,
-      hostname, uri, ipv4, ipv6, uuid
-    - additionalProperties values other than false (forced to false)
-
-    Recurses through: properties, items, $defs, definitions, anyOf, allOf, oneOf.
-    Keys under properties/$defs are names, not keywords - never stripped.
-
-    Returns a deep copy; input is never mutated.
-    """
-    if not isinstance(schema, dict):
-        return schema
-
-    # Deep copy to avoid mutating input
-    result = copy.deepcopy(schema)
-    return _strip_in_place(result)
-
-
-def _strip_in_place(schema: Any) -> Any:
-    """In-place recursive strip. Internal helper."""
-    if not isinstance(schema, dict):
-        return schema
-
-    allowed_formats = {
-        "date-time",
-        "time",
-        "date",
-        "duration",
-        "email",
-        "hostname",
-        "uri",
-        "ipv4",
-        "ipv6",
-        "uuid",
-    }
-
-    # Build list of keys to strip from this level
-    to_strip: list[str] = []
-    modified: list[str] = []
-
-    for key, value in schema.items():
-        if key in (
-            "minimum",
-            "maximum",
-            "exclusiveMinimum",
-            "exclusiveMaximum",
-            "multipleOf",
-            "minLength",
-            "maxLength",
-            "pattern",
-            "maxItems",
-        ):
-            to_strip.append(key)
-            modified.append(key)
-        elif key == "minItems":
-            # Only strip if value > 1
-            if isinstance(value, int) and value > 1:
-                to_strip.append(key)
-                modified.append(key)
-        elif key == "format":
-            if value not in allowed_formats:
-                to_strip.append(key)
-                modified.append(f"format:{value}")
-        elif key == "additionalProperties":
-            # Force to false if not already false
-            if value is not False:
-                schema[key] = False
-                modified.append(f"additionalProperties->{value}")
-
-    # Strip disallowed keys
-    for key in to_strip:
-        del schema[key]
-
-    # Log what was stripped at this level
-    if modified:
-        logger.debug("Bedrock schema sanitizer stripped: %s", modified)
-
-    # Recurse into sub-schemas
-    # Keys under properties/$defs are names, not keywords - preserve them
-    for key in ("properties", "$defs", "definitions"):
-        if key in schema and isinstance(schema[key], dict):
-            for sub_schema in schema[key].values():
-                _strip_in_place(sub_schema)
-
-    # Array items
-    if "items" in schema:
-        _strip_in_place(schema["items"])
-
-    # Combiners
-    for combiner in ("anyOf", "allOf", "oneOf"):
-        if combiner in schema and isinstance(schema[combiner], list):
-            for sub_schema in schema[combiner]:
-                _strip_in_place(sub_schema)
-
-    # AdditionalProperties (if it's a schema, not just false)
-    if isinstance(schema.get("additionalProperties"), dict):
-        _strip_in_place(schema["additionalProperties"])
-
-    # PropertyNames
-    if isinstance(schema.get("propertyNames"), dict):
-        _strip_in_place(schema["propertyNames"])
-
-    return schema
-
-
-def sanitize_bedrock_json_schema(schema: dict[str, Any]) -> dict[str, Any]:
-    """Sanitize a JSON Schema for Bedrock's structured output constraints.
-
-    Args:
-        schema: The JSON Schema dict to sanitize.
-
-    Returns:
-        A deep copy with disallowed keywords stripped.
-    """
-    return _strip_disallowed_keywords(schema)
-
-
-def install_bedrock_schema_sanitizer() -> None:
-    """Install the Bedrock JSON schema sanitizer.
-
-    Patches litellm's AmazonConverseConfig._create_output_config_for_response_format
-    to sanitize schemas before Bedrock receives them.
-
-    Idempotent: calling multiple times has no additional effect.
-    """
-    import functools
-
-    try:
-        from litellm.llms.bedrock.chat.converse_transformation import (
-            AmazonConverseConfig,
-        )
-    except ImportError:
-        logger.debug("AmazonConverseConfig not found; skipping schema sanitizer")
-        return
-
-    # Get the raw descriptor from the class __dict__ to handle staticmethod correctly
-    raw_descriptor = AmazonConverseConfig.__dict__.get(
-        "_create_output_config_for_response_format"
-    )
-    if raw_descriptor is None:
-        logger.warning(
-            "AmazonConverseConfig._create_output_config_for_response_format not found"
-        )
-        return
-
-    # Unwrap staticmethod to get the actual function
-    if isinstance(raw_descriptor, staticmethod):
-        original = raw_descriptor.__func__
-    else:
-        original = raw_descriptor
-
-    # Check if already installed (check on the underlying function)
-    if getattr(original, _SCHEMA_SANITIZER_MARKER, False):
-        logger.debug("Bedrock schema sanitizer already installed")
-        return
-
-    # The original signature is: (json_schema=None, name=None, description=None)
-    @functools.wraps(original)
-    def wrapper(
-        json_schema: dict[str, Any] | None = None,
-        name: str | None = None,
-        description: str | None = None,
-    ) -> Any:
-        """Wrapped staticmethod that sanitizes schemas before passing to Bedrock."""
-        if json_schema is not None and isinstance(json_schema, dict):
-            # Deep copy and sanitize the json_schema
-            json_schema = _strip_disallowed_keywords(json_schema)
-
-        return original(json_schema=json_schema, name=name, description=description)
-
-    # Mark wrapper
-    setattr(wrapper, _SCHEMA_SANITIZER_MARKER, True)
-
-    # Install wrapper as staticmethod
-    setattr(
-        AmazonConverseConfig,
-        "_create_output_config_for_response_format",
-        staticmethod(wrapper),
-    )
-    logger.debug("Installed Bedrock JSON schema sanitizer")
-
-
 def enforces_schema(model: str | None) -> bool | None:
     """Check if a model enforces structured output schemas natively.
 
@@ -553,6 +355,12 @@ def install_two_step_structured_output(
             configs.add(id(cfg))
             llm_configs.append(cfg)
 
+    if not llm_configs:
+        logger.warning(
+            "Two-step structured output: no engine LLM config attribute resolved; "
+            "Hindsight internals may have changed"
+        )
+
     wrapped_count = 0
     for cfg in llm_configs:
         # Check if the config itself is a MultiLLMProvider (fix B2)
@@ -564,7 +372,7 @@ def install_two_step_structured_output(
         impl = getattr(cfg, "_provider_impl", None)
 
         if impl is None:
-            logger.debug("No _provider_impl found on config")
+            logger.warning("No _provider_impl found on config %s", type(cfg).__name__)
             continue
 
         # Skip if the impl is a MultiLLMProvider

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/agents/memory/postgres.py

@@ -33,6 +33,7 @@ class EpisodeStore:
         schema: str | None = None,
         min_size: int = 1,
         max_size: int = 4,
+        persist_recalls: bool = False,
     ):
         """Create store with a psycopg ConnectionPool, scoped to a bank.
 
@@ -45,8 +46,12 @@ class EpisodeStore:
                     (e.g. "episodic", "semantic"). None = server default (public).
             min_size: Minimum connections in pool
             max_size: Maximum connections in pool
+            persist_recalls: Write Prefrontal recall records to the ``recalls``
+                    table. When False (default), ``save_episode`` skips them
+                    and ``save_recalls`` is a no-op. The table is still created.
         """
         self.bank_id = bank_id
+        self.persist_recalls = persist_recalls
         self._schema = schema
         # Inject search_path into the connection string so every pooled
         # connection targets the right schema automatically.
@@ -567,19 +572,20 @@ class EpisodeStore:
                         (self.bank_id, str(episode.id), name, content),
                     )
 
-                # 8. Insert recalls (Prefrontal monitoring) - now with episode_id set
-                self._insert_recalls(
-                    cur, episode.recalls or [], run_id=episode.run_id, episode_id=episode.id, task=episode.task
-                )
+                # 8. Insert recalls (Prefrontal monitoring, opt-in)
+                if self.persist_recalls:
+                    self._insert_recalls(
+                        cur, episode.recalls or [], run_id=episode.run_id, episode_id=episode.id, task=episode.task
+                    )
 
                 conn.commit()
 
         logger.info(
-            "save_episode: persisted episode %s (bank=%s, task=%s, topics=%d, observations=%d, recalls=%d)",
+            "save_episode: persisted episode %s (bank=%s, task=%s, topics=%d, observations=%d, recalls=%s)",
             episode.id, self.bank_id, episode.task,
             len(episode.context_memory.topics),
             len(episode.context_memory.all_observations()),
-            len(episode.recalls or []),
+            len(episode.recalls or []) if self.persist_recalls else "off",
         )
 
     def load_context(
@@ -836,8 +842,10 @@ class EpisodeStore:
             run_id: Run identifier
             episode_id: Optional episode UUID (None for run-level recalls)
             task: Task name (consumer task or "review" for run-level load)
+
+        No-op unless the store was built with ``persist_recalls=True``.
         """
-        if not records:
+        if not self.persist_recalls or not records:
             return
 
         with self._pool.connection() as conn:

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/agents/memory/prefrontal/format.py

@@ -22,10 +22,6 @@ from codespy.agents.memory.prefrontal.reach import (
     tag_value,
 )
 
-# Content a mental model holds until its first refresh completes (kept in sync
-# with cerebral.MENTAL_MODEL_PLACEHOLDER; not imported to avoid loading Hindsight).
-MENTAL_MODEL_PLACEHOLDER = "Generating content..."
-
 SECTION_TITLES: dict[str, str] = {
     FACET_CONTEXT: "Around this work",
     FACET_SEEN_BEFORE: "Seen before",
@@ -158,7 +154,7 @@ def format_context_sections(
     # Briefing sections
     for mm in briefings or []:
         content = (mm.get("content") or "").strip()
-        if not content or content == MENTAL_MODEL_PLACEHOLDER:
+        if not content:
             continue
         name = (mm.get("name") or "Briefing").strip()
         if not name.startswith("Briefing"):

{codespy_ai-2.0.2 → codespy_ai-2.1.1}/src/codespy/agents/memory/prefrontal/prefrontal.py

@@ -27,7 +27,6 @@ import dspy  # type: ignore[import-untyped]
 
 from codespy.agents.memory.prefrontal.facets import run_facets
 from codespy.agents.memory.prefrontal.format import (
-    MENTAL_MODEL_PLACEHOLDER,
     estimate_tokens,
     fget,
     format_context_sections,
@@ -423,7 +422,7 @@ class Prefrontal:
         n_briefings = sum(
             1
             for mm in briefings
-            if (mm.get("content") or "").strip() not in ("", MENTAL_MODEL_PLACEHOLDER)
+            if (mm.get("content") or "").strip()
         )
         facet_details: dict[str, dict[str, Any]] = {}
         for f in facets: