Style the engine's own logs, notice enrolment while serving, say more in status

Four things from a testing pass.

`fluksio serve` printed its own lines through the root logger, which has no
handler and falls back to `INFO:fluksio.cloud.connector:...` — beside uvicorn's
aligned output it reads like something went wrong. The engine's loggers and
alembic's now use uvicorn's own handler. Named rather than configuring the
root: httpx logs every portal call at INFO and none of that is printed today.

`fluksio enroll` writes its config from another process, so an engine already
serving never learned it had been paired. It now looks for one every few
seconds and dials when it appears. `load()` rather than `exists()`, or a file
that does not parse would be restarted forever.

`fluksio status` says where the installation stands with its portal — never
paired, linked, or paired and unreachable, which is the one worth acting on.

`--seed` and `--timeout` had no help text at all. Both say what they are for
now, and the docs say what a seed is actually for: recorded on the run, part of
its input digest, and passed to an input named `seed` when the flow declares
one, so the number a run is labelled with is the one the code drew from.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_019V5bsYGNxcgPs4xXmTPx69

backend/fluksio/cloud/connector.py

@@ -50,6 +50,49 @@ MAX_WS_MESSAGE = 1024 * 1024
 #: Only the versioned API is served over the tunnel. The MCP mount and the
 #: OAuth endpoints live outside it and stay local-only.
 ALLOWED_PREFIX = "/api/v1/"
+#: How often to look for a config that appeared while the engine was up.
+#: Enrolment is something a person does and then waits on, so this is the
+#: delay they sit through — short enough not to be worth a restart.
+ENROL_POLL_S = 3.0
+
+
+def start(app: FastAPI) -> None:
+    """Dial the portal, replacing any link already up."""
+    existing = getattr(app.state, "cloud_task", None)
+    if existing is not None:
+        existing.cancel()
+    connector = CloudConnector(app)
+    app.state.cloud_connector = connector
+    app.state.cloud_task = asyncio.create_task(
+        connector.serve_forever(), name="cloud-connector"
+    )
+
+
+async def watch_enrolment(app: FastAPI) -> None:
+    """Notice an enrolment that happened outside this process.
+
+    ``fluksio enroll`` writes the config against the database directly, with no
+    idea whether an engine is running — so without this, pairing an installation
+    that is already serving would take a restart to come into effect. Enrolling
+    through the API starts the link itself and this sees a task already there.
+    """
+    while True:
+        await asyncio.sleep(ENROL_POLL_S)
+        task = getattr(app.state, "cloud_task", None)
+        if task is not None and task.done():
+            # It returns of its own accord when the config goes away, which is
+            # what `fluksio disconnect` and the portal's own Disconnect do.
+            app.state.cloud_task = None
+            app.state.cloud_connector = None
+            task = None
+        # `load()`, not `exists()`: a file that cannot be read is not an
+        # enrolment, and the connector would give up on it the instant it
+        # started — which, started from here, is a restart every few seconds.
+        # A config that is fine but unreachable keeps its task, and the
+        # retrying belongs to the connector rather than to this.
+        if task is None and cloud_config.load() is not None:
+            logger.info("Enrolled while running; dialling the portal")
+            start(app)
 
 
 class CloudConnector: