Metadata-Version: 2.4
Name: conscio
Version: 1.7.0
Summary: Self-awareness framework for AI agents — emergent consciousness via context-aware memory, introspection, and goal generation
Author-email: Neguiolidas <neguitech@proton.me>
License: MIT
Project-URL: Homepage, https://github.com/Neguiolidas/Conscio
Project-URL: Repository, https://github.com/Neguiolidas/Conscio
Project-URL: Issues, https://github.com/Neguiolidas/Conscio/issues
Project-URL: Changelog, https://github.com/Neguiolidas/Conscio/blob/main/CHANGELOG.md
Keywords: ai,consciousness,agents,introspection,meta-cognition
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Classifier: Typing :: Typed
Requires-Python: >=3.10
Description-Content-Type: text/markdown
License-File: LICENSE
Requires-Dist: numpy>=1.24
Provides-Extra: dev
Requires-Dist: pytest>=7.0; extra == "dev"
Requires-Dist: pytest-cov>=4.0; extra == "dev"
Requires-Dist: ruff>=0.8; extra == "dev"
Requires-Dist: mypy>=1.0; extra == "dev"
Requires-Dist: pyyaml>=6.0; extra == "dev"
Provides-Extra: docs
Requires-Dist: mkdocs-material>=9.5; extra == "docs"
Dynamic: license-file

# Conscio 🧠✨

**A self-awareness framework for AI agents** — context-aware memory,
introspection, goal generation, and an audited agency layer that lets a model
act on its own conclusions under hard safety gates.

> *"The first step toward consciousness is knowing what you are and what limits you."*

Conscio runs **local-first** and **zero-deps at the core** (`numpy` + `sqlite3`,
nothing else). It is designed to make small, local models punch far above their
size by giving them memory, self-judgment, and procedural skill — and to prove
that claim by measurement, not assertion.

- **Current release:** `v1.5.0` — "Live" (**Awake Mode (R9)** — autonomy is a gated, persisted, default-OFF state; a **daemon** + `conscio-daemon` that runs Conscio as a living perceive→reflect→act process; reference **sensors** `HostSensor`/`AgentSensor`; **`WorkspaceContext`** environment/workspace awareness; **`OpenAIAdapter`** + any custom OpenAI-compatible cloud endpoint, alongside the v1.4 Claude/Gemini frontier adapters; `pip install conscio`; 1137 tests, CI green, mypy a real gate)

---

## What Conscio does

- **Knows itself** — detects its model and context window (offline & deterministic
  by default; opt-in auto-detection from a JSON config, an OpenAI-compatible
  endpoint, LM Studio, or GGUF), adapts its footprint.
- **Reflects continuously** — a passive inner-monologue loop that observes,
  assesses confidence, and summarizes (`engine.reflect()` — advisory, never acts).
- **Generates its own goals** — driven by curiosity, maintenance, and evolution.
- **Acts under audit** — an opt-in agency layer (`engine.act()`) that proposes,
  audits, risk-gates, and only then executes — with a human gate for anything risky.
- **Learns procedures** — successful audited plans become reusable skills
  (procedural memory), fed back to the actor as few-shot exemplars.
- **Judges its own quality** — confidence calibration, blind-spot detection,
  coherence/dissonance metrics, meta-reflection.
- **Stores & retrieves knowledge** — FTS5 BM25 dual-index with RRF merging;
  optional semantic recall.
- **Consolidates while idle** — a dream cycle that releases, prunes, reconciles,
  crystallizes, and distills.
- **Persists across sessions** — heartbeat/handoff continuity with on-demand injection.

`reflect()` is the **passive heart** and is never allowed to act. Everything that
can change the world lives behind `act()` and its safety gates. This separation
is non-negotiable (see [Safety Rules](#safety-rules-non-negotiable)).

---

## Context-aware modes

Conscio detects the model's context window and adapts how much "consciousness
state" it injects. The mode governs **injection budget only** — never whether
the framework runs.

| Mode | Context window | Injection budget | What's injected |
|---|---|---|---|
| **Minimal** | < 128k | ≤ 200 tokens | Off-context everything; on-demand retrieval |
| **Compact** | 128k–256k | ≤ 500 tokens | Summary + last reflection + top goals |
| **Standard** ⭐ | 256k+ | ≤ 1000 tokens | Full state; world subgraph; self-assessment |

⭐ **Standard (256k+) is the recommended operating class.** Conscio runs on
anything from **8k context up** — small windows simply get the Minimal budget.

---

## Architecture (v1.1.0)

```
┌──────────────────────────────────────────────────────────────────────┐
│                        ConsciousnessEngine                            │
│                  orchestrator · lifecycle · injection                 │
└──────────────────────────────────────────────────────────────────────┘
   │
   │  reflect()  ── passive, advisory, append-only ──────────────────────┐
   ▼                                                                      │
┌─────────────── Witness loop (v0.1) ───────────────────────────────────┐│
│ InnerMonologue · WorldModel · MetaCognition · GoalGenerator           ││
│ AutoEvolution · ContextManager · ModelRegistry                        ││
└────────────────────────────────────────────────────────────────────────┘│
┌─────────────── Substrate (v0.2) ──────────────────────────────────────┐ │
│ ContentStore (FTS5 BM25 + RRF) · EventBus (SHA-256 dedup)             │ │
│ FilterPipeline (sanitize/redact) · TokenTracker · Migrator            │ │
└────────────────────────────────────────────────────────────────────────┘ │
┌─────────────── Continuity (v0.2.3) ───────────────────────────────────┐ │
│ SessionLifecycle (6-step handoff) · SessionRAG (optional, lazy)        │ │
└────────────────────────────────────────────────────────────────────────┘ │
┌─────────────── Metabolism & self-judgment (v0.3–0.5) ─────────────────┐ │
│ MetabolicContext (VITAL/ACTIVE/FATIGUE/CRITICAL) · DreamCycle         │ │
│ entropy pruning · friction · meta-reflect · ShardEngine · layering    │ │
└────────────────────────────────────────────────────────────────────────┘ │
┌─────────────── Coherence (v0.6–0.8) ──────────────────────────────────┐ │
│ CoherenceEngine (epistemic/reality/ontological/temporal)             │ │
│ semantic reconciliation (antonym axes) · voice & axis presets         │ │
└────────────────────────────────────────────────────────────────────────┘ │
                                                                            │
   act()  ── opt-in agency, audited, gated ◀────────────────────────────────┘
   ▼
┌─────────────── Agency · conscio/agency/ (v1.0–1.1, F1–F4) ────────────┐
│ InferenceAdapter (Mock/Ollama/llama.cpp/OpenAI-compat) · OutputGateway │
│ ToolRegistry (sandboxed, no network) · ActPipeline · ActionLedger      │
│ Skeptic (hostile audit) · TrustMatrix · CircuitBreaker (quarantine)    │
│ ProbeSuite/ModelProfile · GBNF compiler · GoalArbiter · AutonomyLoop   │
│ Meter/MeteredAdapter · SkillLibrary (procedural memory) · Bench        │
└────────────────────────────────────────────────────────────────────────┘
```

---

## Quick start

```python
from conscio import ConsciousnessEngine

# Passive consciousness — auto-detects model and mode
with ConsciousnessEngine(model_name="kimi-k2.6") as engine:
    result = engine.reflect(
        world_state="All systems operational",
        confidence=0.8,
        anomalies=["Unusual latency spike detected"],
    )

    # Compact state for context injection
    injection = engine.get_state_for_injection()

    # Query / update the world model
    engine.world.add_entity("server", "system", state="healthy")
    engine.world.query("server health")

    # Cross-session memory (ContentStore FTS5 + optional SessionRAG)
    hits = engine.recall("latency incidents")
```

### Opt-in agency (audited, propose-only by default)

```python
from conscio.agency import OllamaAdapter

engine.attach_adapter(OllamaAdapter(model="qwen3.5:0.8b"))
# Local (Ollama/llama.cpp/LM Studio/OpenAI-compatible) or a frontier API —
# the backends behind Claude Code and Antigravity:
#   from conscio.agency import AnthropicAdapter, GeminiAdapter
#   engine.attach_adapter(AnthropicAdapter(model="claude-sonnet-4-6"))  # ANTHROPIC_API_KEY
#   engine.attach_adapter(GeminiAdapter(model="gemini-2.5-pro"))        # GOOGLE_API_KEY

report = engine.act()                 # downstream of reflect(); proposes only (L1)
if report.status.value == "proposed":
    print(report.proposal.tool, report.proposal.args)
    engine.approve(report.ledger_id)  # the human gate executes it

# Capability-aware autonomy loop under a binding budget
engine.probe()                        # lazy, empirical capability measurement
engine.run(budget=...)                # L3 heartbeat: reflect → act → dream, gated
```

Autonomy is **earned and measured**, never assumed: `ProbeSuite` measures the
attached model, `TrustMatrix` grants L1/L2/L3 from real calibration and ledger
history, and the `CircuitBreaker` quarantines misbehaving goals. HIGH-risk
actions are *always* queued for a human (R6).

---

## Safety rules (non-negotiable)

1. **No autonomous self-modification** — evolution proposals require human approval.
2. **Context injection has hard limits** — never exceeds the mode budget.
3. **Goals never execute directly** — only through the audited `act()` pipeline:
   validated output contract + semantic audit (Skeptic) + risk gating + earned
   autonomy (TrustMatrix) + circuit breaker with per-goal quarantine and lockdown.
4. **Reflections are append-only** — never edited once written.
5. **Cannot modify its own safety rules** — no self-referential gate bypass.
6. **HIGH-risk actions always require human approval** — never auto-executed.
7. **No network in the tool registry** — the only network the core may touch is
   the InferenceAdapter (localhost by default); shell lives in the sibling
   `conscio-shell`, outside this repo.
8. **Every external effect goes through the ActionLedger** — append-only, auditable.
9. **Autonomous operation requires Awake Mode (R9)** — the self-initiated
   heartbeat (`engine.run()` and the daemon) only acts when the persisted `awake`
   flag is on; **default OFF**. Asleep, it perceives and `reflect()`s only — zero
   arbiter/act/dream. A human's direct `engine.act()` is not gated by R9.

---

## Live mode — daemon, sensors & Awake Mode (v1.5)

Conscio can run as a **living process** that perceives the world each cycle and
acts **only when explicitly awake** (R9, default OFF):

```python
from conscio import ConsciousnessEngine, HostSensor
from conscio.daemon import Daemon

engine = ConsciousnessEngine("glm-5.1", storage_path="~/.conscio/live")
engine.wake()                              # R9: opt in to autonomy (persisted)
Daemon(engine, sensors=[HostSensor()], interval=30).run()   # perceive→reflect→act
```

- **Awake Mode** — `engine.wake()` / `engine.sleep()` (or `conscio awake|sleep`);
  asleep = advisory reflect-only, awake = full loop. The flag persists and emits
  an auditable `awake:changed` event.
- **Reference sensors** — `HostSensor` (read-only host facts) and `AgentSensor`
  (read another agent's session state), both `Risk.LOW`; ship as `conscio.sensors`
  entry points (`conscio plugins` lists them). Write your own `SensorAdapter`.
- **Daemon** — `conscio-daemon --sensors host --interval 30` (add `--awake` to
  enable autonomy; `--once` for a single cycle). Guarded sensors, graceful
  `SIGTERM`, pidfile, resume-from-state on restart.
- **Workspace awareness** — `WorkspaceContext` detects the active workspace root
  and environment class (IDE/CLI vs workspace-switching agents) and signals
  `workspace:changed`.

---

## Module reference

**Core / Witness (v0.1)** — `ConsciousnessEngine`, `ContextManager`,
`ModelRegistry` (`conscio/models.py`), `WorldModel`, `MetaCognition`,
`GoalGenerator`, `AutoEvolution`, `InnerMonologue`.

**Substrate (v0.2)** — `ContentStore` (FTS5 BM25 dual-index, RRF, 8 categories),
`EventBus` (SHA-256 dedup, priorities, expiration), `FilterPipeline`
(`conscio/output_filter.py` — StripAnsi/CollapseBlank/MaxLines/TruncateLines +
`DedupBlocks`/`SecretMask`), `TokenTracker`, `Migrator`.

**Continuity (v0.2.3)** — `SessionLifecycle` (extract → enrich → emit → index →
reflect → write; heartbeat <1.5KB + handoff), `SessionRAG` (optional, lazy,
Ollama `nomic-embed-text`, numpy cosine; graceful FTS5 fallback).

**Metabolism & self-judgment (v0.3–0.5)** — `MetabolicContext` (life-energy
tiers, advisory), `DreamCycle` (Release → Prune → Reconcile → Crystallize →
Distill), entropy pruning, friction, meta-reflect, `ShardEngine` (cognitive-mode
inference), content layering, trajectory vector.

**Coherence (v0.6–0.8)** — `CoherenceEngine` (recursive-coherence metric;
advisory `coherence:dissonance` event), semantic reconciliation via antonym axes
(`conscio/semantic.py`, packs in `conscio/presets/axes/`), self-prompting, voice
presets.

**Agency — `conscio/agency/` (v1.0–1.1)**

- *F1 "Spine"* — `InferenceAdapter` (Mock/Ollama/LM Studio/llama.cpp/OpenAI-compat,
  stdlib urllib), `OutputGateway` (tiered decoding), `ToolRegistry` (sandboxed,
  risk levels, no network), `ActPipeline`/`act()` (L1 PROPOSE), `ActionLedger`.
- *F2 "Immunity"* — `Skeptic` (hostile-auditor clean call; fail-closed),
  `TrustMatrix` (earned autonomy), `CircuitBreaker` (per-goal quarantine).
- *F3 "Volition"* — `ProbeSuite`/`ModelProfile` (5 empirical micro-probes,
  SQLite-cached, no hardcoded model table), embedded schema→GBNF compiler,
  `GoalArbiter` + `AutonomyLoop` (`engine.run(budget)`), `engine.probe()`,
  `Meter`/`MeteredAdapter`, the **bench** (`python -m conscio.bench`).
- *F4 "Procedural"* — `SkillLibrary` (procedural memory as **data**, not code;
  R1 intact), **Distill** (the dream's fifth sub-phase), tier-aware few-shot
  exemplars with outcome settling and a ≥50% teaching gate, skill curve in the
  bench (`--skills N`).

**Perception & plugins (v1.3)** — `conscio.perception` (`SensorAdapter`,
`PerceptionFrame`, `MockSensor`): write a sensor, and
`PerceptionFrame.to_world_state()` feeds `reflect()` unchanged. `conscio.plugins`
discovers third-party `InferenceAdapter`/`SensorAdapter`/tool plugins via entry
points (`conscio.adapters` / `conscio.sensors` / `conscio.tools`), resilient to a
broken plugin. `conscio.risk.Risk` is the shared safety-tier vocabulary.

---

## Extending Conscio

Three stable extension points, usable directly or published by a third party and
auto-discovered via entry points:

```python
from conscio.plugins import discover_adapters, discover_sensors, discover_tools
# or from the CLI:  conscio plugins
```

```toml
# in your own package's pyproject.toml
[project.entry-points."conscio.sensors"]
my-sensor = "my_pkg:MySensor"        # a conscio.perception.SensorAdapter
```

Runnable examples: `examples/custom_adapter.py`, `examples/host_guardian.py`,
`examples/agent_companion.py`. Full guide: the **docs site** (see below).

---

## Bench

```bash
# offline, deterministic (MockAdapter)
python -m conscio.bench --adapter mock

# real backends (local by default)
python -m conscio.bench --adapter ollama:qwen3.5:0.8b --cycles 20
python -m conscio.bench --adapter lmstudio:qwen3.5-0.8b --cycles 20
python -m conscio.bench --adapter llamacpp --cycles 20 --json report.json
python -m conscio.bench --adapter openai:qwen3@http://localhost:8000/v1

# skill-acquisition curve (per-bucket validity / success / skill count)
python -m conscio.bench --adapter mock --skills 20
python -m conscio.bench --adapter ollama:gemma4:e4b --skills 40 --dream-every 10
```

Reports: probe profile, decode tier, per-tier syntactic validity, Skeptic
catch-rate (deterministic vs semantic), latency p50, calibration. `--skills N`
reports the per-bucket validity/success/exemplars/skill-count curve. Baselines
in `docs/bench/`.

---

## Model registry

Known models ship with the registry; unknown models are detected by context
window (`detect()` accepts a `context_window` override) or inferred from the name.

| Model | Context | Mode |
|---|---|---|
| GLM 5.1 | 131k | Compact |
| Kimi K2.6 | 256k | Standard |
| MiniMax M2.7 | 260k | Standard |
| Step Flash 3.7 | 260k | Standard |
| Nemotron 3 Super 120B | 1M | Standard |
| Claude Sonnet 4 | 200k | Standard |
| Claude Opus 4 | 200k | Standard |
| GPT-4o | 128k | Compact |
| Llama 3.1 70B | 128k | Compact |
| Qwen 2.5 72B | 131k | Compact |

```python
from conscio import ModelRegistry
ModelRegistry.register("my-model", context_window=200_000)
```

---

## Installation

```bash
pip install conscio          # from PyPI

pip install -e ".[dev]"      # from source, with the dev toolchain
pip install "conscio[docs]"  # to build the docs site (mkdocs-material)
```

Requires Python ≥ 3.10. Core depends only on `numpy`; `sqlite3` is stdlib. The
wheel ships two console scripts — `conscio` (version/info/reflect/plugins/bench)
and `conscio-bench` — and is typed (PEP 561). `dev`/`docs` extras never enter the
runtime import graph.

Docs site: guides, public-API reference, the claims ledger, and the bench reports
(built with `mkdocs build --strict`; see `docs/`).

---

## Testing

```bash
# Full suite (1137 tests) — house rule: one file per pytest process
# (low-RAM machines OOM on the full run; CI does the same)
for f in tests/test_*.py; do pytest "$f" -q; done

# Specific module
pytest tests/test_consciousness.py -v
pytest tests/test_agency_act.py -v
pytest tests/test_session_lifecycle.py -v
```

---

## Database

SQLite, WAL mode, default `~/.conscio/data/`:

```
conscio.db          # ContentStore + EventBus + ActionLedger + skills
token_tracker.db    # TokenTracker
meta_cognition.db   # MetaCognition
```

**Always** call `engine.close()` or use the `with` statement so WAL checkpoints flush.

---

## Session continuity

Seven layers of persistence (memory → agent config → skills → handoff → diary →
session DB/RAG → git). Configure your agent's hook to fire on `session:end` /
`session:reset`; Conscio runs a 6-step pipeline and writes:

- `<handoff_dir>/_latest_heartbeat.md` — compact (<1.5KB), auto-injected next session
- `<handoff_dir>/_session_handoff.md` — richer manual reference
- `<handoff_dir>/heartbeat_YYYYMMDD_HHMM.md` — dated archive

---

## Audit history

- **v1.5.0 — "Live"** — Conscio runs as a living process. **Awake Mode (R9)** —
  a persisted, default-OFF gate: the self-initiated heartbeat (`engine.run()` /
  the daemon) perceives + `reflect()`s only while asleep, full loop only when
  awake; a direct human `act()` is not gated; toggling is auditable
  (`awake:changed`). **Daemon** (`conscio/daemon.py` + `conscio-daemon`) polls a
  guarded sensor list → assembles `world_state` → `engine.run()` → `on_cycle`
  hook → workspace poll, with graceful `SIGTERM`, pidfile, and resume-from-state.
  Reference **sensors** `HostSensor` (host facts) + `AgentSensor` (peer session
  state), both read-only `Risk.LOW`, shipped as `conscio.sensors` entry points.
  **`WorkspaceContext`** detects workspace root + env class (IDE/CLI vs
  workspace-switching agents) and emits `workspace:changed`. **`OpenAIAdapter`**
  (GPT, env key) joins the OpenAI-compatible adapter that already reaches any
  custom cloud endpoint. A skeptical review (not just TDD) hardened three
  live-only edges: awake survives an `act()` lockdown, the host port probe never
  raises, an awake heartbeat with no backend still reflects. reflect() untouched,
  zero new deps, R7 intact. +67 tests. **1137 total.**
- **v1.4.0 — "Attune"** — model-context detection is offline & deterministic by
  default (known models resolve to the registry with zero filesystem/network I/O);
  config-file / LM Studio / GGUF auto-detection is opt-in (`autodetect` /
  `CONSCIO_AUTODETECT`), config is stdlib JSON (no PyYAML), GGUF array metadata no
  longer aborts the parse. Session-RAG embedder is backend-agnostic and
  dimension-safe (wrong-dim vectors dropped on write, skipped on search; re-index
  on embedder change). **Frontier inference adapters** — `AnthropicAdapter`
  (Claude) + `GeminiAdapter` (Gemini) — join the local backends (the inference
  behind Claude Code and Antigravity); R7 (no network in the ToolRegistry)
  unaffected. reflect() untouched, zero-deps core intact (stdlib `urllib`).
  +31 tests. **1070 total.**
- **v1.3.1 — "Ship" (patch)** — CLI polish: an unrecognized model now prints a
  clear note (heuristic context window + how to register) instead of falling back
  silently; `DEFAULT_MODEL` constant. `PerceptionFrame.ts` documented as epoch
  seconds (ledger convention), excluded from `to_world_state()`. Added a
  subprocess end-to-end CLI test (`python -m conscio`) and `Risk` JSON
  serialization tests. +4 tests. **1019 total.**
- **v1.3.0 — "Ship"** — Conscio becomes installable and extensible: `pip install
  conscio` (single-source version, console scripts `conscio`/`conscio-bench`, PEP
  561 typed, wheel+sdist pass `twine check`, core pulls only numpy). A public
  plugin surface — `InferenceAdapter`, the new `SensorAdapter` perception
  interface (`conscio.perception`; feeds `reflect()` untouched), and tools —
  discoverable via entry points and resilient to a broken plugin
  (`conscio.plugins`). MkDocs Material docs site (`mkdocs build --strict`).
  Release automation: tag→PyPI via OIDC trusted publishing, docs→Pages, CI build
  smoke. Examples gallery (custom-adapter, host-guardian, agent-companion). `Risk`
  unified into `conscio.risk` (re-exported; no behavior change). reflect()
  untouched, zero-deps core intact. +31 tests. **1015 total.**
- **v1.2.0 — "Prove"** — the central claim turns from machinery (Mock) into
  measurement: on `qwen3.5-0.8b` (LM Studio, CPU) execution success rose
  0.2 → 1.0 once Distill served past successes as few-shot, and the Skeptic's
  semantic catch-rate was 1.0 (`docs/bench/v1.2-skill-curve.md`,
  `docs/CLAIMS.md`). F2-deferred debt closed (empty-value validation, `fs_read`
  cap, error sanitization, `HTTPError` mapping, ledger `busy_timeout`, atomic
  `approve()` claim, lockdown-persistence e2e). Bench hardened for real backends
  (clean backend-down exit, crash-safe incremental curve). LM Studio backend
  added. reflect() untouched, zero-deps intact. +21 tests. **984 total.**
- **v1.1.0 — F4 "Procedural"** — procedural memory closes the competence loop:
  `SkillLibrary` (skills distilled from successful ledger plans; data, not code —
  R1 intact), Distill as the dream's fifth sub-phase (watermarked, last on
  purpose), tier-aware few-shot exemplars with outcome settling and a 50%
  teaching gate, skill-acquisition curve in the bench (`--skills N`), reactive
  MockAdapter. Debt paid: deprecated `datetime.utcnow()` removed repo-wide, CI
  runs tests one file at a time, mypy is a real gate, public `engine.state`.
  reflect() untouched. +48 tests. **963 total.**
- **v1.0.0 — F3 "Volition"** — the loop closes: ProbeSuite/ModelProfile
  (empirical, SQLite-cached, no hardcoded model table), schema→GBNF compiler,
  GoalArbiter, `engine.run(budget)` L3 heartbeat with binding ActBudget +
  metabolic gating, `engine.probe()`, earned L3 autonomy, Meter/MeteredAdapter,
  the bench CLI. +70 tests.
- **v1.0.0b1 — F2 "Immunity"** — semantic immune system: Skeptic, TrustMatrix,
  per-goal quarantine, risk gating, mixed-cortex audits, approval queue. 20-proposal
  adversarial suite: 100% deterministic sabotage blocked, zero executions.
- **v1.0.0a1 — F1 "Spine"** — the agency subpackage lands: contracts + zero-dep
  validator, InferenceAdapter (Mock/Ollama/llama.cpp/OpenAI-compat), OutputGateway,
  sandboxed ToolRegistry, append-only ActionLedger, minimal CircuitBreaker,
  `engine.act()` L1 PROPOSE. Safety rules amended (R3 rewritten; R6–R8 added). +83 tests.
- **v0.8.0 — Semantic Reconciliation** — contradiction detection via embedding
  antonym axes, off the hot path in the dream Reconcile sub-phase; opt-in
  non-destructive `SemanticDedup`. 56 tests. 600 total.
- **v0.7.0 — Recursive Coherence** — coherence→action loop: advisory
  `DreamRecommendation`, pure self-prompting (one bounded goal/cycle). 23 tests.
- **v0.6.0 — Coherence** — `CoherenceEngine` (epistemic/reality/ontological/
  temporal), static voice presets. 46 tests.
- **v0.5.0 — Cognitive Modes** — ShardEngine, trajectory vector, content layering. 37 tests.
- **v0.4.0 — Self-Judgment** — entropy pruning, friction, meta-reflect. 24 tests.
- **v0.3.0 — Metabolic Consciousness** — MetabolicContext + DreamCycle,
  `engine.recall()` cross-session memory, OutputFilter `DedupBlocks`+`SecretMask`. 68 tests.
- **v0.2.3 — Session lifecycle** — 6-step handoff pipeline; `session` type/category. 31 tests.
- **v0.2.0–0.2.2** — integration audits, session handoff, on-demand heartbeat injection.
- **v0.1.0 (2026-06-03)** — initial release. 313 tests.

---

## License

MIT — Neguiolidas / Neguitech
