#!/usr/bin/env python3
"""Thin entry point. The implementation is `llm_ingestion_okf.consume`.

It moved into the package on 2026-09-08 (O5), for the reason the module's own
docstring states: a generated consumption skill named this file by absolute
path, so the skill could not be moved, shared, or run without this clone at
that exact path. The command is now `okf consume`, on PATH after an install.

This file stays because the published reproduction blocks and the measurement
scripts under `docs/` name it, and a measurement whose command no longer runs
is a measurement nobody can repeat. `tests/test_okf_consume.py` imports it by
this name and is the contract for the pre-pass.

No logic here, deliberately: a second copy of the ranking or the cut is a
second thing that can be right while the shipped one is wrong.

**IF YOU IMPORT THIS FILE BY PATH** (`importlib.util.spec_from_file_location`),
read the module back out of `sys.modules[<name>]` after `exec_module`, or import
`llm_ingestion_okf.consume` directly: the last line of this file replaces the
REGISTRY entry, which is not the object a path importer holds.
"""

from __future__ import annotations

import sys
from pathlib import Path

sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "src"))

from llm_ingestion_okf import consume as _impl  # noqa: E402

if __name__ == "__main__":
    raise SystemExit(_impl.main())

# A PATH IMPORTER NEVER SEES THE LINE BELOW, so its names are copied here.
# `sys.modules[__name__] = _impl` replaces the REGISTRY entry; a caller using
# `importlib.util.spec_from_file_location` already holds the object
# `module_from_spec` made, and `exec_module` leaves that object with this
# file's own globals -- 3 public names against the packaged module's 76.
# Reported by `vegnormal-okf` after v0.7.0 and reproduced in
# `tests/test_okf_consume_shim.py` under two counting methods.
#
# THE DUNDER FILTER IS LOAD-BEARING. An unfiltered `vars(_impl)` overwrites
# `__name__` with `llm_ingestion_okf.consume`, and the next statement uses
# `__name__` as the `sys.modules` key -- the module would be aliased under the
# wrong one.
#
# This restores attribute ACCESS and NOT patch-through: a caller monkeypatching
# one of these copies patches a binding the implementation never reads. That is
# precisely why the alias below exists, and it is why the alias stays.
globals().update({k: v for k, v in vars(_impl).items() if not k.startswith("__")})

# ALIASED, not re-exported. `import okf_consume` must hand back the packaged module
# ITSELF: a re-export binds copies of the names into a second module object, so
# a caller patching one of them patches a binding the implementation never
# reads. Measured on the move: two tests that monkeypatch `okf_consume` went green
# again only under the alias. Guarded by the `__main__` branch above, because
# aliasing `sys.modules["__main__"]` would replace the running script.
sys.modules[__name__] = _impl