@@ -277,6 +277,18 @@ argument itself: one buried inside an array or an object is a literal, and draws
 Every task has to be called exactly once. An uncalled task fails when the Dag is read, so none can be
 left out of the graph by accident.
 
+The task id may be omitted, in which case it is the handler's function name:
+
+.. code-block:: typescript
+
+    const extract = dag.task(async function extract(): Promise<number> {
+      return 42;
+    });
+
+``airflow-ts-pack`` keeps function names intact, so bundling cannot rename a task. A handler with no
+name of its own, such as an arrow function passed inline, has nothing to take an id from and needs
+one: either positionally or as ``taskId`` in its spec. Give it in one place only, not both.
+
 ``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.
 
@@ -398,9 +410,9 @@ layout header. The layout records the byte ranges and SHA-256 digests of the man
 so there is one file to deploy, with no separate manifest or ``node_modules``.
 
 The code is minified because an integrity digest is only worth taking over an artifact nobody is expected to
-read or edit in place. The ``/*! */`` license banners of bundled dependencies are kept. Nothing is identified by
-a function name, so minified names are safe: a Dag and a task are named by the string ids their registration
-states, and a handler is dispatched by reference.
+read or edit in place. Whitespace and syntax are minified, not identifiers: a task id defaults to its
+handler's name, so the names the SDK reads have to be the ones the author wrote. The ``/*! */`` license
+banners of bundled dependencies are kept.
 
 Because the shipped code is not the code anyone wrote, the packer also embeds the entry module verbatim in a
 ``/*# airflowSource ... #*/`` block comment, verified by its own digest, so Airflow has something readable to
 
@@ -149,9 +149,9 @@ convention.
   by design. Native declaration is what fills them, generated from the serialized-Dag JSON schema the
   way `src/generated/supervisor.ts` is. This ADR does not choose those fields; it fixes where an
   author writes them.
-- `TaskOptions` carries the spec and the handler's positional argument names, which the packer fills in
-  from the parameter list so the Dag names each argument as its handler does. With wiring moved to the
-  factory call, `inputs` is no longer an option.
+- `TaskOptions` carries the spec and the handler's positional argument names, which the Dag reads
+  from the handler's parameter list so it names each argument as the handler does. With wiring moved
+  to the factory call, `inputs` is no longer an option.
 - `TaskHandlerArgs` is removed from the public API, `DagRegistry` becomes `Bundle`, and
   `serveDags(registry)` becomes `bundle.serve()`, which breaks
   0.1.0-beta1 authors; see [ADR-0001](0001-mixed-lang-dag-interface.md) for the shipped call sites
@@ -182,16 +182,17 @@ convention.
   and runs `validateEmptySpec` on it (`ts-sdk/src/sdk/dag.ts`), so task fields land on a path that
   exists rather than a new one.
 - **A positional argument binds by order, and its name is a label.** The serialized Dag names each
-  argument, so the packer reads the names from the handler's parameter list; `arg0`, `arg1` and so on
-  stand in for a name it cannot see, without changing which value reaches which argument.
+  argument, so the names come from the handler's parameter list; `arg0`, `arg1` and so on stand in
+  for a parameter with no name to read, without changing which value reaches which argument.
 - **A `TaskRef` is inert** — a handle for wiring, not a promise. Nothing in a Dag file executes a task
   body.
-- **A defaulted task id is resolved at pack time, not read at runtime.** esbuild renames function
-  identifiers, so `handler.name` in a packed bundle is the minified name, not the author's. The pack
-  step (`ts-sdk/src/cli/pack.ts`) therefore reads an omitted id from the handler's declared name in
-  source and writes it into the registration, rather than depending on `handler.name` or enabling
-  esbuild's `keepNames` across the whole bundle. A handler with no source name leaves nothing to
-  read, which is why an anonymous handler must state its id.
+- **A defaulted task id and the argument labels are read off the handler itself.** The pack step
+  (`ts-sdk/src/cli/pack.ts`) minifies whitespace and syntax but not identifiers, and passes esbuild's
+  `keepNames`, so `handler.name` and the handler's parameter names are the author's in a packed
+  bundle as much as in one run from source. Rewriting the call at pack time was tried first and
+  dropped: it needed a TypeScript parser in the packer to tell a real `.task(` from one inside a
+  string or a comment, and it could not see a handler declared in another module. A handler with no
+  name leaves nothing to read, which is why an anonymous handler must state its id.
 - **`withArgNames` and the name folding behind it** ([ADR-0001](0001-mixed-lang-dag-interface.md))
   exist for the mixed-language case and are never needed here: both ends of every name are
   TypeScript, so `tsc` checks the wiring end to end and there is no foreign name to reconcile.
 
@@ -215,8 +215,14 @@ export async function runPack(argv: readonly string[]): Promise<void> {
       platform: "node",
       format: "esm",
       target: "node22",
-      // A digest is only worth taking over an artifact nobody reads or edits in place.
-      minify: true,
+      // Whitespace and syntax only. Identifiers stay: `dag.task(handler)` takes
+      // the task id from the handler's name and labels its arguments after the
+      // handler's parameters, and both are read off the function at run time.
+      minifyWhitespace: true,
+      minifySyntax: true,
+      // Bundling renames a symbol that two modules both declare, so the name
+      // the SDK reads is pinned to the one the author wrote.
+      keepNames: true,
       // The manifest is read by running the staged bundle, so the metadata describes what ships.
       outfile: stagingPath,
     });
 
@@ -84,7 +84,9 @@ function kindOf(value: object): string {
 }
 
 const DAG_SPEC_KEYS: ReadonlySet<string> = new Set(Object.keys(DAG_SCHEMA_FIELDS));
-const TASK_SPEC_KEYS: ReadonlySet<string> = new Set(Object.keys(TASK_SCHEMA_FIELDS));
+// `taskId` is hand-written rather than generated: the schema's task_id is
+// serializer-owned, and this is the authoring surface's own way to set it.
+const TASK_SPEC_KEYS: ReadonlySet<string> = new Set([...Object.keys(TASK_SCHEMA_FIELDS), "taskId"]);
 
 /**
  * Dag-level options: the schedule, the tags, how many runs may be active, and
@@ -103,9 +105,19 @@ export type DagSpec = GeneratedDagFields;
  * Task-level options: the retries, the pool, the trigger rule, and the rest of
  * what an operator takes in Python.
  *
+ * The task id is here too, for a handler whose id is not given positionally.
  * Optional and record-only on the same terms as {@link DagSpec}.
  */
-export type TaskSpec = GeneratedTaskFields;
+export interface TaskSpec extends GeneratedTaskFields {
+  /**
+   * Airflow task ID, when it should not be the handler's function name.
+   *
+   * `dag.task(handler)` takes the id from the handler's name. Set this for an
+   * id that has to outlive that name, or for an anonymous handler, which has
+   * no name to take one from.
+   */
+  readonly taskId?: string;
+}
 
 // Carries a reference's return type without carrying a value. Not exported, so
 // the property cannot be read or written from outside; it exists only so
@@ -259,10 +271,11 @@ export type TaskOptions = TaskSpec & {
   /**
    * Names for the handler's positional arguments, in declaration order.
    *
-   * `airflow-ts-pack` fills this in from the handler's parameter list, so the
-   * Dag names each argument as its handler does. Positional inputs bind by
-   * order, so a name left out only costs the label: `arg0`, `arg1` and so on
-   * stand in for it.
+   * Read from the handler itself when it declares plain parameters, so the Dag
+   * names each argument as its handler does. Set this to name them yourself,
+   * or for a handler whose parameters are destructured, defaulted or rest.
+   * Positional inputs bind by order, so a name left out only costs the label:
+   * `arg0`, `arg1` and so on stand in for it.
    */
   readonly argBindings?: readonly string[];
 };
@@ -354,12 +367,70 @@ export class Dag {
    * {@link TaskFactory}; `getContext()` and `getClient()` reach the runtime
    * from inside the call, so neither is an argument. The trailing options object
    * carries this task's own {@link TaskSpec}.
+   *
+   * ```ts
+   * const extract = dag.task("extract", async () => 42);
+   * const transform = dag.task(async function transform() {}); // id "transform"
+   * ```
    */
   task<TParams extends readonly unknown[] = [], TReturn = unknown>(
     taskId: string,
     handler: (...args: TParams) => TReturn | Promise<TReturn>,
-    options: TaskOptions = {},
+    options?: TaskOptions,
+  ): TaskFactory<TParams, TReturn>;
+  /**
+   * Declare a task whose id is the handler's function name.
+   *
+   * `airflow-ts-pack` keeps handler names intact, so minification cannot change
+   * a task id. An anonymous handler has no name to take one from, and needs
+   * {@link TaskSpec.taskId} to give it one.
+   */
+  task<TParams extends readonly unknown[] = [], TReturn = unknown>(
+    handler: (...args: TParams) => TReturn | Promise<TReturn>,
+    options?: TaskOptions,
+  ): TaskFactory<TParams, TReturn>;
+  task<TParams extends readonly unknown[] = [], TReturn = unknown>(
+    taskIdOrHandler: string | ((...args: TParams) => TReturn | Promise<TReturn>),
+    handlerOrOptions?: ((...args: TParams) => TReturn | Promise<TReturn>) | TaskOptions,
+    maybeOptions?: TaskOptions,
   ): TaskFactory<TParams, TReturn> {
+    const idGiven = typeof taskIdOrHandler === "string";
+    const handler = (idGiven ? handlerOrOptions : taskIdOrHandler) as (
+      ...args: TParams
+    ) => TReturn | Promise<TReturn>;
+    const given = idGiven ? maybeOptions : (handlerOrOptions as TaskOptions | undefined);
+    // Defaulted only when absent: an explicit `null` is a bad spec, not an
+    // omitted one, and #taskSpecOf is what reports it.
+    const options = given === undefined ? {} : given;
+    const specTaskId =
+      isPlainRecord(options) && typeof options.taskId === "string" ? options.taskId : undefined;
+    // Two ids for one task disagree silently otherwise: the positional one
+    // wins and the spec's is dropped without a word.
+    if (idGiven && specTaskId !== undefined) {
+      throw new Error(
+        `Task "${taskIdOrHandler}" of Dag "${this.dagId}" also carries taskId "${specTaskId}" in ` +
+          "its spec; give the id once, either positionally or in the spec",
+      );
+    }
+    const defaulted = idGiven ? undefined : (specTaskId ?? readFunctionName(handler));
+    const taskId = idGiven ? taskIdOrHandler : defaulted;
+    if (taskId === undefined) {
+      throw new Error(
+        `A task of Dag "${this.dagId}" has no id: its handler has no name to take one from. ` +
+          'Pass an id — dag.task("my_task", handler) — or give the handler a name. A bundler ' +
+          "that drops function names also lands here; airflow-ts-pack keeps them.",
+      );
+    }
+    // A name Airflow would reject is worth catching where it was taken, not in
+    // the server's answer: `fn.bind(...)` names itself "bound extract", and a
+    // method can be named anything at all.
+    if (defaulted !== undefined && !TASK_ID_CHARACTERS.test(defaulted)) {
+      throw new Error(
+        `A task of Dag "${this.dagId}" would take the id "${defaulted}" from its handler's name, ` +
+          "which Airflow does not accept; give it an id of letters, digits, dashes, dots and " +
+          'underscores — dag.task("my_task", handler)',
+      );
+    }
     if (typeof handler !== "function") {
       throw new Error(`handler for Dag "${this.dagId}" task "${taskId}" must be a function`);
     }
@@ -375,7 +446,8 @@ export class Dag {
       );
     }
     const spec = this.#taskSpecOf(taskId, options);
-    const argBindings = this.#validateArgBindings(taskId, options.argBindings);
+    const argBindings =
+      this.#validateArgBindings(taskId, options.argBindings) ?? inferArgBindings(handler);
     const task = createTaskRef(this.dagId, taskId);
     this.#tasks.set(taskId, {
       task,
@@ -560,6 +632,54 @@ function spreadArgs(fn: TaskFunction): TaskFunction {
     handler(...Object.values(args ?? {}))) as unknown as TaskFunction;
 }
 
+// What Airflow accepts as a task id, and so what a name taken from a handler
+// has to look like.
+const TASK_ID_CHARACTERS = /^[\p{L}\p{N}_.-]+$/u;
+
+// A parameter list of plain identifiers, which is the one shape whose names can
+// be read off a function without parsing it.
+const PLAIN_PARAMETERS = /^[A-Za-z_$][\w$]*(?:\s*,\s*[A-Za-z_$][\w$]*)*$/;
+
+/**
+ * A handler's own function name, or undefined when it has none.
+ *
+ * Where a defaulted task id comes from. `airflow-ts-pack` bundles with esbuild's
+ * `keepNames`, so the name survives minification; a bundler that drops names
+ * leaves the empty string, which is why the empty string is not an id.
+ */
+function readFunctionName(handler: unknown): string | undefined {
+  if (typeof handler !== "function") return undefined;
+  const { name } = handler as { name?: unknown };
+  return typeof name === "string" && name.length > 0 ? name : undefined;
+}
+
+/**
+ * The handler's parameter names, when it declares plain ones.
+ *
+ * All-or-nothing: a default, a destructuring pattern, a rest element or a
+ * comment leaves the labels `arg0`, `arg1`, which bind exactly the same way.
+ * `airflow-ts-pack` leaves identifiers alone, so these are the names the author
+ * wrote even in a packed bundle.
+ */
+function inferArgBindings(handler: unknown): readonly string[] | undefined {
+  if (typeof handler !== "function") return undefined;
+  const source = Function.prototype.toString.call(handler);
+  // `async rows => ...`: one parameter, and no parentheses to slice.
+  const bare = /^(?:async\s+)?([A-Za-z_$][\w$]*)\s*=>/.exec(source);
+  if (bare) return Object.freeze([bare[1]!]);
+  const open = source.indexOf("(");
+  const close = source.indexOf(")");
+  const arrow = source.indexOf("=>");
+  // A "(" past the arrow belongs to the body, not to a parameter list.
+  if (open === -1 || close < open || (arrow !== -1 && open > arrow)) return undefined;
+  const parameters = source.slice(open + 1, close).trim();
+  if (parameters === "" || !PLAIN_PARAMETERS.test(parameters)) return undefined;
+  const names = parameters.split(",").map((name) => name.trim());
+  // `length` stops at the first default or rest element, so it matches only a
+  // plain list — and not a slice that a ")" inside a default value cut short.
+  return names.length === handler.length ? Object.freeze(names) : undefined;
+}
+
 function createTaskRef(dagId: string, taskId: string): TaskRef {
   const task: TaskRef = { dagId, taskId };
   brand(task, "TaskRef");
 
@@ -557,6 +557,104 @@ describe("runPack", () => {
     );
   });
 
+  it("takes an omitted task id from the handler name, through minification", async () => {
+    outdir = mkdtempSync(path.join(tmpdir(), "ts-pack-"));
+    const entry = path.join(outdir, "named-entry.ts");
+    writeFileSync(
+      entry,
+      [
+        `import { Bundle, Dag } from ${JSON.stringify(SDK_INDEX)};`,
+        'const salesDag = new Dag("sales_dag");',
+        "salesDag.task(async function extractRows() {})();",
+        "async function loadRows() {}",
+        "salesDag.task(loadRows, { retries: 2 })();",
+        "await new Bundle(salesDag).serve();",
+      ].join("\n"),
+    );
+    const stderr = captureStderr();
+
+    await runPack([entry, "--outdir", outdir]);
+
+    // Read back off the packed artifact, so this asserts what minification
+    // left behind rather than what the source said.
+    expect(JSON.parse(readEmbeddedMetadata(path.join(outdir, "bundle.min.mjs")))).toHaveProperty(
+      "task_handlers.sales_dag.tasks",
+      ["extractRows", "loadRows"],
+    );
+    expect(stderr()).toBe("");
+  });
+
+  it("names a positional handler's arguments, through minification", async () => {
+    outdir = mkdtempSync(path.join(tmpdir(), "ts-pack-"));
+    const entry = path.join(outdir, "positional-entry.ts");
+    writeFileSync(
+      entry,
+      [
+        `import { Bundle, Dag } from ${JSON.stringify(SDK_INDEX)};`,
+        'const salesDag = new Dag("sales_dag");',
+        "const transform = salesDag.task(async function transformRows(rows: number, region: string) {",
+        "  return `${region}:${rows}`;",
+        "});",
+        'transform(1, "us");',
+        "await new Bundle(salesDag).serve();",
+      ].join("\n"),
+    );
+
+    await runPack([entry, "--outdir", outdir]);
+
+    // The Dag reads the names off the handler when it registers, so they have
+    // to survive packing as the parameters themselves.
+    const bundle = readFileSync(path.join(outdir, "bundle.min.mjs"), "utf8");
+    // minifySyntax drops a function expression's own name, which is why
+    // `keepNames` carries the task id; the parameters are what stay verbatim.
+    expect(bundle).toMatch(/async function\s*\(rows,\s*region\)/);
+    expect(JSON.parse(readEmbeddedMetadata(path.join(outdir, "bundle.min.mjs")))).toHaveProperty(
+      "task_handlers.sales_dag.tasks",
+      ["transformRows"],
+    );
+  });
+
+  it("fails the pack when a handler is anonymous and names no task", async () => {
+    outdir = mkdtempSync(path.join(tmpdir(), "ts-pack-"));
+    const entry = path.join(outdir, "anonymous-entry.ts");
+    writeFileSync(
+      entry,
+      [
+        `import { Bundle, Dag } from ${JSON.stringify(SDK_INDEX)};`,
+        'const salesDag = new Dag("sales_dag");',
+        "salesDag.task(async () => undefined)();",
+        "await new Bundle(salesDag).serve();",
+      ].join("\n"),
+    );
+
+    await expect(runPack([entry, "--outdir", outdir])).rejects.toThrow(
+      /has no id: its handler has no name/,
+    );
+  });
+
+  it("takes a computed task id as the id it evaluates to", async () => {
+    outdir = mkdtempSync(path.join(tmpdir(), "ts-pack-"));
+    const entry = path.join(outdir, "computed-entry.ts");
+    writeFileSync(
+      entry,
+      [
+        `import { Bundle, Dag } from ${JSON.stringify(SDK_INDEX)};`,
+        'const salesDag = new Dag("sales_dag");',
+        'const region = "north";',
+        "salesDag.task(`extract_${region}`, async () => undefined)();",
+        'salesDag.task("load_".concat(region), async () => undefined)();',
+        "await new Bundle(salesDag).serve();",
+      ].join("\n"),
+    );
+
+    await runPack([entry, "--outdir", outdir]);
+
+    expect(JSON.parse(readEmbeddedMetadata(path.join(outdir, "bundle.min.mjs")))).toHaveProperty(
+      "task_handlers.sales_dag.tasks",
+      ["extract_north", "load_north"],
+    );
+  });
+
   it("packs only the Dags the served bundle holds", async () => {
     outdir = mkdtempSync(path.join(tmpdir(), "ts-pack-"));
     const entry = path.join(outdir, "forgotten-entry.ts");