topos-node 1.3.47__tar.gz → 1.3.49__tar.gz

{topos_node-1.3.47/topos_node.egg-info → topos_node-1.3.49}/PKG-INFO

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

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

{topos_node-1.3.47 → topos_node-1.3.49}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.47"
-__version_info__ = (1, 3, 47)
+__version__ = "1.3.49"
+__version_info__ = (1, 3, 49)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.47 → topos_node-1.3.49}/topos/engine/backends/ollama.py

@@ -455,13 +455,23 @@ class OllamaAdapter:
                 prompt_tokens = int(data.get("prompt_eval_count") or 0)
                 completion_tokens = int(data.get("eval_count") or 0)
                 total_tokens = prompt_tokens + completion_tokens
+                # This is the DERIVATION lane, and it had no timing signal at
+                # all — no streaming, no heartbeats, no usage rows. It also
+                # alternates models with chat, which evicts weights and pays a
+                # cold load the chat lane then blames on itself. Capture the
+                # same split here so the two lanes are comparable.
+                from topos.services.llm.openai import _ollama_timings
+
+                timings = _ollama_timings(data)
                 return {
                     "text": data.get("response", ""),
                     "usage": {
                         "prompt_tokens": max(0, prompt_tokens),
                         "completion_tokens": max(0, completion_tokens),
                         "total_tokens": max(0, total_tokens),
+                        **({"timings": timings} if timings else {}),
                     },
+                    **({"timings": timings} if timings else {}),
                 }
         except urllib.error.HTTPError as e:
             # Include the response body: Ollama puts the actionable message

{topos_node-1.3.47 → topos_node-1.3.49}/topos/engine/engine.py

@@ -273,7 +273,12 @@ class Engine:
                     origin=origin,
                     source_id=normalized.source_id,
                     duration_ms=duration_ms,
-                    ttfb_ms=duration_ms,
+                    # Engine.run is NON-STREAMING: the whole body arrives at
+                    # once, so there is no first-token moment to measure here.
+                    # Passing duration as ttfb manufactured the sentinel that
+                    # poisoned the column — leave it unset and let the absence
+                    # be visible.
+                    ttfb_ms=None,
                 )
             except Exception:
                 logger.debug("Failed to emit engine llm usage observation", exc_info=True)

{topos_node-1.3.47 → topos_node-1.3.49}/topos/engine/usage_observation.py

@@ -370,9 +370,16 @@ def emit_engine_llm_usage_observation(
         "provider": provider_key,
         "model": model_key,
     }
-    # Non-streaming Engine.run: first token/body arrives with the completed response.
+    # ttfb_ms is RECORDED OR ABSENT — never inferred from duration.
+    #
+    # It used to default to `resolved_duration`, and the result was that 120 of
+    # 135 home-chat rows carried ttfb_ms == duration_ms. Every percentile anyone
+    # computed from that column was a duration percentile wearing a TTFB label,
+    # and the one metric this system is now being tuned for was, in effect, not
+    # measured at all. An honest NULL is a gap you can see; a plausible wrong
+    # number is one you cannot.
     resolved_duration = int(duration_ms) if duration_ms is not None else None
-    resolved_ttfb = int(ttfb_ms) if ttfb_ms is not None else resolved_duration
+    resolved_ttfb = int(ttfb_ms) if ttfb_ms is not None else None
     metadata: Dict[str, Any] = {
         "purpose": purpose,
         "provider": provider_key,

{topos_node-1.3.47 → topos_node-1.3.49}/topos/features/derivation/surfaces.py

@@ -232,6 +232,27 @@ def run_pack_backfill(conn: sqlite3.Connection, pack_id: str, limit: int = 500)
         conn.commit()
     conn.commit()
     stats["quarantined"] = writer.stats.get("quarantined", 0) - stats.pop("quarantined0")
+
+    # A backfill IS a run. Without this the registry keeps last_run_at NULL and
+    # the lens card reads "never run" over a pack that just wrote facts —
+    # observed 2026-09-03 on values.motivation, 73 records in, 11 facts out,
+    # card still blank. mark_pack_run is otherwise only called at the end of an
+    # ingest batch (derivation_job.py:292), which a quiet node may never have.
+    from .registry import mark_pack_run
+    mark_pack_run(conn, pack_id, pack.version)
+
+    # Embed what we just wrote, or the owner can see these facts on the Facts
+    # page and cannot ask about them: the semantic lane reads signal_embeddings,
+    # and the embedding job runs only when an ingest batch happens. Idempotent
+    # and incremental by content hash, so this is cheap when there is nothing
+    # new. Never fatal — the facts are already committed, and a missing
+    # embedding is a degraded answer, not a lost fact.
+    try:
+        from ...features.signal.derived_index import index_derived_objects
+        stats["indexed"] = int(index_derived_objects(conn).get("embedded", 0) or 0)
+    except Exception:  # noqa: BLE001 — see comment above: never fatal
+        stats["indexed"] = -1
+    conn.commit()
     return stats
 
 

{topos_node-1.3.47 → topos_node-1.3.49}/topos/ingestion/ingest_helpers.py

@@ -16,6 +16,40 @@ from ..storage.raw.file_store import RawFileStore
 logger = logging.getLogger("topos.ingestion.ingest_helpers")
 
 
+def chat_ui_raw_payload(payload: dict, *, job_id: str, dataset_id: str) -> dict:
+    """Map a chat UI-stream record to the v1 raw shape {id, thread_id, role, content, created_at}.
+
+    The v1 chat vocabulary — {id, thread_id, role} — is what the file importer,
+    the schema registry, and the browser extension all send. Older store_message
+    callers used {message_id, conversation_id, sender_type}. Read v1 first and
+    fall back to the legacy names, so a client on either vocabulary lands
+    correctly. Reading ONLY the legacy names (the prior behaviour) mislabelled
+    every extension message role=user (sender_type absent), merged every chat
+    under the dataset id (conversation_id absent), and minted a fresh id per
+    record (message_id absent), defeating message-id idempotency.
+    """
+    role = str(payload.get("role") or "").strip()
+    if not role:
+        sender_type = payload.get("sender_type", "human")
+        role = "user" if sender_type == "human" else str(sender_type)
+    created_at = payload.get("created_at")
+    if created_at is None:
+        ts = payload.get("ts")
+        if isinstance(ts, (int, float)):
+            created_at = ts
+        elif isinstance(ts, str):
+            created_at = ts
+        else:
+            created_at = datetime.now(timezone.utc).timestamp()
+    return {
+        "id": str(payload.get("id") or payload.get("message_id") or job_id),
+        "thread_id": payload.get("thread_id") or payload.get("conversation_id") or dataset_id,
+        "role": role,
+        "content": payload.get("content", ""),
+        "created_at": created_at,
+    }
+
+
 def _ui_stream_passes_payload_through(source: Any, source_id: str) -> bool:
     """True when ui_stream ingest should forward the client payload to the source parser."""
     if source_id.startswith("browser_"):
@@ -207,25 +241,7 @@ async def ingest_ui_payload(
     # Legacy path: ChatGPT UI only (backward compatibility when source_id omitted or chatgpt default)
     file_store = RawFileStore()
     job_id = job_id or str(uuid.uuid4())
-    sender_type = payload.get("sender_type", "human")
-    role = "user" if sender_type == "human" else sender_type
-    content = payload.get("content", "")
-    created_at = payload.get("created_at")
-    if created_at is None:
-        ts = payload.get("ts")
-        if isinstance(ts, (int, float)):
-            created_at = ts
-        elif isinstance(ts, str):
-            created_at = ts
-        else:
-            created_at = datetime.now(timezone.utc).timestamp()
-    record = {
-        "id": payload.get("message_id") or job_id,
-        "thread_id": payload.get("conversation_id") or dataset_id,
-        "role": role,
-        "content": content,
-        "created_at": created_at,
-    }
+    record = chat_ui_raw_payload(payload, job_id=job_id, dataset_id=dataset_id)
     logger.info(
         "[PIPELINE:RAW] Appending UI message to raw store: job_id=%s, dataset_id=%s, message_id=%s, content_preview=%s",
         job_id,
@@ -382,25 +398,7 @@ async def _ingest_ui_payload_direct(
             )
         raw_payload.setdefault("record_id", record_id)
     else:
-        sender_type = payload.get("sender_type", "human")
-        role = "user" if sender_type == "human" else sender_type
-        content = payload.get("content", "")
-        created_at = payload.get("created_at")
-        if created_at is None:
-            ts = payload.get("ts")
-            if isinstance(ts, (int, float)):
-                created_at = ts
-            elif isinstance(ts, str):
-                created_at = ts
-            else:
-                created_at = datetime.now(timezone.utc).timestamp()
-        raw_payload = {
-            "id": payload.get("message_id") or job_id,
-            "thread_id": payload.get("conversation_id") or dataset_id,
-            "role": role,
-            "content": content,
-            "created_at": created_at,
-        }
+        raw_payload = chat_ui_raw_payload(payload, job_id=job_id, dataset_id=dataset_id)
         record_id = raw_payload["id"]
     raw_record = RawRecord(record_id=record_id, payload=raw_payload)
 

{topos_node-1.3.47 → topos_node-1.3.49}/topos/protocol/narrowing_vocabulary.json

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

{topos_node-1.3.47 → topos_node-1.3.49}/topos/query/narrowing.py

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

{topos_node-1.3.47 → topos_node-1.3.49}/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.47 → topos_node-1.3.49}/topos/services/llm/openai.py

@@ -181,7 +181,70 @@ async def _ollama_generate(payload: Dict[str, Any]) -> Dict[str, Any]:
             "completion_tokens": completion_tokens,
             "total_tokens": total_tokens,
         }
-    return {"output": text, "model": resp_model, "usage": usage}
+    timings = _ollama_timings(data)
+    if timings:
+        usage = {**usage, "timings": timings}
+    return {"output": text, "model": resp_model, "usage": usage, "timings": timings}
+
+
+#: Nanoseconds-to-milliseconds, rounded to whole ms — the resolution anyone
+#: reasons about latency in. Ollama reports every duration in ns.
+def _ms(value: Any) -> int:
+    try:
+        return int(round(float(value) / 1e6))
+    except (TypeError, ValueError):
+        return 0
+
+
+def _ollama_timings(data: Dict[str, Any]) -> Dict[str, Any]:
+    """Split a generation into load, prefill and decode.
+
+    Ollama puts ``total_duration``, ``load_duration``, ``prompt_eval_duration``
+    and ``eval_duration`` on the SAME terminating JSON object we already read
+    token counts from, and every one of them was being thrown away — at four
+    parse sites, for the whole life of this codebase. A repo-wide search for
+    ``load_duration`` found two hits, both prose in a plan document: it was
+    specified and never built.
+
+    Without the split, "the model was slow" is unanswerable. With it the three
+    causes separate cleanly. Measured on this machine 2026-09-03:
+
+    * ``load`` — weights into memory. Cold 5,695 ms on a 27B, warm 4.7 ms. The
+      544x separation is why ``cold`` below is a threshold and not a guess.
+    * ``prefill`` — reading the prompt. THE one that matters: it IS
+      time-to-first-token, ~65-90 tok/s, and 78 s of a real turn.
+    * ``decode`` — writing the answer, 3.4-10.1 tok/s. Caching cannot touch it.
+
+    ``prefill_cached`` is a prefix-cache hit, and it is deliberately NOT
+    ``prompt_eval_duration == 0``: measured hits ran 74-191 ms on a 3B and
+    ~6,300 ms on a 27B, and ``prompt_eval_count`` still reports the FULL prompt
+    on a hit, so the duration is the only signal there is.
+    """
+    load_ms = _ms(data.get("load_duration"))
+    prefill_ms = _ms(data.get("prompt_eval_duration"))
+    decode_ms = _ms(data.get("eval_duration"))
+    prompt_toks = int(data.get("prompt_eval_count") or 0)
+    completion_toks = int(data.get("eval_count") or 0)
+    timings: Dict[str, Any] = {
+        "load_ms": load_ms,
+        "prefill_ms": prefill_ms,
+        "decode_ms": decode_ms,
+        "total_ms": _ms(data.get("total_duration")),
+        # A cold load is 3 orders of magnitude from a warm one; 1s sits in the
+        # empty middle of that gap rather than near either edge.
+        "cold": load_ms >= 1000,
+    }
+    if prompt_toks and prefill_ms > 0:
+        timings["prefill_tok_s"] = round(prompt_toks * 1000.0 / prefill_ms, 1)
+    if completion_toks and decode_ms > 0:
+        timings["decode_tok_s"] = round(completion_toks * 1000.0 / decode_ms, 1)
+    # A hit still reports the full prompt_eval_count, so infer from the RATE:
+    # anything an order of magnitude above the machine's real prefill speed is
+    # cache reuse, not arithmetic.
+    rate = timings.get("prefill_tok_s")
+    if isinstance(rate, float) and rate > 500.0:
+        timings["prefill_cached"] = True
+    return timings
 
 
 async def _ollama_stream_generate(
@@ -245,6 +308,9 @@ async def _ollama_stream_generate(
     prompt_tokens = 0
     completion_tokens = 0
     done_reason = ""
+    # Stays empty when the stream ends without a terminating frame — a dropped
+    # connection must not raise a NameError on the way out.
+    timings: Dict[str, Any] = {}
     # Liveness (plan §2): phase-aware heartbeats whenever nothing else flows —
     # 10s pre-first-token (load + prefill are silent), 30s mid-stream. Emitted
     # frames of any kind reset the clock.
@@ -306,6 +372,7 @@ async def _ollama_stream_generate(
                         prompt_tokens = int(data.get("prompt_eval_count") or prompt_tokens)
                         completion_tokens = int(data.get("eval_count") or completion_tokens)
                         done_reason = str(data.get("done_reason") or "")
+                        timings = _ollama_timings(data)
     except httpx.RequestError as exc:
         raise HTTPException(
             status_code=status.HTTP_502_BAD_GATEWAY,
@@ -335,6 +402,13 @@ async def _ollama_stream_generate(
             "total_tokens": total_tokens,
         }
     result: Dict[str, Any] = {"output": text, "model": resp_model, "usage": usage}
+    # Nested under usage on purpose: the browser whitelists exactly
+    # output/model/usage (homeLlmStream.ts:415), and the control plane passes
+    # the payload through verbatim (_final_payload, llm_generation_sse.py:353),
+    # so timings reach the UI with NO control-plane change.
+    if timings:
+        result["usage"] = {**usage, "timings": timings}
+        result["timings"] = timings
     if thinking_chars:
         result["thinking_chars"] = thinking_chars
     if done_reason:

{topos_node-1.3.47 → topos_node-1.3.49}/topos/upgrades/manifests.json

@@ -795,16 +795,30 @@
           "id": "index-goals-into-derived-index",
           "kind": "derived_rebuild",
           "title": "Embed stated goals into the derived index",
-          "targets": [
-            "derived_object_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"
+          "consent": "auto",
+          "params": {
+            "targets": [
+              "derived_object_index"
+            ]
+          }
         }
       ],
       "notes": []
     },
+    {
+      "version": "1.3.48",
+      "summary": "Release 1.3.48.",
+      "steps": [],
+      "notes": []
+    },
+    {
+      "version": "1.3.49",
+      "summary": "Release 1.3.49.",
+      "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.47 → topos_node-1.3.49/topos_node.egg-info}/PKG-INFO

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