topos-node 1.0.7__tar.gz → 1.0.8__tar.gz

{topos_node-1.0.7 → topos_node-1.0.8}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.0.7"
+version = "1.0.8"
 description = "Topos personal AI engine (FastAPI): local data, sync, control plane WebSocket client"
 readme = "README.md"
 license = "Apache-2.0"
@@ -89,6 +89,15 @@ markers = [
   "public: public-safe test lane for OSS CI",
   "private: internal architecture or fixtures; excluded from public CI",
   "e2e: end-to-end tests (live Keycloak + Control Plane; require config and running CP)",
+  "live: requires a running local engine (localhost:9000) and a real TOPOS_KEY; excluded from deterministic lanes",
+  "release_pressure: iteration-4 live pressure smoke; run explicitly before releases",
+  "p0: priority marker on release pressure tests",
+  "retrieval_eval: dense-intelligence retrieval eval (loads local embedding model; run explicitly)",
+  "adversarial: scope-break / access-control adversarial test (privacy enforcement)",
+  "uar: unauthorized-access-rate probe (privacy claim #1); tier-1 CI gate, must find zero leaks",
+  "cer: canary-extraction-rate probe (privacy claim #2); tier-1 CI gate",
+  "eval_nightly: statistical privacy eval (attacker advantage, minimality, latency); nightly",
+  "eval_release: release-tier privacy eval (negotiation A/B, Pareto); run per release",
 ]
 pythonpath = ["tests/gap/p3/engine", "tests/gap/p4/engine", "tests/gap/qq/engine", "tests/acceptance/wiki_mvp"]
 testpaths = ["tests"]

topos_node-1.0.8/tests/test_protocol_handled_types.py

@@ -0,0 +1,70 @@
+"""Guards for the handled-message-types protocol snapshot.
+
+The snapshot (topos/protocol/handled_message_types.json) is the machine-readable
+list of control-plane message types this engine dispatches. Two invariants:
+
+1. Freshness — the committed snapshot equals the runtime HANDLERS registry.
+   Adding or removing an @handles registration requires regenerating it:
+   uv run python scripts/dump_handled_types.py > topos/protocol/handled_message_types.json
+
+2. Static parity — the set of string literals in @handles(...) decorators equals
+   the runtime registry, so no handler is registered dynamically in a way that
+   static consumers of the snapshot (or this repo's source) would miss.
+"""
+from __future__ import annotations
+
+import ast
+import json
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+SNAPSHOT = REPO_ROOT / "topos" / "protocol" / "handled_message_types.json"
+
+
+def _runtime_handled() -> set[str]:
+    from topos.core.handlers import HANDLERS
+
+    return set(HANDLERS)
+
+
+def _static_handled() -> set[str]:
+    found: set[str] = set()
+    for py in sorted((REPO_ROOT / "topos").rglob("*.py")):
+        if "__pycache__" in py.parts:
+            continue
+        try:
+            tree = ast.parse(py.read_text(encoding="utf-8"))
+        except SyntaxError:
+            continue
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Call) and getattr(node.func, "id", "") == "handles":
+                for arg in node.args:
+                    if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+                        found.add(arg.value)
+    return found
+
+
+def test_snapshot_matches_runtime_registry():
+    snapshot = set(json.loads(SNAPSHOT.read_text(encoding="utf-8"))["handled_message_types"])
+    runtime = _runtime_handled()
+    missing = sorted(runtime - snapshot)
+    stale = sorted(snapshot - runtime)
+    assert not missing and not stale, (
+        "topos/protocol/handled_message_types.json is stale "
+        f"(missing={missing}, stale={stale}). Regenerate with: "
+        "uv run python scripts/dump_handled_types.py > topos/protocol/handled_message_types.json"
+    )
+
+
+def test_static_handles_literals_match_runtime_registry():
+    runtime = _runtime_handled()
+    static = _static_handled()
+    dynamic_only = sorted(runtime - static)
+    unregistered = sorted(static - runtime)
+    assert not dynamic_only, (
+        "Handlers registered without a literal @handles(...) decorator; static "
+        f"consumers of the registry cannot see them: {dynamic_only}"
+    )
+    assert not unregistered, (
+        f"@handles(...) literals that never reach the runtime registry: {unregistered}"
+    )

{topos_node-1.0.7 → topos_node-1.0.8}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.0.7"
-__version_info__ = (1, 0, 7)
+__version__ = "1.0.8"
+__version_info__ = (1, 0, 8)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.0.7 → topos_node-1.0.8}/topos/api/ingestion_sources.py

@@ -12,6 +12,7 @@ from ..auth import require_api_key
 from ..core.state import get_db_connection
 from ..ingestion.ingest_helpers import ingest_file_payload, ingest_ui_payload, resolve_file_format
 from ..ingestion.local_sync import run_imessage_sync, run_signal_sync, run_signal_upload
+from ..sources.definitions import DELIVERY_LOCAL_SYNC, accepts_app_ingest, is_file_delivery
 from ..sources.registry import REGISTRY
 from ..storage.signal_identity import get_signal_identity, put_signal_identity
 from ..storage.source_settings import get_source_settings, put_source_settings, update_sync_result
@@ -55,7 +56,7 @@ async def ingest_source(
     if not source:
         return {"status": "error", "error": "unknown source_id"}
 
-    if source.source_type == "file":
+    if is_file_delivery(source):
         file = None
         if request.headers.get("content-type", "").startswith("multipart/"):
             form = await request.form()
@@ -108,7 +109,7 @@ async def ingest_source(
             file_format=resolve_file_format(source_definition=source),
         )
 
-    if source.source_type == "ui_stream":
+    if accepts_app_ingest(source):
         if payload is None:
             try:
                 payload = await request.json()
@@ -123,7 +124,7 @@ async def ingest_source(
             source_id=source_id,  # Pass source_id to enable direct processing
         )
 
-    if source.source_type == "local_sync":
+    if source.delivery == DELIVERY_LOCAL_SYNC:
         # iMessage, Signal: ingestion is via sync endpoint (POST /sources/{source_id}/sync), not file/body upload
         return {
             "status": "error",
@@ -161,7 +162,7 @@ async def put_source_settings_endpoint(
     source = REGISTRY.get(source_id)
     if not source:
         return {"status": "error", "error": "unknown source_id"}
-    if source.source_type != "local_sync":
+    if source.delivery != DELIVERY_LOCAL_SYNC:
         return {"status": "error", "error": "settings only apply to local_sync sources"}
     dataset_id = dataset_id or (body.get("dataset_id") if body else None)
     if not dataset_id:
@@ -186,7 +187,7 @@ async def sync_source(
     source = REGISTRY.get(source_id)
     if not source:
         return {"status": "error", "error": "unknown source_id"}
-    if source.source_type != "local_sync":
+    if source.delivery != DELIVERY_LOCAL_SYNC:
         return {"status": "error", "error": "sync endpoint only applies to local_sync sources"}
 
     if not dataset_id:
@@ -315,7 +316,7 @@ async def get_source_contacts(
     source = REGISTRY.get(source_id)
     if not source:
         return {"status": "error", "error": "unknown source_id"}
-    if source.source_type != "local_sync":
+    if source.delivery != DELIVERY_LOCAL_SYNC:
         return {"status": "error", "error": "contacts only apply to local_sync sources"}
     if not dataset_id:
         return {"status": "error", "error": "dataset_id required"}
@@ -368,7 +369,7 @@ async def put_source_contact(
     source = REGISTRY.get(source_id)
     if not source:
         return {"status": "error", "error": "unknown source_id"}
-    if source.source_type != "local_sync":
+    if source.delivery != DELIVERY_LOCAL_SYNC:
         return {"status": "error", "error": "contacts only apply to local_sync sources"}
     if not dataset_id:
         return {"status": "error", "error": "dataset_id required"}
@@ -395,7 +396,7 @@ async def auto_resolve_source_contacts(
     source = REGISTRY.get(source_id)
     if not source:
         return {"status": "error", "error": "unknown source_id"}
-    if source.source_type != "local_sync":
+    if source.delivery != DELIVERY_LOCAL_SYNC:
         return {"status": "error", "error": "contacts only apply to local_sync sources"}
     if not dataset_id:
         return {"status": "error", "error": "dataset_id required"}

topos_node-1.0.8/topos/api/intelligence_lifecycle.py

@@ -0,0 +1,98 @@
+"""Owner data-control API: exclude artifacts from derived intelligence.
+
+These endpoints are the "remove things I don't want included" surface:
+  GET    /intelligence/exclusions            — list tombstones
+  POST   /intelligence/exclusions/fact       — soft-close + tombstone a fact
+  POST   /intelligence/exclusions/entity     — stop tracking an entity
+  POST   /intelligence/exclusions/stat       — suppress a stat insight
+  POST   /intelligence/exclusions/record     — purge one record's derived traces
+  DELETE /intelligence/exclusions            — lift a tombstone (re-inclusion
+                                               happens on the next enrichment)
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from fastapi import APIRouter, Body, Depends, HTTPException
+
+from ..auth import require_api_key
+from ..core.state import get_db_connection
+
+router = APIRouter(tags=["intelligence-lifecycle"])
+
+
+def _store():
+    conn = get_db_connection()
+    if conn is None:
+        raise HTTPException(status_code=503, detail="Database not available")
+    from ..features.lifecycle.exclusions import ExclusionStore
+
+    return ExclusionStore(conn)
+
+
+@router.get("/intelligence/exclusions", dependencies=[Depends(require_api_key)])
+async def list_exclusions(artifact_type: Optional[str] = None) -> Dict[str, Any]:
+    items = _store().list(artifact_type=artifact_type)
+    return {"items": items, "total": len(items)}
+
+
+@router.post("/intelligence/exclusions/fact", dependencies=[Depends(require_api_key)])
+async def exclude_fact(
+    subject_entity_id: str = Body(...),
+    predicate: str = Body(...),
+    object_value: Optional[str] = Body(None),
+    note: Optional[str] = Body(None),
+) -> Dict[str, Any]:
+    try:
+        return _store().exclude_fact(
+            subject_entity_id=subject_entity_id,
+            predicate=predicate,
+            object_value=object_value,
+            note=note,
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/intelligence/exclusions/entity", dependencies=[Depends(require_api_key)])
+async def exclude_entity(
+    entity_ref: str = Body(..., description="entity_id or name"),
+    note: Optional[str] = Body(None),
+) -> Dict[str, Any]:
+    try:
+        return _store().exclude_entity(entity_ref=entity_ref, note=note)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/intelligence/exclusions/stat", dependencies=[Depends(require_api_key)])
+async def exclude_stat_insight(
+    stat_id: str = Body(...),
+    group_key: str = Body(""),
+    note: Optional[str] = Body(None),
+) -> Dict[str, Any]:
+    try:
+        return _store().exclude_stat_insight(stat_id=stat_id, group_key=group_key, note=note)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/intelligence/exclusions/record", dependencies=[Depends(require_api_key)])
+async def exclude_record(
+    record_id: str = Body(...),
+    note: Optional[str] = Body(None),
+) -> Dict[str, Any]:
+    try:
+        return _store().exclude_record(record_id=record_id, note=note)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.delete("/intelligence/exclusions", dependencies=[Depends(require_api_key)])
+async def remove_exclusion(
+    artifact_type: str = Body(...),
+    artifact_key: str = Body(...),
+) -> Dict[str, Any]:
+    removed = _store().remove_exclusion(artifact_type, artifact_key)
+    return {"removed": removed}

{topos_node-1.0.7 → topos_node-1.0.8}/topos/api/signal.py

@@ -197,6 +197,188 @@ async def evaluate_fit(body: FitEvaluateBody, _api_key: str = Depends(require_ap
         raise HTTPException(status_code=503, detail=str(exc)) from exc
 
 
+def _entities_conn():
+    from ..core.state import get_db_connection
+
+    conn = get_db_connection()
+    if conn is None:
+        raise HTTPException(status_code=503, detail="database_unavailable")
+    return conn
+
+
+@router.get("/entities")
+async def list_entities(
+    q: Optional[str] = Query(default=None, max_length=200),
+    entity_type: Optional[str] = Query(default=None, max_length=40),
+    contacts_only: bool = Query(default=False),
+    limit: int = Query(default=50, ge=1, le=200),
+    offset: int = Query(default=0, ge=0),
+    _api_key: str = Depends(require_api_key),
+):
+    """Resolved entity registry (entity spine), sorted by mention count."""
+    from ..features.entities.reads import list_entities as _list
+
+    return _list(
+        _entities_conn(),
+        q=q,
+        entity_type=entity_type,
+        contacts_only=contacts_only,
+        limit=limit,
+        offset=offset,
+    )
+
+
+# NB: must be declared before /entities/{entity_id} so "graph" isn't captured
+# as an entity id.
+@router.get("/entities/graph")
+async def get_entity_graph(
+    limit_nodes: int = Query(default=100, ge=1, le=500),
+    limit_edges: int = Query(default=300, ge=1, le=1500),
+    min_weight: float = Query(default=0.0, ge=0.0),
+    _api_key: str = Depends(require_api_key),
+):
+    """Entity-spine graph (decayed typed edges) in list_graph node/edge shape."""
+    from ..features.entities.reads import entity_graph
+
+    return entity_graph(
+        _entities_conn(),
+        limit_nodes=limit_nodes,
+        limit_edges=limit_edges,
+        min_weight=min_weight,
+    )
+
+
+@router.get("/entities/{entity_id}")
+async def get_entity(
+    entity_id: str,
+    _api_key: str = Depends(require_api_key),
+):
+    """Entity detail: aliases, connections, recent mentions, dossier (owner view)."""
+    from ..features.entities.reads import get_entity_detail
+
+    detail = get_entity_detail(_entities_conn(), entity_id)
+    if detail is None:
+        raise HTTPException(status_code=404, detail=f"entity not found: {entity_id}")
+    return detail
+
+
+@router.get("/entity-review")
+async def list_entity_review(
+    status: str = Query(default="pending", max_length=20),
+    limit: int = Query(default=100, ge=1, le=500),
+    _api_key: str = Depends(require_api_key),
+):
+    """Pending entity merge candidates (owner curation queue)."""
+    from ..features.entities.consolidation import list_review
+
+    items = list_review(_entities_conn(), status=status, limit=limit)
+    return {"items": items, "total": len(items)}
+
+
+@router.post("/entity-review/sweep")
+async def run_entity_review_sweep(_api_key: str = Depends(require_api_key)):
+    """Run the consolidation sweep now; returns proposal counts."""
+    from ..features.entities.consolidation import propose_merges
+
+    return propose_merges(_entities_conn())
+
+
+@router.post("/entity-review/{review_id}/approve")
+async def approve_entity_review(review_id: str, _api_key: str = Depends(require_api_key)):
+    from ..features.entities.consolidation import resolve_review
+
+    try:
+        return resolve_review(_entities_conn(), review_id, action="approve")
+    except LookupError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/entity-review/{review_id}/dismiss")
+async def dismiss_entity_review(review_id: str, _api_key: str = Depends(require_api_key)):
+    from ..features.entities.consolidation import resolve_review
+
+    try:
+        return resolve_review(_entities_conn(), review_id, action="dismiss")
+    except LookupError as exc:
+        raise HTTPException(status_code=404, detail=str(exc))
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.post("/entities/{entity_id}/exclude")
+async def exclude_entity_from_intelligence(
+    entity_id: str,
+    _api_key: str = Depends(require_api_key),
+):
+    """Owner exclusion: stop tracking this entity (tombstoned, reversible)."""
+    from ..features.lifecycle.exclusions import ExclusionStore
+
+    try:
+        return ExclusionStore(_entities_conn()).exclude_entity(entity_ref=entity_id)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
+
+
+@router.get("/facts")
+async def list_facts(
+    predicate: Optional[str] = Query(default=None, max_length=80),
+    dimension: Optional[str] = Query(default=None, max_length=40),
+    include_closed: bool = Query(default=False),
+    limit: int = Query(default=100, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+    _api_key: str = Depends(require_api_key),
+):
+    """Atomic owner facts with temporal validity (belief history via include_closed)."""
+    from ..features.facts.reads import list_facts as _list
+
+    return _list(
+        _entities_conn(),
+        predicate=predicate,
+        dimension=dimension,
+        include_closed=include_closed,
+        limit=limit,
+        offset=offset,
+    )
+
+
+@router.get("/insights")
+async def list_stat_insights(
+    dimension: Optional[str] = Query(default=None, max_length=40),
+    limit: int = Query(default=200, ge=1, le=500),
+    _api_key: str = Depends(require_api_key),
+):
+    """Promoted statistical insights (owner-only rhythms, session stats, trends)."""
+    from ..features.facts.reads import list_stat_insights as _list
+
+    return _list(_entities_conn(), dimension=dimension, limit=limit)
+
+
+@router.get("/timeline")
+async def list_timeline(
+    canonical_table: Optional[str] = Query(default=None, max_length=60),
+    source_id: Optional[str] = Query(default=None, max_length=120),
+    date_from: Optional[str] = Query(default=None, max_length=32),
+    date_to: Optional[str] = Query(default=None, max_length=32),
+    limit: int = Query(default=100, ge=1, le=500),
+    offset: int = Query(default=0, ge=0),
+    _api_key: str = Depends(require_api_key),
+):
+    """Unified temporal projection across canonical tables (newest first)."""
+    from ..features.facts.reads import list_timeline as _list
+
+    return _list(
+        _entities_conn(),
+        canonical_table=canonical_table,
+        source_id=source_id,
+        date_from=date_from,
+        date_to=date_to,
+        limit=limit,
+        offset=offset,
+    )
+
+
 @router.get("/definitions")
 async def list_signal_definitions(_api_key: str = Depends(require_api_key)):
     service = get_signal_service()

{topos_node-1.0.7 → topos_node-1.0.8}/topos/api/source_install.py

@@ -183,12 +183,21 @@ async def _test_ingestion_core(payload: Dict[str, Any]) -> Dict[str, Any]:
     if not source_def:
         raise LookupError(f"No active install found for source_id={source_id}")
 
+    from ..sources.definitions import (
+        DELIVERY_CLIENT_PUSH,
+        DELIVERY_OWNER_UI,
+        DELIVERY_OWNER_UPLOAD,
+        derive_delivery,
+    )
+
     source_type = str(source_def.get("source_type") or "file")
+    # Installed definitions serialized before the delivery rollout lack the field.
+    delivery = str(source_def.get("delivery") or "").strip() or derive_delivery(source_type, source_id)
     schema_id = str(source_def.get("schema_id") or source_def.get("parser_id") or "").strip()
     if not schema_id:
         raise ValueError("Installed source definition is missing schema_id/parser_id")
 
-    if source_type == "file":
+    if delivery == DELIVERY_OWNER_UPLOAD:
         file_path = str(payload.get("sample_file_path") or "").strip()
         if not file_path:
             raise ValueError("sample_file_path is required for file source tests")
@@ -198,7 +207,7 @@ async def _test_ingestion_core(payload: Dict[str, Any]) -> Dict[str, Any]:
             file_path=file_path,
             source_id=source_id,
         )
-    elif source_type == "ui_stream":
+    elif delivery in (DELIVERY_CLIENT_PUSH, DELIVERY_OWNER_UI):
         sample_payload = payload.get("sample_payload")
         if not isinstance(sample_payload, dict):
             raise ValueError("sample_payload object is required for ui_stream source tests")

{topos_node-1.0.7 → topos_node-1.0.8}/topos/app.py

@@ -24,6 +24,7 @@ from .api import (
     ingestion_compat as ingestion_compat_routes,
     ingestion_api as ingestion_routes,
     ingestion_sources as ingestion_sources_routes,
+    intelligence_lifecycle as intelligence_lifecycle_routes,
     local_mcp as local_mcp_routes,
     llm as llm_routes,
     messenger_analytics as messenger_analytics_routes,
@@ -101,6 +102,7 @@ app.include_router(analytics_routes.router)
 app.include_router(sources_routes.router)
 app.include_router(source_install_routes.router, prefix="/v1")
 app.include_router(source_scrub_routes.router, prefix="/v1")
+app.include_router(intelligence_lifecycle_routes.router, prefix="/v1")
 app.include_router(app_registry_routes.router)
 app.include_router(ingestion_compat_routes.router)
 app.include_router(enrichment_routes.router, prefix="/v1")

{topos_node-1.0.7 → topos_node-1.0.8}/topos/config/settings.py

@@ -100,6 +100,10 @@ class Settings(BaseSettings):
     engine_ollama_base_url: str = Field("http://localhost:11434", env="ENGINE_OLLAMA_BASE_URL")
     ollama_query_model: str = Field("llama3.2:latest", env="TOPOS_OLLAMA_QUERY_MODEL")
     engine_default_provider: str = Field("huggingface", env="ENGINE_DEFAULT_PROVIDER")
+    # §D minimizer runs on EVERY grantee query, so it uses a small/fast local model. The judge
+    # only runs in nightly privacy evals (F.4/CER semantic scoring), so it can be larger/slower.
+    disclosure_minimizer_model: str = Field("llama3.2:latest", env="TOPOS_DISCLOSURE_MINIMIZER_MODEL")
+    privacy_judge_model: str = Field("qwen3.5:9b-mlx", env="TOPOS_PRIVACY_JUDGE_MODEL")
 
     engine_max_resident_models: int = Field(3, env="ENGINE_MAX_RESIDENT_MODELS")
     engine_model_idle_ttl_sec: int = Field(0, env="ENGINE_MODEL_IDLE_TTL_SEC")

{topos_node-1.0.7 → topos_node-1.0.8}/topos/control_plane_client.py

@@ -319,6 +319,14 @@ class ControlPlaneClient:
             return False
 
     async def _handle_message(self, ws, data: Dict[str, Any]) -> None:
+        msg_type = str(data.get("type") or "").strip().lower()
+        if msg_type == "ping":
+            pong: Dict[str, Any] = {"type": "pong"}
+            ping_id = data.get("id")
+            if ping_id is not None:
+                pong["id"] = ping_id
+            await self._send_ws_json(ws, pong)
+            return
         try:
             resp = await self.handler(data)
         except Exception as exc:  # noqa: BLE001