@@ -97,6 +97,8 @@ Every source is optional. Each poll degrades to "no data".
 | Strata `:8080` (`/v1/models`, `/metrics`, `/slots`) | second engine plus context slots |
 | any engine in `speculum.toml` | the same fields through the pluggable adapters |
 
+Ports in this table are the defaults; each can be moved. See [Custom ports](#custom-ports).
+
 ## Configuration
 
 Config is optional. With no file, Speculum probes the default ports on localhost and shows what it finds. Copy `speculum.example.toml` to `speculum.toml` in the repo root or in `~/.config/speculum/` to change anything.
@@ -119,6 +121,41 @@ The file sets the bind address and port, discovery targets, history retention, a
 
 Adapters: `ollama`, `llamacpp`, `vllm`, `sglang`, `freetoken`, `koboldcpp`, `tabbyapi`, `localai`, `lmstudio`, `unsloth`, `openai`, `custom`. [`docs/ENGINE-COVERAGE.md`](docs/ENGINE-COVERAGE.md) explains how each adapter recognises a server and which engines stay unsupported.
 
+### Custom ports
+
+An engine does not have to sit on its stock port. There are three ways to point Speculum at another one; pick whichever fits.
+
+**1. Give an engine a `port` (or `host`).** When you configure an engine, `port` and `host` stand in for a full `url`. This is the quickest way to move llama.cpp off 8080:
+
+```toml
+[[engine]]
+name = "llama.cpp"
+type = "llamacpp"
+port = 8081                 # host defaults to 127.0.0.1
+```
+
+`host = "10.0.0.41"` watches another box, and `port` alone leaves the default host. A `url` still works and can be combined with `port` to override just the port.
+
+**2. Add extra discovery ports.** Discovery normally probes the ports in the table under [What it watches](#what-it-watches). `[discovery] ports` adds ports to that sweep on localhost and every `targets` host, so an engine on a non-default port is found and registered like any other:
+
+```toml
+[discovery]
+enabled = true
+ports   = [8081, 9091]      # probed with every adapter, generic openai last
+```
+
+**3. Move the built-in threads.** `llama-swap`, `Strata` and the NInfer backend that follows llama-swap are watched by dedicated threads, not by discovery. Point them elsewhere with `[llama_swap]` and `[strata]`, using `url`, or `host` / `port`:
+
+```toml
+[llama_swap]
+port = 9091                 # default http://127.0.0.1:9090
+
+[strata]
+url = "http://127.0.0.1:8090"   # default http://127.0.0.1:8080
+```
+
+NInfer has no port of its own: it rides the proxy llama-swap reports in `/running`, so fixing `[llama_swap]` is enough. Ports configured here are skipped by discovery, so they are never mistaken for a separate engine.
+
 ## Demo mode
 
 `?demo` runs a seeded simulation with no backend. Serve the repo root any way you like and open `http://localhost:8792/?demo`:
 
@@ -18,7 +18,13 @@
 
 DEFAULTS = {
     "server": {"host": "127.0.0.1", "port": 8792},
-    "discovery": {"enabled": True},
+    # `ports` adds non-default localhost/target ports to the discovery probe
+    # list, for an engine running somewhere other than its stock port.
+    "discovery": {"enabled": True, "ports": []},
+    # Built-in threads (not the adapter scheduler). Override `url`, or give a
+    # `host` / `port`, when llama-swap or Strata runs on a non-default port.
+    "llama_swap": {"url": "http://127.0.0.1:9090"},
+    "strata": {"url": "http://127.0.0.1:8080"},
     "history": {"retention_days": 30},   # 30, 60, 90 or 0 to turn off
     # Threshold alerts, each held for hold_s before it fires. vram_pct is high on
     # purpose: engines fill the card by design; the useful VRAM alert is a foreign process holding it.
@@ -53,7 +59,8 @@ def _clean_engine(e):
     or unknown tables (a [[engine]] with no type is an error, not a
     discovery candidate)."""
     out = {}
-    for k in ("name", "type", "url", "parent", "api_key_env", "optional",
+    for k in ("name", "type", "url", "host", "port", "parent",
+              "api_key_env", "optional",
               "health", "models", "metrics", "slots", "map"):
         if k in e:
             out[k] = e[k]
@@ -76,6 +83,8 @@ def load(path=None):
     cfg = {
         "server": dict(DEFAULTS["server"]),
         "discovery": dict(DEFAULTS["discovery"]),
+        "llama_swap": dict(DEFAULTS["llama_swap"]),
+        "strata": dict(DEFAULTS["strata"]),
         "history": dict(DEFAULTS["history"]),
         "alerts": dict(DEFAULTS["alerts"]),
         "engine": [],
@@ -86,6 +95,8 @@ def load(path=None):
     raw = tomllib.loads(used.read_text(encoding="utf-8"))
     _merge(cfg["server"], raw.get("server"))
     _merge(cfg["discovery"], raw.get("discovery"))
+    _merge(cfg["llama_swap"], raw.get("llama_swap"))
+    _merge(cfg["strata"], raw.get("strata"))
     _merge(cfg["history"], raw.get("history"))
     _merge(cfg["alerts"], raw.get("alerts"))
     for e in raw.get("engine") or []:
 
@@ -51,20 +51,45 @@
 ]
 
 
-def discovery_targets(extra_hosts=()):
+def discovery_targets(extra_hosts=(), extra_ports=()):
     """(host, port, adapter types) triples to probe: localhost on every port,
     then each extra host on the same port list. Localhost comes first so a
-    local engine always wins its own port over a remote one."""
+    local engine always wins its own port over a remote one.
+
+    `extra_ports` are non-default ports ([discovery] ports in speculum.toml).
+    A port the table already knows keeps its ordered types; a new one is
+    probed with every specific adapter, generic `openai` last."""
+    ports = list(DISCOVERY)
+    known = {p for p, _types in DISCOVERY}
+    for p in extra_ports or ():
+        try:
+            p = int(p)
+        except (TypeError, ValueError):
+            continue
+        if p and p not in known:
+            known.add(p)
+            ports.append((p, _all_discovery_types()))
     hosts = []
     for h in extra_hosts or ():
         h = str(h).strip()
         if h and h not in hosts and h not in LOCAL_HOSTS:
             hosts.append(h)
-    out = [(LOCAL_HOST, port, types) for port, types in DISCOVERY]
-    out.extend((h, port, types) for h in hosts for port, types in DISCOVERY)
+    out = [(LOCAL_HOST, port, types) for port, types in ports]
+    out.extend((h, port, types) for h in hosts for port, types in ports)
     return out
 
 
+def _all_discovery_types():
+    """Every discoverable adapter, each once, generic `openai` last. Used for
+    ports [discovery] ports adds that the built-in table does not know."""
+    out = []
+    for _port, types in DISCOVERY:
+        for t in types:
+            if t not in out:
+                out.append(t)
+    return tuple([t for t in out if t != "openai"] + ["openai"])
+
+
 def parse_prom(text):
     """Tiny Prometheus text parser: sum the samples of each metric name,
     ignore labels. NaN / non-numeric values are skipped."""
@@ -984,16 +1009,42 @@ def poll(self):
                "unsloth": "Unsloth", "openai": "OpenAI"}
 
 
+def engine_url(eng, cls=None, override_port=None):
+    """Endpoint for an [[engine]] table: an explicit `url`, or the `host` /
+    `port` shorthand (host defaults to 127.0.0.1, port to the adapter's own
+    default). `override_port` re-points a URL at another port without dropping
+    its host or path (discovery)."""
+    url = eng.get("url") or ""
+    host = eng.get("host") or None
+    port = eng.get("port")
+    default_port = getattr(cls, "default_port", None) if cls else None
+
+    def netloc(u, h, p):
+        parts = urllib.request.urlparse(u)
+        return "%s:%s" % (h or parts.hostname or "127.0.0.1", p)
+
+    if override_port is not None:
+        port = override_port
+    if port is not None:
+        url = (urllib.request.urlparse(url)._replace(
+                   netloc=netloc(url, host, port)).geturl()
+               if url else "http://%s:%s" % (host or "127.0.0.1", port))
+    elif host:
+        if url:
+            p = urllib.request.urlparse(url)
+            url = p._replace(
+                netloc=netloc(url, host, p.port or default_port)).geturl()
+        elif default_port:
+            url = "http://%s:%s" % (host, default_port)
+    return url
+
+
 def make_adapter(eng, port=None):
     """Build an adapter from a config [[engine]] table (a plain dict of
     type/url/...); `port` overrides the table's url port (discovery)."""
     etype = eng.get("type") or "custom"
     cls = ADAPTERS.get(etype, CustomAdapter)
-    url = eng.get("url") or ""
-    if port is not None and url:
-        p = urllib.request.urlparse(url)
-        url = p._replace(netloc=(p.hostname or "127.0.0.1") + ":" + str(port)
-                         ).geturl()
+    url = engine_url(eng, cls, override_port=port)
     a = cls(url=url or None, key=eng.get("name"), label=eng.get("name"),
             parent=eng.get("parent"), api_key_env=eng.get("api_key_env"))
     a.optional = bool(eng.get("optional"))   # down is normal: no alert (speculum.toml)
@@ -1022,10 +1073,11 @@ class Scheduler:
 
     def __init__(self, adapters, discovery_enabled=True, claimed_ports=None,
                  on_result=None, on_event=None, on_discover=None,
-                 discovery_hosts=None):
+                 discovery_hosts=None, discovery_ports=None):
         self.discovery_enabled = discovery_enabled
         self.claimed_ports = claimed_ports
         self.discovery_hosts = list(discovery_hosts or ())
+        self.discovery_ports = list(discovery_ports or ())
         self.on_result = on_result
         self.on_event = on_event
         self.on_discover = on_discover
@@ -1072,7 +1124,8 @@ def _claimed(self):
     def discovery(self):
         claimed = self._claimed()
         found = []
-        for host, port, types in discovery_targets(self.discovery_hosts):
+        for host, port, types in discovery_targets(self.discovery_hosts,
+                                                    self.discovery_ports):
             if (host, port) in claimed:
                 continue
             base = "http://%s:%d" % (host, port)
 
@@ -702,7 +702,7 @@ def logs_thread():
         e = S.engine("ninfer", model, "ninfer", 262144)
         try:
             # /logs/stream/<model> is a plain text tail, not SSE frames
-            req = urllib.request.Request("http://127.0.0.1:9090/logs/stream/%s" % model,
+            req = urllib.request.Request(LLAMA_SWAP + "/logs/stream/%s" % model,
                                          headers={"Accept": "text/plain"})
             r = urllib.request.urlopen(req, timeout=PROBE_SLOW)
             while True:
@@ -1408,13 +1408,35 @@ def _port_of(u):
     return None
 
 
+def endpoint_url(tbl, default):
+    """The base URL for a built-in thread from its config table: `url`, or the
+    `host` / `port` shorthand on top of the default (e.g. llama-swap moved off
+    :9090). Always returned without a trailing slash."""
+    tbl = tbl or {}
+    url = tbl.get("url") or default
+    host, port = tbl.get("host"), tbl.get("port")
+    if port is not None or host:
+        p = urllib.request.urlparse(url)
+        url = p._replace(netloc="%s:%s" % (
+            host or p.hostname or "127.0.0.1", port if port is not None else p.port
+        )).geturl()
+    return url.rstrip("/")
+
+
 def claimed_ports():
-    """Ports the discovery probes must skip: llama-swap, Strata when up,
-    and the backend of any running entry (e.g. the NInfer proxy port)."""
-    ports = {9090}
+    """Ports the discovery probes must skip: llama-swap's port, Strata's while
+    it is up, and the backend of any running entry (e.g. the NInfer proxy
+    port). Llama-swap is always skipped so its port is never mistaken for an
+    engine; Strata's port is released for discovery when Strata is down."""
+    ports = set()
+    p = _port_of(LLAMA_SWAP)
+    if p:
+        ports.add(p)
     with lock:
         if S.strata.get("up"):
-            ports.add(8080)
+            p = _port_of(STRATA)
+            if p:
+                ports.add(p)
         for r in S.running or []:
             p = _port_of(r.get("proxy") or "")
             if p:
@@ -1471,8 +1493,10 @@ def start_scheduler(cfg):
         adapters,
         discovery_enabled=bool(disc.get("enabled", True)),
         # localhost is always probed; `targets` adds remote hosts on the same
-        # port list, for a collector running away from the inference box.
+        # port list, for a collector running away from the inference box, and
+        # `ports` adds non-default ports for engines off their stock port.
         discovery_hosts=disc.get("targets") or (),
+        discovery_ports=disc.get("ports") or (),
         claimed_ports=claimed_ports,
         on_result=on_engine_result,
         on_event=lambda lv, m: push_event(lv, m),
@@ -1484,7 +1508,7 @@ def start_scheduler(cfg):
 
 
 def main():
-    global PORT, HIST
+    global PORT, HIST, LLAMA_SWAP, STRATA
     if sys.stdout is None:       # pythonw / no console: a print would crash
         sys.stdout = sys.stderr = open(os.devnull, "w")
     ap = argparse.ArgumentParser()
@@ -1504,6 +1528,10 @@ def main():
     elif cfg.get("server", {}).get("port"):
         PORT = int(cfg["server"]["port"])
     host = cfg.get("server", {}).get("host") or HOST
+    # Built-in threads can be moved off their stock ports too. NInfer follows
+    # llama-swap's /running proxy, so it needs no separate port.
+    LLAMA_SWAP = endpoint_url(cfg.get("llama_swap"), "http://127.0.0.1:9090")
+    STRATA = endpoint_url(cfg.get("strata"), "http://127.0.0.1:8080")
 
     # SQLite history. retention_days 0 -> no-op object.
     retention = int((cfg.get("history") or {}).get("retention_days", 30) or 0)
 
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Config tests: per-engine host/port keys survive cleaning, the built-in
+endpoint tables have defaults, and a TOML file overrides them."""
+
+import importlib.util
+import tempfile
+import unittest
+from pathlib import Path
+
+import config
+
+
+class TestCleanEngine(unittest.TestCase):
+    def test_host_and_port_kept(self):
+        e = config._clean_engine(
+            {"type": "llamacpp", "host": "10.0.0.9", "port": 8081,
+             "url": "http://127.0.0.1:8080", "unknown": "drop me"})
+        self.assertEqual(e, {"type": "llamacpp", "host": "10.0.0.9",
+                             "port": 8081, "url": "http://127.0.0.1:8080"})
+
+    def test_defaults_carry_endpoint_tables(self):
+        self.assertEqual(config.DEFAULTS["llama_swap"]["url"],
+                         "http://127.0.0.1:9090")
+        self.assertEqual(config.DEFAULTS["strata"]["url"],
+                         "http://127.0.0.1:8080")
+        self.assertEqual(config.DEFAULTS["discovery"]["ports"], [])
+
+
+@unittest.skipUnless(importlib.util.find_spec("tomllib"),
+                     "tomllib needs Python 3.11+")
+class TestLoadToml(unittest.TestCase):
+    def _load(self, text):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "speculum.toml"
+            p.write_text(text, encoding="utf-8")
+            return config.load(str(p))[0]
+
+    def test_engine_port_survives(self):
+        cfg = self._load(
+            '[[engine]]\nname = "llama"\ntype = "llamacpp"\nport = 8081\n')
+        self.assertEqual(cfg["engine"][0]["port"], 8081)
+
+    def test_discovery_ports_and_builtin_urls(self):
+        cfg = self._load(
+            '[discovery]\nports = [8081, 9091]\n'
+            '[llama_swap]\nport = 9091\n'
+            '[strata]\nurl = "http://127.0.0.1:8090"\n')
+        self.assertEqual(cfg["discovery"]["ports"], [8081, 9091])
+        self.assertEqual(cfg["llama_swap"]["port"], 9091)
+        self.assertEqual(cfg["strata"]["url"], "http://127.0.0.1:8090")
+
+
+if __name__ == "__main__":
+    unittest.main(verbosity=2)