riffdb-mlflow 0.2.0__tar.gz

riffdb_mlflow-0.2.0/.github/riffdb-revision

@@ -0,0 +1 @@
+fc72da6e3d2af6ab29be72712139e9d16bcaf233

riffdb_mlflow-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,175 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+  workflow_dispatch:
+    inputs:
+      release_tag:
+        description: 'Release tag to verify (for example v0.2.0)'
+        required: false
+        default: 'v0.2.0'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  verify-and-build:
+    name: Verify adapter and build Python distributions
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    outputs:
+      release_tag: ${{ steps.meta.outputs.release_tag }}
+      version: ${{ steps.meta.outputs.version }}
+      revision: ${{ steps.meta.outputs.revision }}
+    steps:
+      - name: Check out adapter
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+      - name: Install Python
+        uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
+        with:
+          python-version: '3.13'
+      - name: Install uv
+        run: python3 -m pip install --quiet uv
+      - name: Resolve release metadata and download RiffDB release bundle
+        id: meta
+        run: |
+          if [[ "${{ github.event_name }}" == "push" ]]; then
+            release_tag="${GITHUB_REF_NAME}"
+          else
+            release_tag="${{ inputs.release_tag || 'v0.2.0' }}"
+          fi
+          [[ "$release_tag" =~ ^v([0-9]+\.[0-9]+\.[0-9]+)$ ]]
+          version="${BASH_REMATCH[1]}"
+          python3 - "$version" <<'PY'
+          from pathlib import Path
+          import sys
+          import tomllib
+          expected = sys.argv[1]
+          pyproject = tomllib.loads(Path("pyproject.toml").read_text(encoding="utf-8"))
+          assert pyproject["project"]["version"] == expected, pyproject["project"]["version"]
+          init_text = Path("src/riffdb_mlflow/__init__.py").read_text(encoding="utf-8")
+          assert f'__version__ = "{expected}"' in init_text, init_text
+          PY
+          riffdb_rev="$(cat .github/riffdb-revision)"
+          [[ "$riffdb_rev" =~ ^[0-9a-f]{40}$ ]]
+
+          bundle="riffdb-${version}-x86_64-unknown-linux-gnu.tar.gz"
+          base_url="https://github.com/riffdb/riffdb/releases/download/${release_tag}"
+          mkdir -p "$RUNNER_TEMP/riffdb-release"
+          curl -fsSL "$base_url/release-provenance-v1.json" -o "$RUNNER_TEMP/riffdb-release/release-provenance-v1.json"
+          curl -fsSL "$base_url/$bundle" -o "$RUNNER_TEMP/riffdb-release/$bundle"
+          expected_sha="$(jq -r '.bundle_archive.sha256' "$RUNNER_TEMP/riffdb-release/release-provenance-v1.json")"
+          echo "${expected_sha}  $RUNNER_TEMP/riffdb-release/$bundle" | sha256sum -c -
+          tar -xzf "$RUNNER_TEMP/riffdb-release/$bundle" -C "$RUNNER_TEMP/riffdb-release"
+          bundle_dir="$RUNNER_TEMP/riffdb-release/riffdb-${version}-x86_64-unknown-linux-gnu"
+          [[ "$(tr -d '\n' < "$bundle_dir/REVISION")" == "$riffdb_rev" ]]
+          "$bundle_dir/bin/riffdb" application check
+
+          printf 'release_tag=%s\n' "$release_tag" >>"$GITHUB_OUTPUT"
+          printf 'version=%s\n' "$version" >>"$GITHUB_OUTPUT"
+          printf 'revision=%s\n' "$riffdb_rev" >>"$GITHUB_OUTPUT"
+      - name: Run adapter checks and build wheel and sdist
+        run: |
+          uv sync --locked
+          make check
+          mkdir -p "$RUNNER_TEMP/release-out"
+          uv build --out-dir "$RUNNER_TEMP/release-out"
+          (
+            cd "$RUNNER_TEMP/release-out"
+            sha256sum "riffdb_mlflow-${{ steps.meta.outputs.version }}"* >SHA256SUMS
+          )
+      - name: Upload verified release artifacts
+        uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
+        with:
+          name: riffdb-mlflow-release
+          path: ${{ runner.temp }}/release-out/*
+          if-no-files-found: error
+
+  publish-release:
+    name: Publish GitHub Release and PyPI package
+    needs: [verify-and-build]
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: write
+      id-token: write
+      attestations: write
+    steps:
+      - name: Check out adapter
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+      - name: Download verified release artifacts
+        uses: actions/download-artifact@9000827ccba6bdab643e8b6fd33ac0654aef8333 # v8.0.2
+        with:
+          name: riffdb-mlflow-release
+          path: release-out
+      - name: Attest build provenance
+        uses: actions/attest-build-provenance@4d101475d8b20a2381f78447822ac1eab6504dd8 # v4.2.2
+        with:
+          subject-path: |
+            release-out/riffdb_mlflow-${{ needs.verify-and-build.outputs.version }}-py3-none-any.whl
+            release-out/riffdb_mlflow-${{ needs.verify-and-build.outputs.version }}.tar.gz
+            release-out/SHA256SUMS
+      - name: Publish GitHub Release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          tag="${{ needs.verify-and-build.outputs.release_tag }}"
+          version="${{ needs.verify-and-build.outputs.version }}"
+          notes="Compiled RiffDB tracking-store adapter for MLflow v${version} (pinned to RiffDB \`${{ needs.verify-and-build.outputs.revision }}\` and \`riffdb==${version}\`)."
+          if gh release view "$tag" >/dev/null 2>&1; then
+            gh release upload "$tag" release-out/* --clobber
+          else
+            gh release create "$tag" release-out/* \
+              --title "riffdb-mlflow ${tag}" \
+              --notes "$notes" \
+              --verify-tag
+          fi
+      - name: Publish to PyPI (when token or Trusted Publishing is configured)
+        env:
+          PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }}
+        run: |
+          python3 -m pip install --quiet twine
+          if [[ -n "${PYPI_TOKEN:-}" ]]; then
+            python3 -m twine upload --non-interactive --skip-existing -u __token__ -p "$PYPI_TOKEN" release-out/*.whl release-out/*.tar.gz
+          else
+            python3 - <<'PY' || echo "::warning::PyPI Trusted Publishing or PYPI_TOKEN is not yet configured for riffdb-mlflow; GitHub Release wheel and sdist are published."
+          import json
+          import os
+          import subprocess
+          import sys
+          import urllib.request
+
+          req_url = os.environ["ACTIONS_ID_TOKEN_REQUEST_URL"]
+          req_tok = os.environ["ACTIONS_ID_TOKEN_REQUEST_TOKEN"]
+          sep = "&" if "?" in req_url else "?"
+          req = urllib.request.Request(
+              f"{req_url}{sep}audience=pypi",
+              headers={"Authorization": f"Bearer {req_tok}", "Accept": "application/json; api-version=2.0"},
+          )
+          with urllib.request.urlopen(req, timeout=30) as resp:
+              jwt = json.loads(resp.read().decode("utf-8"))["value"]
+          mint = urllib.request.Request(
+              "https://upload.pypi.org/_/oidc/mint-token",
+              data=json.dumps({"token": jwt}).encode("utf-8"),
+              headers={"Content-Type": "application/json", "Accept": "application/json"},
+              method="POST",
+          )
+          with urllib.request.urlopen(mint, timeout=30) as resp:
+              pypi_tok = json.loads(resp.read().decode("utf-8"))["token"]
+          import glob
+          pkgs = sorted(glob.glob("release-out/*.whl") + glob.glob("release-out/*.tar.gz"))
+          subprocess.run(
+              [sys.executable, "-m", "twine", "upload", "--non-interactive", "--skip-existing", "-u", "__token__", "-p", pypi_tok, *pkgs],
+              check=True,
+          )
+          PY
+          fi

riffdb_mlflow-0.2.0/.github/workflows/riffdb-compatibility.yml

@@ -0,0 +1,69 @@
+name: RiffDB compatibility
+
+on:
+  push:
+  pull_request:
+  schedule:
+    - cron: '23 4 * * *'
+  workflow_dispatch:
+    inputs:
+      riffdb_ref:
+        description: 'Full RiffDB commit or main; empty uses the adapter pin'
+        required: false
+        default: ''
+
+permissions:
+  contents: read
+
+concurrency:
+  group: riffdb-compatibility-${{ github.ref }}-${{ github.event_name }}
+  cancel-in-progress: true
+
+jobs:
+  application-compatibility:
+    name: Application compatibility
+    runs-on: ubuntu-24.04
+    timeout-minutes: 30
+    env:
+      CARGO_INCREMENTAL: '0'
+      CARGO_TARGET_DIR: ${{ github.workspace }}/riffdb/target
+    steps:
+      - name: Check out adapter
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          path: adapter
+          persist-credentials: false
+      - name: Select RiffDB revision
+        id: riffdb
+        env:
+          EVENT_NAME: ${{ github.event_name }}
+          REQUESTED_REF: ${{ inputs.riffdb_ref }}
+        run: |
+          revision="$(cat adapter/.github/riffdb-revision)"
+          [[ "$revision" =~ ^[0-9a-f]{40}$ ]]
+          if [[ "$EVENT_NAME" == schedule ]]; then revision=main; fi
+          if [[ -n "$REQUESTED_REF" ]]; then revision="$REQUESTED_REF"; fi
+          [[ "$revision" =~ ^([0-9a-f]{40}|main)$ ]]
+          printf 'revision=%s\n' "$revision" >>"$GITHUB_OUTPUT"
+      - name: Check out RiffDB
+        uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          repository: riffdb/riffdb
+          ref: ${{ steps.riffdb.outputs.revision }}
+          path: riffdb
+          persist-credentials: false
+      - name: Install Rust toolchain
+        run: rustup toolchain install 1.98.1 --profile minimal
+      - name: Cache Cargo sources
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+          key: cargo-compatibility-${{ runner.os }}-${{ hashFiles('riffdb/Cargo.lock') }}
+      - name: Build selected RiffDB CLI
+        working-directory: riffdb
+        run: cargo build --locked --release -p riffdb-cli --bin riffdb
+      - name: Check adapter application
+        working-directory: adapter
+        run: ../riffdb/target/release/riffdb application check

riffdb_mlflow-0.2.0/.gitignore

@@ -0,0 +1,9 @@
+.venv/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+__pycache__/
+*.py[cod]
+build/
+dist/
+*.egg-info/

riffdb_mlflow-0.2.0/AGENTS.md

@@ -0,0 +1,63 @@
+# AGENTS.md — RiffDB MLflow adapter
+
+## Mission
+
+Implement a standalone Python tracking-store plugin for pinned MLflow releases
+using a compiled RiffDB application. All MLflow-specific behavior belongs in
+this repository, never in RiffDB.
+
+## Authoritative inputs
+
+- MLflow `v3.15.1`, especially `mlflow.store.tracking.AbstractStore` and the
+  upstream SQL tracking-store tests.
+- This repository's `DESIGN.md` and `PLAN.md`.
+- The accepted RiffDB specification and ADRs at the revision recorded in the
+  generated application lock and dependency receipt.
+
+If these inputs conflict, stop and request maintainer review. Do not weaken an
+MLflow semantic or a RiffDB safety guarantee to make a test pass.
+
+## Architecture boundaries
+
+1. MLflow mutations use generated, compiled RiffDB commands only.
+2. Reads use generated named RiffQL queries only. Do not add generic CRUD,
+   dynamically assembled RiffQL, client-side filtering, or full-store scans.
+3. One MLflow API mutation that is atomic in the SQL store remains one atomic
+   compiled command, including bounded metric/parameter/tag batches.
+4. Search syntax is parsed and normalized according to MLflow. Every accepted
+   shape dispatches to a finite named-query family; unsupported shapes fail
+   before contacting RiffDB.
+5. Pagination is bounded and continuation tokens are opaque, filter-bound, and
+   rejected on cross-query reuse.
+6. MLflow metric values preserve their exact IEEE-754 payload and MLflow's
+   latest-metric ordering semantics, including NaN and infinities.
+7. Artifact bytes remain in an MLflow artifact repository. This adapter stores
+   tracking metadata and never turns RiffDB into an artifact blob store.
+8. Public exceptions map deliberately to MLflow error codes and never expose
+   RiffDB internals, credentials, protected values, or symbolic plan details.
+
+## Stop conditions
+
+Pause for a generic RiffDB capability or DX review if implementation would
+require:
+
+- splitting an atomic MLflow batch or lifecycle transition;
+- an unbounded query, client-side filtering, sorting, or cursor walking used to
+  repair semantics;
+- process-local time, IDs, ordering, locks, or leases for durable correctness;
+- arbitrary transaction callbacks, raw query text, or direct storage access;
+- target-language reimplementation of RiffDB transport guarantees; or
+- MLflow-specific behavior, vocabulary, routes, or schemas in RiffDB.
+
+## Completion checks
+
+Before calling the adapter usable:
+
+```bash
+make check
+make conformance
+```
+
+Unit fakes may supplement upstream tests but never replace real RiffDB
+loopback coverage.
+

riffdb_mlflow-0.2.0/DESIGN.md

@@ -0,0 +1,88 @@
+# Design
+
+## Compatibility target
+
+The first release pins MLflow `3.15.1` and registers the `riffdb` URI scheme in
+the official `mlflow.tracking_store` entry-point group. The package implements
+the tracking backend used for experiments, runs, metrics, parameters, tags,
+inputs, and search. Artifact payloads remain in the artifact repository named
+by MLflow's `artifact_uri` argument.
+
+MLflow 3.15.1's tracking `AbstractStore` has sixteen abstract methods. The
+compatibility gate records those methods and fails when a pinned upstream
+upgrade changes the abstract surface. Concrete optional domains added by
+MLflow—traces, assessments, evaluation datasets, scorers, review queues, and
+similar GenAI metadata—remain explicitly unsupported until a profile and its
+upstream tests are added. They must never silently fall back to another store.
+
+The Python floor is 3.13, matching the published RiffDB Python driver rather
+than MLflow's broader interpreter matrix.
+
+## Core behavior
+
+| Domain | Required behavior |
+|---|---|
+| Experiments | Unique names, create/get/search, rename, soft delete/restore, tags, stable pages |
+| Runs | Create/get/search, lifecycle updates, soft delete/restore, exact latest data |
+| Metrics | Atomic bounded batches, full paged history, exact IEEE-754 values, MLflow latest-value tie-breaking |
+| Parameters | Immutable per-run key/value binding and duplicate-conflict behavior |
+| Tags | Last-write-wins set and exact deletion semantics |
+| Inputs | Atomic dataset/model input associations with deterministic bounded encoding |
+| Authorization | Per-experiment and per-run row policy through the compiled profile, never Python filtering |
+
+The SQL store is the behavioral reference. RiffDB is not treated as SQL and
+the adapter does not emulate SQL transactions; it exposes equivalent MLflow
+semantics through compiled commands and named queries.
+
+## Configuration
+
+MLflow constructs the plugin with `(store_uri, artifact_uri)`. The canonical
+tracking URI is `riffdb://<database>`. It contains no credential or TLS
+material. Connection authority comes from protected process configuration:
+
+- `RIFFDB_MLFLOW_ENDPOINT`
+- `RIFFDB_MLFLOW_TRUST_ROOT`
+- `RIFFDB_MLFLOW_SERVER_NAME`
+- `RIFFDB_MLFLOW_CREDENTIAL_FILE`
+
+The credential file is consumed through RiffDB's nonextractable protected-file
+API. The database in the URI becomes `CallMetadata`'s database alias. Unknown
+URI components, user information, ports, paths, query parameters, and fragments
+fail before any transport work.
+
+## IDs and time
+
+MLflow-facing experiment and run IDs remain strings with the behavior required
+by upstream tests. MLflow's FileStore establishes that experiment IDs may be
+random fixed-width integers rather than SQL sequences, so the adapter generates
+an 18-digit numeric ID and submits it to one atomic create command. Run IDs use
+MLflow's UUID-shaped convention. Millisecond values supplied by MLflow remain
+exact signed integers. Adapter wall-clock time never establishes durable
+ordering, state transitions, or lease validity.
+
+## Metric representation
+
+An MLflow metric value is an IEEE-754 binary64, not a business decimal. The
+adapter preserves its canonical 64-bit payload, including signed zero, NaN, and
+infinities. It also derives a bytewise sortable key whose ordering is proven
+against MLflow's numeric comparison behavior. The contract stores both values;
+neither is rounded through decimal or JSON. Latest metrics are selected by
+MLflow's `(step, timestamp, value)` precedence in a named query.
+
+## Query compilation boundary
+
+MLflow accepts a textual search grammar. Python parses that grammar using
+MLflow's own parser and normalizes it into a closed internal shape. The shape
+selects a generated named query; it never supplies field, operator, index,
+order, or raw predicate text to RiffDB. Unsupported conjunctions, fields, or
+orders fail with MLflow's invalid-parameter error.
+
+Search result hydration must be bounded in the query or command result. N+1
+reads, fetch-and-filter, adapter sorting, and offset simulation are prohibited.
+
+## Error mapping
+
+RiffDB application outcomes map to MLflow's documented error codes for missing
+resources, duplicates, invalid states, invalid parameters, concurrency
+conflicts, cancellation, deadline, and temporary unavailability. Unknown
+transport or validation failures become a stable redacted internal error.

riffdb_mlflow-0.2.0/Makefile

@@ -0,0 +1,27 @@
+UV ?= uv
+PYTHON ?= $(UV) run python
+RIFFDB ?= riffdb
+
+.PHONY: bootstrap format lint typecheck test check conformance
+
+bootstrap:
+	$(UV) sync
+
+format:
+	$(UV) run ruff format --check .
+
+lint:
+	$(UV) run ruff check .
+
+typecheck:
+	$(UV) run mypy
+
+test:
+	$(UV) run pytest
+
+check: format lint typecheck test
+	git diff --exit-code
+
+conformance:
+	$(RIFFDB) dev --reset --exec '$(PYTHON) -m riffdb_mlflow "$$RIFFDB_ENDPOINT" "$$RIFFDB_CREDENTIAL_FILE" "$$RIFFDB_DATABASE"'
+

riffdb_mlflow-0.2.0/PKG-INFO

@@ -0,0 +1,78 @@
+Metadata-Version: 2.5
+Name: riffdb-mlflow
+Version: 0.2.0
+Summary: Compiled RiffDB tracking-store adapter for MLflow
+Author: RiffDB contributors
+License: MIT OR Apache-2.0
+Requires-Python: >=3.13
+Requires-Dist: mlflow==3.15.1
+Requires-Dist: riffdb==0.2.0
+Description-Content-Type: text/markdown
+
+# riffdb-mlflow
+
+`riffdb-mlflow` is a compiled RiffDB tracking-store plugin for MLflow. It is an
+out-of-tree integration: no MLflow-specific code or vocabulary belongs in the
+RiffDB repository.
+
+The project targets **MLflow 3.15.1** and implements the complete `AbstractStore`
+tracking, tracing, evaluation assessment, trace analytics, logged-model, and
+run-lineage surface:
+
+- **Experiments & Runs**: atomic experiment creation with tags, lifecycle and
+  tag updates, `exact`/`LIKE`/`ILIKE` experiment search, atomic run creation
+  with tags, run get/update/delete/restore, bounded atomic `log_batch`
+  (metrics, parameters, tags), `get_metric_history`, `log_inputs`, `log_outputs`,
+  and `record_logged_model`.
+- **Traces & Out-of-Order Spans (`TraceInfo`, `Span`)**: `start_trace`,
+  `get_trace_info`, `batch_get_traces`, `log_spans`, `log_spans_async`,
+  `ingest_spans_out_of_order`, `search_traces`, `delete_traces`,
+  `set_trace_tag`, `delete_trace_tag`, `link_traces_to_run`,
+  `unlink_traces_from_run`, and `link_prompts_to_trace`. `IngestTraceSpans`
+  uses `init_or_mutate` across `Trace` and `TraceSpan` in one partition commit,
+  allowing child spans to arrive before parent/root spans and even before
+  `start_trace()` without foreign-key failures or read-time `FINAL` merges.
+- **Assessments (`Feedback` & `Expectation`)**: `create_assessment`,
+  `get_assessment`, `update_assessment`, and `delete_assessment`.
+- **Trace Metrics & Analytical Rollups (`query_trace_metrics`, `ADR-0315`)**:
+  backed by contract-declared scalar columnar projections (`TraceAnalytics`,
+  `SpanAnalytics`, `AssessmentAnalytics`) and event-driven rollups
+  (`SpanModelRollup` with `min`/`max`/`mean`/`sum`/`count` and `hour(...)`
+  temporal bucket keys) queried via `source projected` in `.riffq`.
+- **Logged Models (`LoggedModel`)**: `create_logged_model`, `get_logged_model`,
+  `delete_logged_model`, `finalize_logged_model`, `set_logged_model_tags`,
+  `delete_logged_model_tag`, `log_logged_model_params`, and
+  `search_logged_models`.
+
+The intended server configuration is:
+
+```bash
+mlflow server \
+  --backend-store-uri riffdb://mlflow-development \
+  --default-artifact-root s3://example/mlflow-artifacts
+```
+
+RiffDB TLS and credential material is supplied through protected environment
+configuration described in [DESIGN.md](DESIGN.md); it is never embedded in the
+tracking URI.
+
+Development and verification:
+
+```bash
+uv sync
+make check
+make conformance
+```
+
+
+## RiffDB compatibility CI
+
+This adapter owns its RiffDB compatibility checks. Pull requests compile the
+application sources and verify existing locks and generated artifacts against
+the full commit in `.github/riffdb-revision`. Scheduled checks use RiffDB
+`main`; manual dispatch accepts a full commit or `main`. Failures are reported
+here and do not block RiffDB itself. Framework conformance remains separate.
+
+To upgrade, update the pin, migrate sources as needed, review the result of
+`riffdb application lock --write`, and verify with `riffdb application check`.
+Commit the pin and migration together in this repository.

riffdb_mlflow-0.2.0/PLAN.md

@@ -0,0 +1,75 @@
+# Implementation plan
+
+## WP-001 — Repository and upstream surface
+
+Status: in progress.
+
+- Pin MLflow `3.15.1` and record its exact source revision.
+- Register the `riffdb` tracking-store URI scheme.
+- Lock the sixteen-method abstract surface and inventory the SQL-store tests.
+- Establish package, configuration, redaction, and stop boundaries.
+
+Exit: a clean wheel discovers the plugin and upstream surface drift fails CI.
+
+## WP-002 — Core contract and generated Python boundary
+
+Status: pending.
+
+- Model experiments, runs, metrics, latest metrics, parameters, tags, and
+  inputs with explicit bounds and indexes.
+- Compile every mutation as a named command and every read as a named query.
+- Declare application source V7 with only the Python generated surface.
+- Generate and check the exact manifest, V8 lock, and Python client.
+
+Exit: source/lock checks are exact and all core data paths are generated.
+
+## WP-003 — Experiments and runs
+
+Status: in progress. The base experiment and run lifecycle slice passes focused
+unit tests and disposable real-RiffDB loopback; upstream SQL-store parity and
+the remaining run-data operations are not yet complete.
+
+- Implement create/get/rename/delete/restore for experiments.
+- Implement create/get/update/delete/restore for runs.
+- Preserve unique-name, lifecycle, random numeric ID, timestamp, and
+  public-error semantics.
+- Add focused concurrency and retry tests over real loopback.
+
+## WP-004 — Batches and run data
+
+Status: pending.
+
+- Implement atomic `log_batch` for metrics, parameters, and tags.
+- Implement latest metric selection and paged metric history.
+- Implement experiment/run tags and dataset/model inputs.
+- Prove maximum legal batches, duplicate parameters, IEEE-754 edge cases, and
+  idempotent uncertainty recovery.
+
+## WP-005 — Search and pagination
+
+Status: in progress. Experiment search and lifecycle-aware run search use
+compiled queries and bounded cursor coalescing. Remaining run predicates and
+order families are still pending.
+
+- Inventory the MLflow experiment/run search grammar and order matrix.
+- Map accepted normalized shapes to finite bounded named queries.
+- Bind continuation tokens to operation, normalized filter, order, authority,
+  and underlying RiffDB cursor.
+- Prove pages without client filtering, sorting, or offset repair.
+
+## WP-006 — Upstream and real-driver conformance
+
+Status: pending.
+
+- Run the applicable upstream SQL tracking-store semantics against RiffDB.
+- Run an MLflow tracking server and public `MlflowClient` loopback suite.
+- Compare correctness and cold/warm timing with PostgreSQL.
+- Prove clean installation from an immutable local Python publication.
+
+## WP-007 — Optional MLflow domains and release readiness
+
+Status: deferred until the core tracking backend is green.
+
+- Materialize separate reviewed profiles for optional newer MLflow domains.
+- Add compatibility policy, CI, package provenance, and release metadata.
+- Do not publish publicly until explicitly authorized.

riffdb_mlflow-0.2.0/README.md

@@ -0,0 +1,67 @@
+# riffdb-mlflow
+
+`riffdb-mlflow` is a compiled RiffDB tracking-store plugin for MLflow. It is an
+out-of-tree integration: no MLflow-specific code or vocabulary belongs in the
+RiffDB repository.
+
+The project targets **MLflow 3.15.1** and implements the complete `AbstractStore`
+tracking, tracing, evaluation assessment, trace analytics, logged-model, and
+run-lineage surface:
+
+- **Experiments & Runs**: atomic experiment creation with tags, lifecycle and
+  tag updates, `exact`/`LIKE`/`ILIKE` experiment search, atomic run creation
+  with tags, run get/update/delete/restore, bounded atomic `log_batch`
+  (metrics, parameters, tags), `get_metric_history`, `log_inputs`, `log_outputs`,
+  and `record_logged_model`.
+- **Traces & Out-of-Order Spans (`TraceInfo`, `Span`)**: `start_trace`,
+  `get_trace_info`, `batch_get_traces`, `log_spans`, `log_spans_async`,
+  `ingest_spans_out_of_order`, `search_traces`, `delete_traces`,
+  `set_trace_tag`, `delete_trace_tag`, `link_traces_to_run`,
+  `unlink_traces_from_run`, and `link_prompts_to_trace`. `IngestTraceSpans`
+  uses `init_or_mutate` across `Trace` and `TraceSpan` in one partition commit,
+  allowing child spans to arrive before parent/root spans and even before
+  `start_trace()` without foreign-key failures or read-time `FINAL` merges.
+- **Assessments (`Feedback` & `Expectation`)**: `create_assessment`,
+  `get_assessment`, `update_assessment`, and `delete_assessment`.
+- **Trace Metrics & Analytical Rollups (`query_trace_metrics`, `ADR-0315`)**:
+  backed by contract-declared scalar columnar projections (`TraceAnalytics`,
+  `SpanAnalytics`, `AssessmentAnalytics`) and event-driven rollups
+  (`SpanModelRollup` with `min`/`max`/`mean`/`sum`/`count` and `hour(...)`
+  temporal bucket keys) queried via `source projected` in `.riffq`.
+- **Logged Models (`LoggedModel`)**: `create_logged_model`, `get_logged_model`,
+  `delete_logged_model`, `finalize_logged_model`, `set_logged_model_tags`,
+  `delete_logged_model_tag`, `log_logged_model_params`, and
+  `search_logged_models`.
+
+The intended server configuration is:
+
+```bash
+mlflow server \
+  --backend-store-uri riffdb://mlflow-development \
+  --default-artifact-root s3://example/mlflow-artifacts
+```
+
+RiffDB TLS and credential material is supplied through protected environment
+configuration described in [DESIGN.md](DESIGN.md); it is never embedded in the
+tracking URI.
+
+Development and verification:
+
+```bash
+uv sync
+make check
+make conformance
+```
+
+
+## RiffDB compatibility CI
+
+This adapter owns its RiffDB compatibility checks. Pull requests compile the
+application sources and verify existing locks and generated artifacts against
+the full commit in `.github/riffdb-revision`. Scheduled checks use RiffDB
+`main`; manual dispatch accepts a full commit or `main`. Failures are reported
+here and do not block RiffDB itself. Framework conformance remains separate.
+
+To upgrade, update the pin, migrate sources as needed, review the result of
+`riffdb application lock --write`, and verify with `riffdb application check`.
+Commit the pin and migration together in this repository.