`24fda51`

feat(release): Homebrew-tap delivery; drop PyPI; v0.9.0 target

Authored by

espadonne 3 weeks ago

SHA: 24fda51638a9bb353101724282678deeefa0bd10
Parents: d9b8ce8
Tree: 3b1214d

7 changed files

Status	File	+	-
M	`.github/workflows/release.yml`	119	89
M	`CHANGELOG.md`	7	17
M	`CONTRIBUTING.md`	56	45
M	`README.md`	27	20
M	`pyproject.toml`	1	1
M	`src/dlm/export/vendoring.py`	81	31
M	`uv.lock`	1	1

.github/workflows/release.ymlmodified

  name: release
 -# Tag-driven release: push a `v*` tag, the workflow builds the wheel +
 -# sdist and publishes to PyPI via trusted-publisher OIDC (configure
 -# the publisher under the project's PyPI settings before the first
 -# real run). The docs site is deployed separately via `docs.yml`.
 +# Tag-driven release. We don't publish to PyPI — DLM ships via a
 +# Homebrew tap (https://github.com/tenseleyFlow/homebrew-tap).
+ #
 -# Dry-run to test.pypi.org by pushing a `v*-rc*` tag (e.g. `v1.0.0-rc1`).
 -# The publish step routes to the test index when the tag ends in `-rc*`.
 +# What this workflow does on a `v*` tag:
 +#
 +# 1. Gate on the full CI suite (ruff + format + mypy + non-slow pytest
 +#    + mkdocs strict build).
 +# 2. Build a "fat" source tarball that bundles `vendor/llama.cpp/`
 +#    (source only, no build artifacts) so the Homebrew formula can
 +#    drop the convert scripts into libexec without cloning submodules
 +#    at install time.
 +# 3. Create a GitHub release with the tarball + a computed sha256
 +#    pasted into the release notes so the tap formula can bump in one
 +#    edit.
 +# 4. Deploy the docs site to gh-pages.
  on:
    push:
        - "v*"
  permissions:
 -  # Required for trusted-publisher OIDC flow.
 -  id-token: write
 -  # Required so the workflow can read the repo on a tag push.
 -  contents: read
 +  contents: write      # create release + upload asset
 +  id-token: write      # gh-pages OIDC deploy
 +  pages: write
++
 +concurrency:
 +  group: release-${{ github.ref }}
 +  cancel-in-progress: false
  env:
    UV_VERSION: "0.11.6"
          run: uv run pytest -m "not slow and not online and not gpu"
        - name: Mkdocs build --strict
 -        # Audit-05 N14: block release on docs regressions (dead links,
 -        # missing files in nav, etc.) before the publish step so a broken
 -        # docs site can't ship alongside a real PyPI tag.
          run: uv run mkdocs build --strict --site-dir /tmp/mkdocs-check
 -  build:
 -    name: build wheel + sdist
 +  build-release-tarball:
 +    name: build fat source tarball
      needs: ci-gate
      runs-on: ubuntu-latest
 +    outputs:
 +      tarball_name: ${{ steps.build.outputs.tarball_name }}
 +      sha256: ${{ steps.build.outputs.sha256 }}
      steps:
 -      - uses: actions/checkout@v4
+-
 -      - name: Install uv
 -        uses: astral-sh/setup-uv@v4
 +      - name: Checkout with submodules
 +        uses: actions/checkout@v4
          with:
 -          version: ${{ env.UV_VERSION }}
+-
 -      - name: Build
 -        run: uv build
 +          submodules: recursive
 -      - name: Upload artifacts
 +      - name: Build tarball
 +        id: build
 +        run: |
 +          set -euxo pipefail
 +          TAG="${GITHUB_REF_NAME}"
 +          NAME="dlm-${TAG}"
 +          # Build the tarball with a top-level prefix matching NAME so
 +          # `tar xzf` extracts into a clean subdir (Homebrew convention).
 +          # Exclude CI noise + git metadata; KEEP `vendor/llama.cpp/` so
 +          # the formula can use the vendored Python convert scripts.
 +          tar czf "${NAME}.tar.gz" \
 +              --transform="s,^,${NAME}/," \
 +              --exclude=".git" \
 +              --exclude=".github" \
 +              --exclude=".pytest_cache" \
 +              --exclude=".mypy_cache" \
 +              --exclude=".ruff_cache" \
 +              --exclude="__pycache__" \
 +              --exclude="*.pyc" \
 +              --exclude="vendor/llama.cpp/.git" \
 +              --exclude="vendor/llama.cpp/build" \
 +              --exclude="vendor/llama.cpp/.cache" \
 +              --exclude="tests" \
 +              --exclude=".docs" \
 +              --exclude="site" \
 +              .
 +          SHA=$(sha256sum "${NAME}.tar.gz" | awk '{print $1}')
 +          echo "Tarball: ${NAME}.tar.gz (sha256=${SHA})"
 +          echo "tarball_name=${NAME}.tar.gz" >> "$GITHUB_OUTPUT"
 +          echo "sha256=${SHA}" >> "$GITHUB_OUTPUT"
++
 +      - name: Upload tarball artifact
          uses: actions/upload-artifact@v4
          with:
 -          name: dist
 -          path: dist/
+-
 -  classify-tag:
 -    # Audit-05 M8: route by `packaging.version.Version(tag).is_prerelease`
 -    # rather than `contains('-rc')`. The substring check breaks on PEP 440
 -    # canonical prereleases (e.g. `v1.0.0rc1` without the hyphen) — those
 -    # would silently publish to prod PyPI.
 -    name: classify tag as release vs prerelease
 -    needs: ci-gate
 +          name: release-tarball
 +          path: ${{ steps.build.outputs.tarball_name }}
++
 +  publish-github-release:
 +    name: publish GitHub release
 +    needs: build-release-tarball
      runs-on: ubuntu-latest
 -    outputs:
 -      is_prerelease: ${{ steps.classify.outputs.is_prerelease }}
      steps:
 -      - name: Derive is_prerelease via packaging.version
 -        id: classify
 +      - uses: actions/download-artifact@v4
 +        with:
 +          name: release-tarball
++
 +      - name: Create release
 +        env:
 +          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 +          TAG: ${{ github.ref_name }}
 +          TARBALL: ${{ needs.build-release-tarball.outputs.tarball_name }}
 +          SHA256: ${{ needs.build-release-tarball.outputs.sha256 }}
          run: |
 -          TAG="${GITHUB_REF_NAME}"
 -          # Strip leading 'v' if present; packaging accepts either form.
 -          VERSION="${TAG#v}"
 -          IS_PRE=$(python3 -c "import sys; from packaging.version import Version, InvalidVersion
 +          set -euxo pipefail
 +          # Route prerelease tags (PEP 440: rc / a / b / dev suffixes)
 +          # to GitHub "prerelease" flag — surfaces as the yellow banner
 +          # on the releases page instead of "latest".
 +          PRERELEASE_FLAG=""
 +          if python3 -c "
 +          import sys
 +          from packaging.version import Version, InvalidVersion
 +          tag='${TAG}'.lstrip('v')
            try:
 -              v = Version('${VERSION}')
 -              print('true' if v.is_prerelease else 'false')
 +              sys.exit(0 if Version(tag).is_prerelease else 1)
            except InvalidVersion:
 -              # Unparseable tags → treat as prerelease (safer default: routes
 -              # to test.pypi.org, where a bad tag can't stomp the real index).
 -              print('true')
 -          ")
 -          echo "Tag ${TAG} → is_prerelease=${IS_PRE}"
 -          echo "is_prerelease=${IS_PRE}" >> "$GITHUB_OUTPUT"
+-
 -  publish-testpypi:
 -    name: publish to test.pypi.org (prerelease tags only)
 -    needs: [build, classify-tag]
 -    if: needs.classify-tag.outputs.is_prerelease == 'true'
 -    runs-on: ubuntu-latest
 -    environment:
 -      name: test-pypi
 -      url: https://test.pypi.org/project/dlm/
 -    steps:
 -      - uses: actions/download-artifact@v4
 -        with:
 -          name: dist
 -          path: dist/
 +              sys.exit(0)
 +          "; then
 +            PRERELEASE_FLAG="--prerelease"
 +          fi
 -      - name: Publish
 -        uses: pypa/gh-action-pypi-publish@release/v1
 -        with:
 -          repository-url: https://test.pypi.org/legacy/
 +          cat > release-notes.md <<EOF
 +          ## DLM ${TAG}
 -  publish-pypi:
 -    name: publish to pypi.org (release tags)
 -    needs: [build, classify-tag]
 -    if: needs.classify-tag.outputs.is_prerelease == 'false'
 -    runs-on: ubuntu-latest
 -    environment:
 -      name: pypi
 -      url: https://pypi.org/project/dlm/
 -    steps:
 -      - uses: actions/download-artifact@v4
 -        with:
 -          name: dist
 -          path: dist/
 +          Install via the Homebrew tap:
++
 +          \`\`\`
 +          brew tap tenseleyFlow/tap
 +          brew install dlm
 +          \`\`\`
++
 +          ### Formula bump
++
 +          When bumping \`Formula/dlm.rb\` in \`tenseleyFlow/homebrew-tap\`:
++
 +          - \`url\` → https://github.com/tenseleyFlow/DocumentLanguageModel/releases/download/${TAG}/${TARBALL}
 +          - \`sha256\` → \`${SHA256}\`
++
 +          ### Build
++
 +          Full changelog: see \`CHANGELOG.md\` in the tarball.
 +          EOF
 -      - name: Publish
 -        uses: pypa/gh-action-pypi-publish@release/v1
 +          gh release create "${TAG}" \
 +              --repo "${GITHUB_REPOSITORY}" \
 +              --title "DLM ${TAG}" \
 +              --notes-file release-notes.md \
 +              ${PRERELEASE_FLAG} \
 +              "${TARBALL}"
    deploy-docs:
 -    name: deploy docs for release
 -    needs: publish-pypi
 +    name: deploy docs to gh-pages
 +    needs: publish-github-release
      runs-on: ubuntu-latest
 -    permissions:
 -      contents: read
 -      pages: write
 -      id-token: write
      environment:
        name: github-pages
        url: ${{ steps.deployment.outputs.page_url }}

CHANGELOG.mdmodified

  ## [Unreleased]
 -### Added
 +## [0.9.0] — target
 -- Sprint 16 (this entry) — MkDocs Material documentation site,
 -  starter templates under `templates/`, release and docs deployment
 -  workflows, `CHANGELOG.md` itself.
+-
 -### Pending v1.0
+-
 -- Manual verification of the README quickstart on a fresh Linux +
 -  macOS box.
 -- PyPI trusted-publisher configuration + dry-run to test.pypi.org
 -  before tagging v1.0.
+-
 -## [1.0.0] — target
+-
 -First stable release. Covers Phase 0–3 of the sprint roadmap
 -(scaffolding through MVP release).
 +First tagged release. Ships via the
 +[tenseleyFlow/homebrew-tap](https://github.com/tenseleyFlow/homebrew-tap)
 +(`brew tap tenseleyFlow/tap && brew install dlm`). Below v1.0 on
 +purpose — a human still needs to train + export + `ollama run` a real
 +document end-to-end before we claim the stable number.
  ### Highlights
 -- Full v1.0 CLI: `init`, `train`, `prompt`, `export`, `pack`,
 +- CLI: `init`, `train`, `prompt`, `export`, `pack`,
    `unpack`, `doctor`, `show`, `migrate`.
  - Content-addressed store at `~/.dlm/store/<dlm_id>/` with atomic
    manifest updates and exclusive locking.

CONTRIBUTING.mdmodified

  ## Releasing
 -Tag-driven: pushing a `v*` tag triggers `.github/workflows/release.yml`,
 -which runs the full CI gate, builds wheel + sdist via `uv build`, and
 -publishes to PyPI via trusted-publisher OIDC.
+-
 -### One-time PyPI trusted-publisher setup
+-
 -Before the first real release:
+-
 -1. Create a PyPI account for the `dlm` project (someone with publish
 -   rights has to own this).
 -2. Under project settings → **Publishing** → **Add a new pending
 -   publisher**, fill in:
 -   - Owner: `tenseleyFlow`
 -   - Repository name: `DocumentLanguageModel`
 -   - Workflow filename: `release.yml`
 -   - Environment name: `pypi`
 -3. Repeat on test.pypi.org with environment name `test-pypi`.
 -4. In the GitHub repo settings → **Environments**, create both
 -   `pypi` and `test-pypi` environments. Neither needs secrets; the
 -   OIDC token is minted per run.
+-
 -### Pre-flight
+-
 -The CI gate runs the full check suite (ruff, mypy, non-slow pytest,
 -`mkdocs build --strict`). Before tagging, eyeball these locally:
 +Tag-driven. Pushing `v*` triggers `.github/workflows/release.yml`,
 +which runs the full CI gate, builds a "fat" source tarball (includes
 +`vendor/llama.cpp/` so the Homebrew formula can drop the convert
 +scripts into libexec without cloning submodules), creates a GitHub
 +release with the tarball + computed sha256, and deploys the docs to
 +gh-pages.
++
 +We publish via our Homebrew tap —
 +[tenseleyFlow/homebrew-tap](https://github.com/tenseleyFlow/homebrew-tap).
 +**We do not publish to PyPI.** Rationale lives in the audit-05 /
 +release-mode discussion; the short version is: PyPI makes versions
 +permanent, requires us to maintain a ~5 GB transitive dep surface,
 +and signals "this is battle-tested" in a way we're not ready to back
 +yet.
++
 +### Conservative versioning
++
 +Stay below `v1.0.0` until a human has trained + exported +
 +`ollama run`'d an adapter end-to-end. That's the only contract v1.0
 +actually owes users. Current target: `v0.9.0` for the first tagged
 +release.
++
 +### Pre-flight (run locally before tagging)
  ```sh
  uv run ruff check .
  uv run mkdocs build --strict
  ```
 -Then bump the version in `pyproject.toml`, update `CHANGELOG.md`
 -(move the `## [Unreleased]` entries under a new `## [X.Y.Z]` heading),
 -and land both in the same commit.
 +Bump the version in `pyproject.toml`, move `## [Unreleased]` entries
 +under a new `## [X.Y.Z]` heading in `CHANGELOG.md`, and land both in
 +one commit.
  ### Tagging
 -`release.yml` classifies tags via `packaging.version.Version.is_prerelease`:
 +```sh
 +git tag v0.9.0
 +git push origin v0.9.0
 +```
 -- **Prerelease** (routes to `test.pypi.org`): any PEP 440 prerelease.
 -  Canonical: `v1.0.0rc1`, `v1.0.0a2`, `v1.0.0b3`. Hyphenated also
 -  works: `v1.0.0-rc1`.
 -- **Release** (routes to `pypi.org`): clean `vMAJOR.MINOR.PATCH`.
 +`release.yml` classifies the tag via
 +`packaging.version.Version.is_prerelease`:
 -```sh
 -# Dry-run via test.pypi.org first
 -git tag v1.0.0rc1
 -git push origin v1.0.0rc1
 +- **Prerelease** (`v0.9.0rc1`, `v0.9.0a1`, `v0.9.0-rc1`): GitHub
 +  release gets the `prerelease` flag so it doesn't show as "latest."
 +- **Release** (`v0.9.0`, `v0.9.1`): standard GitHub release.
++
 +### Bumping the Homebrew formula
++
 +After the release workflow finishes, it prints the fat-tarball sha256
 +in the release notes. Bump `Formula/dlm.rb` in the tap:
 -# Verify on https://test.pypi.org/project/dlm/, then:
 -git tag v1.0.0
 -git push origin v1.0.0
 +```ruby
 +url "https://github.com/tenseleyFlow/DocumentLanguageModel/releases/download/v0.9.0/dlm-v0.9.0.tar.gz"
 +sha256 "<copy from release notes>"
  ```
 -The release workflow publishes, then the `deploy-docs` job builds the
 -MkDocs site and pushes it to `gh-pages`.
 +Then:
++
 +```sh
 +cd ~/path/to/homebrew-tap
 +brew install --build-from-source ./Formula/dlm.rb   # local smoke
 +brew test ./Formula/dlm.rb                          # runs the `test do` block
 +git commit -am "dlm: bump to v0.9.0"
 +git push
 +```
  ### Rollback
 -There's no unpublish on PyPI (trusted-publisher or otherwise). If a
 -release is bad, bump the patch version and cut a fixed release rather
 -than trying to yank the old one.
 +Homebrew rollback is straightforward: delete the bad GitHub release
 +(or mark it draft), revert the formula bump in the tap. Users who
 +already installed the bad version can `brew uninstall dlm && brew
 +install dlm` to pick up the revert.
  Thanks again — reach out in issues if anything's unclear.

README.mdmodified

  + HuggingFace with a hardware-aware planner that picks precision,
  attention, and batching for your box.
 -**Status:** v1.0 release candidate. All Phase 3 sprints are complete;
 -the CLI surface (`init`, `train`, `prompt`, `export`, `pack`, `unpack`,
 -`doctor`, `show`, `migrate`) is wired end-to-end. A PyPI dry-run on
 -`test.pypi.org` is the last box to tick before the `v1.0` tag.
 +**Status:** pre-1.0 — the Phase 3 CLI surface (`init`, `train`,
 +`prompt`, `export`, `pack`, `unpack`, `doctor`, `show`, `migrate`) is
 +wired end-to-end but hasn't been battle-tested by a human running a
 +full train-export-ollama-run cycle. Ship target is `v0.9.0` via the
 +Homebrew tap below; `v1.0` waits on a real end-to-end train.
  ## Why
  ## Install
 -### From source (current)
 +### From the Homebrew tap (recommended)
  ```sh
 -# Python 3.11+ and uv (https://github.com/astral-sh/uv)
 -git clone https://github.com/tenseleyFlow/DocumentLanguageModel.git
 -cd DocumentLanguageModel
 -uv sync
 -uv run dlm --help
 +brew tap tenseleyFlow/tap
 +brew install dlm
++
 +# Ollama is required for `dlm export` smoke runs:
 +brew install ollama
  ```
 -### From PyPI (v1.0 target)
 +`brew install dlm` pulls in a vendored `llama.cpp` source tree for
 +GGUF conversion and declares `depends_on "llama.cpp"` for the
 +compiled `llama-quantize` / `llama-imatrix` binaries. On NVIDIA
 +hardware, unlock QLoRA 4-bit after install:
  ```sh
 -# Portable install — torch, transformers, peft, trl, datasets included.
 -pip install dlm
+-
 -# Add the CUDA extra for QLoRA 4-bit on Ampere+.
 -pip install "dlm[cuda]"
 +$(brew --prefix dlm)/libexec/venv/bin/pip install 'dlm[cuda]'
  ```
 -For export: install [Ollama](https://ollama.com/) separately — minimum
 -version is pinned in the CLI; `dlm doctor` reports it. For GGUF
 -conversion, the repo vendors `llama.cpp` as a submodule; one-time
 -build:
 +### From source (contributors)
  ```sh
 +# Python 3.11+ and uv (https://github.com/astral-sh/uv).
 +git clone https://github.com/tenseleyFlow/DocumentLanguageModel.git
 +cd DocumentLanguageModel
 +uv sync
 +# One-time: build the vendored llama.cpp binaries for `dlm export`.
  scripts/bump-llama-cpp.sh build
 +uv run dlm --help
  ```
 +We deliberately don't publish to PyPI — too easy to ship unfinished
 +work to a permanent-file-archive with 5 GB of transitive deps. See
 +[CONTRIBUTING.md](./CONTRIBUTING.md) for the release flow.
++
  ## First run
  ```sh

pyproject.tomlmodified

  [project]
  name = "dlm"
 -version = "0.1.0"
 +version = "0.9.0"
  description = "A text file with a .dlm extension becomes a local, trainable LLM."
  readme = "README.md"
  requires-python = ">=3.11"

src/dlm/export/vendoring.pymodified

  - `llama-quantize` — compiled binary (built by cmake). Converts an
    fp16 GGUF into one of the quant levels.
 +Lookup order for the llama.cpp source tree (convert scripts):
++
 +1. `DLM_LLAMA_CPP_ROOT` env var — set by the Homebrew formula so
 +   `brew install dlm` points at `libexec/vendor/llama.cpp/` without
 +   needing an in-tree submodule.
 +2. `vendor/llama.cpp/` relative to the repo root — dev path.
++
 +Binary lookup falls through to `shutil.which()` when the vendored
 +`build/bin/` isn't present, so `brew install llama.cpp`'s
 +`/opt/homebrew/bin/llama-quantize` satisfies the resolver on brew
 +installs.
++
  Missing or unbuilt artifacts raise `VendoringError` with a remediation
 -pointing at `scripts/bump-llama-cpp.sh`. The runner catches + reworks
 -the message for the CLI; test code can catch the bare typed error.
 +pointing at `scripts/bump-llama-cpp.sh` (source install) or
 +`brew install llama.cpp` (brew install). The runner catches + reworks
 +the message for the CLI.
  """
  from __future__ import annotations
 +import os
 +import shutil
  from pathlib import Path
  from typing import Final
  _REPO_ROOT: Final[Path] = Path(__file__).resolve().parents[3]
  VENDOR_LLAMA_CPP: Final[Path] = _REPO_ROOT / "vendor" / "llama.cpp"
 +_ENV_VAR: Final[str] = "DLM_LLAMA_CPP_ROOT"
  CONVERT_HF_TO_GGUF: Final[str] = "convert_hf_to_gguf.py"
  CONVERT_LORA_TO_GGUF: Final[str] = "convert_lora_to_gguf.py"
  def llama_cpp_root(override: Path | None = None) -> Path:
 -    """Return the path to the vendored `llama.cpp` clone.
 +    """Return the path to the llama.cpp source tree.
++
 +    Resolution order:
++
 +    1. `override` kwarg (test hook; production code never passes it).
 +    2. `$DLM_LLAMA_CPP_ROOT` env var (set by the Homebrew formula).
 +    3. `vendor/llama.cpp/` at the repo root (source / dev install).
 -    `override` is a test hook — production code never passes it.
 -    Raises `VendoringError` if the directory is missing OR is empty
 -    (an uninitialized submodule).
 +    Raises `VendoringError` if none of those resolve to a non-empty
 +    directory.
      """
 -    root = override or VENDOR_LLAMA_CPP
 +    if override is not None:
 +        root = override
 +    elif env_override := os.environ.get(_ENV_VAR):
 +        root = Path(env_override)
 +    else:
 +        root = VENDOR_LLAMA_CPP
      if not root.is_dir():
          raise VendoringError(
 -            f"vendor/llama.cpp is missing at {root}. "
 -            "Run `git submodule update --init --recursive` and then "
 -            "`scripts/bump-llama-cpp.sh build` to materialize the toolchain."
 +            f"llama.cpp source tree missing at {root}. For source installs, "
 +            "run `git submodule update --init --recursive` and then "
 +            "`scripts/bump-llama-cpp.sh build`. For brew installs, "
 +            f"ensure the {_ENV_VAR} env var points at a populated tree "
 +            "(normally handled by the dlm formula)."
+         )
      # An empty dir (uninitialized submodule) is the most common failure.
      try:
          raise VendoringError(f"cannot enumerate {root}: {exc}") from exc
      if any_entry is None:
          raise VendoringError(
 -            f"vendor/llama.cpp is empty at {root}. Run `git submodule update --init --recursive`."
 +            f"llama.cpp source tree is empty at {root}. "
 +            "Run `git submodule update --init --recursive` (source install) "
 +            f"or unset {_ENV_VAR} and reinstall the dlm formula."
+         )
      return root
      return _resolve_script(CONVERT_LORA_TO_GGUF, override)
 -def llama_quantize_bin(override: Path | None = None) -> Path:
 -    """Path to the `llama-quantize` binary.
 +def _resolve_binary(
 +    *,
 +    name: str,
 +    candidates: tuple[str, ...],
 +    override: Path | None,
 +) -> Path:
 +    """Find a llama.cpp binary, preferring the vendored build tree then $PATH.
 -    Checks several known build-layout locations since llama.cpp's
 -    build output has moved between releases. If none of the
 -    candidates exist, `VendoringError` points at the bump script's
 -    build step.
 +    When `override` is None and the env/vendor tree lacks a compiled
 +    binary, fall back to `shutil.which(name)` — covers the common
 +    `brew install llama.cpp` case where the binary lives under
 +    `/opt/homebrew/bin/`.
      """
      root = llama_cpp_root(override)
 -    for candidate in _LLAMA_QUANTIZE_CANDIDATES:
 +    for candidate in candidates:
          path = root / candidate
          if path.is_file():
              return path
 +    # Fall through to PATH lookup (brew-installed llama.cpp).
 +    on_path = shutil.which(name)
 +    if on_path is not None:
 +        return Path(on_path)
      raise VendoringError(
 -        f"llama-quantize binary not found under {root}. "
 -        "Run `scripts/bump-llama-cpp.sh build` to compile it."
 +        f"{name} binary not found under {root} and not on $PATH. For "
 +        "source installs, run `scripts/bump-llama-cpp.sh build`. For "
 +        "brew installs, `brew install llama.cpp`."
 +    )
++
++
 +def llama_quantize_bin(override: Path | None = None) -> Path:
 +    """Path to the `llama-quantize` binary.
++
 +    Checks several known build-layout locations, then falls back to
 +    `$PATH` — covers both the vendored `build/bin/llama-quantize`
 +    (source install) and the brew `/opt/homebrew/bin/llama-quantize`
 +    (brew install with `depends_on "llama.cpp"`).
 +    """
 +    return _resolve_binary(
 +        name="llama-quantize",
 +        candidates=_LLAMA_QUANTIZE_CANDIDATES,
 +        override=override,
+     )
  def llama_imatrix_bin(override: Path | None = None) -> Path:
      """Path to the `llama-imatrix` binary (Sprint 11.6).
 -    Same resolver shape as `llama_quantize_bin` — checks several known
 -    build-layout locations. `VendoringError` with the bump-script
 -    pointer if the binary is absent.
 +    Same resolver shape as `llama_quantize_bin` — checks vendored
 +    build layouts, then `$PATH`.
      """
 -    root = llama_cpp_root(override)
 -    for candidate in _LLAMA_IMATRIX_CANDIDATES:
 -        path = root / candidate
 -        if path.is_file():
 -            return path
 -    raise VendoringError(
 -        f"llama-imatrix binary not found under {root}. "
 -        "Run `scripts/bump-llama-cpp.sh build` to compile it."
 +    return _resolve_binary(
 +        name="llama-imatrix",
 +        candidates=_LLAMA_IMATRIX_CANDIDATES,
 +        override=override,
+     )

uv.lockmodified

  [[package]]
  name = "dlm"
 -version = "0.1.0"
 +version = "0.9.0"
  source = { editable = "." }
  dependencies = [
      { name = "cbor2" },