topos-node 1.3.2__tar.gz → 1.3.4__tar.gz

{topos_node-1.3.2/topos_node.egg-info → topos_node-1.3.4}/PKG-INFO

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

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

{topos_node-1.3.2 → topos_node-1.3.4}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.2"
-__version_info__ = (1, 3, 2)
+__version__ = "1.3.4"
+__version_info__ = (1, 3, 4)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.2 → topos_node-1.3.4}/topos/api/enrichment.py

@@ -572,19 +572,33 @@ async def _generic_backfill_core(
                     "errors": [],
                 }
         else:
+            from ..enrichment.catalog import catalog_spec_version
+
             coverage_table = coverage_table_for_job(job_name)
             if coverage_table and _table_exists(db_conn, coverage_table):
                 cols = _table_columns(db_conn, coverage_table)
                 id_col = "message_id" if "message_id" in cols else "record_id"
                 if "source_id" in cols and id_col in cols:
-                    done = {
-                        str(row[0])
-                        for row in db_conn.execute(
-                            f"SELECT DISTINCT {id_col} FROM {coverage_table} WHERE source_id=?",
-                            (source_id,),
-                        ).fetchall()
-                        if row[0]
-                    }
+                    min_spec = catalog_spec_version(job_name)
+                    if "spec_version" in cols:
+                        done = {
+                            str(row[0])
+                            for row in db_conn.execute(
+                                f"SELECT DISTINCT {id_col} FROM {coverage_table} "
+                                f"WHERE source_id=? AND COALESCE(spec_version, 0) >= ?",
+                                (source_id, min_spec),
+                            ).fetchall()
+                            if row[0]
+                        }
+                    else:
+                        done = {
+                            str(row[0])
+                            for row in db_conn.execute(
+                                f"SELECT DISTINCT {id_col} FROM {coverage_table} WHERE source_id=?",
+                                (source_id,),
+                            ).fetchall()
+                            if row[0]
+                        }
                     records = [r for r in records if _record_identifier(r) not in done]
 
     if isinstance(limit, int) and limit > 0:
@@ -650,13 +664,45 @@ async def _generic_backfill_core(
     }
 
 
-def _get_enriched_message_ids(table_name: str, conn) -> set[str]:
-    """Get set of message_ids that have enrichment records in the given table."""
+def _get_enriched_message_ids(
+    table_name: str,
+    conn,
+    *,
+    min_spec_version: Optional[int] = None,
+) -> set[str]:
+    """Ids that already satisfy coverage for ``table_name``.
+
+    When ``min_spec_version`` is set and the table has ``spec_version``, only
+    rows with ``COALESCE(spec_version, 0) >= min_spec_version`` count as done
+    (PLAN M3 stale predicate). Otherwise presence-only.
+    """
     if not conn:
         return set()
     try:
-        cursor = conn.execute(f"SELECT DISTINCT message_id FROM {table_name}")
-        return {row[0] for row in cursor.fetchall()}
+        cols = _table_columns(conn, table_name)
+        if not cols:
+            return set()
+        if "message_id" in cols and "record_id" in cols:
+            id_expr = "COALESCE(message_id, record_id)"
+        elif "message_id" in cols:
+            id_expr = "message_id"
+        elif "record_id" in cols:
+            id_expr = "record_id"
+        else:
+            return set()
+        if (
+            min_spec_version is not None
+            and "spec_version" in cols
+            and isinstance(min_spec_version, int)
+        ):
+            cursor = conn.execute(
+                f"SELECT DISTINCT {id_expr} FROM {table_name} "
+                f"WHERE COALESCE(spec_version, 0) >= ?",
+                (int(min_spec_version),),
+            )
+        else:
+            cursor = conn.execute(f"SELECT DISTINCT {id_expr} FROM {table_name}")
+        return {str(row[0]) for row in cursor.fetchall() if row[0]}
     except Exception as e:
         logger.warning("Failed to query enriched message IDs from %s: %s", table_name, e)
         return set()
@@ -758,12 +804,18 @@ async def _find_unprocessed_messages(
         db_conn, source_def, dataset_id=dataset_id
     )
     if generic_messages:
+        from ..enrichment.catalog import catalog_spec_version
+
         enriched: Optional[set[str]] = None
         job_table_map = {job.get_job_name(): job.get_derived_table() for job in CANONICAL_JOBS}
         for job_name in jobs_to_check:
             table_name = job_table_map.get(job_name)
             if table_name:
-                job_ids = _get_enriched_message_ids(table_name, db_conn)
+                job_ids = _get_enriched_message_ids(
+                    table_name,
+                    db_conn,
+                    min_spec_version=catalog_spec_version(job_name),
+                )
                 enriched = job_ids if enriched is None else (enriched & job_ids)
             else:
                 logger.warning("Unknown enrichment job: %s (skipping check)", job_name)
@@ -947,6 +999,8 @@ async def _find_unprocessed_messages(
     # row for it (intersection). The previous union behavior skipped messages
     # that had been enriched by any single job, leaving partial enrichment
     # permanently un-backfillable.
+    from ..enrichment.catalog import catalog_spec_version
+
     enriched_ids: Optional[set[str]] = None
     # Create a mapping from job name to table name using the job registry
     job_to_table = {job.get_job_name(): job.get_derived_table() for job in CANONICAL_JOBS}
@@ -954,7 +1008,11 @@ async def _find_unprocessed_messages(
     for job_name in jobs_to_check:
         table_name = job_to_table.get(job_name)
         if table_name:
-            job_ids = _get_enriched_message_ids(table_name, db_conn)
+            job_ids = _get_enriched_message_ids(
+                table_name,
+                db_conn,
+                min_spec_version=catalog_spec_version(job_name),
+            )
             enriched_ids = job_ids if enriched_ids is None else (enriched_ids & job_ids)
         else:
             logger.warning("Unknown enrichment job: %s (skipping check)", job_name)

topos_node-1.3.4/topos/api/upgrades.py

@@ -0,0 +1,55 @@
+"""Upgrade status + consent surface for schema/derived migration steps.
+
+The UI shows "Upgrading your intelligence…" while auto steps run, and prompts
+for ``pending_consent`` slow-lane steps (PLAN_NODE_RELEASE_MIGRATIONS M3).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from pydantic import BaseModel, Field
+
+from ..auth import require_api_key
+
+router = APIRouter()
+
+
+def _status_payload() -> Dict[str, Any]:
+    from ..core.state import get_db_connection
+    from ..features.entities.graph_refresh import status as refresh_status
+    from ..upgrades.runner import runner_status
+
+    conn = get_db_connection()
+    upgrade = runner_status(conn) if conn is not None else {"enabled": False, "error": "no database"}
+    return {"upgrade": upgrade, "graph_refresh": refresh_status()}
+
+
+@router.get("/v1/upgrade/status", dependencies=[Depends(require_api_key)])
+async def get_upgrade_status() -> Dict[str, Any]:
+    return _status_payload()
+
+
+class UpgradeConsentBody(BaseModel):
+    step_id: str = Field(..., min_length=1)
+    # Optional: run the step immediately after consent (default true).
+    run_now: bool = True
+
+
+@router.post("/v1/upgrade/consent", dependencies=[Depends(require_api_key)])
+async def post_upgrade_consent(body: UpgradeConsentBody) -> Dict[str, Any]:
+    from ..core.state import get_db_connection
+    from ..upgrades.runner import consent_upgrade_step, run_pending_upgrades
+
+    conn = get_db_connection()
+    if conn is None:
+        raise HTTPException(status_code=503, detail="database unavailable")
+    try:
+        result = consent_upgrade_step(conn, body.step_id.strip())
+    except ValueError as exc:
+        raise HTTPException(status_code=404, detail=str(exc)) from exc
+    run_result: Optional[Dict[str, Any]] = None
+    if body.run_now:
+        run_result = run_pending_upgrades(conn)
+    return {"status": "ok", "consent": result, "run": run_result, **_status_payload()}

{topos_node-1.3.2 → topos_node-1.3.4}/topos/cli/commands.py

@@ -307,6 +307,28 @@ def main(db_path, topos_key, set_topos_key, discover, port, host, skip_update_ch
     start_background_housekeeping()
 
     _emit_startup_banner(host=host, port=port)
+    try:
+        from topos.core.state import get_db_connection
+        from topos.upgrades.runner import runner_status
+
+        _conn = get_db_connection()
+        if _conn is not None:
+            _pending = (runner_status(_conn).get("pending_consent_steps") or [])
+            if _pending:
+                click.echo("")
+                click.echo("Upgrade steps waiting for your consent:")
+                for step in _pending:
+                    click.echo(
+                        f"  • {step.get('id')}: {step.get('title') or step.get('why') or ''}"
+                        f" (cost={step.get('cost') or 'slow'})"
+                    )
+                click.echo(
+                    "Approve with: POST /v1/upgrade/consent {\"step_id\": \"...\"} "
+                    "or the Engine settings banner."
+                )
+                click.echo("")
+    except Exception:
+        pass
 
     from topos.cli import tray as tray_module
 

{topos_node-1.3.2 → topos_node-1.3.4}/topos/config/settings.py

@@ -140,6 +140,12 @@ class Settings(BaseSettings):
     sanitization_ollama_host: Optional[str] = Field(None, env="SANITIZATION_OLLAMA_HOST")
     sanitization_ollama_default_model: str = Field("llama3.2", env="SANITIZATION_OLLAMA_DEFAULT_MODEL")
     sanitization_ollama_timeout_sec: float = Field(120.0, env="SANITIZATION_OLLAMA_TIMEOUT_SEC")
+    # llm_generation / routine hops — must cover local thinking models. Do NOT
+    # reuse sanitization_ollama_timeout_sec (120s): that cuts digest synthesis
+    # mid-flight and surfaces as "Ollama unreachable".
+    engine_ollama_generate_timeout_sec: float = Field(
+        300.0, env="ENGINE_OLLAMA_GENERATE_TIMEOUT_SEC"
+    )
     ollama_list_timeout_sec: float = Field(10.0, env="OLLAMA_LIST_TIMEOUT_SEC")
     sanitization_ollama_auto_pull: bool = Field(True, env="SANITIZATION_OLLAMA_AUTO_PULL")
     sanitization_ollama_max_input_chars: int = Field(8000, env="SANITIZATION_OLLAMA_MAX_INPUT_CHARS")

{topos_node-1.3.2 → topos_node-1.3.4}/topos/core/api_models.py

@@ -108,6 +108,11 @@ class DeviceInfoResponse(BaseModel):
     oplog_bytes_since_last_sync: Optional[int] = None
     database_size_bytes: Optional[int] = None
     storage_breakdown: Optional[Dict[str, Any]] = None
+    # Upgrade runner summary (PLAN_NODE_RELEASE_MIGRATIONS M5). Optional for
+    # older clients / hosted paths without a SQLite upgrade ledger.
+    upgrade_baseline: Optional[str] = None
+    pending_upgrade_steps: Optional[List[str]] = None
+    pending_consent_steps: Optional[List[Any]] = None
 
 
 class DeviceNameRequest(BaseModel):

{topos_node-1.3.2 → topos_node-1.3.4}/topos/core/handlers/config.py

@@ -467,6 +467,37 @@ async def handle_get_upgrade_status(message):
         return {"id": req_id, "status": "error", "error": str(exc)}
 
 
+@handles("consent_upgrade_step")
+async def handle_consent_upgrade_step(message):
+    """Approve a pending_consent upgrade step (PLAN M3)."""
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    step_id = str(payload.get("step_id") or "").strip()
+    if not step_id:
+        return {"id": req_id, "status": "error", "error": "step_id required"}
+    run_now = bool(payload.get("run_now", True))
+    try:
+        from ...core.state import get_db_connection
+        from ...upgrades.runner import consent_upgrade_step, run_pending_upgrades
+
+        conn = get_db_connection()
+        if conn is None:
+            return {"id": req_id, "status": "error", "error": "database unavailable"}
+        result = consent_upgrade_step(conn, step_id)
+        run_result = run_pending_upgrades(conn) if run_now else None
+        return {
+            "id": req_id,
+            "status": "ok",
+            "payload": {"consent": result, "run": run_result},
+        }
+    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("get_exposure_profile_config")
 async def handle_get_exposure_profile_config(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     req_id = message.get("id")

{topos_node-1.3.2 → topos_node-1.3.4}/topos/core/handlers/signal_features.py

@@ -993,3 +993,43 @@ async def handle_signal_set_worn_badge(message: Dict[str, Any]) -> Optional[Dict
         return {"id": req_id, "status": "ok", "payload": {"worn": worn_badge(conn)}}
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("signal_pin_intent")
+async def handle_signal_pin_intent(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    try:
+        from ...features.triage.intents import active_intents, pin_intent
+
+        intent_text = str(payload.get("intent_text") or "").strip()
+        if not intent_text:
+            raise ValueError("intent_text is required")
+        conn = hub.get_db_connection()
+        pin_intent(
+            conn,
+            intent_text,
+            horizon=payload.get("horizon") or "quarter",
+            links=payload.get("links") or [],
+        )
+        return {"id": req_id, "status": "ok", "payload": {"intents": active_intents(conn)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("signal_retire_intent")
+async def handle_signal_retire_intent(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    if not req_id:
+        return None
+    payload = message.get("payload") or {}
+    try:
+        from ...features.triage.intents import active_intents, retire_intent
+
+        conn = hub.get_db_connection()
+        retire_intent(conn, payload.get("object_key") or "")
+        return {"id": req_id, "status": "ok", "payload": {"intents": active_intents(conn)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

{topos_node-1.3.2 → topos_node-1.3.4}/topos/core/state.py

@@ -293,11 +293,37 @@ def get_db_connection() -> Optional[sqlite3.Connection]:
         except Exception as tuning_exc:  # noqa: BLE001
             logger.warning("Connection tuning skipped: %s", tuning_exc)
         try:
-            from ..storage.db.migrations import ensure_migrations_applied
+            from ..storage.db.migrations import (
+                DowngradeGuardError,
+                MigrationError,
+                ensure_migrations_applied,
+            )
 
             ensure_migrations_applied(db_conn)
+        except (MigrationError, DowngradeGuardError) as migration_exc:
+            # Shape migrations must fail loud — serving a half-migrated DB corrupts data.
+            logger.error("Schema migration failed; refusing to open database: %s", migration_exc)
+            try:
+                db_conn.close()
+            except Exception:  # noqa: BLE001
+                pass
+            db_conn = None
+            _db_conn_path = None
+            raise
         except Exception as migration_exc:  # noqa: BLE001
-            logger.warning("Wiki MVP migrations skipped on startup: %s", migration_exc)
+            from ..storage.db.migrations import MigrationError as _MigrationError
+
+            logger.error(
+                "Unexpected schema migration failure; refusing to open database: %s",
+                migration_exc,
+            )
+            try:
+                db_conn.close()
+            except Exception:  # noqa: BLE001
+                pass
+            db_conn = None
+            _db_conn_path = None
+            raise _MigrationError(str(migration_exc)) from migration_exc
         try:
             from ..storage.raw.browser_flat_tables import backfill_browser_visits_from_raw_retention
 
@@ -306,6 +332,12 @@ def get_db_connection() -> Optional[sqlite3.Connection]:
             logger.debug("browser_visits raw→flat backfill skipped: %s", backfill_exc)
         return db_conn
     except Exception as e:
+        # Shape-migration failures must propagate (fail loud). Only soft-fail
+        # unrelated connection errors so callers can treat conn=None as "no DB".
+        from ..storage.db.migrations import DowngradeGuardError, MigrationError
+
+        if isinstance(e, (MigrationError, DowngradeGuardError)):
+            raise
         logger.warning("Failed to create database connection: %s", e)
         db_conn = None
         _db_conn_path = None

{topos_node-1.3.2 → topos_node-1.3.4}/topos/enrichment/catalog.py

@@ -15,7 +15,7 @@ from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Tuple
 
 from .jobs import CANONICAL_JOBS, RAW_JOBS, SIGNAL_JOB_REGISTRY
-from .models.mvp_defaults import MVP_JOB_SPECS
+from .models.mvp_defaults import MVP_JOB_SPECS, job_spec_version
 
 LANE_RAW = "raw"
 LANE_CANONICAL = "canonical"
@@ -48,6 +48,8 @@ class EnrichmentCatalogEntry:
     # Raw-lane stubs that currently produce no output.
     stub: bool = False
     value_props: Tuple[str, ...] = field(default_factory=tuple)
+    # Output-contract version; bump when prior coverage rows are stale (M3).
+    spec_version: int = 1
 
     def to_dict(self) -> Dict[str, Any]:
         return {
@@ -66,6 +68,7 @@ class EnrichmentCatalogEntry:
             "baseline": self.baseline,
             "stub": self.stub,
             "value_props": list(self.value_props),
+            "spec_version": int(self.spec_version),
         }
 
 
@@ -334,10 +337,19 @@ def _build_catalog() -> Dict[str, EnrichmentCatalogEntry]:
             baseline=job_id in baseline,
             stub=is_stub,
             value_props=tuple(meta.get("value_props") or ()),
+            spec_version=job_spec_version(job_id),
         )
     return entries
 
 
+def catalog_spec_version(job_id: str) -> int:
+    """Return the catalog ``spec_version`` for ``job_id`` (default 1)."""
+    entry = get_catalog_entry(job_id)
+    if entry is not None:
+        return int(entry.spec_version)
+    return job_spec_version(job_id)
+
+
 _CATALOG: Optional[Dict[str, EnrichmentCatalogEntry]] = None