nexo-brain 7.31.13 → 7.33.0

package/src/local_context/api.py

@@ -50,6 +50,12 @@ INITIAL_INDEX_STARTED_AT_KEY = "initial_index_started_at"
 PERFORMANCE_PROFILE_KEY = "performance_profile"
 DEFAULT_PERFORMANCE_PROFILE = os.environ.get("NEXO_LOCAL_INDEX_PERFORMANCE_PROFILE", "medium").strip().lower() or "medium"
 VALID_CONTEXT_MODES = {"compact", "full"}
+# FTS5 keyword recall over local_chunks. Additive, guarded, reversible.
+# Backfill batch size; 0 disables the incremental backfill entirely.
+FTS_BACKFILL_BATCH = int(os.environ.get("NEXO_LOCAL_FTS_BACKFILL_BATCH", "500") or "500")
+FTS_MIGRATION_CURSOR_KEY = "fts_migration_cursor"
+FTS_MIGRATION_DONE_KEY = "fts_migration_done"
+FTS_BACKFILL_TOTAL_KEY = "fts_backfill_total"
 EMBEDDING_REFRESH_JOB = "embedding_refresh"
 ENTITY_FACTS_JOB = "entity_facts"
 BACKGROUND_INDEX_JOB_TYPES = {ENTITY_FACTS_JOB}
@@ -3541,6 +3547,14 @@ def run_once(
         }
     scan_result = scan_once(limit=effective_scan_limit)
     job_result = process_jobs(limit=effective_process_limit)
+    # Incremental FTS backfill: bounded one-batch-per-tick, after the disk-budget
+    # gate (above) and after process_jobs. Best-effort — never let it break the
+    # cron tick. Skips itself when disabled (batch=0) or already done.
+    if FTS_BACKFILL_BATCH > 0:
+        try:
+            _backfill_fts_rows(conn, batch_limit=FTS_BACKFILL_BATCH)
+        except Exception:
+            pass
     conn_after = _conn()
     initial_after = _initial_scan_status(conn_after, list_roots(readonly=False))
     blocking_active_after = _active_job_count(conn_after, blocking_only=True)
@@ -4109,6 +4123,32 @@ def _status_from_conn(conn, *, readonly: bool = False) -> dict:
         "permissions": [],
         "models": model_status()["models"],
         "support_log_available": True,
+        "fts_recall": _fts_status(conn),
+    }
+
+
+def _fts_status(conn) -> dict:
+    """Operator-facing FTS5 backfill progress (so progress can be watched)."""
+    try:
+        done = _get_state_conn(conn, FTS_MIGRATION_DONE_KEY, "0") == "1"
+    except Exception:
+        done = False
+    try:
+        cursor = int(_get_state_conn(conn, FTS_MIGRATION_CURSOR_KEY, "0") or "0")
+    except Exception:
+        cursor = 0
+    try:
+        total = int(_get_state_conn(conn, FTS_BACKFILL_TOTAL_KEY, "0") or "0")
+    except Exception:
+        total = 0
+    return {
+        "enabled": _fts_enabled_env(),
+        "available": _fts_available(conn),
+        "done": done,
+        "cursor": cursor,
+        "total": total,
+        "read_path": "fts" if _fts_ready(conn) else "like",
+        "backfill_batch": FTS_BACKFILL_BATCH,
     }
 
 
@@ -4433,6 +4473,136 @@ def _context_prefilter_limit(default: int = 1200) -> int:
     return max(100, min(value, 5000))
 
 
+def _fts_enabled_env() -> bool:
+    """Feature flag for the FTS5 read path (default on; set 0/false to roll back)."""
+    value = os.environ.get("NEXO_LOCAL_CONTEXT_FTS_ENABLED", "1").strip().lower()
+    return value not in {"0", "false", "no", "off"}
+
+
+def _fts_available(conn) -> bool:
+    """True if the local_chunks_fts FTS5 vtab exists and MATCH works.
+
+    Hosts without FTS5 support fall back to a plain shadow table that does NOT
+    support MATCH, so the cheap probe runs a trivial MATCH and catches
+    OperationalError. The probe (a sqlite_master lookup + MATCH LIMIT 0) is fast
+    enough to run inline without caching, which avoids stale per-connection
+    cache bugs across reconnects.
+    """
+    try:
+        row = conn.execute(
+            "SELECT 1 FROM sqlite_master WHERE type IN ('table','view') AND name='local_chunks_fts' LIMIT 1"
+        ).fetchone()
+        if not row:
+            return False
+        # Trivial MATCH proves this is a real FTS5 vtab (shadow fallback raises).
+        conn.execute(
+            "SELECT rowid FROM local_chunks_fts WHERE local_chunks_fts MATCH ? LIMIT 0",
+            ("nexo_fts_probe",),
+        ).fetchall()
+        return True
+    except sqlite3.OperationalError:
+        return False
+    except Exception:
+        return False
+
+
+def _fts_ready(conn) -> bool:
+    """The FTS read path is authoritative only when: backfill done AND the
+    feature flag is on AND FTS5 is actually available on this host."""
+    if not _fts_enabled_env():
+        return False
+    if _get_state_conn(conn, FTS_MIGRATION_DONE_KEY, "0") != "1":
+        return False
+    return _fts_available(conn)
+
+
+def _fts_match_expr(terms: list[str]) -> str:
+    """Build a safe FTS5 MATCH expression from query terms.
+
+    Each term is double-quoted (FTS5 phrase syntax) with embedded double quotes
+    doubled, neutralizing FTS operators/special chars; terms are OR-joined.
+    Returns '' when there is nothing safe to match.
+    """
+    quoted = []
+    for term in terms:
+        cleaned = str(term or "").strip()
+        if not cleaned:
+            continue
+        quoted.append('"' + cleaned.replace('"', '""') + '"')
+    return " OR ".join(quoted)
+
+
+def _backfill_fts_rows(conn, *, batch_limit: int | None = None) -> dict:
+    """Incrementally mirror legacy local_chunks rows into local_chunks_fts.
+
+    Idempotent + resumable: a cursor (max processed rowid) is persisted in
+    local_index_state per batch and committed, so a crash resumes from the last
+    committed rowid. INSERT OR REPLACE keyed by rowid makes re-runs safe.
+    When no rows remain past the cursor the done flag is set. Returns a small
+    status dict. NOTE: new chunks written after schema migration already get FTS
+    rows via the local_chunks_fts triggers, so this only handles pre-existing
+    rows (the legacy 19GB DB).
+    """
+    if batch_limit is None:
+        batch_limit = FTS_BACKFILL_BATCH
+    batch_limit = int(batch_limit)
+    if batch_limit <= 0:
+        return {"ok": True, "skipped": "disabled", "done": _get_state_conn(conn, FTS_MIGRATION_DONE_KEY, "0") == "1"}
+    if not _fts_available(conn):
+        return {"ok": True, "skipped": "fts_unavailable", "done": False}
+    if _get_state_conn(conn, FTS_MIGRATION_DONE_KEY, "0") == "1":
+        return {"ok": True, "skipped": "already_done", "done": True}
+
+    def _run() -> dict:
+        try:
+            cursor = int(_get_state_conn(conn, FTS_MIGRATION_CURSOR_KEY, "0") or "0")
+        except Exception:
+            cursor = 0
+        # Snapshot the total once (first backfill tick) so the operator status
+        # surface can show progress without a COUNT(*) on the 19GB table per tick.
+        if _get_state_conn(conn, FTS_BACKFILL_TOTAL_KEY, "") == "":
+            try:
+                total_row = conn.execute("SELECT COUNT(*) AS total FROM local_chunks").fetchone()
+                _set_state_conn(conn, FTS_BACKFILL_TOTAL_KEY, str(int(total_row["total"] or 0)))
+            except Exception:
+                pass
+        rows = conn.execute(
+            """
+            SELECT c.rowid AS rid, c.text AS text,
+                   COALESCE(a.privacy_class, 'normal') AS privacy_class,
+                   COALESCE(a.status, 'active') AS asset_status
+            FROM local_chunks c
+            LEFT JOIN local_assets a ON a.asset_id = c.asset_id
+            WHERE c.rowid > ?
+            ORDER BY c.rowid ASC
+            LIMIT ?
+            """,
+            (cursor, batch_limit),
+        ).fetchall()
+        if not rows:
+            _set_state_conn(conn, FTS_MIGRATION_DONE_KEY, "1")
+            conn.commit()
+            return {"ok": True, "done": True, "processed": 0, "cursor": cursor}
+        max_rid = cursor
+        for row in rows:
+            rid = int(row["rid"])
+            conn.execute("DELETE FROM local_chunks_fts WHERE rowid = ?", (rid,))
+            conn.execute(
+                """
+                INSERT INTO local_chunks_fts(rowid, text, privacy_class, asset_status)
+                VALUES (?, ?, ?, ?)
+                """,
+                (rid, str(row["text"] or ""), str(row["privacy_class"] or "normal"), str(row["asset_status"] or "active")),
+            )
+            if rid > max_rid:
+                max_rid = rid
+        _set_state_conn(conn, FTS_MIGRATION_CURSOR_KEY, str(max_rid))
+        conn.commit()
+        return {"ok": True, "done": False, "processed": len(rows), "cursor": max_rid}
+
+    return _with_sqlite_busy_retry(_run)
+
+
 def _context_candidate_rows(
     conn,
     entity_asset_ids: list[str],
@@ -4444,39 +4614,73 @@ def _context_candidate_rows(
     prefilter_limit = min(int(base_limit or 5000), _context_prefilter_limit())
     prefilter_rows = []
     if terms:
-        term_clauses = []
-        params: list[str] = []
-        for term in terms:
-            term_clauses.append("(lower(a.path) LIKE ? OR lower(COALESCE(v.summary, '')) LIKE ? OR lower(c.text) LIKE ?)")
-            like = f"%{term}%"
-            params.extend([like, like, like])
-        prefilter_rows = conn.execute(
-            f"""
-            SELECT c.chunk_id, c.asset_id, c.text, a.path, a.file_type, a.privacy_class, v.summary,
-                   e.vector_json, e.model_id, e.model_revision, e.dimension
-            FROM local_chunks c
-            JOIN local_assets a ON a.asset_id = c.asset_id
-            LEFT JOIN local_asset_versions v ON v.version_id = c.version_id
-            LEFT JOIN local_embeddings e ON e.chunk_id = c.chunk_id
-            WHERE a.status='active'
-              AND a.privacy_class='normal'
-              AND ({" OR ".join(term_clauses)})
-            ORDER BY
-              CASE
-                WHEN {" OR ".join("lower(a.path) LIKE ?" for _ in terms)} THEN 0
-                WHEN {" OR ".join("lower(COALESCE(v.summary, '')) LIKE ?" for _ in terms)} THEN 1
-                ELSE 2
-              END,
-              c.created_at DESC
-            LIMIT ?
-            """,
-            [
-                *params,
-                *(f"%{term}%" for term in terms),
-                *(f"%{term}%" for term in terms),
-                prefilter_limit,
-            ],
-        ).fetchall()
+        used_fts = False
+        # DUAL-READ: only take the FTS path once the backfill is done AND the
+        # flag is on AND FTS5 is available. Until then (or on rollback) the
+        # EXACT legacy LIKE path runs, so retrieval is unaffected mid-migration.
+        if _fts_ready(conn):
+            match_expr = _fts_match_expr(terms)
+            if match_expr:
+                try:
+                    prefilter_rows = conn.execute(
+                        """
+                        SELECT c.chunk_id, c.asset_id, c.text, a.path, a.file_type, a.privacy_class, v.summary,
+                               e.vector_json, e.model_id, e.model_revision, e.dimension
+                        FROM local_chunks_fts f
+                        JOIN local_chunks c ON c.rowid = f.rowid
+                        JOIN local_assets a ON a.asset_id = c.asset_id
+                        LEFT JOIN local_asset_versions v ON v.version_id = c.version_id
+                        LEFT JOIN local_embeddings e ON e.chunk_id = c.chunk_id
+                        WHERE local_chunks_fts MATCH ?
+                          AND f.privacy_class='normal'
+                          AND f.asset_status='active'
+                          AND a.status='active'
+                          AND a.privacy_class='normal'
+                        ORDER BY bm25(local_chunks_fts), c.created_at DESC
+                        LIMIT ?
+                        """,
+                        (match_expr, prefilter_limit),
+                    ).fetchall()
+                    used_fts = True
+                except sqlite3.OperationalError:
+                    # Malformed FTS expression (odd user input) -> fall back to
+                    # the legacy LIKE path below instead of erroring the answer.
+                    prefilter_rows = []
+                    used_fts = False
+        if not used_fts:
+            term_clauses = []
+            params: list[str] = []
+            for term in terms:
+                term_clauses.append("(lower(a.path) LIKE ? OR lower(COALESCE(v.summary, '')) LIKE ? OR lower(c.text) LIKE ?)")
+                like = f"%{term}%"
+                params.extend([like, like, like])
+            prefilter_rows = conn.execute(
+                f"""
+                SELECT c.chunk_id, c.asset_id, c.text, a.path, a.file_type, a.privacy_class, v.summary,
+                       e.vector_json, e.model_id, e.model_revision, e.dimension
+                FROM local_chunks c
+                JOIN local_assets a ON a.asset_id = c.asset_id
+                LEFT JOIN local_asset_versions v ON v.version_id = c.version_id
+                LEFT JOIN local_embeddings e ON e.chunk_id = c.chunk_id
+                WHERE a.status='active'
+                  AND a.privacy_class='normal'
+                  AND ({" OR ".join(term_clauses)})
+                ORDER BY
+                  CASE
+                    WHEN {" OR ".join("lower(a.path) LIKE ?" for _ in terms)} THEN 0
+                    WHEN {" OR ".join("lower(COALESCE(v.summary, '')) LIKE ?" for _ in terms)} THEN 1
+                    ELSE 2
+                  END,
+                  c.created_at DESC
+                LIMIT ?
+                """,
+                [
+                    *params,
+                    *(f"%{term}%" for term in terms),
+                    *(f"%{term}%" for term in terms),
+                    prefilter_limit,
+                ],
+            ).fetchall()
 
     fallback_limit = prefilter_limit if not terms else max(120, min(500, prefilter_limit // 3))
     base_rows = conn.execute(

package/src/local_context/db.py

@@ -8,7 +8,7 @@ from typing import Iterable
 from urllib.parse import quote
 
 import paths
-from db._schema import _m63_local_context_layer, _m64_local_context_live_dirs
+from db._schema import _m63_local_context_layer, _m64_local_context_live_dirs, _m84_local_chunks_fts
 
 LOCAL_CONTEXT_DB_NAME = "local-context.db"
 MIGRATION_STATE_KEY = "local_context_db_migrated_from_main"
@@ -118,7 +118,8 @@ def _ensure_schema(conn: sqlite3.Connection) -> None:
     _m64_local_context_live_dirs(conn)
     _ensure_entity_dossier_schema(conn)
     _ensure_local_context_v2_schema(conn)
-    conn.execute("PRAGMA user_version=65")
+    _m84_local_chunks_fts(conn)
+    conn.execute("PRAGMA user_version=84")
     conn.commit()
 
 

package/src/memory_retrieval.py

@@ -9,12 +9,24 @@ from typing import Any
 
 from db import (
     build_pre_action_context,
+    get_memory_observations_by_uids,
     list_memory_events,
     list_memory_observations,
     process_memory_observation_queue,
     search_memory_observations_fts,
+    vector_scan_observations,
 )
 
+# Weight for the semantic (vector) signal when fused with the lexical/FTS score.
+# A strong paraphrase match (high cosine) can carry an observation that the
+# token-overlap score missed entirely, while still ranking below an exact
+# lexical hit on the same query.
+_VECTOR_FUSION_WEIGHT = 0.85
+# Minimum cosine for a semantic-only candidate to survive the relaxed filter.
+# Below this, a vector "match" is noise and must not resurrect an observation
+# that the lexical path already rejected.
+_VECTOR_MIN_SCORE = 0.30
+
 
 def _tokens(text: str) -> set[str]:
     return {
@@ -37,6 +49,41 @@ def _score(query: str, text: str, base: float = 0.0) -> float:
     return min(1.0, base + len(overlap) / max(1, len(query_tokens)))
 
 
+def _model_is_warm() -> bool:
+    """True only when embedding the query will NOT trigger a cold model load."""
+    try:
+        import cognitive._core as cog
+    except Exception:
+        return False
+    try:
+        if cog._model_download_disabled():
+            return True
+    except Exception:
+        return False
+    return getattr(cog, "_model", None) is not None
+
+
+def _maybe_query_embedding(query: str):
+    """Embed the query ONCE for semantic fusion, or return None.
+
+    CRITICAL latency guard: this never loads a cold model. It returns None
+    (degrading to the FTS/token path) unless the deterministic offline fallback
+    is active or the real model is already warm in-process. Any failure also
+    yields None.
+    """
+    clean = (query or "").strip()
+    if not clean:
+        return None
+    if not _model_is_warm():
+        return None
+    try:
+        import cognitive._core as cog
+
+        return cog.embed(clean)
+    except Exception:
+        return None
+
+
 def _project_hint_values(project_hint: str = "") -> set[str]:
     clean = (project_hint or "").strip()
     if not clean:
@@ -225,6 +272,30 @@ def memory_search(
     ):
         uid = item.get("observation_uid") or f"id:{item.get('id')}"
         observations_by_uid.setdefault(uid, item)
+    # Semantic fusion: embed the query ONCE (only when a model is already warm —
+    # never trigger a cold model load on this latency path) and run a bounded
+    # vector scan over precomputed observation embeddings. Paraphrases that the
+    # lexical/FTS path missed are pulled in here.
+    vector_scores: dict[str, float] = {}
+    if clean_query:
+        query_vector = _maybe_query_embedding(clean_query)
+        if query_vector is not None:
+            for hit in vector_scan_observations(
+                query_vector,
+                limit=max_items * 3,
+                start_ts=start,
+                end_ts=end,
+                min_score=_VECTOR_MIN_SCORE,
+            ):
+                uid = hit.get("observation_uid")
+                if uid:
+                    vector_scores[uid] = float(hit.get("vector_score") or 0.0)
+            # Materialise semantic-only observations the lexical scan did not see.
+            missing_uids = [uid for uid in vector_scores if uid not in observations_by_uid]
+            if missing_uids:
+                for uid, item in get_memory_observations_by_uids(missing_uids).items():
+                    observations_by_uid.setdefault(uid, item)
+
     observations = list(observations_by_uid.values())
     events = list_memory_events(
         query=clean_query,
@@ -234,12 +305,23 @@ def memory_search(
         end_ts=end,
     )
 
-    candidates = [
-        _observation_to_candidate(item, clean_query)
-        for item in observations
-        if _within_range(item.get("created_at"), start, end)
-        and _project_matches(item.get("project_key") or "", project_hint)
-    ]
+    candidates = []
+    for item in observations:
+        if not _within_range(item.get("created_at"), start, end):
+            continue
+        if not _project_matches(item.get("project_key") or "", project_hint):
+            continue
+        candidate = _observation_to_candidate(item, clean_query)
+        uid = item.get("observation_uid") or f"id:{item.get('id')}"
+        vector_score = vector_scores.get(uid, 0.0)
+        if vector_score > 0:
+            # Fuse: keep the higher of the lexical score and the weighted vector
+            # signal so a strong paraphrase survives while exact lexical hits
+            # still outrank weak semantic ones.
+            fused = max(float(candidate.get("score") or 0.0), _VECTOR_FUSION_WEIGHT * vector_score)
+            candidate["score"] = round(fused, 4)
+            candidate["vector_score"] = round(vector_score, 4)
+        candidates.append(candidate)
     candidates.extend(
         _event_to_candidate(item, clean_query)
         for item in events
@@ -248,7 +330,14 @@ def memory_search(
     )
 
     if clean_query:
-        candidates = [item for item in candidates if item.get("score", 0) > 0]
+        # Relaxed filter: a candidate survives if it has a positive lexical score
+        # OR a qualifying semantic (vector) match. Previously the hard score>0
+        # filter dropped semantic-only paraphrase hits before they could rank.
+        candidates = [
+            item
+            for item in candidates
+            if item.get("score", 0) > 0 or item.get("vector_score", 0) > 0
+        ]
     candidates.sort(key=lambda item: (item.get("score", 0), item.get("created_at") or 0), reverse=True)
     candidates = candidates[:max_items]
 

package/src/plugins/protocol.py

@@ -1437,6 +1437,7 @@ def handle_confidence_check(
     unknowns: str = "[]",
     verification_step: str = "",
     stakes: str = "",
+    sid: str = "",
 ) -> str:
     """Return the metacognitive response mode: answer, verify, ask, or defer."""
     clean_goal = (goal or "").strip()
@@ -1465,6 +1466,37 @@ def handle_confidence_check(
         verification_step=(verification_step or "").strip(),
         stakes=(stakes or "").strip(),
     )
+    # Persist the check so the G1 answer-contract gate can detect fulfillment of
+    # verify/ask/defer contracts (this table was previously never written, so
+    # verify contracts were structurally unfulfillable). Best-effort: a failure
+    # here must never break the metacognitive answer — g1 simply re-nudges, a
+    # visible signal rather than a silent corruption.
+    try:
+        import hashlib
+        from db import get_db
+        from plugins.guard import _resolve_active_sid
+        conn = get_db()
+        resolved_sid = (sid or "").strip() or _resolve_active_sid(conn)
+        if resolved_sid:
+            conn.execute(
+                """INSERT INTO confidence_checks
+                   (session_id, task_id, goal_hash, task_type, area,
+                    response_mode, confidence, high_stakes, created_at)
+                   VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'))""",
+                (
+                    resolved_sid,
+                    "",
+                    hashlib.sha256(clean_goal.encode("utf-8")).hexdigest()[:16],
+                    clean_type,
+                    (area or "").strip(),
+                    str(result.get("mode") or ""),
+                    int(result.get("confidence") or 0),
+                    1 if result.get("high_stakes") else 0,
+                ),
+            )
+            conn.commit()
+    except Exception:
+        pass
     return json.dumps({"ok": True, **result}, ensure_ascii=False, indent=2)
 
 
@@ -2138,31 +2170,30 @@ def handle_task_close(
         limit=3,
     )
     if pending_corrections:
-        debt = _ensure_open_debt(
-            task["session_id"],
-            task_id,
-            "missing_learning_after_correction",
-            severity="error",
-            evidence=(
-                "User correction was detected for this session and has not "
-                "been resolved by nexo_learning_add. task_close is blocked "
-                "until a durable learning is persisted."
-            ),
-            debts=debts_created,
-        )
-        return json.dumps(
-            {
-                "ok": False,
-                "error": "Cannot close task while a detected user correction has no durable nexo_learning_add.",
-                "hint": "Call nexo_learning_add with the reusable rule learned from the correction, then retry nexo_task_close.",
-                "task_id": task_id,
-                "blocked_by": "d5_correction_learning_required",
-                "debt_id": debt.get("id"),
-                "pending_corrections": len(pending_corrections),
-            },
-            ensure_ascii=False,
-            indent=2,
+        # SOFT enforcement (Ola 1): do NOT block the close. A detected user
+        # correction without a durable nexo_learning_add opens/dedupes an
+        # error-severity protocol_debt and the task still closes. The daily
+        # self-audit + correction_requirement_summary surface the open debt, and
+        # if THIS close supplies the learning, the `if correction:` block below
+        # captures it and resolves both the requirement and the debt. A hard
+        # block here interrupted the operator on every correction (friction);
+        # the debt is the non-blocking signal instead.
+        learning_in_this_close = bool(
+            (learning_title or "").strip() and (learning_content or "").strip()
         )
+        if not learning_in_this_close:
+            _ensure_open_debt(
+                task["session_id"],
+                task_id,
+                "missing_learning_after_correction",
+                severity="error",
+                evidence=(
+                    "User correction detected for this session without a durable "
+                    "nexo_learning_add; debt opened (soft enforcement) — task closed "
+                    "but a follow-up learning is required."
+                ),
+                debts=debts_created,
+            )
 
     # ── Evidence enforcement: reject 'done' without proof ──
     # G1 hardening: "done" is no longer allowed to degrade into a debt-only
@@ -2350,6 +2381,22 @@ def handle_task_close(
                     debt_types=["missing_change_log"],
                     resolution="Change log created by nexo_task_close",
                 )
+                # Cognitive OS Ola 1 — materialize causal/provenance edges from the
+                # closed task (task→change_log "ops:produced" + change_log→task
+                # "causal:motivated_by"). record_task_close_edges had NO caller, so
+                # the causal graph stayed empty (0 candidates) and could never feed
+                # connect-the-dots at answer time. Best-effort: graph wiring must
+                # never break a task close.
+                try:
+                    import causal_graph
+                    causal_graph.record_task_close_edges(
+                        task_id=task_id,
+                        change_log_id=change_log_id,
+                        project_key=str(task.get("project_hint") or task.get("area") or ""),
+                        reason_public=(clean_change_summary or task.get("goal") or "")[:200],
+                    )
+                except Exception:
+                    pass
         else:
             debt = _ensure_open_debt(
                 task["session_id"],