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

{topos_node-1.3.29/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.29
+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.29 → topos_node-1.3.30}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.29"
+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.29 → topos_node-1.3.30}/topos/__version__.py

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

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

@@ -1156,3 +1156,53 @@ async def put_community_name_route(
         )
         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.29 → 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.29 → topos_node-1.3.30}/topos/core/handlers/derivation.py

@@ -119,3 +119,58 @@ async def handle_run_pack_backfill(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("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.29 → topos_node-1.3.30}/topos/features/derivation/surfaces.py

@@ -70,11 +70,16 @@ def set_pack_enabled(conn: sqlite3.Connection, pack_id: str, enabled: bool) -> b
 
 def list_conflicts(conn: sqlite3.Connection, limit: int = 100) -> List[Dict[str, Any]]:
     rows: List[Dict[str, Any]] = []
-    for cid, subj, pred, incumbent, value, conf, status, created in conn.execute(
+    cols = {r[1] for r in conn.execute("PRAGMA table_info(fact_conflicts)")}
+    has_prov = "pack_id" in cols
+    extra = ", pack_id, source_refs_json, quote, about_hint" if has_prov else ""
+    for row in conn.execute(
             "SELECT conflict_id, subject_entity_id, predicate, incumbent_object_id,"
-            " challenger_value, challenger_confidence, status, created_at"
+            " challenger_value, challenger_confidence, status, created_at" + extra +
             " FROM fact_conflicts WHERE status='pending'"
             " ORDER BY created_at DESC LIMIT ?", (min(int(limit), 500),)):
+        cid, subj, pred, incumbent, value, conf, status, created = row[:8]
+        pack_id, refs_json, quote, hint = (row[8:12] if has_prov else (None, None, None, None))
         try:
             val = json.loads(value)
         except (json.JSONDecodeError, TypeError):
@@ -84,7 +89,9 @@ def list_conflicts(conn: sqlite3.Connection, limit: int = 100) -> List[Dict[str,
                      "kind": "quarantine" if is_q else "conflict",
                      "reason": str(incumbent)[len("quarantine:"):] if is_q else None,
                      "incumbent_object_id": incumbent, "value": val,
-                     "confidence": conf, "created_at": created})
+                     "confidence": conf, "created_at": created,
+                     "pack_id": pack_id, "quote": quote, "about_hint": hint,
+                     "promotable": bool(pack_id)})
     return rows
 
 
@@ -224,3 +231,182 @@ def run_pack_backfill(conn: sqlite3.Connection, pack_id: str, limit: int = 500)
     conn.commit()
     stats["quarantined"] = writer.stats.get("quarantined", 0) - stats.pop("quarantined0")
     return stats
+
+
+def predicate_schemas(conn: sqlite3.Connection) -> Dict[str, Any]:
+    """Per-predicate field schemas for the Fact Editor (W4.6): enum options,
+    person-typed flags, free-text fields — straight from the bundled contracts,
+    so the editor can never drift from what the writer accepts."""
+    from .packs import load_packs
+    from .registry import bundled_pack_dir
+
+    out: Dict[str, Any] = {}
+    for pid, pack in load_packs(bundled_pack_dir()).items():
+        for pred in pack.predicates.values():
+            fields: Dict[str, Any] = {}
+            if pred.value_schema:
+                for name, spec in pred.value_schema.items():
+                    if isinstance(spec, dict) and spec.get("enum"):
+                        fields[name] = {"kind": "enum", "options": list(spec["enum"])}
+                    elif isinstance(spec, list):
+                        fields[name] = {"kind": "enum", "options": list(spec)}
+                    elif name in ("person", "member"):
+                        fields[name] = {"kind": "person"}
+                    else:
+                        fields[name] = {"kind": "text"}
+            elif pred.values:
+                fields["__value__"] = {"kind": "enum", "options": list(pred.values)}
+            else:
+                fields["__value__"] = {"kind": "text"}
+            out[pred.name] = {"pack": pid, "fields": fields,
+                              "key_fields": list(pred.key_fields or []),
+                              "temporal": pred.temporal}
+    return out
+
+
+def promote_conflict(conn: sqlite3.Connection, conflict_id: str, *,
+                     subject_entity_id: str = "", new_person_name: str = "",
+                     value: Any = None, to_owner: bool = False) -> Dict[str, Any]:
+    """W4.6 — the review queue's 'Edit & add': the owner supplies the identity
+    (or corrected fields) the machine refused to guess; the fact writes through
+    the FULL writer path and the correction lands in the ledger as GOLD."""
+    import json as _json
+    import uuid as _uuid
+
+    from .packs import load_packs
+    from .registry import bundled_pack_dir
+    from .writer import DerivationWriter
+
+    row = conn.execute(
+        "SELECT subject_entity_id, predicate, challenger_value, challenger_confidence,"
+        " pack_id, source_refs_json, quote, about_hint, status"
+        " FROM fact_conflicts WHERE conflict_id=?", (conflict_id,)).fetchone()
+    if not row:
+        raise ValueError(f"unknown conflict {conflict_id}")
+    subj0, predicate, val_json, conf, pack_id, refs_json, quote, hint, status = row
+    if status != "pending":
+        raise ValueError(f"conflict {conflict_id} already {status}")
+    if not pack_id:
+        raise ValueError("this row predates provenance capture — dismiss and let re-extraction recreate it")
+    pack = load_packs(bundled_pack_dir(), only=[pack_id]).get(pack_id)
+    if pack is None:
+        raise ValueError(f"unknown pack {pack_id}")
+    try:
+        stored_value = _json.loads(val_json or "null")
+    except (ValueError, TypeError):
+        stored_value = val_json
+    final_value = value if value is not None else stored_value
+
+    if to_owner:
+        subject = conn.execute("SELECT entity_id FROM entities WHERE is_self=1").fetchone()[0]
+    elif subject_entity_id:
+        ok = conn.execute("SELECT 1 FROM entities WHERE entity_id=?", (subject_entity_id,)).fetchone()
+        if not ok:
+            raise ValueError(f"unknown entity {subject_entity_id}")
+        subject = subject_entity_id
+    elif new_person_name.strip():
+        subject = f"ent_{_uuid.uuid4().hex[:16]}"
+        n = " ".join(new_person_name.strip().split())
+        cols = {r[1] for r in conn.execute("PRAGMA table_info(entities)")}
+        base = ["entity_id", "entity_type", "canonical_name", "normalized_name", "aliases_json", "is_self"]
+        vals = [subject, "person", n, n.lower(), "[]", 0]
+        for extra in ("created_at", "updated_at"):
+            if extra in cols:
+                base.append(extra); vals.append(None)  # filled by SQL below
+        placeholders = ", ".join(
+            "datetime('now')" if b in ("created_at", "updated_at") else "?" for b in base)
+        conn.execute(
+            f"INSERT INTO entities ({', '.join(base)}) VALUES ({placeholders})",
+            [v for b, v in zip(base, vals) if b not in ("created_at", "updated_at")])
+    else:
+        raise ValueError("supply subject_entity_id, new_person_name, or to_owner")
+
+    writer = DerivationWriter(conn, model="owner-promote")
+    refs = _json.loads(refs_json or "[]")
+    out = writer.assert_pack_fact(
+        pack=pack, predicate=predicate, subject_entity_id=subject,
+        value=final_value, actor_role="authored", source_refs=refs,
+        confidence=1.0, quote=quote or "", about="owner")
+    from ...storage.db.write_gate import commit_connection, with_db_write
+    with with_db_write():
+        conn.execute("UPDATE fact_conflicts SET status='accepted', updated_at=datetime('now')"
+                     " WHERE conflict_id=?", (conflict_id,))
+        try:
+            conn.execute(
+                """INSERT INTO derivation_training_ledger
+                   (ledger_id, stage, pack_id, pack_version, predicate, value_json,
+                    about, quote, confidence, vstatus, written_object_id)
+                   VALUES (?, 'owner_promote', ?, ?, ?, ?, ?, ?, 1.0, 'accepted', ?)""",
+                (f"dtl_{_uuid.uuid4().hex[:16]}", pack_id, pack.version, predicate,
+                 _json.dumps(final_value, default=str), f"entity:{subject}",
+                 quote or "", out.get("object_id")))
+        except sqlite3.OperationalError:
+            pass
+        commit_connection(conn)
+    return {"conflict_id": conflict_id, "outcome": out.get("outcome"),
+            "object_id": out.get("object_id"), "subject_entity_id": subject}
+
+
+def revise_fact(conn: sqlite3.Connection, object_id: str, *,
+                value: Any = None, subject_entity_id: str = "",
+                evidence_date: str = "", asserted_by: str = "") -> Dict[str, Any]:
+    """W4.6 — owner revision of a live pack fact: closes the old row
+    (reason=owner_revision, belief clock inherited), re-inserts through keying
+    with confidence pinned 1.0. Field/date/subject edits only — a fact's KIND
+    never changes here (that is reject + a new fact)."""
+    import json as _json
+    import uuid as _uuid
+
+    from .packs import load_packs
+    from .registry import bundled_pack_dir
+    from .writer import DerivationWriter
+
+    row = conn.execute(
+        "SELECT object_key, payload_json, valid_from, ontology_id FROM signal_objects"
+        " WHERE object_id=? AND object_type='fact' AND valid_to IS NULL", (object_id,)).fetchone()
+    if not row:
+        raise ValueError(f"no live fact {object_id}")
+    key, pj, vf, pack_id = row
+    if not pack_id:
+        raise ValueError("legacy fact — use the verdict edit action")
+    p = _json.loads(pj or "{}")
+    predicate = str(p.get("predicate") or "")
+    pack = load_packs(bundled_pack_dir(), only=[pack_id]).get(pack_id)
+    if pack is None:
+        raise ValueError(f"unknown pack {pack_id}")
+    old_value = p.get("value_struct") if p.get("value_struct") is not None else p.get("object_value")
+    final_value = value if value is not None else old_value
+    subject = subject_entity_id or str(p.get("subject_entity_id") or "")
+    if subject_entity_id:
+        ok = conn.execute("SELECT 1 FROM entities WHERE entity_id=?", (subject_entity_id,)).fetchone()
+        if not ok:
+            raise ValueError(f"unknown entity {subject_entity_id}")
+
+    from ...storage.db.write_gate import commit_connection, with_db_write
+    with with_db_write():
+        conn.execute("UPDATE signal_objects SET valid_to=?, updated_at=datetime('now'),"
+                     " updated_by='owner_revision' WHERE object_id=?",
+                     ((evidence_date or str(vf)), object_id))
+        commit_connection(conn)
+    writer = DerivationWriter(conn, model="owner-revise")
+    out = writer.assert_pack_fact(
+        pack=pack, predicate=predicate, subject_entity_id=subject,
+        value=final_value, actor_role="authored",
+        source_refs=p.get("source_refs") or [], confidence=1.0,
+        quote=str(p.get("quote") or ""), about="owner",
+        event_date=(evidence_date or str(vf)[:10]) or None)
+    with with_db_write():
+        try:
+            conn.execute(
+                """INSERT INTO derivation_training_ledger
+                   (ledger_id, stage, pack_id, predicate, value_json, about, confidence,
+                    vstatus, vreason, written_object_id)
+                   VALUES (?, 'owner_edit', ?, ?, ?, ?, 1.0, 'accepted', ?, ?)""",
+                (f"dtl_{_uuid.uuid4().hex[:16]}", pack_id, predicate,
+                 _json.dumps(final_value, default=str), f"entity:{subject}",
+                 f"revised_from:{object_id}", out.get("object_id")))
+        except sqlite3.OperationalError:
+            pass
+        commit_connection(conn)
+    return {"revised_from": object_id, "outcome": out.get("outcome"),
+            "object_id": out.get("object_id")}

{topos_node-1.3.29 → topos_node-1.3.30}/topos/features/derivation/writer.py

@@ -154,18 +154,33 @@ class DerivationWriter:
         ).fetchone()
         return row[0] if row else None
 
-    def _quarantine(self, subject_entity_id: str, predicate: str, value, confidence: float, reason: str):
+    def _quarantine(self, subject_entity_id: str, predicate: str, value, confidence: float,
+                    reason: str, *, pack=None, source_refs=None, quote: str = "", about: str = ""):
         """A3 quarantine: nothing is silently lost — unroutable assertions land in
-        fact_conflicts (the W4.2 review queue) with a sentinel incumbent id."""
+        fact_conflicts (the review queue) WITH their provenance (migration 68), so
+        the owner can promote them into facts without minting evidence-less rows."""
         import uuid as _uuid
-        self.conn.execute(
-            """INSERT INTO fact_conflicts (conflict_id, subject_entity_id, predicate,
-                   incumbent_object_id, challenger_value, challenger_confidence)
-               VALUES (?, ?, ?, ?, ?, ?)""",
-            (f"cfl_{_uuid.uuid4().hex[:12]}", subject_entity_id, predicate,
-             f"quarantine:{reason}", json.dumps(value, ensure_ascii=False, default=str)[:500],
-             float(confidence)),
-        )
+        hint = about[6:] if isinstance(about, str) and about.startswith("other:") else ""
+        try:
+            self.conn.execute(
+                """INSERT INTO fact_conflicts (conflict_id, subject_entity_id, predicate,
+                       incumbent_object_id, challenger_value, challenger_confidence,
+                       pack_id, source_refs_json, quote, about_hint)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+                (f"cfl_{_uuid.uuid4().hex[:12]}", subject_entity_id, predicate,
+                 f"quarantine:{reason}", json.dumps(value, ensure_ascii=False, default=str)[:500],
+                 float(confidence), getattr(pack, "pack", None),
+                 json.dumps(source_refs or [], default=str)[:800], (quote or "")[:200], hint),
+            )
+        except Exception:  # noqa: BLE001 — pre-migration-68 schema
+            self.conn.execute(
+                """INSERT INTO fact_conflicts (conflict_id, subject_entity_id, predicate,
+                       incumbent_object_id, challenger_value, challenger_confidence)
+                   VALUES (?, ?, ?, ?, ?, ?)""",
+                (f"cfl_{_uuid.uuid4().hex[:12]}", subject_entity_id, predicate,
+                 f"quarantine:{reason}", json.dumps(value, ensure_ascii=False, default=str)[:500],
+                 float(confidence)),
+            )
         self.stats["quarantined"] = self.stats.get("quarantined", 0) + 1
 
     def assert_pack_fact(
@@ -200,11 +215,13 @@ class DerivationWriter:
                     self.stats["routed_dossier"] = self.stats.get("routed_dossier", 0) + 1
                 else:
                     self._quarantine(subject_entity_id, predicate, value, confidence,
-                                     reason=f"dossier_unresolved:{about[6:][:40]}")
+                                     reason=f"dossier_unresolved:{about[6:][:40]}",
+                                     pack=pack, source_refs=source_refs, quote=quote, about=about)
                     return {"outcome": "quarantined", "reason": "about=other unresolvable"}
             else:  # unclear — two passes could not agree on a subject
                 self._quarantine(subject_entity_id, predicate, value, confidence,
-                                 reason="about_unclear")
+                                 reason="about_unclear",
+                                 pack=pack, source_refs=source_refs, quote=quote, about=about)
                 return {"outcome": "quarantined", "reason": "about unclear"}
         synth_preds = {q for e in pack.synthesis for q in (e.get("predicate") if isinstance(e.get("predicate"), list) else [e.get("predicate")])}
         if actor_role == "synthesis":
@@ -228,7 +245,8 @@ class DerivationWriter:
         if pred.name == "asp.milestone" and isinstance(value, dict):
             if not self._milestone_attaches(subject_entity_id, str(value.get("goal_ref") or "")):
                 self._quarantine(subject_entity_id, predicate, value, confidence,
-                                 reason="milestone_without_goal")
+                                 reason="milestone_without_goal",
+                                 pack=pack, source_refs=source_refs, quote=quote, about=about)
                 return {"outcome": "quarantined", "reason": "milestone attaches to no stored goal"}
         # F1.6 guard — every leaf of the value
         for leaf in _value_leaves(value):

{topos_node-1.3.29 → topos_node-1.3.30}/topos/features/entities/maintenance.py

@@ -794,7 +794,7 @@ def compute_communities(conn: sqlite3.Connection) -> Dict[str, int]:
             # A community label is a NAME: name-length, from a name-natured type.
             def _labelable(eid: str) -> bool:
                 nm = names.get(eid, "").strip()
-                if not nm or len(nm) > 40 or len(nm.split()) > 4:
+                if not nm or len(nm) > 40 or len(nm.split()) > 4 or "\n" in nm:
                     return False
                 if types.get(eid, "") in ("goal", "conversation"):
                     return False
@@ -820,7 +820,12 @@ def compute_communities(conn: sqlite3.Connection) -> Dict[str, int]:
             # FALLBACK; identity-matched historical names win, and genuinely
             # new cores get one LLM-derived name (validated, else fallback).
             community_cores[rank[comm]] = [str(m) for m in ranked]
-        _apply_stable_names(conn, community_cores, labels_by_rank, names, eigen)
+        try:
+            _apply_stable_names(conn, community_cores, labels_by_rank, names, eigen)
+        except Exception:  # noqa: BLE001 — naming is an ENHANCEMENT; a lock or
+            # model failure mid-pass must never cost the deterministic labels
+            # (first live run: a transient 'database is locked' wiped them)
+            logger.exception("stable naming pass failed; deterministic labels stand")
         logger.info(
             "graph structural analytics: %d nodes / %d edges, betweenness k=%s, %.2fs",
             n,

{topos_node-1.3.29 → topos_node-1.3.30}/topos/features/facts/reads.py

@@ -130,6 +130,9 @@ def list_facts(
                 "subject_name": subject_name,
                 "predicate": payload.get("predicate"),
                 "object_value": payload.get("object_value"),
+                # the FULL structured value — object_value is a 160-char display
+                # string and renders as cut JSON when a report runs long (W4.6)
+                "value_struct": payload.get("value_struct"),
                 "period_start": payload.get("period_start"),
                 "period_end": payload.get("period_end"),
                 "confidence": payload.get("confidence", fact["confidence"]),

{topos_node-1.3.29 → topos_node-1.3.30}/topos/protocol/handled_message_types.json

@@ -43,6 +43,7 @@
   "get_data_explorer_table_prefs",
   "get_database_explorer_summary",
   "get_derivation_packs",
+  "get_derivation_schema",
   "get_device_info",
   "get_enrichment_lab_bundle_detail",
   "get_enrichment_lab_bundles",
@@ -133,6 +134,7 @@
   "post_source_test_enrichment",
   "post_source_test_enrichment_trigger",
   "post_source_test_ingestion",
+  "promote_fact_conflict",
   "put_community_name",
   "put_conversation_context",
   "put_conversation_context_llm_config",
@@ -156,6 +158,7 @@
   "read_jsonl_file",
   "replay_projection",
   "replay_projection_preview",
+  "revise_pack_fact",
   "routine_has_active_run",
   "run_pack_backfill",
   "set_device_name",

{topos_node-1.3.29 → topos_node-1.3.30}/topos/protocol/narrowing_vocabulary.json

@@ -122,6 +122,7 @@
     "resolved_self",
     "retrieval_parts",
     "retrieval_text",
+    "row_cap_reached",
     "scope_denied",
     "scope_id_invalid",
     "scope_mismatch",

{topos_node-1.3.29 → topos_node-1.3.30}/topos/query/game_layer.py

@@ -204,6 +204,23 @@ class DefaultGameLayer:
         if isinstance(exclusion, dict) and exclusion:
             payload["exclusion"] = exclusion
 
+        # Row-cap truncation (retrieval plane). Carried on EVERY mode for the same
+        # reason as the exclusion block: the claim is about the whole turn, not about
+        # one lane's contents. It is closed-set — an integer cap and table names — and
+        # never carries a row.
+        #
+        # This layer REBUILDS the payload rather than passing the packet through, so a
+        # field set in retrieval and not named here is dropped silently. That is what
+        # happened on 2026-08-25: retrieval set `truncated`, the ledger recorded
+        # `capped/row_cap_reached`, and `public_result` arrived with four keys and no
+        # sign that the answer had been cut off. A scheduled report then stated that
+        # something had not happened, when the evidence that it had was one row past
+        # the cap. An absence read off a truncated result is the failure this field
+        # prevents, and it only prevents it if it survives this rebuild.
+        truncated = context_packet.get("truncated")
+        if isinstance(truncated, dict) and truncated:
+            payload["truncated"] = truncated
+
         return PublicResult(payload=payload, strategy=strategy.value)
 
 

{topos_node-1.3.29 → topos_node-1.3.30}/topos/query/narrowing.py

@@ -293,6 +293,7 @@ REASONS = frozenset(
         "now",
         "query_text_capped",
         "retrieval_parts",
+        "row_cap_reached",
         "retrieval_text",
         "single_call_bootstrap",
         "source_has_live_tools",

{topos_node-1.3.29 → topos_node-1.3.30}/topos/query/packet_resolution.py

@@ -67,13 +67,28 @@ def effective_packet_resolution(
     *,
     requester_id: str = "owner",
     disclosure_tier: str = "owner_raw",
+    owner_id: str = "",
 ) -> Dict[str, Any]:
-    """The setting after both interlocks. `reason` says which floor applied, if any."""
+    """The setting after both interlocks. `reason` says which floor applied, if any.
+
+    The owner test mirrors `resolve_disclosure_tier`: the CP gateway authenticates the
+    caller and forwards requester_id == owner_id (the owner's uuid) on the owner path —
+    see the CP's test_owner_identity_forwarding.py. Comparing against the literal
+    "owner" alone rejected that verified identity, so every gateway-routed owner turn
+    was floored to scores_only and the facts_direct lane could never fire for the
+    surface it was built for (live 2026-08-26: "What medications am I taking?" answered
+    "unknown" while the fact sat in signal_objects). The disclosure-tier leg stays as
+    the independent guard: a grantee is never resolved to owner_raw, including when a
+    forged payload claims owner ids, so id-equality alone can never widen a grantee.
+    """
     from ..config.settings import resolve_packet_resolution, settings
 
     setting = resolve_packet_resolution(settings, conn)
     locality = primary_binding_locality(conn)
-    if str(requester_id or "") != "owner" or str(disclosure_tier or "") != "owner_raw":
+    req = str(requester_id or "")
+    own = str(owner_id or "")
+    is_owner = req == "owner" or (bool(own) and own != "owner" and req == own)
+    if not is_owner or str(disclosure_tier or "") != "owner_raw":
         effective, reason = "scores_only", "non_owner_floor"
     elif setting != "scores_only" and not locality["local"]:
         effective, reason = "scores_only", "hosted_binding"

{topos_node-1.3.29 → topos_node-1.3.30}/topos/query/pipeline.py

@@ -581,7 +581,8 @@ class QueryPipelineOrchestrator:
         # the conservative default is the safe one.
         try:
             _pr = effective_packet_resolution(
-                db_conn, requester_id=str(requester_id), disclosure_tier=disclosure_tier
+                db_conn, requester_id=str(requester_id), disclosure_tier=disclosure_tier,
+                owner_id=str(owner_id or ""),
             )
         except Exception:  # noqa: BLE001
             _pr = {"setting": "scores_only", "effective": "scores_only",