topos-node 1.3.24__tar.gz → 1.3.26__tar.gz

{topos_node-1.3.24 → topos_node-1.3.26}/MANIFEST.in

@@ -5,3 +5,4 @@ recursive-include topos *.json
 recursive-include shared *.json
 # Tray icon glyphs (topos/cli/assets) — without them the tray cannot render.
 recursive-include topos *.png
+recursive-include topos/features/derivation/bundled_packs *.yaml

{topos_node-1.3.24/topos_node.egg-info → topos_node-1.3.26}/PKG-INFO

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

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

{topos_node-1.3.24 → topos_node-1.3.26}/topos/__version__.py

@@ -1,6 +1,6 @@
 """Topos Control Plane Version Information."""
 
-__version__ = "1.3.24"
-__version_info__ = (1, 3, 24)
+__version__ = "1.3.26"
+__version_info__ = (1, 3, 26)
 
 __all__ = ["__version__", "__version_info__"]

{topos_node-1.3.24 → topos_node-1.3.26}/topos/api/enrichment.py

@@ -73,6 +73,67 @@ def _record_identifier(record: Dict[str, Any]) -> Optional[str]:
     return None
 
 
+def _processed_record_ids(conn, source_id: str, job_id: str, min_spec: int) -> set[str]:
+    """Ids this job has already run over, at or above ``min_spec``.
+
+    Distinct from coverage: coverage witnesses OUTPUT, this witnesses the RUN.
+    Returns empty on any failure — the caller then falls back to coverage-only
+    behaviour, which over-scans rather than skipping work that never happened.
+    """
+    if not conn:
+        return set()
+    try:
+        if not _table_exists(conn, "enrichment_record_progress"):
+            return set()
+        rows = conn.execute(
+            "SELECT record_id FROM enrichment_record_progress "
+            "WHERE source_id=? AND job_id=? AND COALESCE(spec_version, 0) >= ?",
+            (source_id, job_id, int(min_spec or 0)),
+        ).fetchall()
+        return {str(row[0]) for row in rows if row and row[0]}
+    except Exception as exc:  # noqa: BLE001 — a marker read must never fail a backfill
+        logger.warning("enrichment_record_progress read failed for %s/%s: %s", source_id, job_id, exc)
+        return set()
+
+
+def _mark_records_processed(
+    conn, source_id: str, job_id: str, records: List[Dict[str, Any]], spec_version: int
+) -> int:
+    """Record that this job ran over these records, whatever it produced.
+
+    Best-effort by design: the enrichment already happened and its output is
+    committed, so a failure here costs a future re-scan, never correctness.
+    """
+    if not conn or not records:
+        return 0
+    ids = [rid for rid in (_record_identifier(r) for r in records) if rid]
+    if not ids:
+        return 0
+    try:
+        if not _table_exists(conn, "enrichment_record_progress"):
+            return 0
+        from ..storage.db.write_gate import batched_writes
+
+        # `batched_writes` holds the write gate across the statements AND the
+        # commit. Doing the executemany bare and only calling commit_connection
+        # takes SQLite's write lock ungated, which the gate detects and warns
+        # about — it can deadlock-until-busy_timeout against whoever holds the
+        # gate, and this runs right after a long enrichment batch, when that is
+        # most likely.
+        with batched_writes(conn):
+            conn.executemany(
+                "INSERT INTO enrichment_record_progress "
+                "(source_id, job_id, record_id, spec_version) VALUES (?,?,?,?) "
+                "ON CONFLICT(source_id, job_id, record_id) DO UPDATE SET "
+                "spec_version=excluded.spec_version, processed_at=datetime('now')",
+                [(source_id, job_id, rid, int(spec_version or 0)) for rid in ids],
+            )
+        return len(ids)
+    except Exception as exc:  # noqa: BLE001
+        logger.warning("enrichment_record_progress write failed for %s/%s: %s", source_id, job_id, exc)
+        return 0
+
+
 def _table_exists(conn, table: str) -> bool:
     try:
         row = conn.execute(
@@ -395,7 +456,11 @@ async def _generic_backfill_core(
     """
     import uuid as _uuid
 
-    from ..enrichment.catalog import coverage_table_for_job, jobs_configured_for_source
+    from ..enrichment.catalog import (
+        catalog_spec_version,
+        coverage_table_for_job,
+        jobs_configured_for_source,
+    )
     from ..ingestion.canonical_pipeline import (
         load_canonical_records_for_signal,
         run_post_canonical_pipeline,
@@ -453,6 +518,18 @@ async def _generic_backfill_core(
                         }
                     records = [r for r in records if _record_identifier(r) not in done]
 
+            # Records this job has already RUN over, whatever it produced.
+            # Coverage tables only witness output, so without this a record
+            # that correctly yields nothing is re-scanned by every backfill
+            # forever (see enrichment_record_progress_v1). Computed once —
+            # this set is read per record, so building it inside the filter
+            # would issue one query per row.
+            already_run = _processed_record_ids(
+                db_conn, source_id, job_name, catalog_spec_version(job_name)
+            )
+            if already_run:
+                records = [r for r in records if _record_identifier(r) not in already_run]
+
     if isinstance(limit, int) and limit > 0:
         records = records[:limit]
 
@@ -507,11 +584,20 @@ async def _generic_backfill_core(
         processed = sum((result.get("records_created") or {}).values())
         errors = list(result.get("errors") or [])
 
+    # Every record in `records` was attempted, so every one is marked — that is
+    # the whole point, since `processed` above counts OUTPUT ROWS CREATED, not
+    # records attempted, and the two differ by exactly the empty results this
+    # marker exists to stop re-scanning.
+    marked = _mark_records_processed(
+        db_conn, source_id, job_name, records, catalog_spec_version(job_name)
+    )
+
     return {
         "rows_scanned": scanned,
         "rows_processed": int(processed),
         "rows_skipped": max(scanned - len(records), 0),
         "rows_failed": len(errors),
+        "rows_marked": marked,
         "errors": errors[:100],
     }
 
@@ -1115,7 +1201,23 @@ async def _get_enrichment_status_core(
     source_def = REGISTRY.get(source_id)
     if not source_def:
         raise ValueError(f"Source {source_id} not found")
-    
+
+    # Report what will ACTUALLY run, not the static definition.
+    #
+    # Every execution path resolves canonical jobs through
+    # `effective_canonical_enrichment_jobs` (canonical_pipeline, ingestion
+    # manager, the WS handler and `process_enrichment` all do), so a status
+    # surface that reads `source_def.canonical_enrichment_jobs` directly
+    # reports a DIFFERENT list than the engine runs the moment a per-source
+    # override exists. Measured 2026-08-25: with `entities` enabled for
+    # imessage via `PATCH /v1/sources/imessage/enrichments/entities`, the
+    # override-aware lanes said `['canonical','signal']` while this endpoint
+    # still said `['emo_27']` — which reads as "entity extraction is off"
+    # when it is on, and cost real time diagnosing exactly that.
+    from ..enrichment.source_overrides import effective_canonical_enrichment_jobs
+
+    effective_jobs = effective_canonical_enrichment_jobs(source_def)
+
     # Get database connection
     db_conn = get_db_connection()
     if not db_conn:
@@ -1125,7 +1227,7 @@ async def _get_enrichment_status_core(
             "total_messages": 0,
             "processed_messages": 0,
             "unprocessed_messages": 0,
-            "enrichment_jobs": source_def.canonical_enrichment_jobs,
+            "enrichment_jobs": effective_jobs,
             "enrichment_trigger": getattr(source_def, "enrichment_trigger", "automatic"),
             "message": "Database connection not available",
         }
@@ -1144,7 +1246,7 @@ async def _get_enrichment_status_core(
                 "total_messages": 0,
                 "processed_messages": 0,
                 "unprocessed_messages": 0,
-                "enrichment_jobs": source_def.canonical_enrichment_jobs,
+                "enrichment_jobs": effective_jobs,
                 "enrichment_trigger": getattr(source_def, "enrichment_trigger", "automatic"),
                 "message": "Canonical table does not exist yet",
             }
@@ -1182,7 +1284,7 @@ async def _get_enrichment_status_core(
             "total_messages": 0,
             "processed_messages": 0,
             "unprocessed_messages": 0,
-            "enrichment_jobs": source_def.canonical_enrichment_jobs,
+            "enrichment_jobs": effective_jobs,
             "enrichment_trigger": getattr(source_def, "enrichment_trigger", "automatic"),
             "message": f"Error reading canonical table: {e}",
         }
@@ -1198,7 +1300,7 @@ async def _get_enrichment_status_core(
         "total_messages": total,
         "processed_messages": processed_count,
         "unprocessed_messages": unprocessed_count,
-        "enrichment_jobs": source_def.canonical_enrichment_jobs,
+        "enrichment_jobs": effective_jobs,
         "enrichment_trigger": getattr(source_def, "enrichment_trigger", "automatic"),
     }
 
@@ -1266,7 +1368,13 @@ def _list_source_enrichments_core(source_id: str) -> Dict[str, Any]:
         raise ValueError(f"Source {source_id} not found")
 
     raw_jobs = list(getattr(source_def, "raw_enrichment_jobs", []) or [])
-    canonical_jobs = list(getattr(source_def, "canonical_enrichment_jobs", []) or [])
+    # Override-aware, for the same reason as `_get_enrichment_status_core`:
+    # this field named the static definition while `enrichments[].lanes`
+    # (built from `jobs_configured_for_source` below) named the effective one,
+    # so one response could disagree with itself about whether a job runs.
+    from ..enrichment.source_overrides import effective_canonical_enrichment_jobs
+
+    canonical_jobs = effective_canonical_enrichment_jobs(source_def)
     implemented_backfills = sorted(
         enrichment_name
         for sid, enrichment_name in _RAW_SOURCE_BACKFILL_HANDLERS

{topos_node-1.3.24 → topos_node-1.3.26}/topos/api/signal.py

@@ -709,6 +709,7 @@ async def dismiss_blackhole_notification(
 async def list_facts(
     predicate: Optional[str] = Query(default=None, max_length=80),
     dimension: Optional[str] = Query(default=None, max_length=40),
+    pack: Optional[str] = Query(default=None, max_length=60),
     include_closed: bool = Query(default=False),
     limit: int = Query(default=100, ge=1, le=500),
     offset: int = Query(default=0, ge=0),
@@ -724,6 +725,7 @@ async def list_facts(
         guard=owner_ui_guard(conn),
         predicate=predicate,
         dimension=dimension,
+        pack=pack,
         include_closed=include_closed,
         limit=limit,
         offset=offset,
@@ -1034,3 +1036,52 @@ async def complexity_influence(
         window_days=window_days,
         target=target,
     )
+
+
+@router.get("/derivation/packs")
+async def get_derivation_packs(_api_key: str = Depends(require_api_key)):
+    """Lens catalog (W4.3): registry rows + live fact + quarantine counts."""
+    from ..features.derivation.surfaces import list_packs
+
+    return list_packs(_entities_conn())
+
+
+@router.put("/derivation/packs/{pack_id}")
+async def put_derivation_pack(
+    pack_id: str,
+    enabled: bool = Body(..., embed=True),
+    _api_key: str = Depends(require_api_key),
+):
+    from ..features.derivation.surfaces import set_pack_enabled
+
+    if not set_pack_enabled(_entities_conn(), pack_id, enabled):
+        raise HTTPException(status_code=404, detail=f"unknown pack {pack_id}")
+    return {"pack_id": pack_id, "enabled": enabled}
+
+
+@router.get("/facts/conflicts")
+async def get_fact_conflicts(
+    limit: int = Query(default=100, ge=1, le=500),
+    _api_key: str = Depends(require_api_key),
+):
+    """The A3 quarantine + Tier-2 conflict review queue (W4.2)."""
+    from ..features.derivation.surfaces import list_conflicts
+
+    return {"conflicts": list_conflicts(_entities_conn(), limit=limit)}
+
+
+@router.post("/facts/conflicts/resolve")
+async def post_fact_conflict_resolution(
+    conflict_id: str = Body(...),
+    status: str = Body(..., description="dismissed | accepted"),
+    _api_key: str = Depends(require_api_key),
+):
+    from ..features.derivation.surfaces import resolve_conflict
+
+    try:
+        ok = resolve_conflict(_entities_conn(), conflict_id, status)
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    if not ok:
+        raise HTTPException(status_code=404, detail=f"unknown conflict {conflict_id}")
+    return {"conflict_id": conflict_id, "status": status}

{topos_node-1.3.24 → topos_node-1.3.26}/topos/config/settings.py

@@ -183,6 +183,9 @@ class Settings(BaseSettings):
     topos_engine_service_url: Optional[str] = Field(None)
 
     topos_database_path: Optional[str] = Field(None)
+    # Packet resolution (PLAN_DERIVATION_LAYER.md): env default only; the per-database
+    # engine_config value overrides. Validated against RESOLUTIONS at read time.
+    topos_packet_resolution: str = Field("scores_only")
     topos_database_mode: str = Field("local")
     topos_database_service_url: Optional[str] = Field(None)
     topos_postgres_dsn: Optional[str] = Field(None)
@@ -400,6 +403,7 @@ settings = Settings()
 # --- P1.5 exposure-profile visibility (PLAN_PROVENANCE_SPLIT) -------------------------
 # Frozen engine_config key the UI toggle writes; a per-node bool the owner sets.
 ENGINE_CONFIG_KEY_EXPOSURE_PROFILE_VISIBLE = "exposure_profile_visible"
+ENGINE_CONFIG_KEY_PACKET_RESOLUTION = "packet_resolution"
 
 _TRUE_STRINGS = frozenset({"1", "true", "t", "yes", "y", "on"})
 _FALSE_STRINGS = frozenset({"0", "false", "f", "no", "n", "off"})
@@ -458,6 +462,23 @@ def resolve_exposure_profile_visible(settings_obj: "Settings", conn=None) -> boo
     return _coerce_bool(raw, default)
 
 
+def resolve_packet_resolution(settings_obj: "Settings", conn=None) -> str:
+    """Effective packet-resolution SETTING (before interlocks): the per-database
+    engine_config value ("packet_resolution") when set and valid, else the
+    env/settings default ("scores_only"). Interlocks (owner floor, model locality)
+    live in query.packet_resolution.effective_packet_resolution — this returns
+    only what the owner asked for."""
+    valid = ("scores_only", "facts", "facts_all")
+    default = str(getattr(settings_obj, "topos_packet_resolution", "") or "scores_only").strip().lower()
+    if default not in valid:
+        default = "scores_only"
+    raw = _read_engine_config_value(conn, ENGINE_CONFIG_KEY_PACKET_RESOLUTION)
+    if raw is None:
+        return default
+    value = str(raw).strip().lower()
+    return value if value in valid else default
+
+
 def exposure_profile_visible(conn=None) -> bool:
     """Module-level convenience: resolve against the global settings singleton
     and (when not passed) the process DB connection. Retrieval passes its own

{topos_node-1.3.24 → topos_node-1.3.26}/topos/control_plane_client.py

@@ -59,6 +59,9 @@ _FAST_INBOUND_MESSAGE_TYPES = frozenset(
         "connection_info",
         "check_inbox_write",
         "list_waiting_routine_runs",
+        "list_active_routine_runs",
+        "list_expired_routine_runs",
+        "delete_routine_runs",
         "list_due_routines",
         "routine_has_active_run",
         "update_routine_run",

{topos_node-1.3.24 → topos_node-1.3.26}/topos/core/handlers/__init__.py

@@ -148,6 +148,7 @@ from .common import logger
 from .registry import HANDLERS, OWNER_ONLY_MESSAGE_TYPES, handles  # noqa: F401
 from . import (  # noqa: F401  (imported for handler registration side effects)
     config,
+    derivation,
     sources,
     filter_lab,
     enrichment_lab,

{topos_node-1.3.24 → topos_node-1.3.26}/topos/core/handlers/config.py

@@ -565,3 +565,65 @@ async def handle_put_exposure_profile_config(message: Dict[str, Any]) -> Optiona
         }
     except Exception as exc:  # noqa: BLE001
         return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("get_packet_resolution_config")
+async def handle_get_packet_resolution_config(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Packet resolution (PLAN_DERIVATION_LAYER.md): the owner's setting PLUS the
+    effective state after interlocks, and the model that receives the packet — the
+    settings UI shows all three so the coupling is legible at the moment of decision."""
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    try:
+        from ...query.packet_resolution import RESOLUTIONS, effective_packet_resolution
+
+        info = effective_packet_resolution(conn, requester_id="owner", disclosure_tier="owner_raw")
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "options": list(RESOLUTIONS), **info}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_packet_resolution_config")
+async def handle_put_packet_resolution_config(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """Set packet resolution. On a DOWNGRADE, cached query artifacts are expired
+    immediately: the cache key isolates resolutions going forward, but artifacts
+    minted under the higher resolution still HOLD that content — "I turned it off"
+    must mean off now, not after a TTL."""
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    value = str(payload.get("packet_resolution") or "").strip().lower()
+    try:
+        from ...config.settings import (
+            ENGINE_CONFIG_KEY_PACKET_RESOLUTION,
+            resolve_packet_resolution,
+        )
+        from ...query.packet_resolution import (
+            RESOLUTIONS,
+            effective_packet_resolution,
+            resolution_order,
+        )
+
+        if value not in RESOLUTIONS:
+            return {"id": req_id, "status": "error",
+                    "error": f"packet_resolution must be one of {list(RESOLUTIONS)}"}
+        previous = resolve_packet_resolution(settings, conn)
+        set_engine_config_value(conn, ENGINE_CONFIG_KEY_PACKET_RESOLUTION, value)
+        expired = 0
+        if resolution_order(value) < resolution_order(previous):
+            from ...storage.db.write_gate import commit_connection, with_db_write
+
+            with with_db_write():
+                cur = conn.execute("DELETE FROM query_artifacts")
+                expired = cur.rowcount if cur.rowcount is not None else 0
+                commit_connection(conn)
+        info = effective_packet_resolution(conn, requester_id="owner", disclosure_tier="owner_raw")
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "previous": previous, "expired_artifacts": expired, **info}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}

topos_node-1.3.26/topos/core/handlers/derivation.py

@@ -0,0 +1,79 @@
+"""Derivation-layer handlers (W4 surfaces) — thin delegates over
+features/derivation/surfaces.py (shared with the HTTP routes in api/signal.py)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+import topos.core.handlers as hub
+from .registry import handles
+
+
+@handles("get_derivation_packs")
+async def handle_get_derivation_packs(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    try:
+        from ...features.derivation.surfaces import list_packs
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", **list_packs(conn)}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_derivation_pack")
+async def handle_put_derivation_pack(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    pack_id = str(payload.get("pack_id") or "").strip()
+    enabled = payload.get("enabled")
+    if not pack_id or not isinstance(enabled, bool):
+        return {"id": req_id, "status": "error", "error": "pack_id and enabled (bool) required"}
+    try:
+        from ...features.derivation.surfaces import set_pack_enabled
+        if not set_pack_enabled(conn, pack_id, enabled):
+            return {"id": req_id, "status": "error", "error": f"unknown pack {pack_id}"}
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "pack_id": pack_id, "enabled": enabled}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("get_fact_conflicts")
+async def handle_get_fact_conflicts(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    try:
+        from ...features.derivation.surfaces import list_conflicts
+        rows = list_conflicts(conn, limit=int(payload.get("limit") or 100))
+        return {"id": req_id, "status": "ok", "payload": {"status": "ok", "conflicts": rows}}
+    except Exception as exc:  # noqa: BLE001
+        return {"id": req_id, "status": "error", "error": str(exc)}
+
+
+@handles("put_fact_conflict")
+async def handle_put_fact_conflict(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    payload = message.get("payload") or {}
+    cid = str(payload.get("conflict_id") or "").strip()
+    status = str(payload.get("status") or "").strip()
+    try:
+        from ...features.derivation.surfaces import resolve_conflict
+        if not resolve_conflict(conn, cid, status):
+            return {"id": req_id, "status": "error", "error": f"unknown conflict {cid}"}
+        return {"id": req_id, "status": "ok",
+                "payload": {"status": "ok", "conflict_id": cid, "new_status": status}}
+    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)}

{topos_node-1.3.24 → topos_node-1.3.26}/topos/core/handlers/routines.py

@@ -297,6 +297,57 @@ async def handle_routine_has_active_run(message: Dict[str, Any]) -> Optional[Dic
         "payload": {"active": active},
     }
 
+@handles("list_active_routine_runs")
+async def handle_list_active_routine_runs(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    from ...routines import store as routines_store
+
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    pl = message.get("payload") or {}
+    engine_id = str(pl.get("engine_id") or "").strip()
+    if not engine_id:
+        return {"id": req_id, "status": "error", "error": "engine_id required"}
+    rows = await run_db_read(routines_store.list_active_runs, engine_id=engine_id)
+    return {"id": req_id, "status": "ok", "payload": {"runs": rows}}
+
+@handles("list_expired_routine_runs")
+async def handle_list_expired_routine_runs(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    from ...routines import store as routines_store
+
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    pl = message.get("payload") or {}
+    engine_id = str(pl.get("engine_id") or "").strip()
+    cutoff = str(pl.get("cutoff") or "").strip()
+    if not engine_id or not cutoff:
+        return {"id": req_id, "status": "error", "error": "engine_id and cutoff required"}
+    rows = await run_db_read(
+        routines_store.list_expired_runs,
+        engine_id=engine_id,
+        cutoff=cutoff,
+        limit=int(pl.get("limit") or 500),
+    )
+    return {"id": req_id, "status": "ok", "payload": {"runs": rows}}
+
+@handles("delete_routine_runs")
+async def handle_delete_routine_runs(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    req_id = message.get("id")
+    from ...routines import store as routines_store
+
+    conn = hub.get_db_connection()
+    if not conn:
+        return {"id": req_id, "status": "error", "error": "Database not available"}
+    pl = message.get("payload") or {}
+    run_ids = pl.get("run_ids")
+    if not isinstance(run_ids, list) or not run_ids:
+        return {"id": req_id, "status": "error", "error": "run_ids required"}
+    deleted = await run_db_write(routines_store.delete_runs, run_ids)
+    return {"id": req_id, "status": "ok", "payload": {"deleted": int(deleted or 0)}}
+
 @handles("advance_routine_next_run_at")
 async def handle_advance_routine_next_run_at(message: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     req_id = message.get("id")

{topos_node-1.3.24 → topos_node-1.3.26}/topos/core/handlers/signal_features.py

@@ -584,6 +584,7 @@ async def handle_signal_list_facts(message: Dict[str, Any]) -> Optional[Dict[str
             guard=guard_from_message(conn, message),
             predicate=payload.get("predicate"),
             dimension=payload.get("dimension"),
+            pack=payload.get("pack"),
             include_closed=bool(payload.get("include_closed")),
             limit=min(int(payload.get("limit") or 100), 500),
             offset=max(0, int(payload.get("offset") or 0)),

{topos_node-1.3.24 → topos_node-1.3.26}/topos/enrichment/jobs/__init__.py

@@ -7,6 +7,7 @@ from .canonical.embeddings_job import EmbeddingsJob
 from .canonical.entities_job import EntitiesJob
 from .canonical.emo_27_job import Emo27Job
 from .canonical.fact_extraction_job import FactExtractionJob
+from .canonical.derivation_job import DerivationJob
 from .canonical.goal_extraction_job import GoalExtractionJob
 from .canonical.relationship_edges_job import RelationshipEdgesJob
 from .canonical.sentiment_job import SentimentJob
@@ -30,6 +31,7 @@ CANONICAL_JOBS = [
     StatisticsJob(),
     FactExtractionJob(),
     TimelineJob(),
+    DerivationJob(),   # W2.3: ontology-pack derivation (after entities/facts — needs the spine)
 ]
 
 SIGNAL_DERIVATION_JOBS = [
@@ -67,6 +69,7 @@ __all__ = [
     "AvailabilityScoresJob",
     "StatisticsJob",
     "FactExtractionJob",
+    "DerivationJob",
     "TimelineJob",
     "AttentionTriageJob",
     "TopicClusterJob",