Start, stop and pause flows, and show what their nodes print

Flows can now be taken off the engine and put back. Stopped state lives in a
runtime.json beside the flow, not in the flow document: the canvas autosaves
that document, so a stopped flow would otherwise start itself again on the
next edit. A stopped flow gets no subscriptions, schedules or webhooks, its
nodes are skipped by the scheduler, and running it answers 409. Pausing holds
a flow's nodes while its values keep arriving, so the canvas still shows what
is coming in.

Node code is user code and print is how it says things, so stdout is teed
through a contextvar sink active only during a node execution — one event per
execution, capped, so a chatty node cannot outrun the stream. A node that
fails sends its traceback the same way, trimmed to the author's own frames.
The dock gains a logs panel and a pause control; the dashboard replaces its
placeholder with what is running, stopped or failing; the edge inspector can
send the last message again.

Single-stepping is deferred and noted: the scheduler keeps no progress between
calls, so a step button would re-run the same node rather than advance.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

backend/app/api/routes/flows.py

@@ -57,6 +57,8 @@ class FlowDetail(BaseModel):
     nodes: list[NodeStatusPublic] = []
     issues: list[ValidationIssue] = []
     has_draft: bool = False
+    enabled: bool = True
+    paused: bool = False
 
 
 class ValidationResult(BaseModel):
@@ -81,6 +83,10 @@ class TriggerRequest(BaseModel):
 
 def _detail(controller: FlowController, definition: FlowDef) -> FlowDetail:
     name = definition.name
+    running = {
+        "enabled": controller.is_enabled(name),
+        "paused": controller.is_paused(name),
+    }
     if controller.store.has_draft(name):
         # Report the draft the editor is showing, not the version running
         # underneath it — otherwise a node the author just broke looks fine.
@@ -90,11 +96,13 @@ def _detail(controller: FlowController, definition: FlowDef) -> FlowDetail:
             nodes=preview.nodes,
             issues=preview.issues,
             has_draft=True,
+            **running,
         )
     return FlowDetail(
         definition=definition,
         nodes=controller.node_statuses(name),
         issues=controller.flow_issues(name),
+        **running,
     )
 
 
@@ -106,6 +114,14 @@ def _read_flow(controller: FlowController, name: str) -> FlowDef:
         raise HTTPException(status_code=404, detail=f"No flow named '{name}'")
 
 
+def _require_enabled(controller: FlowController, name: str) -> None:
+    if not controller.is_enabled(name):
+        raise HTTPException(
+            status_code=409,
+            detail=f"Flow '{name}' is stopped — start it before running it",
+        )
+
+
 def _flow_state(controller: FlowController, name: str) -> FlowStatePublic:
     return FlowStatePublic(
         values={
@@ -137,6 +153,8 @@ def read_flows(controller: FlowControllerDep) -> Any:
                 node_count=len(definition.nodes),
                 error_count=sum(1 for s in statuses if s.status == "error"),
                 has_draft=controller.store.has_draft(name),
+                enabled=controller.is_enabled(name),
+                paused=controller.is_paused(name),
             )
         )
     return FlowsPublic(data=summaries, count=len(summaries))
@@ -316,6 +334,43 @@ async def save_node_source(
     )
 
 
+# -----------------------------------------------------------------------------
+# Running, stopped, paused
+# -----------------------------------------------------------------------------
+
+
+@router.post("/{name}/start", response_model=FlowDetail)
+async def start_flow(name: str, controller: FlowControllerDep) -> Any:
+    """Let the engine run this flow again."""
+    _read_flow(controller, name)
+    await controller.set_enabled(name, True)
+    return _detail(controller, _read_flow(controller, name))
+
+
+@router.post("/{name}/stop", response_model=FlowDetail)
+async def stop_flow(name: str, controller: FlowControllerDep) -> Any:
+    """Take this flow off the engine: no subscriptions, schedules or webhooks."""
+    _read_flow(controller, name)
+    await controller.set_enabled(name, False)
+    return _detail(controller, _read_flow(controller, name))
+
+
+@router.post("/{name}/pause", response_model=Message)
+def pause_flow(name: str, controller: FlowControllerDep) -> Any:
+    """Hold the flow's nodes so its messages can be stepped through."""
+    _read_flow(controller, name)
+    controller.pause_flow(name)
+    return Message(message=f"Paused flow '{name}'")
+
+
+@router.post("/{name}/resume", response_model=Message)
+async def resume_flow(name: str, controller: FlowControllerDep) -> Any:
+    """Let the flow carry on, running whatever was held back."""
+    _read_flow(controller, name)
+    await run_in_threadpool(controller.resume_flow, name)
+    return Message(message=f"Resumed flow '{name}'")
+
+
 # -----------------------------------------------------------------------------
 # Validation and execution
 # -----------------------------------------------------------------------------
@@ -342,6 +397,7 @@ async def run_flow(
     on the canvas. Nothing is deployed by running it.
     """
     _read_flow(controller, name)
+    _require_enabled(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)
@@ -358,6 +414,7 @@ async def trigger_node(
     controller: FlowControllerDep,
 ) -> Any:
     """Feed values into a single node."""
+    _require_enabled(controller, name)
     try:
         await run_in_threadpool(
             controller.trigger_node, f"{name}.{node_id}", body.values
@@ -429,6 +486,8 @@ async def flow_events(websocket: WebSocket, token: str = "") -> None:
                 "values": controller.values(),
                 "nodes": [s.model_dump() for s in controller.node_statuses()],
                 "issues": [i.model_dump() for i in controller.issues],
+                "paused": controller.paused_flows(),
+                "logs": list(event_bus.recent_logs),
             }
         )