Send known task-handler artifacts to the Dag-parsing child

[jason810496]

Stack (bottom to top): #73970, #73971, #73972, #73973, #73974, #73975, #73976, #73977, #74030, #74031, #74032, #74033, #74067

Why

The Dag-parsing child has no database, so the task-handler artifacts the Dag processor already recorded, each with its probe answer, must arrive with the parse request (ADR-0013 "Objects on the wire"). A later layer's fast path uses an artifact's recorded answer when its size and digest still match, instead of probing it again. Nothing reads the field yet.

What changes

DagFileParseRequest gains the known artifacts:

class TaskHandlerArtifact(BaseModel):
    bundle_name: str
    relative_fileloc: str = Field(max_length=2000)
    size_bytes: int
    cache_digest: str | None = Field(max_length=128)
    task_handlers: dict[str, list[TaskHandlerDeclaration]]  # the artifact's whole probe answer


class DagFileParseRequest(BaseModel):
    ...
    known_artifacts: list[TaskHandlerArtifact] = Field(default_factory=list)

With this config, a Dag file in the dags-a bundle gets the rows of java-task-handlers (named) and of dags-a (because go-sdk names no bundle, so it reads the task's own Dag bundle). With [core] multi_team, it gets the java-task-handlers rows only if that bundle's team equals the team of dags-a:

[sdk]
coordinators = {
    "jdk-17": {"classpath": "...JavaCoordinator", "kwargs": {"task_handler_bundle_name": "java-task-handlers"}},
    "go-sdk": {"classpath": "...ExecutableCoordinator"}
}
queue_to_coordinator = {"java": "jdk-17", "golang": "go-sdk"}

• The manager reads lang_sdk_task_handler_artifact, including the task_handlers answer, once per parsing loop and only when it starts a child. That makes rows persisted by earlier children visible to later ones. The query covers the task_handler_bundle_name of each coordinator a queue routes to, plus the Dag bundles it parses when one of them names none, and filters on the leading column of the (bundle_name, relative_fileloc_hash) unique index. Rows come back ordered by bundle and path, so a child's payload is reproducible. There is no query when no queue routes to a coordinator.
• Each child gets the rows of the named bundles whose team equals its Dag bundle's team, plus its own Dag bundle's rows when a coordinator falls back to it, never another Dag bundle's. A recorded answer is trusted by every Dag file that reads it, so it must not cross a team. Without [core] multi_team every team is None and every named bundle is in scope; with it, a team-less Dag bundle sees only team-less named bundles. Files without stub tasks get their scope's rows too.
• The scope is computed in one manager method, which the next layer reuses for the bundles a parse may record answers in.
• cache_digest is None for an artifact that stores no digest. It never matches, so such an artifact is probed on every parse. The max_lengths match the columns.
• CoordinatorManager.get_task_handler_bundle_names() maps each coordinator a queue routes to, by key, to its bundle name, or None for the Dag's own bundle. It reads the specs from_config validated and builds no coordinator. A coordinator no queue routes to runs no stub task, so its bundle is not read, and from_config does not validate its bundle name.
• An invalid [sdk] coordinators value is logged once, and the Dag files are parsed with no known artifacts, so Python-only parsing keeps running.
• A stored row that fails validation is skipped with a warning, so the other rows still go out and that artifact is probed again. A failed read is logged, and the children started in that loop get no known artifacts, so they probe.
• get_known_task_handler_artifacts(bundle_names) reads the database by default and can be overridden to source the rows elsewhere, like fetch_callbacks.
• AddKnownArtifactsToDagFileParseRequest in the in-progress 2026-10-30 version drops the field for a runtime pinned to 2026-06-16. The snapshot, ts-sdk/src/generated/supervisor.ts and the vendored java-sdk/sdk/schema/schema.json are regenerated.
• The Go genmodels are regenerated too, since check-go-sdk-generated-drift (Go SDK: bring the coordinator-protocol models back to the supervisor schema #73963) fails when they lag the snapshot.
• ADR-0013 now describes the fallback bundles, the per-child and per-team scope, and TaskHandlerArtifact with its answer, and its probe sketch no longer sends Dag ids.

How to test

uv run --project airflow-core --with-editable shared/secrets_masker pytest airflow-core/tests/unit/dag_processing/ airflow-core/tests/unit/models/test_lang_sdk_task_handler.py -q
uv run --project task-sdk pytest task-sdk/tests/task_sdk/coordinators task-sdk/tests/task_sdk/execution_time/schema task-sdk/tests/task_sdk/execution_time/test_coordinator.py -q
uv run --project task-sdk --with-editable shared/secrets_masker pytest task-sdk/tests/task_sdk/execution_time/test_supervisor.py -q
breeze run --backend postgres pytest airflow-core/tests/unit/dag_processing/test_manager.py -k "KnownTaskHandlerArtifacts or serialize_parse_request or callback_queue"

Ran:

• airflow-core/tests/unit/dag_processing/ and test_lang_sdk_task_handler.py: 640 passed, 12 skipped (Postgres-only budgets and opt-in real probes).
• task-sdk: coordinators, schema and coordinator tests 327 passed; test_supervisor.py 332 passed, 1 skipped (non-Linux only).
• The manager tests above on Postgres and MySQL through breeze: 23 passed each.
• ./gradlew -p java-sdk :sdk:test --tests '*TaskHandlerParseTest*' and compile-ts-sdk passed against the regenerated schema.
• prek run --from-ref <parent> --stage pre-commit passed, including check-supervisor-schemas-versions without SKIP, mypy-airflow-core and mypy-task-sdk.

The migrator test fails with AddKnownArtifactsToDagFileParseRequest removed from the bundle.

---

Was generative AI tooling used to co-author this PR?

• Yes (please specify the tool below)

Generated-by: Claude Code (Opus 5.5) following the guidelines