@@ -344,6 +344,8 @@ Tasks and groups share one id namespace, as they do in Python, so a Dag cannot h
 group called ``staging``. A ``.`` is what separates a group from what it holds, so it cannot appear in
 an id of either.
 
+.. warning:: A cycle is not allowed. The Dag is rejected when it is read, naming the tasks on the cycle.
+
 ``new Dag`` and ``dag.task`` both take a trailing spec of Airflow options:
 ``{ schedule: "@daily", tags: ["etl"] }`` for the Dag, ``{ retries: 2, retryDelay: 30 }`` for a task.
 
 
@@ -0,0 +1,89 @@
+/*!
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+// Finds a cycle in a Dag's task graph.
+//
+// Only the edges `before`/`after` draw can form one. A cycle through *wiring*
+// is unrepresentable rather than rejected: a `TaskRef` exists only once its
+// producing call has returned, so there is no way to write one. Both kinds of
+// edge are searched together all the same, because a cycle can run through one
+// of each — `transform({ extracted })` and then `extract.after(transform)`.
+
+/** A directed edge between two task IDs. */
+export interface TaskEdge {
+  readonly upstream: string;
+  readonly downstream: string;
+}
+
+/**
+ * The tasks on a cycle, or undefined when there is none.
+ *
+ * The returned path starts and ends on the same task, so it reads as the cycle
+ * it describes: `["a", "b", "a"]` is `a >> b >> a`.
+ *
+ * Iterative rather than recursive: a Dag of a few thousand chained tasks is
+ * within reach for a generated Dag file, and would overflow the stack.
+ */
+export function findTaskCycle(
+  taskIds: Iterable<string>,
+  edges: Iterable<TaskEdge>,
+): string[] | undefined {
+  const downstreamOf = new Map<string, string[]>();
+  for (const taskId of taskIds) downstreamOf.set(taskId, []);
+  for (const { upstream, downstream } of edges) {
+    // An edge naming a task the Dag does not hold cannot be part of a cycle
+    // among the tasks it does, and the caller reports it in its own terms.
+    downstreamOf.get(upstream)?.push(downstream);
+  }
+
+  // Three states, as a depth-first cycle search needs: unvisited, on the
+  // current path, and finished. Finding a task already on the path is the
+  // cycle; finding a finished one only means the search has been there before.
+  const onPath = new Set<string>();
+  const finished = new Set<string>();
+  const path: string[] = [];
+
+  for (const root of downstreamOf.keys()) {
+    if (finished.has(root)) continue;
+    // Each frame is a task and how far its downstream list has been walked.
+    const stack: { taskId: string; next: number }[] = [{ taskId: root, next: 0 }];
+    onPath.add(root);
+    path.push(root);
+
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1]!;
+      const downstream = downstreamOf.get(frame.taskId) ?? [];
+      if (frame.next === downstream.length) {
+        finished.add(frame.taskId);
+        onPath.delete(frame.taskId);
+        path.pop();
+        stack.pop();
+        continue;
+      }
+      const next = downstream[frame.next]!;
+      frame.next += 1;
+      if (onPath.has(next)) return [...path.slice(path.indexOf(next)), next];
+      if (finished.has(next) || !downstreamOf.has(next)) continue;
+      onPath.add(next);
+      path.push(next);
+      stack.push({ taskId: next, next: 0 });
+    }
+  }
+  return undefined;
+}
@@ -30,6 +30,7 @@ import {
 } from "../generated/dag-schema-fields.js";
 import { argListValues, isArgList, type ArgList } from "./arg-list.js";
 import { brand, DUPLICATE_COPY_HINT, hasBrand } from "./brand.js";
+import { findTaskCycle, type TaskEdge } from "./cycle.js";
 import type { JsonValue } from "./client-types.js";
 import type { TaskFunction } from "./task.js";
 
@@ -891,10 +892,67 @@ export class Dag {
         );
       }
     }
-    // Last, so a Dag that failed the check reports that same failure again
+    const cycle = findTaskCycle(this.#tasks.keys(), this.#taskEdges());
+    if (cycle) {
+      throw new Error(
+        `Dag "${this.dagId}" has a cycle: ${cycle.join(" >> ")}. An edge drawn with ` +
+          "before() or after() runs in one direction, so a Dag cannot come back to a task it " +
+          "has already run.",
+      );
+    }
+    // Last, so a Dag that failed a check reports that same failure again
     // rather than reporting itself as already read.
     this.#finalized = true;
   }
+
+  /**
+   * Every edge of this Dag, between task IDs.
+   *
+   * Both kinds are flattened onto the same graph: the wiring a factory call
+   * recorded, and the order-only edges, with a group endpoint standing for
+   * every task the group holds. A cycle can run through one of each, so
+   * searching either kind alone would miss it.
+   */
+  *#taskEdges(): Generator<TaskEdge> {
+    for (const [downstream, inputs] of this.#inputs) {
+      for (const value of Object.values(inputs)) {
+        if (isTaskRef(value)) yield { upstream: value.taskId, downstream };
+      }
+    }
+    for (const { upstream, downstream } of this.#orderEdges.values()) {
+      for (const from of this.#tasksOf(upstream)) {
+        for (const to of this.#tasksOf(downstream)) {
+          yield { upstream: from, downstream: to };
+        }
+      }
+    }
+  }
+
+  /**
+   * The tasks an edge endpoint stands for: the task itself, or every task a
+   * group holds, nested groups included.
+   *
+   * An empty group stands for no task, so an edge to one constrains nothing —
+   * which is also why it cannot put a Dag in a cycle.
+   */
+  #tasksOf(nodeId: string): readonly string[] {
+    const group = this.#groups.get(nodeId);
+    if (group === undefined) return [nodeId];
+    const tasks: string[] = [];
+    // Breadth-first over the group tree, the queue growing as children are
+    // found. It terminates because a child group is only ever created after
+    // its parent, so the tree cannot close on itself.
+    const pending = [group];
+    for (let i = 0; i < pending.length; i += 1) {
+      const current = pending[i]!;
+      tasks.push(...current.taskIds);
+      for (const childId of current.childGroupIds) {
+        const child = this.#groups.get(childId);
+        if (child) pending.push(child);
+      }
+    }
+    return tasks;
+  }
 }
 
 // What Airflow accepts as a task id, and so what a name taken from a handler
 
@@ -0,0 +1,104 @@
+/*!
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+import { describe, expect, it } from "vitest";
+import { findTaskCycle, type TaskEdge } from "../../src/sdk/cycle.js";
+
+/** `"a>b c>d"` as edges, so a graph reads as the shape it is. */
+function edges(spec: string): TaskEdge[] {
+  if (spec === "") return [];
+  return spec.split(" ").map((pair) => {
+    const [upstream, downstream] = pair.split(">");
+    return { upstream: upstream!, downstream: downstream! };
+  });
+}
+
+describe("findTaskCycle", () => {
+  it.each([
+    ["no tasks at all", [], ""],
+    ["one task and no edges", ["a"], ""],
+    ["a chain", ["a", "b", "c"], "a>b b>c"],
+    ["a diamond, where one task is reached twice", ["a", "b", "c", "d"], "a>b a>c b>d c>d"],
+    ["a fan-out", ["a", "b", "c"], "a>b a>c"],
+    ["a fan-in", ["a", "b", "c"], "a>c b>c"],
+    ["two disconnected components", ["a", "b", "c", "d"], "a>b c>d"],
+    ["an isolated task beside a chain", ["a", "b", "lonely"], "a>b"],
+  ])("finds none in %s", (_label, taskIds, spec) => {
+    expect(findTaskCycle(taskIds, edges(spec))).toBeUndefined();
+  });
+
+  it.each([
+    ["a self-edge", ["a"], "a>a", ["a", "a"]],
+    ["a two-task cycle", ["a", "b"], "a>b b>a", ["a", "b", "a"]],
+    ["a three-task cycle", ["a", "b", "c"], "a>b b>c c>a", ["a", "b", "c", "a"]],
+  ])("reports the tasks on %s", (_label, taskIds, spec, expected) => {
+    expect(findTaskCycle(taskIds, edges(spec))).toEqual(expected);
+  });
+
+  it("reports only the cycle, not the path that led into it", () => {
+    // `entry` reaches the cycle but is not on it, so naming it would send a
+    // reader looking for an edge that does not exist.
+    expect(findTaskCycle(["entry", "a", "b"], edges("entry>a a>b b>a"))).toEqual(["a", "b", "a"]);
+  });
+
+  it("finds a cycle in a component the search reaches second", () => {
+    expect(findTaskCycle(["a", "b", "x", "y"], edges("a>b x>y y>x"))).toEqual(["x", "y", "x"]);
+  });
+
+  it("ignores an edge naming a task the Dag does not hold", () => {
+    // The Dag reports an unknown endpoint in its own terms; it cannot be part
+    // of a cycle among the tasks that do exist.
+    expect(findTaskCycle(["a"], edges("a>ghost ghost>a"))).toBeUndefined();
+  });
+
+  it("handles a chain far longer than the call stack would take", () => {
+    const taskIds = Array.from({ length: 50_000 }, (_, i) => `t${i}`);
+    const chain = taskIds.slice(0, -1).map((upstream, i) => ({
+      upstream,
+      downstream: taskIds[i + 1]!,
+    }));
+
+    expect(findTaskCycle(taskIds, chain)).toBeUndefined();
+    expect(
+      findTaskCycle(taskIds, [...chain, { upstream: "t49999", downstream: "t0" }]),
+    ).toHaveLength(taskIds.length + 1);
+  });
+
+  it("does not re-walk a task the search has already finished with", () => {
+    // A wide diamond lattice: exponential if finished tasks were revisited.
+    const taskIds = ["start"];
+    const wide: TaskEdge[] = [];
+    let previous = "start";
+    for (let layer = 0; layer < 30; layer += 1) {
+      const left = `l${layer}`;
+      const right = `r${layer}`;
+      const join = `j${layer}`;
+      taskIds.push(left, right, join);
+      wide.push(
+        { upstream: previous, downstream: left },
+        { upstream: previous, downstream: right },
+        { upstream: left, downstream: join },
+        { upstream: right, downstream: join },
+      );
+      previous = join;
+    }
+
+    expect(findTaskCycle(taskIds, wide)).toBeUndefined();
+  });
+});