brainiac-cli 0.20.41__tar.gz → 0.20.43__tar.gz

{brainiac_cli-0.20.41/src/brainiac_cli.egg-info → brainiac_cli-0.20.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainiac-cli
-Version: 0.20.41
+Version: 0.20.43
 Summary: Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index).
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://github.com/Autopsias/brainiac
@@ -60,7 +60,7 @@ Requires-Dist: numpy>=1.24; extra == "eval"
 Provides-Extra: quant-tools
 Requires-Dist: onnx>=1.14; extra == "quant-tools"
 Provides-Extra: mcp
-Requires-Dist: mcp<2,>=1.28.1; extra == "mcp"
+Requires-Dist: mcp<2,>=1.30.0; extra == "mcp"
 Provides-Extra: index
 Requires-Dist: regex>=2023.0.0; extra == "index"
 Dynamic: license-file

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/pyproject.toml

@@ -8,7 +8,7 @@ build-backend = "setuptools.build_meta"
 # check. The IMPORT package stays `brain` and the console script stays
 # `brain` — only the distribution/project name changes.
 name = "brainiac-cli"
-version = "0.20.41"
+version = "0.20.43"
 description = "Brainiac — local any-LLM second-brain core engine + brain CLI (Markdown truth, derived SQLite index)."
 readme = "README.md"
 license = "Apache-2.0"
@@ -122,7 +122,10 @@ quant-tools = ["onnx>=1.14"]
 # release pipeline's release-asset handshake gate, after it had already shipped).
 # Upgrade path: port the adapter off FastMCP (mcp.server.lowlevel, or the
 # separate `fastmcp` package) and lift the cap — a real migration, not a bump.
-mcp = ["mcp>=1.28.1,<2"]
+# >=1.30.0: CVE-2026-59951 (Streamable HTTP stateful sessions never reclaimed,
+# unbounded memory) is fixed there. The FLOOR, not just the lock, for the same
+# reason as pypdf above: a plain `pip install` reads this, not requirements.lock.
+mcp = ["mcp>=1.30.0,<2"]
 # Timeout-bounded regex engine (mrab-regex) used by BrainIndex.grep's --regex
 # path (RET-04 hardening) as a ReDoS guard: regex.search(text, timeout=...)
 # genuinely bounds catastrophic backtracking, unlike stdlib `re`. Absent ->

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/_version.py

@@ -9,4 +9,4 @@ pip-installed host, importlib.metadata stays primary; brain/__init__.py reads
 this file only as the fallback before 0.0.0+unknown.
 """
 
-__version__ = "0.20.41"
+__version__ = "0.20.43"

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/doctor_checks.py

@@ -61,6 +61,7 @@ class DoctorChecks:
     mcp_vault_paths: DoctorCheck
     cos_deployed_skill: DoctorCheck
     desktop_plugin_store: DoctorCheck
+    mcp_server_code: DoctorCheck
     cowork_vault_dir: DoctorCheck
     quarantine: DoctorCheck
     ingest_capability: DoctorCheck
@@ -208,7 +209,9 @@ def _terminal_rows(
     rows.extend([checks.mcpb_desktop_collision(context.app_support_dir),
                  *checks.mcp_vault_paths()])
     rows.extend(row for row in [checks.cos_deployed_skill()] if row)
-    rows.extend(checks.desktop_plugin_store(context.app_support_dir, ssot))
+    rows.extend(checks.desktop_plugin_store(context.app_support_dir, ssot,
+                                            registry_entries=context.registry_entries))
+    rows.extend(checks.mcp_server_code())
     from .guard_settings import guard_settings_row as _guard_settings_row
     from .guard_settings import session_state_row as _session_state_row
     from .guard_settings import registry_pin_row as _registry_pin_row

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/doctor_context.py

@@ -131,6 +131,7 @@ def build_context_and_checks(
     """
     from . import config as _config
     from . import doctor as _doctor
+    from . import doctor_desktop as _desktop
     from .doctor_checks import DoctorCheckContext, DoctorChecks
 
     context = DoctorCheckContext(
@@ -175,6 +176,7 @@ def build_context_and_checks(
         mcp_vault_paths=_doctor.check_mcp_vault_paths,
         cos_deployed_skill=_doctor.check_cos_deployed_skill,
         desktop_plugin_store=_doctor.check_desktop_plugin_store,
+        mcp_server_code=_desktop.check_mcp_server_code,
         cowork_vault_dir=_doctor._cowork_vault_dir,
         quarantine=_doctor.check_quarantine,
         ingest_capability=_doctor.check_ingest_capability,

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/doctor_desktop.py

@@ -11,6 +11,7 @@ keeps working unchanged. Covered by ``tests/test_doctor_workspace.py``.
 """
 from __future__ import annotations
 
+import re
 from pathlib import Path
 from typing import Optional
 
@@ -124,8 +125,85 @@ def check_mcpb_desktop_collision(
 # manual-required, NEVER gates the exit code — ADR-0005 Ruling 2/4).
 # --------------------------------------------------------------------------
 
+_STAMP = re.compile(rb"<!-- SKILL_VERSION:[^\n]*-->\n?")
+
+# brainiac-manager's skills install/update the HOST and refuse to run in
+# Cowork (brainiac-update is host-only by design), so its absence from the
+# Cowork store is the expected state, not a step the owner owes.
+_OPTIONAL_IN_COWORK = {"brainiac-manager"}
+
+
+def _skill_reference(registry_entries: Optional[list[dict]], ssot: str) -> dict[str, bytes]:
+    """name -> current SKILL.md bytes (version stamp stripped), read from the
+    workspaces' staged ``.skill`` bundles at the SSOT version.
+
+    Cowork's marketplace is a cloud copy that can lag weeks behind GitHub and
+    re-label identical skill text with an old version (measured 2026-10-05:
+    0.20.39 installed, text identical to 0.20.41). Comparing TEXT against the
+    bundles `brain update` just staged is what tells the owner whether to act.
+    """
+    import zipfile
+
+    from .vmstaging import _cowork_staging_root
+
+    ref: dict[str, bytes] = {}
+    for entry in registry_entries or []:
+        if entry.get("target") == "host":
+            continue
+        skills_dir = _cowork_staging_root(entry) / "skills"
+        for bundle in sorted(skills_dir.glob("*.skill")) if skills_dir.is_dir() else []:
+            if bundle.stem in ref:
+                continue
+            try:
+                with zipfile.ZipFile(bundle) as zf:
+                    if zf.read(f"{bundle.stem}/VERSION").decode("utf-8").strip() != ssot:
+                        continue
+                    ref[bundle.stem] = _STAMP.sub(b"", zf.read(f"{bundle.stem}/SKILL.md"))
+            except (OSError, KeyError, UnicodeDecodeError, zipfile.BadZipFile):
+                continue
+    return ref
+
+
+def _content_drift(plugin_dir: Path, reference: dict[str, bytes]) -> Optional[tuple[int, list[str]]]:
+    """(skills compared, names whose text differs), or None when nothing in
+    the installed plugin has a reference to compare against."""
+    skills_root = plugin_dir / "skills"
+    if not skills_root.is_dir():
+        return None
+    names = sorted(p.name for p in skills_root.iterdir()
+                   if p.name in reference and (p / "SKILL.md").is_file())
+    if not names:
+        return None
+    differs = [n for n in names
+               if _STAMP.sub(b"", (skills_root / n / "SKILL.md").read_bytes()) != reference[n]]
+    return len(names), differs
+
+
+def _store_refresh_steps(pname: str, registry_entries: Optional[list[dict]]) -> str:
+    from .vmstaging import _cowork_staging_root
+
+    staged = next((str(_cowork_staging_root(e) / "skills") for e in registry_entries or []
+                   if e.get("target") != "host"), "<workspace>/vault/.brain/skills")
+    return (f"in Cowork: Customize -> Plugins -> refresh the brainiac marketplace, then "
+            f"update {pname}; if it still offers older text, uninstall it and upload "
+            f"the .skill bundles from {staged}; re-run brain doctor on the host to confirm")
+
+
+def _newest_store_copy(sessions_root: Path, pname: str) -> list[tuple[float, Path]]:
+    candidates: list[tuple[float, Path]] = []
+    try:
+        for pjson in sessions_root.glob("*/*/rpm/plugin_*/.claude-plugin/plugin.json"):
+            data = _read_json(pjson)
+            if data and data.get("name") == pname:
+                candidates.append((pjson.stat().st_mtime, pjson))
+    except Exception:
+        return []
+    return sorted(candidates, key=lambda t: t[0], reverse=True)
+
+
 def check_desktop_plugin_store(
     app_support_dir: Path, ssot: str, plugin_dir_names: tuple[str, ...] = PLUGIN_NAMES,
+    registry_entries: Optional[list[dict]] = None,
 ) -> list[dict]:
     """Best-effort read of
     ``.../local-agent-mode-sessions/<uuid>/<uuid>/rpm/plugin_*/.claude-plugin/plugin.json``.
@@ -137,8 +215,14 @@ def check_desktop_plugin_store(
     (not scriptable from here); if multiple candidates tie or none can be
     confidently chosen it reports 'unknown (N candidate sessions)' rather than
     inventing a version.
+
+    When the registered workspaces carry staged bundles at the SSOT version,
+    the verdict is the installed skill TEXT against them, not the label: a
+    match reads `current` (never gating either way, ADR-0005 Ruling 2/4).
+    Every row that needs the owner sets ``raw["action_needed"]``.
     """
     sessions_root = app_support_dir / "local-agent-mode-sessions"
+    reference = _skill_reference(registry_entries, ssot)
     rows = []
     for pname in plugin_dir_names:
         surface = f"Desktop/Cowork plugin store ({pname})"
@@ -148,27 +232,30 @@ def check_desktop_plugin_store(
                              "verify manually in the Cowork/Desktop client",
                              remediation="Open Cowork/Desktop -> Plugins -> check for update"))
             continue
-        candidates: list[tuple[float, Path]] = []
-        try:
-            for pjson in sessions_root.glob("*/*/rpm/plugin_*/.claude-plugin/plugin.json"):
-                data = _read_json(pjson)
-                if data and data.get("name") == pname:
-                    candidates.append((pjson.stat().st_mtime, pjson))
-        except Exception:
-            candidates = []
+        candidates = _newest_store_copy(sessions_root, pname)
+        if not candidates and pname in _OPTIONAL_IN_COWORK:
+            rows.append(_row(surface, UNMANAGED,
+                             "not installed in Cowork — optional: its skills manage the "
+                             "host install and refuse to run in Cowork; nothing to do",
+                             raw={"action_needed": False}))
+            continue
         if not candidates:
             rows.append(_row(surface, MANUAL_REQUIRED,
                              "not found in any session dir — best-effort, "
                              "verify manually in the Cowork/Desktop client",
-                             remediation="Open Cowork/Desktop -> Plugins -> check for update"))
+                             remediation=_store_refresh_steps(pname, registry_entries),
+                             raw={"action_needed": True}))
             continue
-        candidates.sort(key=lambda t: t[0], reverse=True)
         newest_mtime, newest_path = candidates[0]
         data = _read_json(newest_path) or {}
         version = data.get("version")
         if version is None:
             rows.append(_row(surface, UNKNOWN, f"unknown ({len(candidates)} candidate sessions, unparseable)"))
             continue
+        drift = _content_drift(newest_path.parent.parent, reference)
+        if drift is not None:
+            rows.append(_content_row(surface, pname, str(version), ssot, drift, registry_entries))
+            continue
         import datetime
 
         mtime_str = datetime.datetime.fromtimestamp(newest_mtime).isoformat(timespec="seconds")
@@ -204,7 +291,112 @@ def check_desktop_plugin_store(
             remediation = "looks current — no action needed"
         rows.append(_row(surface, MANUAL_REQUIRED, detail, remediation=remediation,
                          raw={"version": version, "candidates": len(candidates),
-                              "newest_mtime": mtime_str}))
+                              "newest_mtime": mtime_str, "action_needed": skew != 0}))
+    return rows
+
+
+def _content_row(surface: str, pname: str, version: str, ssot: str,
+                 drift: tuple[int, list[str]], registry_entries: Optional[list[dict]]) -> dict:
+    checked, differs = drift
+    raw = {"version": version, "checked": checked, "differs": differs,
+           "action_needed": bool(differs)}
+    if not differs:
+        return _row(surface, CURRENT,
+                    f"{checked} skill(s) match the {ssot} text (Cowork labels it {version}; "
+                    "the label can lag, the text is what runs)", raw=raw)
+    return _row(surface, MANUAL_REQUIRED,
+                f"{len(differs)} of {checked} skill(s) differ from the {ssot} text "
+                f"(Cowork labels it {version}): {', '.join(differs)}",
+                remediation=_store_refresh_steps(pname, registry_entries), raw=raw)
+
+
+# --------------------------------------------------------------------------
+# Claude Desktop's running brain-mcp servers. A Python process keeps the code
+# it imported at start, so after `brain update` reinstalls the engine every
+# server Desktop already started still serves the OLD engine until Desktop is
+# quit and reopened. Measured 2026-10-04: 8 servers started 22:30, engine
+# reinstalled 23:15, nothing reported it.
+# --------------------------------------------------------------------------
+
+def _ps_rows() -> Optional[list[tuple[int, float, str]]]:
+    """(pid, start epoch, command) for every process, or None where `ps` with
+    `lstart` is unavailable (Windows)."""
+    import datetime
+    import os
+    import subprocess
+    import sys
+
+    if sys.platform == "win32":
+        return None
+    try:
+        out = subprocess.run(["ps", "-axo", "pid=,lstart=,command="], capture_output=True,
+                             text=True, timeout=15, env={**os.environ, "LC_ALL": "C"}).stdout
+    except (OSError, subprocess.SubprocessError):
+        return None
+    rows = []
+    for line in out.splitlines():
+        parts = line.split(None, 6)
+        if len(parts) < 7:
+            continue
+        try:
+            start = datetime.datetime.strptime(" ".join(parts[1:6]), "%a %b %d %H:%M:%S %Y")
+            rows.append((int(parts[0]), start.timestamp(), parts[6]))
+        except ValueError:
+            continue
+    return rows
+
+
+def _engine_install(command: str) -> Optional[tuple[float, str]]:
+    """(install time, version) of the engine a `<venv>/bin/brain-mcp` runs."""
+    for stamp in sorted(Path(command).parent.parent.glob("lib/python*/site-packages/brain/_version.py")):
+        match = re.search(r'__version__\s*=\s*"([^"]+)"', stamp.read_text(encoding="utf-8"))
+        return stamp.stat().st_mtime, (match.group(1) if match else "?")
+    return None
+
+
+def check_mcp_server_code(config_path: Optional[Path] = None,
+                          ps_rows: Optional[list[tuple[int, float, str]]] = None) -> list[dict]:
+    """One row per brain-mcp command Desktop launches: are its running
+    servers newer than the engine they would load today? Never gating — a
+    Desktop restart must not hold `brain update` or CI hostage."""
+    import datetime
+
+    from . import connect as _connect
+
+    data = _read_json(config_path or _connect.claude_desktop_config_path()) or {}
+    commands = sorted({str((e or {}).get("command")) for e in (data.get("mcpServers") or {}).values()
+                       if "brain-mcp" in str((e or {}).get("command", ""))})
+    procs = _ps_rows() if ps_rows is None else ps_rows
+    rows = []
+    for command in commands:
+        surface = f"Claude Desktop Brainiac servers ({command})"
+        installed = _engine_install(command)
+        if procs is None or installed is None:
+            rows.append(_row(surface, NOT_DETECTABLE, "cannot read the running servers or the "
+                             "engine they load on this platform", raw={"action_needed": False}))
+            continue
+        at, version = installed
+        when = datetime.datetime.fromtimestamp(at).strftime("%Y-%m-%d %H:%M")
+        # Desktop runs each server under its `disclaimer --pgroup --` helper,
+        # which carries the same command line: count the server, not the
+        # wrapper too (it read "16 processes" for 8 servers, 2026-10-11).
+        starts = [start for _pid, start, cmd in procs
+                  if command in cmd and "/Helpers/disclaimer " not in cmd]
+        old = [s for s in starts if s < at]
+        if not starts:
+            rows.append(_row(surface, NOT_DETECTABLE,
+                             f"none running — Claude Desktop will load {version} when it starts them",
+                             raw={"action_needed": False}))
+        elif old:
+            rows.append(_row(surface, MANUAL_REQUIRED,
+                             f"{len(old)} of {len(starts)} running server(s) started before the "
+                             f"engine was installed ({version}, {when}) — they still serve the old code",
+                             remediation="quit Claude Desktop completely (Cmd+Q) and reopen it",
+                             raw={"action_needed": True, "version": version}))
+        else:
+            rows.append(_row(surface, CURRENT,
+                             f"{len(starts)} running server(s), all started after the engine "
+                             f"install ({version}, {when})", raw={"action_needed": False}))
     return rows
 
 

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/doctor_plugins.py

@@ -237,6 +237,44 @@ def check_plugin_manifests(repo_root: Path, ssot: str) -> list[dict]:
 # marketplace + installed_plugins.json are both local files, no network).
 # --------------------------------------------------------------------------
 
+def _plugin_copies(entries: list, folder_version: Optional[str] = None,
+                   ) -> tuple[list[dict], Optional[str], int]:
+    """Each installed copy of one plugin as (scope, project_path, version),
+    plus the last unreadable installPath and the count of orphaned copies.
+
+    An orphaned copy is a project-scope entry whose project no longer exists
+    (a deleted worktree): Claude Code never loads it, and `brain update`
+    crashed running `claude plugin update` from the missing directory
+    (v0.20.42 deploy, 2026-10-11). It is not a copy to judge or update.
+
+    ``folder_version`` is set when the marketplace is a local folder. Claude
+    Code then reads a project copy straight from that folder ("is read from
+    its folder: nothing to update") and never rewrites its registry record, so
+    the recorded cache path stays at an old version forever: judge the copy
+    by the folder it actually loads (false stale rows after 0.20.42)."""
+    copies, unreadable, orphaned = [], None, 0
+    for entry in entries:
+        if not isinstance(entry, dict):
+            unreadable = None
+            continue
+        project = entry.get("projectPath")
+        if entry.get("scope") in ("project", "local") and project and not Path(project).is_dir():
+            orphaned += 1
+            continue
+        if folder_version and entry.get("scope") in ("project", "local"):
+            copies.append({"scope": entry["scope"], "project_path": project,
+                           "version": folder_version})
+            continue
+        install_path = entry.get("installPath")
+        pjson = _read_json(Path(install_path) / ".claude-plugin" / "plugin.json") if install_path else None
+        if not (pjson and pjson.get("version")):
+            unreadable = install_path
+            continue
+        copies.append({"scope": entry.get("scope") or "user",
+                       "project_path": project, "version": pjson["version"]})
+    return copies, unreadable, orphaned
+
+
 def check_installed_cli_plugins(
     claude_home: Path, ssot: str, marketplace_name: str = "brainiac",
     marketplace_dir: Optional[Path] = None,
@@ -246,6 +284,8 @@ def check_installed_cli_plugins(
     # installLocation, NOT the hardcoded marketplaces/<name> dir — the caller
     # passes the resolved dir; keep the hardcoded guess only as the fallback.
     marketplace_dir = marketplace_dir or (claude_home / "plugins" / "marketplaces" / marketplace_name)
+    known = (_read_json(claude_home / "plugins" / "known_marketplaces.json") or {}).get(marketplace_name)
+    from_folder = ((known or {}).get("source") or {}).get("source") == "directory"
     for pname in PLUGIN_NAMES:
         surface = f"Installed CLI plugin ({pname})"
         mkt_json = marketplace_dir / "plugins" / pname / ".claude-plugin" / "plugin.json"
@@ -258,11 +298,28 @@ def check_installed_cli_plugins(
         mkt_version = mkt_data.get("version")
         installed_json = claude_home / "plugins" / "installed_plugins.json"
         installed_data = _read_json(installed_json) or {}
-        plugin_entries = (installed_data.get("plugins") or {}).get(f"{pname}@{marketplace_name}")
+        all_entries = installed_data.get("plugins") or {}
+        plugin_entries = all_entries.get(f"{pname}@{marketplace_name}")
+        elsewhere = sorted(k for k in all_entries if k.startswith(f"{pname}@") and all_entries[k])
+        if not plugin_entries and elsewhere:
+            # Installed from ANOTHER marketplace (e.g. a Desktop upload). That
+            # copy is not ours to manage: installing @<marketplace_name> beside
+            # it creates a same-name duplicate (measured 2026-10-04).
+            first = all_entries[elsewhere[0]]
+            first = first[0] if isinstance(first, list) else first
+            install_path = first.get("installPath") if isinstance(first, dict) else None
+            pjson = _read_json(Path(install_path) / ".claude-plugin" / "plugin.json") if install_path else None
+            version = (pjson or {}).get("version") or "unknown version"
+            rows.append(_row(surface, NOT_DETECTABLE,
+                             f"installed as {elsewhere[0]} ({version}), not from {marketplace_name} "
+                             f"(marketplace has {mkt_version}) — update it where it was installed",
+                             raw={"installed_elsewhere": elsewhere, "marketplace": mkt_version}))
+            continue
         if not plugin_entries:
             rows.append(_row(surface, NOT_DETECTABLE,
                              f"not installed (marketplace has {mkt_version})",
-                             remediation=f"/plugin install {pname}@{marketplace_name}"))
+                             remediation=f"/plugin install {pname}@{marketplace_name}",
+                             raw={"marketplace": mkt_version}))
             continue
         # installed_plugins.json version field is a cache-dir label, not always
         # semver (it can be a git sha for github-sourced plugins) — read the
@@ -272,16 +329,13 @@ def check_installed_cli_plugins(
         # at its own version. Judge the oldest copy: reading only the first
         # entry reported a stale copy current (or the reverse) by list order.
         entries = plugin_entries if isinstance(plugin_entries, list) else [plugin_entries]
-        copies, unreadable = [], None
-        for entry in entries:
-            install_path = entry.get("installPath") if isinstance(entry, dict) else None
-            pjson = _read_json(Path(install_path) / ".claude-plugin" / "plugin.json") if install_path else None
-            if not (pjson and pjson.get("version")):
-                unreadable = install_path
-                continue
-            copies.append({"scope": entry.get("scope") or "user",
-                           "project_path": entry.get("projectPath"),
-                           "version": pjson["version"]})
+        copies, unreadable, orphaned = _plugin_copies(entries, mkt_version if from_folder else None)
+        if orphaned and not copies and unreadable is None:
+            rows.append(_row(surface, NOT_DETECTABLE,
+                             f"installed only for {orphaned} deleted project(s) "
+                             f"(marketplace has {mkt_version})",
+                             raw={"marketplace": mkt_version, "orphaned_copies": orphaned}))
+            continue
         if unreadable is not None or not copies:
             rows.append(_row(surface, UNKNOWN,
                              f"installed but version unreadable at {unreadable}"))
@@ -292,6 +346,8 @@ def check_installed_cli_plugins(
         pick = min if stale_copies else max
         installed_version = pick((c["version"] for c in copies), key=cmp_to_key(_compare))
         where = "" if len(copies) == 1 else f" ({len(stale_copies)} of {len(copies)} copies behind)"
+        if orphaned:
+            where += f" ({orphaned} copy(ies) for deleted projects ignored)"
         cmp_ = _compare(installed_version, mkt_version or "")
         if cmp_ == 0:
             rows.append(_row(surface, CURRENT, f"installed {installed_version} == marketplace {mkt_version}",

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/folds/intake.py

@@ -11,8 +11,7 @@ from .. import _optional, config, maintenance
 # ADR 0013: both constants feed only the COS folds, which never run without COS.
 if _optional.cos_available():
     from ..cos.sheet_threads import BODY_NEVER_READABLE as _BODY_NEVER_READABLE
-    from ..cos._attachment_gate import (
-        BODY_ERROR_NIGHTS as _BODY_ERROR_NIGHTS)
+    from ..cos._attachment_gate import BODY_ERROR_NIGHTS as _BODY_ERROR_NIGHTS
 else:
     _BODY_NEVER_READABLE = frozenset()
     _BODY_ERROR_NIGHTS = 0
@@ -115,8 +114,9 @@ class IntakeFoldsMixin:
         self._cos_night_stopped(run)
         from ..cos.night_died import night_died_items  # noqa: PLC0415
         run.action_required.extend(night_died_items(self.vault, run.results))
-        from ..cos._ingest_claim import encrypted_decline_items  # noqa: PLC0415
-        run.action_required.extend(encrypted_decline_items(self.vault))
+        from ..cos import _ingest_claim, calendar_block  # noqa: PLC0415
+        run.action_required.extend(_ingest_claim.encrypted_decline_items(self.vault))
+        run.action_required.extend(calendar_block.read_failed_items(self.vault))
 
     def _cos_night_stopped(self, run: MaintenanceRun) -> None:
         """A NIGHT THAT STOPPED EARLY REACHES `brain alerts` (2026-09-27).

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/ingest/handlers/tables.py

@@ -51,14 +51,15 @@ def rows_to_markdown(rows: list[list[object]], *, label: str = "table",
     rows = [r for r in rows if any(_cell(c) for c in r)]  # drop fully-blank rows
     if not rows:
         return ""
+    ragged = any(len(r) != len(rows[0]) for r in rows[1:])
+    # Drop fully-blank columns too: a sheet's used range can run thousands of
+    # empty columns wide, and every row then carries them as "|  |" padding.
+    width = max(len(r) for r in rows)
+    cols = [i for i in range(width) if any(i < len(r) and _cell(r[i]) for r in rows)]
+    rows = [[r[i] for i in cols if i < len(r)] for r in rows]
     header = [_cell(c) for c in rows[0]]
     ncols = len(header)
-    unparsed = (
-        ncols == 0
-        or not any(header)
-        or len(rows) < 2
-        or any(len(r) != ncols for r in rows[1:])
-    )
+    unparsed = ncols == 0 or not any(header) or len(rows) < 2 or ragged
     if unparsed:
         raw = "\n".join(" | ".join(_cell(c) for c in r) for r in rows)
         keep("chrome", "```table-unparsed")

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/interview_detect.py

@@ -233,6 +233,34 @@ def _link_targets(core: Any, query: str, sid: str,
             for _, hid, title in ranked[:limit]]
 
 
+_SERIES_DATE = re.compile(r"^\d{4}-\d{2}-\d{2}-")
+_SERIES_NUMBER = re.compile(r"-\d+$")
+
+
+def _series(sid: str) -> str:
+    """`2026-09-14-safety-environment-week-33` -> `safety-environment-week-#`.
+
+    ONLY A TRAILING NUMBER, so `doc-48367-1-signed` stays its own series: a
+    numbered document is not a sibling of another numbered document."""
+    return _SERIES_NUMBER.sub("-#", _SERIES_DATE.sub("", sid))
+
+
+def noise_series(state: dict[str, Any], min_answers: int = 2) -> set[str]:
+    """Numbered series the owner has answered `noise` on at least twice.
+
+    Sheet 2026-10-09: ten `noise` answers on weekly HSSEQ reports (weeks 24-32)
+    and the lane still asked weeks 33, 34 and 36, because each answer silenced
+    one source and a new week arrives every week. Two answers, not one, so a
+    single noise answer never hides a sibling the owner has not seen."""
+    counts: dict[str, int] = {}
+    for r in state["rows"]:
+        if (r.get("shape") == "orphan" and r.get("answer") == "noise"
+                and _SERIES_NUMBER.search(str((r.get("target") or {}).get("id") or ""))):
+            key = _series(str(r["target"]["id"]))
+            counts[key] = counts.get(key, 0) + 1
+    return {k for k, n in counts.items() if n >= min_answers}
+
+
 def _orphan_candidates(core: Any, state: dict[str, Any], today: _dt.date,
                        per_night: int = 3, max_searches: int = 10):
     """Sources nothing cites, from the linking lane's own worklist, with the
@@ -249,12 +277,15 @@ def _orphan_candidates(core: Any, state: dict[str, Any], today: _dt.date,
     except (OSError, ValueError):
         return
     yielded = searched = 0
+    silenced = noise_series(state)
     for c in lane.get("candidates") or []:
         if yielded >= per_night or searched >= max_searches:
             return
         sid = str(c.get("id") or "")
         if not sid or blocked(state, question_key("orphan", [sid]), sid, today):
             continue
+        if _series(sid) in silenced:
+            continue
         searched += 1
         title = str(c.get("title") or sid)
         query = (title + " " + note_excerpt(core.vault, str(c.get("path") or ""),

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/remediation.py

@@ -369,6 +369,7 @@ _EXACT: dict[str, Remedy] = {
         BANNER,
         note="ADR 0013: this vault has COS folders but the installed engine "
              "has no COS code, so the nightly cannot run; never silent"),
+    "cos-calendar-read-failed": Remedy(BANNER, note="next night retries; a good read clears it"),
     "exceptions": Remedy(
         BANNER, note="EXC-03: the unified 'N exception(s) — open <page>' "
                      "banner, read the SAME way on host and VM from the "

{brainiac_cli-0.20.41 → brainiac_cli-0.20.43}/src/brain/update_channels_2.py

@@ -68,12 +68,11 @@ def _run_plugin_reinstall(
         marketplace = raw.get("marketplace")
         plugin_name = row["surface"].split("(", 1)[1].rstrip(")")
         action = callbacks.decide_plugin_action(installed, marketplace)
-        if dry_run:
-            applied = {
-                "action": action,
-                "ok": True,
-                "detail": f"[dry-run] would {action}",
-            }
+        if raw.get("installed_elsewhere"):  # another marketplace's copy: never add a duplicate
+            applied = {"action": "skip", "ok": True,
+                       "detail": f"installed as {', '.join(raw['installed_elsewhere'])} — not managed here"}
+        elif dry_run:
+            applied = {"action": action, "ok": True, "detail": f"[dry-run] would {action}"}
         else:
             applied = callbacks.apply_plugin_action(
                 action,
@@ -211,6 +210,28 @@ def _run_workspace_restage(
     )
 
 
+_DESKTOP_SURFACES = ("Desktop/Cowork plugin store", "Claude Desktop Brainiac servers")
+
+
+def _desktop_residual(after_doctor: dict[str, Any], compare: Any) -> list[str]:
+    """One owner step per Desktop row that needs one. Each row states its own
+    verdict in ``raw["action_needed"]`` (the plugin store judges skill TEXT,
+    not Cowork's lagging label); a row without it falls back to the label."""
+    ssot = after_doctor.get("ssot_version") or "0.0.0"
+    steps = []
+    for row in after_doctor["rows"]:
+        if not row["surface"].startswith(_DESKTOP_SURFACES):
+            continue
+        raw = row.get("raw") or {}
+        need = raw.get("action_needed")
+        if need is None:
+            need = bool(raw.get("version")) and compare(str(raw["version"]), ssot) < 0
+        if need:
+            steps.append(f"{row['surface']} is STALE ({row['detail']}) -> "
+                         f"{row.get('remediation') or 'see brain doctor'}")
+    return steps
+
+
 def _finalize_update(
     result: dict[str, Any],
     before_table: dict[str, str],
@@ -219,20 +240,7 @@ def _finalize_update(
 ) -> None:
     """Build the final before/after table and completion note."""
     result["steps"]["doctor_after"] = callbacks.render_human(after_doctor)
-    ssot_after = after_doctor.get("ssot_version") or "0.0.0"
-    desktop_stale = any(
-        row["surface"].startswith("Desktop/Cowork plugin store")
-        and (row.get("raw") or {}).get("version")
-        and callbacks.compare(str((row.get("raw") or {})["version"]), ssot_after) < 0
-        for row in after_doctor["rows"]
-    )
-    if desktop_stale:
-        result["residual_human_steps"].append(
-            "Desktop/Cowork plugin store is STALE and has no external CLI: in a "
-            "Cowork session use /skill-creator to repackage + Save-and-Replace the "
-            "stale skill(s) — /brainiac-update is host-only and refuses in Cowork — "
-            "then re-run `brain doctor` on the host to confirm it took."
-        )
+    result["residual_human_steps"].extend(_desktop_residual(after_doctor, callbacks.compare))
 
     table: list[dict[str, str]] = []
     surfaces = sorted(set(before_table) | {