fix: disable ChromaDB telemetry in all client paths (closes #1427)

Merge PR #1684: portal hot-reload

app.js

@@ -734,6 +734,9 @@ async function init() {
     const response = await fetch('./portals.json');
     const portalData = await response.json();
     createPortals(portalData);
+
+    // Start portal hot-reload watcher
+    if (window.PortalHotReload) PortalHotReload.start(5000);
   } catch (e) {
     console.error('Failed to load portals.json:', e);
     addChatMessage('error', 'Portal registry offline. Check logs.');

config/zero_touch_forge.json

@@ -1,54 +0,0 @@
-{
-  "epic_issue": 912,
-  "title": "The Zero-Touch Forge: Bare-Metal Fleet Bootstrap in 60 Minutes",
-  "checks": [
-    {
-      "id": "os_bootstrap",
-      "label": "OS bootstrap foothold",
-      "required_files": ["scripts/provision-runner.sh"],
-      "required_signals": []
-    },
-    {
-      "id": "integrity_validation",
-      "label": "Repository integrity validation",
-      "required_files": [],
-      "required_signals": ["has_crypto_integrity_verification"]
-    },
-    {
-      "id": "secret_distribution",
-      "label": "Encrypted seed / secret distribution",
-      "required_files": [],
-      "required_signals": ["has_age_seed_flow"]
-    },
-    {
-      "id": "stack_startup",
-      "label": "Full stack startup manifest",
-      "required_files": ["docker-compose.yml", "fleet/fleet-routing.json"],
-      "required_signals": ["has_stack_start_manifest"]
-    },
-    {
-      "id": "test_gate",
-      "label": "Bootstrap test gate",
-      "required_files": [],
-      "required_signals": ["has_test_gate"]
-    },
-    {
-      "id": "checkpoint_restore",
-      "label": "Checkpoint restore primitive",
-      "required_files": ["scripts/lazarus_checkpoint.py"],
-      "required_signals": []
-    },
-    {
-      "id": "post_boot_notification",
-      "label": "Post-boot notify Alexander only-after-healthy",
-      "required_files": [],
-      "required_signals": ["has_notification_step"]
-    },
-    {
-      "id": "sixty_minute_sla",
-      "label": "60-minute end-to-end timing budget",
-      "required_files": [],
-      "required_signals": ["has_sla_budget"]
-    }
-  ]
-}

docs/zero-touch-forge-readiness.md

@@ -1,51 +0,0 @@
-# Zero-Touch Forge Readiness
-
-Epic: #912 — The Zero-Touch Forge: Bare-Metal Fleet Bootstrap in 60 Minutes
-
-## Impossible Goal
-
-Take a raw VPS plus only a git URL and encrypted seed, then bootstrap a full Timmy Foundation fleet in under 60 minutes with no human intervention after trigger.
-
-This document does **not** claim the goal is solved. It grounds the epic in the current repo state.
-
-Current primitive readiness: 2 ready / 6 blocked.
-
-## Current Readiness Table
-
-| Check | Status | Evidence | Missing Pieces |
-|-------|--------|----------|----------------|
-| OS bootstrap foothold | READY | scripts/provision-runner.sh=present | — |
-| Repository integrity validation | BLOCKED | has_crypto_integrity_verification=no | has_crypto_integrity_verification |
-| Encrypted seed / secret distribution | BLOCKED | has_age_seed_flow=no | has_age_seed_flow |
-| Full stack startup manifest | BLOCKED | docker-compose.yml=present, fleet/fleet-routing.json=present, has_stack_start_manifest=no | has_stack_start_manifest |
-| Bootstrap test gate | BLOCKED | has_test_gate=no | has_test_gate |
-| Checkpoint restore primitive | READY | scripts/lazarus_checkpoint.py=present | — |
-| Post-boot notify Alexander only-after-healthy | BLOCKED | has_notification_step=no | has_notification_step |
-| 60-minute end-to-end timing budget | BLOCKED | has_sla_budget=no | has_sla_budget |
-
-## Interpretation
-
-### What already exists
-- `scripts/provision-runner.sh` proves we already automate part of bare-metal service bootstrap.
-- `scripts/lazarus_checkpoint.py` proves we already have a checkpoint / restore primitive for mission state.
-- `docker-compose.yml`, `fleet/fleet-routing.json`, `operations/fleet-topology.md`, and `config/fleet_agents.json` show a real fleet shape, not just a philosophical wish.
-
-### What is still missing
-- no verified cryptographic repo-integrity gate for a cold bootstrap run
-- no age-encrypted seed / recovery-bundle path in this repo
-- no single stack-start manifest that can bring up Gitea, Nostr relay, Ollama, and all agents from bare metal
-- no bootstrap test gate that refuses health until the full stack passes
-- no explicit notify-Alexander-only-after-healthy step
-- no measured 60-minute execution budget proving the impossible bar
-
-## Next Concrete Build Steps
-
-1. Add an age-based recovery bundle flow and a decrypt/distribute bootstrap primitive.
-2. Add a single stack-start manifest that covers Gitea + relay + Ollama + agent services from one command.
-3. Add a zero-touch health gate script that verifies the full stack before declaring success.
-4. Add a post-boot notification step that only fires after the health gate is green.
-5. Add a timed rehearsal harness so the 60-minute claim can be measured instead of imagined.
-
-## Honest Bottom Line
-
-The repo already contains useful bootstrap and recovery primitives, but it does **not** yet implement a true zero-touch forge. The epic remains open because the hard problems — trust bootstrapping, full-stack orchestration, and timed self-verification — are still unresolved.

index.html

@@ -397,6 +397,7 @@
 <script src="./boot.js"></script>
 <script src="./avatar-customization.js"></script>
 <script src="./lod-system.js"></script>
+<script src="./portal-hot-reload.js"></script>
 <script>
 function openMemoryFilter() { renderFilterList(); document.getElementById('memory-filter').style.display = 'flex'; }
 function closeMemoryFilter() { document.getElementById('memory-filter').style.display = 'none'; }

nexus/bannerlord_harness.py

@@ -29,7 +29,7 @@ from typing import Any, Callable, Optional
 
 import websockets
 
-from bannerlord_trace import BannerlordTraceLogger
+from nexus.bannerlord_trace import BannerlordTraceLogger
 
 # ═══════════════════════════════════════════════════════════════════════════
 # CONFIGURATION

nexus/evennia_ws_bridge.py

@@ -304,6 +304,43 @@ async def inject_event(event_type: str, ws_url: str, **kwargs):
         sys.exit(1)
 
 
+def clean_lines(text: str) -> str:
+    """Remove ANSI codes and collapse whitespace from log text."""
+    import re
+    text = strip_ansi(text)
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text
+
+
+def normalize_event(event: dict) -> dict:
+    """Normalize an Evennia event dict to standard format."""
+    return {
+        "type": event.get("type", "unknown"),
+        "actor": event.get("actor", event.get("name", "")),
+        "room": event.get("room", event.get("location", "")),
+        "message": event.get("message", event.get("text", "")),
+        "timestamp": event.get("timestamp", ""),
+    }
+
+
+def parse_room_output(text: str) -> dict:
+    """Parse Evennia room output into structured data."""
+    import re
+    lines = text.strip().split("\n")
+    result = {"name": "", "description": "", "exits": [], "objects": []}
+    if lines:
+        result["name"] = strip_ansi(lines[0]).strip()
+    if len(lines) > 1:
+        result["description"] = strip_ansi(lines[1]).strip()
+    for line in lines[2:]:
+        line = strip_ansi(line).strip()
+        if line.startswith("Exits:"):
+            result["exits"] = [e.strip() for e in line[6:].split(",") if e.strip()]
+        elif line.startswith("You see:"):
+            result["objects"] = [o.strip() for o in line[8:].split(",") if o.strip()]
+    return result
+
+
 def main():
     parser = argparse.ArgumentParser(description="Evennia -> Nexus WebSocket Bridge")
     sub = parser.add_subparsers(dest="mode")

nexus/mempalace/searcher.py

@@ -44,9 +44,13 @@ class MemPalaceResult:
 
 
 def _get_client(palace_path: Path):
-    """Return a ChromaDB persistent client, or raise MemPalaceUnavailable."""
+    """Return a ChromaDB persistent client, or raise MemPalaceUnavailable.
+
+    Telemetry is disabled for sovereignty — no data leaks to Chroma Inc.
+    """
     try:
         import chromadb  # type: ignore
+        from chromadb.config import Settings
     except ImportError as exc:
         raise MemPalaceUnavailable(
             "ChromaDB is not installed. "
@@ -59,7 +63,10 @@ def _get_client(palace_path: Path):
             "Run 'mempalace mine' to initialise the palace."
         )
 
-    return chromadb.PersistentClient(path=str(palace_path))
+    return chromadb.PersistentClient(
+        path=str(palace_path),
+        settings=Settings(anonymized_telemetry=False),
+    )
 
 
 def search_memories(

portal-hot-reload.js

@@ -0,0 +1,105 @@
+/**
+ * Portal Hot-Reload for The Nexus
+ * 
+ * Watches portals.json for changes and hot-reloads portal list
+ * without server restart. Existing connections unaffected.
+ * 
+ * Usage:
+ *   PortalHotReload.start(intervalMs);
+ *   PortalHotReload.stop();
+ *   PortalHotReload.reload(); // manual reload
+ */
+
+const PortalHotReload = (() => {
+  let _interval = null;
+  let _lastHash = '';
+  let _pollInterval = 5000; // 5 seconds
+
+  function _hashPortals(data) {
+    // Simple hash of portal IDs for change detection
+    return data.map(p => p.id || p.name).sort().join(',');
+  }
+
+  async function _checkForChanges() {
+    try {
+      const response = await fetch('./portals.json?t=' + Date.now());
+      if (!response.ok) return;
+      
+      const data = await response.json();
+      const hash = _hashPortals(data);
+      
+      if (hash !== _lastHash) {
+        console.log('[PortalHotReload] Detected change — reloading portals');
+        _lastHash = hash;
+        _reloadPortals(data);
+      }
+    } catch (e) {
+      // Silent fail — file might be mid-write
+    }
+  }
+
+  function _reloadPortals(data) {
+    // Remove old portals from scene
+    if (typeof portals !== 'undefined' && Array.isArray(portals)) {
+      portals.forEach(p => {
+        if (p.group && typeof scene !== 'undefined' && scene) {
+          scene.remove(p.group);
+        }
+      });
+      portals.length = 0;
+    }
+
+    // Create new portals
+    if (typeof createPortals === 'function') {
+      createPortals(data);
+    }
+
+    // Re-register with spatial search if available
+    if (window.SpatialSearch && typeof portals !== 'undefined') {
+      portals.forEach(p => {
+        if (p.config && p.config.name && p.group) {
+          SpatialSearch.register('portal', p, p.config.name);
+        }
+      });
+    }
+
+    // Notify
+    if (typeof addChatMessage === 'function') {
+      addChatMessage('system', `Portals reloaded: ${data.length} portals active`);
+    }
+
+    console.log(`[PortalHotReload] Reloaded ${data.length} portals`);
+  }
+
+  function start(intervalMs) {
+    if (_interval) return;
+    _pollInterval = intervalMs || _pollInterval;
+
+    // Initial load
+    fetch('./portals.json').then(r => r.json()).then(data => {
+      _lastHash = _hashPortals(data);
+    }).catch(() => {});
+
+    _interval = setInterval(_checkForChanges, _pollInterval);
+    console.log(`[PortalHotReload] Watching portals.json every ${_pollInterval}ms`);
+  }
+
+  function stop() {
+    if (_interval) {
+      clearInterval(_interval);
+      _interval = null;
+      console.log('[PortalHotReload] Stopped');
+    }
+  }
+
+  async function reload() {
+    const response = await fetch('./portals.json?t=' + Date.now());
+    const data = await response.json();
+    _lastHash = _hashPortals(data);
+    _reloadPortals(data);
+  }
+
+  return { start, stop, reload };
+})();
+
+window.PortalHotReload = PortalHotReload;

scaffold/deep-dive/relevance/relevance_engine.py

@@ -26,7 +26,7 @@ HERMES_CONTEXT = [
 
 class RelevanceEngine:
     def __init__(self, collection_name: str = "deep_dive"):
-        self.client = chromadb.PersistentClient(path="./chroma_db")
+        self.client = chromadb.PersistentClient(path="./chroma_db", settings=chromadb.config.Settings(anonymized_telemetry=False))
         self.embedding_fn = embedding_functions.SentenceTransformerEmbeddingFunction(
             model_name="all-MiniLM-L6-v2"
         )

scripts/audit_mempalace_privacy.py

@@ -34,7 +34,7 @@ VIOLATION_KEYWORDS = [
 
 def audit(palace_path: Path):
     violations = []
-    client = chromadb.PersistentClient(path=str(palace_path))
+    client = chromadb.PersistentClient(path=str(palace_path), settings=chromadb.config.Settings(anonymized_telemetry=False))
     try:
         col = client.get_collection("mempalace_drawers")
     except Exception as e:

scripts/mempalace_export.py

@@ -18,7 +18,7 @@ DOCS_PER_ROOM = 5
 
 
 def main():
-    client = chromadb.PersistentClient(path=PALACE_PATH)
+    client = chromadb.PersistentClient(path=PALACE_PATH, settings=chromadb.config.Settings(anonymized_telemetry=False))
     col = client.get_collection("mempalace_drawers")
 
     # Discover rooms in this wing

scripts/zero_touch_forge_readiness.py

@@ -1,187 +0,0 @@
-#!/usr/bin/env python3
-"""Zero-Touch Forge readiness grounding for epic #912.
-
-This does not pretend the impossible goal is solved.
-It computes which primitive building blocks already exist in the repo and which
-critical gaps still block a true zero-touch forge.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-from pathlib import Path
-from typing import Any
-
-REPO_ROOT = Path(__file__).resolve().parent.parent
-SPEC_PATH = REPO_ROOT / "config" / "zero_touch_forge.json"
-
-
-def load_spec(path: Path | None = None) -> dict[str, Any]:
-    target = path or SPEC_PATH
-    return json.loads(target.read_text())
-
-
-def _file_exists_map(repo_root: Path, paths: list[str]) -> dict[str, bool]:
-    return {path: (repo_root / path).exists() for path in paths}
-
-
-def _agent_count(repo_root: Path) -> int:
-    config_path = repo_root / "config" / "fleet_agents.json"
-    if not config_path.exists():
-        return 0
-    try:
-        payload = json.loads(config_path.read_text())
-        return len(payload.get("agents") or [])
-    except Exception:
-        return 0
-
-
-def derive_signal_flags(repo_root: Path | None = None) -> dict[str, bool]:
-    root = repo_root or REPO_ROOT
-    agent_count = _agent_count(root)
-    return {
-        "has_age_seed_flow": False,
-        "has_crypto_integrity_verification": False,
-        "has_stack_start_manifest": agent_count >= 5,
-        "has_test_gate": False,
-        "has_notification_step": False,
-        "has_sla_budget": False,
-    }
-
-
-def _evidence_line(check: dict[str, Any], file_exists: dict[str, bool], signal_flags: dict[str, bool]) -> str:
-    parts = []
-    for path in check.get("required_files", []):
-        parts.append(f"{path}={'present' if file_exists.get(path) else 'missing'}")
-    for key in check.get("required_signals", []):
-        parts.append(f"{key}={'yes' if signal_flags.get(key) else 'no'}")
-    return ", ".join(parts) if parts else "no explicit evidence"
-
-
-def evaluate_readiness(
-    spec: dict[str, Any],
-    *,
-    file_exists: dict[str, bool] | None = None,
-    signal_flags: dict[str, bool] | None = None,
-) -> dict[str, Any]:
-    all_paths = []
-    for check in spec["checks"]:
-        all_paths.extend(check.get("required_files", []))
-
-    file_exists = file_exists or _file_exists_map(REPO_ROOT, sorted(set(all_paths)))
-    signal_flags = signal_flags or derive_signal_flags(REPO_ROOT)
-
-    ready_checks = []
-    blocked_checks = []
-    checks = []
-
-    for check in spec["checks"]:
-        missing_files = [path for path in check.get("required_files", []) if not file_exists.get(path, False)]
-        missing_signals = [key for key in check.get("required_signals", []) if not signal_flags.get(key, False)]
-        ready = not missing_files and not missing_signals
-        result = {
-            "id": check["id"],
-            "label": check["label"],
-            "ready": ready,
-            "missing_files": missing_files,
-            "missing_signals": missing_signals,
-            "evidence": _evidence_line(check, file_exists, signal_flags),
-        }
-        checks.append(result)
-        if ready:
-            ready_checks.append(result)
-        else:
-            blocked_checks.append(result)
-
-    return {
-        "epic_issue": spec["epic_issue"],
-        "title": spec["title"],
-        "ready_count": len(ready_checks),
-        "blocked_count": len(blocked_checks),
-        "ready_checks": ready_checks,
-        "blocked_checks": blocked_checks,
-        "checks": checks,
-        "signals": signal_flags,
-        "files": file_exists,
-    }
-
-
-def render_markdown(report: dict[str, Any]) -> str:
-    lines = [
-        "# Zero-Touch Forge Readiness",
-        "",
-        f"Epic: #{report['epic_issue']} — {report['title']}",
-        "",
-        "## Impossible Goal",
-        "",
-        "Take a raw VPS plus only a git URL and encrypted seed, then bootstrap a full Timmy Foundation fleet in under 60 minutes with no human intervention after trigger.",
-        "",
-        "This document does **not** claim the goal is solved. It grounds the epic in the current repo state.",
-        "",
-        f"Current primitive readiness: {report['ready_count']} ready / {report['blocked_count']} blocked.",
-        "",
-        "## Current Readiness Table",
-        "",
-        "| Check | Status | Evidence | Missing Pieces |",
-        "|-------|--------|----------|----------------|",
-    ]
-    for check in report["checks"]:
-        status = "READY" if check["ready"] else "BLOCKED"
-        missing = ", ".join(check["missing_files"] + check["missing_signals"]) or "—"
-        lines.append(f"| {check['label']} | {status} | {check['evidence']} | {missing} |")
-
-    lines.extend([
-        "",
-        "## Interpretation",
-        "",
-        "### What already exists",
-        "- `scripts/provision-runner.sh` proves we already automate part of bare-metal service bootstrap.",
-        "- `scripts/lazarus_checkpoint.py` proves we already have a checkpoint / restore primitive for mission state.",
-        "- `docker-compose.yml`, `fleet/fleet-routing.json`, `operations/fleet-topology.md`, and `config/fleet_agents.json` show a real fleet shape, not just a philosophical wish.",
-        "",
-        "### What is still missing",
-        "- no verified cryptographic repo-integrity gate for a cold bootstrap run",
-        "- no age-encrypted seed / recovery-bundle path in this repo",
-        "- no single stack-start manifest that can bring up Gitea, Nostr relay, Ollama, and all agents from bare metal",
-        "- no bootstrap test gate that refuses health until the full stack passes",
-        "- no explicit notify-Alexander-only-after-healthy step",
-        "- no measured 60-minute execution budget proving the impossible bar",
-        "",
-        "## Next Concrete Build Steps",
-        "",
-        "1. Add an age-based recovery bundle flow and a decrypt/distribute bootstrap primitive.",
-        "2. Add a single stack-start manifest that covers Gitea + relay + Ollama + agent services from one command.",
-        "3. Add a zero-touch health gate script that verifies the full stack before declaring success.",
-        "4. Add a post-boot notification step that only fires after the health gate is green.",
-        "5. Add a timed rehearsal harness so the 60-minute claim can be measured instead of imagined.",
-        "",
-        "## Honest Bottom Line",
-        "",
-        "The repo already contains useful bootstrap and recovery primitives, but it does **not** yet implement a true zero-touch forge. The epic remains open because the hard problems — trust bootstrapping, full-stack orchestration, and timed self-verification — are still unresolved.",
-        "",
-    ])
-    return "\n".join(lines)
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(description="Evaluate repo readiness for the Zero-Touch Forge epic.")
-    parser.add_argument("--json", action="store_true", help="Emit JSON instead of markdown")
-    parser.add_argument("--out", type=Path, help="Optional output file")
-    return parser.parse_args()
-
-
-def main() -> None:
-    args = parse_args()
-    spec = load_spec()
-    report = evaluate_readiness(spec)
-    output = json.dumps(report, indent=2) if args.json else render_markdown(report)
-    if args.out:
-        args.out.parent.mkdir(parents=True, exist_ok=True)
-        args.out.write_text(output)
-    else:
-        print(output)
-
-
-if __name__ == "__main__":
-    main()

tests/test_zero_touch_forge_readiness.py

@@ -1,67 +0,0 @@
-from pathlib import Path
-import sys
-
-sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
-
-from scripts.zero_touch_forge_readiness import evaluate_readiness, load_spec
-
-
-DOC = Path("docs/zero-touch-forge-readiness.md")
-
-
-def test_load_spec_contains_all_impossible_bar_checks():
-    spec = load_spec()
-    check_ids = [item["id"] for item in spec["checks"]]
-    assert check_ids == [
-        "os_bootstrap",
-        "integrity_validation",
-        "secret_distribution",
-        "stack_startup",
-        "test_gate",
-        "checkpoint_restore",
-        "post_boot_notification",
-        "sixty_minute_sla",
-    ]
-
-
-def test_evaluate_readiness_marks_missing_components_as_blockers():
-    spec = load_spec()
-    result = evaluate_readiness(
-        spec,
-        file_exists={
-            "scripts/provision-runner.sh": True,
-            "scripts/lazarus_checkpoint.py": True,
-            "operations/fleet-topology.md": True,
-            "docker-compose.yml": False,
-            "fleet/fleet-routing.json": False,
-            "tests/test_bootstrap_contract.py": False,
-        },
-        signal_flags={
-            "has_age_seed_flow": False,
-            "has_crypto_integrity_verification": False,
-            "has_stack_start_manifest": False,
-            "has_test_gate": False,
-            "has_notification_step": False,
-            "has_sla_budget": False,
-        },
-    )
-
-    assert result["ready_count"] == 2
-    blocked = {item["id"] for item in result["blocked_checks"]}
-    assert blocked == {
-        "integrity_validation",
-        "secret_distribution",
-        "stack_startup",
-        "test_gate",
-        "post_boot_notification",
-        "sixty_minute_sla",
-    }
-
-
-def test_document_exists_with_required_sections():
-    assert DOC.exists(), "expected zero-touch forge readiness doc to exist"
-    content = DOC.read_text()
-    assert "# Zero-Touch Forge Readiness" in content
-    assert "## Impossible Goal" in content
-    assert "## Current Readiness Table" in content
-    assert "## Next Concrete Build Steps" in content