@@ -362,18 +362,22 @@ there. Set it once on the Dag and each task inherits it:
 Conditional branching
 ~~~~~~~~~~~~~~~~~~~~~
 
-``dag.if`` takes a task whose handler returns a boolean, and names the task each outcome runs:
+``dag.if`` takes a handler that returns a boolean, and names the task each outcome runs:
 
 .. code-block:: typescript
 
-    const condition = dag.task("has_rows", async ({ rows }: { rows: number }) => rows > 0);
-    const gated = condition({ rows: extracted });
+    async function hasRows({ rows }: { rows: number }): Promise<boolean> {
+      return rows > 0;
+    }
 
-    dag.if(gated).then(loaded).else(reportedEmpty);
+    const gate = dag.if(hasRows)({ rows: extracted });
+    gate.then(loaded).else(reportedEmpty);
 
-The condition is an ordinary task, so it is declared, typed and wired like any other, and the
-compiler checks that its handler really returns a boolean. ``else`` is optional: a one-sided
-condition skips its own branch when the condition fails and follows nothing.
+``dag.if`` declares the condition the way ``dag.task`` declares a task: its id is the function's
+name unless ``taskId`` sets it, and the returned factory takes its inputs. The compiler checks that
+the handler returns a boolean. ``else`` is optional: a one-sided condition skips its own branch
+when the condition fails and follows nothing. The condition is also a node, so ``notified.after(gate)``
+orders a task after it.
 
 A guarded task takes no argument for the control edge, because a condition's boolean decides whether
 the task runs rather than what it runs on. Read a value from the condition with
 
@@ -142,18 +142,24 @@ convention.
 names after the host language's control flow:
 
 ```ts
-const gated = dag.task("has_rows", async ({ rows }: { rows: number }) => rows > 0)({
-  rows: extracted,
-});
+async function hasRows({ rows }: { rows: number }): Promise<boolean> {
+  return rows > 0;
+}
 
-dag.if(gated).then(loadIfReady).else(loadFallback);
+const gate = dag.if(hasRows)({ rows: validated });
+gate.then(loadIfReady).else(loadFallback);
 ```
 
-**The condition is a task reference, not a task id and a function.** `dag.if` takes a `TaskRef` the
-Dag already handed back, whose handler's return type the compiler checks is `boolean`. So nothing
-depends on the task's id or on its function name, and a condition is declared, named and typed the
-same way every other task is. The same reasoning that makes a *case* a reference in that ADR's
-decision 2 applies to the condition itself.
+**The condition is a handler, declared the way a task is.** That ADR writes
+`dag.If(hasRows, airflow.Inputs(validated))` in Go, where `dag.Task(fn, airflow.Inputs(x))` declares
+and wires a task in one call. TypeScript splits that call into `dag.task(fn)({ x })`, so `dag.if`
+splits the same way: `dag.if(hasRows)` declares the deciding task, taking its id from the function's
+name unless `taskId` sets it, and the returned factory takes its inputs. The compiler checks that the
+handler returns a `boolean`.
+
+**A condition is a node.** What the factory returns carries `before` and `after`, and stands at the
+other end of an edge as the deciding task, so `notified.after(gate)` reads as Go's `.After(gate)`. It
+is also a valid branch of another condition.
 
 **A `then` chain is a thenable, and is guarded rather than avoided.** An object with a callable
 `then` is a *thenable*: were the object `dag.if` returns to reach an `await`, the runtime would hand
 
@@ -83,6 +83,9 @@ export interface CoordinatorClient extends TaskClient {
    * output fails the task, while one that pushed null binds null.
    */
   getXComEntry(opts: GetXComOpts): Promise<XComEntry>;
+
+  /** Mark direct downstream tasks of the running task as skipped; none is a no-op. */
+  skipDownstreamTasks(taskIds: readonly string[]): Promise<void>;
 }
 
 export function createCoordinatorClient(
@@ -206,8 +209,6 @@ export function createCoordinatorClient(
     // ---- Control flow ----
 
     async skipDownstreamTasks(taskIds: readonly string[]): Promise<void> {
-      // The supervisor treats an empty list as "skip nothing", and sending it
-      // would cost a round trip to say so.
       if (taskIds.length === 0) return;
       const msg: SkipDownstreamTasks = { type: "SkipDownstreamTasks", tasks: [...taskIds] };
       await rpc("SkipDownstreamTasks", null, msg, () => undefined, "throw");
 
@@ -200,9 +200,7 @@ function serializeTask(
   const label = `task "${taskId}" of Dag "${dagId}"`;
   const bindings = serializeArgBindings(inputs, label);
   if (bindings) data["_arg_bindings"] = bindings;
-  // What Python writes for a SkipMixin operator, and what makes
-  // `NotPreviouslySkippedDep` consult this task's `skipmixin_key` XCom when one
-  // of its skipped downstream tasks is cleared.
+  // Lets `NotPreviouslySkippedDep` re-skip a cleared downstream, as Python's SkipMixin does.
   if (canSkipDownstream) data["_can_skip_downstream"] = true;
   applySchemaFields(data, spec, TASK_FIELD_RULES, label);
   if (downstream?.size) {
 
@@ -29,6 +29,7 @@ export type { Registerable } from "./sdk/bundle.js";
 export type {
   Condition,
   ConditionElse,
+  ConditionFactory,
   DagSpec,
   Node,
   TaskFactory,
 
@@ -107,19 +107,6 @@ export interface TaskClient {
    * @throws {@link Exceptions!ConnectionNotFoundError | ConnectionNotFoundError} when the connection does not exist.
    */
   getConnectionOrThrow(connId: string): Promise<ConnectionResult>;
-
-  /**
-   * Mark downstream tasks of the running task as skipped.
-   *
-   * The mechanism behind `dag.if(...)`: a condition's boolean is a run-time
-   * signal, so which branch a Dag run takes is decided here rather than
-   * recorded in the Dag. Python reaches the same supervisor message through
-   * `skip()` and `skip_all_except()`.
-   *
-   * Each id must name a direct downstream of the running task. Passing none is
-   * a no-op, so a branch that skips nothing needs no guard at the call site.
-   */
-  skipDownstreamTasks(taskIds: readonly string[]): Promise<void>;
 }
 
 /** Error thrown by {@link TaskClient.getVariableOrThrow}. */