topos-node 1.3.28__tar.gz → 1.3.30__tar.gz

{topos_node-1.3.28/topos_node.egg-info → topos_node-1.3.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.28
+Version: 1.3.30
 Summary: Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://topos.dialogues.ai

{topos_node-1.3.28 → topos_node-1.3.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.28"
+version = "1.3.30"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"

{topos_node-1.3.28 → topos_node-1.3.30}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.28"
-__version_info__ = (1, 3, 28)
+__version__ = "1.3.30"
+__version_info__ = (1, 3, 30)
 
 __all__ = ["__version__", "__version_info__"]

topos_node-1.3.30/topos/api/community_naming_config.py

@@ -0,0 +1,52 @@
+"""Read/update the owner-selected community-naming model (engine_config).
+
+PLAN_COMMUNITY_NAMING S4: surfaced under Settings → Node functions. Default is
+the local extraction model — naming stays on-device unless the owner points it
+elsewhere. Empty PUT clears the override.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+
+from ..auth import require_api_key
+from ..core.state import get_db_connection, set_engine_config_value
+from ..features.entities.community_naming import (
+    ENGINE_CONFIG_KEY_NAMING_MODEL,
+    resolve_naming_model,
+)
+
+logger = logging.getLogger("topos.api.community_naming_config")
+
+router = APIRouter(tags=["community-naming"])
+
+
+def _payload(conn) -> dict[str, Any]:
+    from ..core.state import get_engine_config_value
+
+    override = get_engine_config_value(conn, ENGINE_CONFIG_KEY_NAMING_MODEL)
+    return {
+        "model": resolve_naming_model(conn),
+        "override": str(override).strip() if override else None,
+    }
+
+
+@router.get("/v1/community-naming-config", dependencies=[Depends(require_api_key)])
+async def get_community_naming_config() -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    return {"status": "ok", **_payload(conn)}
+
+
+@router.put("/v1/community-naming-config", dependencies=[Depends(require_api_key)])
+async def put_community_naming_config(body: dict[str, Any] = Body(default=None)) -> dict[str, Any]:
+    conn = get_db_connection()
+    if not conn:
+        raise HTTPException(status_code=503, detail="Database not available")
+    model = str((body or {}).get("model") or "").strip()
+    set_engine_config_value(conn, ENGINE_CONFIG_KEY_NAMING_MODEL, model or None)
+    return {"status": "ok", **_payload(conn)}

{topos_node-1.3.28 → topos_node-1.3.30}/topos/api/signal.py

@@ -1103,3 +1103,106 @@ async def post_pack_offer_resolution(
     if not out:
         raise HTTPException(status_code=404, detail=f"unknown offer {offer_id}")
     return out
+
+
+@router.post("/derivation/packs/{pack_id}/backfill")
+async def post_pack_backfill(
+    pack_id: str,
+    limit: int = Body(200, embed=True, ge=1, le=1000),
+    _api_key: str = Depends(require_api_key),
+):
+    """Bounded owner-initiated history backfill (lens catalog control)."""
+    import asyncio as _asyncio
+
+    from ..features.derivation.surfaces import run_pack_backfill
+
+    try:
+        stats = await _asyncio.to_thread(run_pack_backfill, _entities_conn(), pack_id, limit)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    return {"pack_id": pack_id, **stats}
+
+
+@router.put("/entities/communities/{community_id}/name")
+async def put_community_name_route(
+    community_id: int,
+    name: str = Body(..., embed=True),
+    _api_key: str = Depends(require_api_key),
+):
+    """Owner rename for a graph community (stable-naming S3)."""
+    from ..features.entities.community_names import core_fingerprint, rename_community
+    from ..features.entities.community_naming import valid_label
+
+    if not valid_label(name):
+        raise HTTPException(status_code=400, detail="a short name (2-4 words, letters) required")
+    conn = _entities_conn()
+    rows = conn.execute(
+        "SELECT entity_id, json_extract(metadata_json,'$.centrality.eigen')"
+        " FROM entities WHERE json_extract(metadata_json,'$.community_id')=?",
+        (community_id,),
+    ).fetchall()
+    if not rows:
+        raise HTTPException(status_code=404, detail=f"unknown community {community_id}")
+    ranked = [x[0] for x in sorted(rows, key=lambda x: -(x[1] or 0.0))]
+    weights = {x[0]: float(x[1] or 0.0) for x in rows}
+    from ..storage.db.write_gate import commit_connection, with_db_write
+    with with_db_write():
+        rename_community(conn, core_fingerprint(ranked, weights), name)
+        conn.execute(
+            "UPDATE entities SET metadata_json=json_patch(COALESCE(metadata_json,'{}'),"
+            " json_object('community_label', ?))"
+            " WHERE json_extract(metadata_json,'$.community_id')=?",
+            (name, community_id),
+        )
+        commit_connection(conn)
+    return {"community_id": community_id, "name": name, "members": len(rows)}
+
+
+@router.get("/derivation/schema")
+async def get_derivation_schema(_api_key: str = Depends(require_api_key)):
+    """Per-predicate field schemas for the Fact Editor (W4.6)."""
+    from ..features.derivation.surfaces import predicate_schemas
+
+    return {"predicates": predicate_schemas(_entities_conn())}
+
+
+@router.post("/facts/conflicts/promote")
+async def post_conflict_promotion(
+    conflict_id: str = Body(...),
+    subject_entity_id: str = Body(""),
+    new_person_name: str = Body(""),
+    to_owner: bool = Body(False),
+    value: Any = Body(None),
+    _api_key: str = Depends(require_api_key),
+):
+    """Edit & add a quarantined extraction: the owner supplies the identity the
+    machine refused to guess; ledgered as gold (W4.6)."""
+    from ..features.derivation.surfaces import promote_conflict
+
+    try:
+        return promote_conflict(_entities_conn(), conflict_id,
+                                subject_entity_id=subject_entity_id,
+                                new_person_name=new_person_name,
+                                value=value, to_owner=to_owner)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+
+
+@router.post("/facts/{object_id}/revise")
+async def post_fact_revision(
+    object_id: str,
+    value: Any = Body(None),
+    subject_entity_id: str = Body(""),
+    evidence_date: str = Body(""),
+    asserted_by: str = Body(""),
+    _api_key: str = Depends(require_api_key),
+):
+    """Owner revision of a live pack fact: field/subject/date, never its kind (W4.6)."""
+    from ..features.derivation.surfaces import revise_fact
+
+    try:
+        return revise_fact(_entities_conn(), object_id, value=value,
+                           subject_entity_id=subject_entity_id,
+                           evidence_date=evidence_date, asserted_by=asserted_by)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc

{topos_node-1.3.28 → topos_node-1.3.30}/topos/app.py

@@ -42,6 +42,7 @@ from .api import (
     data_explorer_table_prefs as data_explorer_table_prefs_routes,
     sanitization_ollama_config as sanitization_ollama_config_routes,
     facts_llm_config as facts_llm_config_routes,
+    community_naming_config as community_naming_config_routes,
     signal_extraction_config as signal_extraction_config_routes,
     filter_lab as filter_lab_routes,
     enrichment_lab as enrichment_lab_routes,
@@ -144,6 +145,7 @@ app.include_router(data_explorer_table_prefs_routes.router)
 app.include_router(user_identity_routes.router)
 app.include_router(sanitization_ollama_config_routes.router)
 app.include_router(facts_llm_config_routes.router)
+app.include_router(community_naming_config_routes.router)
 app.include_router(signal_extraction_config_routes.router)
 app.include_router(filter_lab_routes.router)
 app.include_router(enrichment_lab_routes.router)

{topos_node-1.3.28 → topos_node-1.3.30}/topos/config/model_packs.py

@@ -271,7 +271,12 @@ def _as_binding(raw: Any) -> Optional[Dict[str, str]]:
 def _local_model_present(binding: Mapping[str, str], installed_local_models: Optional[Any]) -> bool:
     if installed_local_models is None:
         return True
-    if str(binding.get("provider") or "").strip().lower() not in LOCAL_PROVIDERS:
+    provider = str(binding.get("provider") or "").strip().lower()
+    # Horos is local but not an Ollama tag; `default` must not look like a
+    # missing download. Mirrors control_plane.model_pack_resolution.
+    if provider == SCOPE_HEAD_PROVIDER:
+        return True
+    if provider not in LOCAL_PROVIDERS:
         return True
     installed = {str(name or "").strip().lower() for name in installed_local_models}
     wanted = str(binding.get("model") or "").strip().lower()

{topos_node-1.3.28 → topos_node-1.3.30}/topos/core/handlers/derivation.py

@@ -97,3 +97,80 @@ async def handle_put_pack_offer(message):
         return {"id": req_id, "status": "error", "error": str(exc)}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("run_pack_backfill")
+async def handle_run_pack_backfill(message):
+    """Owner-initiated bounded history backfill for one enabled pack (W-B #4).
+    Runs in a worker thread; bounded by `limit` hit-records per call."""
+    import asyncio as _asyncio
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    pack_id = str(payload.get("pack_id") or "").strip()
+    limit = min(int(payload.get("limit") or 200), 1000)
+    try:
+        from ...features.derivation.surfaces import run_pack_backfill
+        stats = await _asyncio.to_thread(run_pack_backfill, conn, pack_id, limit)
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", "pack_id": pack_id, **stats}}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc)}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("get_derivation_schema")
+async def handle_get_derivation_schema(message):
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    try:
+        from ...features.derivation.surfaces import predicate_schemas
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "predicates": predicate_schemas(conn)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("promote_fact_conflict")
+async def handle_promote_fact_conflict(message):
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    p = message.get("payload") or {}
+    try:
+        from ...features.derivation.surfaces import promote_conflict
+        out = promote_conflict(conn, str(p.get("conflict_id") or ""),
+                               subject_entity_id=str(p.get("subject_entity_id") or ""),
+                               new_person_name=str(p.get("new_person_name") or ""),
+                               value=p.get("value"), to_owner=bool(p.get("to_owner")))
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", **out}}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc)}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("revise_pack_fact")
+async def handle_revise_pack_fact(message):
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    p = message.get("payload") or {}
+    try:
+        from ...features.derivation.surfaces import revise_fact
+        out = revise_fact(conn, str(p.get("object_id") or ""),
+                          value=p.get("value"),
+                          subject_entity_id=str(p.get("subject_entity_id") or ""),
+                          evidence_date=str(p.get("evidence_date") or ""),
+                          asserted_by=str(p.get("asserted_by") or ""))
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", **out}}
+    except ValueError as exc:
+        return {"id": req_id, "status": "error", "error": str(exc)}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-1.3.28 → topos_node-1.3.30}/topos/core/handlers/signal_features.py

@@ -1192,3 +1192,49 @@ async def handle_signal_retire_intent(message: Dict[str, Any]) -> Optional[Dict[
         return {"id": req_id, "status": "ok", "payload": {"intents": active_intents(conn)}}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_community_name")
+async def handle_put_community_name(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Owner rename for a graph community (PLAN_COMMUNITY_NAMING S3): retires
+    any derived name for the community's core and records the owner's, which
+    wins ties forever after. Stamps the label onto members immediately."""
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    community_id = payload.get("community_id")
+    new_name = str(payload.get("name") or "").strip()
+    try:
+        from ...features.entities.community_names import core_fingerprint, rename_community
+        from ...features.entities.community_naming import valid_label
+
+        if not isinstance(community_id, int) or not valid_label(new_name):
+            return {"id": req_id, "status": "error",
+                    "error": "community_id (int) and a short name (2-4 words, letters) required"}
+        conn = hub.get_db_connection()
+        rows = conn.execute(
+            "SELECT entity_id, json_extract(metadata_json,'$.centrality.eigen')"
+            " FROM entities WHERE json_extract(metadata_json,'$.community_id')=?",
+            (community_id,),
+        ).fetchall()
+        if not rows:
+            return {"id": req_id, "status": "error", "error": f"unknown community {community_id}"}
+        ranked = [r[0] for r in sorted(rows, key=lambda r: -(r[1] or 0.0))]
+        weights = {r[0]: float(r[1] or 0.0) for r in rows}
+        fp = core_fingerprint(ranked, weights)
+        from ...storage.db.write_gate import commit_connection, with_db_write
+        with with_db_write():
+            rename_community(conn, fp, new_name)
+            conn.execute(
+                "UPDATE entities SET metadata_json=json_patch(COALESCE(metadata_json,'{}'),"
+                " json_object('community_label', ?))"
+                " WHERE json_extract(metadata_json,'$.community_id')=?",
+                (new_name, community_id),
+            )
+            commit_connection(conn)
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "community_id": community_id, "name": new_name,
+                            "members": len(rows)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-1.3.28 → topos_node-1.3.30}/topos/enrichment/jobs/canonical/derivation_job.py

@@ -161,6 +161,8 @@ def run_derivation_batch(
                                 temperature=0.0, num_ctx=8192, timeout=180)
         return str(out.get("text") or "") if isinstance(out, dict) else str(out or "")
 
+    from ....features.derivation.router import router_mode
+    _router_hybrid = router_mode() == "hybrid"
     verify_mode = _verify_mode()
     if verify_mode == "required" and packs:
         try:
@@ -176,19 +178,42 @@ def run_derivation_batch(
     writer = DerivationWriter(conn, model=model)
     done = {r[0] for r in conn.execute("SELECT key FROM derivation_progress")}
 
+    HARM_ROLES = {"partner", "spouse", "child", "sibling", "ex_partner"}
+    HARM_EVENTS = {"loss", "conflict", "reconnected", "ended", "estranged"}
+
+    def _is_high_harm(a):
+        v = a.get("value") if isinstance(a.get("value"), dict) else {}
+        if a.get("predicate") == "rel.relationship" and str(v.get("role")) in HARM_ROLES:
+            return True
+        if a.get("predicate") == "rel.relationship_event" and str(v.get("event")) in HARM_EVENTS:
+            return True
+        return False
+
     def judge(pack, rec, a, stage):
-        """Verify one assertion; ledger it; return the annotated assertion."""
+        """Verify one assertion; high-harm predicate classes get 3-vote majority
+        (measured 2026-08-26: single quantized-verifier votes are variance-exposed
+        exactly where errors hurt most). Everything else keeps one vote."""
         if verify_mode == "off":
             a = dict(a); a["verifier_status"] = "skipped"
-        else:
+            return a
+        votes_needed = 3 if _is_high_harm(a) else 1
+        accepts = 0
+        last_verdict = None
+        for _ in range(votes_needed):
             try:
                 verdict = parse_verdict(llm(vmodel, build_verify_prompt(
                     rec["text"], rec["role"], rec["date"],
                     a["predicate"], a["value"], a.get("about", "owner")), n=250))
             except Exception:  # noqa: BLE001
                 verdict = None
-            a = apply_verdict(a, verdict)
-        return a
+            last_verdict = verdict or last_verdict
+            if verdict and verdict["supported"] and verdict["fields_ok"]:
+                accepts += 1
+        if votes_needed > 1 and accepts < 2:
+            a = dict(a); a["verifier_status"] = "rejected"
+            a["verifier_reason"] = f"majority {accepts}/{votes_needed} against"
+            return a
+        return apply_verdict(a, last_verdict)
 
     written = 0
     for row in rows:
@@ -198,8 +223,15 @@ def run_derivation_batch(
         rec = _row_to_record(row)
         if rec is None:
             continue
+        _rec_vec = None
+        if _router_hybrid:
+            from ....features.derivation.router import embed_record
+            _rec_vec = embed_record(rec["text"])
         for pid, pack in all_packs.items():
             hit = rec["role"] in pack.allowed_roles() and filters[pid].passes(rec["text"])
+            if not hit and _router_hybrid and rec["role"] in pack.allowed_roles():
+                from ....features.derivation.router import semantic_passes
+                hit = semantic_passes(pack, _rec_vec)
             if hit:
                 _bump_yield(conn, pid, prefilter_hits=1)
             if pid not in packs:
@@ -247,6 +279,9 @@ def run_derivation_batch(
             conn.execute("INSERT OR REPLACE INTO derivation_progress (key) VALUES (?)", (key,))
         conn.commit()
 
+    _drip_catchup(conn, packs=packs, filters=filters, llm=llm, judge=judge,
+                  writer=writer, owner=owner, done=done, st=st, cancel=cancel)
+
     _self_gate(conn, all_packs=all_packs, enabled=set(packs), filters=filters,
                llm=llm, judge=judge, model=model, vmodel=vmodel, st=st,
                cancel=cancel)
@@ -259,6 +294,94 @@ def run_derivation_batch(
     return written
 
 
+#: history records drip-processed per batch — the dark delta self-heals without
+#: a scheduler; a fresh enablement's history closes over days, or immediately
+#: via the owner's backfill control.
+CATCHUP_PER_BATCH = 25
+
+
+def _iter_history(conn, limit=2000):
+    import sqlite3 as _sqlite3
+    def _rows(sql):
+        try:
+            return conn.execute(sql).fetchall()
+        except _sqlite3.OperationalError:
+            return []
+    out = []
+    for tbl, rid, text, at, role in _rows(
+            f"SELECT 'journal_entries', entry_id, content, entry_at, 'authored'"
+            f" FROM journal_entries WHERE content IS NOT NULL AND LENGTH(content)>15"
+            f" ORDER BY entry_at DESC LIMIT {int(limit)}"):
+        out.append({"table": tbl, "record_id": rid, "text": (text or "")[:6000],
+                    "date": str(at or "")[:10], "role": role or "authored", "source_id": ""})
+    for tbl, rid, text, at, role in _rows(
+            f"SELECT 'conversation_messages', message_id, content, event_at, actor_role"
+            f" FROM conversation_messages WHERE content IS NOT NULL AND LENGTH(content)>15"
+            f" ORDER BY event_at DESC LIMIT {int(limit)}"):
+        out.append({"table": tbl, "record_id": rid, "text": (text or "")[:6000],
+                    "date": str(at or "")[:10], "role": role or "observed", "source_id": ""})
+    return out
+
+
+def _drip_catchup(conn, *, packs, filters, llm, judge, writer, owner, done, st, cancel):
+    """Process up to CATCHUP_PER_BATCH unprocessed HISTORY (record, pack) pairs
+    per batch. Newest-first: recent history answers queries soonest."""
+    if not packs:
+        return
+    from ....features.derivation.template import build_prompt, parse_output
+    from ....features.facts.llm_extract import _resolved_extraction_model
+    from ....config.settings import settings as _settings
+    model = _resolved_extraction_model(_settings, conn)
+    budget = CATCHUP_PER_BATCH
+    for rec in _iter_history(conn):
+        if budget <= 0 or (cancel is not None and cancel.is_set()):
+            return
+        for pid, pack in packs.items():
+            key = f"{pid}@{pack.version}:{rec['table']}:{rec['record_id']}"
+            if key in done:
+                continue
+            if rec["role"] not in pack.allowed_roles() or not filters[pid].passes(rec["text"]):
+                conn.execute("INSERT OR REPLACE INTO derivation_progress (key) VALUES (?)", (key,))
+                done.add(key)
+                continue
+            budget -= 1
+            try:
+                raw = llm(model, build_prompt(pack, rec["text"], rec["date"], rec["role"]))
+                _bump_yield(conn, pid, llm_calls=1, prefilter_hits=1)
+            except Exception:  # noqa: BLE001
+                st["llm_errors"] = st.get("llm_errors", 0) + 1
+                continue
+            valid, _rej = parse_output(raw, pack, record_text=rec["text"])
+            _bump_yield(conn, pid, assertions=len(valid))
+            for a in valid:
+                a = judge(pack, rec, a, "catchup")
+                if a.get("verifier_status") == "rejected":
+                    _ledger_write(conn, stage="catchup", pack=pack, rec=rec, a=a,
+                                  model=model, vmodel="(job)", )
+                    continue
+                _bump_yield(conn, pid, accepted=1)
+                out = writer.assert_pack_fact(
+                    pack=pack, predicate=a["predicate"], subject_entity_id=owner,
+                    value=a["value"], actor_role=rec["role"],
+                    source_refs=[{"table": rec["table"], "record_id": rec["record_id"]}],
+                    confidence=a["confidence"], occurrence=a["occurrence"],
+                    quote=a.get("quote", ""), about=a.get("about", "owner"),
+                    event_date=rec["date"] or None)
+                stored = out.get("outcome") in ("written", "corroborated", "retelling_merged",
+                                                "field_update", "corrected", "superseded")
+                if stored:
+                    _bump_yield(conn, pid, written=1)
+                    st["catchup_written"] = st.get("catchup_written", 0) + 1
+                _ledger_write(conn, stage="catchup", pack=pack, rec=rec, a=a,
+                              model=model, vmodel="(job)",
+                              written_id=out.get("object_id") if stored else None)
+            conn.execute("INSERT OR REPLACE INTO derivation_progress (key) VALUES (?)", (key,))
+            done.add(key)
+            if budget <= 0:
+                break
+        conn.commit()
+
+
 def _self_gate(conn, *, all_packs, enabled, filters, llm, judge, model, vmodel, st, cancel):
     """Per-node self-gating (owner design, 2026-08-26): the node OFFERS, never
     switches. Enable offers come from a capped shadow trial on a disabled pack

{topos_node-1.3.28 → topos_node-1.3.30}/topos/features/derivation/bundled_packs/relationships.social.yaml

@@ -4,7 +4,7 @@
 # KG NOTE: this pack's relationship predicate adds ROLE-TYPED edges between person
 # entities — the single biggest graph upgrade in the catalog (today: communicates_with only).
 pack: relationships.social
-version: 0.2.3
+version: 0.2.5
 status: draft
 title: "Relationships"
 author: topos
@@ -68,7 +68,10 @@ guidance:
     - "Entity resolution first: an unresolvable 'Alex' gets a mention, not a relationship fact."
     - "Others' relationships to each other belong in their dossiers, not in rel.* (which is owner-centric)."
 
-revision:   # Tier-2 declarative rules (§1.6) — added for the shadow pilot (v0.2.1)
+revision:   # Tier-2 declarative rules
+  exclusive_with:      # Tier-2 completion (v0.2.5): contradictions queue, never auto-supersede
+    rel.relationship: [[partner, ex_partner], [spouse, ex_partner]]
+    _field: {rel.relationship: role}
   supersedes_on: {rel.relationship: [status, role]}     # role/status transitions keep history (friend->close_friend is a revision)
   noop_when: "re-statement within 7d at equal confidence"
 

topos_node-1.3.30/topos/features/derivation/report_card.py

@@ -0,0 +1,60 @@
+"""WA.E derivation report card as CODE (protects: attribution of person-facts
+to the correct subject; junk gates; gold retention — PLAN_DERIVATION_WAVE2 §WA.E).
+
+Three scores per pack over a window, computed from the training ledger + owner
+verdicts. Any one alone is gameable; together they describe the pipeline:
+
+  acceptance   — verifier-accepted / judged (the pipeline's own precision proxy)
+  owner_upheld — 1 - (owner-rejected stored facts / stored facts owner reviewed)
+                 (the human-gold correction rate; verified_by_owner counts as upheld)
+  reroute_rate — rerouted / judged (attribution catches — visibility, not a gate)
+
+The full junk/attribution/retention batteries remain offline instruments run
+against graded corpora; this card is the LIVE, always-on shadow of them.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from typing import Any, Dict
+
+
+def compute_report_card(conn: sqlite3.Connection, days: int = 30) -> Dict[str, Any]:
+    out: Dict[str, Any] = {"window_days": days, "packs": {}}
+    try:
+        rows = conn.execute(
+            "SELECT pack_id, vstatus, COUNT(*) FROM derivation_training_ledger"
+            " WHERE ts >= datetime('now', ?) GROUP BY pack_id, vstatus",
+            (f"-{int(days)} day",)).fetchall()
+    except sqlite3.OperationalError:
+        return out
+    per: Dict[str, Dict[str, int]] = {}
+    for pack_id, vstatus, n in rows:
+        per.setdefault(pack_id, {})[str(vstatus)] = int(n)
+    for pack_id, counts in per.items():
+        judged = sum(counts.values())
+        accepted = counts.get("accepted", 0) + counts.get("rerouted", 0)
+        card = {
+            "judged": judged,
+            "acceptance": round(accepted / judged, 3) if judged else None,
+            "reroute_rate": round(counts.get("rerouted", 0) / judged, 3) if judged else None,
+            "rejected": counts.get("rejected", 0) + counts.get("rejected_majority", 0),
+            "grounding_rejects": counts.get("grounding_reject", 0),
+        }
+        out["packs"][pack_id] = card
+    # owner verdicts over stored pack facts (gold)
+    try:
+        for pack_id, upheld, rejected in conn.execute(
+            """SELECT ontology_id,
+                      SUM(CASE WHEN json_extract(payload_json,'$.verified_by_owner')=1 THEN 1 ELSE 0 END),
+                      SUM(CASE WHEN json_extract(payload_json,'$.excluded_by_owner')=1
+                               OR (valid_to IS NOT NULL AND updated_by LIKE '%reject%') THEN 1 ELSE 0 END)
+               FROM signal_objects WHERE object_type='fact' AND ontology_id IS NOT NULL
+               GROUP BY ontology_id"""):
+            card = out["packs"].setdefault(pack_id, {})
+            reviewed = int(upheld or 0) + int(rejected or 0)
+            card["owner_reviewed"] = reviewed
+            card["owner_upheld"] = round(int(upheld or 0) / reviewed, 3) if reviewed else None
+    except sqlite3.OperationalError:
+        pass
+    return out