cairn-operator-dataflow-skypilot 0.1.3__tar.gz

cairn_operator_dataflow_skypilot-0.1.3/.gitignore

@@ -0,0 +1,100 @@
+# Secrets
+.env
+prod/.env.prod
+.env.local
+.env.*.local
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+*.egg-info/
+.installed.cfg
+*.egg
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+.coverage.*
+htmlcov/
+
+# Virtualenvs
+.venv/
+venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Data caches
+data/chroma/
+*.log
+
+# Eval reports
+evals/last_report.json
+evals/*.report.json
+
+# Build
+build/
+dist/
+# The platform image's build context (#2514): the public wheels the ship step copies beside
+
+# Observability sinks (src/obs)
+events.jsonl
+replays/
+
+# CLI run artifacts: trace dirs (cairn run) + the hash-chained audit log.
+.cairn/
+audit.jsonl
+
+# DuckDB local analytics (scripts/dashboard.py)
+obs.duckdb
+*.duckdb.wal
+*.duckdb.tmp/
+
+# Optional external MCP backend — operators drop this in to enable CAIRN_BACKEND=otel.
+# Without it, the selector falls back to the mock backend with a warning.
+src/mcp/tools/_backends/otel.py
+tests/test_otel_backend.py
+
+# Refactor scratch — incident agent package split kept on disk for reference
+# but not part of the shipped tree. __init__.py files were removed so Python
+# imports src/agents/incident.py (the working single-file module) instead.
+src/agents/incident/
+
+
+.cache/
+.chainlit/
+.files/
+chainlit_app.py
+chainlit.md
+.deepeval/
+.langgraph_api/
+prod/
+
+# stale pre-rename data dir (runtime traces); data now lives in .cairn/
+.obs-agent/
+
+# Never commit a secrets file under any name (an untracked .env backup once held
+# the prod Postgres password, JWT secret and admin hash), nor local work areas.
+.env.*
+!.env.example
+!deploy/light/.env.infisical.example
+# the feature-proof profile's generated keys (scripts/oss/proof_seed.py), never committed
+deploy/light/.proof/
+.proof-out/
+*.bak
+/private/
+/site/
+/data/
+# the generated hello-cairn proof report (scripts/oss/feature_proof.sh)
+/FEATURE_PROOF.md

cairn_operator_dataflow_skypilot-0.1.3/DESIGN.md

@@ -0,0 +1,168 @@
+# cairn-operator-dataflow-skypilot — design
+
+- **Distribution:** `cairn-operator-dataflow-skypilot` (`cairn/operators/optional/dataflow_skypilot/`),
+  offered by `cairndev[skypilot]`
+- **Capabilities provided:** none as operators — it registers the `skypilot` dataflow engine
+  (`cairn.dataflow_engines`), which `dataflow.run` and `ml.run` submit to when selected
+- **Status:** experimental — unit-tested against a fake SkyPilot SDK; not in the hello-cairn
+  feature proof
+- **Decisions:** ADR-0104 D5 (SkyPilot as the provisioning engine), ADR-0099 §1 (derive, refuse,
+  never provision), ADR-0134 D3 (an optional wheel; its launch check is the engine-neutral
+  flow-engine door asking this engine's `check_ready()`), #2073, #2102
+
+## 1. Purpose
+
+Run a cairn flow on a machine this engine ACQUIRES — an SSH node pool built from a
+`compute.ssh` box, or a Vast / RunPod / AWS instance — and give it back afterwards. It is the
+engine for an environment that has no standing compute. It does NOT add operators, govern, or
+register artifacts (the `dataflow/run` / `ml/run` operators of cairn-operator-dataflow do), and
+it never provisions to make a readiness check pass. Until ADR-0134 it lived inside
+cairn-operator-dataflow; it moved out so a default `cairndev` install carries no cloud-SDK
+adapter.
+
+## 2. Architecture
+
+```
+dataflow/run | ml/run  (cairn-operator-dataflow; governance, budget, artifacts)
+        │ resolve_engine(kind) — core: cairn.core.dataflow.engine_registry
+        ▼
+skypilot_engine(kind, target)     factory.py — reads the skypilot_* backend keys
+        ▼
+SkyPilotEngine.submit/poll/result/cancel   engines_skypilot.py — sky.launch / sky.status / sky.down
+        │ the task YAML runs cairn-dataflow-run (cairn-operator-dataflow) on the machine
+        ▼
+SSH node pool | Vast | RunPod | AWS
+```
+
+Before any of that, the launch door (`cairn.core.dataflow.engine_door`, ADR-0134 D3c) builds
+this engine and awaits `SkyPilotEngine.check_ready()`: a target is set, the extra is
+importable, `ssh` and `rsync` are on PATH, the target resolves to an infra, that infra is
+enabled (`sky check`). Imports: `cairn.core.*` only (the operator contract,
+`cairn.core.dataflow` incl. the shared `resources` helpers); never another operator pack; `sky`
+lazily.
+
+The one engine that *acquires* the machine. Three protocol calls map onto three
+SkyPilot calls — `submit`→`sky.launch`, `poll`→`sky.status`, `cancel`→`sky.down`
+— and nothing above the engine changes: the spec still travels as
+`CAIRN_DATAFLOW_SPEC`, the machine still runs `cairn-dataflow-run`, the curve
+still streams over the job channel. Five properties are this module's alone,
+because nothing above it can enforce them:
+
+1. **The cost estimate runs BEFORE `sky.launch`** and refuses; a refused submit
+   has provisioned nothing.
+2. **Every terminal state tears the cluster down, exactly once** — success,
+   failure and cancellation alike.
+3. **The cluster carries its own deadline.** Autostop (as autoDOWN, so the disk
+   goes too) is set from the run's `budget.max_seconds` plus a grace window, or
+   a fixed 120-minute ceiling when the run declared no ceiling. It is the last
+   line of defence, not the first — it covers only the case cancel and teardown
+   cannot: a control plane that dies mid-run.
+4. **Every teardown writes a receipt** (cluster, infra, resources, duration,
+   estimate, and how many outputs came home) as a `skypilot.receipt` run event,
+   so what a run bought is on the run's own timeline instead of in a cloud
+   console.
+5. **The result comes home before the machine stops existing** (#2102). The
+   flow runs in `$HOME/.cairn-jobs/<cluster>` — named explicitly, because
+   `cairn-dataflow-run` writes `result.json`/`metrics.json` into `os.getcwd()`
+   and SkyPilot's run script only does `cd ~/sky_workdir`, a directory that
+   need not exist. On every terminal state *and on cancel*, `_teardown` rsyncs
+   the declared outputs off the cluster **before** `sky down`; fetching after
+   would lose the product with the disk.
+
+The SDK sits behind one seam (`sky_sdk()`, overridable with
+`CAIRN_SKY_SDK_FACTORY`, mirroring `compute_lifecycle.ec2_client`) because a
+live `sky launch` provisions a paid machine: the adapter has to be provable
+without one. The fetch has its own seam (`fetch=`) for the same reason.
+
+`SkyPilotEngine.result()` reads the fetched `result.json` and is byte-for-byte
+the SSH engine's contract, through the SSH engine's own functions —
+`fetch_list()` (which files), `fetch_dir()` (where they land:
+`$TMPDIR/cairn-remote-<cluster>`, deterministic so a restarted control plane
+finds them) and `rewrite_fetched()` (remote workdir paths in `stats` → the
+local copies). One result contract, two transports: a pipeline hoist and the
+next leg cannot tell which engine ran this one. A missing `result.json` is a
+loud refusal naming the receipt to check, never an empty result.
+
+**Why rsync and not the SDK.** Checked against skypilot 0.13.0: `sky.client.sdk`
+has no generic file-download call — `download_logs` returns the job's *logs*,
+not the workdir. What SkyPilot does write, for every cluster it manages, is a
+per-cluster SSH stanza at `~/.sky/generated/ssh/<cluster>`
+(`SSHConfigHelper.add_cluster`; `SKY_USER_FILE_PATH = '~/.sky/generated'`)
+whose `Host` is the cluster name and which already carries the address, user,
+key, port and any proxy command. `rsync -e "ssh -F <that file>"` is therefore
+the transport SkyPilot itself uses, with nothing re-derived here. It is also
+why the door refuses when `ssh`/`rsync` are missing (below).
+
+Target resolution turns a cairn connection into a SkyPilot infra. The door asks
+for the infra *name* only (`materialize=False`) — a dry run must not put a
+private key or an API token on disk; only a real submit writes these:
+
+| Connection kind | Becomes | What lands on disk |
+|---|---|---|
+| `compute.ssh` | `infra: ssh/<pool>` | one entry in `~/.sky/ssh_node_pools.yaml` (merged, never clobbered) + the key at `~/.sky/cairn-keys/<pool>.pem`, mode 0600 — SkyPilot reads the key as a PATH |
+| `compute.vast` | `infra: vast` | `~/.config/vastai/vast_api_key`, mode 0600 — the only place SkyPilot's Vast provider reads it |
+| `compute.runpod` | `infra: runpod` | `~/.runpod/config.toml`, mode 0600 — what `runpod config` writes |
+| any connection holding `AWS_ACCESS_KEY_ID` | `infra: aws` | nothing: the keys are passed as process env for the SDK call only |
+
+## 3. Operators
+
+None. The pack registers one `cairn.dataflow_engines` entry, `skypilot` →
+`operator_dataflow_skypilot.factory:skypilot_engine`. The operators that reach it are
+`dataflow/run` and `ml/run` in cairn-operator-dataflow.
+
+## 4. Configuration
+
+| Key | Kind | Scope | Default | Meaning |
+|---|---|---|---|---|
+| `ml_engine` / `dataflow_engine` = `skypilot` | backend field | deployment | `builtin` | select this engine for a flow kind |
+| `ml_target` / `dataflow_target` | backend field | deployment | `` | the compute connection to provision on — required; empty is a refusal at the door |
+| `skypilot_image` / `CAIRN_SKYPILOT_IMAGE` | backend field | deployment | `` | image the provisioned machine runs; empty = a `pip install` setup step (slower, driftable) |
+| `skypilot_accelerator` / `CAIRN_SKYPILOT_ACCELERATOR` | backend field | deployment | `` | the accelerator TYPE the target offers (`A100`, `T4`); the COUNT is the stage's `gpu` hint, sent as `<type>:<count>`. A flow asking for GPUs with this empty is refused |
+| `skypilot_use_spot` / `CAIRN_SKYPILOT_USE_SPOT` | backend field | deployment | `false` | ask for pre-emptible capacity; a reclaimed machine surfaces as a RETRIABLE failure |
+| `CAIRN_SKYPILOT_SETUP` | env | deployment | `pip install 'cairndev[dataflow-engine]'` | override the setup line for a bare VM |
+| `CAIRN_SKYPILOT_HOURLY_USD` | env | deployment | — | price used for the pre-launch estimate when the connection declares none |
+| `CAIRN_SKY_SDK_FACTORY` | env | dev/test | — | point the SkyPilot seam at a fake; unset in production |
+
+## 5. Governance
+
+Reached only through `dataflow/run` / `ml/run`, so every flow leg passes `enforce_flow_gate` and
+the flow-engine door before any record exists. The pre-launch cost estimate is checked against
+the leg's budget before `sky launch`; the cluster is torn down on cancel and after the result is
+fetched; a receipt (`skypilot.receipt`) is recorded per run. The environment allowlist is core's
+engine-neutral set only — no Metaflow configuration and no ambient credential reaches a
+provisioned machine (ADR-0134 D3b).
+
+## 6. Failure modes
+
+| Failure | Cause | Effect | Recovered? |
+|---|---|---|---|
+| Engine not installed | `skypilot` selected without `cairndev[skypilot]` | refused at the launch door, naming the extra | n/a |
+| No target | `ml_target`/`dataflow_target` empty | `check_ready()` refusal at the door | n/a |
+| `ssh`/`rsync` missing (#2102) | the image carries the extra but not the binaries | `check_ready()` refusal | n/a — install them in the image |
+| Infra not enabled | `sky check` does not list the target's infra | `check_ready()` refusal | n/a |
+| Pre-emption | a spot machine reclaimed | the leg fails; no preemption recovery yet | GAP |
+| Cluster left running after a cancelled or failed run (#2073) | a provisioner with no teardown on the terminal path | every terminal state and `cancel` call `sky down` once and write a receipt | yes |
+| Cluster outlives the control plane (#2073) | the process that would tear it down died | autostop/autodown, derived from `budget.max_seconds` + grace (default 120 min) | yes — but it is a backstop; no receipt is written for a cluster the control plane never saw end |
+| A run launches over budget (#2073) | no pre-launch cost check existed for a flow spec | `EngineError` naming the estimate, the ceiling and the infra; nothing provisioned | yes |
+| A run's cost cannot be priced (#2073) | neither the connection's `hourly_usd` nor `CAIRN_SKYPILOT_HOURLY_USD` is set | launches, and the receipt records `priced: false` | no — deliberate: refusing every unpriced run would make the engine unusable, and the receipt makes the gap visible |
+| SkyPilot forgets a cluster it launched (#2073) | its state is a SQLite db under `~/.sky`, which was not on a volume — a control-plane restart lost the cluster records, the SSH node pool and the materialised key | the Helm chart persists `/root/.sky` on the same claim, and REFUSES to render `CAIRN_ML_ENGINE=skypilot` with persistence disabled | yes — but only for the chart; any other deployment shape must mount that path itself, or `sky down` cannot reach a machine that is still billing |
+| The door refused every launch on a good install (#2073) | `sky.enabled_clouds` does not exist at the top level — it is `sky.client.sdk.enabled_clouds`, and the door turns any exception into a refusal | the adapter calls the path that exists; verified against skypilot 0.13 in a throwaway venv | yes |
+| A GPU request asked for an accelerator named "1" (#2073) | `accelerators` was the COUNT alone; SkyPilot wants `<type>:<count>` and parses a bare count as a device NAME (`{'1': 1}`) | the count comes from the stage hint, the TYPE from `skypilot_accelerator`; a GPU request without a type is refused before launch | yes — and the pack's own test had asserted the broken value |
+| The door passed with NOTHING enabled (#2102) | `check_ready` guarded the enabled-infra check with `if enabled and …`, so an empty `sky check` skipped it; seen live in the deployed control plane (`enabled_infra() == []`, verdict ok) | an empty `sky check` is a refusal naming `sky check` and, for an SSH pool, `sky ssh up <pool>`; the membership check always runs | yes |
+| A control plane with the extra installed could launch nothing (#2102) | `Dockerfile.engine` is `python:3.13-slim-trixie`, which ships neither `ssh` nor `rsync`; SkyPilot shells out to both for every node it provisions or adopts and `sky ssh up` needs them (asyncssh is pure Python and does not help). Seen live in the chart-installed pod: `command -v ssh` → nothing | the image installs `openssh-client` + `rsync` (with a build-time `command -v` gate), and the door refuses NAMING the missing binary | yes |
+| A flow leg on SkyPilot could never hand its product to the next leg (#2102) | `result()` raised: the lifecycle shipped without the artifact fetch-back, so only the live metric stream came home | `_teardown` rsyncs the declared outputs off the cluster BEFORE `sky down` (on cancel too), over SkyPilot's own generated per-cluster ssh config; `result()` reads them through the SSH engine's `fetch_list`/`fetch_dir`/`rewrite_fetched` | yes — but only against fakes; the rsync itself has never met a real cluster |
+
+## 7. Testing
+
+`tests/test_skypilot_engine.py` drives a fake SkyPilot SDK (`CAIRN_SKY_SDK_FACTORY` seam): task
+YAML, target resolution, the receipt, teardown, the fetch, and `check_ready()` including the
+empty-target refusal. `tests/test_skypilot_env_allowlist.py` pins the allowlist. No test talks
+to a real cloud — a live `sky launch` provisions a paid machine.
+
+## 8. History
+
+| Date | Change | Issue |
+|---|---|---|
+| 2026-09 | SkyPilot as the provisioning engine (ADR-0104 D5), in cairn-operator-dataflow | #2073, #2102 |
+| 2026-10-16 | The launch check moves from a core SkyPilot door to `check_ready()` behind the engine-neutral flow-engine door (ADR-0134 D3c) | #2683 |
+| 2026-10-16 | Its own optional wheel behind `cairndev[skypilot]` (ADR-0134 D3a) | #2678 |

cairn_operator_dataflow_skypilot-0.1.3/LICENSE

@@ -0,0 +1,202 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 The cairn Authors
+
+   Licensed 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.
+

cairn_operator_dataflow_skypilot-0.1.3/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.5
+Name: cairn-operator-dataflow-skypilot
+Version: 0.1.3
+Summary: The SkyPilot provisioning dataflow engine (ADR-0104 D5) for cairn's ml and data flows — offered by cairndev[skypilot] (ADR-0134 D3).
+Project-URL: Homepage, https://cairndev.sh
+Project-URL: Documentation, https://docs.cairndev.sh
+Project-URL: Source, https://github.com/cairndev-sh/cairn
+Project-URL: Issues, https://github.com/cairndev-sh/cairn/issues
+Author: cairn maintainers
+License-Expression: Apache-2.0
+License-File: LICENSE
+Requires-Python: >=3.12
+Provides-Extra: skypilot
+Requires-Dist: skypilot[aws,kubernetes,runpod,ssh,vast]>=0.13; extra == 'skypilot'
+Description-Content-Type: text/markdown
+
+# cairn-operator-dataflow-skypilot — see DESIGN.md + ADR-0104 D5, ADR-0134 D3.
+
+The SkyPilot provisioning engine for cairn: `pip install 'cairndev[skypilot]'`, set
+`[profile.backends] ml_engine = "skypilot"` (or `dataflow_engine`) and point `ml_target` /
+`dataflow_target` at a compute connection. The launch door asks this engine's `check_ready()`
+before any record exists — nothing is provisioned to make the check pass.

cairn_operator_dataflow_skypilot-0.1.3/README.md

@@ -0,0 +1,6 @@
+# cairn-operator-dataflow-skypilot — see DESIGN.md + ADR-0104 D5, ADR-0134 D3.
+
+The SkyPilot provisioning engine for cairn: `pip install 'cairndev[skypilot]'`, set
+`[profile.backends] ml_engine = "skypilot"` (or `dataflow_engine`) and point `ml_target` /
+`dataflow_target` at a compute connection. The launch door asks this engine's `check_ready()`
+before any record exists — nothing is provisioned to make the check pass.

cairn_operator_dataflow_skypilot-0.1.3/pack.toml

@@ -0,0 +1,15 @@
+# cairn-operator-dataflow-skypilot — the SkyPilot provisioning dataflow engine (ADR-0104 D5),
+# moved out of cairn-operator-dataflow into its own optional wheel (ADR-0134 D3a, #2678). It
+# registers no operator: the `dataflow/run` and `ml/run` operators (cairn-operator-dataflow)
+# submit to it when an environment selects `skypilot` as its dataflow_engine / ml_engine.
+[pack]
+name        = "obs-operator-dataflow-skypilot"
+version     = "0.1.0"
+type        = "operator"
+description = "The SkyPilot provisioning engine behind dataflow/run and ml/run (cairndev[skypilot])."
+kind        = "service_provider"
+publisher   = "cairn"
+trust_level = "official"
+
+[compat]
+cairn_engine = ">=0.1.0"

cairn_operator_dataflow_skypilot-0.1.3/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cairn-operator-dataflow-skypilot"
+version = "0.1.3"
+description = "The SkyPilot provisioning dataflow engine (ADR-0104 D5) for cairn's ml and data flows — offered by cairndev[skypilot] (ADR-0134 D3)."
+readme = "README.md"
+license = "Apache-2.0"
+authors = [{name = "cairn maintainers"}]
+requires-python = ">=3.12"
+# No hard dependency on SkyPilot: the engine imports `sky` lazily, so this wheel imports and
+# registers without it (its tests drive a fake). `cairndev[skypilot]` installs both; installing
+# this wheel alone, add the extra below.
+dependencies = []
+
+[project.optional-dependencies]
+# The PROVISIONING engine (ADR-0104 D5, #2073): the clouds cairn's compute connections
+# already name are the extras picked. A control plane that never acquires a machine must not
+# carry this cloud SDK stack, which is why it is optional.
+skypilot = ["skypilot[aws,kubernetes,runpod,ssh,vast]>=0.13"]
+
+[project.urls]
+Homepage = "https://cairndev.sh"
+Documentation = "https://docs.cairndev.sh"
+Source = "https://github.com/cairndev-sh/cairn"
+Issues = "https://github.com/cairndev-sh/cairn/issues"
+
+# #1512 — core selects an engine by NAME through this group and never imports this pack.
+[project.entry-points."cairn.dataflow_engines"]
+"skypilot" = "operator_dataflow_skypilot.factory:skypilot_engine"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/operator_dataflow_skypilot"]
+
+[tool.hatch.build.targets.wheel.force-include]
+"pack.toml" = "operator_dataflow_skypilot/pack.toml"

cairn_operator_dataflow_skypilot-0.1.3/src/operator_dataflow_skypilot/__init__.py

@@ -0,0 +1,4 @@
+"""cairn-operator-dataflow-skypilot — the SkyPilot provisioning dataflow engine (ADR-0104 D5),
+an optional wheel offered by ``cairndev[skypilot]`` (ADR-0134 D3). Registered as ``skypilot``
+in the ``cairn.dataflow_engines`` group; core selects it by name and never imports this
+package, and asks its ``check_ready()`` at the launch door (ADR-0134 D3c)."""