bioma-micro 1.0.0__tar.gz

bioma_micro-1.0.0/CHANGELOG.md

@@ -0,0 +1,13 @@
+# Changelog
+
+## 1.0.0 — 2026-07-16
+
+First public release on PyPI.
+
+- `dehydrate()` — one-shot, stateless history dehydration (recency-weighted half-life
+  decay, protected `SYSTEM`/`FACT` classes, audited token savings, GIL-released hot path).
+- `ContextApoptosis` — stateful incremental engine (`insert` / `dehydrate` / `render`,
+  atomic audit counters).
+- `saturation_scan()` — O(n) duplicate-shingle flood detector (cognitive-DDoS guard).
+- `HormonalBus` / `HormonalSignal` — lock-free in-memory signal bus (crossbeam).
+- abi3 wheel (`cp38-abi3`): one binary wheel covers CPython ≥ 3.8.

bioma_micro-1.0.0/Cargo.lock

@@ -0,0 +1,196 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
+
+[[package]]
+name = "bioma_micro"
+version = "1.0.0"
+dependencies = [
+ "crossbeam-channel",
+ "pyo3",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d85363c37faeca707aef026efa9f3b34d077bce547e48f770770625c6013679e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.186"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+dependencies = [
+ "cfg-if",
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+dependencies = [
+ "once_cell",
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.46"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf54715a573b99ac80df0bc206da022bcd442c974952c7b9720069370852e21f"
+
+[[package]]
+name = "syn"
+version = "2.0.118"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.12.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

bioma_micro-1.0.0/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "bioma_micro"
+version = "1.0.0"
+edition = "2021"
+description = "B.I.O.M.A. Micro-Kernel — lock-free hormonal bus + context apoptosis (PyO3)."
+license = "LicenseRef-FSL-1.1-MIT"
+readme = "README.md"
+
+[lib]
+name = "bioma_micro"
+# cdylib → a native Python extension module loadable by CPython.
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { version = "0.22", features = ["extension-module"] }
+crossbeam-channel = "0.5"
+
+# Aggressive optimisation for the microsecond hot path — inline everything, fuse
+# codegen units. No panic="abort": PyO3 converts Rust panics into Python
+# exceptions at the FFI boundary, which requires unwinding.
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1
+strip = true
+
+# Standalone crate — its own workspace root, so nested-Cargo workspace
+# resolution never clashes with any parent tree.
+[workspace]

bioma_micro-1.0.0/LICENSE

@@ -0,0 +1,114 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Jonathas Cordeiro
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, INCLUDING
+BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT License that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT License, in which case the following will apply:
+
+MIT License
+
+Copyright 2026 Jonathas Cordeiro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

bioma_micro-1.0.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: bioma_micro
+Version: 1.0.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+License-File: LICENSE
+Summary: B.I.O.M.A. Micro-Kernel — lock-free hormonal bus + autonomous context apoptosis.
+Keywords: llm,context-window,prompt-compression,token-optimization,agents,rust,pyo3
+Author-email: Jonathas Cordeiro <jonathas.cordeiro2023@gmail.com>
+License: LicenseRef-FSL-1.1-MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Changelog, https://github.com/jonathascordeiro20/bioma-framework/blob/main/CHANGELOG.md
+Project-URL: Repository, https://github.com/jonathascordeiro20/bioma-framework
+
+# bioma-micro
+
+**B.I.O.M.A. Micro-Kernel** — a lean efficiency & resilience core for LLM infrastructure,
+written in Rust, exposed to Python via PyO3.
+
+Exactly two proven primitives, nothing else:
+
+- **Context apoptosis** — autonomous history dehydration. Long agent sessions accumulate
+  low-value ballast (verbose tool logs, stale turns). The kernel assigns each message a
+  metabolic weight by class, applies half-life decay, and purges dead weight *before* the
+  payload hits the API. Microsecond-scale, GIL-released, allocation-light.
+- **Hormonal bus** — lock-free in-memory signal injection (~2M signals/s, ~5 µs).
+
+Plus `saturation_scan()`, an O(n) repetition detector for cognitive-DDoS / flood inputs.
+
+## Install
+
+```bash
+pip install bioma-micro
+```
+
+Prebuilt wheel for Windows (Python ≥ 3.8, abi3). Other platforms build from the sdist
+(requires a Rust toolchain: `pip` will invoke `maturin` automatically).
+
+## Quick start
+
+```python
+import bioma_micro as bm
+
+messages = [
+    ("You are a precise operations copilot.", bm.SYSTEM),   # never purged
+    ("FACT: the deploy freeze ends on 2026-07-18.", bm.FACT),  # never purged
+    ("[tool log] 40 KB of verbose audit output ...", bm.TOOL),  # prime target
+    ("Round 1: any anomaly?", bm.USER),
+    ("Nothing above baseline.", bm.ASSISTANT),
+    # ... hundreds of turns later ...
+    ("What is the freeze end date?", bm.USER),
+]
+
+result = bm.dehydrate(messages, half_life=6.0, safe_threshold=0.35)
+print(result["reduction"])          # fraction of input tokens purged (0..1)
+print(result["kernel_latency_us"])  # pure-Rust decision pass, microseconds
+prompt = "\n".join(result["kept"])  # dispatch this instead of the full history
+```
+
+Flood detection:
+
+```python
+bm.saturation_scan(suspicious_text)  # ~1.0 = repetitive flood, ~0.0 = natural text
+```
+
+## The honest contract
+
+Measured, auditable behavior (full methodology and raw data in the
+[framework repo](https://github.com/jonathascordeiro20/bioma-framework)):
+
+| Client behavior | Measured effect |
+| :--- | :--- |
+| Naive tool-calling agent (resends growing history) | **−84%** input tokens |
+| Generic long session (16 rounds, resends everything) | **−95.8%** input tokens |
+| Claude Code (already self-manages context) | **~0%** — safe no-op |
+
+- Values tagged `FACT` and recent turns survive; answer quality stays at parity with the
+  full-context baseline (verified with objective probes against real online models).
+- Durable info buried in old untagged turns **is purged by design** — tag it `FACT`.
+- Against an already-lean agent the kernel is a no-op: it never helps, never hurts.
+
+This is a safety net for agents that do **not** manage their own context — not a
+universal "−X%" claim.
+
+## API surface
+
+| Symbol | Kind | Purpose |
+| :--- | :--- | :--- |
+| `dehydrate(messages, half_life=6.0, safe_threshold=0.35)` | function | one-shot history dehydration; returns kept blocks + audit dict |
+| `saturation_scan(text, window=8)` | function | duplicate-shingle flood score (0..1) |
+| `ContextApoptosis(half_life, safe_threshold, capacity)` | class | stateful incremental engine (`insert` / `dehydrate` / `render`) |
+| `HormonalBus`, `HormonalSignal` | class | lock-free signal bus |
+| `SYSTEM`, `USER`, `ASSISTANT`, `FACT`, `TOOL` | flags | metabolic signal classes |
+
+## License
+
+[FSL-1.1-MIT](https://fsl.software/) — Functional Source License 1.1 with MIT future
+license. Free for internal use, non-commercial use, and professional services; converts
+to MIT two years after each release.
+

bioma_micro-1.0.0/PUBLISH.md

@@ -0,0 +1,29 @@
+# Publicando o bioma-micro no PyPI
+
+Artefatos da release 1.0.0 (já compilados e validados com `twine check` + smoke test):
+
+- `target/wheels/bioma_micro-1.0.0-cp38-abi3-win_amd64.whl` — wheel abi3, cobre CPython ≥ 3.8 no Windows
+- `target/wheels/bioma_micro-1.0.0.tar.gz` — sdist (Linux/macOS compilam via Rust automaticamente)
+
+## Passo único que falta: o token
+
+1. Crie um API token em https://pypi.org/manage/account/token/ (escopo "Entire account"
+   para a primeira publicação; depois restrinja ao projeto `bioma-micro`).
+2. Rode:
+
+```powershell
+cd c:\Users\jonat\A.N.I.M.A\workspace\bioma_micro
+$env:MATURIN_PYPI_TOKEN = "pypi-AgEIcHlwaS5vcmc..."   # seu token
+maturin upload target/wheels/bioma_micro-1.0.0-cp38-abi3-win_amd64.whl target/wheels/bioma_micro-1.0.0.tar.gz
+```
+
+3. Verifique: `pip install bioma-micro` num venv limpo.
+
+> Não suba o wheel antigo `cp312-cp312` — o abi3 o substitui e cobre 3.8→3.13.
+
+## Wheels Linux/macOS (adoção total)
+
+O sdist já permite `pip install bioma-micro` em qualquer plataforma com Rust. Para
+wheels prontos multi-plataforma, o caminho padrão é GitHub Actions com
+`PyO3/maturin-action` (matriz linux/musllinux/macos/windows) publicando via
+`maturin upload` — adicione quando o repo público existir.

bioma_micro-1.0.0/README.md

@@ -0,0 +1,85 @@
+# bioma-micro
+
+**B.I.O.M.A. Micro-Kernel** — a lean efficiency & resilience core for LLM infrastructure,
+written in Rust, exposed to Python via PyO3.
+
+Exactly two proven primitives, nothing else:
+
+- **Context apoptosis** — autonomous history dehydration. Long agent sessions accumulate
+  low-value ballast (verbose tool logs, stale turns). The kernel assigns each message a
+  metabolic weight by class, applies half-life decay, and purges dead weight *before* the
+  payload hits the API. Microsecond-scale, GIL-released, allocation-light.
+- **Hormonal bus** — lock-free in-memory signal injection (~2M signals/s, ~5 µs).
+
+Plus `saturation_scan()`, an O(n) repetition detector for cognitive-DDoS / flood inputs.
+
+## Install
+
+```bash
+pip install bioma-micro
+```
+
+Prebuilt wheel for Windows (Python ≥ 3.8, abi3). Other platforms build from the sdist
+(requires a Rust toolchain: `pip` will invoke `maturin` automatically).
+
+## Quick start
+
+```python
+import bioma_micro as bm
+
+messages = [
+    ("You are a precise operations copilot.", bm.SYSTEM),   # never purged
+    ("FACT: the deploy freeze ends on 2026-07-18.", bm.FACT),  # never purged
+    ("[tool log] 40 KB of verbose audit output ...", bm.TOOL),  # prime target
+    ("Round 1: any anomaly?", bm.USER),
+    ("Nothing above baseline.", bm.ASSISTANT),
+    # ... hundreds of turns later ...
+    ("What is the freeze end date?", bm.USER),
+]
+
+result = bm.dehydrate(messages, half_life=6.0, safe_threshold=0.35)
+print(result["reduction"])          # fraction of input tokens purged (0..1)
+print(result["kernel_latency_us"])  # pure-Rust decision pass, microseconds
+prompt = "\n".join(result["kept"])  # dispatch this instead of the full history
+```
+
+Flood detection:
+
+```python
+bm.saturation_scan(suspicious_text)  # ~1.0 = repetitive flood, ~0.0 = natural text
+```
+
+## The honest contract
+
+Measured, auditable behavior (full methodology and raw data in the
+[framework repo](https://github.com/jonathascordeiro20/bioma-framework)):
+
+| Client behavior | Measured effect |
+| :--- | :--- |
+| Naive tool-calling agent (resends growing history) | **−84%** input tokens |
+| Generic long session (16 rounds, resends everything) | **−95.8%** input tokens |
+| Claude Code (already self-manages context) | **~0%** — safe no-op |
+
+- Values tagged `FACT` and recent turns survive; answer quality stays at parity with the
+  full-context baseline (verified with objective probes against real online models).
+- Durable info buried in old untagged turns **is purged by design** — tag it `FACT`.
+- Against an already-lean agent the kernel is a no-op: it never helps, never hurts.
+
+This is a safety net for agents that do **not** manage their own context — not a
+universal "−X%" claim.
+
+## API surface
+
+| Symbol | Kind | Purpose |
+| :--- | :--- | :--- |
+| `dehydrate(messages, half_life=6.0, safe_threshold=0.35)` | function | one-shot history dehydration; returns kept blocks + audit dict |
+| `saturation_scan(text, window=8)` | function | duplicate-shingle flood score (0..1) |
+| `ContextApoptosis(half_life, safe_threshold, capacity)` | class | stateful incremental engine (`insert` / `dehydrate` / `render`) |
+| `HormonalBus`, `HormonalSignal` | class | lock-free signal bus |
+| `SYSTEM`, `USER`, `ASSISTANT`, `FACT`, `TOOL` | flags | metabolic signal classes |
+
+## License
+
+[FSL-1.1-MIT](https://fsl.software/) — Functional Source License 1.1 with MIT future
+license. Free for internal use, non-commercial use, and professional services; converts
+to MIT two years after each release.

bioma_micro-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["maturin>=1.5,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "bioma_micro"
+description = "B.I.O.M.A. Micro-Kernel — lock-free hormonal bus + autonomous context apoptosis."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "LicenseRef-FSL-1.1-MIT" }
+authors = [{ name = "Jonathas Cordeiro", email = "jonathas.cordeiro2023@gmail.com" }]
+keywords = ["llm", "context-window", "prompt-compression", "token-optimization", "agents", "rust", "pyo3"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Programming Language :: Rust",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dynamic = ["version"]
+
+[project.urls]
+Repository = "https://github.com/jonathascordeiro20/bioma-framework"
+Changelog = "https://github.com/jonathascordeiro20/bioma-framework/blob/main/CHANGELOG.md"
+
+[tool.maturin]
+features = ["pyo3/extension-module", "pyo3/abi3-py38"]

bioma_micro-1.0.0/src/context_apoptosis.rs

@@ -0,0 +1,258 @@
+//! `context_apoptosis.rs` — autonomous history dehydration.
+//!
+//! Long agent sessions (audit logs, massive chats) accumulate low-value ballast:
+//! verbose tool output, stale turns, resolved chatter. This engine assigns each
+//! message a **metabolic weight** by class, applies an aggressive **half-life
+//! decay** (older + lower-value → drains faster), and **purges** any block whose
+//! oxygen falls below the safe threshold — before the payload is dispatched to the
+//! API. Durable classes (SYSTEM, FACT) are reinforced and never purged.
+//!
+//! Result: the input context window is dehydrated (universal input-token savings)
+//! with a pure-Rust, thread-safe, allocation-light pass.
+
+use std::collections::hash_map::DefaultHasher;
+use std::collections::HashSet;
+use std::hash::{Hash, Hasher};
+use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::Mutex;
+use std::time::Instant;
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+// Metabolic signal classes (bitwise flags shared with the Python layer).
+pub const SYSTEM: u32 = 1 << 0; // durable instructions — never purge
+pub const USER: u32 = 1 << 1; // user turns
+pub const ASSISTANT: u32 = 1 << 2; // model turns
+pub const FACT: u32 = 1 << 3; // retrieved facts / decisions to keep
+pub const TOOL: u32 = 1 << 4; // verbose tool logs / scratchpad — prime target
+const PROTECTED: u32 = SYSTEM | FACT;
+
+/// ~4 chars/token — identical to the Python side so 'full' and 'pruned' counts agree.
+#[inline]
+pub fn est_tokens(s: &str) -> u32 {
+    ((s.len() / 4) + 1) as u32
+}
+
+/// Initial metabolic weight (oxygen) by signal class. Durable data start rich;
+/// verbose tool output starts oxygen-poor and dehydrates first.
+#[inline]
+fn metabolic_weight(signal: u32) -> f32 {
+    if signal & PROTECTED != 0 {
+        4.0
+    } else if signal & (USER | ASSISTANT) != 0 {
+        1.0
+    } else if signal & TOOL != 0 {
+        0.25
+    } else {
+        0.6
+    }
+}
+
+struct Cell {
+    content: String,
+    oxygen: f32,
+    signal: u32,
+    tokens: u32,
+}
+
+// --------------------------------------------------------------------------- //
+//  ContextApoptosis — stateful, incremental engine
+// --------------------------------------------------------------------------- //
+/// A self-dehydrating context window. Insert blocks, then run `dehydrate` cycles;
+/// each cycle halves oxygen over `half_life` and purges anything below the
+/// `safe_threshold` (durable classes are reinforced and survive).
+#[pyclass]
+pub struct ContextApoptosis {
+    half_life: f32,
+    safe_threshold: f32,
+    items: Mutex<Vec<Cell>>,
+    inserted_tokens: AtomicU64,
+    apoptosed_tokens: AtomicU64,
+    apoptosed_count: AtomicU64,
+}
+
+#[pymethods]
+impl ContextApoptosis {
+    #[new]
+    #[pyo3(signature = (half_life = 2.0, safe_threshold = 0.35, capacity = 256))]
+    fn new(half_life: f32, safe_threshold: f32, capacity: usize) -> Self {
+        Self {
+            half_life: half_life.max(0.1),
+            safe_threshold,
+            items: Mutex::new(Vec::with_capacity(capacity)),
+            inserted_tokens: AtomicU64::new(0),
+            apoptosed_tokens: AtomicU64::new(0),
+            apoptosed_count: AtomicU64::new(0),
+        }
+    }
+
+    /// Insert a context block. `oxygen < 0` (default) → auto metabolic weight.
+    #[pyo3(signature = (content, signal = 0, oxygen = -1.0))]
+    fn insert(&self, content: String, signal: u32, oxygen: f32) {
+        let tokens = est_tokens(&content);
+        self.inserted_tokens.fetch_add(tokens as u64, Ordering::Relaxed);
+        let oxy = if oxygen < 0.0 { metabolic_weight(signal) } else { oxygen };
+        self.items.lock().unwrap().push(Cell { content, oxygen: oxy, signal, tokens });
+    }
+
+    /// One half-life decay cycle → returns the number of purged blocks. Durable
+    /// classes are reinforced by `reinforce_boost`; everything else decays by
+    /// `2^(-1/half_life)` and is purged in place if it drops below the threshold.
+    #[pyo3(signature = (reinforce_boost = 0.5))]
+    fn dehydrate(&self, py: Python<'_>, reinforce_boost: f32) -> usize {
+        let factor = 2f32.powf(-1.0 / self.half_life);
+        let eps = self.safe_threshold;
+        py.allow_threads(|| {
+            let mut items = self.items.lock().unwrap();
+            for c in items.iter_mut() {
+                if c.signal & PROTECTED != 0 {
+                    c.oxygen += reinforce_boost;
+                } else {
+                    c.oxygen *= factor;
+                }
+            }
+            let before = items.len();
+            let mut freed: u64 = 0;
+            items.retain(|c| {
+                let alive = (c.signal & PROTECTED != 0) || c.oxygen >= eps;
+                if !alive {
+                    freed += c.tokens as u64;
+                }
+                alive
+            });
+            let purged = before - items.len();
+            self.apoptosed_count.fetch_add(purged as u64, Ordering::Relaxed);
+            self.apoptosed_tokens.fetch_add(freed, Ordering::Relaxed);
+            purged
+        })
+    }
+
+    fn active_context(&self) -> Vec<String> {
+        self.items.lock().unwrap().iter().map(|c| c.content.clone()).collect()
+    }
+    /// The dehydrated context, newline-joined, ready to dispatch.
+    fn render(&self) -> String {
+        self.items.lock().unwrap().iter().map(|c| c.content.as_str()).collect::<Vec<_>>().join("\n")
+    }
+    fn active_tokens(&self) -> u64 {
+        self.items.lock().unwrap().iter().map(|c| c.tokens as u64).sum()
+    }
+    fn inserted_tokens(&self) -> u64 {
+        self.inserted_tokens.load(Ordering::Relaxed)
+    }
+    fn __len__(&self) -> usize {
+        self.items.lock().unwrap().len()
+    }
+    /// Fraction of inserted tokens reclaimed by apoptosis (0..1).
+    fn reduction_ratio(&self) -> f32 {
+        let ins = self.inserted_tokens();
+        if ins == 0 { 0.0 } else { self.apoptosed_tokens.load(Ordering::Relaxed) as f32 / ins as f32 }
+    }
+}
+
+// --------------------------------------------------------------------------- //
+//  dehydrate() — the one-shot stateless filter used by the OpenRouter client
+// --------------------------------------------------------------------------- //
+/// Dehydrate a whole message history in a single pass (oldest → newest).
+///
+/// `messages` is a list of `(content, signal_flags)`. Older, lower-value blocks
+/// are decayed by recency-weighted half-life and purged below `safe_threshold`;
+/// durable classes (SYSTEM, FACT) always survive. Returns the surviving blocks
+/// plus audited savings and the pure-kernel latency in microseconds.
+#[pyfunction]
+#[pyo3(signature = (messages, half_life = 6.0, safe_threshold = 0.35))]
+pub fn dehydrate<'py>(
+    py: Python<'py>,
+    messages: Vec<(String, u32)>,
+    half_life: f32,
+    safe_threshold: f32,
+) -> PyResult<Bound<'py, PyDict>> {
+    let hl = half_life.max(0.1);
+    let n = messages.len();
+
+    // --- the measured kernel hot-path: decide survivors (pure compute, GIL released) ---
+    let t0 = Instant::now();
+    let decisions: Vec<bool> = py.allow_threads(|| {
+        let mut keep = Vec::with_capacity(n);
+        for (i, (content, signal)) in messages.iter().enumerate() {
+            let protected = signal & PROTECTED != 0;
+            if protected {
+                keep.push(true);
+                continue;
+            }
+            let age = (n - 1 - i) as f32; // 0 = newest
+            let oxygen = metabolic_weight(*signal) * 2f32.powf(-age / hl);
+            let _ = content; // content length already priced into tokens below
+            keep.push(oxygen >= safe_threshold);
+        }
+        keep
+    });
+    let latency_us = t0.elapsed().as_nanos() as f64 / 1000.0;
+
+    // --- marshal survivors + audit token savings (not counted in kernel latency) ---
+    let kept = pyo3::types::PyList::empty_bound(py);
+    let mut tokens_before: u64 = 0;
+    let mut tokens_after: u64 = 0;
+    let mut purged: usize = 0;
+    for ((content, _sig), &alive) in messages.iter().zip(decisions.iter()) {
+        let tok = est_tokens(content) as u64;
+        tokens_before += tok;
+        if alive {
+            tokens_after += tok;
+            kept.append(content)?;
+        } else {
+            purged += 1;
+        }
+    }
+    let reduction = if tokens_before == 0 {
+        0.0
+    } else {
+        1.0 - (tokens_after as f64 / tokens_before as f64)
+    };
+
+    let d = PyDict::new_bound(py);
+    d.set_item("kept", kept)?;
+    d.set_item("blocks_in", n)?;
+    d.set_item("blocks_kept", n - purged)?;
+    d.set_item("blocks_purged", purged)?;
+    d.set_item("tokens_before", tokens_before)?;
+    d.set_item("tokens_after", tokens_after)?;
+    d.set_item("reduction", reduction)?;
+    d.set_item("kernel_latency_us", latency_us)?;
+    Ok(d)
+}
+
+// --------------------------------------------------------------------------- //
+//  saturation_scan() — cognitive-DDoS / flood detector
+// --------------------------------------------------------------------------- //
+/// Detect input saturation: the fraction of the payload that is **repetition**.
+///
+/// Cognitive-DDoS, forged-log floods and jailbreak spam are highly repetitive —
+/// they reuse the same phrases to exhaust the context window. This scores the
+/// fraction of duplicate `w`-token shingles (default 8): ~1.0 = a repetitive
+/// flood (RED ALERT), ~0.0 = natural, high-entropy text. Pure O(n), no
+/// allocation (shingles are hashed, not materialised), microsecond-scale.
+#[pyfunction]
+#[pyo3(signature = (text, window = 8))]
+pub fn saturation_scan(text: &str, window: usize) -> f32 {
+    let w = window.max(1);
+    let tokens: Vec<&str> = text.split_whitespace().collect();
+    let n = tokens.len();
+    if n < w * 2 {
+        return 0.0;
+    }
+    let windows = n - w + 1;
+    let mut seen: HashSet<u64> = HashSet::with_capacity(windows);
+    let mut dupes = 0usize;
+    for i in 0..windows {
+        let mut h = DefaultHasher::new();
+        for t in &tokens[i..i + w] {
+            t.hash(&mut h);
+        }
+        if !seen.insert(h.finish()) {
+            dupes += 1;
+        }
+    }
+    dupes as f32 / windows as f32
+}

bioma_micro-1.0.0/src/hormonal_bus.rs

@@ -0,0 +1,205 @@
+//! `hormonal_bus.rs` — the lock-free in-memory signalling substrate.
+//!
+//! A fixed bank of atomic `f32` concentration cells (one per signal channel) is
+//! updated with lock-free CAS loops, so `inject`/`sense` never take a lock and the
+//! GIL is released on the hot path. Signal *events* are additionally fanned out
+//! through a bounded `crossbeam-channel` for consumers that want the stream.
+//!
+//! Design target (measured on the reference host): ~2M signals/s at ~5μs mean
+//! latency, bounded under 10× concurrent load. See `tests/`.
+
+use std::collections::HashMap;
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
+use std::sync::Arc;
+
+use crossbeam_channel::{bounded, Receiver, Sender};
+use pyo3::prelude::*;
+
+// --------------------------------------------------------------------------- //
+//  Lock-free atomic f32 cells (concentration stored as its IEEE-754 bit pattern)
+// --------------------------------------------------------------------------- //
+#[inline(always)]
+fn add_f32(cell: &AtomicU32, delta: f32) {
+    let mut cur = cell.load(Ordering::Relaxed);
+    loop {
+        let new = f32::from_bits(cur) + delta;
+        match cell.compare_exchange_weak(cur, new.to_bits(), Ordering::AcqRel, Ordering::Relaxed) {
+            Ok(_) => break,
+            Err(actual) => cur = actual,
+        }
+    }
+}
+#[inline(always)]
+fn mul_f32(cell: &AtomicU32, factor: f32) {
+    let mut cur = cell.load(Ordering::Relaxed);
+    loop {
+        let new = f32::from_bits(cur) * factor;
+        match cell.compare_exchange_weak(cur, new.to_bits(), Ordering::AcqRel, Ordering::Relaxed) {
+            Ok(_) => break,
+            Err(actual) => cur = actual,
+        }
+    }
+}
+#[inline(always)]
+fn load_f32(cell: &AtomicU32) -> f32 {
+    f32::from_bits(cell.load(Ordering::Relaxed))
+}
+#[inline(always)]
+fn valid_mask(n: usize) -> u32 {
+    if n >= 32 { u32::MAX } else { (1u32 << n) - 1 }
+}
+
+// --------------------------------------------------------------------------- //
+//  HormonalSignal — the lightweight payload on the wire
+// --------------------------------------------------------------------------- //
+/// A single hormonal signal: bitwise channel `flags` (`u32`) + `intensity` (`f32`).
+#[pyclass]
+#[derive(Clone, Copy)]
+pub struct HormonalSignal {
+    #[pyo3(get, set)]
+    pub flags: u32,
+    #[pyo3(get, set)]
+    pub intensity: f32,
+}
+
+#[pymethods]
+impl HormonalSignal {
+    #[new]
+    #[pyo3(signature = (flags, intensity = 1.0))]
+    fn new(flags: u32, intensity: f32) -> Self {
+        Self { flags, intensity }
+    }
+    fn __repr__(&self) -> String {
+        format!("HormonalSignal(flags=0x{:X}, intensity={:.3})", self.flags, self.intensity)
+    }
+}
+
+// --------------------------------------------------------------------------- //
+//  BusCore — the shareable, lock-free core
+// --------------------------------------------------------------------------- //
+struct BusCore {
+    conc: Box<[AtomicU32]>,
+    n: usize,
+    secretions: AtomicU64,
+}
+
+impl BusCore {
+    fn new(n: usize) -> Self {
+        let conc = (0..n).map(|_| AtomicU32::new(0)).collect::<Vec<_>>().into_boxed_slice();
+        Self { conc, n, secretions: AtomicU64::new(0) }
+    }
+    #[inline(always)]
+    fn secrete(&self, flags: u32, intensity: f32) {
+        let mut f = flags & valid_mask(self.n);
+        while f != 0 {
+            let bit = f.trailing_zeros() as usize;
+            add_f32(&self.conc[bit], intensity);
+            f &= f - 1;
+        }
+        self.secretions.fetch_add(1, Ordering::Relaxed);
+    }
+    #[inline(always)]
+    fn sense(&self, mask: u32) -> f32 {
+        let mut acc = 0.0f32;
+        let mut m = mask & valid_mask(self.n);
+        while m != 0 {
+            let bit = m.trailing_zeros() as usize;
+            acc += load_f32(&self.conc[bit]);
+            m &= m - 1;
+        }
+        acc
+    }
+    fn tick(&self, decay: f32) {
+        for c in self.conc.iter() {
+            mul_f32(c, decay);
+        }
+    }
+    fn snapshot(&self) -> Vec<f32> {
+        self.conc.iter().map(load_f32).collect()
+    }
+    fn total(&self) -> f32 {
+        self.conc.iter().map(load_f32).sum()
+    }
+}
+
+// --------------------------------------------------------------------------- //
+//  HormonalBus — the Python-facing signalling bus
+// --------------------------------------------------------------------------- //
+/// Lock-free hormonal signalling bus. `inject`/`secrete` are O(popcount) and
+/// release the GIL; `sense` reads the current concentration for a channel mask.
+#[pyclass]
+pub struct HormonalBus {
+    core: Arc<BusCore>,
+    tx: Sender<(u32, f32)>,
+    rx: Receiver<(u32, f32)>,
+}
+
+#[pymethods]
+impl HormonalBus {
+    #[new]
+    #[pyo3(signature = (num_signals = 32, event_capacity = 4096))]
+    fn new(num_signals: usize, event_capacity: usize) -> Self {
+        let n = num_signals.clamp(1, 32);
+        let (tx, rx) = bounded(event_capacity.max(1));
+        Self { core: Arc::new(BusCore::new(n)), tx, rx }
+    }
+
+    /// Inject a typed `HormonalSignal` (the primary API).
+    fn inject(&self, py: Python<'_>, signal: HormonalSignal) {
+        py.allow_threads(|| {
+            self.core.secrete(signal.flags, signal.intensity);
+            let _ = self.tx.try_send((signal.flags, signal.intensity));
+        });
+    }
+
+    /// Raw injection by `(flags, intensity)` — the microsecond hot path.
+    fn secrete(&self, py: Python<'_>, flags: u32, intensity: f32) {
+        py.allow_threads(|| {
+            self.core.secrete(flags, intensity);
+            let _ = self.tx.try_send((flags, intensity));
+        });
+    }
+
+    /// Current summed concentration across every channel in `mask`.
+    fn sense(&self, py: Python<'_>, mask: u32) -> f32 {
+        py.allow_threads(|| self.core.sense(mask))
+    }
+
+    /// Concentration of a single channel bit.
+    fn concentration(&self, signal_bit: usize) -> f32 {
+        if signal_bit < self.core.n {
+            load_f32(&self.core.conc[signal_bit])
+        } else {
+            0.0
+        }
+    }
+
+    /// Multiplicative decay/dissipation of every channel (temporal homeostasis).
+    fn tick(&self, py: Python<'_>, decay: f32) {
+        py.allow_threads(|| self.core.tick(decay));
+    }
+
+    fn snapshot(&self) -> Vec<f32> {
+        self.core.snapshot()
+    }
+
+    /// Drain up to `max` buffered signal events as `(flags, intensity)` pairs.
+    fn drain_events(&self, max: usize) -> Vec<(u32, f32)> {
+        let mut out = Vec::new();
+        while out.len() < max {
+            match self.rx.try_recv() {
+                Ok(e) => out.push(e),
+                Err(_) => break,
+            }
+        }
+        out
+    }
+
+    fn stats(&self) -> HashMap<String, f64> {
+        let mut m = HashMap::new();
+        m.insert("num_signals".into(), self.core.n as f64);
+        m.insert("secretions".into(), self.core.secretions.load(Ordering::Relaxed) as f64);
+        m.insert("total_concentration".into(), self.core.total() as f64);
+        m
+    }
+}

bioma_micro-1.0.0/src/lib.rs

@@ -0,0 +1,40 @@
+//! B.I.O.M.A. Micro-Kernel — a lean efficiency & resilience core for LLM infra.
+//!
+//! Lean topology: exactly two proven primitives, nothing else.
+//!   * [`hormonal_bus`]       — lock-free in-memory signal injection (~2M sig/s, ~5μs).
+//!   * [`context_apoptosis`]  — autonomous history dehydration (universal input-token savings).
+//!
+//! No agents, no mitosis, no orchestration — only the microsecond hot path and the
+//! apoptosis filter, exposed to Python via PyO3.
+
+mod context_apoptosis;
+mod hormonal_bus;
+
+use pyo3::prelude::*;
+use pyo3::wrap_pyfunction;
+
+use context_apoptosis::{dehydrate, saturation_scan, ContextApoptosis};
+use hormonal_bus::{HormonalBus, HormonalSignal};
+
+/// The native module — `import bioma_micro`.
+#[pymodule]
+fn bioma_micro(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    // Signal injection
+    m.add_class::<HormonalBus>()?;
+    m.add_class::<HormonalSignal>()?;
+    // Apoptosis filter
+    m.add_class::<ContextApoptosis>()?;
+    m.add_function(wrap_pyfunction!(dehydrate, m)?)?;
+    m.add_function(wrap_pyfunction!(saturation_scan, m)?)?;
+
+    // Metabolic signal classes (bitwise flags) for the Python layer.
+    m.add("SYSTEM", context_apoptosis::SYSTEM)?;
+    m.add("USER", context_apoptosis::USER)?;
+    m.add("ASSISTANT", context_apoptosis::ASSISTANT)?;
+    m.add("FACT", context_apoptosis::FACT)?;
+    m.add("TOOL", context_apoptosis::TOOL)?;
+
+    m.add("__doc__", "B.I.O.M.A. Micro-Kernel — lock-free hormonal bus + context apoptosis.")?;
+    m.add("__version__", "1.0.0")?;
+    Ok(())
+}