v1.0.3: expanded discovery (30+ service probes: koboldcpp, lmstudio, sglang, librechat, dify, flowise, n8n, qdrant, milvus, comfyui, whisper, openrouter...), tavern wire wiring audit, stack skill injection into container hermes

basecamp.sh

@@ -62,6 +62,7 @@ if docker ps --format '{{.Names}}' 2>/dev/null | grep -q "^${CONTAINER}$"; then
             ollama)     shift; docker exec $TTY_FLAG "$CONTAINER" ollama "$@";;
             bash|shell) docker exec $TTY_FLAG "$CONTAINER" bash;;
             rediscover) docker exec $TTY_FLAG "$CONTAINER" bash -c "rm -f /root/.hermes/basecamp_config.json && python3 /opt/basecamp/discover.py serve";;
+            wire)       docker exec $TTY_FLAG "$CONTAINER" python3 /opt/basecamp/discover.py wire;;
             *)          docker exec $TTY_FLAG "$CONTAINER" hermes "$@";;
         esac
     else

discover.py

@@ -134,21 +134,280 @@ SERVICE_PROBES = {
         "needs_auth": True,
         "auth_type": "bearer",
     },
+    # ── More inference engines ──
+    "koboldcpp": {
+        "paths": ["/api/v1/model", "/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"result"' in r or '"data"' in r,
+        "parse": lambda r: {
+            "models": [m["id"] for m in json.loads(r).get("data", [])]
+            if '"data"' in r else []
+        },
+        "label": "KoboldCpp (GGML inference)",
+        "icon": "KOB",
+    },
+    "lmstudio": {
+        "paths": ["/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"data"' in r and '"id"' in r and "lmstudio" not in r.lower(),
+        "parse": lambda r: {
+            "models": [m["id"] for m in json.loads(r).get("data", [])]
+        },
+        "label": "LM Studio (local model server)",
+        "icon": "LMS",
+    },
+    "sglang": {
+        "paths": ["/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"sglang"' in r.lower() or ('"object":"list"' in r and '"data"' in r and "vllm" not in r.lower()),
+        "parse": lambda r: {
+            "models": [m["id"] for m in json.loads(r).get("data", [])]
+        },
+        "label": "SGLang (fast LLM serving)",
+        "icon": "SGL",
+    },
+    "llamafile": {
+        "paths": ["/v1/models", "/health"],
+        "method": "GET",
+        "match": lambda r: '"data"' in r or '"status"' in r,
+        "parse": lambda r: {},
+        "label": "llamafile (single-file LLM)",
+        "icon": "LMF",
+    },
+    "exo": {
+        "paths": ["/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"data"' in r and '"id"' in r,
+        "parse": lambda r: {},
+        "label": "exo (distributed inference)",
+        "icon": "EXO",
+    },
+    "text-generation-inference": {
+        "paths": ["/v1/models", "/info"],
+        "method": "GET",
+        "match": lambda r: '"model_id"' in r or '"models"' in r,
+        "parse": lambda r: {},
+        "label": "TGI (Text Generation Inference)",
+        "icon": "TGI",
+    },
+    "aphrodite": {
+        "paths": ["/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"aphrodite"' in r.lower(),
+        "parse": lambda r: {},
+        "label": "Aphrodite Engine (inference)",
+        "icon": "APH",
+    },
+    "llamapool": {
+        "paths": ["/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"llama-pool"' in r.lower() or "llama pool" in r.lower(),
+        "parse": lambda r: {},
+        "label": "llama-pool (model router)",
+        "icon": "PL",
+    },
+    # ── More UIs / chat frontends ──
+    "librechat": {
+        "paths": ["/", "/api/health"],
+        "method": "GET",
+        "match": lambda r: "librechat" in r.lower() or "LibreChat" in r,
+        "parse": lambda r: {},
+        "label": "LibreChat (multi-model chat UI)",
+        "icon": "UI ",
+    },
+    "lobechat": {
+        "paths": ["/", "/api/status"],
+        "method": "GET",
+        "match": lambda r: "lobechat" in r.lower() or "LobeChat" in r,
+        "parse": lambda r: {},
+        "label": "LobeChat (AI chat framework)",
+        "icon": "UI ",
+    },
+    "anythingllm": {
+        "paths": ["/", "/api/system/endpoints"],
+        "method": "GET",
+        "match": lambda r: "anythingllm" in r.lower() or "AnythingLLM" in r,
+        "parse": lambda r: {},
+        "label": "AnythingLLM (RAG workspace)",
+        "icon": "RAG",
+    },
+    "dify": {
+        "paths": ["/", "/health"],
+        "method": "GET",
+        "match": lambda r: "dify" in r.lower() or "Dify" in r,
+        "parse": lambda r: {},
+        "label": "Dify (LLM app platform)",
+        "icon": "APP",
+    },
+    "flowise": {
+        "paths": ["/", "/api/v1/ping"],
+        "method": "GET",
+        "match": lambda r: "flowise" in r.lower() or "Flowise" in r,
+        "parse": lambda r: {},
+        "label": "Flowise (no-code agent builder)",
+        "icon": "FLW",
+    },
+    "n8n": {
+        "paths": ["/", "/healthz"],
+        "method": "GET",
+        "match": lambda r: "n8n" in r.lower() or "N8N" in r or "workflow" in r.lower(),
+        "parse": lambda r: {},
+        "label": "n8n (workflow automation)",
+        "icon": "WRK",
+    },
+    "langflow": {
+        "paths": ["/", "/api/v1/configs"],
+        "method": "GET",
+        "match": lambda r: "langflow" in r.lower() or "Langflow" in r,
+        "parse": lambda r: {},
+        "label": "Langflow (agent builder)",
+        "icon": "LGF",
+    },
+    "ragflow": {
+        "paths": ["/", "/api/v1/version"],
+        "method": "GET",
+        "match": lambda r: "ragflow" in r.lower() or "RAGFlow" in r,
+        "parse": lambda r: {},
+        "label": "RAGFlow (RAG engine)",
+        "icon": "RAG",
+    },
+    "koboldai": {
+        "paths": ["/", "/api/v1/config/status"],
+        "method": "GET",
+        "match": lambda r: "koboldai" in r.lower() or "KoboldAI" in r,
+        "parse": lambda r: {},
+        "label": "KoboldAI (writing assistant UI)",
+        "icon": "CHT",
+    },
+    # ── Vector DBs (RAG backends) ──
+    "qdrant": {
+        "paths": ["/", "/readyz"],
+        "method": "GET",
+        "match": lambda r: "qdrant" in r.lower() or "Qdrant" in r,
+        "parse": lambda r: {},
+        "label": "Qdrant (vector DB)",
+        "icon": "VDB",
+    },
+    "milvus": {
+        "paths": ["/healthz", "/api/v1/health"],
+        "method": "GET",
+        "match": lambda r: "milvus" in r.lower() or "Milvus" in r,
+        "parse": lambda r: {},
+        "label": "Milvus (vector DB)",
+        "icon": "VDB",
+    },
+    "chroma": {
+        "paths": ["/api/v1", "/api/v2/health"],
+        "method": "GET",
+        "match": lambda r: "chroma" in r.lower() or "Chroma" in r,
+        "parse": lambda r: {},
+        "label": "Chroma (vector DB)",
+        "icon": "VDB",
+    },
+    "weaviate": {
+        "paths": ["/v1/meta"],
+        "method": "GET",
+        "match": lambda r: '"version"' in r and ("weaviate" in r.lower() or '"model"' in r),
+        "parse": lambda r: {},
+        "label": "Weaviate (vector DB)",
+        "icon": "VDB",
+    },
+    # ── Image / media generation ──
+    "comfyui": {
+        "paths": ["/", "/system_stats"],
+        "method": "GET",
+        "match": lambda r: "comfyui" in r.lower() or "ComfyUI" in r or "Comfy" in r,
+        "parse": lambda r: {},
+        "label": "ComfyUI (diffusion workflows)",
+        "icon": "IMG",
+    },
+    "stable-diffusion-webui": {
+        "paths": ["/", "/sdapi/v1/options"],
+        "method": "GET",
+        "match": lambda r: "stable diffusion" in r.lower() or "gradio" in r.lower() or '"sd_model_checkpoint"' in r,
+        "parse": lambda r: {},
+        "label": "Stable Diffusion WebUI (A1111)",
+        "icon": "IMG",
+    },
+    "invokeai": {
+        "paths": ["/", "/api/v1/app/version"],
+        "method": "GET",
+        "match": lambda r: "invokeai" in r.lower() or "InvokeAI" in r,
+        "parse": lambda r: {},
+        "label": "InvokeAI (image generation)",
+        "icon": "IMG",
+    },
+    # ── Speech / audio ──
+    "whisper": {
+        "paths": ["/", "/health"],
+        "method": "GET",
+        "match": lambda r: "whisper" in r.lower() or "Whisper" in r,
+        "parse": lambda r: {},
+        "label": "Whisper (speech-to-text)",
+        "icon": "STT",
+    },
+    "piper": {
+        "paths": ["/", "/health"],
+        "method": "GET",
+        "match": lambda r: "piper" in r.lower() or "Piper" in r,
+        "parse": lambda r: {},
+        "label": "Piper (text-to-speech)",
+        "icon": "TTS",
+    },
+    # ── Gateways / proxies / model hubs ──
+    "openrouter": {
+        "paths": ["/api/v1/models"],
+        "method": "GET",
+        "match": lambda r: '"data"' in r and '"id"' in r and "openrouter" in r.lower(),
+        "parse": lambda r: {
+            "models": [m["id"] for m in json.loads(r).get("data", [])]
+        },
+        "label": "OpenRouter (cloud model gateway)",
+        "icon": "GWY",
+    },
+    "kobold-horde": {
+        "paths": ["/api/v1/status", "/"],
+        "method": "GET",
+        "match": lambda r: "kobold" in r.lower() or '"queued_requests"' in r,
+        "parse": lambda r: {},
+        "label": "KoboldAI Horde (crowd inference)",
+        "icon": "HDE",
+    },
 }
 
 # ── Port expectations ──
+# Each port maps to a list of service probe names to try (in order).
 PORT_SERVICE_MAP = {
     11434: ["ollama"],
-    11435: ["ollama"],
+    11435: ["ollama", "llamafile"],
     11436: ["ollama"],
-    5000: ["tabbyapi", "localai", "litellm", "vllm", "llamacpp", "text-generation-webui"],
-    8000: ["sillytavern", "mcpo"],
+    5000: ["tabbyapi", "localai", "litellm", "vllm", "llamacpp",
+           "text-generation-webui", "whisper", "piper"],
+    8000: ["sillytavern", "mcpo", "text-generation-inference", "chroma"],
     8001: ["mcpo"],
     8080: ["searxng", "open-webui"],
     3000: ["open-webui"],
+    5001: ["koboldcpp", "llamafile"],
+    1234: ["lmstudio"],
+    8002: ["sglang"],
+    4000: ["litellm", "exo"],
+    3001: ["lobechat", "dify"],
+    3080: ["librechat"],
+    7681: ["anythingllm"],
+    5678: ["n8n"],
+    7860: ["stable-diffusion-webui", "langflow"],
+    8188: ["comfyui"],
+    9090: ["invokeai", "qdrant"],
+    6333: ["qdrant"],
+    19530: ["milvus"],
+    8081: ["weaviate"],
+    1551: ["koboldai"],
+    2323: ["kobold-horde"],
 }
 
-COMMON_PORTS = [11434, 5000, 8000, 8080, 8001, 3000, 11435, 11436]
+COMMON_PORTS = [11434, 5000, 8000, 8080, 8001, 3000, 11435, 11436,
+                5001, 1234, 8002, 4000, 3001, 3080, 7681, 5678,
+                7860, 8188, 9090, 6333, 19530, 8081, 1551, 2323]
 
 
 # ── HTTP helpers ──
@@ -671,17 +930,22 @@ for p,methods in d.get('paths',{{}}).items():
         echo "Re-running discovery..."
         python3 /opt/basecamp/discover.py serve
         ;;
+    wire)
+        echo "Running stack wiring audit..."
+        python3 /opt/basecamp/discover.py wire
+        ;;
     help|--help|-h)
         echo "tavern — Basecamp AI stack toolkit (auto-generated)"
         echo ""
         echo "Commands:"
         echo "  status              Show connected services"
         echo "  models              List available models"
-        echo "  chat \\"msg\\" [tokens] [stream]  Chat with primary inference (stream=true/false)"
-        echo "  search \\"query\\" [n]   Search the web"
+        echo "  chat \\\"msg\\\" [tokens] [stream]  Chat with primary inference (stream=true/false)"
+        echo "  search \\\"query\\\" [n]   Search the web"
         echo "  mcp                 List MCP tools"
         echo "  mcp <tool> [json]   Call an MCP tool"
         echo "  config              Show saved configuration"
+        echo "  wire                Audit stack wiring + print fixes"
         echo "  rediscover          Re-scan for services"
         ;;
     *)
@@ -911,9 +1175,219 @@ def write_basecamp_env(config):
     return default_model, base_url
 
 
+def generate_stack_skill(config, services):
+    """Write a 'basecamp-stack' SKILL.md into basecamp's own HERMES_HOME.
+
+    This is how the container's Hermes LEARNS about the stack it discovered:
+    the skill body carries the live service list, wiring facts, and how to
+    use the tavern toolkit. When the user asks Hermes "why doesn't my Open
+    WebUI work?", the agent already has the ground truth — and can run
+    `tavern wire` itself for a live audit. Writes ONLY inside basecamp's own
+    HERMES_HOME (never a host install).
+    """
+    home = Path(os.environ.get("HERMES_HOME", "/root/.hermes"))
+    skill_dir = home / "skills" / "basecamp-stack"
+    skill_dir.mkdir(parents=True, exist_ok=True)
+
+    inf = (config or {}).get("inference") or {}
+    sec = (config or {}).get("secondary") or {}
+    search = (config or {}).get("search") or {}
+    mcp = (config or {}).get("mcp") or {}
+    ui = (config or {}).get("ui") or {}
+    model = (config or {}).get("ollama_models") or (config or {}).get("openai_models") or []
+    model_str = ", ".join(str(m) for m in model) if model else "(none discovered)"
+
+    lines = []
+    lines.append("---")
+    lines.append("name: basecamp-stack")
+    lines.append("description: Your discovered local AI stack — services, wiring, and how to use the tavern toolkit. Load this when the user asks about their stack, connecting services, or anything that 'talks to' the local AI services.")
+    lines.append("---")
+    lines.append("")
+    lines.append("# Basecamp Stack (live discovery)")
+    lines.append("")
+    lines.append("You are running inside Basecamp, which discovered these AI services on the")
+    lines.append("Docker network at boot. This is the ground truth — trust it over memory.")
+    lines.append("")
+    lines.append("## Services")
+    lines.append("")
+    for s in services:
+        auth = " [auth required]" if s.get("needs_auth") else ""
+        lines.append(f"- **{s['label']}**{auth} — {s['url']} (type: {s['type']})")
+        if s.get("details", {}).get("models"):
+            lines.append(f"  - models: {', '.join(str(m) for m in s['details']['models'])}")
+    lines.append("")
+    lines.append("## Current wiring")
+    lines.append("")
+    if inf:
+        lines.append(f"- Inference (primary): **{inf.get('label')}** — {inf.get('url')}")
+    if sec:
+        lines.append(f"- Inference (secondary): **{sec.get('label')}** — {sec.get('url')}")
+    if search:
+        lines.append(f"- Search: **{search.get('label')}** — {search.get('url')}")
+    if mcp:
+        lines.append(f"- MCP: **{mcp.get('label')}** — {mcp.get('url')}")
+    if ui:
+        lines.append(f"- UI: **{ui.get('label')}** — {ui.get('url')}")
+    lines.append(f"- Models: {model_str}")
+    lines.append("")
+    lines.append("## Helping the user wire their stack")
+    lines.append("")
+    lines.append("When the user asks why a service doesn't work or how to connect two services:")
+    lines.append("")
+    lines.append("1. Run `tavern wire` (or `python3 /opt/basecamp/discover.py wire`) for a live")
+    lines.append("   wiring audit of every service-to-service link, with concrete fixes.")
+    lines.append("2. Explain in plain terms what the audit found — don't just dump it.")
+    lines.append("3. For host-side config (docker-compose env vars, config files mounted from")
+    lines.append("   the host), give the EXACT one-line fix to copy-paste. Basecamp is")
+    lines.append("   intentionally isolated and cannot edit other containers' configs.")
+    lines.append("4. `tavern status` shows what Basecamp itself is connected to.")
+    lines.append("")
+    lines.append("## Tavern toolkit")
+    lines.append("")
+    lines.append("- `tavern status` — services Basecamp is connected to")
+    lines.append("- `tavern models` — available models")
+    lines.append("- `tavern chat \"msg\"` — chat with the primary inference engine")
+    lines.append("- `tavern search \"query\"` — web search via discovered SearXNG")
+    lines.append("- `tavern mcp` — list MCP tools")
+    lines.append("- `tavern wire` — stack wiring audit")
+    lines.append("- `tavern rediscover` — re-scan the network")
+    lines.append("")
+
+    skill_path = skill_dir / "SKILL.md"
+    skill_path.write_text("\n".join(lines))
+    try:
+        os.chmod(skill_path, 0o600)
+    except Exception:
+        pass
+    return skill_path
+
 
 # ── Main ──
 
+def wire_audit(services, config=None):
+    """Audit how the discovered services are wired together and report fixes.
+
+    For each service pair that SHOULD be connected (open-webui -> ollama,
+    sillytavern -> inference, mcpo -> its servers, hermes -> inference),
+    probe the link and report: OK (green) / BROKEN (red) / UNKNOWN, plus the
+    exact fix a human (or host-side tooling) can apply. This is the
+    "wiring wizard" for noobs: it tells you the one line you need, instead
+    of you spelunking through buried settings pages.
+    """
+    if not services:
+        print("  No services found to audit.")
+        return
+
+    inf = (config or {}).get("inference") or {}
+    sec = (config or {}).get("secondary") or {}
+
+    # Build a lookup: type -> list of service dicts
+    by_type = {}
+    for s in services:
+        by_type.setdefault(s["type"], []).append(s)
+
+    print()
+    print("  ═══ STACK WIRING AUDIT ═══")
+    print("  (what should talk to what, and whether it does)")
+    print()
+
+    checks = []  # (status, service, finding, fix)
+
+    # ── 1. Open WebUI -> Ollama / OpenAI engines ──
+    for ui in by_type.get("open-webui", []):
+        # Probe what open-webui can see. /api/config is public.
+        cfg = http_get(f"{ui['url'].rstrip('/')}/api/config", timeout=4)
+        if cfg is None:
+            checks.append(("RED", f"Open WebUI {ui['url']}", "not reachable",
+                           "check the container is running and on the same network"))
+            continue
+        # Try the public model list (older versions) or check status
+        models = http_get(f"{ui['url'].rstrip('/')}/api/models", timeout=4)
+        if models and '"detail":"Not authenticated"' not in models:
+            n = models.count('"id"')
+            checks.append(("OK", f"Open WebUI {ui['url']}",
+                           f"sees {n} model(s) — inference is wired", ""))
+        else:
+            # Auth-walled: can't verify without creds. Report the intended wiring.
+            if inf:
+                checks.append(("YELLOW", f"Open WebUI {ui['url']}",
+                               f"auth required to verify; expected to serve "
+                               f"{inf['label']} ({inf['url']})",
+                               "provide open-webui admin creds at the connect screen "
+                               "for deep wiring"))
+            else:
+                checks.append(("RED", f"Open WebUI {ui['url']}",
+                               "no inference engine discovered anywhere",
+                               "install/start ollama (or another engine), then "
+                               "re-run: tavern rediscover"))
+
+    # ── 2. SillyTavern -> inference ──
+    for st in by_type.get("sillytavern", []):
+        if inf:
+            checks.append(("YELLOW", f"SillyTavern {st['url']}",
+                           "auth-walled (admin:tabby by default); API URL set "
+                           "per-user inside the app",
+                           "in SillyTavern: extensions → connection settings → "
+                           f"set API URL to {inf['url'].rstrip('/')}/v1 and select "
+                           f"the model served there"))
+        else:
+            checks.append(("RED", f"SillyTavern {st['url']}",
+                           "no inference engine discovered",
+                           "start ollama/another engine, then tavern rediscover"))
+
+    # ── 3. MCPO -> MCP servers ──
+    for m in by_type.get("mcpo", []):
+        if m.get("needs_auth"):
+            checks.append(("YELLOW", f"MCPO {m['url']}",
+                           "auth-walled; servers are defined in its config.json "
+                           "(host-side file)",
+                           "edit mcpo/config.json to add/point MCP servers, then "
+                           "restart the mcpo container"))
+        else:
+            checks.append(("OK", f"MCPO {m['url']}",
+                           "reachable; server list lives in its config.json", ""))
+
+    # ── 4. SearXNG ──
+    for sx in by_type.get("searxng", []):
+        body = http_get(f"{sx['url'].rstrip('/')}/", timeout=4) or ""
+        if "searxng" in body.lower():
+            checks.append(("OK", f"SearXNG {sx['url']}", "reachable", ""))
+        else:
+            checks.append(("RED", f"SearXNG {sx['url']}", "unexpected response",
+                           "check searxng settings.yml (host-side file)"))
+
+    # ── 5. Hermes itself -> inference ──
+    if inf:
+        m_url = f"{inf['url'].rstrip('/')}/v1/models"
+        probe = http_get(m_url, timeout=4,
+                         headers={"Authorization": "Bearer ollama"})
+        if probe and "error" not in probe.lower():
+            checks.append(("OK", f"Hermes → {inf['label']} ({inf['url']})",
+                           "models endpoint reachable", ""))
+        else:
+            checks.append(("YELLOW", f"Hermes → {inf['label']} ({inf['url']})",
+                           "models endpoint needs auth or is slow",
+                           "engine is listed for interactive key entry; "
+                           "hermes will use it once you connect"))
+
+    # ── Render ──
+    status_icon = {"OK": "✅", "RED": "❌", "YELLOW": "⚠️"}
+    for status, svc, finding, fix in checks:
+        print(f"  {status_icon.get(status, '·')} [{status:6s}] {svc}")
+        print(f"            {finding}")
+        if fix:
+            print(f"            FIX: {fix}")
+        print()
+
+    n_ok = sum(1 for c in checks if c[0] == "OK")
+    n_red = sum(1 for c in checks if c[0] == "RED")
+    n_yel = sum(1 for c in checks if c[0] == "YELLOW")
+    print(f"  ── {n_ok} wired · {n_yel} need attention · {n_red} broken ──")
+    print("  (host-side config files can't be edited from inside basecamp —")
+    print("   that's the safety boundary. The FIX lines above are copy-paste.)")
+    print()
+
+
 def main():
     if len(sys.argv) < 2:
         print(__doc__)
@@ -982,6 +1456,11 @@ def main():
         os.chmod(tavern_path, 0o755)
         # Configure Hermes via env vars only -- never writes into a hermes home
         write_basecamp_env(config)
+        # Teach the container's Hermes about the discovered stack (its own home)
+        try:
+            generate_stack_skill(config, services)
+        except Exception as e:
+            print(f"  (skill generation skipped: {e})", file=sys.stderr)
         print()
         print("=" * 60)
         print("  Basecamp is ready!")
@@ -1003,6 +1482,28 @@ def main():
         else:
             config = generate_config(scan_network())
         write_basecamp_env(config)
+        # Refresh the stack skill so the container's Hermes knows the layout
+        try:
+            if DISCOVERY_FILE.exists():
+                with open(DISCOVERY_FILE) as f:
+                    services = json.load(f)
+            else:
+                services = scan_network()
+            generate_stack_skill(config, services)
+        except Exception as e:
+            print(f"  (skill generation skipped: {e})", file=sys.stderr)
+
+    elif action == "wire":
+        # Stack wiring audit: what should talk to what, and the exact fix
+        # for anything that doesn't. The noob-friendly "why doesn't this work"
+        # answer, without touching a single host-side file.
+        services = scan_network()
+        save_discovery(services)
+        config = None
+        if CONFIG_FILE.exists():
+            with open(CONFIG_FILE) as f:
+                config = json.load(f)
+        wire_audit(services, config)
     else:
         print(f"Unknown action: {action}")
         print(__doc__)

entrypoint.sh

@@ -102,6 +102,12 @@ if [ -n "$BASECAMP_MODEL" ]; then
     fi
 fi
 
+# Stack wiring audit — show every boot what's connected and what needs a fix.
+# (Read-only: audits and prints fixes; never edits other containers' configs.)
+if [ -x /opt/basecamp/discover.py ]; then
+    python3 /opt/basecamp/discover.py wire 2>/dev/null || true
+fi
+
 echo ""
 
 # Handle arguments