# Run Watchflow

Action `arrow.triangle.branch`

`action.run_watchflow`

Run your other saved flows from inside this one — up to three, in order, as part of the current run. Build a reusable flow once (say Tidy Downloads), then call it from anywhere without copying its nodes.

## Three outlets, three jobs

One inlet in, three outlets out. Every port is the `any` type, so each connects to anything.

Drag the nodes around — it's the same canvas you build on.

## What "Done" hands you

Depends on how many flows you called.

One flow

Done is that flow's final payload — reach its fields directly, just like on its own canvas.

`{{movedCount}} {{result.count}}`
Several flows

Each result lands under its own namespace — the short name you give each flow in the picker (the `as` field, which only appears once you've added a second flow) — plus a `ranFlows` rollup.

`{{tidy.result}} {{report.status}}`

## How it works

### A live preview on the canvas

The flow you pick renders right on the canvas as a dimmed shadow branching off the node — a live window onto the real flow, not a copy.

- • Hover to light it up.
- • Click a shadow node to edit the source flow (shared everywhere it's used).
- • Drag to rearrange; ↗ jumps to that flow's own builder.
- • Nodes light up live as the subflow runs.

### The trigger is just the door

A called flow's trigger doesn't wait for its event. The upstream payload is injected at the trigger's outlet and the flow runs immediately.

- • Trigger config is ignored — which folder, which device, which schedule.
- • If the flow needs a field the trigger normally supplies and you don't provide it, the node warns you which fields are missing — set them with a Set Value node.
- • A flow with no trigger can't be called.

### Locked flows

Mark any flow Locked (in its builder's right sidebar) and its shadow becomes view-only — others can embed and run it but can't edit it through the preview. Its own builder still edits normally. Share a flow others can use but not alter.

### Safe by design

Composition can't spiral out of control.

No recursion Depth ≤ 4 ≤ 64 runs each Bounded results

## Ports

Direction | Name | Type | Carries
--- | --- | --- | ---
Inlet | Input | any | The payload each called flow receives at its trigger
Outlet | Flow | any | Anchor for the dimmed preview — not wired to other nodes
Outlet | Done | any | The result — one flow's payload directly, or namespaced + `ranFlows` for several
Outlet | Pass-through | any | Your original input, unchanged

## Configuration

Field | Type | Description
--- | --- | ---
flows | Flow Picker | The saved flows to run, in order (up to 3). Each pick draws its preview. Only flows with a trigger can be chosen.

## Output variables (several flows)

Call one flow and Done is its payload directly — there's no namespace (so reach `{{result}}`, not `{{anything.result}}`). Call several and each gets a block under its own namespace, taken from the short name you set per flow (e.g. a flow named in the picker as `tidy`), plus a summary array:

Variable | Type | Description
--- | --- | ---
tidy.result | Any | A called flow's final payload, under that flow's namespace (here a flow set to `as tidy`)
tidy.status | String | How it finished — `completed`, `failed`, or `cancelled`
ranFlows | Array | Every flow that ran — `name`, `status`, `namespace` — in order

## Example

A daily cleanup flow calls a reusable Tidy Downloads flow, then notifies you with its result:

Since only one flow is called, Done hands you its payload directly — the Notification reads `{{movedCount}} files tidied`, no `flow_1` wrapper. The Tidy Downloads Schedule trigger is bypassed; it runs the moment this flow reaches the node.