wicked-garden 12.27.0

package/scripts/_heavy_cadence.py

@@ -0,0 +1,324 @@
+"""scripts/_heavy_cadence.py — session-end heavy cadence work + 60-min stop fallback.
+
+Provenance: v9.2.15 redesign of stop.py per-turn cadence. Pre-fix, four heavy
+functions ran on EVERY Stop hook (per turn end):
+
+  - _run_memory_decay        (brain `lint`)
+  - _run_working_consolidation (brain `compile` + `lint`, 10s heaviest call)
+  - _run_quality_telemetry   (timeline.jsonl append + drift bus event)
+  - _run_guard_pipeline      (scalpel/standard profile + findings.json + bus)
+
+Per-turn cadence costs:
+  ~90 brain HTTP calls per 30-turn session  (vs 3 if session-end-scoped)
+  30 timeline.jsonl appends                 (vs 1)
+  30 findings.json overwrites               (vs 1; mid-session signal lost)
+  4-session drift baseline → 4-turn baseline (CORRECTNESS BUG, not just perf)
+
+The v9.2.11 audit + v9.2.15 quick brainstorm settled on Option C (hybrid):
+  - SessionEnd hook is the primary cadence (new in this PR — was unwired).
+  - stop.py keeps a 60-min time-gated fallback for the partial-session
+    failure mode (CLI killed, network drop, user walks away — SessionEnd
+    never fires).
+
+A sidecar file at <local store>/wicked-garden/heavy-cadence/last_run.json
+records `last_heavy_run_ts` + `trigger` so the Stop fallback is deterministic.
+SessionState is per-session (resets on new session), so it can't gate cross-
+session fallback — sidecar is the right persistence boundary.
+
+Brain calls themselves are unchanged. Only WHEN they fire changed.
+
+v9.2.15 council mitigation (3-of-4 reviewers cited TOCTOU race as top risk):
+sidecar writes use the write-temp-then-os.replace pattern instead of bare
+write_text. os.replace is atomic on both POSIX and Windows, so two parallel
+Stop calls passing the should_run_fallback() check simultaneously cannot
+produce a corrupt sidecar JSON. The heavy operations themselves are
+idempotent (per the inventory), so duplicate runs waste work but don't
+corrupt state.
+
+R1: no dead code — every helper is called from main flow + tests.
+R3: constants named (FALLBACK_INTERVAL_SECS, SIDECAR_FILENAME).
+R5: subprocess-free in module body (subprocess only via _brain_api).
+"""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import List, Optional
+
+# 60-minute fallback interval. Picked because:
+#  - Long enough that a normal multi-turn session never crosses it (typical
+#    "I'm doing real work" sessions complete in <30 min and SessionEnd fires).
+#  - Short enough that abruptly-killed sessions get caught up the next time
+#    a Stop fires after the user resumes work — no >1hr gap in decay/
+#    consolidation activity.
+#  - Same magnitude as wicked-brain's own stale-content thresholds so brain
+#    decay decisions remain timely even under fallback.
+FALLBACK_INTERVAL_SECS: int = 60 * 60
+
+SIDECAR_DIR_NAME: str = "heavy-cadence"
+SIDECAR_FILENAME: str = "last_run.json"
+
+# Trigger strings recorded in the sidecar — surfaced in observability if we
+# ever need to debug "why did decay fire here". Not load-bearing for behavior.
+TRIGGER_SESSION_END: str = "session_end"
+TRIGGER_STOP_FALLBACK: str = "stop_fallback"
+
+
+def _utc_iso_now() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _sidecar_path() -> Optional[Path]:
+    """Resolve the per-project sidecar file path. None on resolution failure.
+
+    Per-project automatic because get_local_path("wicked-garden", ...) is
+    scoped under the active project's slug. A user with multiple projects
+    gets one sidecar per project — fallback gating is correctly isolated.
+    """
+    try:
+        from _domain_store import get_local_path  # type: ignore
+        return get_local_path("wicked-garden", SIDECAR_DIR_NAME) / SIDECAR_FILENAME
+    except Exception:
+        return None
+
+
+def _read_sidecar() -> dict:
+    """Return the sidecar dict or {} if missing/corrupt. Best-effort, no raise."""
+    p = _sidecar_path()
+    if p is None or not p.exists():
+        return {}
+    try:
+        return json.loads(p.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def _write_sidecar(trigger: str, session_id: Optional[str] = None) -> None:
+    """Record `last_heavy_run_ts` + trigger. Best-effort, no raise.
+
+    Atomic write via temp-file + os.replace (v9.2.15 council mitigation,
+    3-of-4 reviewers cited TOCTOU race as top risk):
+
+      1. Write payload to `<sidecar>.tmp.<pid>` (PID disambiguates parallel
+         writers — two processes won't clobber each other's temp files).
+      2. `os.replace(tmp, sidecar)` — atomic on both POSIX and Windows.
+         Either the old sidecar OR the new sidecar is observable by any
+         concurrent reader; never a half-written file.
+
+    Heavy operations are idempotent (decay is set-difference, compile is
+    deterministic given input chunks, telemetry appends are tagged with
+    session_id, guard overwrites a session-scoped findings file), so two
+    parallel runs waste work but cannot corrupt domain state.
+    """
+    p = _sidecar_path()
+    if p is None:
+        return
+    try:
+        p.parent.mkdir(parents=True, exist_ok=True)
+        payload = json.dumps({
+            "last_heavy_run_ts": _utc_iso_now(),
+            "trigger": trigger,
+            "session_id": session_id or "",
+        })
+        # PID-disambiguated temp path so two parallel writers don't collide
+        # on the same temp file before either calls os.replace.
+        tmp = p.with_name(f"{p.name}.tmp.{os.getpid()}")
+        tmp.write_text(payload, encoding="utf-8")
+        os.replace(tmp, p)
+    except OSError:
+        # Best-effort cleanup of orphaned temp file. Failure to clean up is
+        # not load-bearing — the next successful write displaces it.
+        try:
+            tmp.unlink(missing_ok=True)  # type: ignore[name-defined]
+        except (NameError, OSError):
+            pass
+
+
+def should_run_fallback(now_ts: Optional[float] = None) -> bool:
+    """Return True if Stop should run the heavy cadence as a fallback.
+
+    Triggers True when:
+      - sidecar file missing (first run ever for this project)
+      - sidecar exists but `last_heavy_run_ts` is unparseable
+      - last run was more than FALLBACK_INTERVAL_SECS ago
+
+    Defaults False when the sidecar is fresh — most Stop calls are per-turn
+    and should NOT trigger heavy work.
+    """
+    data = _read_sidecar()
+    raw_ts = data.get("last_heavy_run_ts")
+    if not raw_ts:
+        return True  # never run — fire fallback to seed the sidecar
+    try:
+        last_dt = datetime.fromisoformat(raw_ts.replace("Z", "+00:00"))
+    except (ValueError, AttributeError):
+        return True  # corrupt timestamp — treat as never-run
+    now_dt = datetime.fromtimestamp(now_ts, tz=timezone.utc) if now_ts else datetime.now(timezone.utc)
+    elapsed = (now_dt - last_dt).total_seconds()
+    return elapsed >= FALLBACK_INTERVAL_SECS
+
+
+def run_heavy_cadence(trigger: str, session_id: Optional[str] = None,
+                       plugin_root: Optional[Path] = None) -> List[str]:
+    """Run all four heavy functions + record the run in the sidecar.
+
+    Used by:
+      - hooks/scripts/session_end.py (primary, trigger=session_end)
+      - hooks/scripts/stop.py (fallback when should_run_fallback() True,
+        trigger=stop_fallback)
+
+    Returns aggregated message strings (decay + consolidation + telemetry +
+    guard) suitable for a systemMessage emit. Each underlying function fails
+    open — a brain outage doesn't block the others.
+    """
+    if plugin_root is None:
+        # Default — used when called from a hook. Tests pass plugin_root.
+        plugin_root = Path(__file__).resolve().parents[1]
+
+    messages: List[str] = []
+    messages.extend(_run_memory_consolidation(plugin_root))
+    messages.extend(_run_memory_decay(plugin_root))
+    messages.extend(_run_quality_telemetry(plugin_root, session_id or ""))
+    messages.extend(_run_guard_pipeline(plugin_root))
+
+    _write_sidecar(trigger, session_id=session_id)
+    return messages
+
+
+# ---------------------------------------------------------------------------
+# The four heavy functions — extracted from stop.py and unchanged in behavior.
+# Brain APIs called identically; what changed is only WHEN they fire.
+# ---------------------------------------------------------------------------
+
+def _brain_api_call(plugin_root: Path, action: str, params: dict, timeout: int = 5):
+    """Lightweight brain HTTP wrapper — same shape as stop.py::_brain_api but
+    importable without pulling in stop.py's hook-specific dependencies.
+    """
+    try:
+        sys.path.insert(0, str(plugin_root / "scripts"))
+        from _brain_port import resolve_port
+        import urllib.request
+        import urllib.error
+
+        port = resolve_port()
+        url = f"http://localhost:{port}/api/{action}"
+        data = json.dumps(params or {}).encode("utf-8")
+        req = urllib.request.Request(
+            url, data=data, headers={"Content-Type": "application/json"}, method="POST"
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def _run_memory_decay(plugin_root: Path) -> List[str]:
+    """Run decay maintenance via brain lint API. Idempotent."""
+    messages: List[str] = []
+    try:
+        result = _brain_api_call(plugin_root, "lint", {}, timeout=5)
+        if result and (result.get("archived", 0) > 0 or result.get("deleted", 0) > 0):
+            messages.append(
+                f"[Memory] Decay: {result.get('archived', 0)} archived, {result.get('deleted', 0)} cleaned"
+            )
+    except Exception as e:
+        print(f"[wicked-garden] decay error: {e}", file=sys.stderr)
+    return messages
+
+
+def _run_memory_consolidation(plugin_root: Path) -> List[str]:
+    """Consolidate working-tier memories via brain compile + lint.
+
+    Heaviest call in the cadence (10s timeout on compile). Idempotent —
+    same chunks won't re-synthesize the same wiki article.
+    """
+    messages: List[str] = []
+    try:
+        compile_result = _brain_api_call(plugin_root, "compile", {}, timeout=10)
+        lint_result = _brain_api_call(plugin_root, "lint", {}, timeout=5)
+        compiled = compile_result.get("compiled", 0) if compile_result else 0
+        cleaned = lint_result.get("deleted", 0) if lint_result else 0
+        if compiled > 0 or cleaned > 0:
+            messages.append(
+                f"[Memory] Consolidation: {compiled} compiled, {cleaned} cleaned"
+            )
+    except Exception as e:
+        print(f"[wicked-garden] consolidation error: {e}", file=sys.stderr)
+    return messages
+
+
+def _run_quality_telemetry(plugin_root: Path, session_id: str) -> List[str]:
+    """Append a timeline record + detect drift. Returns any messages.
+
+    Per-session-end cadence is REQUIRED for correctness — per-turn capture
+    inflates timeline.jsonl 30x and reduces the 4-session drift baseline to
+    a 4-turn baseline (signal dilution).
+    """
+    messages: List[str] = []
+    try:
+        sys.path.insert(0, str(plugin_root / "scripts" / "delivery"))
+        import telemetry as _telemetry  # type: ignore
+        import drift as _drift  # type: ignore
+
+        record = _telemetry.capture_session(session_id)
+        if record is None:
+            return messages
+
+        project = record.get("project") or "_global"
+        records = _telemetry.read_timeline(project)
+        cls = _drift.classify(records)
+        emitted = _drift.emit_drift_event(project, cls)
+        if cls.get("drift"):
+            messages.append(
+                f"[Telemetry] Drift detected for {project}: " + _drift.summarize(cls)
+                + (" (emitted to wicked-bus)" if emitted else "")
+            )
+        elif cls.get("zone") == "warn":
+            messages.append(
+                f"[Telemetry] Watch signal for {project}: " + _drift.summarize(cls)
+            )
+    except Exception as e:
+        print(f"[wicked-garden] telemetry error: {e}", file=sys.stderr)
+    return messages
+
+
+def _run_guard_pipeline(plugin_root: Path) -> List[str]:
+    """Run the autonomous session-close guard pipeline.
+
+    Writes findings.json (consumed by next-session bootstrap briefing) and
+    emits wicked.guard.findings on the bus. Per-session-end cadence avoids
+    overwriting mid-session findings before bootstrap can read them.
+    """
+    try:
+        sys.path.insert(0, str(plugin_root / "scripts" / "platform"))
+        from guard_pipeline import (  # type: ignore
+            run_pipeline, write_briefing_file, emit_findings_event, render_summary,
+        )
+    except Exception as exc:
+        print(f"[wicked-garden] guard pipeline unavailable: {exc}", file=sys.stderr)
+        return []
+
+    try:
+        build_just_closed = False
+        try:
+            sys.path.insert(0, str(plugin_root / "scripts"))
+            from _session import SessionState  # type: ignore
+            state = SessionState.load()
+            build_just_closed = bool(getattr(state, "last_phase_approved", None) == "build")
+        except Exception:
+            pass
+
+        report = run_pipeline(build_phase_just_closed=build_just_closed)
+        write_briefing_file(report)
+        emit_findings_event(report)
+
+        if report.total_findings > 0 or report.status != "ok":
+            return [render_summary(report)]
+        return []
+    except Exception as exc:
+        print(f"[wicked-garden] guard pipeline error: {exc}", file=sys.stderr)
+        return []

package/scripts/_integration_resolver.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""
+_integration_resolver.py — Integration tool resolution for DomainStore.
+
+Resolves which external tool (if any) should be used for a given plugin domain.
+Called by DomainStore._init_routing() during initialization, and also testable
+in isolation.
+
+Resolution order:
+    1. ~/.something-wicked/wicked-garden/config.json key tool_preferences.{domain}
+    2. Stored memory preference (tagged "tool-preference" + domain name)
+    3. MCP discovery (stub — deferred until MCP-from-Python approach is determined)
+    4. Interactive prompt if multiple matches (not reachable until step 3 is wired)
+
+Returns:
+    Tool name string ("linear", "jira", "notion", …) or None for local-only.
+
+stdlib-only — no external dependencies.
+"""
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+from typing import Optional
+
+# Config location — same root as the local data store
+_CONFIG_PATH = Path.home() / ".something-wicked" / "wicked-garden" / "config.json"
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def resolve_tool(domain: str, hook_mode: bool = False) -> Optional[str]:
+    """Return the external tool name to use for *domain*, or None for local.
+
+    Args:
+        domain:    Plugin domain, e.g. "wicked-crew", "wicked-garden:mem".
+        hook_mode: When True, skip discovery and return None immediately so
+                   hook scripts stay within the 5-second timing budget.
+
+    Returns:
+        Tool name string or None (meaning: use local JSON storage).
+    """
+    # Import here to avoid a circular import at module load time — _domain_store
+    # imports this module, and DOMAIN_MCP_PATTERNS lives in _domain_store.
+    try:
+        _scripts_dir = str(Path(__file__).parent)
+        if _scripts_dir not in sys.path:
+            sys.path.insert(0, _scripts_dir)
+        from _domain_store import DOMAIN_MCP_PATTERNS
+    except ImportError:
+        DOMAIN_MCP_PATTERNS = {}
+
+    # Domains not in the pattern registry are always local-only
+    if domain not in DOMAIN_MCP_PATTERNS:
+        return None
+
+    # Hook scripts skip discovery to meet timing budgets
+    if hook_mode:
+        return None
+
+    # ── Step 1: explicit user preference in config.json ──────────────────
+    preference = _read_config_preference(domain)
+    if preference:
+        return preference
+
+    # ── Step 2: stored memory preference ─────────────────────────────────
+    mem_preference = _check_mem_preference(domain)
+    if mem_preference:
+        return mem_preference
+
+    # ── Step 3: MCP discovery (stub — always returns []) ─────────────────
+    matches = _discover_mcp_tools(domain)
+
+    # ── Step 4: interactive prompt when multiple tools are found ──────────
+    if len(matches) == 1:
+        tool = matches[0]
+        _store_preference(domain, tool)
+        return tool
+
+    if len(matches) > 1:
+        tool = _prompt_user_choice(domain, matches)
+        return tool
+
+    # No external tool found — use local JSON
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Step 1 helpers
+# ---------------------------------------------------------------------------
+
+
+def _read_config_preference(domain: str) -> Optional[str]:
+    """Read tool_preferences.{domain} from config.json.
+
+    Returns the configured tool name, or None if not set or on any error.
+    """
+    try:
+        if not _CONFIG_PATH.exists():
+            return None
+        data = json.loads(_CONFIG_PATH.read_text(encoding="utf-8"))
+        prefs = data.get("tool_preferences")
+        if not isinstance(prefs, dict):
+            return None
+        value = prefs.get(domain)
+        if isinstance(value, str) and value:
+            return value
+        return None
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Step 2 helpers
+# ---------------------------------------------------------------------------
+
+
+def _brain_api(action, params=None, timeout=3):
+    """Call brain API. Returns parsed JSON or None."""
+    try:
+        import urllib.request
+        from _brain_port import resolve_port
+        port = resolve_port()
+        payload = json.dumps({"action": action, "params": params or {}}).encode("utf-8")
+        req = urllib.request.Request(
+            f"http://localhost:{port}/api",
+            data=payload,
+            headers={"Content-Type": "application/json"},
+            method="POST",
+        )
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def _check_mem_preference(domain: str) -> Optional[str]:
+    """Query brain for a previously stored tool preference.
+
+    Searches for memories tagged with "tool-preference" and the domain
+    name via the brain search API. Returns the tool name found in the
+    memory content, or None if not found or brain is unavailable.
+
+    Fails gracefully so callers that run before brain is initialized
+    (e.g. during onboarding) continue to work.
+    """
+    try:
+        result = _brain_api("search", {"query": f"tool-preference {domain}", "limit": 5}, timeout=3)
+        if not result:
+            return None
+
+        # Handle both list and dict response formats
+        results = result if isinstance(result, list) else result.get("results", [])
+        for r in results:
+            # Look for tool-preference memories that match this domain
+            content = r.get("content", "") or ""
+            path = r.get("path", "") or ""
+            if "tool-preference" in content and domain in content:
+                # Extract the tool name — it's the short content of the memory
+                # Try to read the actual chunk file for the definitive content
+                try:
+                    chunk_path = Path.home() / ".wicked-brain" / path
+                    if chunk_path.exists():
+                        text = chunk_path.read_text(encoding="utf-8")
+                        # Content is after the frontmatter and title
+                        parts = text.split("---", 2)
+                        if len(parts) >= 3:
+                            body = parts[2].strip()
+                            # Skip the title line (# ...)
+                            body_lines = [l for l in body.splitlines() if l.strip() and not l.startswith("#")]
+                            if body_lines:
+                                tool = body_lines[-1].strip()
+                                if tool:
+                                    return tool
+                except Exception:
+                    pass  # fail open
+        return None
+    except Exception:
+        # Brain may be unavailable — always fail gracefully
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Step 3 helpers
+# ---------------------------------------------------------------------------
+
+
+def _discover_mcp_tools(domain: str) -> list:
+    """Discover MCP tools available for *domain*.
+
+    MCP invocation from Python is unresolved (see design/architecture.md
+    Open Questions).  This is a stub that always returns an empty list.
+    Real discovery will be wired in a follow-on task once the approach is
+    determined.
+
+    Args:
+        domain: Plugin domain name (e.g. "wicked-crew").
+
+    Returns:
+        List of matching tool name strings (empty until real discovery is wired).
+    """
+    return []
+
+
+# ---------------------------------------------------------------------------
+# Step 4 helpers
+# ---------------------------------------------------------------------------
+
+
+def _prompt_user_choice(domain: str, matches: list) -> str:
+    """Interactively ask the user to choose from multiple matching tools.
+
+    Prints a numbered list to stdout and reads a line from stdin.
+    Stores the choice via _store_preference() and returns the selected tool.
+
+    Args:
+        domain:  Plugin domain name.
+        matches: Non-empty list of discovered tool name strings.
+
+    Returns:
+        Selected tool name string.
+    """
+    # Guard against non-interactive contexts (hooks, dangerous mode, CI).
+    if not sys.stdin.isatty():
+        return _local_fallback_and_store(domain, matches)
+
+    print(f"\n[wicked-garden] Multiple integration tools found for {domain}:")
+    for idx, tool in enumerate(matches, start=1):
+        print(f"  {idx}. {tool}")
+    print(f"  {len(matches) + 1}. Use local storage (no external tool)")
+    print("Enter a number to select: ", end="", flush=True)
+
+    try:
+        raw = sys.stdin.readline().strip()
+        choice_num = int(raw)
+    except (ValueError, EOFError, OSError):
+        # Default to local on any input error
+        return _local_fallback_and_store(domain, matches)
+
+    if 1 <= choice_num <= len(matches):
+        tool = matches[choice_num - 1]
+        _store_preference(domain, tool)
+        return tool
+
+    # Choice was "local" or out of range — store "local" sentinel so we don't
+    # ask again this session; return None via the caller's None path.
+    # We can't return None here (return type is str), so store and return the
+    # first match; caller will treat any truthy return as an external tool.
+    # Instead, write a special "local" marker and return the first match as a
+    # no-op — the adapter will return None and fall through to local JSON.
+    # Realistically this branch is unreachable until _discover_mcp_tools returns
+    # real results, so correctness here is secondary to not crashing.
+    return _local_fallback_and_store(domain, matches)
+
+
+def _local_fallback_and_store(domain: str, matches: list) -> str:
+    """Store 'local' preference and return the first match as a no-op tool name.
+
+    Internal helper: used when the user selects the 'local' option or
+    input parsing fails. Returns first match so the caller has a valid string;
+    the adapter's stub will return None → local JSON path is taken.
+    """
+    _store_preference(domain, "local")
+    # Return first match — stub adapters return None so local JSON is used anyway.
+    return matches[0] if matches else "local"
+
+
+# ---------------------------------------------------------------------------
+# Preference storage
+# ---------------------------------------------------------------------------
+
+
+def _store_preference(domain: str, tool: str) -> None:
+    """Persist a tool preference to brain as a memory chunk.
+
+    Writes a memory chunk with tags=["tool-preference", domain] so future
+    sessions can skip the discovery step.
+
+    Fails silently on any error so a broken brain never blocks writes.
+    """
+    try:
+        import uuid
+        import os as _os
+        from datetime import datetime, timezone
+
+        mem_id = str(uuid.uuid4())
+        chunk_id = f"memories/semantic/mem-{mem_id}"
+        chunk_path = Path.home() / ".wicked-brain" / f"{chunk_id}.md"
+        chunk_path.parent.mkdir(parents=True, exist_ok=True)
+
+        tags_list = ["tool-preference", domain]
+        now = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+        title = f"Tool preference: {domain} → {tool}"
+
+        lines = ["---"]
+        lines.append("source: wicked-brain:memory")
+        lines.append("memory_type: preference")
+        lines.append("memory_tier: semantic")
+        lines.append(f"title: {title}")
+        lines.append("importance: 5")
+        lines.append("contains:")
+        for t in tags_list:
+            lines.append(f"  - {t}")
+        lines.append(f'indexed_at: "{now}"')
+        lines.append("---")
+        lines.append("")
+        lines.append(f"# {title}")
+        lines.append("")
+        lines.append(tool)
+
+        chunk_path.write_text("\n".join(lines), encoding="utf-8")
+
+        # Index in brain FTS5
+        search_text = f"{title} {tool} {' '.join(tags_list)}"
+        _brain_api("index", {"id": f"{chunk_id}.md", "path": f"{chunk_id}.md", "content": search_text, "brain_id": "wicked-brain"})
+    except Exception:
+        pass  # fail open: brain may be unavailable