nexo-brain 7.27.3 → 7.28.0

package/src/classifier_local.py

@@ -213,11 +213,55 @@ class LocalZeroShotClassifier:
         )
 
 
+_SHARED_CLASSIFIER_LOCK = threading.Lock()
+_SHARED_CLASSIFIERS: dict[tuple[str, str], LocalZeroShotClassifier] = {}
+
+
+def get_shared_zero_shot_classifier(
+    *,
+    model_id: str = MODEL_ID,
+    revision: str = MODEL_REVISION,
+    confidence_floor: float = DEFAULT_CONFIDENCE_FLOOR,
+) -> LocalZeroShotClassifier:
+    """Return the process-wide classifier wrapper for this pinned model.
+
+    The underlying transformer pipeline is still lazy-loaded, but once it is
+    warm all semantic callers share it instead of creating fresh wrappers.
+    """
+    key = (model_id, revision)
+    with _SHARED_CLASSIFIER_LOCK:
+        classifier = _SHARED_CLASSIFIERS.get(key)
+        if classifier is None:
+            classifier = LocalZeroShotClassifier(
+                model_id=model_id,
+                revision=revision,
+                confidence_floor=confidence_floor,
+            )
+            _SHARED_CLASSIFIERS[key] = classifier
+        else:
+            classifier.confidence_floor = confidence_floor
+        return classifier
+
+
+def is_local_classifier_warm(
+    *,
+    model_id: str = MODEL_ID,
+    revision: str = MODEL_REVISION,
+) -> bool:
+    """Return True only when this process already has a loaded pipeline."""
+    key = (model_id, revision)
+    with _SHARED_CLASSIFIER_LOCK:
+        classifier = _SHARED_CLASSIFIERS.get(key)
+        return bool(classifier is not None and classifier._pipe is not None)
+
+
 __all__ = [
     "LocalZeroShotClassifier",
     "ClassificationResult",
     "MODEL_ID",
     "MODEL_REVISION",
     "DEFAULT_CONFIDENCE_FLOOR",
+    "get_shared_zero_shot_classifier",
+    "is_local_classifier_warm",
     "is_local_classifier_available_with_install_state",
 ]

package/src/cognitive/_core.py

@@ -643,6 +643,9 @@ def _init_tables(conn: sqlite3.Connection):
     conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_source ON kg_edges(source_id)")
     conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_target ON kg_edges(target_id)")
     conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_relation ON kg_edges(relation)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_source_relation_active ON kg_edges(source_id, relation, valid_until)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_target_relation_active ON kg_edges(target_id, relation, valid_until)")
+    conn.execute("CREATE INDEX IF NOT EXISTS idx_kg_edges_relation_active ON kg_edges(relation, valid_until)")
 
     conn.commit()
 

package/src/cognitive_control_observatory.py

@@ -204,12 +204,14 @@ def build_cognitive_control_observatory(
             "usage": local_usage,
             "status": local_status,
         },
+        "runtime_budgets": local_usage.get("runtime_budget_metrics") or {},
         "learnings": learning_summary,
         "followups": followup_summary,
         "intraday_memory": intraday_summary,
     }
     payload["summary"] = {
         "local_context_events": int(local_usage.get("total_events") or 0),
+        "runtime_budget_tiers": len((local_usage.get("runtime_budget_metrics") or {}).get("by_tier") or {}),
         "active_learnings": int(learning_summary.get("active") or 0),
         "active_followups": int((followup_summary.get("counts") or {}).get("active") or 0),
         "intraday_facts": int(intraday_summary.get("intraday_facts_window") or 0),

package/src/db/__init__.py

@@ -56,6 +56,7 @@ _outcomes = _load_submodule("db._outcomes")
 _goal_profiles = _load_submodule("db._goal_profiles")
 _continuity = _load_submodule("db._continuity")
 _memory_v2 = _load_submodule("db._memory_v2")
+_commitments = _load_submodule("db._commitments")
 
 # Core: connection, constants, init, utils
 from db._core import (
@@ -110,6 +111,13 @@ from db._memory_v2 import (
     memory_observation_stats,
 )
 
+from db._commitments import (
+    create_commitment,
+    list_commitments,
+    update_commitment_status,
+    resolve_matching_commitments,
+)
+
 # PostToolUse inbox-reminder rate limit (v6.0.1)
 _hook_inbox_reminders = _load_submodule("db._hook_inbox_reminders")
 from db._hook_inbox_reminders import (

package/src/db/_commitments.py

@@ -0,0 +1,344 @@
+"""Durable commitment ledger for future-action promises.
+
+The ledger is an index over promises and their linked action artifacts. It is
+not a scheduler: followups, workflows, outcomes, and protocol tasks remain the
+systems that execute work.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+import re
+from typing import Any
+
+from db._core import get_db, now_epoch
+
+
+ACTIVE_STATUSES = {"active", "in_progress", "pending"}
+CLOSED_STATUSES = {"fulfilled", "missed", "cancelled", "superseded"}
+VALID_OWNERS = {"agent", "user", "shared", "waiting"}
+VALID_STATUSES = ACTIVE_STATUSES | CLOSED_STATUSES
+_WORD_RE = re.compile(r"[a-z0-9_]+")
+
+
+def _clean_text(value: Any, *, max_chars: int = 1200) -> str:
+    text = str(value or "").strip()
+    if len(text) > max_chars:
+        return text[: max(0, max_chars - 3)].rstrip() + "..."
+    return text
+
+
+def _status(value: str) -> str:
+    clean = str(value or "active").strip().lower()
+    return clean if clean in VALID_STATUSES else "active"
+
+
+def _owner(value: str) -> str:
+    clean = str(value or "agent").strip().lower()
+    return clean if clean in VALID_OWNERS else "agent"
+
+
+def _json(value: dict[str, Any] | None) -> str:
+    try:
+        return json.dumps(value or {}, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+    except Exception:
+        return "{}"
+
+
+def _tokens(value: str) -> set[str]:
+    return {item for item in _WORD_RE.findall(str(value or "").lower()) if len(item) >= 3}
+
+
+def _dedupe_key(*, source_type: str, source_id: str, session_id: str, statement: str) -> str:
+    seed = "|".join(
+        [
+            _clean_text(source_type, max_chars=80).lower(),
+            _clean_text(source_id, max_chars=160).lower(),
+            _clean_text(session_id, max_chars=160).lower(),
+            _clean_text(statement, max_chars=600).lower(),
+        ]
+    )
+    return hashlib.sha1(seed.encode("utf-8", errors="ignore"), usedforsecurity=False).hexdigest()
+
+
+def _commitment_id(dedupe_key: str) -> str:
+    return f"CM-{dedupe_key[:16].upper()}"
+
+
+def _row_dict(row: Any) -> dict[str, Any]:
+    if not row:
+        return {}
+    data = dict(row)
+    try:
+        data["metadata"] = json.loads(data.get("metadata_json") or "{}")
+    except Exception:
+        data["metadata"] = {}
+    return data
+
+
+def create_commitment(
+    *,
+    statement: str,
+    source_type: str = "",
+    source_id: str = "",
+    memory_event_uid: str = "",
+    session_id: str = "",
+    conversation_id: str = "",
+    project_key: str = "",
+    owner: str = "agent",
+    deadline: str = "",
+    status: str = "active",
+    confidence: float = 0.5,
+    action_ref_type: str = "",
+    action_ref_id: str = "",
+    outcome_id: int | None = None,
+    evidence_ref: str = "",
+    dedupe_key: str = "",
+    metadata: dict[str, Any] | None = None,
+    created_at: float | None = None,
+) -> dict[str, Any]:
+    clean_statement = _clean_text(statement)
+    if not clean_statement:
+        return {"ok": False, "error": "statement_required"}
+    stamp = float(created_at if created_at is not None else now_epoch())
+    clean_source_type = _clean_text(source_type, max_chars=80)
+    clean_source_id = _clean_text(source_id, max_chars=180)
+    clean_session_id = _clean_text(session_id, max_chars=180)
+    key = _clean_text(dedupe_key, max_chars=80) or _dedupe_key(
+        source_type=clean_source_type,
+        source_id=clean_source_id,
+        session_id=clean_session_id,
+        statement=clean_statement,
+    )
+    commitment_id = _commitment_id(key)
+    conn = get_db()
+    existing = conn.execute("SELECT * FROM commitments WHERE dedupe_key = ? LIMIT 1", (key,)).fetchone()
+    if existing:
+        result = _row_dict(existing)
+        result.update({"ok": True, "created": False})
+        return result
+    conn.execute(
+        """
+        INSERT INTO commitments (
+            id, created_at, updated_at, closed_at, source_type, source_id,
+            memory_event_uid, session_id, conversation_id, project_key,
+            statement, owner, deadline, status, confidence, action_ref_type,
+            action_ref_id, outcome_id, evidence_ref, dedupe_key, metadata_json
+        )
+        VALUES (?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        """,
+        (
+            commitment_id,
+            stamp,
+            stamp,
+            clean_source_type,
+            clean_source_id,
+            _clean_text(memory_event_uid, max_chars=180),
+            clean_session_id,
+            _clean_text(conversation_id, max_chars=180),
+            _clean_text(project_key, max_chars=120),
+            clean_statement,
+            _owner(owner),
+            _clean_text(deadline, max_chars=80),
+            _status(status),
+            max(0.0, min(1.0, float(confidence or 0.5))),
+            _clean_text(action_ref_type, max_chars=80),
+            _clean_text(action_ref_id, max_chars=180),
+            int(outcome_id) if outcome_id is not None else None,
+            _clean_text(evidence_ref, max_chars=240),
+            key,
+            _json(metadata),
+        ),
+    )
+    conn.commit()
+    row = conn.execute("SELECT * FROM commitments WHERE id = ?", (commitment_id,)).fetchone()
+    result = _row_dict(row)
+    result.update({"ok": True, "created": True})
+    return result
+
+
+def list_commitments(
+    *,
+    query: str = "",
+    status: str = "",
+    session_id: str = "",
+    project_key: str = "",
+    owner: str = "",
+    limit: int = 20,
+) -> list[dict[str, Any]]:
+    clauses = ["1=1"]
+    params: list[Any] = []
+    if status:
+        clean_status = status.strip().lower()
+        if clean_status in {"open", "active"}:
+            clauses.append("status IN ('active','in_progress','pending')")
+        elif clean_status in {"closed", "resolved"}:
+            clauses.append("status IN ('fulfilled','missed','cancelled','superseded')")
+        else:
+            clauses.append("status = ?")
+            params.append(_status(clean_status))
+    if session_id.strip():
+        clauses.append("session_id = ?")
+        params.append(session_id.strip())
+    if project_key.strip():
+        clauses.append("project_key = ?")
+        params.append(project_key.strip())
+    if owner.strip():
+        clauses.append("owner = ?")
+        params.append(_owner(owner))
+    max_items = max(1, min(int(limit or 20), 100))
+    terms = _tokens(query)
+    # Query filtering is semantic-ish and happens in Python over multiple
+    # fields. Fetch a larger bounded window first so older relevant open
+    # commitments do not disappear merely because the caller requested a
+    # small result limit.
+    query_window = 500 if terms else max_items * 3
+    rows = get_db().execute(
+        f"""
+        SELECT * FROM commitments
+         WHERE {' AND '.join(clauses)}
+         ORDER BY
+            CASE status WHEN 'active' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'pending' THEN 2 ELSE 3 END,
+            COALESCE(deadline, '') ASC,
+            updated_at DESC
+         LIMIT ?
+        """,
+        [*params, query_window],
+    ).fetchall()
+    items = [_row_dict(row) for row in rows]
+    if terms:
+        filtered = []
+        for item in items:
+            haystack = _tokens(
+                " ".join(
+                    str(item.get(field) or "")
+                    for field in (
+                        "id",
+                        "statement",
+                        "source_type",
+                        "source_id",
+                        "session_id",
+                        "project_key",
+                        "action_ref_type",
+                        "action_ref_id",
+                        "evidence_ref",
+                    )
+                )
+            )
+            if terms & haystack:
+                filtered.append(item)
+        items = filtered
+    return items[:max_items]
+
+
+def update_commitment_status(
+    commitment_id: str,
+    *,
+    status: str,
+    evidence_ref: str = "",
+    action_ref_type: str = "",
+    action_ref_id: str = "",
+    outcome_id: int | None = None,
+    metadata: dict[str, Any] | None = None,
+    now: float | None = None,
+) -> dict[str, Any]:
+    clean_status = _status(status)
+    stamp = float(now if now is not None else now_epoch())
+    closed_at = stamp if clean_status in CLOSED_STATUSES else None
+    conn = get_db()
+    row = conn.execute("SELECT * FROM commitments WHERE id = ?", (commitment_id.strip(),)).fetchone()
+    if not row:
+        return {"ok": False, "error": f"commitment_not_found:{commitment_id}"}
+    merged_metadata = _row_dict(row).get("metadata") or {}
+    merged_metadata.update(metadata or {})
+    conn.execute(
+        """
+        UPDATE commitments
+           SET status = ?,
+               updated_at = ?,
+               closed_at = ?,
+               evidence_ref = COALESCE(NULLIF(?, ''), evidence_ref),
+               action_ref_type = COALESCE(NULLIF(?, ''), action_ref_type),
+               action_ref_id = COALESCE(NULLIF(?, ''), action_ref_id),
+               outcome_id = COALESCE(?, outcome_id),
+               metadata_json = ?
+         WHERE id = ?
+        """,
+        (
+            clean_status,
+            stamp,
+            closed_at,
+            _clean_text(evidence_ref, max_chars=240),
+            _clean_text(action_ref_type, max_chars=80),
+            _clean_text(action_ref_id, max_chars=180),
+            int(outcome_id) if outcome_id is not None else None,
+            _json(merged_metadata),
+            commitment_id.strip(),
+        ),
+    )
+    conn.commit()
+    updated = conn.execute("SELECT * FROM commitments WHERE id = ?", (commitment_id.strip(),)).fetchone()
+    result = _row_dict(updated)
+    result["ok"] = True
+    return result
+
+
+def resolve_matching_commitments(
+    *,
+    session_id: str = "",
+    evidence_text: str = "",
+    action_ref_type: str = "",
+    action_ref_id: str = "",
+    evidence_ref: str = "",
+    status: str = "fulfilled",
+    limit: int = 5,
+) -> dict[str, Any]:
+    """Close active commitments when completion evidence overlaps enough."""
+    terms = _tokens(evidence_text)
+    if not terms and not (action_ref_type and action_ref_id):
+        return {"ok": True, "resolved": 0, "items": [], "reason": "no_matching_signal"}
+    candidates = list_commitments(session_id=session_id, status="open", limit=max(1, min(limit, 20)))
+    resolved: list[dict[str, Any]] = []
+    for item in candidates:
+        action_match = (
+            bool(action_ref_type and action_ref_id)
+            and item.get("action_ref_type") == action_ref_type
+            and item.get("action_ref_id") == action_ref_id
+        )
+        statement_terms = _tokens(str(item.get("statement") or ""))
+        matched_terms = terms & statement_terms
+        overlap = len(matched_terms) / max(1, len(statement_terms))
+        required_matches = max(4, math.ceil(len(statement_terms) * 0.55))
+        strong_text_match = bool(
+            len(matched_terms) >= required_matches
+            and overlap >= 0.65
+        )
+        if not action_match and not strong_text_match:
+            continue
+        resolved.append(
+            update_commitment_status(
+                str(item.get("id")),
+                status=status,
+                evidence_ref=evidence_ref,
+                action_ref_type=action_ref_type,
+                action_ref_id=action_ref_id,
+                metadata={
+                    "resolved_by": "action_ref" if action_match else "strong_matching_evidence",
+                    "overlap": round(overlap, 4),
+                    "matched_terms": sorted(matched_terms)[:12],
+                },
+            )
+        )
+        if len(resolved) >= limit:
+            break
+    return {"ok": True, "resolved": len(resolved), "items": resolved}
+
+
+__all__ = [
+    "create_commitment",
+    "list_commitments",
+    "update_commitment_status",
+    "resolve_matching_commitments",
+]

package/src/db/_entities.py

@@ -1,30 +1,101 @@
 from __future__ import annotations
 """NEXO DB — Entities module."""
+import json
 import time
 from db._core import get_db, _multi_word_like
 from db._fts import fts_upsert
 
 # ── Entities ──────────────────────────────────────────────────────
 
-def create_entity(name: str, type: str, value: str, notes: str = "") -> int:
+
+def _json_text(value, default):
+    if value in (None, ""):
+        value = default
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, ensure_ascii=False, sort_keys=True)
+    except Exception:
+        return json.dumps(default, ensure_ascii=False, sort_keys=True)
+
+
+def _entity_columns(conn) -> set[str]:
+    try:
+        return {str(row["name"]) for row in conn.execute("PRAGMA table_info(entities)").fetchall()}
+    except Exception:
+        return set()
+
+
+def _entity_search_columns(conn) -> list[str]:
+    columns = ["name", "value"]
+    available = _entity_columns(conn)
+    if "aliases" in available:
+        columns.append("aliases")
+    if "metadata" in available:
+        columns.append("metadata")
+    return columns
+
+
+def _entity_fts_content(row: dict) -> str:
+    return " ".join(
+        str(row.get(key) or "")
+        for key in ("name", "value", "notes", "aliases", "metadata", "access_mode")
+    )
+
+
+def create_entity(
+    name: str,
+    type: str,
+    value: str,
+    notes: str = "",
+    aliases=None,
+    metadata=None,
+    source: str = "manual",
+    confidence: float = 1.0,
+    access_mode: str = "unknown",
+) -> int:
     """Create a new entity. Returns the entity ID."""
     conn = get_db()
     now = time.time()
+    row = {
+        "name": name,
+        "type": type,
+        "value": value,
+        "notes": notes,
+        "aliases": _json_text(aliases, []),
+        "metadata": _json_text(metadata, {}),
+        "source": source or "manual",
+        "confidence": float(confidence if confidence is not None else 1.0),
+        "access_mode": access_mode or "unknown",
+        "created_at": now,
+        "updated_at": now,
+    }
+    available = _entity_columns(conn)
+    columns = [
+        key
+        for key in (
+            "name", "type", "value", "notes", "aliases", "metadata",
+            "source", "confidence", "access_mode", "created_at", "updated_at",
+        )
+        if key in available
+    ]
+    if not columns:
+        columns = ["name", "type", "value", "notes", "created_at", "updated_at"]
     cursor = conn.execute(
-        "INSERT INTO entities (name, type, value, notes, created_at, updated_at) "
-        "VALUES (?, ?, ?, ?, ?, ?)",
-        (name, type, value, notes, now, now)
+        f"INSERT INTO entities ({', '.join(columns)}) "
+        f"VALUES ({', '.join('?' for _ in columns)})",
+        tuple(row[key] for key in columns),
     )
     conn.commit()
     eid = cursor.lastrowid
-    fts_upsert("entity", str(eid), name, f"{name} {value} {notes}", type or "general", commit=False)
+    fts_upsert("entity", str(eid), name, _entity_fts_content(row), type or "general", commit=False)
     return eid
 
 
 def search_entities(query: str, type: str = "") -> list[dict]:
     """Search entities by name or value. Multi-word AND search."""
     conn = get_db()
-    frag, params = _multi_word_like(query, ["name", "value"])
+    frag, params = _multi_word_like(query, _entity_search_columns(conn))
     if type:
         where = f"type = ? AND ({frag})"
         params.insert(0, type)
@@ -53,12 +124,23 @@ def list_entities(type: str = "") -> list[dict]:
 
 
 def update_entity(id: int, **kwargs):
-    """Update entity fields: name, type, value, notes."""
+    """Update entity fields, including extended alias/metadata/access fields."""
     conn = get_db()
-    allowed = {"name", "type", "value", "notes"}
+    allowed = {
+        "name", "type", "value", "notes", "aliases", "metadata",
+        "source", "confidence", "access_mode",
+    }
+    available = _entity_columns(conn)
+    allowed &= available
     updates = {k: v for k, v in kwargs.items() if k in allowed}
     if not updates:
             return
+    if "aliases" in updates:
+        updates["aliases"] = _json_text(updates["aliases"], [])
+    if "metadata" in updates:
+        updates["metadata"] = _json_text(updates["metadata"], {})
+    if "confidence" in updates:
+        updates["confidence"] = float(updates["confidence"] if updates["confidence"] is not None else 1.0)
     updates["updated_at"] = time.time()
     set_clause = ", ".join(f"{k} = ?" for k in updates)
     values = list(updates.values()) + [id]
@@ -67,7 +149,14 @@ def update_entity(id: int, **kwargs):
     row = conn.execute("SELECT * FROM entities WHERE id = ?", (id,)).fetchone()
     if row:
         r = dict(row)
-        fts_upsert("entity", str(id), r.get("name",""), f"{r.get('name','')} {r.get('value','')} {r.get('notes','')}", r.get("type","general"), commit=False)
+        fts_upsert(
+            "entity",
+            str(id),
+            r.get("name", ""),
+            _entity_fts_content(r),
+            r.get("type", "general"),
+            commit=False,
+        )
 
 
 def delete_entity(id: int) -> bool:
@@ -175,5 +264,3 @@ def delete_agent(id: str) -> bool:
     result = conn.execute("DELETE FROM agents WHERE id = ?", (id,))
     conn.commit()
     return result.rowcount > 0
-
-