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

{topos_node-1.3.29/topos_node.egg-info → topos_node-1.3.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.29
+Version: 1.3.31
 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.31}/pyproject.toml

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

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

{topos_node-1.3.29 → topos_node-1.3.31}/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.31}/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.31}/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.31}/topos/features/derivation/bundled_packs/aspirations.goals.yaml

@@ -73,8 +73,8 @@ guidance:
     - "Authored-only: an assigned OKR is work context, not a personal goal, unless the owner adopts it in their own words."
     - "Idle wishes ('would love to someday') are aspirations, never goals — the horizon field is load-bearing."
     - "v0.2.4 A goal is STATED INTENT in the owner's own words ('Goal:', 'I want to', 'I will').
-       Wry observations, jokes and family lore ('this is the closest I can keep that pattern
-       going') are never goals — if the owner would be surprised to see it on their goal list,
+       Wry observations, jokes and family lore ('guess the family streak continues through me
+      ') are never goals — if the owner would be surprised to see it on their goal list,
        extract nothing."
     - "v0.2.4 goal_ref is a NAME (a few words), not a sentence — a goal_ref longer than ~8 words
        means the goal was never really named; prefer the Goal: header's own phrasing."

{topos_node-1.3.29 → topos_node-1.3.31}/topos/features/derivation/bundled_packs/health.mental.yaml

@@ -31,7 +31,7 @@ predicates:
       v0.2.4 — a state report is a FELT-STATE statement about how the owner is/was
       ("I am exhausted", "slept 8 hours, wild dreams", "so nervous with the talk").
       An intention, aspiration, reflection or observation is NOT a state, whatever
-      dimension it brushes: "I need to be talking to more intelligent people" is a
+      dimension it brushes: "I need to be around more ambitious builders" is a
       want, not an energy report; "the talk motivated me to write" is a reflection,
       not a focus report. If the words don't describe how the owner FEELS or FELT,
       extract nothing.
@@ -70,9 +70,9 @@ eval:
     - {text: "Third week straight of terrible sleep, I'm running on fumes", role: authored,
        expect: [{predicate: mind.self_reported_state, value: {dimension: sleep_quality}}]}
   negative_controls:
-    - {text: "I need to be talking to more intelligent people. To go out of my way to speak with people.", role: authored,
+    - {text: "I need to be around more ambitious builders. To go out of my way to find them.", role: authored,
        expect_not: [{predicate: mind.self_reported_state}], note: "v0.2.4 measured junk: a want is not an energy state"}
-    - {text: "The talk at the end motivated me to write my own thought on coordination tools.", role: authored,
+    - {text: "The workshop at the end inspired me to draft my own essay on collaboration tools.", role: authored,
        expect_not: [{predicate: mind.self_reported_state}], note: "v0.2.4 measured junk: a reflection is not a focus state"}
     - {text: "Podcast episode about burnout culture in tech", role: ambient, expect: []}
     - {text: "My brother finally started therapy, proud of him", role: authored, expect: [], note: "third party"}

{topos_node-1.3.29 → topos_node-1.3.31}/topos/features/derivation/bundled_packs/places.mobility.yaml

@@ -81,8 +81,8 @@ decisions:
   - >
     2026-08-26 (W5 gate, measured): role_policy tightened to authored_addressed —
     with ambient/observed allowed, OTHER PEOPLE'S messages became owner place-ties
-    ("I am once again at Radio East" from a friend -> owner workplace_location;
-    a friend's NJ parking find -> owner tie to New Jersey). 4/5 sampled accepts
+    ("I am once again at the Harbor Cafe" from a friend -> owner workplace_location;
+    a friend's parking find -> owner tie to that city). 4/5 sampled accepts
     were junk, dominated by this leak. Location-bearing ambient signals return
     via the no-LLM synthesizer lane (timestamps/geo), never via LLM reading of
     others' words.

{topos_node-1.3.29 → topos_node-1.3.31}/topos/features/derivation/bundled_packs/work.career.yaml

@@ -117,12 +117,12 @@ eval:
        expect: [{predicate: work.project, value: {status: paused}}]}
   negative_controls:
     - {text: "Sounds like Dana's team is hiring three more", role: authored, expect: [], note: "other team's news"}
-    - {text: "I applied to Tavus' job application today", role: authored, expect: [], note: "v0.2.2 measured junk: applied is NOT hired"}
-    - {text: "I applied to the Google Startup Fund", role: authored, expect: [], note: "v0.2.2 measured junk: applying for funding is NOT started_venture"}
+    - {text: "I applied to Meridian's open role today", role: authored, expect: [], note: "v0.2.2 measured junk: applied is NOT hired"}
+    - {text: "I applied to the Horizon Startup Fund", role: authored, expect: [], note: "v0.2.2 measured junk: applying for funding is NOT started_venture"}
     - {text: "I filed for unemployment.", role: authored, expect: [{predicate: work.employment_shape, value: between_roles}],
        expect_not: [{predicate: work.career_event}], note: "v0.2.2: shape yes, event no"}
-    - {text: "I took the ccat again. I got a 32.", role: authored, expect: [], note: "v0.2.2 measured junk: a test score is not an award"}
-    - {text: "All day with Texas Ventures.", role: authored, expect_not: [{predicate: work.employer}], note: "v0.2.2 measured junk: co-presence is not employment"}
+    - {text: "I took the practice aptitude test again. Scored a 32.", role: authored, expect: [], note: "v0.2.2 measured junk: a test score is not an award"}
+    - {text: "All day with Harbor Ventures.", role: authored, expect_not: [{predicate: work.employer}], note: "v0.2.2 measured junk: co-presence is not employment"}
     - {text: "(newsletter: 'The 2026 layoff wave continues')", role: ambient, expect: []}
   calibration: {min_conf_for_assert: 0.65, ece_max: 0.15}
 

{topos_node-1.3.29 → topos_node-1.3.31}/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.31}/topos/features/derivation/template.py

@@ -100,7 +100,7 @@ LOSS_EVIDENCE = ("died", "passed", "passing", "funeral", "loss of", "death", "re
 
 def relationship_role_check(role: str, person: str, record_text: str):
     """A1 role-evidence guard (measured 2026-08-26 full-run): the 27B verifier
-    CONSISTENTLY accepts possessive misattribution ("Wiki and her boyfriend Luc"
+    CONSISTENTLY accepts possessive misattribution ("Nora and her boyfriend Theo"
     -> owner's partner) — textual support without subject discipline. Rules,
     all deterministic:
       1. A kin-term PERSON ("Mom", "brother") is self-evidencing -> owner.
@@ -239,7 +239,7 @@ Hard rules:
 - Extract only what this record actually states about the OWNER. No guesses, no world knowledge.
 - Every assertion MUST carry "about": "owner" if the fact is about the record's author-owner,
   "other:<name>" if the record states it about someone else (their appointment, their partner,
-  their loss — e.g. "Wiki and her boyfriend Luc" -> about: "other:Wiki"), or "unclear" if you
+  their loss — e.g. "Nora and her boyfriend Theo" -> about: "other:Nora"), or "unclear" if you
   cannot tell. Facts about others are NOT discarded — they are routed to that person's dossier —
   so NEVER launder a third party's fact into "owner" to save it.
   The about field does NOT make extraction stricter: extract exactly what you would have

{topos_node-1.3.29 → topos_node-1.3.31}/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.31}/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.31}/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.31}/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.31}/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.31}/topos/query/facts_direct.py

@@ -93,9 +93,27 @@ def fetch_direct_facts(
                 "altitude": altitude or "stated", "pack": pack,
                 "evidence_count": len(refs) if isinstance(refs, list) else 0,
             })
+    # Durable facts (a standing role/status: "mom, parent, active") outrank event
+    # facts ("met X at the saloon") in a known-item answer. Recency-only ordering
+    # let a month of introductions push the owner's parents past the compose cap:
+    # live 2026-08-26, "Who's in my family?" listed 16 met-events and cut
+    # mom/brother while keeping them in store. Stable sort keeps recency DESC
+    # within each band, so event feeds ("what happened with X?") are unaffected
+    # below the durable block.
+    out.sort(key=lambda f: 0 if _is_durable(f.get("value")) else 1)
     return out or None
 
 
+def _is_durable(value: Any) -> bool:
+    """A fact whose value carries a standing role/status rather than an event."""
+    if isinstance(value, str):
+        try:
+            value = json.loads(value)
+        except (json.JSONDecodeError, TypeError):
+            return False
+    return isinstance(value, dict) and bool(value.get("role") or value.get("status"))
+
+
 def _fmt_value(v: Any) -> str:
     if isinstance(v, str):
         try: