diff --git a/AGENTS.md b/AGENTS.md
index 1b0b407..8ae8c81 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -23,7 +23,10 @@ mypy taskmaestro               # type check (strict mode)
 | `taskmaestro/context.py` | `ExecutionContext` with correlation ID, logger, scratch dir, service registry |
 | `taskmaestro/task.py` | `Task[I, O]` ABC, type introspection (`get_input_type`, `get_output_type`) |
 | `taskmaestro/workflow.py` | `Workflow` (linear + DAG), `WorkflowBuilder`, validation (cycles, types, fan-in) |
-| `taskmaestro/dependencies.py`, `taskmaestro/mapping.py` | Task handles, output references, `collect()`, mapped-task configuration |
+| `taskmaestro/dependencies.py`, `taskmaestro/mapping.py` | Task handles (incl. guard sugar `on`/`otherwise`/`if_true`/`if_false`), output references, `collect()`, `first_of()`, mapped-task configuration |
+| `taskmaestro/conditions.py` | `SwitchTask[I, L]`/`ConditionTask[I]` (label in a `Branch` output), `Condition` (unresolved `when=`), `Guard` (resolved), `when()`, `ContextFlag` (condition on a context value; `Runner.run` checks configured keys are registered before running) |
+| `taskmaestro/condition_tasks.py` | Ready-made conditions registered as `condition.*` task entry points: `Compare`, `IsTrue`, `PathExists` |
+| `taskmaestro/scripts.py` | Built-in subprocess tasks `taskmaestro.python` (`PythonScript`) and `taskmaestro.command` (`Command`), `ScriptOutput`; JSON exchange via `TASKMAESTRO_INPUT`/`TASKMAESTRO_OUTPUT` (see `docs/script-tasks.md`) |
 | `taskmaestro/workflow_task.py` | Nested workflows wrapped as tasks |
 | `taskmaestro/yaml_config.py` | YAML parsing, task imports, workflow and input validation; `load_registered_workflow` pairs an entry-point workflow with an input file |
 | `taskmaestro/cli.py`, `taskmaestro/discovery.py` | CLI (`run`, `validate`, `graph`, `tasks list/describe`, `workflow list/describe`; workflow arguments accept a YAML path or a registered workflow name), plugin entry-point discovery (`load_registry` collects broken entry points instead of raising) |
@@ -43,7 +46,9 @@ mypy taskmaestro               # type check (strict mode)
 - **Timeouts**: `signal.setitimer`/`SIGALRM` (Unix only, main thread); gracefully warns if unavailable. All armed timeouts go through the process-wide `_AlarmScheduler`, which always arms the nearest expiry, so nested runs (`workflow_task`) cannot cancel or extend an enclosing run's timeouts
 - **Hook error swallowing**: `_emit()` wraps each hook call in try/except, reports via `warnings.warn(..., HookError, source=exc)` — message includes `repr(exc)`; `HookError` subclasses `UserWarning` so it can be filtered or escalated
 - **Inner-workflow failures**: `workflow_task` raises `WorkflowTaskError` (a `TaskExecutionError`) carrying `inner_job` and chaining the original exception via `__cause__`; `Job.exception` keeps the raw exception alongside `Job.error`
-- **Validation order**: unique names → acyclic (DFS) → type chain → result task detection
+- **Conditional branches**: a `when=` guard is a control edge (ordering + predicate, no data); guard sources count as upstreams for topo order, cycles and sinks. A task that is not run gets `TaskStatus.SKIPPED` + `skip_reason` and `on_task_skip(job, task_name, reason)` (no `task_start`). Skips propagate through plain deps; `collect()` drops skipped members; `first_of` takes the first member that ran; a skipped result task fails the job with `ResultTaskSkippedError`. Every switch label needs an `on()` or `otherwise()`
+- **Script tasks**: `inputs` is `dict[str, Any]`, wired with a keyed `collect`; subprocesses only (no in-process mode). Relative paths resolve against the process CWD. Failures raise `ScriptError` (a `TaskExecutionError`)
+- **Validation order**: unique names → references → acyclic (DFS) → task maps → guards (incl. switch label coverage) → type chain (incl. `first_of`) → result task detection
 
 ## Testing Conventions
 
diff --git a/README.md b/README.md
index 99f2521..8726fdd 100644
--- a/README.md
+++ b/README.md
@@ -423,6 +423,123 @@ with `MappedOutput(root={})`. Per-item records are available in
 built-in logging, timing, and persistence hooks observe individual items.
 Concurrent mapped execution is intentionally deferred.
 
+## Conditional Branches
+
+A workflow can choose between branches at run time. A *switch task* returns a
+branch label; downstream tasks are guarded with `when=` and run only when their
+guard matches. Tasks whose guard does not match are **skipped**, not failed.
+
+```python
+from typing import Literal
+
+from taskmaestro import ConditionTask, SwitchTask, Workflow, first_of
+
+
+class ChooseShipping(SwitchTask[Parcel, Literal["express", "freight", "standard"]]):
+    def decide(self, input: Parcel, ctx: ExecutionContext) -> Literal["express", "freight", "standard"]:
+        return "freight" if input.weight_kg > 100 else "standard"
+
+
+builder = Workflow.builder("shipping")
+parcel = builder.task(LoadParcel)
+method = builder.task(ChooseShipping, depends_on=parcel)
+express = builder.task(ExpressShipping, depends_on=parcel, when=method.on("express"))
+freight = builder.task(FreightShipping, depends_on=parcel, when=method.on("freight"))
+standard = builder.task(StandardShipping, depends_on=parcel, when=method.otherwise())
+builder.task(PrintLabel, parcel=parcel, shipment=first_of(express, freight, standard))
+```
+
+- `SwitchTask[I, L]`: implement `decide()` and return a label of type `L`, a
+  `Literal[...]` or an `Enum`. The task output is a `Branch` model with a
+  `branch` field.
+- `ConditionTask[I]` is a switch with the labels `True`/`False`; guard with
+  `handle.if_true()` and `handle.if_false()`.
+- `handle.on(*labels)` runs a task for any of the labels. `handle.otherwise()`
+  runs it for every label that no `on()` guard claims.
+- Any output field can be a guard too: `when(handle.field("kind"), equals=...)`,
+  `in_=[...]` or `truthy=True|False` (truthy/falsy needs a `bool` or optional
+  field; a non-bool value counts as truthy when it is not `None`, so `0` or `""`
+  still count as set). Guard values are validated strictly against the field
+  type: `"no"` or `1` is not accepted for a `bool` field, while the string value
+  of an enum member is. Shorthands: `handle.field("kind").equals(...)`, `.is_in(...)`,
+  `.truthy()`, `.falsy()`.
+- `first_of(a, b, ...)` joins branches: the input gets the output of the first
+  listed member that ran.
+- `ContextFlag` is a ready-made condition on the execution context: it is
+  `True` when the context value registered under its configured `key` is
+  truthy. `Runner.run` raises `ContextValueMissingError` (a
+  `WorkflowDefinitionError`) before any task runs if
+  a configured key is not registered. The `taskmaestro` CLI does not register
+  context values, so it reports such workflows as a configuration error.
+
+  ```python
+  dry = builder.task(ContextFlag, name="dry_run", config_fields=["key"])
+  builder.task(Deploy, depends_on=data, when=dry.if_false())
+  # job configuration: {"dry_run": {"key": "dry_run"}}
+  ctx.register("dry_run", True)
+  ```
+
+- Ready-made conditions, registered as task plugins so they show up in
+  `taskmaestro tasks list` and workflow editors
+  (`taskmaestro.condition_tasks`):
+
+  | Task id                 | Class        | `True` when                                                    |
+  |-------------------------|--------------|----------------------------------------------------------------|
+  | `condition.compare`     | `Compare`    | `value <op> threshold`; `op` is one of `<`, `<=`, `==`, `!=`, `>=` (default), `>` |
+  | `condition.is_true`     | `IsTrue`     | `value` is truthy                                              |
+  | `condition.path_exists` | `PathExists` | `path` exists; `kind` may require a `file` or `directory`     |
+
+  ```yaml
+  - task: condition.compare
+    name: is_large
+    depends_on:
+      value: [pipeline.LoadOrder, amount]
+    config_fields: [op, threshold]
+  - task: pipeline.ManualReview
+    depends_on: pipeline.LoadOrder
+    when: {switch: is_large, case: true}
+  ```
+
+Validation happens at build time. Labels must belong to the switch's label
+type, so typos are caught. Every label needs a guarded task or an
+`otherwise()`. An `otherwise()` that can never match is an error. A switch with
+no guarded tasks is an ordinary task.
+
+At run time:
+
+- A task is skipped when its guard does not match, when the guard's source was
+  skipped, when any plain dependency was skipped, or when every `first_of`
+  member was skipped. Skips propagate downstream.
+- `collect()` leaves out skipped members.
+- Skipped tasks get a `TaskResult` with `status=TaskStatus.SKIPPED` and a
+  `skip_reason`, and are listed in `job.skipped_tasks`. Hooks receive
+  `on_task_skip(job, task_name, reason)`; `on_task_start` is not called for
+  them.
+- If the result task is skipped, the job fails with `ResultTaskSkippedError`.
+
+In YAML:
+
+```yaml
+- task: pipeline.ExpressShipping
+  depends_on: pipeline.LoadParcel
+  when: {switch: pipeline.ChooseShipping, case: express}       # case may be a list
+- task: pipeline.StandardShipping
+  depends_on: pipeline.LoadParcel
+  when: {switch: pipeline.ChooseShipping, otherwise: true}
+- task: pipeline.Audit
+  depends_on: pipeline.LoadParcel
+  when: {ref: [pipeline.LoadParcel, priority], truthy: true}   # or equals: / in: [...]
+- task: pipeline.PrintLabel
+  depends_on:
+    parcel: pipeline.LoadParcel
+    shipment:
+      first_of: [pipeline.ExpressShipping, pipeline.StandardShipping]
+```
+
+In Mermaid diagrams, switch tasks are diamonds and guards are dashed edges
+labeled with their case (`express`, `otherwise`, `true`, `.kind = a`, ...).
+`first_of` joins are drawn as rounded nodes.
+
 ## ObjectModel
 
 `ObjectModel[T]` wraps arbitrary (non-Pydantic) objects so they can flow through workflows. Use it as a type alias for simple wrappers, or subclass it to add extra fields:
@@ -586,6 +703,58 @@ workflow:
 The same root/result type inference and single-unconfigured-root requirement apply as for
 `Workflow.as_task()`.
 
+## Script and Command Tasks
+
+Two built-in tasks run user code without a Task class. Both run a subprocess and return
+`ScriptOutput` (`result`, `returncode`, `stdout`, `stderr`):
+
+| Task id | Runs | Main settings |
+|---|---|---|
+| `taskmaestro.python` | `<current python> <script> <args...>` | `script`, `args` |
+| `taskmaestro.command` | A string through the shell, or a list as an executable with arguments (no shell) | `command` |
+
+Shared settings: `inputs` (upstream data), `env` (extra environment variables), `cwd`,
+`timeout` (seconds; the process is killed) and `check` (default `true`: a nonzero exit
+code fails the task with `ScriptError`, including the last lines of stderr). Absolute paths
+are used as given; relative `script` and `cwd` paths resolve against the current directory
+of the process running the workflow.
+
+Data is exchanged through JSON files in a fresh directory under the scratch directory:
+
+- `TASKMAESTRO_INPUT`: path to a JSON object holding `inputs` (set when `inputs` is not empty).
+- `TASKMAESTRO_OUTPUT`: path where the process may write a JSON value; it becomes `result`.
+
+`inputs` is a `dict[str, Any]`, connected with a keyed `collect` so scripts always receive a
+JSON object. Runtime-only objects (such as `ObjectModel[rips.EclipseCase]`) cannot be sent to a
+process and fail the task; use a regular `Task` for those.
+
+Their settings are ordinary input fields, given per task in `input.yaml`:
+
+```yaml
+# workflow.yaml (tasks)
+- task: taskmaestro.python
+  name: word_count
+- task: taskmaestro.command
+  name: save_report
+  depends_on:
+    inputs:
+      collect: {counts: [word_count, result]}
+```
+
+```yaml
+# input.yaml
+word_count:
+  script: scripts/word_count.py
+  args: [data/sample.txt]
+save_report:
+  command: sh scripts/save_report.sh
+  env: {REPORT_DIR: /tmp/reports}
+```
+
+Downstream tasks can use a single field, e.g. `depends_on: {path: [save_report, result]}`;
+the downstream input model validates the value at run time. See
+[`docs/script-tasks.md`](docs/script-tasks.md) and `examples/scripts/`.
+
 ## Visualization
 
 Generate Mermaid diagrams of workflow topology:
@@ -616,7 +785,7 @@ graph TD
     build_report -->|AnalysisReport| _end_
 ```
 
-Edges are labeled with data types. Fan-in edges show field names, and field routing edges show `.field: Type`. When a `JobConfiguration` is provided, configured tasks get dashed edges from a `JobConfiguration` node.
+Edges are labeled with data types. Fan-in edges show field names, and field routing edges show `.field: Type`. When a `JobConfiguration` is provided, configured tasks get dashed edges from a `JobConfiguration` node. Switch tasks are drawn as diamonds with dashed, labeled guard edges (see [Conditional Branches](#conditional-branches)).
 
 ## Error Handling
 
@@ -630,6 +799,8 @@ WorkflowRunnerError (base)
 │   └── WorkflowLookupError       # Unknown or broken registered workflow name
 └── TaskExecutionError            # Runtime task failure
     ├── MappedTaskExecutionError  # One or more mapped items failed
+    ├── ResultTaskSkippedError    # The result task was skipped by a condition
+    ├── ScriptError               # A script/command task failed (returncode, stdout, stderr)
     ├── TaskOutputTypeError       # Output type mismatch
     └── TaskTimeoutError          # Task exceeded timeout
 ```
@@ -738,7 +909,7 @@ prints indented JSON.
 
 ## Examples
 
-Four full example pipelines are included in the `examples/` directory:
+Seven full example pipelines are included in the `examples/` directory:
 
 | Example | Features |
 |---|---|
@@ -746,6 +917,9 @@ Four full example pipelines are included in the `examples/` directory:
 | `examples/resinsight/` | `ObjectModel[T]` for gRPC objects, `JobConfiguration` with per-task config, named task instances, `config_fields`, YAML config |
 | `examples/image_processing/` | Nested workflows through `Workflow.as_task()` and YAML `workflow:`, typed boundaries, expanded Mermaid subgraph |
 | `examples/release_pipeline/` | Keyed `collect()` dependencies, mapped tasks, mapped output routing, per-task YAML config |
+| `examples/conditional_if/` | If/else with `ConditionTask`, `if_true()`/`if_false()` guards, `first_of` join, YAML `when:` |
+| `examples/conditional_switch/` | Multi-way `SwitchTask` with `on(...)` and `otherwise()`, `first_of` join, YAML `when:` |
+| `examples/scripts/` | `taskmaestro.python` and `taskmaestro.command` tasks, keyed `collect` into a script (YAML only; run from the repository root) |
 
 Run an example:
 
diff --git a/docs/conditional-branches-plan.md b/docs/conditional-branches-plan.md
new file mode 100644
index 0000000..5461bdf
--- /dev/null
+++ b/docs/conditional-branches-plan.md
@@ -0,0 +1,83 @@
+# Conditional branch execution (issue #16)
+
+## Problem
+The runner executes every task in topological order and stops at the first failure. Nothing lets a workflow pick a path at runtime. Issue #16 asks for conditional switching between branches.
+
+## Agreed design
+
+### Concepts
+- **`when` guard**: a *control edge* on a task. It adds ordering and a runtime predicate, but it carries no data. The guarded task still gets its input through `depends_on`.
+- **`SwitchTask[I, L]`**: the user implements `decide(input, ctx) -> L`, where `L` is a `Literal[...]` or `StrEnum`. The base class's final `run()` wraps the returned label in `Branch[L]`, a generic Pydantic model with one field, `branch: L`. `__init_subclass__` sets `Outputs = Branch[L]`, and the existing `get_output_type` honours that, so introspection does not change. The label set comes from `L`.
+- **`ConditionTask[I]`**: a `SwitchTask` with branches `True`/`False`. `decide -> bool`.
+- **Handle sugar**: `handle.on(*labels)` returns a guard (`in`). `handle.otherwise()` matches any label that no other guard on the same switch claims. For a ConditionTask: `on(True)` and `on(False)`, plus `if_true()`/`if_false()` aliases.
+- **Generic field guards**: `when(ref, equals=…)`, `when(ref, in_=[…])`, `when(ref, truthy=True|False)` on any upstream output field. `ref` is an `OutputHandle`, a `(task, field)` tuple, or a name string.
+- **Join**: `first_of(a, b, …)` is a dependency value like `collect()`. It resolves to the first member, in declaration order, that completed.
+- Labels are chosen over target task ids. They are validated at build time, one label can enable many tasks, and renaming a task does not break routing.
+
+### Runtime semantics
+- New `TaskStatus.SKIPPED`. A skipped task gets a `TaskResult(status=SKIPPED, output=None, error=None)` plus a reason, and `Event.TASK_SKIP` / `on_task_skip(job, task, reason)` is emitted. A skipped task does **not** emit `task_start`.
+- A task is skipped when any of these holds:
+  1. Its guard evaluates false.
+  2. The guard's source task was skipped.
+  3. Any plain data dependency (whole output, field ref, or a direct fan-in value) was skipped.
+  4. Every member of one of its `first_of` dependencies was skipped.
+- `collect()` drops skipped members. A list gets shorter; a dict loses those keys. If all members are skipped, the result is an empty list or dict, which is not a skip.
+- Skips propagate transitively because tasks run in topological order.
+- If the result task is skipped, the job **fails**. The new `ResultTaskSkippedError` goes in `job.exception`/`job.error`, `failed_task = result task`, and `JOB_FAIL` is emitted.
+- If a guarded task is mapped and its guard is false, the whole node is skipped. No map items run.
+- Nested workflows: if the inner result is skipped, the inner job fails, which raises `WorkflowTaskError` through the existing path.
+
+### Static validation (`Workflow._validate`)
+New step after references: `_validate_guards`. The order becomes: unique names → references (now including guard and `first_of` refs) → acyclic (including control edges) → task maps → guards → types → result task.
+- The guard source task and field must exist. A guard cannot read a field on a mapped task's output (`MappedOutput`).
+- `on()`/`equals`/`in` values must be compatible with the field annotation. When the field is a `Literal` or enum, a value outside it is an error, which catches typos.
+- `truthy`/`falsy` guards are only allowed on `bool` or Optional fields.
+- For each switch: every declared label is consumed by some `on()` or covered by `otherwise()`, else build error. `otherwise()` matches the labels not claimed by any `on()` on that switch. Several tasks may use `otherwise()`, and they all mean the same thing. If every label is already claimed, `otherwise()` is an error because it is unreachable.
+- `first_of` needs at least 2 members, and each member type must be compatible with the destination field (reuses `_is_type_compatible`).
+- `topological_order`, `_find_sinks`, and cycle detection include guard sources as upstreams. A switch that is consumed only by guards is therefore not a sink.
+
+### Stored representation (`workflow.py`)
+- `Workflow._guards: dict[str, Guard]`, where `Guard` is a frozen dataclass in a new `taskmaestro/conditions.py`: `ref: OutputRef`, `op: Literal["in","truthy","falsy","otherwise"]`, `values: tuple[Any, ...]`. `equals` is normalized to `in` with one value. The user-facing helpers `when()` and `first_of()` and the classes `SwitchTask`, `ConditionTask`, `Branch` also live there.
+- `FirstOfRef(members: tuple[OutputRef, ...])` is stored as a `FanInValue`, next to `CollectionRef`. Update `_extract_upstream_names`, `_validate_types`, and `build()` copying.
+- New public accessors: `get_guard(name)`, `is_conditional(name)`.
+
+## Surfaces to update
+| Area | Change |
+|---|---|
+| `conditions.py` (new) | `Branch`, `SwitchTask`, `ConditionTask`, `Guard`, `Condition` (unresolved), `when()`; `first_of()`/`FirstOfRef` live in `dependencies.py` |
+| `dependencies.py` | `TaskHandle.on()`, `.otherwise()`, `.if_true()`, `.if_false()`; `OutputHandle.equals()/.is_in()/.truthy()/.falsy()` sugar |
+| `workflow.py` | `when=` kwarg on `add_task`/`task`/`map_task`; resolution of guard and `first_of` refs; validation; topo/sinks/cycles; snapshot copy in `build()` |
+| `runner.py` | evaluate guard and skip rules before `TASK_START`; skipped set; `first_of` resolution; `collect()` dropping skipped members; result-task-skipped failure |
+| `job.py` | `TaskStatus.SKIPPED`; `TaskResult.skip_reason: str \| None = None`; `Job.skipped_tasks` convenience property |
+| `exceptions.py` | `ResultTaskSkippedError(TaskExecutionError)` (check hierarchy) |
+| `hooks/base.py` | `Event.TASK_SKIP`, `on_task_skip` on the Protocol and `BaseHook` |
+| `hooks/logging.py`, `timing.py`, `persistence.py` | log the skip; timing records nothing (or 0); persistence writes nothing for skipped tasks |
+| `yaml_config.py` | `TaskConfig.when`: `{switch: <task>, case: <label> \| [labels]}`, `{switch: <task>, otherwise: true}` (not `case: default`, since `default` could be a real label) or `{ref: <task> \| [task, field], equals \| in \| truthy: …}` (`truthy: false` means falsy); dependency value `{first_of: [refs]}` |
+| `visualization.py` | dashed control edge `route -.->\|express\| fast`; `first_of` rendered as a rounded (stadium) join node; switch nodes drawn as diamonds `id{"label"}` |
+| `introspection.py` | `describe_workflow` adds per-task `when` (JSON form) and the switch `branches` list; `dependency_spec` renders `first_of` |
+| `definition.py` | `when` on nodes (or `control` edges with `kind: "when"`), `first_of` edges (`"first_of": true` with order); load and write round-trip; `_check_saveable` |
+| `cli.py` | `run --json`: include skipped tasks in output if task statuses are reported; check the existing contract |
+| `__init__.py` | export `SwitchTask`, `ConditionTask`, `Branch`, `when`, `first_of`, `ResultTaskSkippedError` |
+| examples | `examples/conditional_if/` (`ConditionTask` + `first_of`) and `examples/conditional_switch/` (`SwitchTask` + `on`/`otherwise` + `first_of`), each with `pipeline.py`, `workflow.yaml`, `input.yaml` |
+| docs | README "Conditional Branches" section plus a YAML snippet; AGENTS.md architecture row and key-pattern bullet (skip semantics, validation order) |
+
+## Todos
+1. **conditions-core**: `conditions.py` types (`Branch`, `SwitchTask`, `ConditionTask`, `Guard`, `FirstOfRef`, `when`, `first_of`) and handle sugar in `dependencies.py`.
+2. **workflow-model**: builder `when=` and `first_of` resolution, storage, accessors, topo/sinks/cycles, `build()` copy.
+3. **workflow-validation**: `_validate_guards`, `first_of` type checks, label coverage and `otherwise` rules.
+4. **job-hooks**: `TaskStatus.SKIPPED`, `TaskResult.skip_reason`, `Event.TASK_SKIP`, hook implementations, `ResultTaskSkippedError`.
+5. **runner**: skip evaluation, `first_of`/`collect` resolution with skips, result-skipped failure.
+6. **yaml**: `when`/`first_of` in YAML schema and loader.
+7. **visualization**: Mermaid control edges, switch nodes, `first_of` nodes.
+8. **introspection**: describe JSON and `dependency_spec`.
+9. **definition**: round-trip of `when` and `first_of` in the editable graph form.
+10. **exports-cli**: `__init__` exports; CLI JSON output for skipped tasks.
+11. **example-docs**: example directory, README, AGENTS.md.
+12. **tests**: focused tests in existing files (`test_workflow`, `test_runner`, `test_hooks`, `test_yaml_config`, `test_visualization`, `test_definition`, `test_cli`, `test_workflow_task`) plus `test_conditions.py`. Run `pytest`, `ruff check`, `ruff format`, `mypy taskmaestro`.
+
+## Notes / risks
+- Adding `on_task_skip` to the `runtime_checkable` `Hook` Protocol changes `isinstance(x, Hook)` for third-party hooks that do not subclass `BaseHook`. Check how `Hook` is used. If it is used for isinstance checks, keep the Protocol method optional or document the change.
+- `Branch[L]` is a generic Pydantic model. Check that `_safe_type_name`, JSON schema, and `_is_type_compatible` handle `Literal`/`StrEnum` field annotations. For an `in` check against a `Literal`, compare against `get_args`.
+- A bool `ConditionTask` gives YAML case labels `true`/`false`. YAML parses them as booleans, which matches the `Literal[True, False]` values.
+- `first_of` with a member that comes before the guard in topo order: "first completed in declaration order" stays deterministic.
+- Cross-cutting: `Job.task_results` now contains skipped entries. Check consumers that assume every result is COMPLETED or FAILED (CLI, persistence, examples).
diff --git a/docs/script-tasks.md b/docs/script-tasks.md
new file mode 100644
index 0000000..7b6130c
--- /dev/null
+++ b/docs/script-tasks.md
@@ -0,0 +1,105 @@
+# Script and command tasks (issue #1)
+
+## Problem
+Users need small steps in a workflow: post-processing a result, copying files, or
+calling an existing script or executable. Before this change, each such step needed a
+`Task[I, O]` subclass with its own Pydantic input and output models. Issue #1 asks for
+custom tasks without that overhead. The design follows the proposal in the issue
+comments, with the changes listed under "Decisions".
+
+## Agreed design
+
+### Built-in tasks
+Both tasks are registered in the `taskmaestro.tasks` entry-point group. They appear in
+`taskmaestro tasks list`, and `tasks describe` reports their schemas.
+
+| Task id | Class | Runs |
+|---|---|---|
+| `taskmaestro.python` | `PythonScript` | `<sys.executable> <script> <args...>` in a subprocess |
+| `taskmaestro.command` | `Command` | `command` as a string through the shell, or as a list run directly, without a shell |
+
+Input fields:
+
+| Field | Type | Default | Tasks |
+|---|---|---|---|
+| `script` | path | required | python |
+| `args` | list of str | `[]` | python |
+| `command` | str \| list of str | required | command |
+| `inputs` | `dict[str, Any]` | `{}` | both |
+| `env` | mapping str → str | `{}` | both, added to the inherited environment |
+| `cwd` | path | current dir | both |
+| `timeout` | float > 0 (s) | none | both, kills the process |
+| `check` | bool | `true` | both, fails on a nonzero exit code |
+
+Output (`ScriptOutput`): `result: Any` (the JSON from `$TASKMAESTRO_OUTPUT`, or `null`),
+`returncode`, `stdout`, `stderr`.
+
+### Data exchange
+Each run gets a fresh directory under `ctx.scratch_dir` (`script-*`). The directory is
+kept for debugging.
+
+- `TASKMAESTRO_INPUT` is set only when `inputs` is not empty. It holds the path to
+  `input.json`, which is `inputs` serialized with `pydantic_core.to_json`, so Pydantic
+  models become objects.
+- `TASKMAESTRO_OUTPUT` is always set. The process may write one JSON value there. A
+  missing or empty file gives `result = null`. Invalid JSON fails the task.
+
+### `inputs` is `dict[str, Any]`
+Upstream data is connected with a keyed `collect`:
+`inputs: {collect: {export: [exporter, result]}}`. A `[task, field]` reference whose
+type is `dict[str, ...]` also works. Scripts therefore always receive a JSON object with
+known keys. This type needs no change to the type checker, because keyed collections
+into `dict[str, T]` were already supported.
+
+Alternatives that were rejected:
+- `Any` would accept a whole model, a list or a dict. Collections into `Any` would need a
+  core validation change, and scripts would get an input whose shape varies.
+- `str` would only accept string-typed fields. Most upstream outputs are models.
+
+`result` is `Any`, so it can be connected to any downstream field. The downstream input
+model validates the value at run time.
+
+### Configuration
+The settings are ordinary input fields. They are given per task in `input.yaml`, like
+any other task configuration, and need no new YAML syntax.
+
+The proposal also had a `params:` key on workflow task entries. It would hold fixed
+settings, such as the script path, in `workflow.yaml`. It was left out because it is a
+general YAML feature rather than something scripts need, and it can be proposed
+separately.
+
+### Errors and timeouts
+Failures raise `ScriptError`, a `TaskExecutionError` with `returncode`, `stdout` and
+`stderr`:
+- A missing script is reported before anything runs.
+- Inputs that cannot be converted to JSON fail the task with a message suggesting a
+  regular Task. This applies to runtime-only objects such as `ObjectModel[rips.EclipseCase]`.
+- A process that cannot start (`OSError`) fails the task.
+- A `timeout` kills the process and fails the task.
+- A nonzero exit code with `check: true` fails the task. The message includes the exit
+  code and the last 20 lines of stderr.
+- When a runner or task timeout (`SIGALRM`) fires while a process runs,
+  `subprocess.run` kills and reaps the child before the timeout error propagates.
+
+### Paths
+Absolute paths are used as given. Relative `script` and `cwd` paths resolve against the
+current directory of the process that runs the workflow, not the workflow file's
+directory. `script` is made absolute before the process starts, so `cwd` does not
+affect it. Paths inside `command` or `args` are interpreted by the child process
+in `cwd`.
+
+## Decisions
+- **Function (in-process) mode is postponed.** The proposal had a default `function`
+  mode that calls `main(inputs, options, ctx)` in the workflow's interpreter. That mode
+  could receive live objects. If it is added later, it should be an opt-in `mode`
+  field that defaults to `subprocess`, which keeps existing workflows unchanged.
+- **No `params:` key** (see Configuration).
+- No new dependencies.
+
+## ResInsight integration notes
+- `result` has the empty JSON schema `{}`. ResInsight must accept edges out of a field
+  with that schema.
+- `inputs` is an object schema whose values can be anything. ResInsight connects to it
+  with keyed `collect` edges (`"collect": "dict"`).
+- ResInsight could warn when an opaque (`x-taskmaestro-opaque`) output is collected into
+  `inputs`, since that fails at run time.
diff --git a/examples/conditional_if/input.yaml b/examples/conditional_if/input.yaml
new file mode 100644
index 0000000..1422fb0
--- /dev/null
+++ b/examples/conditional_if/input.yaml
@@ -0,0 +1,7 @@
+# Per-task configuration. Amounts of 10000 or more take the manual-review
+# branch; lower amounts are approved automatically.
+
+load_order:
+  order_id: A-1001
+  customer: Acme
+  amount: 25000
diff --git a/examples/conditional_if/pipeline.py b/examples/conditional_if/pipeline.py
new file mode 100644
index 0000000..108728c
--- /dev/null
+++ b/examples/conditional_if/pipeline.py
@@ -0,0 +1,198 @@
+"""Example: an if/else branch with ``ConditionTask`` and ``first_of``.
+
+Large orders are sent to manual review, the rest are approved automatically.
+Exactly one of the two branches runs; the other is skipped. ``first_of`` joins
+the branches again by taking the decision of whichever branch ran.
+
+                          ┌─ true ── ManualReview ─┐
+    LoadOrder ── IsLarge ◇┤                        ├─ first_of ── Finalize
+                          └─ false ─ AutoApprove ──┘
+
+Run:
+    python examples/conditional_if/pipeline.py
+    python examples/conditional_if/pipeline.py --amount 25000
+    python examples/conditional_if/pipeline.py --yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+from typing import Any, cast
+
+from pydantic import BaseModel
+
+from taskmaestro import (
+    ConditionTask,
+    EmptyConfig,
+    ExecutionContext,
+    Job,
+    JobConfiguration,
+    Runner,
+    Task,
+    TaskStatus,
+    Workflow,
+    first_of,
+)
+from taskmaestro.hooks import LoggingHook
+
+REVIEW_THRESHOLD = 10_000.0
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+
+class OrderInput(BaseModel):
+    """Order supplied as job configuration."""
+
+    order_id: str
+    customer: str
+    amount: float
+
+
+class Order(BaseModel):
+    order_id: str
+    customer: str
+    amount: float
+
+
+class Decision(BaseModel):
+    order_id: str
+    approved: bool
+    reviewer: str
+
+
+class FinalizeInput(BaseModel):
+    order: Order
+    decision: Decision
+
+
+class Receipt(BaseModel):
+    order_id: str
+    status: str
+    reviewer: str
+
+
+# ---------------------------------------------------------------------------
+# Tasks
+# ---------------------------------------------------------------------------
+
+
+class LoadOrder(Task[OrderInput, Order]):
+    name = "load_order"
+
+    def run(self, input: OrderInput, ctx: ExecutionContext) -> Order:
+        return Order(**input.model_dump())
+
+
+class IsLargeOrder(ConditionTask[Order]):
+    """The 'if': True when the order needs a manual review."""
+
+    def decide(self, input: Order, ctx: ExecutionContext) -> bool:
+        return input.amount >= REVIEW_THRESHOLD
+
+
+class ManualReview(Task[Order, Decision]):
+    def run(self, input: Order, ctx: ExecutionContext) -> Decision:
+        ctx.logger.info("Order %s needs manual review", input.order_id)
+        return Decision(order_id=input.order_id, approved=True, reviewer="finance-team")
+
+
+class AutoApprove(Task[Order, Decision]):
+    def run(self, input: Order, ctx: ExecutionContext) -> Decision:
+        return Decision(order_id=input.order_id, approved=True, reviewer="auto")
+
+
+class Finalize(Task[FinalizeInput, Receipt]):
+    def run(self, input: FinalizeInput, ctx: ExecutionContext) -> Receipt:
+        status = "approved" if input.decision.approved else "rejected"
+        return Receipt(
+            order_id=input.order.order_id, status=status, reviewer=input.decision.reviewer
+        )
+
+
+# ---------------------------------------------------------------------------
+# Workflow
+# ---------------------------------------------------------------------------
+
+
+def build_workflow() -> Workflow:
+    builder = Workflow.builder("conditional_if")
+    order = builder.task(LoadOrder, config_fields=["order_id", "customer", "amount"])
+    is_large = builder.task(IsLargeOrder, depends_on=order)
+    manual = builder.task(ManualReview, depends_on=order, when=is_large.if_true())
+    auto = builder.task(AutoApprove, depends_on=order, when=is_large.if_false())
+    builder.task(Finalize, order=order, decision=first_of(manual, auto))
+    return builder.build()
+
+
+def job_configuration(amount: float) -> JobConfiguration:
+    return JobConfiguration(
+        {"load_order": {"order_id": "A-1001", "customer": "Acme", "amount": amount}}
+    )
+
+
+def print_result(result: Job[Any], workflow: Workflow) -> None:
+    print("=" * 60)
+    print("Conditional if/else")
+    print("=" * 60)
+    print(f"Status: {result.status}")
+    if result.error:
+        print(f"Error: {result.error}")
+        return
+    for task_result in result.task_results:
+        marker = "skipped" if task_result.status == TaskStatus.SKIPPED else "ran"
+        print(f"  {task_result.task_name:16s} {marker}")
+    receipt = cast(Receipt, result.result)
+    print(f"Receipt: {receipt.order_id} {receipt.status} by {receipt.reviewer}")
+    print("\nMermaid diagram:")
+    print("```mermaid")
+    print(workflow.to_mermaid(), end="")
+    print("```")
+
+
+def run_python_mode(amount: float) -> None:
+    workflow = build_workflow()
+    result = Runner(hooks=[LoggingHook()]).run(
+        Job(workflow, EmptyConfig(), job_configuration=job_configuration(amount))
+    )
+    print_result(result, workflow)
+
+
+def run_yaml_mode(workflow_path: str, input_path: str) -> None:
+    from taskmaestro.yaml_config import load_workflow_from_yaml
+
+    loaded = load_workflow_from_yaml(workflow_path, input_path)
+    print_result(loaded.run(), loaded.workflow)
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s — %(message)s")
+    example_dir = Path(__file__).resolve().parent
+    parser = argparse.ArgumentParser(description="Conditional if/else example")
+    parser.add_argument("--amount", type=float, default=250.0, help="Order amount")
+    parser.add_argument(
+        "--yaml",
+        metavar="FILE",
+        nargs="?",
+        const=str(example_dir / "workflow.yaml"),
+        help="Load YAML workflow (default: workflow.yaml)",
+    )
+    parser.add_argument(
+        "--input",
+        metavar="FILE",
+        default=str(example_dir / "input.yaml"),
+        help="Input YAML file (default: input.yaml)",
+    )
+    args = parser.parse_args()
+
+    if args.yaml:
+        run_yaml_mode(args.yaml, args.input)
+    else:
+        run_python_mode(args.amount)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/conditional_if/workflow.yaml b/examples/conditional_if/workflow.yaml
new file mode 100644
index 0000000..a0f6d18
--- /dev/null
+++ b/examples/conditional_if/workflow.yaml
@@ -0,0 +1,29 @@
+# If/else branch: IsLargeOrder decides, exactly one review task runs.
+# Run with: python examples/conditional_if/pipeline.py --yaml
+
+workflow:
+  name: conditional_if
+  tasks:
+    - task: pipeline.LoadOrder
+      config_fields: [order_id, customer, amount]
+
+    - task: pipeline.IsLargeOrder
+      depends_on: pipeline.LoadOrder
+
+    - task: pipeline.ManualReview
+      depends_on: pipeline.LoadOrder
+      when: {switch: pipeline.IsLargeOrder, case: true}
+
+    - task: pipeline.AutoApprove
+      depends_on: pipeline.LoadOrder
+      when: {switch: pipeline.IsLargeOrder, case: false}
+
+    - task: pipeline.Finalize
+      depends_on:
+        order: pipeline.LoadOrder
+        decision:
+          first_of: [pipeline.ManualReview, pipeline.AutoApprove]
+
+runner:
+  hooks:
+    - hook: taskmaestro.hooks.logging.LoggingHook
diff --git a/examples/conditional_switch/input.yaml b/examples/conditional_switch/input.yaml
new file mode 100644
index 0000000..74680d0
--- /dev/null
+++ b/examples/conditional_switch/input.yaml
@@ -0,0 +1,8 @@
+# Per-task configuration. Parcels over 100 kg go by freight, priority parcels
+# by express, everything else by standard shipping.
+
+load_parcel:
+  parcel_id: P-42
+  weight_kg: 150
+  priority: false
+  destination: Bergen
diff --git a/examples/conditional_switch/pipeline.py b/examples/conditional_switch/pipeline.py
new file mode 100644
index 0000000..4435a0e
--- /dev/null
+++ b/examples/conditional_switch/pipeline.py
@@ -0,0 +1,225 @@
+"""Example: a multi-way switch with ``SwitchTask``, ``otherwise()`` and ``first_of``.
+
+``ChooseShipping`` returns one of four labels. Each shipping task is guarded by
+the labels it handles; ``otherwise()`` catches every label that no other task
+claims (here ``standard`` and ``economy``). ``first_of`` joins the branches.
+
+                                   ┌─ express ──── ExpressShipping ──┐
+    LoadParcel ── ChooseShipping ◇─┼─ freight ──── FreightShipping ──┼─ first_of ── PrintLabel
+                                   └─ otherwise ── StandardShipping ─┘
+
+Run:
+    python examples/conditional_switch/pipeline.py
+    python examples/conditional_switch/pipeline.py --weight 120
+    python examples/conditional_switch/pipeline.py --priority
+    python examples/conditional_switch/pipeline.py --yaml
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+from pathlib import Path
+from typing import Any, Literal, cast
+
+from pydantic import BaseModel
+
+from taskmaestro import (
+    EmptyConfig,
+    ExecutionContext,
+    Job,
+    JobConfiguration,
+    Runner,
+    SwitchTask,
+    Task,
+    TaskStatus,
+    Workflow,
+    first_of,
+)
+from taskmaestro.hooks import LoggingHook
+
+ShippingMethod = Literal["express", "freight", "standard", "economy"]
+
+# ---------------------------------------------------------------------------
+# Models
+# ---------------------------------------------------------------------------
+
+
+class ParcelInput(BaseModel):
+    """Parcel supplied as job configuration."""
+
+    parcel_id: str
+    weight_kg: float
+    priority: bool = False
+    destination: str
+
+
+class Parcel(BaseModel):
+    parcel_id: str
+    weight_kg: float
+    priority: bool
+    destination: str
+
+
+class Shipment(BaseModel):
+    parcel_id: str
+    carrier: str
+    days: int
+    cost: float
+
+
+class LabelInput(BaseModel):
+    parcel: Parcel
+    shipment: Shipment
+
+
+class ShippingLabel(BaseModel):
+    text: str
+
+
+# ---------------------------------------------------------------------------
+# Tasks
+# ---------------------------------------------------------------------------
+
+
+class LoadParcel(Task[ParcelInput, Parcel]):
+    name = "load_parcel"
+
+    def run(self, input: ParcelInput, ctx: ExecutionContext) -> Parcel:
+        return Parcel(**input.model_dump())
+
+
+class ChooseShipping(SwitchTask[Parcel, ShippingMethod]):
+    """The 'switch': returns the label of the branch to run."""
+
+    def decide(self, input: Parcel, ctx: ExecutionContext) -> ShippingMethod:
+        if input.weight_kg > 100:
+            return "freight"
+        if input.priority:
+            return "express"
+        if input.weight_kg < 1:
+            return "economy"
+        return "standard"
+
+
+class ExpressShipping(Task[Parcel, Shipment]):
+    def run(self, input: Parcel, ctx: ExecutionContext) -> Shipment:
+        return Shipment(parcel_id=input.parcel_id, carrier="AirFast", days=1, cost=49.0)
+
+
+class FreightShipping(Task[Parcel, Shipment]):
+    def run(self, input: Parcel, ctx: ExecutionContext) -> Shipment:
+        cost = 2.5 * input.weight_kg
+        return Shipment(parcel_id=input.parcel_id, carrier="HeavyHaul", days=7, cost=cost)
+
+
+class StandardShipping(Task[Parcel, Shipment]):
+    def run(self, input: Parcel, ctx: ExecutionContext) -> Shipment:
+        return Shipment(parcel_id=input.parcel_id, carrier="PostNord", days=3, cost=9.0)
+
+
+class PrintLabel(Task[LabelInput, ShippingLabel]):
+    def run(self, input: LabelInput, ctx: ExecutionContext) -> ShippingLabel:
+        shipment = input.shipment
+        return ShippingLabel(
+            text=(
+                f"{input.parcel.parcel_id} -> {input.parcel.destination} via "
+                f"{shipment.carrier} ({shipment.days} days, {shipment.cost:.2f} EUR)"
+            )
+        )
+
+
+# ---------------------------------------------------------------------------
+# Workflow
+# ---------------------------------------------------------------------------
+
+
+def build_workflow() -> Workflow:
+    builder = Workflow.builder("conditional_switch")
+    parcel = builder.task(
+        LoadParcel, config_fields=["parcel_id", "weight_kg", "priority", "destination"]
+    )
+    method = builder.task(ChooseShipping, depends_on=parcel)
+    express = builder.task(ExpressShipping, depends_on=parcel, when=method.on("express"))
+    freight = builder.task(FreightShipping, depends_on=parcel, when=method.on("freight"))
+    standard = builder.task(StandardShipping, depends_on=parcel, when=method.otherwise())
+    builder.task(PrintLabel, parcel=parcel, shipment=first_of(express, freight, standard))
+    return builder.build()
+
+
+def job_configuration(weight_kg: float, priority: bool) -> JobConfiguration:
+    return JobConfiguration(
+        {
+            "load_parcel": {
+                "parcel_id": "P-42",
+                "weight_kg": weight_kg,
+                "priority": priority,
+                "destination": "Bergen",
+            }
+        }
+    )
+
+
+def print_result(result: Job[Any], workflow: Workflow) -> None:
+    print("=" * 60)
+    print("Conditional switch")
+    print("=" * 60)
+    print(f"Status: {result.status}")
+    if result.error:
+        print(f"Error: {result.error}")
+        return
+    for task_result in result.task_results:
+        marker = "skipped" if task_result.status == TaskStatus.SKIPPED else "ran"
+        print(f"  {task_result.task_name:18s} {marker}")
+    label = cast(ShippingLabel, result.result)
+    print(f"Label: {label.text}")
+    print("\nMermaid diagram:")
+    print("```mermaid")
+    print(workflow.to_mermaid(), end="")
+    print("```")
+
+
+def run_python_mode(weight_kg: float, priority: bool) -> None:
+    workflow = build_workflow()
+    result = Runner(hooks=[LoggingHook()]).run(
+        Job(workflow, EmptyConfig(), job_configuration=job_configuration(weight_kg, priority))
+    )
+    print_result(result, workflow)
+
+
+def run_yaml_mode(workflow_path: str, input_path: str) -> None:
+    from taskmaestro.yaml_config import load_workflow_from_yaml
+
+    loaded = load_workflow_from_yaml(workflow_path, input_path)
+    print_result(loaded.run(), loaded.workflow)
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(name)s — %(message)s")
+    example_dir = Path(__file__).resolve().parent
+    parser = argparse.ArgumentParser(description="Conditional switch example")
+    parser.add_argument("--weight", type=float, default=4.0, help="Parcel weight in kg")
+    parser.add_argument("--priority", action="store_true", help="Request priority shipping")
+    parser.add_argument(
+        "--yaml",
+        metavar="FILE",
+        nargs="?",
+        const=str(example_dir / "workflow.yaml"),
+        help="Load YAML workflow (default: workflow.yaml)",
+    )
+    parser.add_argument(
+        "--input",
+        metavar="FILE",
+        default=str(example_dir / "input.yaml"),
+        help="Input YAML file (default: input.yaml)",
+    )
+    args = parser.parse_args()
+
+    if args.yaml:
+        run_yaml_mode(args.yaml, args.input)
+    else:
+        run_python_mode(args.weight, args.priority)
+
+
+if __name__ == "__main__":
+    main()
diff --git a/examples/conditional_switch/workflow.yaml b/examples/conditional_switch/workflow.yaml
new file mode 100644
index 0000000..f24702b
--- /dev/null
+++ b/examples/conditional_switch/workflow.yaml
@@ -0,0 +1,37 @@
+# Multi-way switch: ChooseShipping returns a label, the matching branch runs.
+# Run with: python examples/conditional_switch/pipeline.py --yaml
+
+workflow:
+  name: conditional_switch
+  tasks:
+    - task: pipeline.LoadParcel
+      config_fields: [parcel_id, weight_kg, priority, destination]
+
+    - task: pipeline.ChooseShipping
+      depends_on: pipeline.LoadParcel
+
+    - task: pipeline.ExpressShipping
+      depends_on: pipeline.LoadParcel
+      when: {switch: pipeline.ChooseShipping, case: express}
+
+    - task: pipeline.FreightShipping
+      depends_on: pipeline.LoadParcel
+      when: {switch: pipeline.ChooseShipping, case: freight}
+
+    # Runs for every label not claimed above: standard and economy.
+    - task: pipeline.StandardShipping
+      depends_on: pipeline.LoadParcel
+      when: {switch: pipeline.ChooseShipping, otherwise: true}
+
+    - task: pipeline.PrintLabel
+      depends_on:
+        parcel: pipeline.LoadParcel
+        shipment:
+          first_of:
+            - pipeline.ExpressShipping
+            - pipeline.FreightShipping
+            - pipeline.StandardShipping
+
+runner:
+  hooks:
+    - hook: taskmaestro.hooks.logging.LoggingHook
diff --git a/examples/scripts/input.yaml b/examples/scripts/input.yaml
new file mode 100644
index 0000000..2902d62
--- /dev/null
+++ b/examples/scripts/input.yaml
@@ -0,0 +1,8 @@
+word_count:
+  script: examples/scripts/word_count.py
+  args: [examples/scripts/sample.txt, "5"]
+count_bytes:
+  command: [wc, -c, examples/scripts/sample.txt]
+save_report:
+  command: sh examples/scripts/save_report.sh
+  env: {REPORT_DIR: /tmp/taskmaestro-script-tasks}
diff --git a/examples/scripts/sample.txt b/examples/scripts/sample.txt
new file mode 100644
index 0000000..b42662d
--- /dev/null
+++ b/examples/scripts/sample.txt
@@ -0,0 +1,3 @@
+Taskmaestro runs typed tasks in a workflow.
+A script task runs a script, and a command task runs a command.
+Tasks pass JSON to scripts and scripts pass JSON back to tasks.
diff --git a/examples/scripts/save_report.sh b/examples/scripts/save_report.sh
new file mode 100644
index 0000000..698d162
--- /dev/null
+++ b/examples/scripts/save_report.sh
@@ -0,0 +1,9 @@
+#!/bin/sh
+# Run by the taskmaestro.command task. Upstream data is in $TASKMAESTRO_INPUT
+# (JSON); the path of the saved report is returned through $TASKMAESTRO_OUTPUT.
+set -eu
+mkdir -p "$REPORT_DIR"
+report="$REPORT_DIR/word_count.json"
+cp "$TASKMAESTRO_INPUT" "$report"
+printf '{"report": "%s"}' "$report" > "$TASKMAESTRO_OUTPUT"
+echo "Saved $report"
diff --git a/examples/scripts/word_count.py b/examples/scripts/word_count.py
new file mode 100644
index 0000000..783b342
--- /dev/null
+++ b/examples/scripts/word_count.py
@@ -0,0 +1,32 @@
+"""Count the words in a text file and return the most common ones.
+
+Run by the ``taskmaestro.python`` task: arguments come from ``args`` and the
+result is written as JSON to ``$TASKMAESTRO_OUTPUT``. Taskmaestro is not imported.
+"""
+
+import json
+import os
+import sys
+from collections import Counter
+
+path = sys.argv[1]
+top = int(sys.argv[2]) if len(sys.argv) > 2 else 3
+
+with open(path, encoding="utf-8") as f:
+    text = f.read()
+words = [word.strip(".,;:!?\"'()").lower() for word in text.split()]
+words = [word for word in words if word]
+if not words:
+    print(f"No words in {path}", file=sys.stderr)
+    sys.exit(1)  # Fails the task (check: true).
+
+with open(os.environ["TASKMAESTRO_OUTPUT"], "w", encoding="utf-8") as f:
+    json.dump(
+        {
+            "words": len(words),
+            "lines": len(text.splitlines()),
+            "top_words": [word for word, _count in Counter(words).most_common(top)],
+        },
+        f,
+    )
+print(f"Counted {len(words)} words in {path}")
diff --git a/examples/scripts/workflow.yaml b/examples/scripts/workflow.yaml
new file mode 100644
index 0000000..1bc8967
--- /dev/null
+++ b/examples/scripts/workflow.yaml
@@ -0,0 +1,25 @@
+# Script and command tasks: no Task classes needed. Their settings (script,
+# args, command, env, ...) are ordinary input fields, given in input.yaml.
+# Run from the repository root (relative paths resolve against the current directory):
+#   taskmaestro run examples/scripts/workflow.yaml --input examples/scripts/input.yaml
+
+workflow:
+  name: script_tasks
+  tasks:
+    # Python file run in a subprocess.
+    - task: taskmaestro.python
+      name: word_count
+
+    # Executable with arguments (list form: no shell, no quoting issues).
+    - task: taskmaestro.command
+      name: count_bytes
+
+    # Shell script (string form: runs through the shell). Upstream data
+    # arrives as one JSON object in $TASKMAESTRO_INPUT.
+    - task: taskmaestro.command
+      name: save_report
+      depends_on:
+        inputs:
+          collect:
+            counts: [word_count, result]
+            wc_output: [count_bytes, stdout]
diff --git a/pyproject.toml b/pyproject.toml
index 9409bb4..d4f9380 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -31,6 +31,13 @@ dependencies = [
 [project.scripts]
 taskmaestro = "taskmaestro.cli:main"
 
+[project.entry-points."taskmaestro.tasks"]
+"condition.compare" = "taskmaestro.condition_tasks:Compare"
+"condition.is_true" = "taskmaestro.condition_tasks:IsTrue"
+"condition.path_exists" = "taskmaestro.condition_tasks:PathExists"
+"taskmaestro.command" = "taskmaestro.scripts:Command"
+"taskmaestro.python" = "taskmaestro.scripts:PythonScript"
+
 [project.urls]
 Homepage = "https://github.com/OPM/taskmaestro"
 Repository = "https://github.com/OPM/taskmaestro"
diff --git a/taskmaestro/__init__.py b/taskmaestro/__init__.py
index 305d178..811ad15 100644
--- a/taskmaestro/__init__.py
+++ b/taskmaestro/__init__.py
@@ -2,8 +2,17 @@
 
 __version__ = "0.4.0"
 
+from taskmaestro.conditions import (
+    Branch,
+    Condition,
+    ConditionTask,
+    ContextFlag,
+    ContextFlagInput,
+    SwitchTask,
+    when,
+)
 from taskmaestro.context import ExecutionContext
-from taskmaestro.dependencies import OutputHandle, TaskHandle, collect
+from taskmaestro.dependencies import OutputHandle, TaskHandle, collect, first_of
 from taskmaestro.discovery import (
     TASK_ENTRY_POINT_GROUP,
     WORKFLOW_ENTRY_POINT_GROUP,
@@ -16,12 +25,15 @@
 )
 from taskmaestro.exceptions import (
     ConfigLoadError,
+    ContextValueMissingError,
     CycleDetectedError,
     DefinitionError,
     IncompleteInputError,
     JobStateError,
     MappedTaskExecutionError,
     PluginLoadError,
+    ResultTaskSkippedError,
+    ScriptError,
     TaskExecutionError,
     TaskOutputTypeError,
     TaskTimeoutError,
@@ -34,6 +46,13 @@
 from taskmaestro.mapping import MappedOutput, TaskMap
 from taskmaestro.object_model import ObjectModel
 from taskmaestro.runner import HookError, Runner
+from taskmaestro.scripts import (
+    Command,
+    CommandInput,
+    PythonScript,
+    PythonScriptInput,
+    ScriptOutput,
+)
 from taskmaestro.task import Task
 from taskmaestro.visualization import to_mermaid
 from taskmaestro.workflow import Workflow, WorkflowBuilder
@@ -48,7 +67,15 @@
 __all__ = [
     "TASK_ENTRY_POINT_GROUP",
     "WORKFLOW_ENTRY_POINT_GROUP",
+    "Branch",
+    "Command",
+    "CommandInput",
+    "Condition",
+    "ConditionTask",
     "ConfigLoadError",
+    "ContextFlag",
+    "ContextFlagInput",
+    "ContextValueMissingError",
     "CycleDetectedError",
     "DefinitionError",
     "EmptyConfig",
@@ -65,7 +92,13 @@
     "ObjectModel",
     "OutputHandle",
     "PluginLoadError",
+    "PythonScript",
+    "PythonScriptInput",
+    "ResultTaskSkippedError",
     "Runner",
+    "ScriptError",
+    "ScriptOutput",
+    "SwitchTask",
     "Task",
     "TaskExecutionError",
     "TaskHandle",
@@ -81,6 +114,7 @@
     "WorkflowRunnerError",
     "WorkflowTaskError",
     "collect",
+    "first_of",
     "get_registered_task",
     "get_registered_workflow",
     "load_registered_workflow",
@@ -91,5 +125,6 @@
     "registered_workflows",
     "run_workflow_from_yaml",
     "to_mermaid",
+    "when",
     "workflow_task",
 ]
diff --git a/taskmaestro/cli.py b/taskmaestro/cli.py
index a740af0..0ca3d15 100644
--- a/taskmaestro/cli.py
+++ b/taskmaestro/cli.py
@@ -18,7 +18,12 @@
     registered_task_names,
     registered_workflow_names,
 )
-from taskmaestro.exceptions import ConfigLoadError, PluginLoadError, WorkflowLookupError
+from taskmaestro.exceptions import (
+    ConfigLoadError,
+    ContextValueMissingError,
+    PluginLoadError,
+    WorkflowLookupError,
+)
 from taskmaestro.introspection import (
     TaskSchemaGenerator,
     dependency_spec,
@@ -302,6 +307,18 @@ def main(argv: Sequence[str] | None = None) -> int:
     except PluginLoadError as exc:
         print(f"Plugin error: {exc}", file=sys.stderr)
         return 2
+    except ContextValueMissingError as exc:
+        # Raised by Runner.run before any task starts. The message only names
+        # context keys and tasks, so it is safe to report.
+        if getattr(args, "json", False):
+            print(
+                json.dumps(
+                    {"status": "invalid", "error": _error("configuration_error", exc, str(exc))}
+                )
+            )
+        else:
+            print(f"Configuration error: {exc}", file=sys.stderr)
+        return 2
 
 
 if __name__ == "__main__":
diff --git a/taskmaestro/condition_tasks.py b/taskmaestro/condition_tasks.py
new file mode 100644
index 0000000..7814bf7
--- /dev/null
+++ b/taskmaestro/condition_tasks.py
@@ -0,0 +1,84 @@
+"""Ready-made condition tasks, registered as ``condition.*`` task plugins.
+
+They make simple ``if`` branches possible without writing a task: wire an
+upstream output into the condition and guard tasks with ``if_true()`` /
+``if_false()`` (``case: true|false`` in YAML).
+"""
+
+from __future__ import annotations
+
+import operator
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any, Literal
+
+from pydantic import BaseModel, Field
+
+from taskmaestro.conditions import ConditionTask
+from taskmaestro.context import ExecutionContext
+
+type CompareOp = Literal["<", "<=", "==", "!=", ">=", ">"]
+
+_OPERATORS: dict[str, Callable[[Any, Any], bool]] = {
+    "<": operator.lt,
+    "<=": operator.le,
+    "==": operator.eq,
+    "!=": operator.ne,
+    ">=": operator.ge,
+    ">": operator.gt,
+}
+
+
+class CompareInput(BaseModel):
+    """Input of :class:`Compare`."""
+
+    value: int | float = Field(description="Value to compare")
+    op: CompareOp = Field(default=">=", description="Comparison operator")
+    threshold: float = Field(description="Value to compare against")
+
+
+class Compare(ConditionTask[CompareInput]):
+    """``True`` when ``value <op> threshold`` holds, e.g. ``value >= 100``."""
+
+    name = "compare"
+
+    def decide(self, input: CompareInput, ctx: ExecutionContext) -> bool:
+        return _OPERATORS[input.op](input.value, input.threshold)
+
+
+class IsTrueInput(BaseModel):
+    """Input of :class:`IsTrue`."""
+
+    value: Any = Field(description="Value to test")
+
+
+class IsTrue(ConditionTask[IsTrueInput]):
+    """``True`` when ``value`` is truthy (not ``False``, ``None``, zero or empty)."""
+
+    name = "is_true"
+
+    def decide(self, input: IsTrueInput, ctx: ExecutionContext) -> bool:
+        return bool(input.value)
+
+
+class PathExistsInput(BaseModel):
+    """Input of :class:`PathExists`."""
+
+    path: Path = Field(description="File or directory to look for")
+    kind: Literal["any", "file", "directory"] = Field(
+        default="any", description="Kind of path that must exist"
+    )
+
+
+class PathExists(ConditionTask[PathExistsInput]):
+    """``True`` when ``path`` exists (and is a file or directory if ``kind`` says so)."""
+
+    name = "path_exists"
+
+    def decide(self, input: PathExistsInput, ctx: ExecutionContext) -> bool:
+        path = input.path.expanduser()
+        if input.kind == "file":
+            return path.is_file()
+        if input.kind == "directory":
+            return path.is_dir()
+        return path.exists()
diff --git a/taskmaestro/conditions.py b/taskmaestro/conditions.py
new file mode 100644
index 0000000..1cc55d5
--- /dev/null
+++ b/taskmaestro/conditions.py
@@ -0,0 +1,248 @@
+"""Conditional execution: switch tasks, branch labels and task guards.
+
+A *guard* (``when=`` on a task) is a control edge: it orders the guarded task
+after its source and decides at runtime whether the task runs. It carries no
+data; the guarded task still receives its input through ``depends_on``.
+"""
+
+from __future__ import annotations
+
+import enum
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any, ClassVar, Generic, Literal, TypeVar, get_args, get_origin
+
+from pydantic import BaseModel, create_model
+
+from taskmaestro.context import ExecutionContext
+from taskmaestro.dependencies import OutputRef, OutputReference
+from taskmaestro.task import Task, get_output_type
+
+I = TypeVar("I", bound=BaseModel)
+L = TypeVar("L")
+
+type GuardOp = Literal["in", "truthy", "falsy", "otherwise"]
+
+#: Output field of a switch task holding the selected branch label.
+BRANCH_FIELD = "branch"
+
+
+class Branch(BaseModel):
+    """Output of a :class:`SwitchTask`: the label of the selected branch.
+
+    Every concrete switch task gets its own subclass whose ``branch`` field is
+    annotated with the switch's label type.
+    """
+
+    branch: Any
+
+
+def branch_labels(label_type: Any) -> tuple[Any, ...]:
+    """Return the labels declared by a switch label type.
+
+    ``bool``, ``Literal[...]`` and :class:`enum.Enum` subclasses are supported.
+    """
+    if label_type is bool:
+        return (True, False)
+    if get_origin(label_type) is Literal:
+        return get_args(label_type)
+    if isinstance(label_type, type) and issubclass(label_type, enum.Enum):
+        return tuple(label_type)
+    raise TypeError(f"Switch label type must be bool, Literal[...] or an Enum, got {label_type!r}")
+
+
+def plain_label(value: Any) -> Any:
+    """Return a label as plain JSON/YAML data (enum members become their values)."""
+    return value.value if isinstance(value, enum.Enum) else value
+
+
+def _resolve_label_type(cls: type[Any]) -> Any | None:
+    """Find the concrete ``L`` of ``SwitchTask[I, L]`` in *cls*'s bases.
+
+    Type variables are substituted through intermediate generic subclasses,
+    so ``class Concrete(MySwitch[Literal["a", "b"]])`` resolves its labels
+    even when ``MySwitch`` itself is still generic in ``L``.
+    """
+    label = _label_from_bases(cls, {})
+    return None if isinstance(label, TypeVar) else label
+
+
+def _label_from_bases(cls: type[Any], substitutions: dict[Any, Any]) -> Any | None:
+    for base in cls.__dict__.get("__orig_bases__", cls.__bases__):
+        origin = get_origin(base) or base
+        if not (isinstance(origin, type) and issubclass(origin, SwitchTask)):
+            continue
+        args = tuple(
+            substitutions.get(arg, arg) if isinstance(arg, TypeVar) else arg
+            for arg in get_args(base)
+        )
+        if origin is SwitchTask:
+            label = args[1] if len(args) == 2 else None
+        else:
+            parameters = getattr(origin, "__parameters__", ())
+            label = _label_from_bases(origin, dict(zip(parameters, args, strict=False)))
+        if label is not None:
+            return label
+    return None
+
+
+class SwitchTask(Task[I, Branch], Generic[I, L]):
+    """A task that selects which branch of a workflow runs.
+
+    Subclass ``SwitchTask[InputModel, Literal["a", "b"]]`` (or a ``StrEnum``)
+    and implement :meth:`decide`. The task's output is a ``Branch`` model whose
+    ``branch`` field holds the returned label. Guard downstream tasks with
+    ``handle.on("a")`` or ``handle.otherwise()``.
+    """
+
+    #: The labels this switch can select, in declaration order.
+    branches: ClassVar[tuple[Any, ...]] = ()
+
+    def __init_subclass__(cls, **kwargs: object) -> None:
+        super().__init_subclass__(**kwargs)
+        label_type = _resolve_label_type(cls)
+        if label_type is None:
+            return
+        cls.branches = branch_labels(label_type)
+        if "Outputs" not in cls.__dict__:
+            outputs = create_model(
+                f"{cls.__name__}Branch",
+                __base__=Branch,
+                __module__=cls.__module__,
+                branch=(label_type, ...),
+            )
+            cls.Outputs = outputs  # type: ignore[attr-defined]
+
+    @abstractmethod
+    def decide(self, input: I, ctx: ExecutionContext) -> L:
+        """Return the label of the branch to run."""
+        ...
+
+    def run(self, input: I, ctx: ExecutionContext) -> Branch:
+        label = self.decide(input, ctx)
+        return get_output_type(type(self)).model_validate({BRANCH_FIELD: label})  # type: ignore[return-value]
+
+
+class ConditionTask(SwitchTask[I, bool], Generic[I]):
+    """A two-way switch: :meth:`decide` returns ``True`` or ``False``.
+
+    Guard downstream tasks with ``handle.if_true()`` and ``handle.if_false()``.
+    """
+
+    @abstractmethod
+    def decide(self, input: I, ctx: ExecutionContext) -> bool:
+        """Return whether the condition holds."""
+        ...
+
+
+class ContextFlagInput(BaseModel):
+    """Configuration of a :class:`ContextFlag`: the context service key to read."""
+
+    key: str
+
+
+class ContextFlag(ConditionTask[ContextFlagInput]):
+    """Condition that is ``True`` when the context value under ``key`` is truthy.
+
+    Add it with ``config_fields=["key"]`` and set ``key`` in the job
+    configuration. ``Runner.run`` checks that every configured key is
+    registered on the execution context before any task runs.
+    """
+
+    def decide(self, input: ContextFlagInput, ctx: ExecutionContext) -> bool:
+        return bool(ctx.resolve(input.key))
+
+
+def is_switch_task(task_cls: type[Any]) -> bool:
+    """Return whether *task_cls* is a concrete switch task."""
+    return (
+        isinstance(task_cls, type) and issubclass(task_cls, SwitchTask) and bool(task_cls.branches)
+    )
+
+
+@dataclass(frozen=True)
+class Condition:
+    """An unresolved guard, created by :func:`when` or handle helpers such as ``on()``."""
+
+    source: OutputReference
+    op: GuardOp
+    values: tuple[Any, ...] = ()
+
+
+@dataclass(frozen=True)
+class Guard:
+    """A resolved guard: the referenced output field and the predicate on its value.
+
+    For ``otherwise`` guards, ``values`` holds the switch labels that no other
+    guard on the same switch claims; it is filled in during validation.
+    """
+
+    ref: OutputRef
+    op: GuardOp
+    values: tuple[Any, ...] = ()
+
+    def matches(self, value: Any) -> bool:
+        """Return whether the guarded task runs for the source *value*.
+
+        ``truthy``/``falsy`` test a ``bool`` value directly; any other value
+        counts as truthy when it is set (not ``None``), so ``0``, ``""`` or an
+        empty list in an optional field still count as present.
+        """
+        if self.op == "truthy":
+            return _is_set(value)
+        if self.op == "falsy":
+            return not _is_set(value)
+        return value in self.values
+
+    def describe(self) -> str:
+        """Return a short human-readable form, used in skip reasons."""
+        source = f"{self.ref.task_name}.{self.ref.output_field}"
+        if self.op == "truthy":
+            return source
+        if self.op == "falsy":
+            return f"not {source}"
+        labels = ", ".join(repr(plain_label(value)) for value in self.values)
+        if self.op == "otherwise":
+            return f"{source} otherwise ({labels})"
+        return f"{source} in [{labels}]"
+
+
+def _is_set(value: Any) -> bool:
+    """Truthiness used by guards: a ``bool`` itself, otherwise ``value is not None``."""
+    if isinstance(value, bool):
+        return value
+    return value is not None
+
+
+_MISSING: Any = object()
+
+
+def when(
+    source: OutputReference,
+    *,
+    equals: Any = _MISSING,
+    in_: Any = None,
+    truthy: bool | None = None,
+) -> Condition:
+    """Guard a task on an upstream output field.
+
+    Pass exactly one of ``equals=`` (value equality), ``in_=`` (one of several
+    values) or ``truthy=`` (``True`` runs the task when the value is ``True``
+    or, for non-bool fields, set to anything but ``None``; ``False`` runs it
+    otherwise). ``source`` is an output field reference such
+    as ``handle.field("kind")`` or ``(task, "kind")``; a switch task may be
+    referenced as a whole.
+    """
+    given = [equals is not _MISSING, in_ is not None, truthy is not None]
+    if sum(given) != 1:
+        raise TypeError("when() takes exactly one of equals=, in_= or truthy=")
+    if equals is not _MISSING:
+        return Condition(source, "in", (equals,))
+    if in_ is not None:
+        if isinstance(in_, str | bytes):
+            raise TypeError("when(in_=...) takes a collection of values, not a string")
+        values = tuple(in_)
+        if not values:
+            raise TypeError("when(in_=...) needs at least one value")
+        return Condition(source, "in", values)
+    return Condition(source, "truthy" if truthy else "falsy")
diff --git a/taskmaestro/context.py b/taskmaestro/context.py
index 80a9ff3..02875d3 100644
--- a/taskmaestro/context.py
+++ b/taskmaestro/context.py
@@ -37,6 +37,10 @@ def register(self, key: str, service: Any) -> None:
         """Register a service by key."""
         self._registry[key] = service
 
+    def has(self, key: str) -> bool:
+        """Return whether a service is registered under *key*."""
+        return key in self._registry
+
     def resolve(self, key: str) -> Any:
         """Retrieve a registered service. Raises KeyError if not found."""
         return self._registry[key]
diff --git a/taskmaestro/definition.py b/taskmaestro/definition.py
index caf31e1..e414ae7 100644
--- a/taskmaestro/definition.py
+++ b/taskmaestro/definition.py
@@ -232,7 +232,9 @@ def _field_reference(raw: Any, task: str, field: str | None) -> tuple[str, str |
 def _load_edges(definition: dict[str, Any], config: Any, candidates: dict[str, set[str]]) -> None:
     entries = config.workflow.tasks
     nodes = definition["nodes"]
-    linear = all(entry.depends_on is None and entry.map is None for entry in entries)
+    linear = all(
+        entry.depends_on is None and entry.map is None and entry.when is None for entry in entries
+    )
     if linear:
         for previous, node in pairwise(nodes):
             definition["edges"].append(_edge(previous["name"], None, node["name"], None))
@@ -245,6 +247,8 @@ def _load_edges(definition: dict[str, Any], config: Any, candidates: dict[str, s
 
     for entry, node in zip(entries, nodes, strict=True):
         name = node["name"]
+        if entry.when is not None:
+            node["when"] = _load_when(entry.when, candidates, name)
         deps = entry.depends_on
         if deps is None:
             continue
@@ -253,6 +257,9 @@ def _load_edges(definition: dict[str, Any], config: Any, candidates: dict[str, s
                 if isinstance(raw, dict) and set(raw) == {"collect"}:
                     _load_collect(definition, candidates, raw["collect"], name, field)
                     continue
+                if isinstance(raw, dict) and set(raw) == {"first_of"}:
+                    _load_first_of(definition, candidates, raw["first_of"], name, field)
+                    continue
                 ref, output = _field_reference(raw, name, field)
                 upstream = _resolve_reference(candidates, ref, name)
                 definition["edges"].append(_edge(upstream, output, name, field))
@@ -262,6 +269,41 @@ def _load_edges(definition: dict[str, Any], config: Any, candidates: dict[str, s
         definition["edges"].append(_edge(upstream, output, name, None))
 
 
+def _load_when(when: Any, candidates: dict[str, set[str]], name: str) -> dict[str, Any]:
+    """Return a node's ``when`` in YAML form, with task references resolved."""
+    document = _jsonable(when.model_dump(by_alias=True, exclude_unset=True), name)
+    if "switch" in document:
+        document["switch"] = _resolve_reference(candidates, document["switch"], name)
+    else:
+        ref = document["ref"]
+        if isinstance(ref, list):
+            document["ref"] = [_resolve_reference(candidates, ref[0], name), ref[1]]
+        else:
+            document["ref"] = _resolve_reference(candidates, ref, name)
+    return dict(document)
+
+
+def _load_first_of(
+    definition: dict[str, Any],
+    candidates: dict[str, set[str]],
+    members: Any,
+    name: str,
+    field: str,
+) -> None:
+    if not isinstance(members, list):
+        raise DefinitionError(
+            f"'first_of' for field '{field}' on task '{name}' must be a list",
+            task=name,
+            field=field,
+        )
+    for member in members:
+        ref, output = _field_reference(member, name, field)
+        upstream = _resolve_reference(candidates, ref, name)
+        definition["edges"].append(
+            _edge(upstream, output, name, field, collect="first_of", key=None)
+        )
+
+
 def _load_collect(
     definition: dict[str, Any],
     candidates: dict[str, set[str]],
@@ -435,7 +477,7 @@ def definition_from_workflow(
 
     ``class_ids`` maps registered task classes to their entry-point names.
     """
-    from taskmaestro.dependencies import CollectionRef
+    from taskmaestro.dependencies import CollectionRef, FirstOfRef
 
     definition = _empty_definition(workflow.name)
     definition["source"]["registered_id"] = registered_id
@@ -463,6 +505,10 @@ def definition_from_workflow(
         task_map = workflow.get_task_map(name)
         if task_map is not None:
             node["map"] = _map_json(task_map)
+        guard = workflow.get_guard(name)
+        if guard is not None:
+            node["when"] = _guard_document(workflow, guard)
+            has_dependents.add(guard.ref.task_name)
         definition["nodes"].append(node)
         definition["inputs"][name] = {}
 
@@ -493,6 +539,18 @@ def definition_from_workflow(
                                 key=key,
                             )
                         )
+                elif isinstance(ref, FirstOfRef):
+                    for member in ref.members:
+                        definition["edges"].append(
+                            _edge(
+                                member.task_name,
+                                member.output_field,
+                                name,
+                                field,
+                                collect="first_of",
+                                key=None,
+                            )
+                        )
                 elif isinstance(ref, tuple):
                     definition["edges"].append(_edge(ref[0], ref[1], name, field))
                 else:
@@ -514,6 +572,27 @@ def definition_from_workflow(
     return definition
 
 
+def _guard_document(workflow: Any, guard: Any) -> dict[str, Any]:
+    """Return the YAML form of a resolved guard."""
+    from taskmaestro.conditions import BRANCH_FIELD, plain_label
+
+    source = guard.ref.task_name
+    values = [plain_label(value) for value in guard.values]
+    if workflow.is_switch(source) and guard.ref.output_field == BRANCH_FIELD:
+        if guard.op == "otherwise":
+            return {"switch": source, "otherwise": True}
+        if guard.op == "in":
+            return {"switch": source, "case": values[0] if len(values) == 1 else values}
+    document: dict[str, Any] = {"ref": [source, guard.ref.output_field]}
+    if guard.op in ("truthy", "falsy"):
+        document["truthy"] = guard.op == "truthy"
+    elif len(values) == 1:
+        document["equals"] = values[0]
+    else:
+        document["in"] = values
+    return document
+
+
 # --- Saving YAML ---
 
 
@@ -571,6 +650,22 @@ def _check_saveable(definition: dict[str, Any]) -> None:
         for end in ("from", "to"):
             if edge.get(end) not in names:
                 raise DefinitionError(f"Connection refers to unknown task '{edge.get(end)}'")
+    for node in nodes:
+        when = node.get("when")
+        if when is None:
+            continue
+        if not isinstance(when, dict):
+            raise DefinitionError(
+                f"Invalid condition for task '{node['name']}'", task=node["name"]
+            )
+        source = when.get("switch", when.get("ref"))
+        if isinstance(source, list) and source:
+            source = source[0]
+        if source not in names:
+            raise DefinitionError(
+                f"Condition of task '{node['name']}' refers to unknown task '{source}'",
+                task=node["name"],
+            )
     result_task = definition.get("result_task")
     if result_task is not None and result_task not in names:
         raise DefinitionError(f"Unknown result task '{result_task}'")
@@ -613,6 +708,9 @@ def _dependencies(definition: dict[str, Any], node_name: str) -> Any:
 def _add_collect_member(deps: dict[str, Any], edge: dict[str, Any], node_name: str) -> None:
     field = edge["input"]
     kind = edge["collect"]
+    if kind == "first_of":
+        _add_first_of_member(deps, edge, node_name)
+        return
     if kind not in ("list", "dict"):
         raise DefinitionError(
             f"Unknown collect kind '{kind}' for input '{node_name}.{field}'",
@@ -652,6 +750,19 @@ def _add_collect_member(deps: dict[str, Any], edge: dict[str, Any], node_name: s
     members[key] = reference
 
 
+def _add_first_of_member(deps: dict[str, Any], edge: dict[str, Any], node_name: str) -> None:
+    field = edge["input"]
+    existing = deps.setdefault(field, {"first_of": []})
+    found = existing.get("first_of") if isinstance(existing, dict) else None
+    if not isinstance(found, list):
+        raise DefinitionError(
+            f"Input '{node_name}.{field}' mixes first_of alternatives with other connections",
+            task=node_name,
+            field=field,
+        )
+    found.append(_reference(edge["from"], edge.get("output")))
+
+
 def _map_document(task_map: Any, node_name: str) -> dict[str, Any]:
     if not isinstance(task_map, dict):
         raise DefinitionError(f"Invalid map for task '{node_name}'", task=node_name)
@@ -680,6 +791,17 @@ def _map_document(task_map: Any, node_name: str) -> dict[str, Any]:
     return document
 
 
+def _when_document(when: dict[str, Any]) -> dict[str, Any]:
+    document = dict(when)
+    if isinstance(document.get("ref"), list):
+        document["ref"] = _FlowList(document["ref"])
+    if isinstance(document.get("case"), list):
+        document["case"] = _FlowList(document["case"])
+    if isinstance(document.get("in"), list):
+        document["in"] = _FlowList(document["in"])
+    return document
+
+
 def workflow_document(definition: dict[str, Any]) -> dict[str, Any]:
     """Build the ``workflow.yaml`` document for a definition."""
     _check_saveable(definition)
@@ -698,6 +820,8 @@ def workflow_document(definition: dict[str, Any]) -> dict[str, Any]:
             entry["config_fields"] = _FlowList(node["config_fields"])
         if node.get("map"):
             entry["map"] = _map_document(node["map"], node["name"])
+        if node.get("when"):
+            entry["when"] = _when_document(node["when"])
         tasks.append(entry)
 
     section: dict[str, Any] = {"name": definition["name"]}
diff --git a/taskmaestro/dependencies.py b/taskmaestro/dependencies.py
index 5ec7800..066f2b2 100644
--- a/taskmaestro/dependencies.py
+++ b/taskmaestro/dependencies.py
@@ -4,13 +4,16 @@
 
 from collections.abc import Mapping
 from dataclasses import dataclass, field
-from typing import Any, Generic, Literal, TypeVar, overload
+from typing import TYPE_CHECKING, Any, Generic, Literal, TypeVar, overload
 
 from pydantic import BaseModel
 
 from taskmaestro.exceptions import WorkflowDefinitionError
 from taskmaestro.task import Task
 
+if TYPE_CHECKING:
+    from taskmaestro.conditions import Condition
+
 O = TypeVar("O", bound=BaseModel)
 T = TypeVar("T")
 
@@ -24,6 +27,30 @@ class OutputHandle(Generic[T]):
     annotation: Any
     _owner: object = field(repr=False)
 
+    def equals(self, value: Any) -> Condition:
+        """Guard: run the task when this field equals *value*."""
+        from taskmaestro.conditions import when
+
+        return when(self, equals=value)
+
+    def is_in(self, *values: Any) -> Condition:
+        """Guard: run the task when this field equals one of *values*."""
+        from taskmaestro.conditions import when
+
+        return when(self, in_=values)
+
+    def truthy(self) -> Condition:
+        """Guard: run the task when this field is ``True`` (or, if not a bool, not ``None``)."""
+        from taskmaestro.conditions import when
+
+        return when(self, truthy=True)
+
+    def falsy(self) -> Condition:
+        """Guard: run the task when this field is ``False`` or ``None``."""
+        from taskmaestro.conditions import when
+
+        return when(self, truthy=False)
+
 
 @dataclass(frozen=True)
 class TaskHandle(Generic[O]):
@@ -33,6 +60,28 @@ class TaskHandle(Generic[O]):
     output_type: type[BaseModel]
     _owner: object = field(repr=False)
 
+    def on(self, *labels: Any) -> Condition:
+        """Guard: run the task when this switch selects one of *labels*."""
+        from taskmaestro.conditions import Condition
+
+        if not labels:
+            raise TypeError("on() needs at least one branch label")
+        return Condition(self, "in", labels)
+
+    def otherwise(self) -> Condition:
+        """Guard: run the task when this switch selects a label no other guard claims."""
+        from taskmaestro.conditions import Condition
+
+        return Condition(self, "otherwise")
+
+    def if_true(self) -> Condition:
+        """Guard: run the task when this condition task returns ``True``."""
+        return self.on(True)
+
+    def if_false(self) -> Condition:
+        """Guard: run the task when this condition task returns ``False``."""
+        return self.on(False)
+
     def field(self, name: str) -> OutputHandle[Any]:
         """Return a validated reference to a named output field."""
         fields = self.output_type.model_fields
@@ -129,3 +178,34 @@ def collect(
         "positional",
         positional_members=tuple(members),  # type: ignore[arg-type]
     )
+
+
+@dataclass(frozen=True)
+class FirstOfDependency:
+    """Unresolved alternative dependency declared through :func:`first_of`."""
+
+    members: tuple[OutputReference, ...]
+
+
+@dataclass(frozen=True)
+class FirstOfRef:
+    """An alternative dependency whose task references have been resolved."""
+
+    members: tuple[OutputRef, ...]
+
+    def output_refs(self) -> tuple[OutputRef, ...]:
+        """Return all output references in declaration order."""
+        return self.members
+
+
+def first_of(*members: OutputReference) -> FirstOfDependency:
+    """Take one input field from whichever of several conditional branches ran.
+
+    At runtime the field receives the output of the first member, in
+    declaration order, that was not skipped. If every member was skipped the
+    downstream task is skipped too. Members may be task classes, task handles,
+    registered names, output handles, or ``(task, output_field)`` references.
+    """
+    if len(members) < 2:
+        raise TypeError("first_of() needs at least two members")
+    return FirstOfDependency(tuple(members))
diff --git a/taskmaestro/exceptions.py b/taskmaestro/exceptions.py
index 7b3a206..11b3388 100644
--- a/taskmaestro/exceptions.py
+++ b/taskmaestro/exceptions.py
@@ -30,6 +30,14 @@ class IncompleteInputError(WorkflowDefinitionError):
     """Fan-in input has required fields not mapped to any upstream task."""
 
 
+class ContextValueMissingError(WorkflowDefinitionError):
+    """A ``ContextFlag`` key is not registered on the execution context.
+
+    Raised by ``Runner.run`` before any task starts. The message only names
+    context keys and task names.
+    """
+
+
 class JobStateError(WorkflowRunnerError):
     """Job not in expected state (e.g., attempting to re-run a completed job)."""
 
@@ -56,6 +64,10 @@ class TaskTimeoutError(TaskExecutionError):
     """Raised when a task exceeds its timeout_seconds."""
 
 
+class ResultTaskSkippedError(TaskExecutionError):
+    """The workflow's result task was skipped by conditional execution."""
+
+
 class WorkflowTaskError(TaskExecutionError):
     """An inner workflow wrapped by ``workflow_task`` failed.
 
@@ -74,6 +86,28 @@ def __init__(self, workflow_name: str, inner_job: Any) -> None:
         )
 
 
+class ScriptError(TaskExecutionError):
+    """A script or command run by ``taskmaestro.python``/``taskmaestro.command`` failed.
+
+    ``returncode`` is ``None`` when the process was not started or did not finish
+    (missing script, unserializable inputs, timeout). ``stdout``/``stderr`` hold the
+    captured output, if any.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        returncode: int | None = None,
+        stdout: str = "",
+        stderr: str = "",
+    ) -> None:
+        super().__init__(message)
+        self.returncode = returncode
+        self.stdout = stdout
+        self.stderr = stderr
+
+
 class ConfigLoadError(WorkflowRunnerError):
     """Raised when YAML config loading fails (parse errors, import failures, validation)."""
 
diff --git a/taskmaestro/hooks/base.py b/taskmaestro/hooks/base.py
index 7c854e6..ad6dec7 100644
--- a/taskmaestro/hooks/base.py
+++ b/taskmaestro/hooks/base.py
@@ -21,6 +21,7 @@ class Event(StrEnum):
     TASK_START = "task_start"
     TASK_COMPLETE = "task_complete"
     TASK_FAIL = "task_fail"
+    TASK_SKIP = "task_skip"
     MAP_ITEM_START = "map_item_start"
     MAP_ITEM_COMPLETE = "map_item_complete"
     MAP_ITEM_FAIL = "map_item_fail"
@@ -36,6 +37,7 @@ def on_job_fail(self, job: Job[Any]) -> None: ...
     def on_task_start(self, job: Job[Any], task: Task[Any, Any]) -> None: ...
     def on_task_complete(self, job: Job[Any], task: Task[Any, Any], output: BaseModel) -> None: ...
     def on_task_fail(self, job: Job[Any], task: Task[Any, Any], error: Exception) -> None: ...
+    def on_task_skip(self, job: Job[Any], task_name: str, reason: str) -> None: ...
     def on_map_item_start(self, job: Job[Any], task: Task[Any, Any], key: str) -> None: ...
     def on_map_item_complete(
         self, job: Job[Any], task: Task[Any, Any], key: str, output: BaseModel
@@ -66,6 +68,9 @@ def on_task_complete(self, job: Job[Any], task: Task[Any, Any], output: BaseMode
     def on_task_fail(self, job: Job[Any], task: Task[Any, Any], error: Exception) -> None:
         pass
 
+    def on_task_skip(self, job: Job[Any], task_name: str, reason: str) -> None:
+        """A conditional task was skipped; it is never started or instantiated."""
+
     def on_map_item_start(self, job: Job[Any], task: Task[Any, Any], key: str) -> None:
         pass
 
diff --git a/taskmaestro/hooks/logging.py b/taskmaestro/hooks/logging.py
index 0a51253..c2c2a5d 100644
--- a/taskmaestro/hooks/logging.py
+++ b/taskmaestro/hooks/logging.py
@@ -43,6 +43,9 @@ def on_task_complete(self, job: Job[Any], task: Task[Any, Any], output: BaseMode
     def on_task_fail(self, job: Job[Any], task: Task[Any, Any], error: Exception) -> None:
         self._logger.log(self._level, "Task failed: %s, error=%s", task.name, error)
 
+    def on_task_skip(self, job: Job[Any], task_name: str, reason: str) -> None:
+        self._logger.log(self._level, "Task skipped: %s, reason=%s", task_name, reason)
+
     def on_map_item_start(self, job: Job[Any], task: Task[Any, Any], key: str) -> None:
         self._logger.log(self._level, "Map item started: %s[%s]", task.name, key)
 
diff --git a/taskmaestro/introspection.py b/taskmaestro/introspection.py
index 8623ee8..cb8ceee 100644
--- a/taskmaestro/introspection.py
+++ b/taskmaestro/introspection.py
@@ -23,7 +23,8 @@
 from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
 from pydantic_core import core_schema
 
-from taskmaestro.dependencies import CollectionRef, OutputRef
+from taskmaestro.conditions import Guard, plain_label
+from taskmaestro.dependencies import CollectionRef, FirstOfRef, OutputRef
 from taskmaestro.exceptions import ConfigLoadError, WorkflowDefinitionError
 from taskmaestro.job import EmptyConfig, Job, JobConfiguration
 from taskmaestro.task import get_input_type, get_output_type
@@ -126,6 +127,8 @@ def dependency_spec(deps: Any) -> Any:
             else:
                 members = [_output_ref(item) for item in ref.positional_members]
             result[field] = {"collect": {"kind": ref.kind, "members": members}}
+        elif isinstance(ref, FirstOfRef):
+            result[field] = {"first_of": [_output_ref(item) for item in ref.members]}
         elif isinstance(ref, tuple):
             result[field] = {"task": ref[0], "field": ref[1]}
         else:
@@ -133,6 +136,21 @@ def dependency_spec(deps: Any) -> Any:
     return result
 
 
+def guard_spec(guard: Guard | None) -> dict[str, Any] | None:
+    """Render a task's guard: source task and field, operator and values.
+
+    For ``otherwise`` guards ``values`` lists the labels the guard matches.
+    """
+    if guard is None:
+        return None
+    return {
+        "task": guard.ref.task_name,
+        "field": guard.ref.output_field,
+        "op": guard.op,
+        "values": [plain_label(value) for value in guard.values],
+    }
+
+
 def _jsonable_key(key: object, path: str) -> str:
     """Convert a YAML mapping key to the JSON object key it would get."""
     value = jsonable(key, path)
@@ -359,6 +377,12 @@ def describe_workflow(
                     field for field, info in input_type.model_fields.items() if info.is_required()
                 ),
                 "map": asdict(task_map) if task_map is not None else None,
+                "when": guard_spec(workflow.get_guard(name)),
+                "branches": (
+                    [plain_label(label) for label in task.branches]  # type: ignore[attr-defined]
+                    if workflow.is_switch(name)
+                    else None
+                ),
                 "input_schema": model_json_schema(input_type, schema_generator),
                 "output_schema": model_json_schema(output_type, schema_generator),
             }
diff --git a/taskmaestro/job.py b/taskmaestro/job.py
index db35e95..ef6b51a 100644
--- a/taskmaestro/job.py
+++ b/taskmaestro/job.py
@@ -29,6 +29,7 @@ class TaskStatus(StrEnum):
 
     COMPLETED = "completed"
     FAILED = "failed"
+    SKIPPED = "skipped"
 
 
 @dataclass
@@ -41,6 +42,7 @@ class TaskResult:
     started_at: datetime
     duration_seconds: float
     error: str | None = None
+    skip_reason: str | None = None
 
 
 class EmptyConfig(BaseModel):
@@ -106,6 +108,13 @@ def __init__(
         self._validate_task_configuration()
         self._validate_root_task_inputs(config)
 
+    @property
+    def skipped_tasks(self) -> list[str]:
+        """Names of tasks skipped by conditional execution, in execution order."""
+        return [
+            result.task_name for result in self.task_results if result.status == TaskStatus.SKIPPED
+        ]
+
     def _validate_task_configuration(self) -> None:
         """Ensure every declared configuration field has a supplied value.
 
diff --git a/taskmaestro/runner.py b/taskmaestro/runner.py
index 55cd725..4985f51 100644
--- a/taskmaestro/runner.py
+++ b/taskmaestro/runner.py
@@ -15,10 +15,12 @@
 from pydantic import BaseModel
 
 from taskmaestro.context import ExecutionContext
-from taskmaestro.dependencies import CollectionRef, OutputRef
+from taskmaestro.dependencies import CollectionRef, FirstOfRef, OutputRef
 from taskmaestro.exceptions import (
+    ContextValueMissingError,
     JobStateError,
     MappedTaskExecutionError,
+    ResultTaskSkippedError,
     TaskOutputTypeError,
     TaskTimeoutError,
 )
@@ -26,6 +28,24 @@
 from taskmaestro.job import Job, JobStatus, TaskResult, TaskStatus
 from taskmaestro.mapping import MappedOutput, TaskMap
 from taskmaestro.task import Task, get_input_type, get_output_type
+from taskmaestro.workflow import Workflow
+
+
+def _required_upstreams(deps: Any) -> set[str]:
+    """Return upstreams whose output a task needs; collections and first_of are optional."""
+    if deps is None:
+        return set()
+    if isinstance(deps, str):
+        return {deps}
+    if isinstance(deps, tuple):
+        return {deps[0]}
+    names: set[str] = set()
+    for ref in deps.values():
+        if isinstance(ref, tuple):
+            names.add(ref[0])
+        elif isinstance(ref, str):
+            names.add(ref)
+    return names
 
 
 class _JobTimeoutError(TaskTimeoutError):
@@ -177,6 +197,7 @@ def run(
 
         ctx = ctx or ExecutionContext()
         workflow = job.workflow
+        self._check_context_flags(job, ctx)
 
         self._emit(Event.JOB_START, job)
         job.status = JobStatus.RUNNING
@@ -189,11 +210,29 @@ def run(
             deadline.job_deadline = time.monotonic() + timeout_seconds
 
         outputs: dict[str, BaseModel] = {}
+        skip_reasons: dict[str, str] = {}
         job_config = job.job_configuration
 
         try:
             for task_name, task_cls in workflow.topological_order():
                 deps = workflow.get_dependencies(task_name)
+                # Tasks run in topological order and the job stops at the first
+                # failure, so an upstream without an output was skipped.
+                skip_reason = self._skip_reason(workflow, task_name, deps, outputs)
+                if skip_reason is not None:
+                    skip_reasons[task_name] = skip_reason
+                    job.task_results.append(
+                        TaskResult(
+                            task_name=task_name,
+                            status=TaskStatus.SKIPPED,
+                            output=None,
+                            started_at=datetime.now(),
+                            duration_seconds=0.0,
+                            skip_reason=skip_reason,
+                        )
+                    )
+                    self._emit(Event.TASK_SKIP, job, task_name, skip_reason)
+                    continue
                 config_fields = workflow.get_config_fields(task_name)
                 task_map = workflow.get_task_map(task_name)
                 all_config_values = (
@@ -292,12 +331,75 @@ def run(
             # Safety net; each unit of work already disarms right after running.
             self._disarm(deadline)
 
+        result_task_name = workflow.result_task_name
+        if result_task_name in skip_reasons:
+            skipped_error = ResultTaskSkippedError(
+                f"Result task '{result_task_name}' was skipped: {skip_reasons[result_task_name]}"
+            )
+            job.status = JobStatus.FAILED
+            job.error = str(skipped_error)
+            job.exception = skipped_error
+            job.failed_task = result_task_name
+            job.completed_at = datetime.now()
+            self._emit(Event.JOB_FAIL, job)
+            return job
+
         job.status = JobStatus.COMPLETED
-        job.result = outputs[workflow.result_task_name]
+        job.result = outputs[result_task_name]
         job.completed_at = datetime.now()
         self._emit(Event.JOB_COMPLETE, job)
         return job
 
+    @staticmethod
+    def _check_context_flags(job: Job[Any], ctx: ExecutionContext) -> None:
+        """Fail before any task runs if a ContextFlag's key is not registered."""
+        from taskmaestro.conditions import ContextFlag
+
+        missing: list[str] = []
+        for name, task_cls in job.workflow.topological_order():
+            if not issubclass(task_cls, ContextFlag) or job.job_configuration is None:
+                continue
+            key = job.job_configuration.get_config_for_task(name).get("key")
+            if isinstance(key, str) and not ctx.has(key):
+                missing.append(f"'{key}' (task '{name}')")
+        if missing:
+            raise ContextValueMissingError(
+                "Context value(s) not registered on the execution context: " + ", ".join(missing)
+            )
+
+    @staticmethod
+    def _skip_reason(
+        workflow: Workflow,
+        task_name: str,
+        deps: Any,
+        outputs: dict[str, BaseModel],
+    ) -> str | None:
+        """Return why a task must be skipped, or ``None`` if it runs.
+
+        A task is skipped when a required (non-collected, non-alternative)
+        upstream or its guard source was skipped, when its guard does not hold,
+        or when every alternative of a ``first_of`` input was skipped.
+        """
+        for upstream in _required_upstreams(deps):
+            if upstream not in outputs:
+                return f"upstream task '{upstream}' was skipped"
+        guard = workflow.get_guard(task_name)
+        if guard is not None:
+            source = guard.ref.task_name
+            if source not in outputs:
+                return f"condition source '{source}' was skipped"
+            assert guard.ref.output_field is not None  # resolved during validation
+            value = getattr(outputs[source], guard.ref.output_field)
+            if not guard.matches(value):
+                return f"condition {guard.describe()} not met (value {value!r})"
+        if isinstance(deps, dict):
+            for field_name, ref in deps.items():
+                if isinstance(ref, FirstOfRef) and not any(
+                    member.task_name in outputs for member in ref.members
+                ):
+                    return f"every first_of alternative for input '{field_name}' was skipped"
+        return None
+
     @staticmethod
     def _build_task_input(
         job: Job[Any],
@@ -342,6 +444,9 @@ def _resolve_named_dependencies(
         for field_name, ref in deps.items():
             if isinstance(ref, CollectionRef):
                 values[field_name] = Runner._resolve_collection(ref, outputs)
+            elif isinstance(ref, FirstOfRef):
+                chosen = next(member for member in ref.members if member.task_name in outputs)
+                values[field_name] = Runner._resolve_output_ref(chosen, outputs)
             elif isinstance(ref, tuple):
                 upstream_name, output_field = ref
                 values[field_name] = getattr(outputs[upstream_name], output_field)
@@ -458,13 +563,20 @@ def _resolve_collection(
         collection: CollectionRef,
         outputs: dict[str, BaseModel],
     ) -> object:
-        """Resolve a collection while preserving its declaration order."""
+        """Resolve a collection while preserving its declaration order.
+
+        Members whose task was skipped are left out.
+        """
         if collection.kind == "positional":
             return [
-                Runner._resolve_output_ref(ref, outputs) for ref in collection.positional_members
+                Runner._resolve_output_ref(ref, outputs)
+                for ref in collection.positional_members
+                if ref.task_name in outputs
             ]
         return {
-            key: Runner._resolve_output_ref(ref, outputs) for key, ref in collection.keyed_members
+            key: Runner._resolve_output_ref(ref, outputs)
+            for key, ref in collection.keyed_members
+            if ref.task_name in outputs
         }
 
     def _arm(self, task_timeout: float | None, label: str, deadline: _Deadline) -> None:
diff --git a/taskmaestro/scripts.py b/taskmaestro/scripts.py
new file mode 100644
index 0000000..be85e78
--- /dev/null
+++ b/taskmaestro/scripts.py
@@ -0,0 +1,206 @@
+"""Built-in tasks that run a Python script or a command in a subprocess.
+
+Registered as the ``taskmaestro.python`` and ``taskmaestro.command`` task plugins.
+They make one-off workflow steps possible without writing a Task class.
+
+Data exchange with the process uses JSON files in a fresh directory under the
+run's scratch directory:
+
+- ``TASKMAESTRO_INPUT``: path to a JSON object holding ``inputs`` (set only when
+  ``inputs`` is not empty).
+- ``TASKMAESTRO_OUTPUT``: path where the process may write a JSON value, which
+  becomes ``ScriptOutput.result``.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+from pydantic_core import PydanticSerializationError, to_json
+
+from taskmaestro.context import ExecutionContext
+from taskmaestro.exceptions import ScriptError
+from taskmaestro.task import Task
+
+INPUT_ENV = "TASKMAESTRO_INPUT"
+OUTPUT_ENV = "TASKMAESTRO_OUTPUT"
+_STDERR_TAIL_LINES = 20
+
+
+class ScriptOutput(BaseModel):
+    """Output of :class:`PythonScript` and :class:`Command`."""
+
+    result: Any = Field(default=None, description=f"JSON value written to ${OUTPUT_ENV}, or null")
+    returncode: int = Field(default=0, description="Exit code of the process")
+    stdout: str = Field(default="", description="Captured standard output")
+    stderr: str = Field(default="", description="Captured standard error")
+
+
+class _ProcessInput(BaseModel):
+    """Settings shared by script and command tasks."""
+
+    inputs: dict[str, Any] = Field(
+        default_factory=dict,
+        description=(
+            f"Upstream data, connected with a keyed collect; written as JSON to ${INPUT_ENV}"
+        ),
+    )
+    env: dict[str, str] = Field(
+        default_factory=dict, description="Extra environment variables for the process"
+    )
+    cwd: Path | None = Field(
+        default=None, description="Working directory of the process (default: current directory)"
+    )
+    timeout: float | None = Field(
+        default=None, gt=0, description="Kill the process after this many seconds"
+    )
+    check: bool = Field(default=True, description="Fail the task on a nonzero exit code")
+
+
+class PythonScriptInput(_ProcessInput):
+    """Input of :class:`PythonScript`."""
+
+    script: Path = Field(description="Python file to run")
+    args: list[str] = Field(default_factory=list, description="Command-line arguments")
+
+
+class CommandInput(_ProcessInput):
+    """Input of :class:`Command`."""
+
+    command: str | list[str] = Field(
+        description=(
+            "A string runs through the shell; a list runs the executable directly, without a shell"
+        )
+    )
+
+
+class PythonScript(Task[PythonScriptInput, ScriptOutput]):
+    """Run a Python file with the current interpreter in a subprocess."""
+
+    name = "python"
+
+    def run(self, input: PythonScriptInput, ctx: ExecutionContext) -> ScriptOutput:
+        # Resolve before the process changes directory to ``cwd``.
+        script = input.script.expanduser().absolute()
+        if not script.is_file():
+            raise ScriptError(f"Script not found: {script}")
+        return run_process(
+            [sys.executable, str(script), *input.args],
+            settings=input,
+            ctx=ctx,
+            label=f"Script '{script.name}'",
+        )
+
+
+class Command(Task[CommandInput, ScriptOutput]):
+    """Run a shell command, shell script or executable in a subprocess."""
+
+    name = "command"
+
+    def run(self, input: CommandInput, ctx: ExecutionContext) -> ScriptOutput:
+        if not input.command:
+            raise ScriptError("Command is empty")
+        shown = input.command if isinstance(input.command, str) else " ".join(input.command)
+        return run_process(input.command, settings=input, ctx=ctx, label=f"Command '{shown}'")
+
+
+def run_process(
+    command: str | list[str],
+    *,
+    settings: _ProcessInput,
+    ctx: ExecutionContext,
+    label: str,
+) -> ScriptOutput:
+    """Run ``command`` with the data-exchange protocol and return its output.
+
+    A string runs through the shell. Raises :class:`ScriptError` when the
+    process cannot be run, times out, exits nonzero with ``check`` set, or
+    writes invalid JSON to ``TASKMAESTRO_OUTPUT``.
+    """
+    ctx.scratch_dir.mkdir(parents=True, exist_ok=True)
+    exchange_dir = Path(tempfile.mkdtemp(prefix="script-", dir=ctx.scratch_dir))
+    output_path = exchange_dir / "output.json"
+    env = {**os.environ, **settings.env, OUTPUT_ENV: str(output_path)}
+    env.pop(INPUT_ENV, None)
+    if settings.inputs:
+        input_path = exchange_dir / "input.json"
+        try:
+            input_path.write_bytes(to_json(settings.inputs))
+        except PydanticSerializationError as exc:
+            raise ScriptError(
+                f"{label}: inputs cannot be converted to JSON ({exc}). Runtime-only "
+                "objects cannot be passed to a subprocess; use a regular Task instead."
+            ) from exc
+        env[INPUT_ENV] = str(input_path)
+
+    ctx.logger.debug("%s: running in %s", label, exchange_dir)
+    try:
+        completed = subprocess.run(
+            command,
+            shell=isinstance(command, str),
+            capture_output=True,
+            text=True,
+            env=env,
+            cwd=settings.cwd,
+            timeout=settings.timeout,
+            check=False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        raise ScriptError(
+            f"{label} timed out after {settings.timeout}s",
+            stdout=_text(exc.stdout),
+            stderr=_text(exc.stderr),
+        ) from exc
+    except OSError as exc:
+        raise ScriptError(f"{label} could not be started: {exc}") from exc
+
+    if settings.check and completed.returncode != 0:
+        tail = "\n".join(completed.stderr.splitlines()[-_STDERR_TAIL_LINES:])
+        message = f"{label} failed with exit code {completed.returncode}"
+        raise ScriptError(
+            f"{message}: {tail}" if tail else message,
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+        )
+
+    return ScriptOutput(
+        result=_read_result(output_path, label, completed),
+        returncode=completed.returncode,
+        stdout=completed.stdout,
+        stderr=completed.stderr,
+    )
+
+
+def _read_result(
+    output_path: Path, label: str, completed: subprocess.CompletedProcess[str]
+) -> Any:
+    """Return the JSON value written to the output file, or ``None`` if none was written."""
+    try:
+        text = output_path.read_text()
+    except FileNotFoundError:
+        return None
+    if not text.strip():
+        return None
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise ScriptError(
+            f"{label} wrote invalid JSON to ${OUTPUT_ENV}: {exc}",
+            returncode=completed.returncode,
+            stdout=completed.stdout,
+            stderr=completed.stderr,
+        ) from exc
+
+
+def _text(value: str | bytes | None) -> str:
+    if value is None:
+        return ""
+    return value.decode(errors="replace") if isinstance(value, bytes) else value
diff --git a/taskmaestro/visualization.py b/taskmaestro/visualization.py
index ce27d4f..84cceda 100644
--- a/taskmaestro/visualization.py
+++ b/taskmaestro/visualization.py
@@ -5,7 +5,8 @@
 import sys
 from typing import TYPE_CHECKING, Any, get_args, get_origin
 
-from taskmaestro.dependencies import CollectionRef, OutputRef
+from taskmaestro.conditions import BRANCH_FIELD, Guard, plain_label
+from taskmaestro.dependencies import CollectionRef, FirstOfRef, OutputRef
 from taskmaestro.task import get_input_type
 
 if TYPE_CHECKING:
@@ -62,6 +63,41 @@ def _output_ref_label(workflow: Workflow, task_by_name: dict[str, type], ref: Ou
     return _field_type_label(workflow, task_by_name, ref.task_name, ref.output_field)
 
 
+def _label_text(value: Any) -> str:
+    """Render a guard value for an edge label."""
+    value = plain_label(value)
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    return str(value).replace('"', "'").replace("|", "/")
+
+
+def _guard_label(workflow: Workflow, guard: Guard) -> str:
+    """Return the label of a dashed control edge for a guard."""
+    switch_case = (
+        workflow.is_switch(guard.ref.task_name) and guard.ref.output_field == BRANCH_FIELD
+    )
+    if switch_case:
+        if guard.op == "otherwise":
+            return "otherwise"
+        if guard.op == "in":
+            return " / ".join(_label_text(value) for value in guard.values)
+    field = f".{guard.ref.output_field}"
+    if guard.op == "truthy":
+        return field if not switch_case else "true"
+    if guard.op == "falsy":
+        return f"not {field}" if not switch_case else "false"
+    if len(guard.values) == 1:
+        return f"{field} = {_label_text(guard.values[0])}"
+    return f"{field} in {' / '.join(_label_text(value) for value in guard.values)}"
+
+
+def _node_line(workflow: Workflow, task_name: str, node_id: str, label: str) -> str:
+    """Return a node definition; switch tasks are drawn as diamonds."""
+    if workflow.is_switch(task_name):
+        return f'{node_id}{{"{label}"}}'
+    return f'{node_id}["{label}"]'
+
+
 def _apply_redirect(name: str, redirect: dict[str, str]) -> str:
     """Replace *name* with its redirect target if one exists."""
     return redirect.get(name, name)
@@ -101,7 +137,20 @@ def _emit_edges(
             lines.append(f"{indent}{upstream_src} -->|{label}| {tgt_name}")
         elif isinstance(deps, dict):
             for down_field, upstream_ref in sorted(deps.items()):
-                if isinstance(upstream_ref, CollectionRef):
+                if isinstance(upstream_ref, FirstOfRef):
+                    first_node = f"_first_of_{tgt_name}_{down_field}_"
+                    lines.append(f'{indent}{first_node}(["first_of {down_field}"])')
+                    for ref in upstream_ref.members:
+                        upstream_src = _apply_redirect(ref.task_name, source_redirect)
+                        label = _output_ref_label(workflow, task_by_name, ref)
+                        lines.append(f"{indent}{upstream_src} -->|{label}| {first_node}")
+                    input_model = get_input_type(task_cls)
+                    annotation = input_model.model_fields[down_field].annotation
+                    field_type = _safe_type_name(annotation, task_cls)
+                    lines.append(
+                        f"{indent}{first_node} -->|{down_field}: {field_type}| {tgt_name}"
+                    )
+                elif isinstance(upstream_ref, CollectionRef):
                     collection_node = f"_collect_{tgt_name}_{down_field}_"
                     lines.append(f'{indent}{collection_node}{{{{"collect {down_field}"}}}}')
                     if upstream_ref.kind == "positional":
@@ -140,6 +189,11 @@ def _emit_edges(
                         f"{indent}{upstream_src} -->|{down_field}: {output_name}| {tgt_name}"
                     )
 
+        guard = workflow.get_guard(task_name)
+        if guard is not None:
+            guard_src = _apply_redirect(guard.ref.task_name, source_redirect)
+            lines.append(f"{indent}{guard_src} -.->|{_guard_label(workflow, guard)}| {tgt_name}")
+
 
 def to_mermaid(
     workflow: Workflow,
@@ -157,19 +211,14 @@ def to_mermaid(
     Tasks created via ``workflow_task`` are expanded into Mermaid subgraphs
     showing the inner workflow's structure.
     """
-    from taskmaestro.workflow import _extract_upstream_names
-
     lines: list[str] = ["---", f"title: {workflow.name}", "---", "graph TD"]
 
     tasks = workflow.topological_order()
     task_by_name: dict[str, type] = {name: cls for name, cls in tasks}
 
-    # Find sink tasks (no downstream dependents)
-    has_dependents: set[str] = set()
-    for task_name, _task_cls in tasks:
-        deps = workflow.get_dependencies(task_name)
-        has_dependents.update(_extract_upstream_names(deps))
-    sinks = [(name, cls) for name, cls in tasks if name not in has_dependents]
+    # Find sink tasks (no downstream data or condition dependents)
+    sink_names = set(workflow._find_sinks())
+    sinks = [(name, cls) for name, cls in tasks if name in sink_names]
 
     # Collect tasks with config_fields
     configured_tasks = {
@@ -224,7 +273,7 @@ def to_mermaid(
             # Inner node definitions
             for iname, _icls in inner_tasks:
                 prefixed = f"{task_name}__{iname}"
-                lines.append(f'        {prefixed}["{iname}"]')
+                lines.append(f"        {_node_line(inner_wf, iname, prefixed, iname)}")
 
             # Inner edges (skip start/end — handled by outer redirects)
             inner_source_redirect: dict[str, str] = {
@@ -252,7 +301,7 @@ def to_mermaid(
             label = (
                 f"{task_name}<br/>map over: {task_map.over}" if task_map is not None else task_name
             )
-            lines.append(f'    {task_name}["{label}"]')
+            lines.append(f"    {_node_line(workflow, task_name, task_name, label)}")
 
     # Outer edge definitions
     _emit_edges(
diff --git a/taskmaestro/workflow.py b/taskmaestro/workflow.py
index 9a66add..e8b2bcb 100644
--- a/taskmaestro/workflow.py
+++ b/taskmaestro/workflow.py
@@ -7,16 +7,25 @@
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast, get_args, get_origin
 
-from pydantic import BaseModel
+from pydantic import BaseModel, TypeAdapter, ValidationError
 
 if TYPE_CHECKING:
     from taskmaestro.context import ExecutionContext
     from taskmaestro.hooks.base import BaseHook
     from taskmaestro.job import Job, JobConfiguration
 
+from taskmaestro.conditions import (
+    BRANCH_FIELD,
+    Condition,
+    Guard,
+    is_switch_task,
+    plain_label,
+)
 from taskmaestro.dependencies import (
     CollectionDependency,
     CollectionRef,
+    FirstOfDependency,
+    FirstOfRef,
     OutputHandle,
     OutputRef,
     OutputReference,
@@ -37,9 +46,10 @@
 #   None              — root task
 #   str               — single upstream (whole output)
 #   tuple[str, str]   — single upstream, specific field
-#   dict[str, str | tuple[str, str]]  — fan-in (values may be field refs)
+#   dict[str, str | tuple[str, str]]  — fan-in (values may be field refs,
+#                                       collections or first_of alternatives)
 type DepValue = str | tuple[str, str]
-type FanInValue = DepValue | CollectionRef
+type FanInValue = DepValue | CollectionRef | FirstOfRef
 type StoredDeps = dict[str, FanInValue] | str | tuple[str, str] | None
 
 
@@ -53,7 +63,7 @@ def _extract_upstream_names(deps: StoredDeps) -> set[str]:
         return {deps[0]}
     names: set[str] = set()
     for value in deps.values():
-        if isinstance(value, CollectionRef):
+        if isinstance(value, CollectionRef | FirstOfRef):
             names.update(ref.task_name for ref in value.output_refs())
         elif isinstance(value, tuple):
             names.add(value[0])
@@ -139,6 +149,25 @@ def _type_name(annotation: Any) -> str:
     return getattr(annotation, "__name__", str(annotation))
 
 
+_MISSING_VALUE: Any = object()
+
+
+def _accepts_truthiness(annotation: Any) -> bool:
+    """Return whether a field may be guarded with truthy/falsy conditions.
+
+    Only ``bool``, ``Literal`` booleans and optional fields qualify. For
+    non-bool values the guard tests ``is not None`` (see ``Guard.matches``),
+    so it never depends on Python's truthiness of arbitrary values.
+    """
+    if annotation is None or annotation is Any or annotation is bool:
+        return True
+    if get_origin(annotation) is Literal:
+        return all(isinstance(arg, bool) for arg in get_args(annotation))
+    if _is_union(annotation):
+        return type(None) in get_args(annotation)
+    return False
+
+
 class Workflow:
     """A DAG of tasks. Linear pipelines are a special case."""
 
@@ -158,6 +187,7 @@ def __init__(
         self._dependencies: dict[str, StoredDeps] = {}
         self._config_fields: dict[str, set[str]] = {}
         self._task_maps: dict[str, TaskMap] = {}
+        self._guards: dict[str, Guard] = {}
         self._result_task_name: str | None = None
 
         if tasks is not None:
@@ -224,8 +254,8 @@ def topological_order(self) -> list[tuple[str, type[Task[Any, Any]]]]:
         in_degree: dict[str, int] = {name: 0 for name in self._tasks}
         adjacency: dict[str, list[str]] = {name: [] for name in self._tasks}
 
-        for name, deps in self._dependencies.items():
-            for upstream in _extract_upstream_names(deps):
+        for name in self._dependencies:
+            for upstream in self._upstream_names(name):
                 in_degree[name] += 1
                 adjacency[upstream].append(name)
 
@@ -261,6 +291,26 @@ def get_dependencies(self, task_name: str) -> StoredDeps:
         """Return the dependency spec for a task."""
         return self._dependencies[task_name]
 
+    def get_guard(self, task_name: str) -> Guard | None:
+        """Return the guard (``when=``) of a task, or ``None`` if it always runs."""
+        return self._guards.get(task_name)
+
+    def is_conditional(self, task_name: str) -> bool:
+        """Return whether a task has a guard."""
+        return task_name in self._guards
+
+    def is_switch(self, task_name: str) -> bool:
+        """Return whether a task is a switch task selecting between branches."""
+        return is_switch_task(self._tasks[task_name])
+
+    def _upstream_names(self, task_name: str) -> set[str]:
+        """Return the data upstreams of a task plus the source of its guard."""
+        names = _extract_upstream_names(self._dependencies[task_name])
+        guard = self._guards.get(task_name)
+        if guard is not None:
+            names.add(guard.ref.task_name)
+        return names
+
     def get_config_fields(self, task_name: str) -> set[str]:
         """Return the set of config field names for a task, or empty set."""
         return self._config_fields.get(task_name, set())
@@ -298,6 +348,7 @@ def _validate(self) -> None:
         self._validate_references()
         self._validate_acyclic()
         self._validate_task_maps()
+        self._validate_guards()
         self._validate_types()
         self._validate_result_task()
 
@@ -319,6 +370,12 @@ def _validate_references(self) -> None:
                         f"Task '{name}' depends on '{upstream}', "
                         f"which is not registered in the workflow"
                     )
+        for name, guard in self._guards.items():
+            if guard.ref.task_name not in self._tasks:
+                raise WorkflowDefinitionError(
+                    f"Condition of task '{name}' refers to '{guard.ref.task_name}', "
+                    f"which is not registered in the workflow"
+                )
 
     def _validate_acyclic(self) -> None:
         """Detect cycles via DFS. Raise CycleDetectedError."""
@@ -327,8 +384,8 @@ def _validate_acyclic(self) -> None:
 
         def _build_adjacency() -> dict[str, list[str]]:
             adj: dict[str, list[str]] = {name: [] for name in self._tasks}
-            for name, deps in self._dependencies.items():
-                for upstream in _extract_upstream_names(deps):
+            for name in self._dependencies:
+                for upstream in self._upstream_names(name):
                     adj[upstream].append(name)
             return adj
 
@@ -406,6 +463,14 @@ def _validate_types(self) -> None:
                 if cf:
                     downstream_input = get_input_type(task_cls)
                     model_fields = downstream_input.model_fields
+                    # Unknown names first: a misspelled field also leaves the
+                    # intended one uncovered, and the typo is the real error.
+                    for field_name in cf:
+                        if field_name not in model_fields:
+                            raise WorkflowDefinitionError(
+                                f"Config field '{field_name}' not found on "
+                                f"{downstream_input.__name__} (input of '{name}')"
+                            )
                     # Validate config_fields cover all required input fields
                     task_map = self.get_task_map(name)
                     map_fields = (
@@ -418,13 +483,6 @@ def _validate_types(self) -> None:
                                 f"{downstream_input.__name__} is not covered by "
                                 f"config_fields for root task '{name}'"
                             )
-                    # Validate config field names exist on the model
-                    for field_name in cf:
-                        if field_name not in model_fields:
-                            raise WorkflowDefinitionError(
-                                f"Config field '{field_name}' not found on "
-                                f"{downstream_input.__name__} (input of '{name}')"
-                            )
                 continue
             elif isinstance(deps, str):
                 # Single dependency (whole output)
@@ -533,6 +591,14 @@ def _validate_types(self) -> None:
                             upstream_ref,
                         )
                         continue
+                    if isinstance(upstream_ref, FirstOfRef):
+                        if field_name in cf:
+                            raise WorkflowDefinitionError(
+                                f"Field '{field_name}' on task '{name}' is supplied by both "
+                                "a first_of dependency and config_fields"
+                            )
+                        self._validate_first_of(name, field_name, field_annotation, upstream_ref)
+                        continue
                     if isinstance(upstream_ref, tuple):
                         up_name, up_field = upstream_ref
                         up_output = self.get_output_annotation(up_name)
@@ -640,6 +706,156 @@ def _validate_collection(
                     f"{_type_name(expected_type)}"
                 )
 
+    def _validate_first_of(
+        self,
+        task_name: str,
+        field_name: str,
+        field_annotation: Any,
+        alternatives: FirstOfRef,
+    ) -> None:
+        """Validate that every first_of member can fill the destination field."""
+        for ref in alternatives.members:
+            produced_type = self._resolve_output_ref_type(ref)
+            if (
+                field_annotation is not None
+                and produced_type is not None
+                and not _is_type_compatible(produced_type, field_annotation)
+            ):
+                source = ref.task_name
+                if ref.output_field is not None:
+                    source += f".{ref.output_field}"
+                raise WorkflowDefinitionError(
+                    f"first_of type mismatch for '{task_name}.{field_name}': '{source}' "
+                    f"produces {_type_name(produced_type)}, but the field expects "
+                    f"{_type_name(field_annotation)}"
+                )
+
+    def _validate_guards(self) -> None:
+        """Validate guard sources and values, and switch branch coverage.
+
+        Resolves a whole-output reference to a switch into its ``branch``
+        field, normalizes guard values to the field's type (e.g. strings to
+        enum members), and fills in the labels matched by ``otherwise()``.
+        """
+        for name, guard in list(self._guards.items()):
+            source = guard.ref.task_name
+            source_cls = self._tasks[source]
+            if self.is_mapped_task(source):
+                raise WorkflowDefinitionError(
+                    f"Condition of task '{name}' cannot refer to mapped task '{source}'",
+                    task_name=name,
+                )
+            switch = self.is_switch(source)
+            field_name = guard.ref.output_field
+            if field_name is None:
+                if not switch:
+                    raise WorkflowDefinitionError(
+                        f"Condition of task '{name}' must refer to an output field of "
+                        f"'{source}', which is not a switch task",
+                        task_name=name,
+                    )
+                field_name = BRANCH_FIELD
+            output_type = get_output_type(source_cls)
+            if field_name not in output_type.model_fields:
+                raise WorkflowDefinitionError(
+                    f"Field '{field_name}' not found on {output_type.__name__} "
+                    f"(output of {source}, used by the condition of '{name}')",
+                    task_name=name,
+                )
+            annotation = output_type.model_fields[field_name].annotation
+            is_branch = switch and field_name == BRANCH_FIELD
+            values = guard.values
+            if guard.op == "otherwise" and not is_branch:
+                raise WorkflowDefinitionError(
+                    f"otherwise() on task '{name}' requires a switch task, but "
+                    f"'{source}' is not one",
+                    task_name=name,
+                )
+            if guard.op == "in":
+                values = tuple(
+                    self._guard_value(name, source, field_name, annotation, value)
+                    for value in values
+                )
+            elif guard.op in ("truthy", "falsy") and not _accepts_truthiness(annotation):
+                raise WorkflowDefinitionError(
+                    f"truthy/falsy condition of task '{name}' requires a bool or optional "
+                    f"field, but {source}.{field_name} is {_type_name(annotation)}",
+                    task_name=name,
+                )
+            self._guards[name] = Guard(OutputRef(source, field_name), guard.op, values)
+
+        consumers: dict[str, list[str]] = {}
+        for name, guard in self._guards.items():
+            source = guard.ref.task_name
+            if self.is_switch(source) and guard.ref.output_field == BRANCH_FIELD:
+                consumers.setdefault(source, []).append(name)
+        for switch_name, guarded in consumers.items():
+            self._validate_switch_coverage(switch_name, guarded)
+
+    def _validate_switch_coverage(self, switch_name: str, guarded: list[str]) -> None:
+        """Every label of a switch needs a case; ``otherwise()`` must be reachable."""
+        labels: tuple[Any, ...] = self._tasks[switch_name].branches  # type: ignore[attr-defined]
+        claimed: list[Any] = []
+        has_otherwise = False
+        for name in guarded:
+            guard = self._guards[name]
+            if guard.op == "otherwise":
+                has_otherwise = True
+            elif guard.op == "in":
+                claimed.extend(guard.values)
+            else:
+                claimed.extend(label for label in labels if bool(label) == (guard.op == "truthy"))
+        unclaimed = tuple(label for label in labels if label not in claimed)
+        readable = [plain_label(label) for label in unclaimed]
+        if not has_otherwise:
+            if unclaimed:
+                raise WorkflowDefinitionError(
+                    f"Switch '{switch_name}' has no task for branch(es) {readable}; "
+                    "guard a task with on(...) or otherwise()",
+                    task_name=switch_name,
+                )
+            return
+        if not unclaimed:
+            raise WorkflowDefinitionError(
+                f"otherwise() on switch '{switch_name}' can never match: every branch "
+                "already has a case",
+                task_name=switch_name,
+            )
+        for name in guarded:
+            guard = self._guards[name]
+            if guard.op == "otherwise":
+                self._guards[name] = Guard(guard.ref, "otherwise", unclaimed)
+
+    @staticmethod
+    def _guard_value(
+        task_name: str, source: str, field_name: str, annotation: Any, value: Any
+    ) -> Any:
+        """Validate a guard value against the source field's annotation.
+
+        Values are validated strictly, so ``"no"`` or ``1`` never silently become
+        ``False``/``True``. A lax conversion is only accepted when it keeps the
+        plain value, e.g. the YAML string ``"express"`` for an enum member.
+        """
+        if annotation is None or annotation is Any:
+            return value
+        adapter: TypeAdapter[Any] = TypeAdapter(annotation)
+        try:
+            return adapter.validate_python(value, strict=True)
+        except ValidationError:
+            pass
+        try:
+            converted = adapter.validate_python(value)
+        except ValidationError:
+            converted = _MISSING_VALUE
+        plain = plain_label(converted)
+        if converted is not _MISSING_VALUE and type(plain) is type(value) and plain == value:
+            return converted
+        raise WorkflowDefinitionError(
+            f"Condition value {plain_label(value)!r} of task '{task_name}' is not a "
+            f"valid value of {source}.{field_name} ({_type_name(annotation)})",
+            task_name=task_name,
+        )
+
     def _validate_result_task(self) -> None:
         """Ensure result_task is set and registered. Default to sole sink; raise if ambiguous."""
         if self._result_task_name is not None:
@@ -683,8 +899,8 @@ def to_mermaid(self, *, job_configuration: JobConfiguration | None = None) -> st
     def _find_sinks(self) -> list[str]:
         """Return task names with no downstream dependents."""
         has_dependents: set[str] = set()
-        for deps in self._dependencies.values():
-            has_dependents.update(_extract_upstream_names(deps))
+        for name in self._dependencies:
+            has_dependents.update(self._upstream_names(name))
         return [name for name in self._tasks if name not in has_dependents]
 
 
@@ -703,6 +919,7 @@ def __init__(
         self._workflow._dependencies = {}
         self._workflow._config_fields = {}
         self._workflow._task_maps = {}
+        self._workflow._guards = {}
         self._workflow._result_task_name = None
         # Store the raw result_task ref for resolution at build() time
         self._result_task_ref: type[Task[Any, Any]] | str | TaskHandle[Any] | None = result_task
@@ -782,10 +999,13 @@ def add_task(
         *,
         name: str | None = None,
         depends_on: (
-            OutputReference | Mapping[str, OutputReference | CollectionDependency] | None
+            OutputReference
+            | Mapping[str, OutputReference | CollectionDependency | FirstOfDependency]
+            | None
         ) = None,
         config_fields: list[str] | None = None,
         mapped_over: TaskMap | None = None,
+        when: Condition | None = None,
     ) -> WorkflowBuilder:
         """Add a task to the DAG. Returns self for chaining.
 
@@ -800,13 +1020,28 @@ def add_task(
         - ``{"field": task_reference, ...}`` — fan-in, whole outputs
         - ``{"field": output_reference, ...}`` — fan-in with field routing
         - ``{"field": collect(...), ...}`` — collect outputs into a list or dictionary
+        - ``{"field": first_of(a, b), ...}`` — take whichever conditional branch ran
 
         ``mapped_over`` expands this logical task over a configured mapping.
+
+        ``when`` makes the task conditional, e.g. ``switch.on("label")``,
+        ``switch.otherwise()``, ``condition.if_true()`` or
+        ``when(handle.field("flag"), truthy=True)``. A task whose condition
+        does not hold, or whose required upstream was skipped, is skipped.
         """
         wf = self._workflow
         task_name = name if name is not None else task_cls.name
         if task_name in wf._tasks:
             raise WorkflowDefinitionError(f"Duplicate task name '{task_name}'")
+        if isinstance(depends_on, FirstOfDependency):
+            raise WorkflowDefinitionError(
+                f"first_of() for task '{task_name}' must be assigned to a named input field"
+            )
+        if when is not None and not isinstance(when, Condition):
+            raise WorkflowDefinitionError(
+                f"when= for task '{task_name}' must be a condition such as "
+                "switch.on(...) or when(...)"
+            )
         wf._tasks[task_name] = task_cls
 
         if depends_on is None:
@@ -826,6 +1061,10 @@ def add_task(
             for field, dep in depends_on.items():
                 if isinstance(dep, CollectionDependency):
                     resolved_dependencies[field] = self._resolve_collection(dep)
+                elif isinstance(dep, FirstOfDependency):
+                    resolved_dependencies[field] = FirstOfRef(
+                        tuple(self._resolve_output_reference(member) for member in dep.members)
+                    )
                 elif isinstance(dep, OutputHandle):
                     output_ref = self._resolve_output_reference(dep)
                     resolved_dependencies[field] = (
@@ -847,6 +1086,10 @@ def add_task(
             wf._config_fields[task_name] = set(config_fields)
         if mapped_over is not None:
             wf._task_maps[task_name] = mapped_over
+        if when is not None:
+            wf._guards[task_name] = Guard(
+                self._resolve_output_reference(when.source), when.op, when.values
+            )
 
         return self
 
@@ -856,11 +1099,14 @@ def task(
         *,
         name: str | None = None,
         depends_on: (
-            OutputReference | Mapping[str, OutputReference | CollectionDependency] | None
+            OutputReference
+            | Mapping[str, OutputReference | CollectionDependency | FirstOfDependency]
+            | None
         ) = None,
         config_fields: list[str] | None = None,
         mapped_over: TaskMap | None = None,
-        **input_dependencies: OutputReference | CollectionDependency,
+        when: Condition | None = None,
+        **input_dependencies: OutputReference | CollectionDependency | FirstOfDependency,
     ) -> TaskHandle[O]:
         """Add a task and return an unambiguous handle to that instance.
 
@@ -869,6 +1115,11 @@ def task(
         dependencies may be passed directly as keyword arguments instead of
         through ``depends_on``.
         """
+        if when is not None and not isinstance(when, Condition):
+            # Before conditional execution existed, ``when=`` was an ordinary
+            # keyword input dependency for a field named "when".
+            input_dependencies = {**input_dependencies, "when": when}
+            when = None
         if input_dependencies:
             if depends_on is not None:
                 raise WorkflowDefinitionError(
@@ -881,6 +1132,7 @@ def task(
             depends_on=depends_on,
             config_fields=config_fields,
             mapped_over=mapped_over,
+            when=when,
         )
         task_name = name if name is not None else task_cls.name
         output_type = cast(type[BaseModel], self._workflow.get_output_annotation(task_name))
@@ -896,10 +1148,13 @@ def map_task(
         error_mode: Literal["fail_fast", "collect_all"] = "fail_fast",
         name: str | None = None,
         depends_on: (
-            OutputReference | Mapping[str, OutputReference | CollectionDependency] | None
+            OutputReference
+            | Mapping[str, OutputReference | CollectionDependency | FirstOfDependency]
+            | None
         ) = None,
         config_fields: list[str] | None = None,
-        **input_dependencies: OutputReference | CollectionDependency,
+        when: Condition | None = None,
+        **input_dependencies: OutputReference | CollectionDependency | FirstOfDependency,
     ) -> TaskHandle[MappedOutput[O]]:
         """Add a task mapped over configured items and return its handle."""
         handle = self.task(
@@ -913,6 +1168,7 @@ def map_task(
                 value_as=value_as,
                 error_mode=error_mode,
             ),
+            when=when,
             **input_dependencies,
         )
         return cast(TaskHandle[MappedOutput[O]], handle)
@@ -942,6 +1198,7 @@ def build(self) -> Workflow:
             name: set(fields) for name, fields in source._config_fields.items()
         }
         workflow._task_maps = dict(source._task_maps)
+        workflow._guards = dict(source._guards)
         ref = self._result_task_ref
         workflow._result_task_name = self._resolve_dep_ref(ref) if ref is not None else None
         workflow._validate()
diff --git a/taskmaestro/yaml_config.py b/taskmaestro/yaml_config.py
index 0fc2fd7..b817ece 100644
--- a/taskmaestro/yaml_config.py
+++ b/taskmaestro/yaml_config.py
@@ -14,8 +14,15 @@
 import yaml
 from pydantic import BaseModel, ConfigDict, Field, ValidationError, model_validator
 
+from taskmaestro.conditions import Condition, when
 from taskmaestro.context import ExecutionContext
-from taskmaestro.dependencies import CollectionDependency, OutputReference, collect
+from taskmaestro.dependencies import (
+    CollectionDependency,
+    FirstOfDependency,
+    OutputReference,
+    collect,
+    first_of,
+)
 from taskmaestro.discovery import (
     get_registered_task,
     get_registered_workflow,
@@ -47,6 +54,54 @@ class TaskMapConfig(BaseModel):
     error_mode: typing.Literal["fail_fast", "collect_all"] = "fail_fast"
 
 
+class WhenConfig(BaseModel):
+    """The ``when:`` condition of a YAML task entry.
+
+    Either a switch case, ``{switch: route, case: express}`` (``case`` may be a
+    list) or ``{switch: route, otherwise: true}``, or a condition on an output
+    field: ``{ref: [task, field], equals: value}`` with ``in: [...]`` or
+    ``truthy: true|false`` instead of ``equals``.
+    """
+
+    model_config = ConfigDict(extra="forbid", populate_by_name=True)
+
+    switch: str | None = None
+    case: Any = None
+    otherwise: bool = False
+    ref: str | list[str] | None = None
+    equals: Any = None
+    in_: list[Any] | None = Field(default=None, alias="in")
+    truthy: bool | None = None
+
+    @model_validator(mode="after")
+    def _check_form(self) -> WhenConfig:
+        given = self.model_fields_set
+        field_ops = given & {"equals", "in_", "truthy"}
+        if self.switch is not None:
+            if self.ref is not None or field_ops:
+                raise ValueError("'when' with 'switch' accepts only 'case' or 'otherwise'")
+            if ("case" in given) == self.otherwise:
+                raise ValueError("'when' with 'switch' needs either 'case' or 'otherwise: true'")
+            if "case" in given and (self.case is None or self.case == []):
+                raise ValueError("'when' 'case' needs at least one branch label")
+            return self
+        if self.ref is not None:
+            if given & {"case", "otherwise"}:
+                raise ValueError("'when' with 'ref' does not accept 'case' or 'otherwise'")
+            if len(field_ops) != 1:
+                raise ValueError("'when' with 'ref' needs exactly one of 'equals', 'in', 'truthy'")
+            if "truthy" in given and self.truthy is None:
+                raise ValueError("'when' 'truthy' must be true or false")
+            if "in_" in given and not self.in_:
+                raise ValueError("'when' 'in' needs at least one value")
+            if isinstance(self.ref, list) and (
+                len(self.ref) != 2 or not all(isinstance(item, str) for item in self.ref)
+            ):
+                raise ValueError("'when' 'ref' must be a task name or [task, field]")
+            return self
+        raise ValueError("'when' needs either 'switch' or 'ref'")
+
+
 class TaskConfig(BaseModel):
     """A single task entry in the YAML workflow config."""
 
@@ -57,6 +112,7 @@ class TaskConfig(BaseModel):
     depends_on: str | list[str] | dict[str, Any] | None = None
     config_fields: list[str] | None = None
     map: TaskMapConfig | None = None
+    when: WhenConfig | None = None
 
     @model_validator(mode="after")
     def _check_task_or_workflow(self) -> TaskConfig:
@@ -436,9 +492,46 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
             f"'collect' must contain a list or mapping for task '{context_task}'"
         )
 
-    # 6. Detect linear vs DAG mode
+    def _resolve_yaml_alternatives(raw_members: Any, context_task: str) -> FirstOfDependency:
+        """Resolve a YAML first_of list."""
+        if not isinstance(raw_members, list) or len(raw_members) < 2:
+            raise ConfigLoadError(
+                f"'first_of' must contain a list of at least two members for task '{context_task}'"
+            )
+        return first_of(
+            *(_resolve_yaml_output_ref(member, context_task) for member in raw_members)
+        )
+
+    def _resolve_yaml_condition(raw: WhenConfig | None, context_task: str) -> Condition | None:
+        """Resolve a YAML ``when:`` entry to a condition."""
+        if raw is None:
+            return None
+        if raw.switch is not None:
+            source = _resolve_yaml_dep(raw.switch, context_task, what="Condition switch")
+            if raw.otherwise:
+                return Condition(source, "otherwise")
+            cases = raw.case if isinstance(raw.case, list) else [raw.case]
+            return Condition(source, "in", tuple(cases))
+        assert raw.ref is not None
+        ref: OutputReference
+        if isinstance(raw.ref, list):
+            ref = (_resolve_yaml_dep(raw.ref[0], context_task, what="Condition"), raw.ref[1])
+        else:
+            ref = _resolve_yaml_dep(raw.ref, context_task, what="Condition")
+        given = raw.model_fields_set
+        if "equals" in given:
+            return when(ref, equals=raw.equals)
+        if "in_" in given:
+            assert raw.in_  # checked by WhenConfig
+            return when(ref, in_=raw.in_)
+        assert raw.truthy is not None  # checked by WhenConfig
+        return when(ref, truthy=raw.truthy)
+
+    # 6. Detect linear vs DAG mode. Conditions refer to other tasks, so a
+    #    workflow with a 'when' entry is a DAG as well.
     has_depends_on = any(
-        tc.depends_on is not None or tc.map is not None for tc in config.workflow.tasks
+        tc.depends_on is not None or tc.map is not None or tc.when is not None
+        for tc in config.workflow.tasks
     )
 
     # 6b. Input YAML always uses per-task configuration. Top-level keys are
@@ -485,12 +578,14 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
         previous_registered = registered_name
 
         try:
+            condition = _resolve_yaml_condition(task_config.when, key)
             if deps is None:
                 builder.add_task(
                     cls,
                     name=instance_name,
                     config_fields=cfg_fields,
                     mapped_over=mapped_over,
+                    when=condition,
                 )
             elif isinstance(deps, _LinearDep):
                 builder.add_task(
@@ -499,6 +594,7 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
                     depends_on=deps.upstream,
                     config_fields=cfg_fields,
                     mapped_over=mapped_over,
+                    when=condition,
                 )
             elif isinstance(deps, str):
                 resolved_dep = _resolve_yaml_dep(deps, key)
@@ -508,6 +604,7 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
                     depends_on=resolved_dep,
                     config_fields=cfg_fields,
                     mapped_over=mapped_over,
+                    when=condition,
                 )
             elif isinstance(deps, list):
                 if len(deps) != 2 or not all(isinstance(e, str) for e in deps):
@@ -523,6 +620,7 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
                     depends_on=(resolved_dep, field_name),
                     config_fields=cfg_fields,
                     mapped_over=mapped_over,
+                    when=condition,
                 )
             elif isinstance(deps, dict):
                 fan_in: dict[
@@ -530,11 +628,16 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
                     type[Task[Any, Any]]
                     | str
                     | tuple[type[Task[Any, Any]] | str, str]
-                    | CollectionDependency,
+                    | CollectionDependency
+                    | FirstOfDependency,
                 ] = {}
                 for field_name, upstream_ref in deps.items():
                     if isinstance(upstream_ref, dict) and set(upstream_ref) == {"collect"}:
                         fan_in[field_name] = _resolve_yaml_collection(upstream_ref["collect"], key)
+                    elif isinstance(upstream_ref, dict) and set(upstream_ref) == {"first_of"}:
+                        fan_in[field_name] = _resolve_yaml_alternatives(
+                            upstream_ref["first_of"], key
+                        )
                     elif isinstance(upstream_ref, list):
                         if len(upstream_ref) != 2 or not all(
                             isinstance(e, str) for e in upstream_ref
@@ -561,6 +664,7 @@ def _resolve_yaml_collection(raw_collection: Any, context_task: str) -> Collecti
                     depends_on=fan_in,
                     config_fields=cfg_fields,
                     mapped_over=mapped_over,
+                    when=condition,
                 )
         except WorkflowDefinitionError as exc:
             raise ConfigLoadError(f"Workflow validation failed: {exc}") from exc
diff --git a/tests/test_condition_tasks.py b/tests/test_condition_tasks.py
new file mode 100644
index 0000000..fa6fce8
--- /dev/null
+++ b/tests/test_condition_tasks.py
@@ -0,0 +1,105 @@
+"""Tests for the ready-made condition tasks in ``taskmaestro.condition_tasks``."""
+
+from __future__ import annotations
+
+import tomllib
+from importlib import import_module
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from taskmaestro import ExecutionContext, Job, JobConfiguration, Runner, Workflow, first_of
+from taskmaestro.condition_tasks import (
+    Compare,
+    CompareInput,
+    IsTrue,
+    IsTrueInput,
+    PathExists,
+    PathExistsInput,
+)
+from taskmaestro.conditions import is_switch_task
+from tests.conftest import AddOne, Double, NumberInput, NumberOutput
+from tests.test_conditions import Join, Negate
+
+
+@pytest.mark.parametrize(
+    ("value", "op", "threshold", "expected"),
+    [
+        (3, ">=", 3, True),
+        (2.5, ">=", 3, False),
+        (2, "<", 3, True),
+        (3, "<=", 3, True),
+        (3, "==", 3.0, True),
+        (3, "!=", 3, False),
+        (4, ">", 3, True),
+    ],
+)
+def test_compare(value: float, op: Any, threshold: float, expected: bool) -> None:
+    input = CompareInput(value=value, op=op, threshold=threshold)
+    assert Compare().decide(input, ExecutionContext()) is expected
+
+
+def test_compare_defaults_to_greater_or_equal() -> None:
+    assert CompareInput(value=1, threshold=0).op == ">="
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [(True, True), (1, True), ("x", True), (0, False), ("", False), (None, False), ([], False)],
+)
+def test_is_true(value: Any, expected: bool) -> None:
+    assert IsTrue().decide(IsTrueInput(value=value), ExecutionContext()) is expected
+
+
+def test_path_exists(tmp_path: Path) -> None:
+    file = tmp_path / "file.txt"
+    file.write_text("x")
+    ctx = ExecutionContext()
+
+    def check(path: Path, kind: Any = "any") -> bool:
+        return PathExists().decide(PathExistsInput(path=path, kind=kind), ctx)
+
+    assert check(file) and check(file, "file") and not check(file, "directory")
+    assert check(tmp_path) and check(tmp_path, "directory") and not check(tmp_path, "file")
+    assert not check(tmp_path / "missing")
+
+
+def test_condition_tasks_are_switch_tasks() -> None:
+    for task in (Compare, IsTrue, PathExists):
+        assert is_switch_task(task)
+        assert task.branches == (True, False)
+
+
+def test_condition_tasks_are_registered() -> None:
+    pyproject = tomllib.loads((Path(__file__).parents[1] / "pyproject.toml").read_text())
+    registered = pyproject["project"]["entry-points"]["taskmaestro.tasks"]
+    loaded = {}
+    for name, target in registered.items():
+        module, _, attribute = target.partition(":")
+        loaded[name] = getattr(import_module(module), attribute)
+    condition_entries = {
+        name: obj for name, obj in loaded.items() if name.startswith("condition.")
+    }
+    assert condition_entries == {
+        "condition.compare": Compare,
+        "condition.is_true": IsTrue,
+        "condition.path_exists": PathExists,
+    }
+
+
+@pytest.mark.parametrize(("start", "result"), [(1, 4), (5, -6)])
+def test_compare_routes_on_upstream_field(start: int, result: int) -> None:
+    builder = Workflow.builder("compare")
+    added = builder.task(AddOne)
+    large = builder.task(Compare, value=added.field("value"), config_fields=["op", "threshold"])
+    yes = builder.task(Negate, depends_on=added, when=large.if_true())
+    no = builder.task(Double, depends_on=added, when=large.if_false())
+    builder.task(Join, picked=first_of(yes, no))
+    job = Job(
+        workflow=builder.build(),
+        config=NumberInput(value=start),
+        job_configuration=JobConfiguration({"compare": {"op": ">", "threshold": 3}}),
+    )
+
+    assert Runner().run(job).result == NumberOutput(value=result)
diff --git a/tests/test_conditions.py b/tests/test_conditions.py
new file mode 100644
index 0000000..8ddeabe
--- /dev/null
+++ b/tests/test_conditions.py
@@ -0,0 +1,1026 @@
+"""Tests for conditional branches: switch/condition tasks, guards and first_of."""
+
+from __future__ import annotations
+
+import enum
+import json
+import logging
+import subprocess
+import sys
+from pathlib import Path
+from typing import Any, Generic, Literal, TypeVar
+
+import pytest
+from pydantic import BaseModel
+
+from taskmaestro import (
+    ConditionTask,
+    ContextFlag,
+    ExecutionContext,
+    Job,
+    JobConfiguration,
+    JobStatus,
+    ResultTaskSkippedError,
+    Runner,
+    SwitchTask,
+    Task,
+    TaskStatus,
+    Workflow,
+    WorkflowDefinitionError,
+    collect,
+    first_of,
+    load_workflow_from_yaml,
+    to_mermaid,
+    when,
+)
+from taskmaestro.cli import main as cli_main
+from taskmaestro.conditions import Condition
+from taskmaestro.definition import definition_from_workflow, load_definition, write_definition
+from taskmaestro.exceptions import ConfigLoadError, ContextValueMissingError, DefinitionError
+from taskmaestro.hooks import LoggingHook
+from taskmaestro.hooks.base import BaseHook
+from taskmaestro.introspection import describe_workflow
+from tests.conftest import AddOne, Double, NumberInput, NumberOutput
+
+L = TypeVar("L")
+
+EXAMPLES = Path(__file__).resolve().parents[1] / "examples"
+
+# --- Tasks ---
+
+
+class Route(SwitchTask[NumberOutput, Literal["small", "medium", "large"]]):
+    name = "route"
+
+    def decide(
+        self, input: NumberOutput, ctx: ExecutionContext
+    ) -> Literal["small", "medium", "large"]:
+        if input.value < 10:
+            return "small"
+        if input.value < 100:
+            return "medium"
+        return "large"
+
+
+class IsEven(ConditionTask[NumberOutput]):
+    name = "is_even"
+
+    def decide(self, input: NumberOutput, ctx: ExecutionContext) -> bool:
+        return input.value % 2 == 0
+
+
+class Color(enum.StrEnum):
+    RED = "red"
+    BLUE = "blue"
+
+
+class PickColor(SwitchTask[NumberOutput, Color]):
+    name = "pick_color"
+
+    def decide(self, input: NumberOutput, ctx: ExecutionContext) -> Color:
+        return Color.RED if input.value % 2 else Color.BLUE
+
+
+class Triple(Task[NumberOutput, NumberOutput]):
+    name = "triple"
+
+    def run(self, input: NumberOutput, ctx: ExecutionContext) -> NumberOutput:
+        return NumberOutput(value=input.value * 3)
+
+
+class Negate(Task[NumberOutput, NumberOutput]):
+    name = "negate"
+
+    def run(self, input: NumberOutput, ctx: ExecutionContext) -> NumberOutput:
+        return NumberOutput(value=-input.value)
+
+
+class Flagged(BaseModel):
+    value: int
+    flag: bool
+
+
+class MakeFlag(Task[NumberOutput, Flagged]):
+    name = "make_flag"
+
+    def run(self, input: NumberOutput, ctx: ExecutionContext) -> Flagged:
+        return Flagged(value=input.value, flag=input.value > 5)
+
+
+class MaybeFlag(BaseModel):
+    note: str | None
+
+
+class MaybeCount(BaseModel):
+    count: int | None
+
+
+class MakeMaybeCount(Task[NumberOutput, MaybeCount]):
+    name = "make_maybe_count"
+
+    def run(self, input: NumberOutput, ctx: ExecutionContext) -> MaybeCount:
+        return MaybeCount(count=None if input.value > 5 else input.value - 2)
+
+
+class MakeMaybeFlag(Task[NumberOutput, MaybeFlag]):
+    name = "make_maybe_flag"
+
+    def run(self, input: NumberOutput, ctx: ExecutionContext) -> MaybeFlag:
+        return MaybeFlag(note="big" if input.value > 5 else None)
+
+
+class Item(BaseModel):
+    key: str
+    value: int
+
+
+class ItemFlag(Task[Item, Flagged]):
+    name = "item_flag"
+
+    def run(self, input: Item, ctx: ExecutionContext) -> Flagged:
+        return Flagged(value=input.value, flag=True)
+
+
+class JoinInput(BaseModel):
+    picked: NumberOutput
+
+
+class Join(Task[JoinInput, NumberOutput]):
+    name = "join"
+
+    def run(self, input: JoinInput, ctx: ExecutionContext) -> NumberOutput:
+        return input.picked
+
+
+class CollectInput(BaseModel):
+    values: list[NumberOutput]
+
+
+class CountValues(Task[CollectInput, NumberOutput]):
+    name = "count_values"
+
+    def run(self, input: CollectInput, ctx: ExecutionContext) -> NumberOutput:
+        return NumberOutput(value=len(input.values))
+
+
+class WhenInput(BaseModel):
+    when: NumberOutput
+
+
+class UsesWhenField(Task[WhenInput, NumberOutput]):
+    name = "uses_when_field"
+
+    def run(self, input: WhenInput, ctx: ExecutionContext) -> NumberOutput:
+        return input.when
+
+
+class SkipRecorder(BaseHook):
+    def __init__(self) -> None:
+        self.events: list[str] = []
+
+    def on_task_start(self, job: Job[Any], task: Task[Any, Any]) -> None:
+        self.events.append(f"start:{task.name}")
+
+    def on_task_skip(self, job: Job[Any], task_name: str, reason: str) -> None:
+        self.events.append(f"skip:{task_name}")
+
+    def on_job_fail(self, job: Job[Any]) -> None:
+        self.events.append("job_fail")
+
+
+def _run(workflow: Workflow, value: int, hooks: list[Any] | None = None) -> Job[Any]:
+    return Runner(hooks=hooks or []).run(Job(workflow=workflow, config=NumberInput(value=value)))
+
+
+def _status(job: Job[Any]) -> dict[str, TaskStatus]:
+    return {result.task_name: result.status for result in job.task_results}
+
+
+def _switch_workflow() -> Workflow:
+    builder = Workflow.builder("routing")
+    start = builder.task(AddOne)
+    route = builder.task(Route, depends_on=start)
+    small = builder.task(Double, depends_on=start, when=route.on("small"))
+    other = builder.task(Triple, depends_on=start, when=route.otherwise())
+    builder.task(Join, picked=first_of(small, other))
+    return builder.build()
+
+
+# --- Routing ---
+
+
+@pytest.mark.parametrize(
+    ("value", "ran", "skipped", "result"),
+    [(1, "double", "triple", 4), (20, "triple", "double", 63), (500, "triple", "double", 1503)],
+)
+def test_switch_routes_and_first_of_joins(value: int, ran: str, skipped: str, result: int) -> None:
+    job = _run(_switch_workflow(), value)
+
+    assert job.status == JobStatus.COMPLETED
+    assert job.result == NumberOutput(value=result)
+    status = _status(job)
+    assert status[ran] == TaskStatus.COMPLETED
+    assert status[skipped] == TaskStatus.SKIPPED
+    assert job.skipped_tasks == [skipped]
+
+
+def test_condition_task_if_true_and_if_false() -> None:
+    builder = Workflow.builder("if")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    yes = builder.task(Double, depends_on=start, when=even.if_true())
+    no = builder.task(Negate, depends_on=start, when=even.if_false())
+    builder.task(Join, picked=first_of(yes, no))
+    workflow = builder.build()
+
+    assert _run(workflow, 1).result == NumberOutput(value=4)
+    assert _run(workflow, 2).result == NumberOutput(value=-3)
+
+
+@pytest.mark.parametrize(
+    ("value", "truthy_runs"),
+    [(1, True), (2, True), (9, False)],  # counts 0, 1 and None
+)
+def test_truthy_guard_on_optional_non_bool_tests_presence(value: int, truthy_runs: bool) -> None:
+    builder = Workflow.builder("presence")
+    start = builder.task(AddOne)
+    maybe = builder.task(MakeMaybeCount, depends_on=start)
+    builder.task(Double, depends_on=start, when=maybe.field("count").truthy())
+    builder.task(Negate, depends_on=start, when=maybe.field("count").falsy())
+    builder.set_result_task(MakeMaybeCount)
+    status = _status(_run(builder.build(), value))
+
+    assert status["double"] == (TaskStatus.COMPLETED if truthy_runs else TaskStatus.SKIPPED)
+    assert status["negate"] == (TaskStatus.SKIPPED if truthy_runs else TaskStatus.COMPLETED)
+
+
+def test_enum_switch_accepts_members_and_values() -> None:
+    builder = Workflow.builder("enum")
+    start = builder.task(AddOne)
+    color = builder.task(PickColor, depends_on=start)
+    red = builder.task(Double, depends_on=start, when=color.on(Color.RED))
+    blue = builder.task(Negate, depends_on=start, when=color.on("blue"))
+    builder.task(Join, picked=first_of(red, blue))
+    workflow = builder.build()
+
+    assert _run(workflow, 2).result == NumberOutput(value=6)
+    assert _run(workflow, 1).result == NumberOutput(value=-2)
+
+
+@pytest.mark.parametrize(
+    ("condition", "value", "runs"),
+    [
+        (lambda h: when(h.field("value"), equals=5), 4, True),
+        (lambda h: h.field("value").equals(5), 5, False),
+        (lambda h: when((h, "value"), in_=[1, 2, 3]), 2, True),
+        (lambda h: h.field("value").is_in(7, 8), 2, False),
+        (lambda h: h.field("flag").truthy(), 9, True),
+        (lambda h: h.field("flag").falsy(), 9, False),
+    ],
+)
+def test_field_guards(condition: Any, value: int, runs: bool) -> None:
+    builder = Workflow.builder("field")
+    start = builder.task(AddOne)
+    flagged = builder.task(MakeFlag, depends_on=start)
+    builder.task(Double, depends_on=start, when=condition(flagged))
+    builder.set_result_task(MakeFlag)
+    status = _status(_run(builder.build(), value))
+
+    assert status["double"] == (TaskStatus.COMPLETED if runs else TaskStatus.SKIPPED)
+
+
+@pytest.mark.parametrize(("value", "runs"), [(9, True), (1, False)])
+def test_truthy_guard_on_optional_field(value: int, runs: bool) -> None:
+    builder = Workflow.builder("optional")
+    start = builder.task(AddOne)
+    maybe = builder.task(MakeMaybeFlag, depends_on=start)
+    builder.task(Double, depends_on=start, when=maybe.field("note").truthy())
+    builder.set_result_task(MakeMaybeFlag)
+    status = _status(_run(builder.build(), value))
+
+    assert status["double"] == (TaskStatus.COMPLETED if runs else TaskStatus.SKIPPED)
+
+
+def test_truthy_guard_on_condition_task_claims_its_label() -> None:
+    builder = Workflow.builder("truthy_switch")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    yes = builder.task(Double, depends_on=start, when=when(even, truthy=True))
+    no = builder.task(Negate, depends_on=start, when=even.otherwise())
+    builder.task(Join, picked=first_of(yes, no))
+    workflow = builder.build()
+
+    assert workflow.get_guard("negate").values == (False,)  # type: ignore[union-attr]
+    assert _run(workflow, 1).result == NumberOutput(value=4)
+
+
+# --- Skip semantics ---
+
+
+def test_skip_propagates_and_collect_omits_skipped_members() -> None:
+    builder = Workflow.builder("propagate")
+    start = builder.task(AddOne)
+    flagged = builder.task(MakeFlag, depends_on=start)
+    yes = builder.task(Double, depends_on=start, when=flagged.field("flag").truthy())
+    downstream = builder.task(Negate, depends_on=yes)
+    builder.task(CountValues, values=collect(start, yes, downstream))
+    job = _run(builder.build(), 2)
+
+    assert job.status == JobStatus.COMPLETED
+    assert job.result == NumberOutput(value=1)
+    skipped = {r.task_name: r for r in job.task_results if r.status == TaskStatus.SKIPPED}
+    assert set(skipped) == {"double", "negate"}
+    assert "make_flag.flag" in (skipped["double"].skip_reason or "")
+    assert "double" in (skipped["negate"].skip_reason or "")
+
+
+def test_task_is_skipped_when_its_condition_source_was_skipped() -> None:
+    builder = Workflow.builder("source_skipped")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    flag = builder.task(MakeFlag, depends_on=start, when=even.if_true())
+    builder.task(Negate, depends_on=start, when=even.if_false())
+    builder.task(Double, depends_on=start, when=flag.field("flag").truthy())
+    builder.set_result_task(AddOne)
+    job = _run(builder.build(), 2)
+
+    skipped = {r.task_name: r.skip_reason for r in job.task_results if r.skip_reason}
+    assert skipped["double"] == "condition source 'make_flag' was skipped"
+
+
+def test_first_of_with_every_member_skipped_skips_the_task() -> None:
+    builder = Workflow.builder("all_skipped")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    yes = builder.task(Double, depends_on=start, when=even.if_true())
+    no = builder.task(Negate, depends_on=start, when=even.if_false())
+    gated = builder.task(Triple, depends_on=no, when=even.if_true())
+    builder.task(Join, picked=first_of(yes, gated))
+    builder.set_result_task(AddOne)
+
+    assert _status(_run(builder.build(), 2))["join"] == TaskStatus.SKIPPED
+
+
+def test_skipped_result_task_fails_the_job_and_emits_skip_events() -> None:
+    builder = Workflow.builder("result_skipped")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    builder.task(Double, depends_on=start, when=even.if_true())
+    builder.task(Negate, depends_on=start, when=even.if_false())
+    builder.set_result_task(Double)
+    recorder = SkipRecorder()
+    job = _run(builder.build(), 2, hooks=[recorder])
+
+    assert job.status == JobStatus.FAILED
+    assert isinstance(job.exception, ResultTaskSkippedError)
+    assert job.failed_task == "double"
+    assert recorder.events == [
+        "start:add_one",
+        "start:is_even",
+        "skip:double",
+        "start:negate",
+        "job_fail",
+    ]
+
+
+def test_guarded_map_task_is_skipped_without_running_items() -> None:
+    class Item(BaseModel):
+        key: str
+        amount: int
+
+    class Bump(Task[Item, NumberOutput]):
+        name = "bump"
+
+        def run(self, input: Item, ctx: ExecutionContext) -> NumberOutput:
+            raise AssertionError("mapped items must not run")
+
+    builder = Workflow.builder("mapped")
+    start = builder.task(AddOne)
+    flagged = builder.task(MakeFlag, depends_on=start)
+    builder.map_task(
+        Bump, over="items", key_as="key", value_as="amount", when=flagged.field("flag").truthy()
+    )
+    builder.set_result_task(MakeFlag)
+    job = Runner().run(
+        Job(
+            workflow=builder.build(),
+            config=NumberInput(value=1),
+            job_configuration=JobConfiguration({"bump": {"items": {"a": 1, "b": 2}}}),
+        )
+    )
+
+    assert job.status == JobStatus.COMPLETED
+    assert _status(job)["bump"] == TaskStatus.SKIPPED
+
+
+# --- Validation ---
+
+
+def test_uncovered_switch_label_is_an_error() -> None:
+    builder = Workflow.builder("uncovered")
+    start = builder.task(AddOne)
+    route = builder.task(Route, depends_on=start)
+    builder.task(Double, depends_on=start, when=route.on("small"))
+    builder.set_result_task(Route)
+
+    with pytest.raises(WorkflowDefinitionError, match="no task for branch"):
+        builder.build()
+
+
+def test_unreachable_otherwise_is_an_error() -> None:
+    builder = Workflow.builder("unreachable")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    builder.task(Double, depends_on=start, when=even.if_true())
+    builder.task(Negate, depends_on=start, when=even.if_false())
+    builder.task(Triple, depends_on=start, when=even.otherwise())
+    builder.set_result_task(AddOne)
+
+    with pytest.raises(WorkflowDefinitionError, match="can never match"):
+        builder.build()
+
+
+@pytest.mark.parametrize(
+    ("make_condition", "message"),
+    [
+        (lambda route, flag: route.on("smal"), "not a valid value"),
+        (lambda route, flag: flag.field("flag").equals("no"), "not a valid value"),
+        (lambda route, flag: flag.field("flag").equals(1), "not a valid value"),
+        (lambda route, flag: flag.field("value").equals("5"), "not a valid value"),
+        (lambda route, flag: flag.field("value").truthy(), "requires a bool"),
+        (lambda route, flag: flag.otherwise(), "not a switch task"),
+        (lambda route, flag: when(flag, equals=1), "not a switch task"),
+        (lambda route, flag: when((flag, "missing"), equals=1), "not found on Flagged"),
+    ],
+)
+def test_invalid_guards_are_rejected(make_condition: Any, message: str) -> None:
+    builder = Workflow.builder("invalid")
+    start = builder.task(AddOne)
+    route = builder.task(Route, depends_on=start)
+    builder.task(Triple, depends_on=start, when=route.otherwise())
+    flag = builder.task(MakeFlag, depends_on=start)
+    builder.set_result_task(AddOne)
+
+    with pytest.raises(WorkflowDefinitionError, match=message):
+        builder.task(Double, depends_on=start, when=make_condition(route, flag))
+        builder.build()
+
+
+def test_condition_on_mapped_task_is_rejected() -> None:
+    builder = Workflow.builder("mapped_source")
+    start = builder.task(AddOne)
+    mapped = builder.map_task(ItemFlag, over="items", key_as="key", value_as="value")
+    builder.task(Double, depends_on=start, when=when((mapped, "flag"), truthy=True))
+    builder.set_result_task(AddOne)
+
+    with pytest.raises(WorkflowDefinitionError, match="cannot refer to mapped task"):
+        builder.build()
+
+
+def test_first_of_must_target_a_named_field_without_config() -> None:
+    builder = Workflow.builder("first_of_misuse")
+    start = builder.task(AddOne)
+    other = builder.task(Double, depends_on=start)
+    with pytest.raises(WorkflowDefinitionError, match="named input field"):
+        builder.task(Join, depends_on=first_of(start, other))  # type: ignore[arg-type]
+
+    builder.task(Join, picked=first_of(start, other), config_fields=["picked"])
+    with pytest.raises(WorkflowDefinitionError, match="both a first_of dependency"):
+        builder.build()
+
+
+def test_first_of_needs_two_members_and_is_type_checked() -> None:
+    builder = Workflow.builder("first_of")
+    start = builder.task(AddOne)
+    flag = builder.task(MakeFlag, depends_on=start)
+    with pytest.raises(TypeError, match="at least two"):
+        first_of(start)
+
+    builder.task(Join, picked=first_of(start, flag))
+    with pytest.raises(WorkflowDefinitionError):
+        builder.build()
+
+
+def test_task_input_field_named_when_still_works() -> None:
+    builder = Workflow.builder("back_compat")
+    start = builder.task(AddOne)
+    builder.task(UsesWhenField, when=start)
+
+    assert _run(builder.build(), 1).result == NumberOutput(value=2)
+
+
+def test_switch_without_guards_is_an_ordinary_task() -> None:
+    builder = Workflow.builder("plain_switch")
+    start = builder.task(AddOne)
+    builder.task(Route, depends_on=start)
+
+    assert _run(builder.build(), 1).result.branch == "small"  # type: ignore[union-attr]
+
+
+# --- Surfaces: Mermaid, describe, definition, YAML ---
+
+
+def test_mermaid_draws_switches_as_diamonds_with_dashed_guard_edges() -> None:
+    diagram = to_mermaid(_switch_workflow())
+
+    assert 'route{"route"}' in diagram
+    assert "route -.->|small| double" in diagram
+    assert "route -.->|otherwise| triple" in diagram
+    assert '_first_of_join_picked_(["first_of picked"])' in diagram
+    assert "_first_of_join_picked_ -->|picked: NumberOutput| join" in diagram
+
+
+def test_mermaid_labels_field_guards() -> None:
+    builder = Workflow.builder("field_labels")
+    start = builder.task(AddOne)
+    flag = builder.task(MakeFlag, depends_on=start)
+    builder.task(Double, depends_on=start, when=flag.field("value").equals(3))
+    builder.task(Triple, depends_on=start, when=flag.field("value").is_in(1, 2))
+    builder.task(Negate, depends_on=start, when=flag.field("flag").truthy())
+    builder.task(Join, picked=start, when=flag.field("flag").falsy())
+    builder.set_result_task(AddOne)
+    diagram = to_mermaid(builder.build())
+
+    assert "make_flag -.->|.value = 3| double" in diagram
+    assert "make_flag -.->|.value in 1 / 2| triple" in diagram
+    assert "make_flag -.->|.flag| negate" in diagram
+    assert "make_flag -.->|not .flag| join" in diagram
+
+
+def test_describe_workflow_reports_guards_and_branches() -> None:
+    tasks = {task["name"]: task for task in describe_workflow(_switch_workflow())["tasks"]}
+
+    assert tasks["route"]["branches"] == ["small", "medium", "large"]
+    assert tasks["double"]["when"] == {
+        "task": "route",
+        "field": "branch",
+        "op": "in",
+        "values": ["small"],
+    }
+    assert tasks["triple"]["when"]["values"] == ["medium", "large"]
+    assert tasks["join"]["depends_on"]["picked"] == {
+        "first_of": [{"task": "double", "field": None}, {"task": "triple", "field": None}]
+    }
+
+
+def test_definition_round_trip_keeps_guards_and_first_of(tmp_path: Path) -> None:
+    builder = Workflow.builder("roundtrip")
+    start = builder.task(AddOne, config_fields=["value"])
+    route = builder.task(Route, depends_on=start)
+    small = builder.task(Double, depends_on=start, when=route.on("small", "medium"))
+    large = builder.task(Triple, depends_on=start, when=route.otherwise())
+    flag = builder.task(MakeFlag, depends_on=start)
+    builder.task(Negate, depends_on=large, when=flag.field("flag").truthy())
+    builder.task(Join, picked=first_of(small, large))
+    builder.set_result_task(Join)
+
+    class_ids = {
+        cls: f"{cls.__module__}.{cls.__name__}"
+        for cls in (AddOne, Route, Double, Triple, MakeFlag, Negate, Join)
+    }
+    write_definition(definition_from_workflow(builder.build(), None, class_ids), tmp_path)
+    text = (tmp_path / "workflow.yaml").read_text()
+    assert "case: [small, medium]" in text
+    assert "otherwise: true" in text
+    assert "ref: [make_flag, flag]" in text
+
+    reloaded = load_definition(tmp_path)
+    nodes = {node["name"]: node for node in reloaded["nodes"]}
+    assert nodes["triple"]["when"] == {"switch": "route", "otherwise": True}
+    assert [e["from"] for e in reloaded["edges"] if e.get("collect") == "first_of"] == [
+        "double",
+        "triple",
+    ]
+    (tmp_path / "input.yaml").write_text("add_one: {value: 200}\n")
+    job = load_workflow_from_yaml(tmp_path / "workflow.yaml", tmp_path / "input.yaml").run()
+    assert job.result == NumberOutput(value=603)
+
+
+YAML_WORKFLOW = """\
+workflow:
+  name: yaml_routing
+  result_task: join
+  tasks:
+    - task: tests.conftest.AddOne
+      name: add_one
+      config_fields: [value]
+    - task: tests.test_conditions.Route
+      name: route
+      depends_on: add_one
+    - task: tests.conftest.Double
+      name: double
+      depends_on: add_one
+      when: {switch: route, case: [small, medium]}
+    - task: tests.test_conditions.Triple
+      name: triple
+      depends_on: add_one
+      when: {switch: route, otherwise: true}
+    - task: tests.test_conditions.MakeFlag
+      name: make_flag
+      depends_on: add_one
+    - task: tests.test_conditions.Negate
+      name: negate
+      depends_on: add_one
+      when: {ref: [make_flag, flag], truthy: false}
+    - task: tests.test_conditions.Join
+      name: join
+      depends_on:
+        picked:
+          first_of: [double, triple]
+"""
+
+
+@pytest.mark.parametrize(
+    ("value", "result", "negate"), [(1, 4, TaskStatus.COMPLETED), (499, 1500, TaskStatus.SKIPPED)]
+)
+def test_yaml_when_and_first_of(
+    tmp_path: Path, value: int, result: int, negate: TaskStatus
+) -> None:
+    (tmp_path / "workflow.yaml").write_text(YAML_WORKFLOW)
+    (tmp_path / "input.yaml").write_text(f"add_one: {{value: {value}}}\n")
+
+    job = load_workflow_from_yaml(tmp_path / "workflow.yaml", tmp_path / "input.yaml").run()
+
+    assert job.result == NumberOutput(value=result)
+    assert _status(job)["negate"] == negate
+
+
+FIELD_GUARD_YAML = """\
+workflow:
+  name: field_guards
+  result_task: add_one
+  tasks:
+    - task: tests.conftest.AddOne
+      name: add_one
+      config_fields: [value]
+    - task: tests.test_conditions.Route
+      name: route
+      depends_on: add_one
+    - task: tests.conftest.Double
+      name: double
+      depends_on: add_one
+      when: {ref: route, in: [small, medium]}
+    - task: tests.test_conditions.Triple
+      name: triple
+      depends_on: add_one
+      when: {switch: route, case: large}
+    - task: tests.test_conditions.Negate
+      name: negate
+      depends_on: add_one
+      when: {ref: [add_one, value], equals: 3}
+    - task: tests.test_conditions.Join
+      name: join
+      depends_on:
+        picked: add_one
+      when: {ref: [add_one, value], in: [1, 2]}
+"""
+
+
+def test_yaml_field_guards_run_and_round_trip(tmp_path: Path) -> None:
+    source = tmp_path / "source"
+    source.mkdir()
+    (source / "workflow.yaml").write_text(FIELD_GUARD_YAML)
+    (source / "input.yaml").write_text("add_one: {value: 2}\n")
+    job = load_workflow_from_yaml(source / "workflow.yaml", source / "input.yaml").run()
+    assert _status(job) == {
+        "add_one": TaskStatus.COMPLETED,
+        "route": TaskStatus.COMPLETED,
+        "double": TaskStatus.COMPLETED,
+        "triple": TaskStatus.SKIPPED,
+        "negate": TaskStatus.COMPLETED,
+        "join": TaskStatus.SKIPPED,
+    }
+
+    definition = load_definition(source)
+    nodes = {node["name"]: node for node in definition["nodes"]}
+    assert nodes["double"]["when"] == {"ref": "route", "in": ["small", "medium"]}
+    saved = tmp_path / "saved"
+    write_definition(definition, saved)
+    text = (saved / "workflow.yaml").read_text()
+    assert "in: [small, medium]" in text
+    assert "equals: 3" in text
+    assert "in: [1, 2]" in text
+
+    builder = Workflow.builder("field_guards")
+    start = builder.task(AddOne, config_fields=["value"])
+    builder.task(Negate, depends_on=start, when=start.field("value").equals(3))
+    builder.task(Join, picked=start, when=start.field("value").is_in(1, 2))
+    builder.set_result_task(AddOne)
+    generated = definition_from_workflow(builder.build(), None, {})
+    whens = {node["name"]: node.get("when") for node in generated["nodes"]}
+    assert whens["negate"] == {"ref": ["add_one", "value"], "equals": 3}
+    assert whens["join"] == {"ref": ["add_one", "value"], "in": [1, 2]}
+
+
+def test_saving_a_condition_on_an_unknown_task_is_rejected(tmp_path: Path) -> None:
+    (tmp_path / "workflow.yaml").write_text(FIELD_GUARD_YAML)
+    definition = load_definition(tmp_path)
+    triple = next(node for node in definition["nodes"] if node["name"] == "triple")
+    triple["when"] = {"switch": "missing", "case": "large"}
+
+    with pytest.raises(DefinitionError, match="unknown task 'missing'"):
+        write_definition(definition, tmp_path / "out")
+
+
+@pytest.mark.parametrize(
+    "when_yaml",
+    [
+        "{switch: route}",
+        "{switch: route, case: small, otherwise: true}",
+        "{ref: [make_flag, flag]}",
+        "{ref: [make_flag, flag], equals: 1, truthy: true}",
+        "{switch: route, ref: add_one, case: small}",
+        "{case: small}",
+        "{switch: route, case: []}",
+        "{ref: [make_flag, flag], otherwise: true, truthy: true}",
+        "{ref: [make_flag], truthy: true}",
+        "{ref: [make_flag, value], in: []}",
+        "{ref: [make_flag, value], in: null}",
+        "{ref: [make_flag, flag], truthy: null}",
+    ],
+)
+def test_yaml_rejects_malformed_when(tmp_path: Path, when_yaml: str) -> None:
+    workflow = YAML_WORKFLOW.replace("{switch: route, otherwise: true}", when_yaml)
+    (tmp_path / "workflow.yaml").write_text(workflow)
+    (tmp_path / "input.yaml").write_text("add_one: {value: 1}\n")
+
+    with pytest.raises(ConfigLoadError):
+        load_workflow_from_yaml(tmp_path / "workflow.yaml", tmp_path / "input.yaml")
+
+
+@pytest.mark.parametrize("example", ["conditional_if", "conditional_switch"])
+@pytest.mark.parametrize("mode", [[], ["--yaml"]])
+def test_conditional_examples_run(example: str, mode: list[str]) -> None:
+    completed = subprocess.run(
+        [sys.executable, str(EXAMPLES / example / "pipeline.py"), *mode],
+        capture_output=True,
+        text=True,
+        check=True,
+    )
+
+    assert "Status: completed" in completed.stdout
+    assert "skipped" in completed.stdout
+
+
+# --- ContextFlag ---
+
+
+def _flag_workflow() -> Workflow:
+    builder = Workflow.builder("flag")
+    start = builder.task(AddOne)
+    dry = builder.task(ContextFlag, name="dry_run", config_fields=["key"])
+    yes = builder.task(Negate, depends_on=start, when=dry.if_true())
+    no = builder.task(Double, depends_on=start, when=dry.if_false())
+    builder.task(Join, picked=first_of(yes, no))
+    return builder.build()
+
+
+def _flag_job() -> Job[Any]:
+    return Job(
+        workflow=_flag_workflow(),
+        config=NumberInput(value=1),
+        job_configuration=JobConfiguration({"dry_run": {"key": "dry"}}),
+    )
+
+
+@pytest.mark.parametrize(("value", "result"), [(True, -2), ("", 4)])
+def test_context_flag_routes_on_context_value(value: Any, result: int) -> None:
+    ctx = ExecutionContext()
+    ctx.register("dry", value)
+
+    assert Runner().run(_flag_job(), ctx=ctx).result == NumberOutput(value=result)
+
+
+def test_context_flag_with_unregistered_key_fails_before_any_task() -> None:
+    recorder = SkipRecorder()
+    job = _flag_job()
+
+    with pytest.raises(ContextValueMissingError, match="'dry' \\(task 'dry_run'\\)"):
+        Runner(hooks=[recorder]).run(job, ctx=ExecutionContext())
+    assert job.status == JobStatus.PENDING
+    assert recorder.events == []
+
+
+@pytest.mark.parametrize("as_json", [False, True])
+def test_cli_reports_unregistered_context_flag_key(
+    tmp_path: Path, capsys: pytest.CaptureFixture[str], as_json: bool
+) -> None:
+    (tmp_path / "workflow.yaml").write_text(
+        """\
+workflow:
+  name: cli_flag
+  tasks:
+    - task: tests.conftest.AddOne
+      name: add_one
+      config_fields: [value]
+    - task: taskmaestro.ContextFlag
+      name: dry_run
+      config_fields: [key]
+    - task: tests.conftest.Double
+      name: double
+      depends_on: add_one
+      when: {switch: dry_run, case: false}
+    - task: tests.test_conditions.Negate
+      name: negate
+      depends_on: add_one
+      when: {switch: dry_run, case: true}
+    - task: tests.test_conditions.Join
+      name: join
+      depends_on:
+        picked:
+          first_of: [double, negate]
+"""
+    )
+    (tmp_path / "input.yaml").write_text("add_one: {value: 1}\ndry_run: {key: dry}\n")
+    args = ["run", str(tmp_path / "workflow.yaml"), "--input", str(tmp_path / "input.yaml")]
+
+    assert cli_main([*args, "--json"] if as_json else args) == 2
+    captured = capsys.readouterr()
+    if as_json:
+        payload = json.loads(captured.out)
+        assert payload["status"] == "invalid"
+        assert "'dry' (task 'dry_run')" in payload["error"]["message"]
+    else:
+        assert "'dry' (task 'dry_run')" in captured.err
+
+
+# --- Edge cases and error branches ---
+
+
+class Verdict(BaseModel):
+    ok: Literal[True, False]
+    data: Any
+
+
+class MakeVerdict(Task[NumberOutput, Verdict]):
+    name = "make_verdict"
+
+    def run(self, input: NumberOutput, ctx: ExecutionContext) -> Verdict:
+        return Verdict(ok=input.value > 5, data=input.value)
+
+
+class GenericSwitch(SwitchTask[NumberOutput, L], Generic[L]):
+    """Intermediate generic switch; concrete labels come from subclasses."""
+
+    def decide(self, input: NumberOutput, ctx: ExecutionContext) -> Any:
+        return self.branches[-1]
+
+
+class LabelMixin:
+    """A non-switch base listed before the switch base."""
+
+
+class ConcreteSwitch(LabelMixin, GenericSwitch[Literal["first", "last"]]):
+    name = "concrete_switch"
+
+
+class RenamedConcreteSwitch(ConcreteSwitch):
+    name = "renamed_switch"
+
+
+class UnlabelledSwitch(SwitchTask):  # type: ignore[type-arg]
+    def decide(self, input: Any, ctx: ExecutionContext) -> Any:
+        return None
+
+
+def test_generic_switch_base_resolves_labels_in_concrete_subclasses() -> None:
+    assert GenericSwitch.branches == ()
+    assert UnlabelledSwitch.branches == ()
+    assert ConcreteSwitch.branches == ("first", "last")
+    assert RenamedConcreteSwitch.branches == ("first", "last")
+
+    builder = Workflow.builder("generic_switch")
+    start = builder.task(AddOne)
+    switch = builder.task(ConcreteSwitch, depends_on=start)
+    builder.task(Double, depends_on=start, when=switch.on("first"))
+    builder.task(Triple, depends_on=start, when=switch.on("last"))
+    builder.set_result_task(AddOne)
+    status = _status(_run(builder.build(), 1))
+
+    assert status["double"] == TaskStatus.SKIPPED
+    assert status["triple"] == TaskStatus.COMPLETED
+
+
+def test_switch_label_type_must_be_bool_literal_or_enum() -> None:
+    with pytest.raises(TypeError, match="Switch label type must be"):
+
+        class IntSwitch(SwitchTask[NumberOutput, int]):
+            def decide(self, input: NumberOutput, ctx: ExecutionContext) -> int:
+                return 0
+
+
+@pytest.mark.parametrize(
+    ("make", "message"),
+    [
+        (lambda h: when(h), "exactly one of"),
+        (lambda h: when(h, equals=1, truthy=True), "exactly one of"),
+        (lambda h: when(h, in_=[]), "at least one value"),
+        (lambda h: when(h, in_="abc"), "not a string"),
+        (lambda h: h.on(), "at least one branch label"),
+    ],
+)
+def test_condition_helpers_reject_bad_arguments(make: Any, message: str) -> None:
+    builder = Workflow.builder("helpers")
+    route = builder.task(Route, depends_on=builder.task(AddOne))
+
+    with pytest.raises(TypeError, match=message):
+        make(route)
+
+
+def test_guards_on_literal_bool_and_any_fields() -> None:
+    builder = Workflow.builder("verdict")
+    start = builder.task(AddOne)
+    verdict = builder.task(MakeVerdict, depends_on=start)
+    builder.task(Double, depends_on=start, when=verdict.field("ok").truthy())
+    builder.task(Negate, depends_on=start, when=verdict.field("data").equals(2))
+    builder.task(Triple, depends_on=start, when=verdict.field("ok").equals(True))
+    builder.set_result_task(AddOne)
+    workflow = builder.build()
+
+    assert workflow.is_conditional("double")
+    assert not workflow.is_conditional("add_one")
+    assert "make_verdict -.->|.ok = true| triple" in to_mermaid(workflow)
+    status = _status(_run(workflow, 1))
+    assert status["double"] == TaskStatus.SKIPPED
+    assert status["negate"] == TaskStatus.COMPLETED
+
+
+@pytest.mark.parametrize(
+    ("add", "message"),
+    [
+        (
+            lambda b, flag: b.add_task(Double, depends_on="add_one", when=flag),
+            "must be a condition",
+        ),
+        (
+            lambda b, flag: b.add_task(
+                Double, depends_on="add_one", when=Condition((flag, "flag"), "otherwise")
+            ),
+            "requires a switch task",
+        ),
+        (
+            lambda b, flag: b.add_task(
+                Double, depends_on="add_one", when=Condition("missing", "in", (1,))
+            ),
+            "missing",
+        ),
+        (
+            lambda b, flag: b.task(Join, picked=first_of((flag, "flag"), "add_one")),
+            "'make_flag.flag' produces bool",
+        ),
+    ],
+)
+def test_builder_rejects_invalid_conditions(add: Any, message: str) -> None:
+    builder = Workflow.builder("builder_errors")
+    builder.task(AddOne)
+    flag = builder.task(MakeFlag, depends_on="add_one")
+    builder.set_result_task(AddOne)
+
+    with pytest.raises(WorkflowDefinitionError, match=message):
+        add(builder, flag)
+        builder.build()
+
+
+def test_yaml_first_of_needs_two_members(tmp_path: Path) -> None:
+    (tmp_path / "workflow.yaml").write_text(YAML_WORKFLOW.replace("[double, triple]", "[double]"))
+    (tmp_path / "input.yaml").write_text("add_one: {value: 1}\n")
+
+    with pytest.raises(ConfigLoadError, match="at least two members"):
+        load_workflow_from_yaml(tmp_path / "workflow.yaml", tmp_path / "input.yaml")
+
+
+def test_definition_rejects_malformed_first_of_and_conditions(tmp_path: Path) -> None:
+    broken = tmp_path / "broken"
+    broken.mkdir()
+    (broken / "workflow.yaml").write_text(
+        YAML_WORKFLOW.replace("first_of: [double, triple]", "first_of: double")
+    )
+    with pytest.raises(DefinitionError, match="must be a list"):
+        load_definition(broken)
+
+    (tmp_path / "workflow.yaml").write_text(YAML_WORKFLOW)
+    definition = load_definition(tmp_path)
+    join = next(node for node in definition["nodes"] if node["name"] == "join")
+    join["when"] = "always"
+    with pytest.raises(DefinitionError, match="Invalid condition for task 'join'"):
+        write_definition(definition, tmp_path / "out")
+
+    join.pop("when")
+    plain = {"from": "add_one", "output": None, "to": "join", "input": "picked"}
+    definition["edges"].insert(0, plain)
+    with pytest.raises(DefinitionError, match="mixes first_of alternatives"):
+        write_definition(definition, tmp_path / "out")
+
+
+def test_logging_hook_logs_skipped_tasks(caplog: pytest.LogCaptureFixture) -> None:
+    builder = Workflow.builder("logged")
+    start = builder.task(AddOne)
+    even = builder.task(IsEven, depends_on=start)
+    builder.task(Double, depends_on=start, when=even.if_true())
+    builder.task(Negate, depends_on=start, when=even.if_false())
+    builder.set_result_task(AddOne)
+
+    with caplog.at_level(logging.INFO, logger="taskmaestro.hooks.logging"):
+        _run(builder.build(), 2, hooks=[LoggingHook()])
+
+    assert "Task skipped: double, reason=" in caplog.text
diff --git a/tests/test_scripts.py b/tests/test_scripts.py
new file mode 100644
index 0000000..c02e8e8
--- /dev/null
+++ b/tests/test_scripts.py
@@ -0,0 +1,330 @@
+"""Tests for the built-in ``taskmaestro.python`` and ``taskmaestro.command`` tasks."""
+
+from __future__ import annotations
+
+import json
+import os
+import signal
+import subprocess
+import sys
+import textwrap
+import time
+from pathlib import Path
+
+import pytest
+from pydantic import BaseModel
+
+from taskmaestro import (
+    Command,
+    CommandInput,
+    ConfigLoadError,
+    EmptyConfig,
+    ExecutionContext,
+    JobStatus,
+    ObjectModel,
+    PythonScript,
+    PythonScriptInput,
+    ScriptError,
+    WorkflowBuilder,
+    load_workflow_from_yaml,
+    registered_task_names,
+)
+
+ECHO_SCRIPT = """\
+import json, os, sys
+data = None
+if "TASKMAESTRO_INPUT" in os.environ:
+    with open(os.environ["TASKMAESTRO_INPUT"]) as f:
+        data = json.load(f)
+with open(os.environ["TASKMAESTRO_OUTPUT"], "w") as f:
+    json.dump({"args": sys.argv[1:], "inputs": data, "cwd": os.getcwd(),
+               "flag": os.environ.get("FLAG")}, f)
+print("done")
+"""
+
+
+@pytest.fixture
+def ctx(tmp_path: Path) -> ExecutionContext:
+    return ExecutionContext(scratch_dir=tmp_path / "scratch")
+
+
+def _script(directory: Path, text: str, name: str = "step.py") -> Path:
+    path = directory / name
+    path.write_text(textwrap.dedent(text))
+    return path
+
+
+class Point(BaseModel):
+    x: int
+
+
+def test_python_script_exchanges_json_and_captures_output(
+    tmp_path: Path, ctx: ExecutionContext
+) -> None:
+    script = _script(tmp_path, ECHO_SCRIPT)
+    workdir = tmp_path / "work"
+    workdir.mkdir()
+
+    output = PythonScript().run(
+        PythonScriptInput(
+            script=script,
+            args=["a", "b"],
+            inputs={"point": Point(x=1), "n": 2},
+            env={"FLAG": "on"},
+            cwd=workdir,
+        ),
+        ctx,
+    )
+
+    assert output.result == {
+        "args": ["a", "b"],
+        "inputs": {"point": {"x": 1}, "n": 2},
+        "cwd": str(workdir),
+        "flag": "on",
+    }
+    assert (output.returncode, output.stdout, output.stderr) == (0, "done\n", "")
+    assert (ctx.scratch_dir.iterdir().__next__() / "input.json").exists()
+
+
+def test_relative_script_resolves_against_the_process_cwd(
+    tmp_path: Path, ctx: ExecutionContext, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _script(tmp_path, ECHO_SCRIPT)
+    elsewhere = tmp_path / "elsewhere"
+    elsewhere.mkdir()
+    monkeypatch.chdir(tmp_path)
+
+    output = PythonScript().run(PythonScriptInput(script=Path("step.py"), cwd=elsewhere), ctx)
+
+    assert output.result["inputs"] is None
+    assert output.result["cwd"] == str(elsewhere)
+
+
+def test_missing_output_file_gives_null_result(tmp_path: Path, ctx: ExecutionContext) -> None:
+    script = _script(tmp_path, "print('no result')\n")
+
+    output = PythonScript().run(PythonScriptInput(script=script), ctx)
+
+    assert output.result is None
+    assert output.stdout == "no result\n"
+
+
+def test_empty_output_file_gives_null_result(tmp_path: Path, ctx: ExecutionContext) -> None:
+    script = _script(
+        tmp_path, "import os\nopen(os.environ['TASKMAESTRO_OUTPUT'], 'w').write(' \\n')\n"
+    )
+
+    output = PythonScript().run(PythonScriptInput(script=script), ctx)
+
+    assert output.result is None
+
+
+def test_nonzero_exit_fails_with_exit_code_and_stderr(
+    tmp_path: Path, ctx: ExecutionContext
+) -> None:
+    script = _script(tmp_path, "import sys\nprint('bad things', file=sys.stderr)\nsys.exit(3)\n")
+
+    with pytest.raises(ScriptError, match="failed with exit code 3: bad things") as info:
+        PythonScript().run(PythonScriptInput(script=script), ctx)
+
+    assert info.value.returncode == 3
+    assert info.value.stderr == "bad things\n"
+
+
+def test_nonzero_exit_without_check_is_returned(tmp_path: Path, ctx: ExecutionContext) -> None:
+    script = _script(tmp_path, "import sys\nsys.exit(3)\n")
+
+    output = PythonScript().run(PythonScriptInput(script=script, check=False), ctx)
+
+    assert output.returncode == 3
+
+
+def test_missing_script_fails_before_running(tmp_path: Path, ctx: ExecutionContext) -> None:
+    with pytest.raises(ScriptError, match=r"Script not found: .*missing\.py"):
+        PythonScript().run(PythonScriptInput(script=tmp_path / "missing.py"), ctx)
+
+
+def test_invalid_output_json_fails(tmp_path: Path, ctx: ExecutionContext) -> None:
+    script = _script(
+        tmp_path, "import os\nopen(os.environ['TASKMAESTRO_OUTPUT'], 'w').write('{oops')\n"
+    )
+
+    with pytest.raises(ScriptError, match=r"wrote invalid JSON to \$TASKMAESTRO_OUTPUT"):
+        PythonScript().run(PythonScriptInput(script=script), ctx)
+
+
+def test_runtime_only_inputs_cannot_be_sent_to_a_process(
+    tmp_path: Path, ctx: ExecutionContext
+) -> None:
+    script = _script(tmp_path, ECHO_SCRIPT)
+    opaque = ObjectModel[object](value=object())
+
+    with pytest.raises(ScriptError, match="cannot be converted to JSON"):
+        PythonScript().run(PythonScriptInput(script=script, inputs={"case": opaque}), ctx)
+
+
+def test_timeout_kills_the_process_and_keeps_partial_output(
+    tmp_path: Path, ctx: ExecutionContext
+) -> None:
+    script = _script(tmp_path, "import time\nprint('working', flush=True)\ntime.sleep(30)\n")
+
+    started = time.monotonic()
+    with pytest.raises(ScriptError, match=r"timed out after 1\.0s") as info:
+        PythonScript().run(PythonScriptInput(script=script, timeout=1.0), ctx)
+    assert time.monotonic() - started < 10
+    assert info.value.stdout == "working\n"
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="POSIX shell")
+def test_command_string_runs_through_the_shell(ctx: ExecutionContext) -> None:
+    output = Command().run(
+        CommandInput(
+            command=(
+                'printf "%s" "$GREETING" | tr a-z A-Z; printf \'[1, 2]\' > "$TASKMAESTRO_OUTPUT"'
+            ),
+            env={"GREETING": "hello"},
+        ),
+        ctx,
+    )
+
+    assert output.stdout == "HELLO"
+    assert output.result == [1, 2]
+
+
+def test_command_list_runs_without_a_shell(ctx: ExecutionContext) -> None:
+    output = Command().run(
+        CommandInput(command=[sys.executable, "-c", "import sys; print(sys.argv[1])", "$HOME"]),
+        ctx,
+    )
+
+    assert output.stdout == "$HOME\n"
+
+
+def test_command_that_cannot_start_fails(ctx: ExecutionContext) -> None:
+    with pytest.raises(ScriptError, match="could not be started"):
+        Command().run(CommandInput(command=["/nonexistent/taskmaestro-tool"]), ctx)
+
+
+def test_empty_command_fails(ctx: ExecutionContext) -> None:
+    with pytest.raises(ScriptError, match="Command is empty"):
+        Command().run(CommandInput(command=[]), ctx)
+
+
+@pytest.mark.skipif(not hasattr(signal, "SIGALRM"), reason="Runner timeouts need SIGALRM")
+def test_runner_timeout_kills_a_running_process(tmp_path: Path) -> None:
+    pid_file = tmp_path / "pid"
+    builder = WorkflowBuilder("slow")
+    builder.task(Command, config_fields=["command"])
+    command = ["sh", "-c", f'echo $$ > "{pid_file}"; exec sleep 30']
+
+    started = time.monotonic()
+    job = builder.build().run(
+        EmptyConfig(),
+        task_config={"command": {"command": command}},
+        ctx=ExecutionContext(scratch_dir=tmp_path),
+        timeout_seconds=1,
+    )
+
+    assert job.status == JobStatus.FAILED
+    assert time.monotonic() - started < 10
+    with pytest.raises(ProcessLookupError):
+        os.kill(int(pid_file.read_text()), 0)
+
+
+def test_script_tasks_are_registered() -> None:
+    assert {"taskmaestro.python", "taskmaestro.command"} <= registered_task_names()
+
+
+def _yaml_files(tmp_path: Path, workflow: str, inputs: str = "{}\n") -> tuple[Path, Path]:
+    workflow_path = tmp_path / "workflow.yaml"
+    input_path = tmp_path / "input.yaml"
+    workflow_path.write_text(textwrap.dedent(workflow))
+    input_path.write_text(inputs)
+    return workflow_path, input_path
+
+
+def test_yaml_workflow_connects_script_results_with_collect(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    _script(tmp_path, ECHO_SCRIPT)
+    monkeypatch.chdir(tmp_path)
+    workflow_path, input_path = _yaml_files(
+        tmp_path,
+        """\
+        workflow:
+          name: scripts
+          tasks:
+            - task: taskmaestro.python
+              name: first
+            - task: taskmaestro.command
+              name: second
+              depends_on:
+                inputs:
+                  collect: {args: [first, result], code: [first, returncode]}
+        """,
+        f"first: {{script: step.py, args: [two]}}\n"
+        f"second: {{command: [{json.dumps(sys.executable)}, step.py]}}\n",
+    )
+
+    job = load_workflow_from_yaml(workflow_path, input_path).run()
+
+    assert job.status == JobStatus.COMPLETED, job.error
+    assert job.result is not None
+    assert job.result.result["inputs"] == {
+        "args": {"args": ["two"], "inputs": None, "cwd": str(tmp_path), "flag": None},
+        "code": 0,
+    }
+
+
+def test_whole_output_cannot_be_connected_to_inputs(tmp_path: Path) -> None:
+    workflow_path, input_path = _yaml_files(
+        tmp_path,
+        """\
+        workflow:
+          name: scripts
+          tasks:
+            - task: taskmaestro.command
+              name: first
+            - task: taskmaestro.command
+              name: second
+              depends_on: {inputs: first}
+        """,
+        'first: {command: "true"}\nsecond: {command: "true"}\n',
+    )
+
+    with pytest.raises(ConfigLoadError, match=r"expects dict\[str, Any\]"):
+        load_workflow_from_yaml(workflow_path, input_path)
+
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Example uses sh and wc")
+def test_scripts_example_runs(tmp_path: Path) -> None:
+    root = Path(__file__).resolve().parents[1]
+    input_path = tmp_path / "input.yaml"
+    example_input = (root / "examples/scripts/input.yaml").read_text()
+    input_path.write_text(
+        example_input.replace("/tmp/taskmaestro-script-tasks", json.dumps(str(tmp_path)))
+    )
+
+    run = subprocess.run(
+        [
+            sys.executable,
+            "-m",
+            "taskmaestro",
+            "run",
+            "examples/scripts/workflow.yaml",
+            "--input",
+            str(input_path),
+            "--json",
+        ],
+        cwd=root,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert run.returncode == 0, run.stderr
+    report = tmp_path / "word_count.json"
+    assert json.loads(run.stdout)["result"]["result"] == {"report": str(report)}
+    saved = json.loads(report.read_text())
+    assert saved["counts"]["words"] == 32
+    assert saved["wc_output"].split()[0] == "172"
diff --git a/tests/test_workflow.py b/tests/test_workflow.py
index a1dced7..488637b 100644
--- a/tests/test_workflow.py
+++ b/tests/test_workflow.py
@@ -1051,6 +1051,12 @@ def test_root_task_config_field_not_on_model_raises(self) -> None:
                 .build()
             )
 
+    def test_root_task_misspelled_config_field_is_reported_before_missing_ones(self) -> None:
+        with pytest.raises(WorkflowDefinitionError, match="Config field 'cuont'"):
+            Workflow.builder("bad").add_task(
+                ConfigOnlyTask, config_fields=["path", "cuont"]
+            ).build()
+
     def test_single_dep_with_config_fields(self) -> None:
         """Single dep + config_fields: upstream fields + config cover all required."""
         wf = (