nexo-brain 7.30.7 → 7.30.9

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.7",
+  "version": "7.30.9",
   "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.7` is the current packaged-runtime line. 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.
+Version `7.30.9` is the current packaged-runtime line. Patch release over v7.30.8 - post-update self-heal now stamps a verified repair baseline, and doctor release gates distinguish current installation failures from historical operator/session drift.
+
+Previously in `7.30.8`: 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nexo-brain",
-  "version": "7.30.7",
+  "version": "7.30.9",
   "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/auto_update.py

@@ -70,6 +70,7 @@ DATA_DIR.mkdir(parents=True, exist_ok=True)
 SRC_DIR = Path(__file__).resolve().parent
 NEXO_CODE = Path(os.environ.get("NEXO_CODE", str(SRC_DIR)))
 REPO_DIR = SRC_DIR.parent
+REPAIR_BASELINE_FILE = "last-repair-baseline.json"
 
 
 def _resolve_repo_dir() -> Path:
@@ -90,6 +91,22 @@ def _resolve_repo_dir() -> Path:
 
 _RESOLVED_REPO_DIR = _resolve_repo_dir()
 
+
+def _stamp_runtime_repair_baseline(dest: Path) -> str:
+    operations_dir = dest / "operations"
+    operations_dir.mkdir(parents=True, exist_ok=True)
+    now = time.time()
+    payload = {
+        "last_repair_epoch": now,
+        "last_repair_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(now)),
+        "source": "auto_update._run_runtime_post_sync",
+        "reason": "verified runtime repair baseline after update/post-sync",
+    }
+    (operations_dir / REPAIR_BASELINE_FILE).write_text(
+        json.dumps(payload, indent=2, ensure_ascii=False) + "\n"
+    )
+    return "runtime-repair-baseline"
+
 LAST_CHECK_FILE = DATA_DIR / "auto_update_last_check.json"
 MIGRATION_VERSION_FILE = DATA_DIR / "migration_version"
 CLAUDE_MD_VERSION_FILE = DATA_DIR / "claude_md_version.txt"
@@ -5210,6 +5227,10 @@ def _run_runtime_post_sync(dest: Path = NEXO_HOME, progress_fn=None) -> tuple[bo
     if verify.returncode != 0:
         return False, [verify.stderr.strip() or verify.stdout.strip() or "import verify failed"]
     actions.append("verify")
+    try:
+        actions.append(_stamp_runtime_repair_baseline(dest))
+    except Exception as exc:
+        actions.append(f"runtime-repair-baseline-warning:{exc.__class__.__name__}")
     return True, actions
 
 

package/src/doctor/models.py

@@ -17,6 +17,7 @@ class DoctorCheck:
     repair_plan: list[str] = field(default_factory=list)
     escalation_prompt: str = ""
     fixed: bool = False
+    category: str = "installed_product"  # installed_product, operator_history
 
 
 @dataclass

package/src/doctor/orchestrator.py

@@ -46,7 +46,7 @@ def run_doctor(tier: str = "boot", fix: bool = False, plane: str = "") -> Doctor
         report.duration_ms = int((time.monotonic() - start) * 1000)
         return report
 
-    _, preflight = diagnostic_plane_preflight(plane)
+    normalized_plane, preflight = diagnostic_plane_preflight(plane)
     if preflight is not None:
         report.add(preflight)
         report.compute_status()
@@ -60,7 +60,7 @@ def run_doctor(tier: str = "boot", fix: bool = False, plane: str = "") -> Doctor
         if not runner:
             continue
         try:
-            checks = runner(fix=fix)
+            checks = runner(fix=fix, plane=normalized_plane)
             for check in checks:
                 report.add(check)
         except Exception as exc:

package/src/doctor/providers/boot.py

@@ -899,7 +899,7 @@ def check_f06_migration_consistency() -> DoctorCheck:
     )
 
 
-def run_boot_checks(fix: bool = False) -> list[DoctorCheck]:
+def run_boot_checks(fix: bool = False, plane: str = "") -> list[DoctorCheck]:
     """Run all boot-tier checks."""
     checks = [
         safe_check(check_db_exists),

package/src/doctor/providers/deep.py

@@ -357,7 +357,7 @@ def check_learning_count() -> DoctorCheck:
         )
 
 
-def run_deep_checks(fix: bool = False) -> list[DoctorCheck]:
+def run_deep_checks(fix: bool = False, plane: str = "") -> list[DoctorCheck]:
     """Run all deep-tier checks. Read-only."""
     return [
         safe_check(check_self_audit_summary),

package/src/doctor/providers/runtime.py

@@ -64,6 +64,47 @@ CORE_AUTOMATION_CALLERS_BY_CRON = {
     "morning-agent": ("morning_agent",),
     "sleep": ("sleep/nightly",),
 }
+REPAIR_BASELINE_FILE = "last-repair-baseline.json"
+
+
+def _post_update_repair_baseline_epoch() -> float:
+    path = paths.operations_dir() / REPAIR_BASELINE_FILE
+    if not path.is_file():
+        return 0.0
+    try:
+        payload = json.loads(path.read_text())
+    except Exception:
+        return 0.0
+    if not isinstance(payload, dict):
+        return 0.0
+    for key in ("last_repair_epoch", "timestamp_epoch"):
+        try:
+            value = float(payload.get(key) or 0)
+        except Exception:
+            value = 0.0
+        if value > 0:
+            return value
+    raw_iso = str(payload.get("last_repair_at") or payload.get("timestamp") or "").strip()
+    if not raw_iso:
+        return 0.0
+    try:
+        parsed = dt.datetime.fromisoformat(raw_iso.replace("Z", "+00:00"))
+    except Exception:
+        return 0.0
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=dt.timezone.utc)
+    return parsed.timestamp()
+
+
+def _history_cutoff_epoch(*, days: int) -> float:
+    return max(time.time() - (days * 86400), _post_update_repair_baseline_epoch())
+
+
+def _history_baseline_sqlite() -> str:
+    epoch = _post_update_repair_baseline_epoch()
+    if epoch <= 0:
+        return ""
+    return dt.datetime.fromtimestamp(epoch, tz=dt.timezone.utc).strftime("%Y-%m-%d %H:%M:%S")
 
 
 def _evolution_objective_payload() -> dict:
@@ -271,7 +312,7 @@ def _recent_codex_session_parity_status(*, days: int = 7, max_files: int = 24) -
         Path.home() / ".codex" / "sessions",
         Path.home() / ".codex" / "archived_sessions",
     ]
-    cutoff = time.time() - (days * 86400)
+    cutoff = _history_cutoff_epoch(days=days)
     candidates: list[tuple[float, Path]] = []
     for root in roots:
         if not root.exists():
@@ -288,6 +329,7 @@ def _recent_codex_session_parity_status(*, days: int = 7, max_files: int = 24) -
 
     status = {
         "files": len(files),
+        "history_baseline_epoch": _post_update_repair_baseline_epoch(),
         "bootstrap_sessions": 0,
         "startup_sessions": 0,
         "heartbeat_sessions": 0,
@@ -578,7 +620,7 @@ def _recent_codex_conditioned_file_discipline_status(*, days: int = 7, max_files
         Path.home() / ".codex" / "sessions",
         Path.home() / ".codex" / "archived_sessions",
     ]
-    cutoff = time.time() - (days * 86400)
+    cutoff = _history_cutoff_epoch(days=days)
     candidates: list[tuple[float, Path]] = []
     for root in roots:
         if not root.exists():
@@ -593,6 +635,7 @@ def _recent_codex_conditioned_file_discipline_status(*, days: int = 7, max_files
     candidates.sort(key=lambda item: item[0], reverse=True)
     files = candidates[:max_files]
     status["files"] = len(files)
+    status["history_baseline_epoch"] = _post_update_repair_baseline_epoch()
 
     for file_mtime, path in files:
         cwd = ""
@@ -2312,6 +2355,7 @@ def check_codex_session_parity() -> DoctorCheck:
             status="healthy",
             severity="info",
             summary="Codex session parity check skipped (Codex not selected)",
+            category="operator_history",
         )
 
     audit = _recent_codex_session_parity_status()
@@ -2329,6 +2373,7 @@ def check_codex_session_parity() -> DoctorCheck:
                 "Codex is selected, but there are no recent durable Codex sessions to inspect. "
                 "NEXO cannot prove that manual Codex sessions are entering the shared-brain startup flow."
             ),
+            category="operator_history",
         )
 
     evidence = [
@@ -2378,6 +2423,7 @@ def check_codex_session_parity() -> DoctorCheck:
             "Codex is selected, but recent durable Codex sessions are not consistently showing NEXO bootstrap markers or `nexo_startup`. "
             "Manual Codex sessions may still be starting too plain."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -2400,6 +2446,7 @@ def check_bootstrap_reached_startup() -> DoctorCheck:
             status="healthy",
             severity="info",
             summary="Startup reachability skipped (Codex not selected)",
+            category="operator_history",
         )
 
     audit = _recent_codex_session_parity_status(days=1, max_files=48)
@@ -2425,6 +2472,7 @@ def check_bootstrap_reached_startup() -> DoctorCheck:
             evidence=evidence,
             repair_plan=["Start Codex through the managed NEXO launcher and re-run doctor"],
             escalation_prompt="NEXO cannot prove recent Codex sessions reached startup.",
+            category="operator_history",
         )
 
     status = "healthy" if missing == 0 else "critical"
@@ -2447,6 +2495,7 @@ def check_bootstrap_reached_startup() -> DoctorCheck:
         escalation_prompt=(
             "Codex sessions are starting without the shared-brain startup step, so memory/guard continuity is not guaranteed."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -2468,6 +2517,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             status="healthy",
             severity="info",
             summary="Codex conditioned-file discipline check skipped (Codex not selected)",
+            category="operator_history",
         )
 
     audit = _recent_codex_conditioned_file_discipline_status()
@@ -2491,6 +2541,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             severity="info",
             summary="No active conditioned-file learnings defined for Codex session audits",
             evidence=evidence,
+            category="operator_history",
         )
 
     if audit["files"] == 0 or audit["conditioned_sessions"] == 0:
@@ -2501,6 +2552,7 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             severity="info",
             summary="No conditioned-file touches seen in recent Codex sessions",
             evidence=evidence + [f"conditioned touches: {audit['conditioned_touches']}"],
+            category="operator_history",
         )
 
     evidence.extend([
@@ -2595,10 +2647,11 @@ def check_codex_conditioned_file_discipline() -> DoctorCheck:
             "Codex sessions are touching conditioned files without the expected protocol/guard sequence. "
             "Until this is clean, parity with Claude hooks is still incomplete."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
-def check_codex_protocol_compliance() -> DoctorCheck:
+def check_codex_protocol_compliance(include_history: bool = True) -> DoctorCheck:
     try:
         schedule = _load_json(SCHEDULE_FILE) if SCHEDULE_FILE.is_file() else {}
     except Exception:
@@ -2646,6 +2699,16 @@ def check_codex_protocol_compliance() -> DoctorCheck:
             ),
         )
 
+    if not include_history:
+        return DoctorCheck(
+            id="installation_live.codex_protocol_compliance",
+            tier="runtime",
+            status="healthy",
+            severity="info",
+            summary="Codex live protocol enforcement is installed",
+            evidence=[f"codex PreToolUse hook: managed ({hooks.get('pretool_matcher') or '*'})"],
+        )
+
     startup = _recent_codex_session_parity_status(days=1)
     conditioned = _recent_codex_conditioned_file_discipline_status(days=1)
     sessions = int(startup.get("files") or conditioned.get("files") or 0)
@@ -2659,6 +2722,7 @@ def check_codex_protocol_compliance() -> DoctorCheck:
             repair_plan=[
                 "Run Codex through the managed NEXO bootstrap so doctor can verify live protocol compliance",
             ],
+            category="operator_history",
         )
 
     startup_violation_sessions = 0
@@ -2709,6 +2773,7 @@ def check_codex_protocol_compliance() -> DoctorCheck:
         escalation_prompt=(
             "Codex CLI parity is not clean: recent sessions miss startup/heartbeat or bypass conditioned-file guard discipline."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -2898,11 +2963,14 @@ def check_protocol_compliance() -> DoctorCheck:
                 debt_rows = None
                 if {"protocol_tasks", "protocol_debt"}.issubset(tables):
                     window = "-7 days"
+                    history_floor = _history_baseline_sqlite()
+                    task_floor_clause = " AND opened_at >= ?" if history_floor else ""
+                    task_params = (window, history_floor) if history_floor else (window,)
                     tasks = conn.execute(
-                        """SELECT * FROM protocol_tasks
-                           WHERE opened_at >= datetime('now', ?)
+                        f"""SELECT * FROM protocol_tasks
+                           WHERE opened_at >= datetime('now', ?){task_floor_clause}
                            ORDER BY opened_at DESC""",
-                        (window,),
+                        task_params,
                     ).fetchall()
                     protocol_debt_cols = {
                         row["name"] for row in conn.execute("PRAGMA table_info(protocol_debt)").fetchall()
@@ -2946,6 +3014,8 @@ def check_protocol_compliance() -> DoctorCheck:
                         task_status_expr = "'' AS task_status"
                         if "status" in protocol_task_cols:
                             task_status_expr = "pt.status AS task_status"
+                        debt_floor_clause = " AND pd.created_at >= ?" if history_floor else ""
+                        debt_params = (window, history_floor) if history_floor else (window,)
                         open_debts = conn.execute(
                             f"""SELECT
                                     pd.severity,
@@ -2956,9 +3026,9 @@ def check_protocol_compliance() -> DoctorCheck:
                                     {task_status_expr}
                                 FROM protocol_debt pd
                                 LEFT JOIN protocol_tasks pt ON pt.task_id = pd.task_id
-                                WHERE pd.status = 'open' AND pd.created_at >= datetime('now', ?)
+                                WHERE pd.status = 'open' AND pd.created_at >= datetime('now', ?){debt_floor_clause}
                                 ORDER BY pd.created_at DESC""",
-                            (window,),
+                            debt_params,
                         ).fetchall()
                         debt_counter: dict[tuple[str, str], int] = {}
                         for row in open_debts:
@@ -2987,12 +3057,13 @@ def check_protocol_compliance() -> DoctorCheck:
                     else:
                         debt_rows = [
                             dict(row) for row in conn.execute(
-                                """SELECT severity, debt_type, COUNT(*) AS total
+                                f"""SELECT severity, debt_type, COUNT(*) AS total
                                    FROM protocol_debt
                                    WHERE status = 'open' AND created_at >= datetime('now', ?)
+                                   {"AND created_at >= ?" if history_floor else ""}
                                    GROUP BY severity, debt_type
                                    ORDER BY total DESC, debt_type ASC""",
-                                (window,),
+                                (window, history_floor) if history_floor else (window,),
                             ).fetchall()
                         ]
                     has_cortex_evaluations = bool(
@@ -3010,16 +3081,33 @@ def check_protocol_compliance() -> DoctorCheck:
                             ).fetchall()
                         }
                         first_eval_row = conn.execute(
-                            """SELECT MIN(created_at) AS first_eval
+                            f"""SELECT MIN(created_at) AS first_eval
                                FROM cortex_evaluations
-                               WHERE created_at >= datetime('now', ?)""",
-                            (window,),
+                               WHERE created_at >= datetime('now', ?)
+                               {"AND created_at >= ?" if history_floor else ""}""",
+                            (window, history_floor) if history_floor else (window,),
                         ).fetchone()
                         if first_eval_row and first_eval_row["first_eval"]:
                             first_cortex_eval_at = str(first_eval_row["first_eval"])
             finally:
                 conn.close()
 
+            history_floor = _history_baseline_sqlite()
+            if tasks is not None and debt_rows is not None and not tasks and not debt_rows and history_floor:
+                return DoctorCheck(
+                    id="runtime.protocol_compliance",
+                    tier="runtime",
+                    status="healthy",
+                    severity="info",
+                    summary="No protocol drift after the last verified runtime repair",
+                    evidence=[
+                        "live protocol window: 7d",
+                        f"post-update repair baseline: {history_floor}",
+                        "no protocol tasks or open debt after repair baseline",
+                    ],
+                    category="operator_history",
+                )
+
             if tasks is not None and debt_rows is not None and (tasks or debt_rows):
                     closed_tasks = [row for row in tasks if row["status"] != "open"]
                     verify_required = [row for row in closed_tasks if row["must_verify"] and row["status"] == "done"]
@@ -3122,6 +3210,7 @@ def check_protocol_compliance() -> DoctorCheck:
                         escalation_prompt=(
                             "Task discipline is drifting in live runtime data. NEXO is still skipping verification, change logging, or correction capture."
                         ) if status != "healthy" else "",
+                        category="operator_history",
                     )
     except Exception:
         pass
@@ -3140,6 +3229,7 @@ def check_protocol_compliance() -> DoctorCheck:
             escalation_prompt=(
                 "NEXO cannot verify heartbeat / guard_check / change_log compliance because the latest weekly Deep Sleep summary is missing."
             ),
+            category="operator_history",
         )
 
     protocol = summary.get("protocol_summary") or {}
@@ -3197,6 +3287,7 @@ def check_protocol_compliance() -> DoctorCheck:
         escalation_prompt=(
             "Heartbeat / guard_check / change_log discipline is drifting. NEXO is at risk of repeating known errors and hiding change history."
         ) if status != "healthy" else "",
+        category="operator_history",
     )
 
 
@@ -3979,9 +4070,15 @@ def check_memory_fabric_health(fix: bool = False) -> DoctorCheck:
         )
 
 
-def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
+def _filter_runtime_checks_for_plane(checks: list[DoctorCheck], plane: str = "") -> list[DoctorCheck]:
+    if plane == "installation_live":
+        return [check for check in checks if check.category != "operator_history"]
+    return checks
+
+
+def run_runtime_checks(fix: bool = False, plane: str = "") -> list[DoctorCheck]:
     """Run all runtime-tier checks. Read-only by default."""
-    return [
+    checks = [
         safe_check(check_immune_status),
         safe_check(check_watchdog_status),
         safe_check(check_runner_health_status),
@@ -3992,7 +4089,7 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_codex_session_parity),
         safe_check(check_bootstrap_reached_startup),
         safe_check(check_codex_conditioned_file_discipline),
-        safe_check(check_codex_protocol_compliance),
+        safe_check(check_codex_protocol_compliance, include_history=plane != "installation_live"),
         safe_check(check_claude_desktop_shared_brain),
         safe_check(check_transcript_source_parity),
         safe_check(check_client_assumption_regressions),
@@ -4009,3 +4106,4 @@ def run_runtime_checks(fix: bool = False) -> list[DoctorCheck]:
         safe_check(check_personal_script_registry, fix=fix),
         safe_check(check_skill_health, fix=fix),
     ]
+    return _filter_runtime_checks_for_plane(checks, plane=plane)

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 ""),
     }