topos-node 1.3.46__tar.gz → 1.3.48__tar.gz

{topos_node-1.3.46/topos_node.egg-info → topos_node-1.3.48}/PKG-INFO

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

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

{topos_node-1.3.46 → topos_node-1.3.48}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.46"
-__version_info__ = (1, 3, 46)
+__version__ = "1.3.48"
+__version_info__ = (1, 3, 48)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.46 → topos_node-1.3.48}/topos/features/lifecycle/blackhole_rebuild.py

@@ -269,11 +269,20 @@ def _withdraw_embeddings(conn: sqlite3.Connection, terms: Set[str]) -> int:
         ).fetchall()
     except sqlite3.OperationalError:
         return 0
-    doomed = [
+    doomed_set = {
         str(embedding_id)
         for embedding_id, preview, search_text in rows
         if _mentions(preview, terms) or _mentions(search_text, terms)
-    ]
+    }
+    # The identity leg: a derived row keyed to a protected entity goes whether
+    # or not its generated sentence happens to name them.
+    try:
+        doomed_set |= _derived_embedding_ids_for_entities(
+            conn, BlackholeStore(conn).blackholed_entity_ids()
+        )
+    except Exception as exc:  # noqa: BLE001 — never let it cost the term leg
+        logger.warning("blackhole: derived identity sweep failed (%s); term leg stands", exc)
+    doomed = sorted(doomed_set)
     if not doomed:
         return 0
 
@@ -292,6 +301,57 @@ def _withdraw_embeddings(conn: sqlite3.Connection, terms: Set[str]) -> int:
     return len(doomed)
 
 
+#: Payload keys that name the entity a derived object is ABOUT. The read side
+#: already filters on exactly these (`retrieval._BLACKHOLE_ENTITY_ID_KEYS`);
+#: the withdrawal sweep is the write-side half of the same rule.
+_DERIVED_SUBJECT_KEYS = (
+    "entity_id",
+    "subject_entity_id",
+    "object_entity_id",
+    "source_entity_id",
+    "target_entity_id",
+)
+
+
+def _derived_embedding_ids_for_entities(
+    conn: sqlite3.Connection, entity_ids: Set[str]
+) -> Set[str]:
+    """Embedding ids whose derived object is KEYED to a protected entity.
+
+    The term scan beside this one can only catch a row that says the name, and
+    a rendered sentence is generated text: it refers to people by pronoun, by
+    role, and by aliases the term set never learned ("my brother", "the founder
+    I met"). A derived row is about its subject whether or not it names them,
+    and the subject is recorded — so identity, not wording, is what decides
+    here. Term matching stays, for rows that name someone without being keyed
+    to them.
+    """
+    if not entity_ids:
+        return set()
+    try:
+        rows = conn.execute(
+            "SELECT e.embedding_id, o.payload_json"
+            " FROM signal_embeddings e"
+            " JOIN signal_objects o ON o.object_id = e.record_id"
+        ).fetchall()
+    except sqlite3.OperationalError:
+        return set()
+    doomed: Set[str] = set()
+    for embedding_id, payload_json in rows:
+        try:
+            payload = json.loads(payload_json or "{}") or {}
+        except (TypeError, ValueError):
+            continue
+        if not isinstance(payload, dict):
+            continue
+        for key in _DERIVED_SUBJECT_KEYS:
+            value = str(payload.get(key) or "").strip()
+            if value and value in entity_ids:
+                doomed.add(str(embedding_id))
+                break
+    return doomed
+
+
 def _withdraw_goals(conn: sqlite3.Connection, terms: Set[str]) -> int:
     """Drop extracted goals whose text names the entity.
 

{topos_node-1.3.46 → topos_node-1.3.48}/topos/features/signal/derived_index.py

@@ -64,6 +64,12 @@ DERIVED_RECORD_TYPES: Dict[str, str] = {
     "RelationshipEdge": "derived_relationship_edge",
     "entity_dossier": "derived_entity_dossier",
     "fact": "derived_fact",
+    # S8: the measured hole. 1,548 user_goals + 68 Goal objects carried the
+    # owner's own prose and none were embedded, so a goal question reached
+    # dossiers and facts instead of goals. Both types share one renderer —
+    # they differ only in producer, not in shape.
+    "user_goals": "derived_goal",
+    "Goal": "derived_goal",
 }
 
 DERIVED_RECORD_TYPE_SET = frozenset(DERIVED_RECORD_TYPES.values())
@@ -504,10 +510,75 @@ def render_fact(obj: Dict[str, Any], resolver: _NameResolver) -> Optional[Derive
     )
 
 
+#: Goal text over this many characters is a journal entry that happens to be
+#: stored as a goal; embedding the whole thing dilutes the vector toward the
+#: day's narrative and away from the intent. The head is where the intent is.
+_GOAL_TEXT_CAP = 400
+
+
+def render_goal(obj: Dict[str, Any], resolver: _NameResolver) -> Optional[DerivedRendering]:
+    """A stated intention as the sentence someone would ask it back with.
+
+    Measured on the owner store 2026-09-03: 1,548 ``user_goals`` + 68 ``Goal``
+    objects held real prose and NONE were embedded, so "what am I trying to
+    achieve commercially?" reached a GitHub dossier and a stray fact while
+    "Aim the pitch at the segments that actually convert"
+    sat one table away. Dossiers and facts were already at full coverage;
+    goals were the whole remaining hole in the derived index.
+
+    The vocabulary is deliberately thin. ``_TIER_PHRASE``'s lesson applies
+    here in the same direction: the topical nouns must come from the owner's
+    own goal text, never from this template, or every goal becomes a match for
+    every question about whatever noun the template chose. So the frame says
+    only that this is something the owner is trying to do, and ``status`` and
+    ``horizon`` ride along ONLY when the object declares them — they are the
+    handles for "what am I working on right now" versus "what did I want to
+    get to eventually".
+    """
+    payload = obj.get("payload") or {}
+    text = str(payload.get("goal_text") or payload.get("text") or "").strip()
+    if not text:
+        # A goal with no prose is an identity row: a key and a timestamp. There
+        # is no question it could answer, and rendering it as its key would put
+        # an id in a retrieval preview.
+        return None
+    if len(text) > _GOAL_TEXT_CAP:
+        text = text[:_GOAL_TEXT_CAP].rsplit(" ", 1)[0] + "…"
+
+    status = str(payload.get("status") or "").strip().replace("_", " ")
+    horizon = str(payload.get("horizon") or "").strip().replace("_", " ")
+    qualifiers = [q for q in (horizon, status) if q]
+    frame = "a goal I set"
+    if qualifiers:
+        frame = f"a {' '.join(qualifiers[:1])} goal I set"
+        if len(qualifiers) > 1:
+            frame = f"{frame}, {qualifiers[1]}"
+
+    body = f"{text.rstrip(' .;')} — {frame}"
+    return DerivedRendering(
+        object_id=str(obj["object_id"]),
+        object_type=str(obj.get("object_type") or "user_goals"),
+        object_key=str(obj.get("object_key") or ""),
+        record_type=DERIVED_RECORD_TYPES.get(
+            str(obj.get("object_type") or ""), "derived_goal"
+        ),
+        signal_dimension=str(obj.get("signal_dimension") or "goals"),
+        text=f"{body}.",
+        header="goal | something I am trying to do",
+        title=text[:80],
+        # A goal is the owner's own statement of intent. The index never widens
+        # what the producer decided; absent a declaration, owner_only.
+        disclosure=str(payload.get("disclosure") or "owner_only"),
+        extra={"status": status or None, "horizon": horizon or None},
+    )
+
+
 _RENDERERS = {
     "RelationshipEdge": render_relationship_edge,
     "entity_dossier": render_entity_dossier,
     "fact": render_fact,
+    "user_goals": render_goal,
+    "Goal": render_goal,
 }
 
 

{topos_node-1.3.46 → topos_node-1.3.48}/topos/protocol/narrowing_vocabulary.json

@@ -95,6 +95,7 @@
     "graph_lane",
     "gate_vetoed",
     "grantee_scrub_facts",
+    "hosted_binding_text_withheld",
     "grantee_scrub_scores",
     "grantee_scrub_semantic_hits",
     "grantee_scrub_summaries",

{topos_node-1.3.46 → topos_node-1.3.48}/topos/query/narrowing.py

@@ -255,6 +255,7 @@ REASONS = frozenset(
         "no_source_connected",
         # --- engine: the grantee content filter, one per scrubbed artifact list
         "grantee_scrub_facts",
+        "hosted_binding_text_withheld",
         "grantee_scrub_scores",
         "grantee_scrub_semantic_hits",
         "grantee_scrub_summaries",

{topos_node-1.3.46 → topos_node-1.3.48}/topos/query/pipeline.py

@@ -25,7 +25,7 @@ from .inference import run_query_inference
 from .intent import compute_intent_hash
 from .manifest import ScopeResolutionManifest
 from .minimizer import DisclosureMinimizer
-from .narrowing import NarrowingLedger, result_is_empty
+from .narrowing import STAGE_DISCLOSURE, NarrowingLedger, result_is_empty
 from . import narrowing as _N
 from .negotiation import DEFAULT_MAX_ROUNDS, build_narrow_request_response, qualify_intent
 from .retrieval import DefaultSignalRetrievalAdapter, resolve_retrieval_source_ids
@@ -48,6 +48,57 @@ _NOT_QUERIED_OUTCOMES = frozenset(
 )
 
 
+#: Item containers in `public_result` that carry generated or quoted prose.
+#: Declared rather than recursed, the same choice `disclosure._GRANTEE_DICT_ARTIFACTS`
+#: makes and for the same reason: a new artifact has to be listed here, and the
+#: listing is the review.
+_HOSTED_FLOOR_ITEM_KEYS = ("summaries", "scores", "semantic_hits", "items", "facts")
+
+
+def withhold_text_for_hosted_binding(
+    public_dict: Dict[str, Any], *, ledger: Optional[NarrowingLedger] = None
+) -> int:
+    """Strip prose from a floored turn's payload, keeping its shape.
+
+    Identity, provenance, rank and dates survive: a caller can still see THAT
+    something matched and how strongly, and the turn stays legible. The words
+    do not travel. Emptying the lists instead would be worse than useless —
+    an empty result is indistinguishable from a corpus that held nothing,
+    which is the false-absence failure this whole plan exists to end, so the
+    withholding is declared in the ledger rather than performed in silence.
+
+    Returns the number of text fields removed, so a caller can assert the cap
+    actually did something (a severed-wire lever, and the reason this is a
+    module-level function rather than an inline loop).
+    """
+    from .disclosure import _GRANTEE_TEXT_KEYS
+
+    removed = 0
+    for container in _HOSTED_FLOOR_ITEM_KEYS:
+        items = public_dict.get(container)
+        if not isinstance(items, list):
+            continue
+        for item in items:
+            if not isinstance(item, dict):
+                continue
+            for key in _GRANTEE_TEXT_KEYS:
+                if item.get(key):
+                    item[key] = ""
+                    removed += 1
+    # The free-text answer is the same content in one field.
+    if public_dict.get("answer") and public_dict.get("answer_type") not in ("band", "yes_no"):
+        public_dict["answer"] = ""
+        removed += 1
+    if removed and ledger is not None:
+        ledger.record(
+            STAGE_DISCLOSURE,
+            "excluded",
+            "hosted_binding_text_withheld",
+            dropped=removed,
+        )
+    return removed
+
+
 def _attach_narrowing(result: Dict[str, Any], ledger: NarrowingLedger) -> Dict[str, Any]:
     """Put the ledger on the response, and attribute any empty the body did not.
 
@@ -853,6 +904,17 @@ class QueryPipelineOrchestrator:
             public.payload = enforce_availability_inference_contract(public.payload)
 
         public_dict = public.to_dict()
+        # The hosted-binding floor reaches the ANSWER, not only the packet.
+        # `effective_packet_resolution` gates what the engine's own model reads;
+        # summary prose does not stop there — it rides `public_result` to
+        # whatever model writes the reply, and on a hosted pack that model is
+        # the hosted one. Measured on an owner snapshot 2026-09-03: a turn
+        # reporting `scores_only`/`hosted_binding` still carried 60,151
+        # characters of the owner's conversation text, byte-identical to the
+        # same query on a local binding. The protection read as active on the
+        # turn that carried the content out.
+        if _pr["effective"] == "scores_only" and _pr["reason"] == "hosted_binding":
+            withhold_text_for_hosted_binding(public_dict, ledger=ledger)
         # Declared, never silent: every turn says what resolution actually applied and
         # why (active / non_owner_floor / hosted_binding). Same post-hoc pattern as
         # `empty_cause` below.

{topos_node-1.3.46 → topos_node-1.3.48}/topos/query/retrieval.py

@@ -4208,6 +4208,13 @@ def _semantic_hits(
                 {
                     "record_id": item.get("record_id"),
                     "text_preview": item.get("text_preview"),
+                    # The indexed body, which is longer than the 200-char
+                    # preview. This rebuild is an explicit allow-list, and
+                    # omitting the key silently capped every vector and derived
+                    # summary at the preview length — measured 2026-09-03: 45
+                    # of 462 derived rows carried up to 850 characters of
+                    # rendering that no answer could ever show.
+                    "search_text": item.get("search_text"),
                     "similarity": item.get("similarity"),
                     "source_id": item.get("source_id"),
                     "signal_dimension": item.get("signal_dimension"),
@@ -5527,7 +5534,10 @@ def _build_summary_items_unfiltered(
     # people that never surfaces a name answers nothing.
     derived_items: List[Dict[str, Any]] = []
     for hit in derived_hits or []:
-        text = str(hit.get("text_preview") or "").strip()
+        # The full rendering, not its 200-char preview: `index_derived_objects`
+        # writes both, and a rendering cut mid-clause reads as a truncated
+        # thought rather than the sentence the lane exists to hand back.
+        text = str(hit.get("search_text") or hit.get("text_preview") or "").strip()
         if not text:
             continue
         object_type = str(hit.get("object_type") or "")

{topos_node-1.3.46 → topos_node-1.3.48}/topos/upgrades/manifests.json

@@ -787,6 +787,32 @@
       "steps": [],
       "notes": []
     },
+    {
+      "version": "1.3.47",
+      "summary": "Release 1.3.47.",
+      "steps": [
+        {
+          "id": "index-goals-into-derived-index",
+          "kind": "derived_rebuild",
+          "title": "Embed stated goals into the derived index",
+          "why": "Goals were the last uncovered derived type: measured on a live node 2026-09-03, 1,548 user_goals + 68 Goal objects carried the owner's own prose and NONE were embedded, so 'what am I trying to achieve commercially?' reached a GitHub dossier and a stray fact while the goals sat one table away. The index pass is incremental by content hash, so this embeds only the newly-renderable goal objects; dossiers, facts and edges are unchanged.",
+          "cost": "seconds",
+          "consent": "auto",
+          "params": {
+            "targets": [
+              "derived_object_index"
+            ]
+          }
+        }
+      ],
+      "notes": []
+    },
+    {
+      "version": "1.3.48",
+      "summary": "Release 1.3.48.",
+      "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.46 → topos_node-1.3.48/topos_node.egg-info}/PKG-INFO

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