engrammic-primitives 0.1.0__tar.gz

engrammic_primitives-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,54 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --all-extras
+
+      - name: Run linter
+        run: uv run ruff check src tests
+
+      - name: Run type checker
+        run: uv run mypy src
+
+      - name: Run tests
+        run: uv run pytest tests -v
+
+  build:
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Build package
+        run: uv build
+
+      - name: Upload dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/

engrammic_primitives-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,40 @@
+name: Publish to PyPI
+
+on:
+  push:
+    branches: [release]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Build package
+        run: uv build
+
+      - name: Upload dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download dist
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

engrammic_primitives-0.1.0/.github/workflows/release-please.yml

@@ -0,0 +1,43 @@
+name: Release Please
+
+on:
+  push:
+    branches: [main]
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+
+    steps:
+      - uses: googleapis/release-please-action@v4
+        id: release
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+  publish:
+    needs: release-please
+    if: ${{ needs.release-please.outputs.release_created }}
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+
+      - name: Build package
+        run: uv build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

engrammic_primitives-0.1.0/.gitignore

@@ -0,0 +1,63 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+.mypy_cache/
+.ruff_cache/
+.hypothesis/
+coverage.xml
+*.cover
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.envrc
+*.local
+
+# UV
+.uv/
+
+# Claude Code
+.claude/
+CLAUDE.md

engrammic_primitives-0.1.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0"
+}

engrammic_primitives-0.1.0/CHANGELOG.md

@@ -0,0 +1,25 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-05-04
+
+### Added
+
+- EAG (Epistemic Augmented Generation) paradigm implementation
+- CITE schema with four cognitive layers: Memory, Knowledge, Wisdom, Intelligence
+- Node types: Claim, Fact, Insight, Principle, Strategy, Model
+- Edge types for layer transitions and relationships
+- Scoring primitives: decay, freshness, confidence
+- Promotion and supersession logic
+- KnowledgeStore, LifecycleManager, SignalProvider protocols
+- Code-specific extensions
+- Taxonomy definitions
+
+[Unreleased]: https://github.com/anthropics/primitives/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/anthropics/primitives/releases/tag/v0.1.0

engrammic_primitives-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Delta Prime
+
+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.

engrammic_primitives-0.1.0/PKG-INFO

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: engrammic-primitives
+Version: 0.1.0
+Summary: EAG schema primitives for epistemic context management
+Author-email: Aliasgar Khimani <aliasgar.khimani@engrammic.ai>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: ai-agents,context-management,graphrag,knowledge-graph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.13
+Requires-Dist: pydantic>=2.0
+Description-Content-Type: text/markdown
+
+# Engrammic Primitives
+
+EAG schema primitives for building epistemic context systems.
+
+## Install
+
+```bash
+pip install engrammic-primitives
+```
+
+## Usage
+
+```python
+from primitives.schema import MemoryNode, KnowledgeNode, WisdomNode
+from primitives.eag import CognitiveTier
+
+# Create a memory node
+node = MemoryNode(
+    content="User prefers dark mode",
+    importance=0.7,
+)
+
+# Check cognitive tier
+tier = CognitiveTier.MEMORY
+```
+
+## When to Use
+
+Building your own EAG-compatible system or extending Engrammic.
+
+For using Engrammic directly, see:
+- [engrammic-mcp](https://github.com/engrammic/mcp-client) - hosted service
+- [engrammic-engine](https://github.com/engrammic/engine) - local engine
+
+## Learn More
+
+- [EAG Manifesto](docs/manifesto.md) - the paradigm explained
+
+## Modules
+
+| Module | Purpose |
+|--------|---------|
+| `primitives.schema` | Node and edge type definitions |
+| `primitives.eag` | EAG-specific implementations |
+| `primitives.protocols` | Storage and lifecycle interfaces |
+| `primitives.scoring` | Decay and freshness formulas |
+
+## License
+
+Apache 2.0

engrammic_primitives-0.1.0/README.md

@@ -0,0 +1,50 @@
+# Engrammic Primitives
+
+EAG schema primitives for building epistemic context systems.
+
+## Install
+
+```bash
+pip install engrammic-primitives
+```
+
+## Usage
+
+```python
+from primitives.schema import MemoryNode, KnowledgeNode, WisdomNode
+from primitives.eag import CognitiveTier
+
+# Create a memory node
+node = MemoryNode(
+    content="User prefers dark mode",
+    importance=0.7,
+)
+
+# Check cognitive tier
+tier = CognitiveTier.MEMORY
+```
+
+## When to Use
+
+Building your own EAG-compatible system or extending Engrammic.
+
+For using Engrammic directly, see:
+- [engrammic-mcp](https://github.com/engrammic/mcp-client) - hosted service
+- [engrammic-engine](https://github.com/engrammic/engine) - local engine
+
+## Learn More
+
+- [EAG Manifesto](docs/manifesto.md) - the paradigm explained
+
+## Modules
+
+| Module | Purpose |
+|--------|---------|
+| `primitives.schema` | Node and edge type definitions |
+| `primitives.eag` | EAG-specific implementations |
+| `primitives.protocols` | Storage and lifecycle interfaces |
+| `primitives.scoring` | Decay and freshness formulas |
+
+## License
+
+Apache 2.0

engrammic_primitives-0.1.0/context/README.md

@@ -0,0 +1,50 @@
+# CAG — Cognitive Augmented Generation
+
+Reference documentation for the CAG paradigm implemented in this library.
+
+## What is CAG
+
+CAG (Cognitive Augmented Generation) is a four-layer cognitive architecture for AI agents. Information flows through distinct persistence regimes:
+
+- **Memory** — experiences that fade (Gaussian decay)
+- **Knowledge** — facts that persist until contradicted (indefinite supersession)
+- **Wisdom** — beliefs that revise on evidence shift (evidence-gated revision)
+- **Intelligence** — ephemeral reasoning (session-scoped)
+
+Unlike RAG, CAG adjudicates (via a Custodian), tracks provenance, supports supersession, and shapes itself around usage (heat). Extraction produces structured claims; the epistemology library is deterministic.
+
+Source: arxiv:2604.11364v1 — *The Missing Knowledge Layer in Cognitive Architectures for AI Agents*.
+
+## What this library provides
+
+`primitives` implements the open, deterministic parts of CAG:
+
+- **Epistemology** — confidence math, contradiction detection, promotion rules (R1/R2), corroboration. Pure functions, no LLM at decision time.
+- **Signals** — heat, freshness, priority scoring formulas.
+- **Schema** — node type definitions, `PersistenceLayer` enum, edge catalogue.
+- **Protocols** — `KnowledgeStore`, `LifecycleManager`, `SignalProvider`, `ProvenanceTracker`.
+- **Shared utilities** — used across modules.
+
+What is NOT in this library (proprietary to the service layer):
+
+- Custodian workers (promotion, synthesis, revision scheduling)
+- Extraction prompts and LLM orchestration
+- Graph + vector write paths
+- Storage backends (Memgraph, Qdrant, Redis, Postgres)
+- API and MCP interface
+
+## Specs index
+
+| Doc | Contents |
+|-----|----------|
+| [specs/01-paradigm.md](specs/01-paradigm.md) | Why CAG, the category error in RAG, when CAG pays off |
+| [specs/02-layers.md](specs/02-layers.md) | KMWI layer semantics, node types, scoring formulas |
+| [specs/03-transitions.md](specs/03-transitions.md) | Transition catalogue (T1-T9), execution rules, provenance |
+| [specs/06-epistemology.md](specs/06-epistemology.md) | Deterministic primitives: confidence, contradiction, corroboration, provenance invariants |
+
+## Reading order
+
+1. [01-paradigm.md](specs/01-paradigm.md) — what and why
+2. [02-layers.md](specs/02-layers.md) — KMWI taxonomy
+3. [03-transitions.md](specs/03-transitions.md) — architecture lives here
+4. [06-epistemology.md](specs/06-epistemology.md) — deterministic primitives (maps directly to this library's API)

engrammic_primitives-0.1.0/context/specs/01-paradigm.md

@@ -0,0 +1,48 @@
+# 01 — Paradigm: CAG (Cognitive Augmented Generation)
+
+## The category error in RAG
+
+Plain RAG retrieves documents and appends them to a prompt. Systems built on top tend to apply **one persistence model** (usually some form of decay) uniformly to all information they store. This conflates:
+
+- A Slack message from yesterday ("I'm thinking we should use Dagster")
+- A validated fact ("OAuth refresh tokens expire in 30 days")
+- A pattern synthesised from dozens of observations ("this team ships on Fridays")
+- A reasoning chain generated for the current query
+
+These have *different persistence semantics*. A decaying Slack message is correct; a decaying validated fact is a bug. The paper (arxiv:2604.11364v1) calls this a category error.
+
+## The CAG move
+
+Split persistence into four layers, each with its own semantics:
+
+| Layer | Semantics | Example |
+|---|---|---|
+| **Memory** | Gaussian decay — experiences fade | "User asked about auth on 2026-04-21 14:32" |
+| **Knowledge** | Indefinite supersession — facts until contradicted | "OAuth refresh tokens expire in 30 days" |
+| **Wisdom** | Evidence-gated revision — beliefs update on shift | "This team ships on Fridays" |
+| **Intelligence** | Ephemeral — temporary inference | "For this query, I considered facts A, B, C" |
+
+## Four distinctions from RAG
+
+CAG is not RAG-with-extras. It differs structurally:
+
+1. **Multi-layered persistence** — no single decay model; each layer has its own rules
+2. **Active adjudication** — the Custodian promotes, supersedes, validates. Retrieval is one verb among many
+3. **Usage-shaped** — attention (heat) drives priority for maintenance transitions, not just retrieval
+4. **Graph-structured claim-level extraction** — claims (structured triples), not chunks, are the unit of knowledge
+
+## What CAG is *not*
+
+- Not a replacement for plain RAG in all contexts — when you just want cheap retrieval-augmented prompting, RAG is fine
+- Not about bigger embeddings or better retrieval tricks; the architecture is the thesis
+- Not AGI-adjacent; it's bookkeeping for agent-authored information, not cognition itself
+
+## When CAG pays off
+
+CAG's overhead (Custodian, provenance, multi-layer scoring) is justified when:
+- Agents operate over long horizons where facts change
+- Multiple agents share a knowledge substrate and disagree
+- Audit / compliance / temporal queries matter ("what did we believe on 2026-03-01?")
+- Information has authorship that needs tracking (who said what, when)
+
+It's overkill for: chat-with-your-PDF, single-agent short-horizon tasks, purely factual FAQ retrieval.

engrammic_primitives-0.1.0/context/specs/02-layers.md

@@ -0,0 +1,89 @@
+# 02 — The Four Layers (KMWI)
+
+## Memory
+
+**Semantics:** Gaussian decay. Experiences fade over time. Retrieval weight drops toward zero but content is preserved (until hard-deleted per the Cold Memory policy — see erasure rules).
+
+**Node types:**
+- `:Document` — an ingested source (file, page, transcript)
+- `:Passage` — a chunk within a Document
+- `:Utterance` — something an agent or human said in a conversation
+- `:Event` — a system-observed occurrence (tool called, ingestion ran)
+
+**Scoring:** `similarity × fresh(t) × heat × proximity(candidate, query_anchors)`
+- `fresh(t)` is the Gaussian per-class decay (ephemeral 7d, standard 90d, durable 540d, permanent 5y)
+- `heat` is ambient access-recency PPR (Heat-PPR)
+- `proximity` is query-time ego-graph PPR (Anchor-PPR)
+
+## Knowledge
+
+**Semantics:** indefinite supersession. Facts persist until contradicted. No time decay.
+
+**Node types:**
+- `:Fact` — a validated proposition
+- `:Claim` — an extracted proposition awaiting promotion (unpromoted Claim is persistent but scored lower)
+
+**Structural rule:** every `:Fact` has at least one `DERIVED_FROM` edge to a Memory-layer source. No orphan Facts.
+
+**Supersession:** when a new Fact contradicts an existing Fact, the Custodian writes `(:Fact_new)-[:SUPERSEDES]->(:Fact_old)` with `reason ∈ {'contradiction', 'evidence_shift', 'author_update', 'evidence_erased'}`. The old Fact remains queryable — audit and temporal queries (`as_of`) walk the SUPERSEDES chain.
+
+**Scoring:** `similarity × confidence × corroboration × proximity × NOT_superseded`
+
+## Wisdom
+
+**Semantics:** evidence-gated revision. Beliefs update when the underlying fact distribution shifts past a threshold, not on a clock.
+
+**Node types:**
+- `:Belief` — a synthesised judgment over many Facts
+- `:Pattern` — a recurring shape detected across Facts
+- `:Commitment` — a declared stance (agent-authored)
+- `:ProposedBelief` — a weak synthesis awaiting validation (status: pending/accepted/rejected)
+
+**Transitions in:** Knowledge → Wisdom via synthesis (cluster density threshold). Knowledge → Wisdom via propose (weak confidence creates ProposedBelief). Wisdom → Wisdom via revision (distribution shift >= M%). ProposedBelief → Belief via accept. ProposedBelief → tombstone via reject.
+
+Revision writes a new `:Belief` with a `SUPERSEDES` edge to the old Belief, `reason='evidence_shift'`. Old Beliefs remain queryable for audit and `as_of` temporal queries — Beliefs are never replaced in place.
+
+> **Cross-layer exception:** `:Commitment` is structurally a Knowledge-layer Claim subtype (multi-labeled `:Claim:Commitment`, SPO-structured, predicate-registry-governed) but carries Wisdom-layer semantics (authored stance via `DECLARED_BY`, reconcilable by the `commitment_reconciler`, revisable on author update). This is the single cross-layer node type in CAG; every other node belongs to exactly one layer.
+
+**Scoring:** `similarity × evidence_strength × underlying_fact_recency × proximity × wisdom_status_multiplier`
+- `wisdom_status ∈ {'active', 'stale'}`; stale Beliefs score at 0.1x (defined by erasure cascade)
+
+## Intelligence
+
+**Semantics:** ephemeral inference. Session-scoped. Temporary computational state.
+
+**Node types:**
+- `:ReasoningChain` — a stored reasoning sequence with steps inlined as a `steps: list[ChainStep]` JSON property (not separate nodes)
+- `:QueryContext` — the working set assembled for a specific query
+- `:WorkingHypothesis` — an agent's in-progress hypothesis during reasoning (session-scoped, mutable)
+
+**Promotion paths out:**
+- `Intelligence → Knowledge` via consensus: >= K chains from effective_J >= threshold agents agree → promote to Fact
+- `Intelligence → Memory` via trace: reasoning chain completes → compact trace stored as experience
+- `Intelligence → Wisdom` via commit: agent declares a stance from session work → Commitment
+
+**Scoring:** session-scoped only. Not retrieved cross-session (the session-end trace lives in Memory afterwards).
+
+## Why these four (and not three or five)
+
+- Three (conflating Knowledge and Wisdom) loses the authored-vs-synthesised distinction. A Commitment is not a Fact; a Belief about team patterns is not a Fact either. Both are Wisdom.
+- Five (splitting Memory into raw-vs-compressed) is a storage tier, not a persistence-semantics distinction. Doesn't deserve top-level status.
+- The four map cleanly onto distinct transition rules and distinct retrieval-scoring needs. That's the architectural test.
+
+## Layer tagging
+
+Every node carries a `PersistenceLayer` enum:
+
+```python
+class PersistenceLayer(str, Enum):
+    MEMORY = "memory"
+    KNOWLEDGE = "knowledge"
+    WISDOM = "wisdom"
+    INTELLIGENCE = "intelligence"
+```
+
+Used for:
+- Retrieval scoring dispatch
+- Custodian worker routing
+- Telemetry grouping
+- Erasure cascade classification

engrammic_primitives-0.1.0/context/specs/03-transitions.md

@@ -0,0 +1,70 @@
+# 03 — Transitions: the architecture lives here
+
+The layers themselves are a taxonomy. The **transitions** between them define the system's behaviour.
+
+## Transition diagram
+
+```
+    Memory --- extract ---> Knowledge --- synthesize ---> Wisdom
+      |                       |              |              |
+      |                       v              v              |
+      |                   supersede      propose         revise
+      |                (Knowledge->     (creates       (Wisdom->Wisdom
+      |                 Knowledge)    ProposedBelief)  on evidence shift)
+      v                                    |
+    decay                            accept/reject
+   (retrieval                     (ProposedBelief ->
+    weight -> 0)                   Belief or tombstone)
+
+    Intelligence -- consensus ---> Knowledge
+    Intelligence -- trace -------> Memory
+    Intelligence -- commit ------> Wisdom (Commitment)
+    Intelligence -- crystallize -> Wisdom (from WorkingHypothesis)
+```
+
+## Transition catalogue
+
+| # | Transition | Trigger predicate | Execution | Priority |
+|---|---|---|---|---|
+| T1 | **Memory -> Knowledge** (extract) | passage is hot OR source-changed OR cold-but-queried | signal-driven | `heat × (1 / last_extracted_at)` |
+| T2 | **Knowledge -> Knowledge** (supersede) | new Fact's (s, p, o) conflicts with existing Fact | eager (synchronous in validator) | N/A |
+| T3 | **Knowledge -> Wisdom** (synthesize) | cluster density >= N AND no current Belief covers it | signal-driven | `heat × cluster_density` |
+| T4 | **Wisdom -> Wisdom** (revise) | distribution shift >= M% since last synthesis | signal-driven — Revision = supersede-with-new-Belief, not in-place edit. Preserves audit chain. | `heat × shift_magnitude` |
+| T5 | **Intelligence -> Knowledge** (consensus) | >= K reasoning chains from effective_J >= J agents agree | lazy | consensus timestamp |
+| T6 | **Intelligence -> Memory** (trace) | reasoning chain completes | batched post-session | session end time |
+| T7 | **Intelligence -> Wisdom** (commit) — writes `:Claim:Commitment` (Knowledge-structure, Wisdom-semantics) | agent declares a stance | eager | N/A |
+| T8 | **Memory -> ⊥** (decay) | time-based; retrieval weight -> 0 | compute-at-query | N/A |
+| T9 | **Memory -> ⊥** (hard-delete) | `age > 2 × class.σ` OR GDPR | scheduled GC (hard-delete default) | `age` |
+| T10 | **Knowledge -> Wisdom** (propose) | synthesis confidence in weak range (above min, below auto-promote) | signal-driven | `heat × confidence` |
+| T11 | **Wisdom -> Wisdom** (accept) | validator accepts ProposedBelief | eager | N/A |
+| T12 | **Wisdom -> ⊥** (reject) | validator rejects ProposedBelief | eager | N/A |
+| T13 | **Intelligence -> Wisdom** (crystallize) | agent crystallizes WorkingHypothesis | eager | N/A |
+
+## The execution rule
+
+- **Eager** for correctness-critical transitions (T2 supersession, T7 commit)
+- **Signal-driven + heat-ranked** for optimisation transitions (T1 extract, T3 synthesize, T4 revise)
+- **Batched / lazy / scheduled** for housekeeping (T5 consensus, T6 trace, T8/T9 decay)
+
+## Why transitions, not layers, are the architecture
+
+If you know the four layers but not the transitions, you can't build CAG. The layers tell you *what exists*; the transitions tell you *what moves*. A CAG implementation is largely the sum of its transition workers.
+
+Consequence: the Custodian (service-layer proprietary) is internally structured as one worker per transition, plus a shared epistemology library. Transitions are first-class design objects.
+
+The epistemology library in this package implements the deterministic decision functions that underlie T1, T2, T3, T5, and T7. Scheduling and execution of the transitions themselves lives in the service layer.
+
+## Provenance across transitions
+
+Every transition that creates a node writes a provenance edge back to its source(s):
+
+- T1 extract: `(:Claim)-[:DERIVED_FROM]->(:Passage)` (Extraction owns)
+- T2 supersede: `(:Fact_new)-[:SUPERSEDES]->(:Fact_old)` with reason + timestamp
+- T3 synthesize: `(:Belief)-[:SYNTHESIZED_FROM]->(:Fact)+` (>= N required)
+- T5 consensus: `(:Fact)-[:PROMOTED_FROM]->(:ReasoningChain)+`
+- T6 trace: `(:ReasoningChain)-[:DERIVED_FROM_EVIDENCE]->(:Document|:Passage|:Claim)+`; optionally `(:ReasoningChain)-[:CRYSTALLIZED_INTO]->(:Claim)` for crystallizations
+- T7 commit: `(:Claim:Commitment)-[:DECLARED_BY]->(:Agent)` (per D1); `CRYSTALLIZED_INTO` used for Intelligence->Knowledge linkage
+- T10 propose: `(:ProposedBelief)-[:SYNTHESIZED_FROM]->(:Fact)+` (same as T3, but creates proposal)
+- T11 accept: `(:Belief)-[:PROMOTED_FROM]->(:ProposedBelief)` with `accepted_at` timestamp
+- T12 reject: `(:ProposedBelief)` marked `status='rejected'` with `reason` and `rejected_at`
+- T13 crystallize: `(:Commitment)-[:CRYSTALLIZED_FROM]->(:WorkingHypothesis)`