@simbimbo/memory-ocmemog 0.1.19 → 0.1.20

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## Unreleased
 
+## 0.1.20 — 2026-03-29
+
+Operational-artifact canonicalization, dead-lane retrieval hardening, and rehydratable-memory recall fixes.
+
+### Highlights
+- added first-class operational artifact canonicalization with idempotent upsert semantics for durable canonical memories keyed by artifact identity
+- added a sidecar API route to canonicalize operational artifacts explicitly, including aliases, ownership, status, kind, and provenance/source references
+- taught retrieval to recognize operational-artifact / dead-lane queries and strongly reward exact operational literals such as cron/job names and CLI module tokens
+- reduced transcript/reflection noise for operational-artifact queries so canonical memories win over repeated run logs and scattered debug fragments
+- added transcript claim-search as a bounded fallback surface for exact prior-claim recovery, alongside larger `/memory/context` transcript windows with provenance-anchor fallback
+- added focused regression coverage for operational artifact canonicalization, claim-search/memory-context rehydration, and canonical top-answer retrieval behavior
+- validated the architecture fix with a targeted release gate: `30 passed`
+
 ## 0.1.19 — 2026-03-29
 
 Hydrate/resume hardening, unresolved-state main-DB consolidation, and retrieval/rehydration source-of-truth completion.

package/ocmemog/runtime/memory/api.py

@@ -789,6 +789,87 @@ def find_contradiction_candidates(
     return top
 
 
+def canonicalize_operational_artifact(
+    *,
+    key: str,
+    summary: str,
+    aliases: Optional[List[str]] = None,
+    status: str = "active",
+    owner: Optional[str] = None,
+    artifact_kind: Optional[str] = None,
+    source_references: Optional[List[str]] = None,
+    source_labels: Optional[List[str]] = None,
+) -> Dict[str, Any]:
+    normalized_key = str(key or "").strip().lower()
+    if not normalized_key:
+        return {"ok": False, "error": "missing_key"}
+
+    aliases = [str(item).strip() for item in (aliases or []) if str(item).strip()]
+    source_references = [str(item).strip() for item in (source_references or []) if str(item).strip()]
+    source_labels = [str(item).strip() for item in (source_labels or []) if str(item).strip()]
+
+    conn = store.connect()
+    existing_reference: Optional[str] = None
+    existing_row: Optional[Dict[str, Any]] = None
+    try:
+        rows = conn.execute(
+            "SELECT id, content, metadata_json FROM knowledge ORDER BY id DESC LIMIT 500"
+        ).fetchall()
+        for row in rows:
+            memory_id = int(row["id"] if isinstance(row, dict) else row[0])
+            content = str(row["content"] if isinstance(row, dict) else row[1] or "")
+            raw_metadata = row["metadata_json"] if isinstance(row, dict) else row[2]
+            metadata = json.loads(raw_metadata or "{}")
+            prov = metadata.get("provenance") if isinstance(metadata.get("provenance"), dict) else {}
+            artifact_key = str(prov.get("artifact_key") or metadata.get("artifact_key") or "").strip().lower()
+            haystack = f"{content}\n{json.dumps(metadata, ensure_ascii=False)}".lower()
+            if artifact_key == normalized_key or normalized_key in haystack:
+                existing_reference = f"knowledge:{memory_id}"
+                existing_row = {"content": content, "metadata": metadata}
+                break
+    finally:
+        conn.close()
+
+    metadata = provenance.normalize_metadata({
+        "artifact_key": normalized_key,
+        "artifact_aliases": aliases,
+        "artifact_kind": artifact_kind or "operational_artifact",
+        "owner": owner or "openclaw",
+        "memory_status": status,
+        "canonical": True,
+        "source_references": source_references,
+        "source_labels": list(dict.fromkeys(source_labels + ["canonical-operational-artifact"])),
+        "derived_via": "operational_artifact_canonicalize",
+    }, source="operational_artifact")
+
+    if existing_reference:
+        provenance.force_update_memory_metadata(existing_reference, metadata)
+        parsed = _parse_memory_reference(existing_reference)
+        if parsed:
+            table, identifier = parsed
+            conn = store.connect()
+            try:
+                conn.execute(
+                    f"UPDATE {table} SET content=?, metadata_json=? WHERE id=?",
+                    (summary, json.dumps(provenance.normalize_metadata({**metadata, **(existing_row.get('metadata') if existing_row else {})}, source='operational_artifact'), ensure_ascii=False), int(identifier)),
+                )
+                conn.commit()
+            finally:
+                conn.close()
+        return {"ok": True, "reference": existing_reference, "created": False}
+
+    memory_id = store_memory(
+        "knowledge",
+        summary,
+        source="operational_artifact",
+        metadata=metadata,
+        post_process=True,
+    )
+    reference = f"knowledge:{memory_id}"
+    provenance.force_update_memory_metadata(reference, {"canonical_reference": reference, "memory_status": status, "artifact_key": normalized_key})
+    return {"ok": True, "reference": reference, "created": True}
+
+
 def mark_memory_relationship(
     reference: str,
     *,

package/ocmemog/runtime/memory/retrieval.py

@@ -98,6 +98,35 @@ def _recency_score(timestamp: str | None) -> float:
     return 0.0
 
 
+def _operational_literal_bonus(prompt: str, metadata: Dict[str, Any], content: str) -> float:
+    lowered_prompt = str(prompt or '').lower()
+    lowered_text = f"{metadata} {content}".lower()
+    bonus = 0.0
+    strong_literals = [
+        token for token in (
+            'provider-monitor',
+            'provider monitor',
+            'brain.cli provider-monitor',
+            'cron job',
+            'auto-assign',
+            'lan discovery',
+            'auto discovery',
+            'autodiscovery',
+        )
+        if token in lowered_prompt and token in lowered_text
+    ]
+    if strong_literals:
+        bonus += 0.45
+    query_literals = [token for token in _tokenize(lowered_prompt) if len(token) >= 6]
+    matching_literals = [token for token in query_literals if token in lowered_text]
+    if matching_literals:
+        bonus += min(0.28, 0.07 * len(set(matching_literals)))
+    if any(marker in lowered_prompt for marker in ('dead lane', 'stale automation', 'why does this exist', 'what is this old job')):
+        if any(marker in lowered_text for marker in ('provider-monitor', 'cron', 'disabled', 'stale', 'dead lane', 'auto-assign', 'lan discovery')):
+            bonus += 0.22
+    return round(min(0.75, bonus), 3)
+
+
 MEMORY_BUCKETS: Tuple[str, ...] = tuple(store.MEMORY_TABLES)
 
 _PROCEDURAL_QUERY_MARKERS: Tuple[str, ...] = (
@@ -194,6 +223,14 @@ def _source_authority_bonus(bucket: str, metadata: Dict[str, Any], content: str,
         if is_policy_doc or is_audit_doc:
             bonus -= 0.18
 
+    if qtype == "operational_artifact":
+        if bucket == "reflections" and is_transcript:
+            bonus -= 0.38
+        if bucket in {"knowledge", "directives"} and (is_canonical_file or "canonical" in text or "deprecated" in text or "disabled" in text):
+            bonus += 0.36
+        if is_policy_doc or is_audit_doc:
+            bonus -= 0.12
+
     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
@@ -209,6 +246,8 @@ def _doc_type(metadata: Dict[str, Any], bucket: str, content: str) -> str:
     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 any(marker in text for marker in ("provider-monitor", "provider monitor", "auto-assign", "lan discovery", "auto discovery", "autodiscovery", "cron job", "brain.cli provider-monitor")):
+        return "operational_artifact"
     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:
@@ -299,6 +338,8 @@ def _query_type(prompt: str) -> str:
     lowered = str(prompt or "").strip().lower()
     if not lowered:
         return "generic"
+    if any(marker in lowered for marker in ("provider-monitor", "provider monitor", "dead lane", "stale automation", "old cron", "cron job", "auto-discovery", "autodiscovery", "lan discovery", "auto-assign", "what is this old job", "why does this exist")):
+        return "operational_artifact"
     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:
@@ -320,7 +361,7 @@ def _doc_type_bonus(prompt: str, metadata: Dict[str, Any], bucket: str, content:
     if qtype == "generic":
         return 0.0
     if qtype == dtype:
-        return 0.35
+        return 0.35 if qtype != "operational_artifact" else 0.55
     compatible = {
         ("runbook", "authority_map"): -0.16,
         ("runbook", "policy"): -0.28,
@@ -332,6 +373,9 @@ def _doc_type_bonus(prompt: str, metadata: Dict[str, Any], bucket: str, content:
         ("authority_map", "audit"): -0.10,
         ("continuity", "audit"): -0.08,
         ("user_preference", "policy"): -0.06,
+        ("operational_artifact", "policy"): -0.22,
+        ("operational_artifact", "audit"): -0.18,
+        ("operational_artifact", "authority_map"): -0.10,
     }
     if (qtype, dtype) in compatible:
         return compatible[(qtype, dtype)]
@@ -636,9 +680,10 @@ def retrieve(
         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)
+        operational_literal_bonus = _operational_literal_bonus(prompt, metadata_payload, 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)
+        score = round((keyword * 0.45) + (semantic * 0.35) + reinf_score + promo_score + recency + lane_bonus + intent_bonus + authority_bonus + doc_type_bonus + operational_literal_bonus + family_penalty + derivative_penalty, 3)
         return score, {
             "keyword": round(keyword, 3),
             "semantic": round(semantic, 3),
@@ -653,6 +698,7 @@ def retrieve(
             "intent_bonus": round(intent_bonus, 3),
             "authority_bonus": round(authority_bonus, 3),
             "doc_type_bonus": round(doc_type_bonus, 3),
+            "operational_literal_bonus": round(operational_literal_bonus, 3),
             "family_penalty": round(family_penalty, 3),
             "derivative_penalty": round(derivative_penalty, 3),
         }

package/ocmemog/sidecar/app.py

@@ -693,6 +693,17 @@ class TranscriptClaimSearchRequest(BaseModel):
     limit: int = Field(default=5, ge=1, le=20)
 
 
+class OperationalArtifactCanonicalizeRequest(BaseModel):
+    key: str
+    summary: str
+    aliases: List[str] = Field(default_factory=list)
+    status: str = "active"
+    owner: Optional[str] = None
+    artifact_kind: Optional[str] = None
+    source_references: List[str] = Field(default_factory=list)
+    source_labels: List[str] = Field(default_factory=list)
+
+
 class RecentRequest(BaseModel):
     categories: Optional[List[str]] = Field(default=None, description="Filter by memory categories")
     limit: int = Field(default=12, ge=1, le=100, description="Maximum items per category")
@@ -1900,6 +1911,25 @@ def transcript_claim_search(request: TranscriptClaimSearchRequest) -> dict[str,
     }
 
 
+@app.post("/memory/canonicalize_operational_artifact")
+def canonicalize_operational_artifact(request: OperationalArtifactCanonicalizeRequest) -> dict[str, Any]:
+    runtime = _runtime_payload()
+    result = api.canonicalize_operational_artifact(
+        key=request.key,
+        summary=request.summary,
+        aliases=request.aliases,
+        status=request.status,
+        owner=request.owner,
+        artifact_kind=request.artifact_kind,
+        source_references=request.source_references,
+        source_labels=request.source_labels,
+    )
+    return {
+        **result,
+        **runtime,
+    }
+
+
 @app.post("/memory/recent")
 def memory_recent(request: RecentRequest) -> dict[str, Any]:
     runtime = _runtime_payload()

package/package.json

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