rhylthyme-cli-runner 0.3.0a0__tar.gz → 0.4.0a0__tar.gz

{rhylthyme_cli_runner-0.3.0a0/src/rhylthyme_cli_runner.egg-info → rhylthyme_cli_runner-0.4.0a0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rhylthyme-cli-runner
-Version: 0.3.0a0
+Version: 0.4.0a0
 Summary: CLI runner for Rhylthyme real-time program schedules
 Home-page: https://github.com/rhylthyme/rhylthyme-cli-runner
 Author: Rhylthyme Team
@@ -26,9 +26,11 @@ Requires-Dist: click>=8.0.0
 Requires-Dist: jsonschema>=4.0.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: colorama>=0.4.0
-Requires-Dist: rhylthyme-spec>=0.2.1a0
+Requires-Dist: rhylthyme-spec>=0.2.2a0
 Provides-Extra: galago
 Requires-Dist: rhylthyme-galago>=0.2.0a0; extra == "galago"
+Provides-Extra: labmcp
+Requires-Dist: rhylthyme-labmcp>=0.1.0a0; extra == "labmcp"
 Provides-Extra: dev
 Requires-Dist: pytest>=6.0.0; extra == "dev"
 Requires-Dist: pytest-cov>=2.10.0; extra == "dev"

{rhylthyme_cli_runner-0.3.0a0 → rhylthyme_cli_runner-0.4.0a0}/setup.py

@@ -19,7 +19,7 @@ def read_readme():
 
 setup(
     name="rhylthyme-cli-runner",
-    version="0.3.0a0",
+    version="0.4.0a0",
     description="CLI runner for Rhylthyme real-time program schedules",
     long_description=read_readme(),
     long_description_content_type="text/markdown",
@@ -38,11 +38,13 @@ setup(
         "jsonschema>=4.0.0",
         "pyyaml>=6.0",
         "colorama>=0.4.0",
-        "rhylthyme-spec>=0.2.1a0",
+        "rhylthyme-spec>=0.2.2a0",
     ],
     extras_require={
         # Instrument steps on galago-tools lab instruments (--workcell, rhylthyme bridge)
         "galago": ["rhylthyme-galago>=0.2.0a0"],
+        # Instrument steps on LabMCP instrument servers (driver "labmcp" in a workcell)
+        "labmcp": ["rhylthyme-labmcp>=0.1.0a0"],
         "dev": [
             # Testing framework
             "pytest>=6.0.0",

{rhylthyme_cli_runner-0.3.0a0 → rhylthyme_cli_runner-0.4.0a0}/src/rhylthyme_cli_runner/__init__.py

@@ -6,7 +6,7 @@ This package provides the command-line interface for running and validating
 Rhylthyme real-time program schedules.
 """
 
-__version__ = "0.3.0a0"
+__version__ = "0.4.0a0"
 __author__ = "Rhylthyme Team"
 __description__ = "CLI runner for Rhylthyme real-time program schedules"
 

rhylthyme_cli_runner-0.4.0a0/src/rhylthyme_cli_runner/bridge.py

@@ -0,0 +1,427 @@
+"""Publish a live instrument run to rhylthyme.com and take commands from it.
+
+``rhylthyme bridge --workcell lab.json PROGRAM`` runs a program exactly like
+``rhylthyme run`` and, while it runs, keeps two rows up to date in the user's
+own Supabase tables (owner-only RLS; see rhylthyme-server/sql/galago_bridges.sql
+and docs/design/web-bridge.md):
+
+- ``bridges``: this lab machine, its tools (name, type, status) and a
+  heartbeat;
+- ``bridge_state``: the run's steps, their status, the tool each waits on and
+  any failure.
+
+With a ``submit`` callback it also reads the user's ``bridge_commands`` rows
+(pause, resume, retry, skip, abort), refuses stale, foreign or unknown ones,
+lets the runner decide the rest, and writes each outcome back to its row.
+
+Only outbound HTTPS, with the user's session. Nothing about where a tool
+listens ever leaves the machine: rows are built from an allowlist of fields,
+and error text is scrubbed of every private value each tool's driver names
+(galago hosts and ports; LabMCP serial, TCP and VISA addresses, server URLs
+and options).
+
+Moved here from rhylthyme_galago.bridge so that every instrument driver can
+use it; that module stays for compatibility.
+"""
+
+import base64
+import json
+import re
+import threading
+import time
+import urllib.error
+import urllib.request
+import uuid
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Mapping, Optional
+
+from .drivers import blocking_action
+
+TokenFn = Callable[[], str]
+
+HEARTBEAT_SECONDS = 10.0
+STATE_SECONDS = 1.0
+
+#: Commands the browser may send (design note: "The command set"): steering a
+#: run in progress, and starting one on an idle bridge.
+STEER_KINDS = ("pause", "resume", "retry", "skip", "abort")
+START_KINDS = ("start_run",)
+
+#: A command older than this when the bridge sees it is refused, so a
+#: reconnecting bridge never replays a stale retry or abort.
+COMMAND_MAX_AGE_SECONDS = 30.0
+
+#: Called with {"id", "kind", "args"}; returns {"accepted", "reason"} once the
+#: runner has decided, or None if it did not answer in time.
+Submit = Callable[[Dict[str, Any]], Optional[Dict[str, Any]]]
+
+
+class BridgeError(RuntimeError):
+    """The bridge could not reach or write to rhylthyme.com."""
+
+
+def user_id_from_token(token: str) -> str:
+    """The ``sub`` of a Supabase JWT (the server re-checks it through RLS)."""
+    try:
+        payload = token.split(".")[1]
+        payload += "=" * (-len(payload) % 4)
+        return json.loads(base64.urlsafe_b64decode(payload))["sub"]
+    except Exception as e:  # noqa: BLE001
+        raise BridgeError(
+            "The saved session is not a usable token; run `rhylthyme login`."
+        ) from e
+
+
+def bridge_id_for(workcell: Any, config_path: Path) -> str:
+    """A stable id per workcell on this machine, kept in ``config_path``."""
+    try:
+        ids = json.loads(config_path.read_text())
+    except (FileNotFoundError, json.JSONDecodeError):
+        ids = {}
+    if workcell.id not in ids:
+        ids[workcell.id] = str(uuid.uuid4())
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        config_path.write_text(json.dumps(ids, indent=2))
+    return ids[workcell.id]
+
+
+def scrubber(workcell: Any) -> Callable[[Optional[str]], str]:
+    """
+    Replace every private value of every workcell tool in free text: each
+    tool's ``secrets()`` (see drivers.ToolView), longest first so
+    "10.0.0.12:50010" goes before "10.0.0.12".
+    """
+    pairs = [pair for tool in workcell.tools.values() for pair in tool.secrets()]
+    pairs.sort(key=lambda p: len(p[0]), reverse=True)
+    pattern = re.compile("|".join(re.escape(p[0]) for p in pairs)) if pairs else None
+    mapping = dict(pairs)
+
+    def scrub(text: Optional[str]) -> str:
+        if not text or pattern is None:
+            return text or ""
+        return pattern.sub(lambda m: mapping[m.group(0)], text)
+
+    return scrub
+
+
+def _status_value(status: Any) -> str:
+    return getattr(status, "value", str(status))
+
+
+def run_status(runner: Any) -> str:
+    if getattr(runner, "program_abort_reason", None):
+        return "aborted"
+    if getattr(runner, "failed_steps", None):
+        return "failed"
+    steps = list(runner.steps.values())
+    if steps and all(_status_value(s.status) == "COMPLETED" for s in steps):
+        return "completed"
+    if getattr(runner, "is_paused", False):
+        return "paused"
+    if getattr(runner, "is_running", False):
+        return "running"
+    return "idle"
+
+
+def snapshot(runner: Any, scrub: Callable[[Optional[str]], str]) -> Dict[str, Any]:
+    """The run as the web sees it: an allowlist of fields, error text scrubbed."""
+    t0 = getattr(runner, "program_start_time", None)
+
+    def rel(t: Optional[float]) -> Optional[float]:
+        return round(t - t0, 2) if (t is not None and t0 is not None) else None
+
+    steps = []
+    for step in runner.steps.values():
+        instrument = step.instrument or {}
+        main = blocking_action(instrument) or {}
+        status = _status_value(step.status)
+        failure = None
+        if step.failure:
+            failure = {
+                "code": str(step.failure.get("code") or ""),
+                "errorMessage": scrub(step.failure.get("errorMessage")),
+            }
+        steps.append(
+            {
+                "stepId": step.step_id,
+                "name": step.name,
+                "trackId": step.track_id,
+                "status": status,
+                "start": rel(step.start_time),
+                "end": rel(step.end_time),
+                "tool": instrument.get("tool"),
+                # The call the step waits on: its command or its until action
+                "command": main.get("command"),
+                "waitingOn": (
+                    main.get("tool") if (main and status == "RUNNING") else None
+                ),
+                "failure": failure,
+                "abortReason": scrub(step.abort_reason) if step.abort_reason else None,
+            }
+        )
+    clock = None
+    if t0 is not None:
+        clock = round(runner.current_time - t0, 2)
+    return {
+        "clock": clock,
+        "paused": bool(getattr(runner, "is_paused", False)),
+        "abortReason": scrub(getattr(runner, "program_abort_reason", None)) or None,
+        "steps": steps,
+    }
+
+
+class SupabaseRest:
+    """Minimal PostgREST client acting as the signed-in user."""
+
+    def __init__(self, url: str, anon_key: str, token: TokenFn, timeout: float = 10.0):
+        self.url = url.rstrip("/") + "/rest/v1"
+        self.anon_key = anon_key
+        self.token = token
+        self.timeout = timeout
+
+    def select(self, table: str, query: str) -> List[Dict[str, Any]]:
+        return self._request("GET", f"/{table}?{query}", None, {}) or []
+
+    def upsert(self, table: str, row: Mapping[str, Any], on_conflict: str) -> None:
+        self._request(
+            "POST",
+            f"/{table}?on_conflict={on_conflict}",
+            row,
+            {"Prefer": "resolution=merge-duplicates,return=minimal"},
+        )
+
+    def patch(self, table: str, match: str, row: Mapping[str, Any]) -> None:
+        self._request("PATCH", f"/{table}?{match}", row, {"Prefer": "return=minimal"})
+
+    def _request(self, method: str, path: str, body: Any, extra: Dict[str, str]) -> Any:
+        headers = {
+            "apikey": self.anon_key,
+            "Authorization": f"Bearer {self.token()}",
+            "Content-Type": "application/json",
+            **extra,
+        }
+        data = None if body is None else json.dumps(body).encode()
+        req = urllib.request.Request(
+            self.url + path, data=data, headers=headers, method=method
+        )
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                raw = resp.read()
+                return json.loads(raw) if raw else None
+        except urllib.error.HTTPError as e:
+            detail = e.read().decode("utf-8", "replace")[:300]
+            raise BridgeError(
+                f"{method} {path.split('?')[0]}: HTTP {e.code} {detail}"
+            ) from e
+        except urllib.error.URLError as e:
+            raise BridgeError(f"Could not reach rhylthyme.com: {e.reason}") from e
+
+
+class Publisher:
+    """Keeps ``bridges`` and ``bridge_state`` current on a background thread.
+
+    With a ``runner`` it publishes that run and passes steering commands to
+    ``submit``. With ``runner=None`` the bridge is idle: it keeps its heartbeat,
+    leaves the last run's state as it was, and passes ``start_run`` on.
+    """
+
+    def __init__(
+        self,
+        runner: Any,
+        *,
+        rest: SupabaseRest,
+        bridge_id: str,
+        user_id: str,
+        workcell: Any,
+        tools: List[Dict[str, str]],
+        program: Optional[Mapping[str, Any]] = None,
+        mode: str = "simulated",
+        allows_live: bool,
+        version: str,
+        on_error: Optional[Callable[[str], None]] = None,
+        submit: Optional[Submit] = None,
+        clock: Callable[[], float] = time.time,
+        program_id: Optional[str] = None,
+    ):
+        self.runner = runner
+        self.rest = rest
+        self.bridge_id = bridge_id
+        self.user_id = user_id
+        self.workcell = workcell
+        self.tools = tools
+        self.program = program or {}
+        self.program_id = program_id
+        self.mode = mode
+        self.accepts = STEER_KINDS if runner is not None else START_KINDS
+        self.allows_live = allows_live
+        self.version = version
+        self.scrub = scrubber(workcell)
+        self.run_id = str(uuid.uuid4())
+        self.on_error = on_error or (lambda message: None)
+        self.submit = submit  # None: watch only, commands are not read
+        self.clock = clock
+        self._handled: set = set()
+        self.last_error: Optional[str] = None
+        self._stop = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._last_state: Optional[str] = None
+        self._last_heartbeat = 0.0
+
+    def bridge_row(self) -> Dict[str, Any]:
+        return {
+            "id": self.bridge_id,
+            "user_id": self.user_id,
+            "name": self.workcell.name,
+            "allows_live": self.allows_live,
+            "tools": self.tools,
+            "version": self.version,
+            "last_seen": _now_iso(),
+        }
+
+    def state_row(self) -> Optional[Dict[str, Any]]:
+        if self.runner is None:
+            return None  # idle: the last run's state stays as it was
+        state = snapshot(self.runner, self.scrub)
+        state["program"] = self.program
+        return {
+            "bridge_id": self.bridge_id,
+            "user_id": self.user_id,
+            "run_id": self.run_id,
+            "program_id": self.program_id,
+            "program_name": self.program.get("name"),
+            "mode": self.mode,
+            "status": run_status(self.runner),
+            "state": state,
+            "updated_at": _now_iso(),
+        }
+
+    def publish_once(self, force: bool = False) -> None:
+        now = time.time()
+        if force or now - self._last_heartbeat >= HEARTBEAT_SECONDS:
+            self.rest.upsert("bridges", self.bridge_row(), "id")
+            self._last_heartbeat = now
+        row = self.state_row()
+        if row is None:
+            return
+        key = json.dumps(
+            {k: v for k, v in row.items() if k != "updated_at"}, sort_keys=True
+        )
+        if force or key != self._last_state:
+            self.rest.upsert("bridge_state", row, "bridge_id")
+            self._last_state = key
+
+    def poll_commands(self) -> None:
+        """Handle pending browser commands, oldest first, once each."""
+        if self.submit is None:
+            return
+        pending = self.rest.select(
+            "bridge_commands",
+            f"bridge_id=eq.{self.bridge_id}&status=eq.pending&order=created_at.asc&select=*",
+        )
+        for command in pending:
+            command_id = str(command.get("id"))
+            if command_id in self._handled:
+                continue
+            self._handled.add(command_id)
+            outcome = self._decide(command)
+            self.rest.patch(
+                "bridge_commands",
+                f"id=eq.{command_id}&status=eq.pending",
+                {
+                    "status": "done" if outcome["accepted"] else "rejected",
+                    "result": outcome,
+                    "updated_at": _now_iso(),
+                },
+            )
+
+    def _decide(self, command: Mapping[str, Any]) -> Dict[str, Any]:
+        def no(reason: str) -> Dict[str, Any]:
+            return {"accepted": False, "reason": reason}
+
+        if command.get("user_id") != self.user_id:
+            return no("not your bridge")
+        age = self.clock() - _parse_iso(command.get("created_at"))
+        if age > COMMAND_MAX_AGE_SECONDS:
+            return no(f"expired ({int(age)} s old)")
+        kind = command.get("kind")
+        if kind not in STEER_KINDS + START_KINDS:
+            return no(f"unknown command {kind!r}")
+        if kind not in self.accepts:
+            if kind in START_KINDS:
+                return no("a run is already in progress")
+            return no("no run in progress")
+        args = command.get("args") if isinstance(command.get("args"), dict) else {}
+        if self.submit is None:
+            return no("this bridge does not take commands")
+        outcome = self.submit(
+            {"id": str(command.get("id")), "kind": kind, "args": args}
+        )
+        if outcome is None:
+            return no("the runner did not answer")
+        return {
+            "accepted": bool(outcome.get("accepted")),
+            "reason": outcome.get("reason") or "",
+        }
+
+    def start(self) -> "Publisher":
+        self.publish_once(force=True)  # fail fast: bad session, missing tables
+        self._thread = threading.Thread(
+            target=self._loop, name="rhylthyme-bridge", daemon=True
+        )
+        self._thread.start()
+        return self
+
+    def _loop(self) -> None:
+        while not self._stop.wait(STATE_SECONDS):
+            try:
+                self.poll_commands()
+                self.publish_once()
+                self.last_error = None
+            except Exception as e:  # noqa: BLE001 - keep running; report once
+                message = str(e)
+                if message != self.last_error:
+                    self.on_error(message)
+                self.last_error = message
+
+    def stop(self) -> None:
+        """Publish the final state, then stop."""
+        self._stop.set()
+        if self._thread is not None:
+            self._thread.join(timeout=5)
+        try:
+            self.publish_once(force=True)
+        except Exception as e:  # noqa: BLE001
+            self.on_error(str(e))
+
+
+def _now_iso() -> str:
+    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+
+
+def _parse_iso(value: Any) -> float:
+    """Seconds since the epoch for a Postgres/ISO timestamp (UTC if no zone)."""
+    from datetime import datetime, timezone
+
+    text = str(value or "").replace("Z", "+00:00")
+    try:
+        parsed = datetime.fromisoformat(text)
+    except ValueError:
+        return 0.0  # unparseable: treat as ancient, so it expires
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=timezone.utc)
+    return parsed.timestamp()
+
+
+__all__ = [
+    "BridgeError",
+    "COMMAND_MAX_AGE_SECONDS",
+    "START_KINDS",
+    "STEER_KINDS",
+    "Publisher",
+    "SupabaseRest",
+    "bridge_id_for",
+    "run_status",
+    "scrubber",
+    "snapshot",
+    "user_id_from_token",
+]

{rhylthyme_cli_runner-0.3.0a0 → rhylthyme_cli_runner-0.4.0a0}/src/rhylthyme_cli_runner/bridge_serve.py

@@ -23,7 +23,7 @@ import re
 import sys
 from typing import Any, Callable, Dict, List, Mapping, Optional, Tuple
 
-from .instruments import INSTALL_HINT, InstrumentSetupError
+from .instruments import InstrumentSetupError
 
 UUID_RE = re.compile(
     r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$", re.I
@@ -105,15 +105,11 @@ def serve(
     out=None,
     allow_live: bool = False,
     client_factory: Optional[Callable] = None,
+    driver_options: Optional[Mapping[str, Mapping[str, Any]]] = None,
 ) -> int:
     """Wait for runs from the web until Ctrl-C (or ``max_runs``). Returns runs started."""
     out = out or sys.stdout
-    try:
-        import rhylthyme_galago as galago
-        from rhylthyme_galago import bridge as B
-    except ImportError:
-        raise InstrumentSetupError(INSTALL_HINT) from None
-
+    from . import bridge as B
     from .remote import auth
     from .validate_program import load_program_file
 
@@ -123,10 +119,19 @@ def serve(
         run = run_program
     run_fn: Callable[..., Any] = run
 
+    from .drivers import DriverUnavailable, WorkcellError, load_workcell
+    from .instruments import bridge_workcell, open_drivers
+
     try:
-        workcell = galago.load_workcell(workcell_source)
-    except galago.WorkcellError as e:
+        workcell = load_workcell(workcell_source)
+    except (WorkcellError, DriverUnavailable) as e:
         raise InstrumentSetupError(str(e)) from None
+    # Opened only to describe the tools and what to scrub; touches nothing
+    described = open_drivers(workcell, workcell.by_driver())
+    for driver in described.values():
+        driver.shutdown()
+    view = bridge_workcell(workcell, described)
+    version = ", ".join(v for v in (d.version for d in described.values()) if v)
     try:
         if rest is None or token_fn is None:
             creds = auth.load_credentials() or {}
@@ -143,15 +148,19 @@ def serve(
         raise InstrumentSetupError(str(e)) from None
 
     bridge_id = B.bridge_id_for(
-        workcell, config_path or (auth.config_dir() / "bridges.json")
+        view, config_path or (auth.config_dir() / "bridges.json")
     )
     schema = load_program_file(schema_file)
     tools: List[Dict[str, str]] = [
-        {"name": t.name, "type": t.type, "status": "idle"}
-        for t in workcell.tools.values()
+        {
+            "name": e.name,
+            "type": described[e.driver].tool_type(e.name),
+            "status": "idle",
+        }
+        for e in sorted(workcell.tools.values(), key=lambda e: e.index)
     ]
     starts: "queue.Queue[Tuple[Dict[str, Any], str, Any, bool]]" = queue.Queue()
-    scrub = B.scrubber(workcell)
+    scrub = B.scrubber(view)
 
     def fetch_program(program_id: str) -> Optional[Mapping[str, Any]]:
         rows = rest.select(
@@ -180,7 +189,7 @@ def serve(
 
         session = None
         try:
-            kwargs: Dict[str, Any] = {"live": live}
+            kwargs: Dict[str, Any] = {"live": live, "driver_options": driver_options}
             if client_factory is not None:
                 kwargs["client_factory"] = client_factory
             session = open_instruments(program, workcell_source, **kwargs)
@@ -212,10 +221,10 @@ def serve(
             rest=rest,
             bridge_id=bridge_id,
             user_id=user_id,
-            workcell=workcell,
+            workcell=view,
             tools=tools,
             allows_live=allow_live,
-            version=getattr(galago, "__version__", ""),
+            version=version,
             on_error=lambda message: print(f"Bridge: {message}", file=out),
             submit=submit,
         )

{rhylthyme_cli_runner-0.3.0a0 → rhylthyme_cli_runner-0.4.0a0}/src/rhylthyme_cli_runner/cli.py

@@ -110,8 +110,8 @@ def cli(ctx, environments_dir):
     type=click.Path(exists=True, dir_okay=False),
     default=None,
     help=(
-        "Workcell file: check instrument steps against its galago tools "
-        "(tool names, types, commands and params)"
+        "Workcell file: check instrument steps against its tools (galago or "
+        "LabMCP: tool names, types, commands, params and limits)"
     ),
 )
 def validate(
@@ -126,8 +126,9 @@ def validate(
     Use --json to get machine-readable output for CI or scripting.
     Use --strict to require all tasks used in steps/buffers to be defined in resourceConstraints.
     Use -e/--environment to validate against specific environment constraints.
-    Use --workcell to check instrument steps against a lab's galago tools;
-    without it, commands are checked against each step's toolType.
+    Use --workcell to check instrument steps against a lab's tools (galago
+    or LabMCP); without it, commands are checked against each step's
+    toolType (a galago tool type, or a LabMCP server such as labmcp-ika).
     """
     # Set up environment for validation if specified
     if environment:
@@ -275,15 +276,15 @@ def validate(
     default=None,
     help=(
         "Workcell file mapping the program's instrument tools to galago-tools "
-        "servers; required for programs with instrument steps"
+        "or LabMCP servers; required for programs with instrument steps"
     ),
 )
 @click.option(
     "--live",
     is_flag=True,
     help=(
-        "Run instrument steps on real hardware instead of galago's simulated "
-        "mode; shows what will run and asks first"
+        "Run instrument steps on real hardware instead of simulated mode; "
+        "shows what will run and asks first"
     ),
 )
 @click.option(
@@ -335,10 +336,12 @@ def run(
     and --predict-context KEY=VALUE to predict for a context other than the
     factor answers.
 
-    Programs with instrument steps need --workcell FILE (galago-tools servers,
-    via rhylthyme-galago). Tools run in galago's simulated mode unless you pass
-    --live, which lists the tools and commands and asks you to type 'live'
-    before anything is configured; --confirm-live answers for scripts.
+    Programs with instrument steps need --workcell FILE, which maps each tool
+    to a galago-tools server (rhylthyme[galago]) or a LabMCP server
+    (rhylthyme[labmcp]). Tools run simulated unless you pass --live, which
+    shows each instrument, its limits and every hazardous action and asks you
+    to type 'live' before anything is configured; --confirm-live answers for
+    scripts.
     """
     run_program(
         program_file,
@@ -366,7 +369,7 @@ def run(
     "--workcell",
     type=click.Path(exists=True, dir_okay=False),
     required=True,
-    help="Workcell file mapping the program's instrument tools to galago-tools servers",
+    help="Workcell file mapping the program's instrument tools to galago-tools or LabMCP servers",
 )
 @click.option(
     "--live",
@@ -396,7 +399,7 @@ def bridge(
     program_file, workcell, live, confirm_live, allow_live, time_scale, no_record
 ):
     """
-    Run a program on a galago workcell and show it live on rhylthyme.com.
+    Run a program on a workcell and show it live on rhylthyme.com.
 
     Without PROGRAM_FILE, wait for runs started from the Bridges page: a
     program saved in your library, checked here against the workcell (no code
@@ -406,9 +409,9 @@ def bridge(
 
     Works like `rhylthyme run --workcell`, and while the run lasts keeps your
     Bridges page up to date: every step, the tool it waits on, any failure.
-    Needs `rhylthyme login` and rhylthyme-galago
-    (pip install "rhylthyme[galago]"). Only outbound HTTPS; tool addresses
-    never leave this machine. From the Bridges page you can pause, resume,
+    Needs `rhylthyme login` and the workcell's drivers (pip install
+    "rhylthyme[galago]" and/or "rhylthyme[labmcp]"). Only outbound HTTPS;
+    tool addresses never leave this machine. From the Bridges page you can pause, resume,
     retry or skip a failed step and abort; this machine checks and logs each
     command, and Ctrl-C here always wins.
     """
@@ -471,7 +474,7 @@ def bridge(
     default=None,
     help=(
         "Workcell file: estimate instrument steps that have no duration from "
-        "their tools' EstimateDuration"
+        "their tools (galago's EstimateDuration, LabMCP's params and defaults)"
     ),
 )
 def plan(input_file, output_file, environment, verbose, workcell):
@@ -485,8 +488,9 @@ def plan(input_file, output_file, environment, verbose, workcell):
     The optimized program is saved to the specified output file.
 
     Instrument steps without a duration get an estimated one (flagged in
-    metadata.durationEstimate): from the tool with --workcell, else from a
-    duration-like command param, else a default.
+    metadata.durationEstimate) by their tool's driver: galago asks the tool
+    with --workcell, else reads a duration-like param; LabMCP reads series
+    lengths, run lengths and wait timeouts from the params; else a default.
     """
     success = plan_program(
         input_file,