nexo-brain 7.30.6 → 7.30.8

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.6",
+  "version": "7.30.8",
   "description": "Local cognitive runtime for Claude Code \u2014 persistent memory, overnight learning, doctor diagnostics, personal scripts, recovery-aware jobs, startup preflight, and optional dashboard/power helper.",
   "author": {
     "name": "NEXO Brain",

package/README.md

@@ -18,7 +18,11 @@
 
 [Watch the overview video](https://nexo-brain.com/watch/) · [Watch on YouTube](https://www.youtube.com/watch?v=i2lkGhKyVqI) · [Open the infographic](https://nexo-brain.com/assets/nexo-brain-infographic-v5.png)
 
-Version `7.30.6` is the current packaged-runtime line. Patch release over v7.30.5 - Deep Sleep now rotates its operational artifacts and logs automatically, keeping historical installs bounded without touching local-context memory.
+Version `7.30.8` is the current packaged-runtime line. Patch release over v7.30.7 - Deep Sleep now folds parallel Codex sub-agents into their parent thread and Local Context stops the `entity_facts` cartesian blow-up that created runaway sidecar databases.
+
+Previously in `7.30.7`: patch release over v7.30.6 - the Deep Sleep retention update is republished with the required release smoke contract so final closeout, npm, GitHub, and runtime verification stay aligned.
+
+Previously in `7.30.6`: patch release over v7.30.5 - Deep Sleep now rotates its operational artifacts and logs automatically, keeping historical installs bounded without touching local-context memory.
 
 Previously in `7.30.4`: patch release over v7.30.3 - local runtime update post-sync now gives bounded Memory Fabric repair enough time to finish, and headless automations now treat `nexo_stop` as a terminal close so followup/deep-sleep runners do not reopen no-op protocol loops.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.6",
+  "version": "7.30.8",
   "mcpName": "io.github.wazionapps/nexo",
   "description": "NEXO Brain — Shared brain for AI agents. Persistent memory, semantic RAG, natural forgetting, metacognitive guard, trust scoring, 150+ MCP tools. Works with Claude Code, Codex, Claude Desktop & any MCP client. 100% local, free.",
   "homepage": "https://nexo-brain.com",

package/src/local_context/api.py

@@ -55,6 +55,10 @@ ENTITY_DOSSIER_MAX_ASSETS = int(os.environ.get("NEXO_ENTITY_DOSSIER_MAX_ASSETS",
 ENTITY_DOSSIER_MAX_CHUNKS = int(os.environ.get("NEXO_ENTITY_DOSSIER_MAX_CHUNKS", "1200") or "1200")
 ENTITY_DOSSIER_MAX_FACTS = int(os.environ.get("NEXO_ENTITY_DOSSIER_MAX_FACTS", "3000") or "3000")
 ENTITY_FACT_MIN_CONFIDENCE = float(os.environ.get("NEXO_ENTITY_FACT_MIN_CONFIDENCE", "0.45") or "0.45")
+# Hard ceilings to stop the entity_facts cartesian blow-up (chunks × entities × candidates).
+# Without these a single document could emit thousands of facts; 258k assets produced 337M rows / 255 GB.
+ENTITY_FACTS_MAX_PER_ASSET = int(os.environ.get("NEXO_ENTITY_FACTS_MAX_PER_ASSET", "200") or "200")
+ENTITY_FACT_MAX_VALUE_LEN = int(os.environ.get("NEXO_ENTITY_FACT_MAX_VALUE_LEN", "240") or "240")
 ENTITY_FACTS_LLM_ENABLED = os.environ.get("NEXO_ENTITY_FACTS_LLM_ENABLED", "1").strip().lower() not in {"0", "false", "no", "off"}
 LOCAL_PRESENCE_MODEL_SPEC = "qwen3-0.6b-q4-local-presence"
 FOREGROUND_GOVERNOR_ENABLED = os.environ.get("NEXO_LOCAL_INDEX_FOREGROUND_GOVERNOR", "1").strip().lower() not in {"0", "false", "no", "off"}
@@ -3133,28 +3137,42 @@ def _replace_entity_facts(conn, asset_id: str) -> int:
     ).fetchall()
     inserted = 0
     for chunk in chunks:
+        if inserted >= ENTITY_FACTS_MAX_PER_ASSET:
+            break
         text = str(chunk["text"] or "")
         if not text or contains_secret(text):
             continue
         candidates = _fact_candidate_lines(text)
         if not candidates:
             candidates = [("mencion", sentence.strip(), 0.48) for sentence in re.split(r"(?<=[.!?])\s+", text) if sentence.strip()][:4]
+        chunk_id = str(chunk["chunk_id"] or "")
         for entity in entities_by_id.values():
+            if inserted >= ENTITY_FACTS_MAX_PER_ASSET:
+                break
             aliases = sorted(alias for alias in entity["aliases"] if alias)
-            direct = _chunk_mentions_entity(text, aliases)
+            # Only attribute a chunk's facts to entities actually mentioned in THAT chunk.
+            # Previously every candidate was attached to every entity in the asset (a
+            # chunks × entities × candidates cartesian product) which produced 337M junk
+            # rows / 255 GB. Gating on mention is both the size fix and the correctness fix.
+            if not _chunk_mentions_entity(text, aliases):
+                continue
             for predicate, value, base_confidence in candidates:
-                predicate = _strip_entity_aliases_from_predicate(predicate, aliases)
-                confidence = base_confidence if direct else min(base_confidence, 0.56)
-                if confidence < ENTITY_FACT_MIN_CONFIDENCE:
+                if inserted >= ENTITY_FACTS_MAX_PER_ASSET:
+                    break
+                # Drop paragraph-as-fact noise: real facts carry short values.
+                if len(value) > ENTITY_FACT_MAX_VALUE_LEN:
                     continue
+                if base_confidence < ENTITY_FACT_MIN_CONFIDENCE:
+                    continue
+                predicate = _strip_entity_aliases_from_predicate(predicate, aliases)
                 if _insert_entity_fact(
                     conn,
                     entity_id=entity["entity_id"],
                     predicate=predicate,
                     value=value,
                     source_asset_id=asset_id,
-                    source_chunk_id=str(chunk["chunk_id"] or ""),
-                    confidence=confidence,
+                    source_chunk_id=chunk_id,
+                    confidence=base_confidence,
                 ):
                     inserted += 1
     return inserted

package/src/scripts/deep-sleep/collect.py

@@ -155,6 +155,117 @@ def collect_transcripts_since(since_iso: str, until_iso: str = "") -> list[dict]
     return _transcripts.collect_transcripts_since(since_iso, until_iso)
 
 
+# ── Fold parallel sub-agent threads into their parent ──────────────────────
+
+
+def _is_subagent(session: dict) -> bool:
+    """True when a session was spawned as a sub-agent thread of another session."""
+    if str(session.get("thread_source", "")).strip().lower() == "subagent":
+        return True
+    if str(session.get("parent_thread_id", "") or "").strip():
+        return True
+    source = session.get("source")
+    return isinstance(source, dict) and "subagent" in source
+
+
+def _root_thread_key(session: dict, by_uid: dict[str, dict]) -> str:
+    """Resolve the top-of-tree thread for a session, following parent links.
+
+    Sub-agent rollouts carry ``parent_thread_id``; we walk up until we reach a
+    session with no parent (the real top-level thread). When the parent is not
+    part of this batch we still group siblings under the parent id so several
+    explorers spawned by the same (absent) parent collapse together. The walk is
+    bounded so a malformed/cyclic chain can never loop forever.
+    """
+    cur = session
+    for _ in range(16):
+        parent = str(cur.get("parent_thread_id", "") or "").strip()
+        if not parent:
+            break
+        nxt = by_uid.get(parent)
+        if nxt is None or nxt is cur:
+            return parent
+        cur = nxt
+    return str(cur.get("session_uid", "") or cur.get("session_file", ""))
+
+
+def dedupe_sessions(sessions: list[dict]) -> tuple[list[dict], list[dict]]:
+    """Fold parallel sub-agent threads into their parent so each real thread is
+    analyzed and counted once instead of once per spawned explorer.
+
+    Sessions are grouped by their root thread (see :func:`_root_thread_key`).
+    Within a group the actual parent session is kept as the canonical thread
+    (falling back to a non-sub-agent member, then the earliest one); the folded
+    sub-agent transcripts are appended to the canonical session — so no content
+    is lost — and their ids/nicknames are recorded on the kept session
+    (``folded_subagents``) and in the returned report.
+
+    Returns ``(kept_sessions, dedupe_report)``. Distinct top-level threads are
+    never merged.
+    """
+    by_uid: dict[str, dict] = {}
+    for session in sessions:
+        uid = str(session.get("session_uid", "") or "").strip()
+        if uid:
+            by_uid.setdefault(uid, session)
+
+    groups: dict[str, list[dict]] = {}
+    order: list[str] = []
+    for session in sessions:
+        key = _root_thread_key(session, by_uid)
+        if key not in groups:
+            groups[key] = []
+            order.append(key)
+        groups[key].append(session)
+
+    kept: list[dict] = []
+    report: list[dict] = []
+    for key in order:
+        members = groups[key]
+        if len(members) == 1:
+            kept.append(members[0])
+            continue
+        representative = next(
+            (m for m in members if str(m.get("session_uid", "") or "") == key), None
+        )
+        if representative is None:
+            representative = next((m for m in members if not _is_subagent(m)), None)
+        if representative is None:
+            representative = min(members, key=lambda m: str(m.get("modified", "")))
+
+        folded = [m for m in members if m is not representative]
+        rep_messages = representative.setdefault("messages", [])
+        rep_tools = representative.setdefault("tool_uses", [])
+        for child in folded:
+            label = child.get("agent_nickname") or child["session_file"]
+            role = child.get("agent_role") or "subagent"
+            rep_messages.append({
+                "role": "user",
+                "index": 0,
+                "text": f"──── folded sub-agent thread: {label} ({role}) — {child['session_file']} ────",
+            })
+            rep_messages.extend(child.get("messages") or [])
+            rep_tools.extend(child.get("tool_uses") or [])
+        representative["message_count"] = len(rep_messages)
+        representative["tool_use_count"] = len(rep_tools)
+        representative["folded_subagents"] = [
+            {
+                "session_file": m["session_file"],
+                "agent_nickname": m.get("agent_nickname", ""),
+                "agent_role": m.get("agent_role", ""),
+            }
+            for m in folded
+        ]
+        kept.append(representative)
+        report.append({
+            "root_thread": key,
+            "kept": representative["session_file"],
+            "folded": [m["session_file"] for m in folded],
+            "count": len(members),
+        })
+    return kept, report
+
+
 # ── Database queries ──────────────────────────────────────────────────────
 
 
@@ -818,6 +929,17 @@ def main():
         sessions = collect_transcripts_since(fallback_since)
     print(f"  Found {len(sessions)} sessions")
 
+    # Fold parallel sub-agent rollouts into their parent thread so a single
+    # logical thread is not analyzed (and counted) once per spawned explorer,
+    # which otherwise inflates the finding count.
+    sessions, dedupe_report = dedupe_sessions(sessions)
+    folded_total = sum(len(item["folded"]) for item in dedupe_report)
+    if folded_total:
+        print(
+            f"  Folded {folded_total} sub-agent session(s) into "
+            f"{len(dedupe_report)} parent thread(s); {len(sessions)} unique threads remain"
+        )
+
     if not sessions:
         print(f"[collect] No new sessions found. Writing minimal context file.")
         output_file = DEEP_SLEEP_DIR / f"{run_id}-context.txt"
@@ -959,9 +1081,12 @@ def main():
                 "source": s.get("source", ""),
                 "session_path": s.get("session_path", ""),
                 "session_txt_file": session_txt_map.get(s["session_file"], ""),
+                "folded_subagents": s.get("folded_subagents", []),
             }
             for s in sessions
         ],
+        "sessions_folded": folded_total,
+        "dedupe_report": dedupe_report,
         "total_messages": sum(s["message_count"] for s in sessions),
         "total_tool_uses": sum(s["tool_use_count"] for s in sessions),
         "followups_active": len(followups),

package/src/transcript_utils.py

@@ -208,6 +208,9 @@ def extract_claude_session(jsonl_path: Path, *, min_user_messages: int = MIN_USE
         "messages": messages,
         "tool_uses": tool_uses,
         "source": "claude_projects",
+        "session_uid": jsonl_path.stem,
+        "thread_source": "user",
+        "parent_thread_id": "",
     }
 
 
@@ -216,6 +219,7 @@ def extract_codex_session(jsonl_path: Path, *, min_user_messages: int = MIN_USER
     tool_uses = []
     user_msg_count = 0
     session_meta: dict = {}
+    spawn_meta: dict = {}
 
     try:
         with open(jsonl_path, "r") as f:
@@ -232,7 +236,16 @@ def extract_codex_session(jsonl_path: Path, *, min_user_messages: int = MIN_USER
                 data = payload.get("payload", {})
 
                 if item_type == "session_meta" and isinstance(data, dict):
-                    session_meta = data
+                    # A sub-agent rollout embeds two session_meta records: its
+                    # own first, then the parent it forked from. Keep the FIRST
+                    # as this thread's identity (last-wins would mislabel the
+                    # sub-agent as its parent) and remember whichever record
+                    # carries the sub-agent spawn linkage.
+                    if not session_meta:
+                        session_meta = data
+                    src = data.get("source")
+                    if not spawn_meta and isinstance(src, dict) and isinstance(src.get("subagent"), dict):
+                        spawn_meta = data
                     continue
 
                 if item_type == "event_msg" and isinstance(data, dict) and data.get("type") == "user_message":
@@ -280,6 +293,17 @@ def extract_codex_session(jsonl_path: Path, *, min_user_messages: int = MIN_USER
     if user_msg_count < _min_user_messages(min_user_messages):
         return None
 
+    spawn_source = (spawn_meta or session_meta).get("source")
+    thread_spawn: dict = {}
+    if isinstance(spawn_source, dict) and isinstance(spawn_source.get("subagent"), dict):
+        thread_spawn = spawn_source["subagent"].get("thread_spawn") or {}
+    parent_thread_id = str(
+        thread_spawn.get("parent_thread_id", "")
+        or session_meta.get("forked_from_id", "")
+        or ""
+    )
+    is_subagent = bool(thread_spawn) or str(session_meta.get("thread_source", "")).lower() == "subagent"
+
     return {
         "client": "codex",
         "session_file": _session_identifier("codex", jsonl_path.name),
@@ -294,6 +318,10 @@ def extract_codex_session(jsonl_path: Path, *, min_user_messages: int = MIN_USER
         "cwd": session_meta.get("cwd", ""),
         "originator": session_meta.get("originator", ""),
         "session_uid": session_meta.get("id", ""),
+        "thread_source": "subagent" if is_subagent else (session_meta.get("thread_source", "") or "user"),
+        "parent_thread_id": parent_thread_id,
+        "agent_nickname": str(session_meta.get("agent_nickname", "") or thread_spawn.get("agent_nickname", "") or ""),
+        "agent_role": str(session_meta.get("agent_role", "") or thread_spawn.get("agent_role", "") or ""),
     }