An example to evaluate: a training run, its dashboard, and two bugs it found

make seed-demo builds demo_training — prepare on the engine, a GPU-bound
train, evaluate back here — and a panel that draws the loss curve while the
training is still going. It is the session's whole argument in one flow: batch
runs with parameters and a result, a generator yielding on a declared port
rather than logging, fluksio.emit from inside a callback, artifacts carrying
the dataset and the weights between machines, and a sweep whose configs are
isolated from each other. The train node prefers its label rather than
requiring it, so it runs before a GPU box exists and says which machine and
which numeric backend it actually used.

Building it turned up two real bugs. A run waited for a worker its flow only
*preferred*, because required_labels ignored device_policy — so the example
hung on a label it did not need. And a run's seed never reached the flow, so
sweeping over seeds ran the same experiment N times; it now fills an input of
that name when the flow declares one, which is what the field looked like it
did all along.

Pressing Run on a batch flow now submits a run rather than taking the old
non-durable path — that button is the first thing anyone evaluating will press,
and it was quietly doing something else.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AD8SfVhzXBG2nAfFcVh3iD

backend/app/api/routes/flows.py

@@ -8,6 +8,7 @@ from fastapi import (
     APIRouter,
     Depends,
     HTTPException,
+    Request,
     WebSocket,
     WebSocketDisconnect,
 )
@@ -27,6 +28,7 @@ from app.flow.dashboards import DashboardStore
 from app.flow.events import event_bus
 from app.flow.messages import qualify
 from app.flow.pipeline import ValidationIssue
+from app.flow.runs import RunRejected
 from app.flow.schemas import (
     NAME_PATTERN,
     BrainGraph,
@@ -616,15 +618,38 @@ def validate_flow(name: str, controller: FlowControllerDep) -> Any:
 async def run_flow(
     name: str,
     body: RunRequest,
+    request: Request,
     controller: FlowControllerDep,
+    user: CurrentUser,
 ) -> Any:
     """Run every node of a flow once.
 
     With unpublished changes this runs the draft, so the button matches what is
     on the canvas. Nothing is deployed by running it.
+
+    A *batch* flow is submitted as a run instead, because that is what running
+    one means: it is what keeps the parameters, the series and the result, and
+    a button that quietly did something else would be a trap.
     """
-    _read_flow(controller, name)
+    definition = _read_flow(controller, name)
     _require_enabled(controller, name)
+    if definition.mode == "batch":
+        service = getattr(request.app.state, "run_service", None)
+        if service is None:
+            raise HTTPException(status_code=503, detail="Runs are not available")
+        try:
+            await run_in_threadpool(
+                service.submit,
+                name,
+                params=body.inputs,
+                cause="api",
+                actor=user.email,
+                draft=controller.store.has_draft(name),
+            )
+        except RunRejected as exc:
+            raise HTTPException(status_code=422, detail=str(exc)) from exc
+        return _flow_state(controller, name)
+
     inputs = {qualify(name, key): value for key, value in body.inputs.items()}
     if controller.store.has_draft(name):
         await run_in_threadpool(controller.run_preview, name, inputs)