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

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

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

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

{topos_node-1.3.31 → topos_node-1.3.32}/topos/__version__.py

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

{topos_node-1.3.31 → topos_node-1.3.32}/topos/features/derivation/writer.py

@@ -23,9 +23,23 @@ import uuid
 from datetime import datetime, timezone, timedelta
 from typing import Any, Dict, List, Optional
 
+import os
+
 from topos.features.facts.store import FactStore, normalize_predicate, CONFLICT_CONFIDENCE_MARGIN
 from .guard import find_identifiers
 from .packs import Pack, Predicate
+
+#: Whether a resolved `about=other:<name>` assertion may be WRITTEN to that person's
+#: dossier. Default OFF, and it must stay off until a net-subject policy plane exists
+#: (per-subject opt-in defaulting to off, a write-time BlackholeStore consult, and
+#: pack-level `net_subject: allow|deny`). With it off, every outward assertion is
+#: quarantined with reason `net_subject_disabled:<name>` and waits for a human.
+#:
+#: The env override exists so the policy work can be developed and tested against the
+#: real path without editing the module. It is NOT a supported production setting: any
+#: node that sets it is writing durable facts about people who never consented and
+#: cannot, with no gate in front of the write.
+NET_SUBJECT_WRITES_ENABLED = os.environ.get("TOPOS_NET_SUBJECT_WRITES") == "1"
 # extractor provenance must track the PROMPT actually used — a local copy of this
 # constant stamped every shadow-2..6 fact "shadow-1" (caught in W1.3 grading)
 from .template import TEMPLATE_VERSION
@@ -206,6 +220,43 @@ class DerivationWriter:
         # --- A3 (attribution ladder): route by subject BEFORE any owner-assert ---
         about = (about or "owner").strip()
         if about != "owner":
+            # --- net-subject kill switch (temporary; remove when the policy plane lands) ---
+            #
+            # Below this line, `about=other:<name>` that RESOLVES is written as a durable
+            # fact onto that person's dossier. There is currently no consent plane to
+            # authorise that: `net_subject` / `subject_axis` appear ZERO times in this
+            # engine, the control plane, the front end, or any of the 25 pack YAMLs; the
+            # Pack/Predicate dataclasses carry no subject field, so a pack can neither
+            # declare nor refuse an outward subject; `pack.disclosure_default` is stored
+            # on every registry row and never read; and BlackholeGuard is consulted only
+            # at READ time, so a blackholed person can still ACCRUE facts.
+            #
+            # Nothing has been written so far only because `_resolve_person` is an exact
+            # match on `entities.normalized_name` and fails on every third-party first
+            # name — 624 of 1,505 person entities are keyed on a phone number and only 36
+            # carry aliases. That is an accident of an unbuilt person spine, not a policy.
+            # The planned L0 (person spine) exists precisely to make that resolution
+            # succeed, which would silently switch automatic third-party dossier writing
+            # ON. The owner's standing decision is "off until asked".
+            #
+            # So: quarantine EVERY outward assertion, resolvable or not. Quarantine is
+            # already the reviewed path — the rows carry full provenance and the fact
+            # editor promotes them — so nothing is lost, only deferred to a human.
+            #
+            # REMOVE THIS BLOCK when the net-subject policy plane exists (plan L4-4:
+            # per-subject opt-in defaulting to off, a write-time BlackholeStore consult,
+            # and pack-level `net_subject: allow|deny`). Replace it with that lookup —
+            # do not simply delete it.
+            if about.startswith("other:") and not NET_SUBJECT_WRITES_ENABLED:
+                # Its own reason, deliberately: these are POLICY holds, not failures to
+                # identify a subject. Collapsing them into `about_unclear` would make a
+                # withheld-by-policy row indistinguishable from one the verifier could
+                # not attribute, and the review queue's whole value is that distinction.
+                self._quarantine(subject_entity_id, predicate, value, confidence,
+                                 reason=f"net_subject_disabled:{about[6:][:40]}",
+                                 pack=pack, source_refs=source_refs, quote=quote, about=about)
+                self.stats["net_subject_withheld"] = self.stats.get("net_subject_withheld", 0) + 1
+                return {"outcome": "quarantined", "reason": "net-subject writes disabled"}
             if about.startswith("other:"):
                 other = self._resolve_person(about[6:])
                 if other:

{topos_node-1.3.31 → topos_node-1.3.32}/topos/features/entities/fact_materializer.py

@@ -360,7 +360,7 @@ def _display_value(raw) -> str:
                 return hv.strip()
         # NO fallback to arbitrary fields: a description/free-text value is
         # narrative, not identity — minting it produced sentence-named nodes
-        # ("rode with albi on the way to…"). A structured value with no
+        # ("rode with a friend on the way to…"). A structured value with no
         # identity key mints nothing; the fact itself still exists.
         return ""
     return str(v or "").strip()

{topos_node-1.3.31 → topos_node-1.3.32}/topos/features/entities/linking.py

@@ -43,7 +43,7 @@ _LINK_STOPWORDS = frozenset(
 
 def _linkable_candidate(cand: str) -> bool:
     """A candidate name is linkable only if it carries at least one real word:
-    ≥3 chars and not a function word. 'Luc' links; 'IS', 'Go', 'The One' do not."""
+    ≥3 chars and not a function word. 'Leo' links; 'IS', 'Go', 'The One' do not."""
     words = [w for w in cand.split() if w]
     if not words:
         return False

{topos_node-1.3.31 → topos_node-1.3.32}/topos/features/facts/reads.py

@@ -136,7 +136,13 @@ def list_facts(
                 "period_start": payload.get("period_start"),
                 "period_end": payload.get("period_end"),
                 "confidence": payload.get("confidence", fact["confidence"]),
-                "disclosure": payload.get("disclosure", "scoped"),
+                # Fail closed, and match the sibling reader 74 lines below, which
+                # already defaults to owner_only. A payload with no disclosure is
+                # a row nobody classified; reading it as shareable is the wrong
+                # direction to guess in, and the two readers disagreeing meant the
+                # same unclassified row was shareable on one path and private on
+                # the other.
+                "disclosure": payload.get("disclosure", "owner_only"),
                 # Attribution: who asserted this claim (owner | contact:<id> |
                 # assistant | page-author | …). Powers the person→ambient badge.
                 "asserted_by": payload.get("asserted_by", "owner"),

{topos_node-1.3.31 → topos_node-1.3.32}/topos/features/facts/store.py

@@ -110,7 +110,14 @@ class FactStore:
         confidence: float = 0.7,
         source_refs: Optional[List[Dict[str, Any]]] = None,
         valid_from: Optional[str] = None,
-        disclosure: str = "scoped",
+        # Fail closed. Every in-tree caller passes this explicitly (verdicts.py,
+        # llm_extract.py, extract.py x2, truth_facts.py), so the default is only
+        # ever reached by a caller that forgot — and the safe thing to do with a
+        # claim about a person when nobody said how far it may travel is to keep
+        # it. This is the second fact write path: DerivationWriter pins owner_only
+        # by construction, and this one did not, so "facts are owner_only" was
+        # true of one lane and merely conventional in the other.
+        disclosure: str = "owner_only",
         period_start: Optional[str] = None,
         period_end: Optional[str] = None,
         asserted_by: str = "owner",

{topos_node-1.3.31 → topos_node-1.3.32}/topos/features/lifecycle/derived_scrub.py

@@ -524,9 +524,22 @@ def sweep_orphans(conn: sqlite3.Connection) -> Dict[str, int]:
             """
         )
         out["embedding_entities"] = int(cursor.rowcount or 0)
+        # A conflict row is an orphan when the fact it CHALLENGES is gone. A3
+        # quarantine rows have no incumbent by design — an unroutable or withheld
+        # assertion is not challenging anything — so they carry the synthetic
+        # sentinel `quarantine:<reason>` (writer.py::_quarantine). That sentinel is
+        # never a signal_objects.object_id, so the orphan predicate matched every
+        # one of them: measured on the live node 2026-08-26, all 13 pending rows
+        # would be deleted by this sweep, and it fires on the owner's ordinary
+        # per-record exclusion flow. That queue is the human review path for
+        # third-party assertions — including health.condition about people who
+        # never consented — so deleting it silently discards exactly the decisions
+        # a person is supposed to make.
         cursor = conn.execute(
             """
-            DELETE FROM fact_conflicts WHERE incumbent_object_id NOT IN (
+            DELETE FROM fact_conflicts
+             WHERE incumbent_object_id NOT LIKE 'quarantine:%'
+               AND incumbent_object_id NOT IN (
                 SELECT object_id FROM signal_objects WHERE object_type='fact'
             )
             """

{topos_node-1.3.31 → topos_node-1.3.32}/topos/query/facts_direct.py

@@ -38,7 +38,8 @@ _ALIASES: List[tuple] = [
     (r"\b(career|fired|hired|promoted|laid off)\b", ["work.career_event"], False),
     (r"\bfamily member|my (family|relatives|parents|siblings|kids|children)\b",
      ["rel.relationship"], False),
-    (r"\b(closest|inner circle|best friend)s?\b", ["rel.closeness_tier", "rel.relationship"], False),
+    (r"\b(closest|inner circle|close circle|close friend|best friend)s?\b",
+     ["rel.closeness_tier", "rel.relationship"], False),
     (r"\bchronotype|night owl|early bird\b", ["behavior.chronotype"], False),
 ]
 
@@ -66,19 +67,43 @@ def fetch_direct_facts(
         return None
     if special and packet_resolution != "facts_all":
         return None
-    owner = conn.execute("SELECT entity_id FROM entities WHERE is_self=1").fetchone()
+    # `is_self` is not unique: live 2026-08-26 three entities carried it —
+    # ent_e73ff33ae330422b ("Owner", 178 facts) plus two "self" rows created that
+    # morning holding none. An unordered fetchone() picked the fact-bearing row by
+    # rowid luck; a vacuum or a rewrite of that row would have silently blanked
+    # every known-item answer. Prefer the self-entity that actually owns facts,
+    # entity_id as the tiebreak, so the choice is stable across rewrites. (No
+    # created_at in the ORDER BY: the query fixtures build a minimal `entities`
+    # table without it.)
+    owner = conn.execute(
+        """SELECT e.entity_id
+             FROM entities e
+            WHERE e.is_self=1
+         ORDER BY (SELECT COUNT(*) FROM signal_objects o
+                    WHERE o.object_type='fact'
+                      AND o.object_key LIKE 'fact:' || e.entity_id || ':%') DESC,
+                  e.entity_id ASC
+            LIMIT 1"""
+    ).fetchone()
     if not owner:
         return None
     out: List[Dict[str, Any]] = []
     for pred in predicates:
+        # Delimiter-aware: a bare `{pred}%` prefix also swept sibling predicates.
+        # "Who's in my family?" asks for rel.relationship and was handed the 23
+        # rel.relationship_event rows too, so the answer listed people the owner
+        # merely met (live 2026-08-26: Vitalik Buterin returned as family). Match
+        # the exact key or the key plus its ':value' segment, nothing else.
+        # `_` is a LIKE wildcard and predicates contain it, so escape it.
+        like_pred = pred.replace("\\", "\\\\").replace("_", "\\_").replace("%", "\\%")
         rows = conn.execute(
             """SELECT object_key, payload_json, confidence, valid_from, valid_to,
                       ontology_id, altitude
                FROM signal_objects
                WHERE object_type='fact' AND valid_to IS NULL
-                 AND object_key LIKE ?
+                 AND (object_key = ? OR object_key LIKE ? ESCAPE '\\')
                ORDER BY valid_from DESC LIMIT 40""",
-            (f"fact:{owner[0]}:{pred}%",),
+            (f"fact:{owner[0]}:{pred}", f"fact:{owner[0]}:{like_pred}:%"),
         ).fetchall()
         for key, payload_json, conf, vf, vt, pack, altitude in rows:
             try:
@@ -125,6 +150,37 @@ def _fmt_value(v: Any) -> str:
     return str(v)
 
 
+def _fact_labels(facts: List[Dict[str, Any]]) -> List[str]:
+    """Subject labels for `items`.
+
+    The game layer fills `items` speculatively from graph/score text before this
+    lane runs, and pipeline's `payload.update(direct)` only overwrites the keys
+    this lane returns. Leaving `items` behind shipped a correct `answer` next to a
+    contradicting list: live 2026-08-26 "Who's in my family?" carried Mom, Dad,
+    brother and grandma in `answer` while `items` held NER debris ("U", "AI",
+    "##os", "NAME"), and the local synthesis model answered from the debris.
+    """
+    out: List[str] = []
+    seen: set[str] = set()
+    for f in facts:
+        value = f.get("value")
+        if isinstance(value, str):
+            try:
+                value = json.loads(value)
+            except (json.JSONDecodeError, TypeError):
+                value = None
+        label = None
+        if isinstance(value, dict):
+            label = value.get("person") or value.get("name") or value.get("value")
+        if not label:
+            label = _fmt_value(f.get("value"))
+        label = str(label).strip()
+        if label and label not in seen:
+            seen.add(label)
+            out.append(label)
+    return out[:20]
+
+
 def compose_facts_answer(facts: List[Dict[str, Any]]) -> str:
     lines = []
     for f in facts[:20]:
@@ -158,5 +214,6 @@ def try_facts_direct(
         "answer_type": "facts",
         "answer": compose_facts_answer(facts),
         "facts": facts[:20],
+        "items": _fact_labels(facts),
         "facts_direct": True,
     }

{topos_node-1.3.31 → topos_node-1.3.32}/topos/query/game_layer.py

@@ -55,6 +55,34 @@ def _extract_inference_evidence(context_packet: Dict[str, Any], *, limit: int =
     return evidence
 
 
+#: Redaction writes these placeholders into stored text, and the NER pass then
+#: extracts them as if they were names.
+_REDACTION_PLACEHOLDERS = {"NAME", "ADDRESS", "DATE", "EMAIL", "PHONE", "URL", "LOCATION"}
+
+
+def _looks_like_entity_label(value: str) -> bool:
+    """Reject debris that is not a name.
+
+    `graph.nodes` and `scores` carry raw NER output, which includes WordPiece
+    continuation tokens ("Topos" tokenizes to "Top" + "##os", and both are stored
+    as separate entities), redaction placeholders, and serialized fact blobs. Live
+    2026-08-26 the answer to "Who's in my close circle?" was
+    ["U", "AI", "UMA", "Sara", "Marcus", "NAME", "Top", "##os", "VoxTerm A"].
+    """
+    v = value.strip()
+    if len(v) < 2 or len(v) > 60:
+        return False
+    if v.startswith("##"):          # WordPiece continuation, never a standalone name
+        return False
+    if "{" in v or "}" in v:        # serialized fact payload, not a label
+        return False
+    if v.upper() in _REDACTION_PLACEHOLDERS:
+        return False
+    if v.isupper() and len(v) <= 3:  # bare acronym (U, AI, UMA), not a person here
+        return False
+    return True
+
+
 def _extract_entity_labels(context_packet: Dict[str, Any]) -> List[str]:
     labels: List[str] = []
     seen: set[str] = set()
@@ -64,7 +92,7 @@ def _extract_entity_labels(context_packet: Dict[str, Any]) -> List[str]:
             continue
         for key in ("label", "name", "node_id", "entity_text"):
             value = node.get(key)
-            if value and str(value) not in seen:
+            if value and str(value) not in seen and _looks_like_entity_label(str(value)):
                 seen.add(str(value))
                 labels.append(str(value))
     for score in context_packet.get("scores") or []:
@@ -72,7 +100,7 @@ def _extract_entity_labels(context_packet: Dict[str, Any]) -> List[str]:
             continue
         for key in ("entity_text", "label", "topic", "summary_text"):
             value = score.get(key)
-            if value and str(value) not in seen:
+            if value and str(value) not in seen and _looks_like_entity_label(str(value)):
                 seen.add(str(value))
                 labels.append(str(value))
     return labels[:10]

{topos_node-1.3.31 → topos_node-1.3.32}/topos/upgrades/manifests.json

@@ -611,6 +611,12 @@
       "steps": [],
       "notes": []
     },
+    {
+      "version": "1.3.32",
+      "summary": "Release 1.3.32.",
+      "steps": [],
+      "notes": []
+    },
     {
       "version": "unreleased",
       "summary": "Staging entry for in-flight PRs. cut_release.py stamps this with the next version at release cut. Never executed by steps_between.",

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: topos-node
-Version: 1.3.31
+Version: 1.3.32
 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