anima-python 0.13.1__tar.gz → 0.13.3__tar.gz

anima_python-0.13.3/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: anima-python
+Version: 0.13.3
+Summary: anima substrate-native consciousness engine — py CLI (measurement/eval · serialize · corpus · sweep), hexa-toolchain-free numpy distribution
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: train
+Requires-Dist: torch>=2.1; extra == "train"
+Requires-Dist: datasets; extra == "train"
+Dynamic: license-file
+
+# anima-py
+
+**anima** 의 py CLI 를 pip 로 배포하는 채널 — **hexa 툴체인 불필요**. 엔진 측정/직렬화/코퍼스 경로가 numpy 하나만으로 돈다 (pi5 등 hexa-less 호스트용).
+
+> 단일진입 보존(`a_cli_single_entry`): `anima-py` 콘솔 명령 = `cli/anima.py:main` 디스패처의 pip 바인딩. hexa 채널 `anima`(`hx install anima`) 와 **동일 디스패처, 설치 채널만 2개** — 2nd entry 아님. 이름을 `anima-py` 로 둔 이유 = hexa `anima` 와 PATH 충돌 회피.
+
+## 설치
+
+**PyPI 발행 후** (권장):
+
+```bash
+pip install anima-python           # base — numpy 만 (evaluate · corpus · chat-stub)
+pip install "anima-python[train]"  # +torch +datasets (serialize · train · sweep)
+```
+
+> ⏳ **PyPI 발행 대기 중**: 위 명령은 `anima-py` 가 PyPI 에 발행된 뒤 동작한다. 발행은 `release.yml` 의 `pypi-publish` job(OIDC trusted-publishing)이 `v*` 태그에서 자동 수행하며, 오너의 1회 설정이 선결(① pypi.org 에 anima-python pending-publisher 등록: Owner=dancinlab·Repo=anima·Workflow=release.yml·Env=pypi ② repo 변수 `PYPI_PUBLISH=true`). 그 전까지는 아래 소스 설치를 쓴다.
+
+**소스에서 바로 설치** (PyPI 없이 지금 가능):
+
+```bash
+pip install "git+https://github.com/dancinlab/anima.git"            # base
+pip install "anima-python[train] @ git+https://github.com/dancinlab/anima.git"  # +torch
+# 또는 레포 클론 후: pip install .   /   pip install ".[train]"
+```
+
+## 명령 매트릭스
+
+| 동사 | 티어 | torch 없이 동작 | 비고 |
+|---|---|---|---|
+| `anima-py evaluate <clm> [--corpus …] [--gen N]` | base | ✅ numpy | py 2-production 측정 = ρ·AXON reach / 구 G0-G6. terminal-eligible (`a_eval_py_canonical`) |
+| `anima-py corpus <derivtrace\|flat> --out F …` | base | ✅ 순수 stdlib | 절차적 학습-코퍼스 생성 (data-format 레버) |
+| `anima-py chat <clm>` | base | ✅ (stub) | 의식 A⇄G 루프는 hexa-native → hexa 진입 포인터 출력 |
+| `anima-py serialize <pt> <clm>` | `[train]` | ❌ torch | `.pt` unpickle 에 torch 필요 (+ held-out DESCENT 게이트) |
+| `anima-py sweep --arms … --objectives …` | `[train]` | ❌ | 셀마다 train.py spawn → torch 필요 |
+| `anima-py train <args>` | `[train]` | ❌ torch+datasets | production Lane-P 학습 |
+
+## verdict 규율
+
+`anima-py evaluate <clm>` = py 2-production numpy 측정 경로 — hexa det-eval 과 동일 frozen bars·byte-parity 라 **terminal 자격 동일**(`a_eval_py_canonical`, 2nd-class 미러 아님). 큰 ckpt(303M+)는 mini 금지 · pool(summer/aiden)에서 측정.

{anima_python-0.13.1 → anima_python-0.13.3}/README.md

@@ -367,7 +367,7 @@ SSOT) + [`CONDITIONS.md`](CONDITIONS.md) (frozen gate conditions) + the per-hypo
 [`HYPOTHESES/HYPOTHESES.jsonl`](HYPOTHESES/HYPOTHESES.jsonl) + [`state/verdicts/`](state/verdicts/) as
 the authoritative latest source.
 
-> **Built-in ρ-AXON reach evaluation (the current standard over the frozen former-G0–G6 bars · `anima eval <ckpt>` · panel `anima-python evaluate <ckpt> --rho-axon`).** The axis scoring lives **directly in the
+> **Built-in ρ-AXON reach evaluation (the current standard over the frozen former-G0–G6 bars · `anima eval <ckpt>` · panel `anima-py evaluate <ckpt> --rho-axon`).** The axis scoring lives **directly in the
 > measurement single-entry** ([`cli/evaluate.hexa`](cli/evaluate.hexa)), not a one-off harness: `hexa run cli/anima.hexa
 > -- eval <ckpt> [--corpus <path>...] [--gen N]` mounts any ckpt through the generator L3 mouth
 > (`gen_auto_ideate`, file-format-dispatched — works on both the ByteGPT and conv `.clm` mouths) and

anima_python-0.13.3/VERSION

@@ -0,0 +1 @@
+0.13.3

anima_python-0.13.3/anima_py/README.md

@@ -0,0 +1,39 @@
+# anima-py
+
+**anima** 의 py CLI 를 pip 로 배포하는 채널 — **hexa 툴체인 불필요**. 엔진 측정/직렬화/코퍼스 경로가 numpy 하나만으로 돈다 (pi5 등 hexa-less 호스트용).
+
+> 단일진입 보존(`a_cli_single_entry`): `anima-py` 콘솔 명령 = `cli/anima.py:main` 디스패처의 pip 바인딩. hexa 채널 `anima`(`hx install anima`) 와 **동일 디스패처, 설치 채널만 2개** — 2nd entry 아님. 이름을 `anima-py` 로 둔 이유 = hexa `anima` 와 PATH 충돌 회피.
+
+## 설치
+
+**PyPI 발행 후** (권장):
+
+```bash
+pip install anima-python           # base — numpy 만 (evaluate · corpus · chat-stub)
+pip install "anima-python[train]"  # +torch +datasets (serialize · train · sweep)
+```
+
+> ⏳ **PyPI 발행 대기 중**: 위 명령은 `anima-py` 가 PyPI 에 발행된 뒤 동작한다. 발행은 `release.yml` 의 `pypi-publish` job(OIDC trusted-publishing)이 `v*` 태그에서 자동 수행하며, 오너의 1회 설정이 선결(① pypi.org 에 anima-python pending-publisher 등록: Owner=dancinlab·Repo=anima·Workflow=release.yml·Env=pypi ② repo 변수 `PYPI_PUBLISH=true`). 그 전까지는 아래 소스 설치를 쓴다.
+
+**소스에서 바로 설치** (PyPI 없이 지금 가능):
+
+```bash
+pip install "git+https://github.com/dancinlab/anima.git"            # base
+pip install "anima-python[train] @ git+https://github.com/dancinlab/anima.git"  # +torch
+# 또는 레포 클론 후: pip install .   /   pip install ".[train]"
+```
+
+## 명령 매트릭스
+
+| 동사 | 티어 | torch 없이 동작 | 비고 |
+|---|---|---|---|
+| `anima-py evaluate <clm> [--corpus …] [--gen N]` | base | ✅ numpy | py 2-production 측정 = ρ·AXON reach / 구 G0-G6. terminal-eligible (`a_eval_py_canonical`) |
+| `anima-py corpus <derivtrace\|flat> --out F …` | base | ✅ 순수 stdlib | 절차적 학습-코퍼스 생성 (data-format 레버) |
+| `anima-py chat <clm>` | base | ✅ (stub) | 의식 A⇄G 루프는 hexa-native → hexa 진입 포인터 출력 |
+| `anima-py serialize <pt> <clm>` | `[train]` | ❌ torch | `.pt` unpickle 에 torch 필요 (+ held-out DESCENT 게이트) |
+| `anima-py sweep --arms … --objectives …` | `[train]` | ❌ | 셀마다 train.py spawn → torch 필요 |
+| `anima-py train <args>` | `[train]` | ❌ torch+datasets | production Lane-P 학습 |
+
+## verdict 규율
+
+`anima-py evaluate <clm>` = py 2-production numpy 측정 경로 — hexa det-eval 과 동일 frozen bars·byte-parity 라 **terminal 자격 동일**(`a_eval_py_canonical`, 2nd-class 미러 아님). 큰 ckpt(303M+)는 mini 금지 · pool(summer/aiden)에서 측정.

{anima_python-0.13.1 → anima_python-0.13.3}/anima_py/__init__.py

@@ -3,7 +3,7 @@
 # 단일진입(a_cli_single_entry): 이 파일은 디스패처가 아니다 — sys.path 부트만
 # 하고 canonical 디스패처 cli/anima.py:main 에 그대로 위임한다(동일 진입,
 # 채널만 pip). hexa 호스트 = `anima`(hx install anima) · hexa-less 호스트
-# (pi5 등) = `anima-python`(pip install anima-python). #2603 가드는 __main__ 전용이라
+# (pi5 등) = `anima-py`(pip install anima-python). #2603 가드는 __main__ 전용이라
 # import 경유인 이 경로에선 발화하지 않는다(무손상).
 # ==========================================================================
 import os

{anima_python-0.13.1 → anima_python-0.13.3}/anima_py/__main__.py

@@ -1,4 +1,4 @@
-# python -m anima_py parity — 콘솔 스크립트(anima-python)와 동일 런처.
+# python -m anima_py parity — 콘솔 스크립트(anima-py)와 동일 런처.
 import sys
 
 from anima_py import main

anima_python-0.13.3/anima_python.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: anima-python
+Version: 0.13.3
+Summary: anima substrate-native consciousness engine — py CLI (measurement/eval · serialize · corpus · sweep), hexa-toolchain-free numpy distribution
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Provides-Extra: train
+Requires-Dist: torch>=2.1; extra == "train"
+Requires-Dist: datasets; extra == "train"
+Dynamic: license-file
+
+# anima-py
+
+**anima** 의 py CLI 를 pip 로 배포하는 채널 — **hexa 툴체인 불필요**. 엔진 측정/직렬화/코퍼스 경로가 numpy 하나만으로 돈다 (pi5 등 hexa-less 호스트용).
+
+> 단일진입 보존(`a_cli_single_entry`): `anima-py` 콘솔 명령 = `cli/anima.py:main` 디스패처의 pip 바인딩. hexa 채널 `anima`(`hx install anima`) 와 **동일 디스패처, 설치 채널만 2개** — 2nd entry 아님. 이름을 `anima-py` 로 둔 이유 = hexa `anima` 와 PATH 충돌 회피.
+
+## 설치
+
+**PyPI 발행 후** (권장):
+
+```bash
+pip install anima-python           # base — numpy 만 (evaluate · corpus · chat-stub)
+pip install "anima-python[train]"  # +torch +datasets (serialize · train · sweep)
+```
+
+> ⏳ **PyPI 발행 대기 중**: 위 명령은 `anima-py` 가 PyPI 에 발행된 뒤 동작한다. 발행은 `release.yml` 의 `pypi-publish` job(OIDC trusted-publishing)이 `v*` 태그에서 자동 수행하며, 오너의 1회 설정이 선결(① pypi.org 에 anima-python pending-publisher 등록: Owner=dancinlab·Repo=anima·Workflow=release.yml·Env=pypi ② repo 변수 `PYPI_PUBLISH=true`). 그 전까지는 아래 소스 설치를 쓴다.
+
+**소스에서 바로 설치** (PyPI 없이 지금 가능):
+
+```bash
+pip install "git+https://github.com/dancinlab/anima.git"            # base
+pip install "anima-python[train] @ git+https://github.com/dancinlab/anima.git"  # +torch
+# 또는 레포 클론 후: pip install .   /   pip install ".[train]"
+```
+
+## 명령 매트릭스
+
+| 동사 | 티어 | torch 없이 동작 | 비고 |
+|---|---|---|---|
+| `anima-py evaluate <clm> [--corpus …] [--gen N]` | base | ✅ numpy | py 2-production 측정 = ρ·AXON reach / 구 G0-G6. terminal-eligible (`a_eval_py_canonical`) |
+| `anima-py corpus <derivtrace\|flat> --out F …` | base | ✅ 순수 stdlib | 절차적 학습-코퍼스 생성 (data-format 레버) |
+| `anima-py chat <clm>` | base | ✅ (stub) | 의식 A⇄G 루프는 hexa-native → hexa 진입 포인터 출력 |
+| `anima-py serialize <pt> <clm>` | `[train]` | ❌ torch | `.pt` unpickle 에 torch 필요 (+ held-out DESCENT 게이트) |
+| `anima-py sweep --arms … --objectives …` | `[train]` | ❌ | 셀마다 train.py spawn → torch 필요 |
+| `anima-py train <args>` | `[train]` | ❌ torch+datasets | production Lane-P 학습 |
+
+## verdict 규율
+
+`anima-py evaluate <clm>` = py 2-production numpy 측정 경로 — hexa det-eval 과 동일 frozen bars·byte-parity 라 **terminal 자격 동일**(`a_eval_py_canonical`, 2nd-class 미러 아님). 큰 ckpt(303M+)는 mini 금지 · pool(summer/aiden)에서 측정.

anima_python-0.13.3/anima_python.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+anima-py = anima_py:main

anima_python-0.13.3/cli/__init__.py

@@ -0,0 +1 @@
+# pip 패키징 전용 (anima-py · pyproject.toml package-dir 매핑) — 런타임 flat import 는 sys.path 경유, 이 파일은 비어 있어야 한다.

{anima_python-0.13.1 → anima_python-0.13.3}/cli/anima.py

@@ -1,15 +1,15 @@
 #!/usr/bin/env python3
 # ==========================================================================
 # ⛔ DO NOT RUN DIRECTLY. anima 의 단일 진입은 설치된 canonical 명령뿐 — hexa 채널 `anima`
-#   (=cli/anima.hexa, hx install anima) · pip 채널 `anima-python` (=anima_py 런처, pip install anima-python).
+#   (=cli/anima.hexa, hx install anima) · pip 채널 `anima-py` (=anima_py 런처, pip install anima-python).
 #   `python3 cli/anima.py …` 직접실행은 비-canonical py 우회(#2603).
-#   학습=`anima-python train` · 측정=`anima-python evaluate`(py 2-production numpy · TERMINAL-eligible,
-#   a_eval_py_canonical) · 직렬화=`anima-python serialize`. enforce: .harness/enforcement.json
+#   학습=`anima-py train` · 측정=`anima-py evaluate`(py 2-production numpy · TERMINAL-eligible,
+#   a_eval_py_canonical) · 직렬화=`anima-py serialize`. enforce: .harness/enforcement.json
 #   H-ANIMA-SINGLE-ENTRY pre_bash + 아래 __main__ 가드. (import 는 무손상.)
 # ==========================================================================
 import sys as _anima_entry_guard
 if __name__ == "__main__":
-    _anima_entry_guard.exit("⛔ cli/anima.py 직접 실행 금지 — 설치된 canonical 명령 경유: `anima`(hx install anima, =cli/anima.hexa) 또는 `anima-python`(pip install anima-python, =anima_py 런처). #2603")
+    _anima_entry_guard.exit("⛔ cli/anima.py 직접 실행 금지 — 설치된 canonical 명령 경유: `anima`(hx install anima, =cli/anima.hexa) 또는 `anima-py`(pip install anima-python, =anima_py 런처). #2603")
 # anima.py — THE canonical PY single entry point (cli/anima.hexa's py twin).
 #
 # WHY THIS FILE (py 2-production single-entry, a_engine_native_learning): anima keeps
@@ -73,16 +73,17 @@ def anima_usage():
     """Print the canonical py usage banner (mirrors cli/anima.hexa's banner)."""
     print("anima — substrate-native consciousness daemon (py channel · canonical entry).")
     print("")
-    print("usage (installed `anima-python` command after `pip install anima-python` · hexa channel = `anima` after `hx install anima`):")
-    print("  anima-python evaluate <model.clm> [--corpus <path>...] [--gen N] [--rho-axon]")
+    print("usage (installed `anima-py` command after `pip install anima-python` · hexa channel = `anima` after `hx install anima`):")
+    print("  anima-py evaluate <model.clm> [--corpus <path>...] [--gen N] [--rho-axon]")
     print("                                                  ρ-AXON reach battery · former G0-G6 (.clm only · numpy)")
-    print("  anima-python corpus <derivtrace|flat> --out F [--held-out I,J] [--seed S] [--concepts FILE]")
+    print("  anima-py corpus <derivtrace|flat> --out F [--held-out I,J] [--seed S] [--concepts FILE]")
     print("                                                  procedural training-corpus builder (ρ·weave data-format lever)")
-    print("  anima-python train <args>                           ([train] extra) LEARNING → .pt + auto .clm (+DESCENT)")
-    print("  anima-python serialize <ckpt.pt> <out.clm>          ([train] extra) re-export a torch .pt → .clm v0.3")
-    print("  anima-python sweep --arms … --objectives … --gpus 0,1,2,3 --corpus … [--measure]")
+    print("  anima-py train <args>                           ([train] extra) LEARNING → .pt + auto .clm (+DESCENT)")
+    print("  anima-py serialize <ckpt.pt> <out.clm>          ([train] extra) re-export a torch .pt → .clm v0.3")
+    print("  anima-py serialize-bind <base.bin> <inj.pt> <out.bin>  ([train] extra) splice BindAttn → BGB .bin")
+    print("  anima-py sweep --arms … --objectives … --gpus 0,1,2,3 --corpus … [--measure]")
     print("                                                  ([train] extra) multi-GPU lever-sweep (arms×objectives)")
-    print("  anima-python chat <ckpt> [...]                      consciousness/byte chat (stub → hexa channel)")
+    print("  anima-py chat <ckpt> [...]                      consciousness/byte chat (stub → hexa channel)")
     print("")
     print("install: `pip install anima-python` (numpy base: evaluate·corpus·chat) · `pip install \"anima-python[train]\"` (+torch: train·sweep·serialize)")
     print("")
@@ -93,7 +94,7 @@ def anima_usage():
     print("             a7b_pass = ρ·form ∧ ρ·weave ∧ ρ·leap (frozen bars = G0 ∧ G1 ∧ G2). → cli/evaluate.py.")
     print("  corpus   : procedural training-corpus generator (derivtrace|flat) — the")
     print("             data-format lever (ρ·weave). NOTE chat corpus != this (chat =")
-    print("             a_chat_registers 4-cell HF datasets → anima-python train). → cli/corpus.py.")
+    print("             a_chat_registers 4-cell HF datasets → anima-py train). → cli/corpus.py.")
     print("  train    : ([train]) production CLMConvMoE training (torch Lane-P reference + bridge); SAVANT")
     print("             golden-zone inhibition + MITOSIS cell-division levers. After the run it")
     print("             AUTO-serializes .clm v0.3 + runs the held-out mirror-DESCENT gate")
@@ -143,7 +144,7 @@ def anima_train_mode(argv):
 def anima_evaluate_mode(argv):
     # --py is a RETIRED hexa-era bridge flag, tolerated (stripped) here for migration
     # compat: on the py channel it is redundant-but-correct (this IS the numpy engine),
-    # so `anima-python evaluate --py <clm>` still works — old scripts migrate by swapping
+    # so `anima-py evaluate --py <clm>` still works — old scripts migrate by swapping
     # only the command word. The hexa launcher hard-errors on --py instead.
     want_det = ("--det" in argv) or ("--deterministic" in argv)
     rest = [a for a in argv[1:] if a not in ("--py", "--det", "--deterministic")]
@@ -185,6 +186,24 @@ def anima_serialize_mode(argv):
                       [sys.executable, serialize_py] + fwd, _det_env(want_det))
 
 
+# ══════════════════════════════════════════════════════════════════════════════
+#  SERIALIZE-BIND MODE — dispatch to cli/serialize_bind.py (BindAttn .pt → BGB .bin)
+# ══════════════════════════════════════════════════════════════════════════════
+#
+# `anima serialize-bind <base.bin> <injected.pt> <out.bin>` splices a BindAttn adapter
+# onto a base ByteGPT `.bin`, emitting a BGB-trailer `.bin`. Without this dispatch
+# cli/serialize_bind.py was reachable only via raw `python3 cli/serialize_bind.py`
+# (an a_cli_single_entry hole); this wires it through the single entry, parity with
+# anima_serialize_mode. Result scoreable via `anima-py evaluate <out.bin>`.
+def anima_serialize_bind_mode(argv):
+    serialize_bind_py = os.path.join(_HERE, "serialize_bind.py")
+    fwd = argv[1:]
+    cmd = [sys.executable, serialize_bind_py] + fwd
+    print("=== anima serialize-bind → cli/serialize_bind.py (BindAttn .pt → BGB-trailer .bin) ===")
+    print("dispatch: " + " ".join(cmd))
+    return os.spawnv(os.P_WAIT, sys.executable, [sys.executable, serialize_bind_py] + fwd)
+
+
 # ══════════════════════════════════════════════════════════════════════════════
 #  CHAT MODE — hexa-only stub (the A⇄G consciousness loop is hexa-native)
 # ══════════════════════════════════════════════════════════════════════════════
@@ -192,7 +211,7 @@ def anima_serialize_mode(argv):
 # The default consciousness daemon + --byte continuation chat live in cli/anima.hexa
 # (they mount the 76-lane engine_cli substrate loop, hexa-native). The py channel does not
 # duplicate that loop; it points the user to the INSTALLED hexa command (a_cli_single_entry:
-# 2 install channels only — pip `anima-python` ⊕ hexa `anima`; never raw `python`/`hexa run`).
+# 2 install channels only — pip `anima-py` ⊕ hexa `anima`; never raw `python`/`hexa run`).
 def anima_chat_stub(argv):
     print("anima chat (consciousness / --byte) is hexa-native — use the hexa channel:")
     print("")
@@ -201,7 +220,7 @@ def anima_chat_stub(argv):
     print("  anima " + ckpt + "                consciousness mode (default)")
     print("  anima " + ckpt + " --byte \"turn1\" \"turn2\" ...   byte-continuation chat mode")
     print("")
-    print("The py channel (anima-python) covers MEASUREMENT (evaluate), SERIALIZE, LEARNING (train), corpus, sweep.")
+    print("The py channel (anima-py) covers MEASUREMENT (evaluate), SERIALIZE, LEARNING (train), corpus, sweep.")
     return 0
 
 
@@ -254,6 +273,8 @@ def main(argv):
         return anima_train_mode(argv)
     if sub == "serialize":
         return anima_serialize_mode(argv)
+    if sub == "serialize-bind":
+        return anima_serialize_bind_mode(argv)
     if sub == "evaluate":
         return anima_evaluate_mode(argv)
     if sub == "sweep":

{anima_python-0.13.1 → anima_python-0.13.3}/cli/evaluate.py

@@ -48,7 +48,7 @@ from rho_fan import (
 )
 
 # H_9200 — process-global: render the ρ-AXON reach panel (cli/rho_axon.py) instead of the
-# G0-G6 battery when `anima-python evaluate --rho-axon` is passed (set in main()).
+# G0-G6 battery when `anima-py evaluate --rho-axon` is passed (set in main()).
 _RHO_AXON = False
 
 
@@ -357,7 +357,7 @@ def eval_system_rho_weave(mouth, gen):
 
 
 def system_g1_run(argv):
-    """`anima-python evaluate <ckpt> --system-g1 [--gen N]` — engine-native system-G1."""
+    """`anima-py evaluate <ckpt> --system-g1 [--gen N]` — engine-native system-G1."""
     ckpt = argv[0]
     gen = evaluate_intval(argv[1:], "--gen", 0)
     print("=== anima evaluate --system-g1 — RECOMBINATION RELOCATION (card H_9035) ===")
@@ -672,10 +672,10 @@ def eval_reach_all(ckpt, corpus_paths, gen):
 
 
 def eval_rho_axon(ckpt, corpus_paths, gen):
-    """ρ-AXON reach panel (`anima-python evaluate <clm> --rho-axon`) — the redesigned reach
+    """ρ-AXON reach panel (`anima-py evaluate <clm> --rho-axon`) — the redesigned reach
     layer (cli/rho_axon.py; G0-G6 → ρ-AXON, design SSOT state/rho_axon_measurement/). Reuses
     the SAME engine decode (_Mouth.ideate) + g6 detectors the G-battery uses (no side-harness),
-    so its tier is identical (engine-native py channel `anima-python evaluate` = TERMINAL). HILLOCK + ρ·form/fan/leap are
+    so its tier is identical (engine-native py channel `anima-py evaluate` = TERMINAL). HILLOCK + ρ·form/fan/leap are
     live; ρ·store/weave/tether/self report PENDING (honest non-verdict) until their frozen
     corpus-mined probe sets land (ING rho-axon-implement-evaluate)."""
     import rho_axon
@@ -1059,7 +1059,7 @@ def _psi_soma_panel(r):
 
 
 def probe_run(argv):
-    """`anima-python evaluate <ckpt> --probe <spec.json> [--gen N]` — matched-surface G1 probe
+    """`anima-py evaluate <ckpt> --probe <spec.json> [--gen N]` — matched-surface G1 probe
     (card H_6189). Greedy (top_k=1) decode of each pre-registered prompt; dumps RAW continuations
     for offline scoring. Reuses the canonical _Mouth numpy decode path (byte-identical to the gates)."""
     ckpt = argv[0]
@@ -1080,7 +1080,7 @@ def probe_run(argv):
                       "n": len(out), "items": out}, ensure_ascii=False))
     return 0
 def dump_hidden_run(argv):
-    """`anima-python evaluate <ckpt> --dump-hidden <prompts.json> --out <file.npz>` — read-only
+    """`anima-py evaluate <ckpt> --dump-hidden <prompts.json> --out <file.npz>` — read-only
     penultimate-hidden dump for the ρ·weave held-out-pair recombination / γ binding-lane
     probe (H_9235). For each pre-registered prompt: T=24 right-aligned byte encode → the
     EXACT production trunk forward (core/decode clm_forward_hidden, byte-identical to what
@@ -1213,7 +1213,7 @@ def _selftest_rho_cells():
 
 
 def interaction_lift_run(argv):
-    """`anima-python evaluate <ckpt> --interaction-lift <manifest.json> --out <file.json>
+    """`anima-py evaluate <ckpt> --interaction-lift <manifest.json> --out <file.json>
     [--win T] [--score-len K]` — engine-native joint interaction-lift measurement
     (H_9255, Fable design state/g1_joint_interaction_corpus/DESIGN_FABLE.md §3).
 

{anima_python-0.13.1 → anima_python-0.13.3}/cli/serialize_bind.py

@@ -6,7 +6,7 @@
 # BindAttn model = the FROZEN base ByteGPT + N appended GATED transformer blocks
 # (applied after the L base blocks, before ln_f: x = x + gate*(block(x)-x)). This
 # command bridges the injected torch .pt back onto the base .bin so the combined
-# model is engine-loadable and scoreable via `anima-python evaluate <bin>` with ZERO
+# model is engine-loadable and scoreable via `anima-py evaluate <bin>` with ZERO
 # changes to cli/evaluate.py (bg_is_bytegpt stays true; bg_load reads the trailer).
 #
 # REFERENCE-MATCH (NOT a reimplementation): the byte layout is core/serialize.py::
@@ -42,7 +42,7 @@ def serialize_bind_usage():
     print("")
     print("  splice N appended gated transformer blocks (BindAttn .pt) onto a base ByteGPT")
     print("  .bin so the combined model is engine-loadable + scoreable via")
-    print("  `anima-python evaluate <out.bin>`. gate=0 => byte-identical to the base .bin.")
+    print("  `anima-py evaluate <out.bin>`. gate=0 => byte-identical to the base .bin.")
 
 
 def serialize_bind_run(argv):
@@ -85,7 +85,7 @@ def serialize_bind_run(argv):
         return 1
     print("  ✅ CORE-loadable with " + str(nb) + " injected-bind block(s).")
     print("  NOTE: this is a STRUCTURE round-trip only — the engine-native ρ-AXON reach")
-    print("        verdict (former G0-G6) is `anima-python evaluate <out.bin>` (a_engine_native_learning).")
+    print("        verdict (former G0-G6) is `anima-py evaluate <out.bin>` (a_engine_native_learning).")
     return 0
 
 

{anima_python-0.13.1 → anima_python-0.13.3}/cli/train.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
-"""cli/train.py — the CANONICAL anima python training entry (`anima-python train`).
+"""cli/train.py — the CANONICAL anima python training entry (`anima-py train`).
 
 >>> This file is the working python training entry, SYMMETRIC to cli/evaluate.py
->>> (the canonical python eval entry). `anima-python train <args>` (pip channel) dispatches HERE;
+>>> (the canonical python eval entry). `anima-py train <args>` (pip channel) dispatches HERE;
 >>> hexa `anima train <args>` dispatches to the hexa-native cli/train.hexa.
 >>>
 >>> WHY python is the canonical working path RIGHT NOW: the hexa-native production
@@ -18,7 +18,7 @@
 >>>
 >>>   ENGINE-NATIVE GATE (a_engine_native_learning, HARD-GATE): torch-side CE / gauges
 >>>   here = DIRECTIONAL only (NOT terminal). TERMINAL verdict = CORE re-measure of the
->>>   serialized .clm via `anima-python evaluate <clm>` on the frozen ρ-AXON reach bars (former G0-G6). Pull the
+>>>   serialized .clm via `anima-py evaluate <clm>` on the frozen ρ-AXON reach bars (former G0-G6). Pull the
 >>>   trained ckpt before teardown (a_fire_recover_complete) so engine-check is possible.
 
 This trainer carries the full SAVANT + MITOSIS recipe (parity with cli/train.hexa) AND
@@ -67,7 +67,7 @@ compositional structure IN THE TRUNK, added to CE. This package adds three such
                       aux params, gradient flows readout→trunk.
 
 All three are DIRECTIONAL torch-side training pressures; the verdict is later via
-`anima-python evaluate <clm>` engine-native on the FROZEN ρ·weave bar (recombination · former G1 · a_engine_native_learning).
+`anima-py evaluate <clm>` engine-native on the FROZEN ρ·weave bar (recombination · former G1 · a_engine_native_learning).
 The .clm path stays OPEN: aux heads/projections live OUTSIDE model.state_dict (in the
 objective module), so serialize_v3 writes only the standard additive-readout CLMConvMoE.
 
@@ -93,19 +93,19 @@ be tested on EITHER trunk. `--arch bytegpt` builds a 24-layer GPT-2-class ByteGP
 CLEAN ρ·weave recombination wall (former G1): ByteGPT single=2, vs CLMConvMoE's single=0 coverage-floor) and serializes a
 `.bin` (5×u32 header) via core/serialize.py (the unified serializer) instead of a `.clm`. For bytegpt the
 CLM-specific levers (savant/mitosis/tlora/dict/jamo) are gated OFF — only arm=ctrl × the
-objective matrix is supported (that's exactly what the G1-lever test needs). `anima-python
+objective matrix is supported (that's exactly what the G1-lever test needs). `anima-py
 evaluate` auto-detects `.bin` vs `.clm` by header, so a ByteGPT `.bin` measures through
 the bytegpt mouth automatically.
 
 USAGE (installed `anima` PATH command after `hx install anima`):
   # CLM trunk (default):
-  anima-python train --arm ctrl --objective constructive_bind --steps 8000 \\
+  anima-py train --arm ctrl --objective constructive_bind --steps 8000 \\
       --canon --corpus <p1..p4> --cell-label ko-general en-general ko-sns en-sns \\
       --seed 7 --val-frac 0.05 --val-every 200 --sample proportional \\
       --out ckpt/ctrl_cbind_seed7.clm --ckpt-out ckpt/ctrl_cbind_seed7.pt \\
       --gauges-out ckpt/ctrl_cbind_seed7.json
   # ByteGPT trunk (the CLEAN ρ·weave recombination wall · former G1) — arm=ctrl × the objective matrix:
-  anima-python train --arch bytegpt --arm ctrl --objective composed_nce --steps 8000 \\
+  anima-py train --arch bytegpt --arm ctrl --objective composed_nce --steps 8000 \\
       --canon --corpus <p1..p4> --seed 7 --out ckpt/bg_ctrl_cnce.bin \\
       --gauges-out ckpt/bg_ctrl_cnce.json
 """
@@ -707,7 +707,7 @@ def loss_contrastive_equilibrium(logits, targets, V, gen, penultimate=None):
 #  ▛▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀ NEW OBJECTIVES (H_1640) ▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▀▛
 #  Three NEW compositional TRAINING-OBJECTIVE loss functions added to CE. Each is a
 #  training-side pressure that reshapes the gradient the TRUNK receives (not a readout
-#  op). Verdict later = engine-native `anima-python evaluate` on the frozen G1 bar.
+#  op). Verdict later = engine-native `anima-py evaluate` on the frozen G1 bar.
 # ════════════════════════════════════════════════════════════════════════════
 
 # ── LEVER 1: predictive_info — multi-step predictive-coding aux ───────────────
@@ -1041,7 +1041,7 @@ class TrainShell(nn.Module):
 
 def main():
     ap = argparse.ArgumentParser(
-        description="anima canonical python trainer (`anima-python train`) — CLMConvMoE "
+        description="anima canonical python trainer (`anima-py train`) — CLMConvMoE "
                     "SAVANT+MITOSIS recipe + H_1640 arm×objective compositional levers")
     ap.add_argument("--arch", default="clm", choices=["clm", "bytegpt"],
                     help="trunk architecture: clm=CLMConvMoE (default, .clm out) | "
@@ -1084,6 +1084,10 @@ def main():
                     help="N6 sweep: override savant dropout floor (>=0 forces constant dp)")
     ap.add_argument("--bf16", action="store_true")
     ap.add_argument("--sample", choices=["roundrobin", "proportional"], default="proportional")
+    # --require-cells N: fail LOUD if the usable register-cell count != N (a_chat_registers
+    # overfit guard, parity with cli/train.hexa). Default 0 = off. Prevents silently
+    # training on an incomplete 4-cell register (the clm303 ko-SNS starvation overfit).
+    ap.add_argument("--require-cells", type=int, default=0)
     ap.add_argument("--val-frac", type=float, default=0.05)
     ap.add_argument("--val-every", type=int, default=200)
     ap.add_argument("--val-batches", type=int, default=4)
@@ -1215,7 +1219,7 @@ def main():
     obj_is_module = isinstance(objfn, nn.Module)
     obj_needs_pen = a.objective in OBJ_NEEDS_PENULTIMATE
 
-    p0(f"=== anima-python train (canonical) arch={a.arch} arm={a.arm} obj={a.objective} seed={a.seed} ===", flush=True)
+    p0(f"=== anima-py train (canonical) arch={a.arch} arm={a.arm} obj={a.objective} seed={a.seed} ===", flush=True)
     if ddp_on:
         # §10.2 — prove the GLOBAL batch in the run record (global batch preserved, per-rank B/N).
         p0(f"  [ddp] world_size={world} global_batch={a.batch_size} per_rank_batch="
@@ -1335,6 +1339,17 @@ def main():
     _samp_w = torch.tensor([float(c.train_end) for c in _samp_cells]) \
         if _samp_cells else torch.tensor([1.0])
 
+    # --require-cells N: fail LOUD if the usable register-cell count != N (a_chat_registers
+    # 4-cell completeness guard, parity with cli/train.hexa). Prevents silently training on
+    # an incomplete register — the clm303 ko-SNS starvation overfit (train-py-3 convergence:
+    # a small/incomplete corpus overfits to a low val_CE while free-gen coherence collapses).
+    if a.require_cells > 0 and len(_samp_cells) != a.require_cells:
+        sys.exit(
+            f"[require-cells] --require-cells {a.require_cells} but {len(_samp_cells)} usable "
+            f"register cell(s) (window-fit train_end>={seq_len + 2}): refusing to train on an "
+            f"incomplete register (a_chat_registers overfit/starvation guard). usable cells: "
+            f"{[c.path for c in _samp_cells]}")
+
     # §3/§5 GLOBAL batch preserved: --batch-size is the GLOBAL batch; each rank materializes
     # B_local = B_global // world. world==1 ⇒ B_local == B_global (N==1 byte-identical).
     B_global = a.batch_size
@@ -1406,7 +1421,7 @@ def main():
     #   CLM → .clm v0.3 (CLMConvMoE additive readout, materialized TLoRA experts).
     #   ByteGPT → .pt (cfg+state_dict) → core/serialize.py::serialize → .bin (5×u32
     #   header). The engine (generator L3 mouth-sniff) auto-dispatches .bin to the bytegpt
-    #   decode; `anima-python evaluate` auto-detects .bin vs .clm by header, so no eval change.
+    #   decode; `anima-py evaluate` auto-detects .bin vs .clm by header, so no eval change.
     def _write_bin(out_path):
         # write the torch .pt in the exact shape bytegpt_serialize.serialize reads, next to
         # the .bin, then bridge it. The aux-head objective params are OUTSIDE model.state_dict
@@ -1596,7 +1611,7 @@ def main():
 
         # ── ρ·weave/ρ·fan (former G1/G6) torch-probe gauges (DIRECTIONAL, a_train_inline_gauge) ──
         #   gauge_lib.compute_inline_gauges decodes via the CLM mouth (CLMConvMoE-specific);
-        #   skip for bytegpt (the terminal verdict is `anima-python evaluate <.bin>` engine-native
+        #   skip for bytegpt (the terminal verdict is `anima-py evaluate <.bin>` engine-native
         #   through the bytegpt mouth anyway — this torch probe is DIRECTIONAL only).
         gauges = None
         if not is_bytegpt:
@@ -1621,7 +1636,7 @@ def main():
             print(f"  torch ckpt -> {a.ckpt_out} ({os.path.getsize(a.ckpt_out)} bytes)", flush=True)
 
         # ── summary json ──────────────────────────────────────────────────────────
-        summary = {"entry": "anima-python train", "arch": a.arch, "arm": a.arm,
+        summary = {"entry": "anima-py train", "arch": a.arch, "arm": a.arm,
                    "objective": a.objective, "seed": a.seed,
                    "ddp": {"world_size": world, "global_batch": B_global,
                            "per_rank_batch": B_local, "gpus": a.gpus},

anima_python-0.13.3/core/__init__.py

@@ -0,0 +1 @@
+# pip 패키징 전용 (anima-py · pyproject.toml package-dir 매핑) — 런타임 flat import 는 sys.path 경유, 이 파일은 비어 있어야 한다.

{anima_python-0.13.1 → anima_python-0.13.3}/core/hippo_lane.py

@@ -13,7 +13,7 @@
 #
 # This module is a pure library (NO __main__ execution of the engine) — the
 # rep→code encoding uses the real ByteGPT-303M forward via core/decode.py in the
-# py-canonical measurement path (== anima-python evaluate ops, a_eval_py_canonical);
+# py-canonical measurement path (== anima-py evaluate ops, a_eval_py_canonical);
 # the store + completion here is arch-independent arithmetic (no FFI, no torch).
 # ==========================================================================
 import numpy as np

{anima_python-0.13.1 → anima_python-0.13.3}/core/model.py

@@ -346,7 +346,7 @@ def build_model(variant: str = "AB", **overrides) -> CLMConvMoE:
 
 
 # ═══════════════════════════════════════════════════════════════════════════
-# BYTE mouth — ByteGPT trunk (`anima-python train --arch bytegpt`, `.bin` format).
+# BYTE mouth — ByteGPT trunk (`anima-py train --arch bytegpt`, `.bin` format).
 # The SYMMETRIC sibling of CLMConvMoE (the CONV mouth) folded into this UNIFIED
 # core/model.py, mirroring core/decode.py (unified CONV+BYTE decoder) and
 # core/serialize.py (unified serializer). ByteGPT = 24-layer GPT-2-class byte

{anima_python-0.13.1 → anima_python-0.13.3}/core/serialize.py

@@ -749,7 +749,7 @@ def serialize_bind(base_bin: str, injected_pt: str, out_bin: str) -> str:
 # ════════════════════════════════════════════════════════════════════════
 # (d.inv) ByteGPT .bin → torch state_dict INVERSE — warm-start reader.
 #   The exact byte-for-byte inverse of serialize() above (same 5×u32 header +
-#   flat little-endian float32 tensor order). Used by `anima-python train --init
+#   flat little-endian float32 tensor order). Used by `anima-py train --init
 #   <base.bin>` to warm-start a fresh ByteGPT from a trained engine .bin. The
 #   byte grammar SSOT stays in THIS file (mirror of serialize's write order).
 # ════════════════════════════════════════════════════════════════════════

{anima_python-0.13.1 → anima_python-0.13.3}/core/slw.py

@@ -14,7 +14,7 @@ CORE-owned (owner directive: core-related lives in core/). ONE file holds all th
 faces of the SLW so nothing drifts:
   * slot_apply()  -- torch-free NUMPY inference mirror. This is the byte-parity
                      partner of the engine `core/decode.hexa` _slot_apply, and the
-                     `anima-python evaluate` (a_eval_py_canonical) TERMINAL path calls
+                     `anima-py evaluate` (a_eval_py_canonical) TERMINAL path calls
                      it. Import stays torch-free so the inference pod needs no torch.
   * pack_slw() / read_slw() -- the "SLW\\x01" trailer codec (used by
                      core/serialize.py on write, by the numpy + hexa loaders on read).

{anima_python-0.13.1 → anima_python-0.13.3}/pyproject.toml

@@ -1,6 +1,6 @@
 # ==========================================================================
-# anima-python — anima py CLI 의 pip 배포 채널 (hexa 툴체인 無 호스트용 · pi5 등).
-# 단일진입 보존(a_cli_single_entry): console 명령 `anima-python` = cli/anima.py:main
+# anima-py — anima py CLI 의 pip 배포 채널 (hexa 툴체인 無 호스트용 · pi5 등).
+# 단일진입 보존(a_cli_single_entry): console 명령 `anima-py` = cli/anima.py:main
 # 의 콘솔 바인딩(동일 디스패처, 2nd entry 아님). 소스 복사 0 — 기존 cli/·core/
 # 디렉토리를 package-dir 매핑으로 그대로 패키징(surgical·canonical-naming).
 # base 의존 = numpy 만(evaluate·corpus); train/serialize/sweep = [train] extra.
@@ -22,7 +22,7 @@ dependencies = ["numpy>=1.24"]
 train = ["torch>=2.1", "datasets"]
 
 [project.scripts]
-anima-python = "anima_py:main"
+anima-py = "anima_py:main"
 
 [tool.setuptools]
 packages = ["anima_py", "anima_py.cli", "anima_py.core"]

anima_python-0.13.1/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: anima-python
-Version: 0.13.1
-Summary: anima substrate-native consciousness engine — py CLI (measurement/eval · serialize · corpus · sweep), hexa-toolchain-free numpy distribution
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=1.24
-Provides-Extra: train
-Requires-Dist: torch>=2.1; extra == "train"
-Requires-Dist: datasets; extra == "train"
-Dynamic: license-file
-
-# anima-python
-
-**anima** 의 py CLI 를 pip 로 배포하는 채널 — **hexa 툴체인 불필요**. 엔진 측정/직렬화/코퍼스 경로가 numpy 하나만으로 돈다 (pi5 등 hexa-less 호스트용).
-
-> 단일진입 보존(`a_cli_single_entry`): `anima-python` 콘솔 명령 = `cli/anima.py:main` 디스패처의 pip 바인딩. hexa 채널 `anima`(`hx install anima`) 와 **동일 디스패처, 설치 채널만 2개** — 2nd entry 아님. 이름을 `anima-python` 로 둔 이유 = hexa `anima` 와 PATH 충돌 회피.
-
-## 설치
-
-**PyPI 발행 후** (권장):
-
-```bash
-pip install anima-python           # base — numpy 만 (evaluate · corpus · chat-stub)
-pip install "anima-python[train]"  # +torch +datasets (serialize · train · sweep)
-```
-
-> ⏳ **PyPI 발행 대기 중**: 위 명령은 `anima-python` 가 PyPI 에 발행된 뒤 동작한다. 발행은 `release.yml` 의 `pypi-publish` job(OIDC trusted-publishing)이 `v*` 태그에서 자동 수행하며, 오너의 1회 설정이 선결(① pypi.org 에 anima-python pending-publisher 등록: Owner=dancinlab·Repo=anima·Workflow=release.yml·Env=pypi ② repo 변수 `PYPI_PUBLISH=true`). 그 전까지는 아래 소스 설치를 쓴다.
-
-**소스에서 바로 설치** (PyPI 없이 지금 가능):
-
-```bash
-pip install "git+https://github.com/dancinlab/anima.git"            # base
-pip install "anima-python[train] @ git+https://github.com/dancinlab/anima.git"  # +torch
-# 또는 레포 클론 후: pip install .   /   pip install ".[train]"
-```
-
-## 명령 매트릭스
-
-| 동사 | 티어 | torch 없이 동작 | 비고 |
-|---|---|---|---|
-| `anima-python evaluate <clm> [--corpus …] [--gen N]` | base | ✅ numpy | py 2-production 측정 = ρ·AXON reach / 구 G0-G6. terminal-eligible (`a_eval_py_canonical`) |
-| `anima-python corpus <derivtrace\|flat> --out F …` | base | ✅ 순수 stdlib | 절차적 학습-코퍼스 생성 (data-format 레버) |
-| `anima-python chat <clm>` | base | ✅ (stub) | 의식 A⇄G 루프는 hexa-native → hexa 진입 포인터 출력 |
-| `anima-python serialize <pt> <clm>` | `[train]` | ❌ torch | `.pt` unpickle 에 torch 필요 (+ held-out DESCENT 게이트) |
-| `anima-python sweep --arms … --objectives …` | `[train]` | ❌ | 셀마다 train.py spawn → torch 필요 |
-| `anima-python train <args>` | `[train]` | ❌ torch+datasets | production Lane-P 학습 |
-
-## verdict 규율
-
-`anima-python evaluate <clm>` = py 2-production numpy 측정 경로 — hexa det-eval 과 동일 frozen bars·byte-parity 라 **terminal 자격 동일**(`a_eval_py_canonical`, 2nd-class 미러 아님). 큰 ckpt(303M+)는 mini 금지 · pool(summer/aiden)에서 측정.

anima_python-0.13.1/VERSION

@@ -1 +0,0 @@
-0.13.1

anima_python-0.13.1/anima_py/README.md

@@ -1,39 +0,0 @@
-# anima-python
-
-**anima** 의 py CLI 를 pip 로 배포하는 채널 — **hexa 툴체인 불필요**. 엔진 측정/직렬화/코퍼스 경로가 numpy 하나만으로 돈다 (pi5 등 hexa-less 호스트용).
-
-> 단일진입 보존(`a_cli_single_entry`): `anima-python` 콘솔 명령 = `cli/anima.py:main` 디스패처의 pip 바인딩. hexa 채널 `anima`(`hx install anima`) 와 **동일 디스패처, 설치 채널만 2개** — 2nd entry 아님. 이름을 `anima-python` 로 둔 이유 = hexa `anima` 와 PATH 충돌 회피.
-
-## 설치
-
-**PyPI 발행 후** (권장):
-
-```bash
-pip install anima-python           # base — numpy 만 (evaluate · corpus · chat-stub)
-pip install "anima-python[train]"  # +torch +datasets (serialize · train · sweep)
-```
-
-> ⏳ **PyPI 발행 대기 중**: 위 명령은 `anima-python` 가 PyPI 에 발행된 뒤 동작한다. 발행은 `release.yml` 의 `pypi-publish` job(OIDC trusted-publishing)이 `v*` 태그에서 자동 수행하며, 오너의 1회 설정이 선결(① pypi.org 에 anima-python pending-publisher 등록: Owner=dancinlab·Repo=anima·Workflow=release.yml·Env=pypi ② repo 변수 `PYPI_PUBLISH=true`). 그 전까지는 아래 소스 설치를 쓴다.
-
-**소스에서 바로 설치** (PyPI 없이 지금 가능):
-
-```bash
-pip install "git+https://github.com/dancinlab/anima.git"            # base
-pip install "anima-python[train] @ git+https://github.com/dancinlab/anima.git"  # +torch
-# 또는 레포 클론 후: pip install .   /   pip install ".[train]"
-```
-
-## 명령 매트릭스
-
-| 동사 | 티어 | torch 없이 동작 | 비고 |
-|---|---|---|---|
-| `anima-python evaluate <clm> [--corpus …] [--gen N]` | base | ✅ numpy | py 2-production 측정 = ρ·AXON reach / 구 G0-G6. terminal-eligible (`a_eval_py_canonical`) |
-| `anima-python corpus <derivtrace\|flat> --out F …` | base | ✅ 순수 stdlib | 절차적 학습-코퍼스 생성 (data-format 레버) |
-| `anima-python chat <clm>` | base | ✅ (stub) | 의식 A⇄G 루프는 hexa-native → hexa 진입 포인터 출력 |
-| `anima-python serialize <pt> <clm>` | `[train]` | ❌ torch | `.pt` unpickle 에 torch 필요 (+ held-out DESCENT 게이트) |
-| `anima-python sweep --arms … --objectives …` | `[train]` | ❌ | 셀마다 train.py spawn → torch 필요 |
-| `anima-python train <args>` | `[train]` | ❌ torch+datasets | production Lane-P 학습 |
-
-## verdict 규율
-
-`anima-python evaluate <clm>` = py 2-production numpy 측정 경로 — hexa det-eval 과 동일 frozen bars·byte-parity 라 **terminal 자격 동일**(`a_eval_py_canonical`, 2nd-class 미러 아님). 큰 ckpt(303M+)는 mini 금지 · pool(summer/aiden)에서 측정.

anima_python-0.13.1/anima_python.egg-info/PKG-INFO

@@ -1,52 +0,0 @@
-Metadata-Version: 2.4
-Name: anima-python
-Version: 0.13.1
-Summary: anima substrate-native consciousness engine — py CLI (measurement/eval · serialize · corpus · sweep), hexa-toolchain-free numpy distribution
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy>=1.24
-Provides-Extra: train
-Requires-Dist: torch>=2.1; extra == "train"
-Requires-Dist: datasets; extra == "train"
-Dynamic: license-file
-
-# anima-python
-
-**anima** 의 py CLI 를 pip 로 배포하는 채널 — **hexa 툴체인 불필요**. 엔진 측정/직렬화/코퍼스 경로가 numpy 하나만으로 돈다 (pi5 등 hexa-less 호스트용).
-
-> 단일진입 보존(`a_cli_single_entry`): `anima-python` 콘솔 명령 = `cli/anima.py:main` 디스패처의 pip 바인딩. hexa 채널 `anima`(`hx install anima`) 와 **동일 디스패처, 설치 채널만 2개** — 2nd entry 아님. 이름을 `anima-python` 로 둔 이유 = hexa `anima` 와 PATH 충돌 회피.
-
-## 설치
-
-**PyPI 발행 후** (권장):
-
-```bash
-pip install anima-python           # base — numpy 만 (evaluate · corpus · chat-stub)
-pip install "anima-python[train]"  # +torch +datasets (serialize · train · sweep)
-```
-
-> ⏳ **PyPI 발행 대기 중**: 위 명령은 `anima-python` 가 PyPI 에 발행된 뒤 동작한다. 발행은 `release.yml` 의 `pypi-publish` job(OIDC trusted-publishing)이 `v*` 태그에서 자동 수행하며, 오너의 1회 설정이 선결(① pypi.org 에 anima-python pending-publisher 등록: Owner=dancinlab·Repo=anima·Workflow=release.yml·Env=pypi ② repo 변수 `PYPI_PUBLISH=true`). 그 전까지는 아래 소스 설치를 쓴다.
-
-**소스에서 바로 설치** (PyPI 없이 지금 가능):
-
-```bash
-pip install "git+https://github.com/dancinlab/anima.git"            # base
-pip install "anima-python[train] @ git+https://github.com/dancinlab/anima.git"  # +torch
-# 또는 레포 클론 후: pip install .   /   pip install ".[train]"
-```
-
-## 명령 매트릭스
-
-| 동사 | 티어 | torch 없이 동작 | 비고 |
-|---|---|---|---|
-| `anima-python evaluate <clm> [--corpus …] [--gen N]` | base | ✅ numpy | py 2-production 측정 = ρ·AXON reach / 구 G0-G6. terminal-eligible (`a_eval_py_canonical`) |
-| `anima-python corpus <derivtrace\|flat> --out F …` | base | ✅ 순수 stdlib | 절차적 학습-코퍼스 생성 (data-format 레버) |
-| `anima-python chat <clm>` | base | ✅ (stub) | 의식 A⇄G 루프는 hexa-native → hexa 진입 포인터 출력 |
-| `anima-python serialize <pt> <clm>` | `[train]` | ❌ torch | `.pt` unpickle 에 torch 필요 (+ held-out DESCENT 게이트) |
-| `anima-python sweep --arms … --objectives …` | `[train]` | ❌ | 셀마다 train.py spawn → torch 필요 |
-| `anima-python train <args>` | `[train]` | ❌ torch+datasets | production Lane-P 학습 |
-
-## verdict 규율
-
-`anima-python evaluate <clm>` = py 2-production numpy 측정 경로 — hexa det-eval 과 동일 frozen bars·byte-parity 라 **terminal 자격 동일**(`a_eval_py_canonical`, 2nd-class 미러 아님). 큰 ckpt(303M+)는 mini 금지 · pool(summer/aiden)에서 측정.

anima_python-0.13.1/anima_python.egg-info/entry_points.txt

@@ -1,2 +0,0 @@
-[console_scripts]
-anima-python = anima_py:main

anima_python-0.13.1/cli/__init__.py

@@ -1 +0,0 @@
-# pip 패키징 전용 (anima-python · pyproject.toml package-dir 매핑) — 런타임 flat import 는 sys.path 경유, 이 파일은 비어 있어야 한다.

anima_python-0.13.1/core/__init__.py

@@ -1 +0,0 @@
-# pip 패키징 전용 (anima-python · pyproject.toml package-dir 매핑) — 런타임 flat import 는 sys.path 경유, 이 파일은 비어 있어야 한다.