@simbimbo/memory-ocmemog 0.1.17 → 0.1.19

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## Unreleased
 
+## 0.1.19 — 2026-03-29
+
+Hydrate/resume hardening, unresolved-state main-DB consolidation, and retrieval/rehydration source-of-truth completion.
+
+### Highlights
+- eliminated expensive hydrate hot-path scans by adding release-critical indexes for linked-memory and unresolved-state lookups
+- moved unresolved state into the main SQLite memory DB with compatibility import from legacy `unresolved_state.db`
+- removed inline self-heal from `/conversation/hydrate` and kept hydrate read-mostly/fast by default
+- disabled predictive brief generation on hydrate by default and added long-session hydrate guardrails for oversized scopes
+- surfaced hydrate budget/warning metadata for long sessions and added doctor visibility for stale legacy unresolved-state DB residue
+- completed the stranded retrieval/rehydration hardening lane: preserved canonical operator-facing `selected_because` semantics while retaining richer ranking signals, and validated canonical source-of-truth retrieval behavior
+- added regression coverage for resume-latency query plans, long-session guardrails, unresolved-state main-DB migration, and updated retrieval explanation semantics
+- validation passed across the combined retrieval + hydrate + migration + doctor suite, and the canonical `./scripts/ocmemog-release-check.sh` gate passed
+
 ## 0.1.17 — 2026-03-26
 
 Promotion/governance observability, anti-cruft hardening, queue/runtime summary parity, and release validation recovery.

package/ocmemog/doctor.py

@@ -279,6 +279,8 @@ def _run_sqlite_schema(_: None) -> CheckResult:
             tables = {row[0] for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
             missing = sorted(required - tables)
             quick = str(conn.execute("PRAGMA quick_check(1)").fetchone()[0] or "unknown")
+            legacy_unresolved_state_path = state_store.data_dir() / "unresolved_state.db"
+            legacy_unresolved_state_exists = legacy_unresolved_state_path.exists()
             for table in sorted(required):
                 if table in missing:
                     continue
@@ -319,6 +321,7 @@ def _run_sqlite_schema(_: None) -> CheckResult:
             "schema_version_expected": store.SCHEMA_VERSION,
             "schema_versions": version_map,
             "schema_version_issues": version_issues,
+            "legacy_unresolved_state_db": str(legacy_unresolved_state_path) if legacy_unresolved_state_exists else None,
         }
     else:
         details = {
@@ -329,6 +332,7 @@ def _run_sqlite_schema(_: None) -> CheckResult:
             "schema_version_expected": store.SCHEMA_VERSION,
             "schema_versions": version_map,
             "schema_version_issues": version_issues,
+            "legacy_unresolved_state_db": str(legacy_unresolved_state_path) if legacy_unresolved_state_exists else None,
         }
     if version_issues:
         details["schema_version_issues"] = version_issues
@@ -361,11 +365,14 @@ def _run_sqlite_schema(_: None) -> CheckResult:
             message="Schema metadata includes unexpected versions or schema column issues.",
             details=details,
         )
+    message = "SQLite schema and DB open state are healthy."
+    if legacy_unresolved_state_exists:
+        message = "SQLite schema and DB open state are healthy, but legacy unresolved_state.db still exists and should be cleaned up after migration verification."
     return CheckResult(
         key="sqlite/schema-access",
         label="sqlite and schema",
         status="ok",
-        message="SQLite schema and DB open state are healthy.",
+        message=message,
         details=details,
     )
 

package/ocmemog/runtime/memory/conversation_state.py

@@ -29,6 +29,10 @@ _SHORT_REPLY_NORMALIZED = {
     "okay",
     "do it",
     "go ahead",
+    "proceed",
+    "get on it",
+    "lets go",
+    "let us go",
     "sounds good",
     "lets do it",
     "let us do it",
@@ -395,7 +399,10 @@ def _infer_short_reply_resolution(
     if not referent_content:
         return None
     decision = "decline" if normalized in _NEGATIVE_SHORT_REPLY_NORMALIZED else "confirm"
-    effective_summary = turn_content.strip()
+    if decision == "confirm":
+        effective_summary = f"Continue approved step: {referent_content}"
+    else:
+        effective_summary = f"Decline proposed step: {referent_content}"
     return {
         "kind": "short_reply_reference",
         "decision": decision,
@@ -447,10 +454,17 @@ def _enrich_turn_metadata(
             enriched["resolution"] = resolution
             if reply_target is None:
                 reply_target = _get_turn_by_id(resolution.get("resolved_turn_id"))
+    lane_pivot = role == "user" and _looks_like_lane_pivot(content)
     if reply_target:
         reply_meta = _turn_meta(reply_target)
-        branch_root_turn_id = int(reply_meta.get("branch_root_turn_id") or reply_target.get("id") or 0) or None
-        branch_id = str(reply_meta.get("branch_id") or f"branch:{branch_root_turn_id or reply_target.get('id')}")
+        if lane_pivot:
+            branch_root_turn_id = int(reply_target.get("id") or 0) or None
+            branch_id = f"pivot:{branch_root_turn_id or (message_id or 'unknown')}"
+            enriched["lane_pivot"] = True
+            enriched["lane_pivot_from_turn_id"] = int(reply_target.get("id") or 0) or None
+        else:
+            branch_root_turn_id = int(reply_meta.get("branch_root_turn_id") or reply_target.get("id") or 0) or None
+            branch_id = str(reply_meta.get("branch_id") or f"branch:{branch_root_turn_id or reply_target.get('id')}")
         enriched["reply_to_turn_id"] = int(reply_target.get("id") or 0) or None
         enriched["reply_to_reference"] = reply_target.get("reference")
         if reply_target.get("message_id"):
@@ -458,7 +472,7 @@ def _enrich_turn_metadata(
         if branch_root_turn_id:
             enriched["branch_root_turn_id"] = branch_root_turn_id
         enriched["branch_id"] = branch_id
-        enriched["branch_depth"] = int(reply_meta.get("branch_depth") or 0) + 1
+        enriched["branch_depth"] = int(reply_meta.get("branch_depth") or 0) + 1 if not lane_pivot else 1
     elif message_id and "branch_id" not in enriched:
         enriched["branch_id"] = f"message:{message_id}"
         enriched["branch_depth"] = 0
@@ -478,6 +492,30 @@ def _effective_turn_content(turn: Optional[Dict[str, Any]]) -> Optional[str]:
     return content or None
 
 
+def _looks_like_lane_pivot(text: str) -> bool:
+    lowered = _normalize_conversation_text(text).lower()
+    if not lowered:
+        return False
+    return any(
+        token in lowered
+        for token in (
+            "before we continue",
+            "let's pause",
+            "lets pause",
+            "back to",
+            "move back",
+            "return to",
+            "failing us",
+            "before we move back",
+            "pause for one second",
+            "task list for",
+            "can you show me",
+            "what did we just fix",
+            "what is the task list",
+        )
+    )
+
+
 def _reply_chain_for_turn(turn: Optional[Dict[str, Any]], turns: Sequence[Dict[str, Any]], *, limit: int = 6) -> List[Dict[str, Any]]:
     if not turn:
         return []
@@ -494,7 +532,21 @@ def _reply_chain_for_turn(turn: Optional[Dict[str, Any]], turns: Sequence[Dict[s
             break
         seen.add(reply_to_turn_id)
         current = lookup.get(reply_to_turn_id) or _get_turn_by_id(reply_to_turn_id)
-    return list(reversed(chain))
+    chain = list(reversed(chain))
+
+    # Trim temporary side-answer prefixes when the later cluster clearly returns to the foreground lane.
+    if len(chain) >= 4:
+        for idx in range(len(chain) - 3):
+            first = chain[idx]
+            second = chain[idx + 1]
+            third = chain[idx + 2]
+            first_text = _normalize_conversation_text(str(first.get("content") or "").strip()).lower()
+            second_text = _normalize_conversation_text(str(second.get("content") or "").strip()).lower()
+            third_text = _normalize_conversation_text(str(third.get("content") or "").strip()).lower()
+            if first.get("role") == "assistant" and second.get("role") == "user" and third.get("role") == "assistant":
+                if any(token in first_text for token in ("recent", "repo work", "list", "includes", "task list", "show me")) and any(token in second_text for token in ("great", "proceed", "task list", "back to", "continue")):
+                    return chain[idx + 1 :]
+    return chain
 
 
 def _active_branch_payload(turns: Sequence[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
@@ -512,13 +564,56 @@ def _active_branch_payload(turns: Sequence[Dict[str, Any]]) -> Optional[Dict[str
     ]
     if not branch_turns:
         branch_turns = [latest_turn]
+
+    reply_chain = _reply_chain_for_turn(latest_turn, turns_list, limit=8)
+    reply_chain_ids = [int(item.get("id") or 0) for item in reply_chain if int(item.get("id") or 0) > 0]
+    latest_turn_id = int(latest_turn.get("id") or 0)
+
+    # When a later user/assistant cluster explicitly pivots or returns to a lane,
+    # prefer the suffix of the branch starting at the most recent non-reply turn that
+    # follows the earlier adjacent lane. This keeps fluid topic switches from dragging
+    # previous foreground work into the active branch payload.
+    suffix_start_id = reply_chain_ids[0] if reply_chain_ids else latest_turn_id
+    for turn in reversed(branch_turns):
+        turn_id = int(turn.get("id") or 0)
+        if turn_id <= 0 or turn_id >= latest_turn_id:
+            continue
+        meta = _turn_meta(turn)
+        if meta.get("reply_to_turn_id"):
+            continue
+        if turn.get("role") != "user":
+            continue
+        turn_text = _normalize_conversation_text(str(turn.get("content") or "").strip()).lower()
+        if any(token in turn_text for token in ("before we continue", "let's pause", "move back", "back to", "failing us", "return to", "resume", "task list for", "can you show me", "what did we just fix", "what is the task list")):
+            suffix_start_id = turn_id
+            break
+
+    # If the latest reply chain is the user explicitly returning after a temporary side answer,
+    # do not keep the side-answer assistant turn as foreground branch context.
+    if len(reply_chain_ids) >= 2:
+        first_reply_id = reply_chain_ids[0]
+        first_reply_turn = next((turn for turn in branch_turns if int(turn.get("id") or 0) == first_reply_id), None)
+        if first_reply_turn and first_reply_turn.get("role") == "assistant":
+            first_reply_text = _normalize_conversation_text(str(first_reply_turn.get("content") or "").strip()).lower()
+            if any(token in first_reply_text for token in ("recent", "repo work", "list", "includes", "task list", "show me")):
+                user_followup_id = reply_chain_ids[1] if len(reply_chain_ids) > 1 else None
+                if user_followup_id:
+                    suffix_start_id = max(suffix_start_id, user_followup_id)
+
+    filtered_branch_turns = [
+        turn for turn in branch_turns
+        if int(turn.get("id") or 0) >= suffix_start_id or int(turn.get("id") or 0) in reply_chain_ids
+    ]
+    if filtered_branch_turns:
+        branch_turns = filtered_branch_turns
+
     return {
         "branch_id": branch_id,
         "root_turn_id": root_turn_id or latest_turn.get("id"),
         "latest_turn": _turn_anchor(latest_turn),
         "turn_ids": [int(turn.get("id") or 0) for turn in branch_turns],
         "turns": [_turn_anchor(turn) for turn in branch_turns[-8:]],
-        "reply_chain": _reply_chain_for_turn(latest_turn, turns_list, limit=8),
+        "reply_chain": reply_chain,
     }
 
 

package/ocmemog/runtime/memory/memory_links.py

@@ -46,6 +46,12 @@ def _ensure_table(conn) -> None:
             "CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_links_unique ON memory_links(source_reference, link_type, target_reference)"
         )
         conn.commit()
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_memory_links_target_created_source ON memory_links(target_reference, created_at DESC, source_reference DESC)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_memory_links_source_created_target ON memory_links(source_reference, created_at DESC, target_reference)"
+    )
 
 
 def add_memory_link(source_reference: str, link_type: str, target_reference: str) -> None:

package/ocmemog/runtime/memory/promote.py

@@ -49,7 +49,26 @@ def _should_promote(confidence: float, threshold: float | None = None) -> bool:
 
 def _destination_table(summary: str) -> str:
     lowered = summary.lower()
-    if "runbook" in lowered or "procedure" in lowered or "steps" in lowered:
+    procedural_markers = (
+        "runbook",
+        "procedure",
+        "steps",
+        "checklist",
+        "how to",
+        "how-do-i",
+        "upgrade",
+        "recover",
+        "recovery",
+        "rollback",
+        "restart",
+        "validate",
+        "verification",
+        "diagnose",
+        "troubleshoot",
+        "fix by",
+        "safe way",
+    )
+    if any(marker in lowered for marker in procedural_markers):
         return "runbooks"
     if "lesson" in lowered or "postmortem" in lowered or "learned" in lowered:
         return "lessons"
@@ -64,6 +83,46 @@ def _normalized_text(text: str) -> str:
     return " ".join((text or "").strip().lower().split())
 
 
+def _looks_like_changelog_or_release_notes(text: str) -> bool:
+    lowered = _normalized_text(text)
+    if not lowered:
+        return False
+    changelog_markers = (
+        "thanks @",
+        "(#",
+        "ghsa-",
+        "release notes",
+        "changelog",
+        "breaking change",
+        "bootstrap:",
+        "security/",
+        "agents/",
+        "telegram:",
+        "discord/",
+        "slack/",
+        "providers/",
+        "install/",
+        "docker/",
+    )
+    bulletish = lowered.count(" - ") >= 2 or lowered.startswith("-")
+    return bulletish and any(marker in lowered for marker in changelog_markers)
+
+
+def _looks_like_docs_index_link_list(text: str) -> bool:
+    lowered = _normalized_text(text)
+    if not lowered:
+        return False
+    markers = (
+        "start with the docs index",
+        "architecture overview",
+        "full configuration reference",
+        "run the gateway by the book",
+        "learn how the control ui/web surfaces work",
+        "https://docs.openclaw.ai",
+    )
+    return lowered.count("https://docs.openclaw.ai") >= 2 and any(marker in lowered for marker in markers)
+
+
 def _is_redundant_generic_candidate(summary_text: str) -> bool:
     normalized = _normalized_text(summary_text)
     if not normalized:
@@ -83,6 +142,8 @@ def _is_redundant_generic_candidate(summary_text: str) -> bool:
 
 
 def _should_reject_as_cruft(*, confidence: float, threshold: float, destination: str, summary_text: str) -> bool:
+    if destination == "runbooks" and (_looks_like_changelog_or_release_notes(summary_text) or _looks_like_docs_index_link_list(summary_text)):
+        return True
     if destination != "knowledge" or confidence >= threshold:
         return False
     return bool(_normalized_text(summary_text))
@@ -189,6 +250,17 @@ def promote_candidate(candidate: Dict[str, Any]) -> Dict[str, Any]:
     candidate_metadata["candidate_id"] = candidate_id
     candidate_metadata["derived_from_candidate_id"] = candidate_id
     candidate_metadata["derived_via"] = "promotion"
+    # Preserve rehydration-critical anchors whenever available.
+    transcript_anchor = candidate_metadata.get("transcript_anchor")
+    if isinstance(transcript_anchor, dict):
+        path_value = transcript_anchor.get("path")
+        if path_value and not candidate_metadata.get("source_path"):
+            candidate_metadata["source_path"] = path_value
+        if not candidate_metadata.get("source_type"):
+            candidate_metadata["source_type"] = "transcript"
+    source_refs = candidate_metadata.get("source_references")
+    if isinstance(source_refs, list) and source_refs and not candidate_metadata.get("source_type"):
+        candidate_metadata["source_type"] = "derived"
 
     conn = store.connect()
     promotion_id = None

package/ocmemog/runtime/memory/retrieval.py

@@ -100,11 +100,267 @@ def _recency_score(timestamp: str | None) -> float:
 
 MEMORY_BUCKETS: Tuple[str, ...] = tuple(store.MEMORY_TABLES)
 
+_PROCEDURAL_QUERY_MARKERS: Tuple[str, ...] = (
+    "how do i",
+    "how to",
+    "procedure",
+    "steps",
+    "checklist",
+    "safely",
+    "safe way",
+    "upgrade",
+    "recover",
+    "recovery",
+    "rollback",
+    "restart",
+    "validate",
+    "verification",
+    "diagnose",
+    "troubleshoot",
+)
+
 
 def _empty_results() -> Dict[str, List[Dict[str, Any]]]:
     return {bucket: [] for bucket in MEMORY_BUCKETS}
 
 
+def _query_intent(prompt: str) -> str:
+    lowered = str(prompt or "").strip().lower()
+    if not lowered:
+        return "generic"
+    if any(marker in lowered for marker in _PROCEDURAL_QUERY_MARKERS):
+        return "procedural"
+    return "generic"
+
+
+def _bucket_intent_bonus(bucket: str, prompt: str, metadata: Dict[str, Any]) -> float:
+    intent = _query_intent(prompt)
+    if intent == "procedural":
+        if bucket == "runbooks":
+            return 0.28
+        if bucket == "knowledge":
+            # Some procedures are still stored as knowledge; keep them competitive.
+            lowered = str(metadata).lower()
+            if any(marker in lowered for marker in _PROCEDURAL_QUERY_MARKERS):
+                return 0.12
+        if bucket in {"tasks", "reflections"}:
+            return -0.12
+    return 0.0
+
+
+def _source_authority_bonus(bucket: str, metadata: Dict[str, Any], content: str, prompt: str) -> float:
+    prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
+    origin_source = str(prov.get("origin_source") or metadata.get("source_path") or "").lower()
+    source_label = str(metadata.get("source_label") or "").lower()
+    text = f"{metadata} {content}".lower()
+    qtype = _query_type(prompt)
+    bonus = 0.0
+    is_policy_doc = "policy established" in text or "anti-rediscovery" in text or "authoritative recall memory" in text
+    is_audit_doc = "scorecard" in text or "results —" in text or "results -" in text or "audit" in text
+    is_continuity_doc = "current-work-continuity-source-of-truth" in origin_source or str(metadata.get("source_label") or "").lower() == "canonical-current-work-continuity"
+    is_user_pref_doc = "preferred development model" in text or "messaging auth safety" in text or "default model" in text
+    is_infra_doc = "truth plane" in text or "librenms" in text or "10.5.56.130" in text or "192.168.1.x" in text or "10.x" in text
+    is_transcript = origin_source == "transcript" or "memory/transcripts/" in text
+    is_canonical_file = "/docs/" in origin_source or str(metadata.get("canonical") or "").lower() == "true"
+
+    if bucket in {"runbooks", "knowledge", "directives"}:
+        if "docs/ops/" in text or "runtime-authority-map.md" in text:
+            bonus += 0.22
+        if "docs/runbooks/" in text or "openclaw-upgrade-validation-runbook.md" in text or "canonical-openclaw-upgrade-runbook" in source_label or "/docs/runbooks/" in origin_source:
+            bonus += 0.55
+        if "workspace/memory/" in text or "transcript:" in text:
+            bonus -= 0.05
+
+    if qtype != "policy" and is_policy_doc:
+        bonus -= 0.45
+    if qtype != "policy" and is_audit_doc:
+        bonus -= 0.22
+
+    if qtype == "infra_fact":
+        if is_infra_doc:
+            bonus += 0.38
+        if not is_infra_doc and (is_policy_doc or is_audit_doc):
+            bonus -= 0.18
+    if qtype == "user_preference":
+        if is_user_pref_doc:
+            bonus += 0.42
+        if not is_user_pref_doc and (is_policy_doc or is_audit_doc):
+            bonus -= 0.16
+    if qtype == "continuity":
+        if bucket == "reflections" and is_transcript:
+            bonus -= 0.30
+        if is_continuity_doc and (bucket in {"knowledge", "directives"} or is_canonical_file):
+            bonus += 0.70
+        if is_policy_doc or is_audit_doc:
+            bonus -= 0.18
+
+    if bucket == "runbooks":
+        if "readme.md" in origin_source or "repos/openclaw/readme.md" in origin_source or "start with the docs index" in text:
+            bonus -= 0.55
+        if "changelog.md" in text or "release notes" in text or "thanks @" in text or "(#" in text:
+            bonus -= 0.35
+        if "quarantine/" in text or "/backups/" in text or "memory/candidates/" in text:
+            bonus -= 0.25
+    return bonus
+
+
+def _doc_type(metadata: Dict[str, Any], bucket: str, content: str) -> str:
+    prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
+    origin_source = str(prov.get("origin_source") or metadata.get("source_path") or "").lower()
+    source_label = str(metadata.get("source_label") or "").lower()
+    text = f"{metadata} {content}".lower()
+    if "canonical-openclaw-upgrade-runbook" in source_label or "/docs/runbooks/" in origin_source or "openclaw-upgrade-validation-runbook.md" in origin_source:
+        return "runbook"
+    if "user-preferences-source-of-truth" in origin_source or "gpt 5.2 codex (ultra)" in text or "never send authentication, challenge, or verification prompts" in text:
+        return "user_preference"
+    if "tbc-truth-plane-source-of-truth" in origin_source or "librenms on 10.5.56.130" in text or "primary truth plane" in text:
+        return "infra_fact"
+    if "current-work-continuity-source-of-truth" in origin_source:
+        return "continuity"
+    if "runtime authority" in text or "launchagent" in text or "authoritative source tree" in text:
+        return "authority_map"
+    if "policy established" in text or "anti-rediscovery" in text or "authoritative recall memory" in text:
+        return "policy"
+    if "audit" in text or "scorecard" in text or "results —" in text or "results -" in text:
+        return "audit"
+    if "how to" in text or "procedure" in text or "checklist" in text or "safely upgrade" in text or "validate logs" in text:
+        return "runbook"
+    if "truth plane" in text or "librenms" in text or "10.5.56.130" in text or "192.168.1.x" in text or "10.x" in text:
+        return "infra_fact"
+    if "preferred development model" in text or "default model" in text or "messaging auth safety" in text:
+        return "user_preference"
+    if bucket != "runbooks" and bucket != "directives" and ("work unit" in text or "checkpoint" in text or "current work lane" in text or "next step" in text):
+        return "continuity"
+    return "generic"
+
+
+def _artifact_family(metadata: Dict[str, Any], bucket: str, content: str) -> str:
+    prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
+    origin_source = str(prov.get("origin_source") or metadata.get("source_path") or "").lower()
+    text = f"{metadata} {content}".lower()
+    if "/docs/runbooks/" in origin_source:
+        return "canonical_runbook"
+    if "user-preferences-source-of-truth" in origin_source:
+        return "user_preference"
+    if "tbc-truth-plane-source-of-truth" in origin_source:
+        return "infra_fact"
+    if "current-work-continuity-source-of-truth" in origin_source:
+        return "continuity_summary"
+    if "runtime-authority-map" in origin_source or "ocmemog-operational-memory-policy" in origin_source or "docs/ops/" in origin_source:
+        return "ops_doc"
+    if "audit" in origin_source or "manifest" in origin_source or "inventory" in origin_source or "almost-trash" in origin_source:
+        return "cleanup_or_audit_meta"
+    if origin_source in {"transcript", "session"} or "memory/transcripts/" in text:
+        return "transcript_or_session_artifact"
+    if "readme.md" in origin_source:
+        return "readme_pseudorunbook"
+    if bucket == "reflections":
+        return "reflection"
+    if bucket == "directives":
+        if "preferred development model" in text or "messaging auth safety" in text or "never send authentication" in text:
+            return "user_preference"
+        if "current work lane" in text or "what still fails" in text or "next priority order" in text:
+            return "continuity_summary"
+        return "generic_process_directive"
+    if bucket == "runbooks" and str(content or "").startswith("After any substantial work block"):
+        return "generic_process_directive"
+    return "generic"
+
+
+_LEGACY_BAD_CONTINUITY_RUNBOOKS = {
+    'runbooks:177', 'runbooks:165', 'runbooks:151', 'runbooks:132', 'runbooks:126', 'runbooks:99', 'runbooks:75', 'runbooks:65', 'runbooks:45'
+}
+
+
+def _artifact_family_penalty(prompt: str, metadata: Dict[str, Any], bucket: str, content: str) -> float:
+    qtype = _query_type(prompt)
+    family = _artifact_family(metadata, bucket, content)
+    ref = str(metadata.get('reference') or '')
+    lowered = str(content or '').lower()
+    if qtype == "infra_fact":
+        if family in {"canonical_runbook", "cleanup_or_audit_meta", "transcript_or_session_artifact", "readme_pseudorunbook", "generic_process_directive"}:
+            return -0.45
+    if qtype == "user_preference":
+        if family in {"canonical_runbook", "cleanup_or_audit_meta", "transcript_or_session_artifact", "readme_pseudorunbook", "generic_process_directive"}:
+            return -0.45
+    if qtype == "continuity":
+        if ref in _LEGACY_BAD_CONTINUITY_RUNBOOKS:
+            return -1.25
+        if family in {"cleanup_or_audit_meta", "transcript_or_session_artifact", "readme_pseudorunbook", "generic_process_directive", "canonical_runbook", "ops_doc"}:
+            return -0.55
+        if family == "reflection":
+            return -0.18
+        if bucket == 'tasks' and ('name: steven imbimbo' in lowered or 'what to call them:' in lowered or 'timezone:' in lowered):
+            return -0.65
+    return 0.0
+
+
+def _query_type(prompt: str) -> str:
+    lowered = str(prompt or "").strip().lower()
+    if not lowered:
+        return "generic"
+    if "policy" in lowered or "rule" in lowered or "anti-rediscovery" in lowered:
+        return "policy"
+    if "what launches" in lowered or "runtime authority" in lowered or "authoritative source tree" in lowered or "health endpoint" in lowered:
+        return "authority_map"
+    if any(marker in lowered for marker in _PROCEDURAL_QUERY_MARKERS):
+        return "runbook"
+    if "truth plane" in lowered or "librenms" in lowered or "192.168.1.x" in lowered or "10.x" in lowered:
+        return "infra_fact"
+    if "preferred development model" in lowered or "auth safety rule" in lowered or "preference" in lowered:
+        return "user_preference"
+    if "current work lane" in lowered or "checkpoint" in lowered or "next step" in lowered:
+        return "continuity"
+    return "generic"
+
+
+def _doc_type_bonus(prompt: str, metadata: Dict[str, Any], bucket: str, content: str) -> float:
+    qtype = _query_type(prompt)
+    dtype = _doc_type(metadata, bucket, content)
+    if qtype == "generic":
+        return 0.0
+    if qtype == dtype:
+        return 0.35
+    compatible = {
+        ("runbook", "authority_map"): -0.16,
+        ("runbook", "policy"): -0.28,
+        ("runbook", "audit"): -0.24,
+        ("infra_fact", "audit"): -0.16,
+        ("infra_fact", "policy"): -0.12,
+        ("policy", "audit"): -0.06,
+        ("policy", "runbook"): -0.12,
+        ("authority_map", "audit"): -0.10,
+        ("continuity", "audit"): -0.08,
+        ("user_preference", "policy"): -0.06,
+    }
+    if (qtype, dtype) in compatible:
+        return compatible[(qtype, dtype)]
+    if dtype in {"policy", "audit", "authority_map"} and qtype not in {dtype, "generic"}:
+        return -0.10
+    return 0.0
+
+
+def _derivative_penalty(bucket: str, metadata: Dict[str, Any], content: str, governance: Dict[str, Any]) -> float:
+    prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
+    source_refs = prov.get("source_references") if isinstance(prov.get("source_references"), list) else []
+    derived_via = str(prov.get("derived_via") or "").strip().lower()
+    origin_source = str(prov.get("origin_source") or "").strip().lower()
+    lowered = str(content or "").lower()
+    penalty = 0.0
+    if bucket == "reflections":
+        if source_refs:
+            penalty -= 0.28
+        if derived_via in {"ponder", "distill", "artifact_distill"}:
+            penalty -= 0.12
+        if lowered.startswith("potential durable learning:") or lowered.startswith("consolidated pattern:"):
+            penalty -= 0.18
+    if governance.get("canonical_reference") and str(governance.get("canonical_reference")) != "" and str(governance.get("canonical_reference")) != str(metadata.get("reference") or ""):
+        penalty -= 0.10
+    if origin_source == "transcript" and bucket == "reflections":
+        penalty -= 0.06
+    return penalty
+
+
 def _parse_metadata(raw: Any) -> Dict[str, Any]:
     if isinstance(raw, dict):
         return raw
@@ -369,7 +625,7 @@ def retrieve(
             if source_type in selected_categories and source_id:
                 semantic_scores[f"{source_type}:{source_id}"] = float(item.get("score") or 0.0)
 
-    def score_record(*, content: str, memory_ref: str, promo_conf: float, timestamp: str | None, metadata_payload: Dict[str, Any]) -> tuple[float, Dict[str, float]]:
+    def score_record(*, bucket: str, content: str, memory_ref: str, promo_conf: float, timestamp: str | None, metadata_payload: Dict[str, Any]) -> tuple[float, Dict[str, float]]:
         keyword = _match_score(content, prompt)
         semantic = float(semantic_scores.get(memory_ref, 0.0))
         reinf = reinforcement.get(memory_ref, {})
@@ -377,7 +633,12 @@ def retrieve(
         promo_score = float(promo_conf) * 0.2
         recency = _recency_score(timestamp)
         lane_bonus = _lane_bonus(metadata_payload, active_lane)
-        score = round((keyword * 0.45) + (semantic * 0.35) + reinf_score + promo_score + recency + lane_bonus, 3)
+        intent_bonus = _bucket_intent_bonus(bucket, prompt, metadata_payload)
+        authority_bonus = _source_authority_bonus(bucket, metadata_payload, content, prompt)
+        doc_type_bonus = _doc_type_bonus(prompt, metadata_payload, bucket, content)
+        family_penalty = _artifact_family_penalty(prompt, metadata_payload, bucket, content)
+        derivative_penalty = _derivative_penalty(bucket, metadata_payload, content, _governance_summary(_governance_state(metadata_payload)[1]))
+        score = round((keyword * 0.45) + (semantic * 0.35) + reinf_score + promo_score + recency + lane_bonus + intent_bonus + authority_bonus + doc_type_bonus + family_penalty + derivative_penalty, 3)
         return score, {
             "keyword": round(keyword, 3),
             "semantic": round(semantic, 3),
@@ -389,6 +650,11 @@ def retrieve(
             "promotion": round(promo_score, 3),
             "recency": round(recency, 3),
             "lane_bonus": round(lane_bonus, 3),
+            "intent_bonus": round(intent_bonus, 3),
+            "authority_bonus": round(authority_bonus, 3),
+            "doc_type_bonus": round(doc_type_bonus, 3),
+            "family_penalty": round(family_penalty, 3),
+            "derivative_penalty": round(derivative_penalty, 3),
         }
 
     for table in selected_categories:
@@ -425,11 +691,16 @@ def retrieve(
                 bucket_counts[memory_status] = int(bucket_counts.get(memory_status) or 0) + 1
                 continue
             metadata = provenance.fetch_reference(mem_ref)
-            score, signals = score_record(content=content, memory_ref=mem_ref, promo_conf=promo_conf, timestamp=timestamp, metadata_payload=metadata_payload)
+            score, signals = score_record(bucket=table, content=content, memory_ref=mem_ref, promo_conf=promo_conf, timestamp=timestamp, metadata_payload=metadata_payload)
             if memory_status == "contested":
                 score = round(max(0.0, score - 0.15), 3)
                 signals["contradiction_penalty"] = 0.15
-            selected_because = max(signals, key=signals.get) if signals else "keyword"
+            primary_reason_order = ("keyword", "semantic", "reinforcement", "promotion", "recency")
+            primary_reason_signals = {
+                key: float(signals.get(key) or 0.0)
+                for key in primary_reason_order
+            }
+            selected_because = max(primary_reason_signals, key=primary_reason_signals.get) if primary_reason_signals else "keyword"
             reinforcement_count = float(signals.get("reinforcement_count") or 0.0)
             negative_penalty = float(signals.get("reinforcement_negative_penalty") or 0.0)
             if reinforcement_count > 0.0 or negative_penalty > 0.0:

package/ocmemog/runtime/memory/store.py

@@ -279,6 +279,17 @@ CREATE TABLE IF NOT EXISTS conversation_state (
 CREATE INDEX IF NOT EXISTS idx_conversation_state_conversation ON conversation_state(conversation_id);
 CREATE INDEX IF NOT EXISTS idx_conversation_state_session ON conversation_state(session_id);
 CREATE INDEX IF NOT EXISTS idx_conversation_state_thread ON conversation_state(thread_id);
+
+CREATE TABLE IF NOT EXISTS unresolved_state (
+  state_id INTEGER PRIMARY KEY AUTOINCREMENT,
+  state_type TEXT NOT NULL,
+  reference TEXT,
+  summary TEXT,
+  created_at TEXT NOT NULL DEFAULT (datetime('now')),
+  resolved INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX IF NOT EXISTS idx_unresolved_state_resolved_reference_created ON unresolved_state(resolved, reference, created_at DESC);
 """
 
 _WRITE_QUEUE: "queue.Queue[tuple]" = queue.Queue()

package/ocmemog/runtime/memory/unresolved_state.py

@@ -2,10 +2,12 @@ from __future__ import annotations
 
 import sqlite3
 import time
+from pathlib import Path
 from typing import Dict, List
 
 from ocmemog.runtime import state_store
 from ocmemog.runtime.instrumentation import emit_event
+from ocmemog.runtime.memory import store
 
 LOGFILE = state_store.report_log_path()
 
@@ -17,12 +19,15 @@ TYPES = {
     "incomplete_hypothesis",
 }
 
+_LEGACY_DB_IMPORTED = False
+
+
+def _legacy_db_path() -> Path:
+    return state_store.data_dir() / "unresolved_state.db"
+
 
 def _connect() -> sqlite3.Connection:
-    path = state_store.data_dir() / "unresolved_state.db"
-    path.parent.mkdir(parents=True, exist_ok=True)
-    conn = sqlite3.connect(str(path))
-    conn.row_factory = sqlite3.Row
+    conn = store.connect()
     conn.execute(
         """
         CREATE TABLE IF NOT EXISTS unresolved_state (
@@ -35,39 +40,95 @@ def _connect() -> sqlite3.Connection:
         )
         """
     )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_unresolved_state_resolved_reference_created ON unresolved_state(resolved, reference, created_at DESC)"
+    )
+    _import_legacy_db_if_needed(conn)
     return conn
 
 
+def _import_legacy_db_if_needed(conn: sqlite3.Connection) -> None:
+    global _LEGACY_DB_IMPORTED
+    if _LEGACY_DB_IMPORTED:
+        return
+    legacy_path = _legacy_db_path()
+    if not legacy_path.exists():
+        _LEGACY_DB_IMPORTED = True
+        return
+    try:
+        existing = conn.execute("SELECT COUNT(*) FROM unresolved_state").fetchone()
+        existing_count = int(existing[0]) if existing else 0
+        legacy = sqlite3.connect(str(legacy_path))
+        legacy.row_factory = sqlite3.Row
+        try:
+            tables = {
+                str(row[0])
+                for row in legacy.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()
+            }
+            if "unresolved_state" not in tables:
+                _LEGACY_DB_IMPORTED = True
+                return
+            rows = legacy.execute(
+                "SELECT state_type, reference, summary, created_at, resolved FROM unresolved_state ORDER BY state_id ASC"
+            ).fetchall()
+        finally:
+            legacy.close()
+        if rows and existing_count == 0:
+            conn.executemany(
+                "INSERT INTO unresolved_state (state_type, reference, summary, created_at, resolved) VALUES (?, ?, ?, ?, ?)",
+                [
+                    (
+                        str(row["state_type"] or "unresolved_question"),
+                        row["reference"],
+                        row["summary"],
+                        row["created_at"] or time.strftime("%Y-%m-%d %H:%M:%S"),
+                        int(row["resolved"] or 0),
+                    )
+                    for row in rows
+                ],
+            )
+            conn.commit()
+            emit_event(LOGFILE, "brain_unresolved_state_legacy_imported", status="ok", imported=len(rows))
+    finally:
+        _LEGACY_DB_IMPORTED = True
+
+
 def add_unresolved_state(state_type: str, reference: str, summary: str) -> int:
     if state_type not in TYPES:
         state_type = "unresolved_question"
     conn = _connect()
-    conn.execute(
-        "INSERT INTO unresolved_state (state_type, reference, summary, created_at, resolved) VALUES (?, ?, ?, ?, 0)",
-        (state_type, reference, summary, time.strftime("%Y-%m-%d %H:%M:%S")),
-    )
-    conn.commit()
-    row = conn.execute("SELECT last_insert_rowid()").fetchone()
-    conn.close()
+    try:
+        conn.execute(
+            "INSERT INTO unresolved_state (state_type, reference, summary, created_at, resolved) VALUES (?, ?, ?, ?, 0)",
+            (state_type, reference, summary, time.strftime("%Y-%m-%d %H:%M:%S")),
+        )
+        conn.commit()
+        row = conn.execute("SELECT last_insert_rowid()").fetchone()
+    finally:
+        conn.close()
     emit_event(LOGFILE, "brain_unresolved_state_added", status="ok", state_type=state_type)
     return int(row[0]) if row else 0
 
 
 def list_unresolved_state(limit: int = 20) -> List[Dict[str, object]]:
     conn = _connect()
-    rows = conn.execute(
-        "SELECT state_id, state_type, reference, summary, created_at FROM unresolved_state WHERE resolved=0 ORDER BY created_at DESC LIMIT ?",
-        (limit,),
-    ).fetchall()
-    conn.close()
+    try:
+        rows = conn.execute(
+            "SELECT state_id, state_type, reference, summary, created_at FROM unresolved_state WHERE resolved=0 ORDER BY created_at DESC LIMIT ?",
+            (limit,),
+        ).fetchall()
+    finally:
+        conn.close()
     return [dict(row) for row in rows]
 
 
 def resolve_unresolved_state(state_id: int) -> bool:
     conn = _connect()
-    conn.execute("UPDATE unresolved_state SET resolved=1 WHERE state_id=?", (state_id,))
-    conn.commit()
-    conn.close()
+    try:
+        conn.execute("UPDATE unresolved_state SET resolved=1 WHERE state_id=?", (state_id,))
+        conn.commit()
+    finally:
+        conn.close()
     emit_event(LOGFILE, "brain_unresolved_state_resolved", status="ok", state_id=state_id)
     return True
 
@@ -78,16 +139,20 @@ def list_unresolved_state_for_references(references: List[str], limit: int = 20)
         return []
     placeholders = ",".join("?" for _ in refs)
     conn = _connect()
-    rows = conn.execute(
-        f"SELECT state_id, state_type, reference, summary, created_at FROM unresolved_state WHERE resolved=0 AND reference IN ({placeholders}) ORDER BY created_at DESC LIMIT ?",
-        (*refs, limit),
-    ).fetchall()
-    conn.close()
+    try:
+        rows = conn.execute(
+            f"SELECT state_id, state_type, reference, summary, created_at FROM unresolved_state WHERE resolved=0 AND reference IN ({placeholders}) ORDER BY created_at DESC LIMIT ?",
+            (*refs, limit),
+        ).fetchall()
+    finally:
+        conn.close()
     return [dict(row) for row in rows]
 
 
 def count_unresolved_state() -> int:
     conn = _connect()
-    row = conn.execute("SELECT COUNT(*) FROM unresolved_state WHERE resolved=0").fetchone()
-    conn.close()
+    try:
+        row = conn.execute("SELECT COUNT(*) FROM unresolved_state WHERE resolved=0").fetchone()
+    finally:
+        conn.close()
     return int(row[0]) if row else 0

package/ocmemog/sidecar/app.py

@@ -684,7 +684,13 @@ class GetRequest(BaseModel):
 
 class ContextRequest(BaseModel):
     reference: str
-    radius: int = Field(default=10, ge=0, le=200)
+    radius: int = Field(default=200, ge=0, le=1000)
+
+
+class TranscriptClaimSearchRequest(BaseModel):
+    query: str
+    radius: int = Field(default=40, ge=0, le=1000)
+    limit: int = Field(default=5, ge=1, le=20)
 
 
 class RecentRequest(BaseModel):
@@ -743,6 +749,11 @@ class ConversationHydrateRequest(BaseModel):
     predictive_brief_limit: int = Field(default=5, ge=1, le=12)
 
 
+_LONG_SESSION_TURN_THRESHOLD = max(200, int(os.environ.get("OCMEMOG_LONG_SESSION_TURN_THRESHOLD", "800") or "800"))
+_LONG_SESSION_HYDRATE_TURNS = max(6, int(os.environ.get("OCMEMOG_LONG_SESSION_HYDRATE_TURNS", "8") or "8"))
+_LONG_SESSION_LINKED_MEMORY_LIMIT = max(1, int(os.environ.get("OCMEMOG_LONG_SESSION_LINKED_MEMORY_LIMIT", "2") or "2"))
+
+
 class ConversationCheckpointRequest(BaseModel):
     conversation_id: Optional[str] = None
     session_id: Optional[str] = None
@@ -939,7 +950,19 @@ def _build_predictive_brief(
 ) -> Dict[str, Any]:
     latest_user_ask = ((summary.get("latest_user_intent") or {}).get("effective_content") if isinstance(summary.get("latest_user_intent"), dict) else None) or ((summary.get("latest_user_ask") or {}).get("content") if isinstance(summary.get("latest_user_ask"), dict) else None) or ""
     summary_text = str(summary.get("summary_text") or "").strip()
-    query = _compact_text(latest_user_ask or summary_text or "resume context", 260)
+
+    linked_query_hints: list[str] = []
+    for item in linked_memories[:3]:
+        if not isinstance(item, dict):
+            continue
+        hint = _compact_text(item.get("summary") or item.get("content") or "", 120)
+        lowered = hint.lower()
+        if any(token in lowered for token in ("codex", "openclaw", "tool", "runtime", "config", "setup", "session", "endpoint", "mechanism", "acp")):
+            linked_query_hints.append(hint)
+    query_seed = latest_user_ask or summary_text or "resume context"
+    if linked_query_hints:
+        query_seed = f"{query_seed} | prior linked precedent: {' | '.join(linked_query_hints[:2])}"
+    query = _compact_text(query_seed, 260)
     lane = retrieval.infer_lane(query)
     profiles = retrieval._load_lane_profiles()
     profile = profiles.get(lane or "") if lane else None
@@ -986,6 +1009,53 @@ def _build_predictive_brief(
             "reference": item.get("reference"),
             "summary": _compact_text(item.get("summary") or item.get("content") or item.get("reference") or "", 140),
         })
+
+    lane_hints = []
+    active_branch = summary.get("active_branch")
+    active_branch_summary = ""
+    if isinstance(active_branch, dict):
+        active_branch_summary = str(active_branch.get("summary") or active_branch.get("branch_id") or "").strip()
+    elif isinstance(active_branch, str):
+        active_branch_summary = active_branch.strip()
+    if active_branch_summary:
+        lane_hints.append({"kind": "active_branch", "summary": _compact_text(active_branch_summary, 120)})
+    if checkpoint and str(checkpoint.get("summary") or "").strip():
+        lane_hints.append({
+            "kind": "latest_checkpoint",
+            "summary": _compact_text(checkpoint.get("summary") or "", 160),
+            "reference": checkpoint.get("reference"),
+        })
+    if summary_text:
+        lane_hints.append({"kind": "summary", "summary": _compact_text(summary_text, 180)})
+
+    next_steps = []
+    pending_actions = summary.get("pending_actions") if isinstance(summary.get("pending_actions"), list) else []
+    for item in pending_actions[:2]:
+        if not isinstance(item, dict):
+            continue
+        summary_text_value = str(item.get("summary") or "").strip()
+        if not summary_text_value:
+            continue
+        next_steps.append({
+            "kind": item.get("kind") or "pending_action",
+            "summary": _compact_text(summary_text_value, 140),
+            "reference": item.get("source_reference") or item.get("reference"),
+        })
+
+    avoid_drift = []
+    for item in linked_memories[:4]:
+        if not isinstance(item, dict):
+            continue
+        text = _compact_text(item.get("summary") or item.get("content") or "", 160)
+        lowered = text.lower()
+        if not text:
+            continue
+        if any(token in lowered for token in ("not ", "do not", "avoid", "instead of", "same-surface", "different mechanism", "don't assume")):
+            avoid_drift.append({
+                "reference": item.get("reference"),
+                "summary": text,
+            })
+
     return {
         "lane": lane,
         "query": query,
@@ -1005,6 +1075,9 @@ def _build_predictive_brief(
         ],
         "memories": items,
         "linked_memories": recent_linked,
+        "lane_hints": lane_hints[:3],
+        "next_steps": next_steps,
+        "avoid_drift": avoid_drift[:2],
         "latest_user_ask": _compact_text(latest_user_ask, 180),
         "summary_text": _compact_text(summary_text, 220),
         "mode": "predictive-brief",
@@ -1156,7 +1229,29 @@ def _read_transcript_snippet(path: Path, line_start: Optional[int], line_end: Op
     }
 
 
+def _search_transcripts_for_claim(query: str, radius: int, limit: int) -> list[Dict[str, Any]]:
+    needle = (query or "").strip().lower()
+    if not needle:
+        return []
+    hits: list[Dict[str, Any]] = []
+    for root in _allowed_transcript_roots():
+        if not root.exists() or not root.is_dir():
+            continue
+        for path in sorted(root.glob('*.log')):
+            try:
+                with path.open('r', encoding='utf-8', errors='ignore') as handle:
+                    for idx, line in enumerate(handle, start=1):
+                        if needle in line.lower():
+                            hits.append(_read_transcript_snippet(path, idx, idx, radius))
+                            if len(hits) >= limit:
+                                return hits
+            except OSError:
+                continue
+    return hits
+
+
 @app.get("/healthz")
+@app.get("/health")
 def healthz() -> dict[str, Any]:
     payload = _runtime_payload()
     payload["ok"] = True
@@ -1764,6 +1859,7 @@ def memory_get(request: GetRequest) -> dict[str, Any]:
 def memory_context(request: ContextRequest) -> dict[str, Any]:
     runtime = _runtime_payload()
     links = memory_links.get_memory_links(request.reference)
+    prov = provenance.hydrate_reference(request.reference, depth=2)
     transcript = None
     for link in links:
         target = link.get("target_reference", "")
@@ -1772,12 +1868,34 @@ def memory_context(request: ContextRequest) -> dict[str, Any]:
             path, line_start, line_end = parsed
             transcript = _read_transcript_snippet(path, line_start, line_end, request.radius)
             break
+    if transcript is None and isinstance(prov, dict):
+        anchor = prov.get("transcript_anchor") or {}
+        path_value = anchor.get("path")
+        if path_value:
+            transcript = _read_transcript_snippet(
+                Path(path_value),
+                anchor.get("start_line"),
+                anchor.get("end_line"),
+                request.radius,
+            )
     return {
         "ok": True,
         "reference": request.reference,
         "links": links,
         "transcript": transcript,
-        "provenance": provenance.hydrate_reference(request.reference, depth=2),
+        "provenance": prov,
+        **runtime,
+    }
+
+
+@app.post("/transcript/claim_search")
+def transcript_claim_search(request: TranscriptClaimSearchRequest) -> dict[str, Any]:
+    runtime = _runtime_payload()
+    hits = _search_transcripts_for_claim(request.query, request.radius, request.limit)
+    return {
+        "ok": True,
+        "query": request.query,
+        "results": hits,
         **runtime,
     }
 
@@ -1828,18 +1946,34 @@ def conversation_hydrate(request: ConversationHydrateRequest) -> dict[str, Any]:
             now_ms = time.time() * 1000.0
             if cached and (now_ms - cached[0]) <= cache_ttl_ms:
                 return {**cached[1], **runtime}
+    turn_counts = conversation_state.get_turn_counts(
+        conversation_id=request.conversation_id,
+        session_id=request.session_id,
+        thread_id=request.thread_id,
+    )
+    _mark("get_turn_counts")
+    requested_turns_limit = int(request.turns_limit)
+    effective_turns_limit = requested_turns_limit
+    long_session_mode = turn_counts.get("total", 0) >= _LONG_SESSION_TURN_THRESHOLD
+    if long_session_mode:
+        effective_turns_limit = min(effective_turns_limit, _LONG_SESSION_HYDRATE_TURNS)
     turns = conversation_state.get_recent_turns(
         conversation_id=request.conversation_id,
         session_id=request.session_id,
         thread_id=request.thread_id,
-        limit=request.turns_limit,
+        limit=effective_turns_limit,
     )
     _mark("get_recent_turns")
+    linked_memories_limit = request.memory_limit
+    if _parse_bool_env("OCMEMOG_HYDRATE_FAST_MODE", default=True):
+        linked_memories_limit = min(linked_memories_limit, 3)
+    if long_session_mode:
+        linked_memories_limit = min(linked_memories_limit, _LONG_SESSION_LINKED_MEMORY_LIMIT)
     linked_memories = conversation_state.get_linked_memories(
         conversation_id=request.conversation_id,
         session_id=request.session_id,
         thread_id=request.thread_id,
-        limit=request.memory_limit,
+        limit=linked_memories_limit,
     )
     _mark("get_linked_memories")
     link_targets: List[Dict[str, Any]] = []
@@ -1849,11 +1983,6 @@ def conversation_hydrate(request: ConversationHydrateRequest) -> dict[str, Any]:
         link_targets.extend(memory_links.get_memory_links_for_session(request.session_id))
     if request.conversation_id:
         link_targets.extend(memory_links.get_memory_links_for_conversation(request.conversation_id))
-    conversation_state._self_heal_legacy_continuity_artifacts(
-        conversation_id=request.conversation_id,
-        session_id=request.session_id,
-        thread_id=request.thread_id,
-    )
     latest_checkpoint = conversation_state.get_latest_checkpoint(
         conversation_id=request.conversation_id,
         session_id=request.session_id,
@@ -1896,13 +2025,29 @@ def conversation_hydrate(request: ConversationHydrateRequest) -> dict[str, Any]:
         runtime["warnings"] = [*runtime["warnings"], "hydrate returned persisted state while state refresh was delayed"]
     elif state_status == "derived_not_persisted":
         runtime["warnings"] = [*runtime["warnings"], "hydrate returned derived state without inline state refresh"]
-    predictive_brief = _build_predictive_brief(
-        request=request,
-        turns=turns,
-        summary=summary,
-        linked_memories=linked_memories,
-    )
+    predictive_brief: Dict[str, Any] = {
+        "query": "",
+        "items": [],
+        "lane": None,
+        "lane_hints": [],
+        "next_steps": [],
+        "avoid_drift": [],
+        "linked_memories": [],
+    }
+    predictive_brief_enabled = _parse_bool_env("OCMEMOG_HYDRATE_PREDICTIVE_BRIEF", default=False)
+    if predictive_brief_enabled:
+        predictive_brief = _build_predictive_brief(
+            request=request,
+            turns=turns,
+            summary=summary,
+            linked_memories=linked_memories,
+        )
     _mark("build_predictive_brief")
+    if long_session_mode:
+        runtime["warnings"] = [
+            *runtime["warnings"],
+            f"hydrate long-session guardrail active: total_turns={turn_counts.get('total', 0)} requested_turns_limit={requested_turns_limit} effective_turns_limit={effective_turns_limit}",
+        ]
     response = {
         "ok": True,
         "conversation_id": request.conversation_id,
@@ -1911,11 +2056,15 @@ def conversation_hydrate(request: ConversationHydrateRequest) -> dict[str, Any]:
         "recent_turns": turns,
         "summary": summary,
         "predictive_brief": predictive_brief,
-        "turn_counts": conversation_state.get_turn_counts(
-            conversation_id=request.conversation_id,
-            session_id=request.session_id,
-            thread_id=request.thread_id,
-        ),
+        "turn_counts": turn_counts,
+        "hydrate_budget": {
+            "requested_turns_limit": requested_turns_limit,
+            "effective_turns_limit": effective_turns_limit,
+            "requested_memory_limit": int(request.memory_limit),
+            "effective_memory_limit": linked_memories_limit,
+            "long_session_mode": long_session_mode,
+            "long_session_threshold": _LONG_SESSION_TURN_THRESHOLD,
+        },
         "linked_memories": linked_memories,
         "linked_references": link_targets,
         "checkpoint_graph": summary.get("checkpoint_graph"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simbimbo/memory-ocmemog",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Advanced OpenClaw memory plugin with durable recall, transcript-backed continuity, and sidecar APIs",
   "license": "MIT",
   "repository": {

package/scripts/ocmemog-continuity-benchmark.py

@@ -109,8 +109,22 @@ def run_scenario(scenario: Dict[str, Any]) -> Dict[str, Any]:
         expect = dict(scenario.get("expect") or {})
         latest_user_contains = str(expect.get("latest_user_contains") or "").strip()
         if latest_user_contains:
-            value = str((hydrate.get("state") or {}).get("latest_user_ask") or "")
-            recovered_value = str((recovered.get("state") or {}).get("latest_user_ask") or "")
+            hydrate_summary = hydrate.get("summary") or {}
+            recovered_summary = recovered.get("summary") or {}
+            hydrate_latest = (hydrate_summary.get("latest_user_intent") or {}) if isinstance(hydrate_summary.get("latest_user_intent"), dict) else {}
+            recovered_latest = (recovered_summary.get("latest_user_intent") or {}) if isinstance(recovered_summary.get("latest_user_intent"), dict) else {}
+            value = str(
+                hydrate_latest.get("literal", {}).get("content")
+                or hydrate_latest.get("literal", {}).get("effective_content")
+                or (hydrate.get("state") or {}).get("latest_user_ask")
+                or ""
+            )
+            recovered_value = str(
+                recovered_latest.get("literal", {}).get("content")
+                or recovered_latest.get("literal", {}).get("effective_content")
+                or (recovered.get("state") or {}).get("latest_user_ask")
+                or ""
+            )
             _run_check(checks, "hydrate.latest_user_contains", latest_user_contains in value, {"value": value, "expected": latest_user_contains})
             _run_check(checks, "restart.latest_user_contains", latest_user_contains in recovered_value, {"value": recovered_value, "expected": latest_user_contains})
 
@@ -121,10 +135,13 @@ def run_scenario(scenario: Dict[str, Any]) -> Dict[str, Any]:
             _run_check(checks, "hydrate.reply_chain_contains", all(item in reply_chain_ids for item in reply_chain_expected), {"value": reply_chain_ids, "expected": reply_chain_expected})
             _run_check(checks, "restart.reply_chain_contains", all(item in recovered_reply_chain_ids for item in reply_chain_expected), {"value": recovered_reply_chain_ids, "expected": reply_chain_expected})
 
+        branch_turn_ids = _message_id_list((hydrate.get("active_branch") or {}).get("turns") or [])
         excluded = list(expect.get("active_branch_turns_exclude") or [])
         if excluded:
-            branch_turn_ids = _message_id_list((hydrate.get("active_branch") or {}).get("turns") or [])
             _run_check(checks, "hydrate.active_branch_excludes", all(item not in branch_turn_ids for item in excluded), {"value": branch_turn_ids, "excluded": excluded})
+        included = list(expect.get("active_branch_turns_include") or [])
+        if included:
+            _run_check(checks, "hydrate.active_branch_includes", all(item in branch_turn_ids for item in included), {"value": branch_turn_ids, "included": included})
 
         top_ranked_turn_message_id = str(expect.get("top_ranked_turn_message_id") or "").strip()
         if top_ranked_turn_message_id and checkpoint_expand: