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

{topos_node-1.3.3/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.3
+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.3 → topos_node-1.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "topos-node"
-version = "1.3.3"
+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.3 → topos_node-1.3.4}/topos/__version__.py

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

{topos_node-1.3.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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.3 → 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
 
 

{topos_node-1.3.3 → topos_node-1.3.4}/topos/enrichment/derived_tables.py

@@ -38,6 +38,18 @@ def _insert_matching_columns(
     )
 
 
+def _record_spec_version(record: Dict[str, Any], job_id: str = "") -> int:
+    raw = record.get("spec_version")
+    if raw is not None:
+        try:
+            return int(raw)
+        except (TypeError, ValueError):
+            pass
+    from .models.mvp_defaults import job_spec_version
+
+    return job_spec_version(job_id or str(record.get("job_id") or ""))
+
+
 class DerivedTablesManager(BaseObject):
     """Manages derived tables for enrichment data."""
 
@@ -210,26 +222,18 @@ class DerivedTablesManager(BaseObject):
                             if isinstance(all_emotions_val, list)
                             else (all_emotions_val if isinstance(all_emotions_val, str) else "[]")
                         )
-                        values.append(
-                            (
-                                record.get("message_id"),
-                                record.get("source_id"),
-                                record.get("emotion_label"),
-                                record.get("confidence"),
-                                record.get("model_name") or record.get("model"),
-                                all_emotions_str,
-                                extracted_at,
-                            )
-                        )
-                    self.conn.executemany(
-                        """
-                        INSERT OR REPLACE INTO message_emotions (
-                            message_id, source_id, emotion_label, confidence,
-                            model_name, all_emotions_json, created_at
-                        ) VALUES (?, ?, ?, ?, ?, ?, ?)
-                        """,
-                        values,
-                    )
+                        row = {
+                            "message_id": record.get("message_id"),
+                            "source_id": record.get("source_id"),
+                            "emotion_label": record.get("emotion_label"),
+                            "confidence": record.get("confidence"),
+                            "model_name": record.get("model_name") or record.get("model"),
+                            "all_emotions_json": all_emotions_str,
+                            "created_at": extracted_at,
+                            "spec_version": _record_spec_version(record, "emo_27"),
+                        }
+                        _insert_matching_columns(self.conn, "message_emotions", cols, row)
+                        values.append(1)
                 elif use_wiki:
                     import json
                     import uuid
@@ -238,21 +242,17 @@ class DerivedTablesManager(BaseObject):
                         message_id = record.get("message_id") or record.get("record_id")
                         emotion_id = str(record.get("emotion_id") or uuid.uuid4())
                         payload = json.dumps({**record, "message_id": message_id})
-                        self.conn.execute(
-                            """
-                            INSERT OR REPLACE INTO message_emotions (
-                                emotion_id, record_id, source_id, model, provider, payload_json
-                            ) VALUES (?, ?, ?, ?, ?, ?)
-                            """,
-                            (
-                                emotion_id,
-                                message_id,
-                                record.get("source_id"),
-                                record.get("model_name") or record.get("model"),
-                                record.get("provider"),
-                                payload,
-                            ),
-                        )
+                        row = {
+                            "emotion_id": emotion_id,
+                            "record_id": message_id,
+                            "source_id": record.get("source_id"),
+                            "model": record.get("model_name") or record.get("model"),
+                            "provider": record.get("provider"),
+                            "payload_json": payload,
+                            "spec_version": _record_spec_version(record, "emo_27"),
+                        }
+                        _insert_matching_columns(self.conn, "message_emotions", cols, row)
+                        values = [1]  # noqa: F841 — keep written accounting below
                 else:
                     logger.warning("%s: message_emotions schema not recognized", self)
                     return 0
@@ -292,21 +292,20 @@ class DerivedTablesManager(BaseObject):
                 entity_id = str(record.get("entity_id") or uuid.uuid4())
                 payload = json.dumps({**record, "record_id": record_id, "entity_id": entity_id})
                 if "payload_json" in cols:
-                    self.conn.execute(
-                        """
-                        INSERT OR REPLACE INTO message_entities (
-                            entity_id, record_id, source_id, entity_text, model, provider, payload_json
-                        ) VALUES (?, ?, ?, ?, ?, ?, ?)
-                        """,
-                        (
-                            entity_id,
-                            record_id,
-                            record.get("source_id"),
-                            entity_text,
-                            record.get("model"),
-                            record.get("provider"),
-                            payload,
-                        ),
+                    _insert_matching_columns(
+                        self.conn,
+                        "message_entities",
+                        cols,
+                        {
+                            "entity_id": entity_id,
+                            "record_id": record_id,
+                            "source_id": record.get("source_id"),
+                            "entity_text": entity_text,
+                            "model": record.get("model"),
+                            "provider": record.get("provider"),
+                            "payload_json": payload,
+                            "spec_version": _record_spec_version(record, "entities"),
+                        },
                     )
                 if "message_id" in cols:
                     try:
@@ -341,21 +340,20 @@ class DerivedTablesManager(BaseObject):
                 if not goal_text:
                     continue
                 goal_id = str(record.get("goal_id") or uuid.uuid4())
-                self.conn.execute(
-                    """
-                    INSERT OR REPLACE INTO user_goals (
-                        goal_id, record_id, source_id, goal_text, model, provider, payload_json
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?)
-                    """,
-                    (
-                        goal_id,
-                        record_id,
-                        record.get("source_id"),
-                        goal_text,
-                        record.get("model"),
-                        record.get("provider"),
-                        json.dumps({**record, "goal_id": goal_id}),
-                    ),
+                _insert_matching_columns(
+                    self.conn,
+                    "user_goals",
+                    cols,
+                    {
+                        "goal_id": goal_id,
+                        "record_id": record_id,
+                        "source_id": record.get("source_id"),
+                        "goal_text": goal_text,
+                        "model": record.get("model"),
+                        "provider": record.get("provider"),
+                        "payload_json": json.dumps({**record, "goal_id": goal_id}),
+                        "spec_version": _record_spec_version(record, "goal_extraction"),
+                    },
                 )
                 written += 1
             commit_connection(self.conn)
@@ -406,6 +404,7 @@ class DerivedTablesManager(BaseObject):
                 "model": record.get("model"),
                 "provider": record.get("provider"),
                 "payload_json": json.dumps({**record, "topic_id": topic_id}),
+                "spec_version": _record_spec_version(record, "topics"),
             }
             if "message_id" in cols:
                 values["message_id"] = record.get("message_id") or record_id
@@ -435,6 +434,7 @@ class DerivedTablesManager(BaseObject):
                 "model": record.get("model"),
                 "provider": record.get("provider"),
                 "payload_json": json.dumps({**record, "sentiment_id": sentiment_id}),
+                "spec_version": _record_spec_version(record, "sentiment"),
             }
             if "message_id" in cols:
                 values["message_id"] = record.get("message_id") or record_id
@@ -464,6 +464,7 @@ class DerivedTablesManager(BaseObject):
                 "dims": record.get("dims") or (len(vector) if isinstance(vector, list) else None),
                 "vector_json": json.dumps(vector) if vector is not None else None,
                 "payload_json": json.dumps({**record, "embedding_id": embedding_id}),
+                "spec_version": _record_spec_version(record, "embeddings"),
             }
             if "message_id" in cols:
                 values["message_id"] = record.get("message_id") or record_id
@@ -487,32 +488,70 @@ class DerivedTablesManager(BaseObject):
             for i in range(0, len(records), batch_size):
                 batch = records[i : i + batch_size]
                 values = []
+                cols = _table_columns(self.conn, "browser_url_classification")
                 for record in batch:
                     record_id = record.get("record_id") or record.get("event_id")
                     if not record_id:
                         continue
-                    values.append(
-                        (
-                            record.get("enriched_from_table") or "activity_events",
-                            record_id,
-                            record.get("dataset_id"),
-                            record.get("url"),
-                            record.get("title"),
-                            record.get("url_category") or record.get("category"),
-                            record.get("url_confidence") if record.get("url_confidence") is not None else record.get("confidence"),
-                            record.get("model_name") or record.get("model"),
+                    row = {
+                        "enriched_from_table": record.get("enriched_from_table") or "activity_events",
+                        "record_id": record_id,
+                        "dataset_id": record.get("dataset_id"),
+                        "url": record.get("url"),
+                        "title": record.get("title"),
+                        "url_category": record.get("url_category") or record.get("category"),
+                        "url_confidence": (
+                            record.get("url_confidence")
+                            if record.get("url_confidence") is not None
+                            else record.get("confidence")
+                        ),
+                        "model_name": record.get("model_name") or record.get("model"),
+                        "updated_at": "datetime('now')",
+                        "spec_version": _record_spec_version(record, "url_classification"),
+                    }
+                    # updated_at uses SQL datetime — keep prior executemany path for that col
+                    if "spec_version" in cols:
+                        self.conn.execute(
+                            """
+                            INSERT OR REPLACE INTO browser_url_classification
+                            (enriched_from_table, record_id, dataset_id, url, title,
+                             url_category, url_confidence, model_name, updated_at, spec_version)
+                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), ?)
+                            """,
+                            (
+                                row["enriched_from_table"],
+                                row["record_id"],
+                                row["dataset_id"],
+                                row["url"],
+                                row["title"],
+                                row["url_category"],
+                                row["url_confidence"],
+                                row["model_name"],
+                                row["spec_version"],
+                            ),
                         )
-                    )
+                    else:
+                        self.conn.execute(
+                            """
+                            INSERT OR REPLACE INTO browser_url_classification
+                            (enriched_from_table, record_id, dataset_id, url, title,
+                             url_category, url_confidence, model_name, updated_at)
+                            VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
+                            """,
+                            (
+                                row["enriched_from_table"],
+                                row["record_id"],
+                                row["dataset_id"],
+                                row["url"],
+                                row["title"],
+                                row["url_category"],
+                                row["url_confidence"],
+                                row["model_name"],
+                            ),
+                        )
+                    values.append(1)
                 if not values:
                     continue
-                self.conn.executemany(
-                    """
-                    INSERT OR REPLACE INTO browser_url_classification
-                    (enriched_from_table, record_id, dataset_id, url, title, url_category, url_confidence, model_name, updated_at)
-                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))
-                    """,
-                    values,
-                )
                 commit_connection(self.conn)
                 written += len(values)
         except Exception as exc: