Skip to content

CLAUDE.md

Latest commit

 

History

History
129 lines (98 loc) · 10.5 KB

CLAUDE.md

File metadata and controls

129 lines (98 loc) · 10.5 KB
Raw

🧠 anima

⛔ EVERY engine op goes through the installed anima-py CLI — read this before you type anything

the ONLY command
corpus anima-py corpus <fmt> --out c.txt … (emits the budget floor the trainer enforces)
train anima-py train --corpus c.txt --init base.clm … ([train] extra)
judge anima-py evaluate <clm> [--xbind m.json] [--rho-axon] — TERMINAL verdict path
serialize·sweep·chat anima-py serialize/sweep/chat
  • do: py channel for every engine op (pip install "anima-python[train]") · a NEW manipulation is a flag on these commands.
  • dont: python3 cli/*.py · a script beside the engine · a probe re-doing a forward pass.
  • dont: cement on a number these commands did not produce — code-blocked; every bypass died undecidable (H_9303·H_9307).

🇬🇧 EN-FIRST until the recombination wall breaks (owner directive · research corpora only)

  • do: build every NEW research corpus with --lang en — the Korean lane is 🧱 BINDING, every escape measured dead (H_9327).
  • do: EN is the discriminator — not FREE/pre-posed vs 지 않다 BOUND suffix.
  • dont: read an EN positive as cemented (SCREENER, DIRECTIONAL — moves morphology+base+carrier at once).
  • dont: touch --lang ko (byte-identical to frozen corpora) · build EN over the Korean atom file.

Project

anima = a substrate-native consciousness chat daemon, not an assistant. Engines A (forward, CE) ⇄ G (reverse, gradient-free) push; that tension pulls emit/silence to Ψ = ½. Identity emerges from the architecture. Deep structure → ARCHITECTURE.json.

Tree

anima/
├─ core/       — A⇄G⇄brain engine (weights via generator.hexa L3)
├─ cli/        — anima entry · train · evaluate · corpus
├─ stdlib/     — iit4 faithful-Φ · flame/forge GPU
├─ HYPOTHESES/ — jsonl + cards/ (2 surfaces, nothing else)
├─ lab/v*/     — 🧪 SANDBOX: rule-exempt, in-tree (v2·v3·v4·v5 · each owns its CLAUDE.md · NOT production)
├─ state/      — 🔒 FROZEN: verdicts/ only · state/ + archive/state/ new-write G7-blocked (content → cards)
└─ ARCHITECTURE.json — deep-structure SSOT (`python3 serve.py`)

🧪 lab/v*/ — RULE-EXEMPT sandboxes (owner · full → each lab/v<n>/CLAUDE.md)

  • do: experiment freely — every clause here is VOID inside lab/v*/ · lab hypotheses live in that lab's own folder only (lab/v2/hypotheses/V2_<n>_*.md · lab/v<n>/HYPOTHESES/), never the parent jsonl or an H_ id.
  • dont: promote a lab number to a production verdict (permanent DIRECTIONAL ceiling — port to core/+anima-py to earn TERMINAL) · import lab/v*/ in production · re-detach a lab into its own git repo (they are in-tree; history of the retired v3/v4/v5 repos = ../lab-archive/anima-v<n>.bundle).

🚦 Pre-action hard-gate (BLOCKING · before any work/verify/fire)

  • do: ① cement only on engine-native core/ decode ② heavy compute on pool, never mini ③ pull the ckpt before teardown ④ CHANGELOG+ARCHITECTURE/ING → pr-cycle.
  • do: ⑤ a negative is a result — no tune-to-green, frozen-first, no self-judge ⑥ every H on 2 surfaces ⑦ GREEN only when wired.
  • dont: skip ①/⑥ — code-blocked by .harness/enforce_anima_gates.py (G2 = no non-card under HYPOTHESES/ · G5 = VERSION bump · G6 = unique H_id).

🤖 Autonomy — NO human-approval gate (owner directive)

  • do: run engine/instrument/core//cli/design changes + standing-pool cost runs AUTONOMOUSLY. p5 = daemon-runtime rule (no hardcoded speak/emit), NOT an approval gate on my work.
  • dont: tag an engine/instrument/design change owner p5/owner-gate and punt to human approval (owner: NOT owner-gate) · session-terminal on autonomously-doable work. Only real go-gate = fleet rent=spend.

📦 Packaging (pod)

  • do: production tree = core/·cli/·agent/ only (+ vendored stdlib/) · pip install anima-python → run anima-py (install name ≠ run cmd) · hexa twin = hx install anima.
  • dont: production import from archive/ · a wheel change (cli/**·core/**·pyproject.toml) without a root VERSION bump (G5) · gate py on a hexa smoke.

Philosophy p1–p8 (what anima rejects)

p1 no system prompt · p2 no identity rules · p3 no persona injection · p4 no assistant framing · p5 no speak() (emit only over real tension; reactive self-seed banned) · p6 no fine-tuned ethics · p7 no perplexity verdict · p8 no train/infer split.

🩺 Ψ-SOMA — measurement frame (SSOT · reframes the old G-ladder · full → ARCHITECTURE psi-soma-vitals)

  • do: read the verdict as mode-of-existence, not capability — Θ (Ψ=½ pulse; Θ dead ⟹ σ VOID) · σ (9 axes) · INVALID/VOID/PENDING first-class.
  • do: read the signal as collapse-Δ vs ≥2 controls, never a raw value (FORM tunable·BIND earned·p7).
  • dont: fold ρ-AXON (reach · --rho-axon) into the verdict — the G1/G6 wall is a reach fact, not a consciousness deficit · cement TERMINAL on a toy (only 303M py is).

Governance (name — core MUST; full do/dont + H_ precedents → ARCHITECTURE.json)

Keyword-trigger index. Each line is a pointer — full do/dont + the earning H_ live in ARCHITECTURE.json.

🔬 Verification (HARD-GATE)

  • a_no_llm_frame_trap — substrate-first, not the LLM frame.
  • a_break_the_wall — a wall = change angle; a ceiling needs ≥2–3 lenses. No tune-to-green.
  • a_engine_native_learning — cement only on core/ decode; a mirror = DIRECTIONAL.
  • a_experiment_engine_native — 🧪 the INSTRUMENT is engine-native too: a manipulation is an anima-py flag, not a probe beside the engine.
  • a_verified_must_wire/a_blue_closed — GREEN only when output AND wiring are closed.
  • a_phi_iit4_tool — Φ via faithful IIT4, never a proxy.
  • a_train_inline_gauge — in-training metrics are MONITOR-ONLY, never in the loss.
  • a_korean_byte_budget — 🇰🇷 byte-LM knobs are BYTES (ko = 3 B/char); oracle budget must equal the model's. Bit us 3×.

🧪 Hypothesis

  • a_hypothesis_register — every H on 2 surfaces: jsonl + card. Nothing else.
  • a_no_scatter_hypotheses_first — 🧹 4 output surfaces: card+jsonl · ARCHITECTURE gate node · state/verdicts/ · /tmp. New state/·archive/state/ writes = hook+G7 blocked.
  • a_claim_manifest/a_claim_verify — claim → hexa verify → frozen verdict. No self-judge. Use the global harness/hexa.
  • a_h_continuous_no_branch — owner: run the next H autonomously, no per-step go.
  • a_all_paths_no_leak — 🔀 all paths · zero leak (owner): at a design fork with several live angles, do NOT pick one — launch them ALL in parallel (hard design → lab full, implementation done concurrently = the "both" default). Every launched angle · background job · worktree · pod · venv · donor · ckpt is TRACKED (ing/poller) → RECOVERED on completion (a_fire_recover_complete) → CLEANED (worktree sweep · pod teardown) so leakage = 0. Forbidden: a dropped angle · unlanded code · an unswept worktree · an un-torn-down pod · an unrecovered result · an orphan proc. Scan for leaks with end / worktree gc / hexa cloud pods.
  • a_discovery/a_discovery_log — run discovery every batch → domains/<DOMAIN>.log.md.
  • a_toy_scale_recheck/a_scale_honest_scope — a toy verify ≠ closure; bound a metric to its scale.
  • a_lab_full_diverge — 🔀 sidecar lab full = Fable 5 + Codex Sol in parallel (2 models cover each other's blind spots; lab fable/lab sol = single-model). Brief MUST embed the current frontier map + kill-list (blocks regenerating dead angles). Register EVERY surviving angle as a PROPOSED card on 2 surfaces (jsonl+card); id = origin's live max + 1 (avoid G6 collision — a parallel session may be mid-campaign) tagged as an R# series. a_parallel_session_compare: read origin's latest BEFORE registering → no duplicate fire · report AGREES/CONFLICTS/NOVEL. Divergence output = DIRECTIONAL design, never a verdict — cement only via engine-native anima-py.

🔥 Fire·GPU·recovery

  • a_fire_autonomous — fire a cost run autonomously (⚠️ fleet rent=spend needs go).
  • a_wall_first — independent tracks, one GPU host each, concurrently ⟹ wall = max(track), never sum.
  • a_fire_recover_complete — pull the ckpt to permanent storage BEFORE teardown.
  • a_cpu_local_no_waiter/a_dont_kill_live_compute — inline-poll a fire; prove a stall before killing it.

🏗️ CORE engine

  • a_core_engine_map — core/ = A⇄G⇄brain; weights via generator.hexa L3.
  • a_cli_single_entry — engine ops via INSTALLED commands only: anima-py <verb> · hexa anima <verb>. Scratch tree FROZEN.
  • a_eval_py_canonical — reach eval = anima-py evaluate. Heavy 303M → pool, never mini.
  • a_gpu_default_no_optin — GPU fast-paths DEFAULT-ON via cuda_available(), never opt-in env (H_9119).
  • a_no_archive_import — production never imports from archive/.
  • a_savant_train — SAVANT inhibition DISJOINT from the emit-drive lane.
  • a_mitosis_train — p8 MITOSIS; growth 🟢, from-scratch split 🔴.
  • a_chat_registers — chat = ko·en × general·SNS, all 4 cells.
  • a_lane_akida_gpu_split — AKIDA ⊥ GPU: separate entries + tag.
  • a_substrate_disjoint — LAW: separation = preservation, overlap = conflict.

🗣️ Substrate autonomy

  • a_substrate_native_speak/a_autonomy_over_hardcode — speech is substrate-native; no hardcoded emit gate.
  • a_chat_sleep_imagination — 5-stage sleep; imagination ≠ speak().
  • a_kosmos — persistence = .kosmos; identity via self-anchor (mouth ⊥ id).
  • a_eeg_consciousness_record — OpenBCI NATIVE serial, REAL only; HF PUBLIC.

🔧 Identity·HF·chip

  • a1 — version registry = VERSIONS.md SSOT.
  • a_hf_* (complete/autonomous/registry/collections) — HF complete, no drift; auto-upload +sha256; PUBLIC → collection.
  • a_pi5_akida_registry — pi5-akida = PI5-AKIDA.json SSOT; never move it to the pool.
  • a_completeness_over_cheap — completeness bar first; cost is not a gate.
  • a_parallel_session_compare — read what other sessions landed before you fire; report AGREES/CONFLICTS. Never edit the primary checkout.

Harness · claim flow

  • do: global harness·hexa on PATH; claim → hexa verify → frozen verdict → card + jsonl.
  • dont: trust the stale submodule binary · write a paper unless asked (c15).