epistemic-ledger 0.12.0__tar.gz

epistemic_ledger-0.12.0/LICENSE

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

epistemic_ledger-0.12.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: epistemic-ledger
+Version: 0.12.0
+Summary: A living epistemic ledger: append-only conclusions with fluid certainty scores, revised as new facts arrive.
+Author: Axiovex Systems, LLC
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/AXIOVEX/epistemic-ledger
+Project-URL: Documentation, https://epistemic-ledger.readthedocs.io/
+Project-URL: Repository, https://github.com/AXIOVEX/epistemic-ledger
+Project-URL: Issues, https://github.com/AXIOVEX/epistemic-ledger/issues
+Project-URL: Changelog, https://github.com/AXIOVEX/epistemic-ledger/blob/main/CHANGELOG.md
+Keywords: epistemology,belief-revision,bitemporal,event-sourcing,truth-maintenance,agent-memory,knowledge-graph
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Database
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: hypothesis>=6; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.11; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Requires-Dist: mkdocstrings[python]>=0.26; extra == "docs"
+Dynamic: license-file
+
+# Epistemic Ledger
+
+A living epistemic ledger: an append-only database where every
+conclusion carries a fluid certainty score, and new facts automatically
+trigger re-evaluation of the conclusions — and their dependents — that
+they affect, instead of any judgment ever being final.
+
+```bash
+pip install epistemic-ledger
+```
+
+```python
+from epistemic_ledger import Ledger
+
+ledger = Ledger("my-ledger")
+claim = ledger.assert_claim("the bridge design is safe", 0.60)
+fact = ledger.ingest_evidence("load test passed", 0.90)["fact_id"]
+ledger.add_support(claim, fact, "evidential", p_given=0.95, p_given_not=0.30)
+print(ledger.get_score(claim))  # the score moved; the history kept both
+```
+
+## The four properties
+
+1. **Append-only records.** Conclusions are never changed or deleted.
+   A correction is a new record that supersedes the old one; the full
+   history of what was believed, and when, stays queryable.
+2. **Fluid certainty scores.** Every conclusion carries a score that
+   moves as evidence accumulates — today's result is tomorrow's
+   starting point — instead of a one-time yes-or-no verdict.
+3. **Dependency-tracked revisits.** Each conclusion records *why* it
+   is held. When a new fact arrives, the change spreads along the
+   dependency graph and re-evaluates exactly the conclusions it
+   touches, plus their dependents.
+4. **A trigger discipline.** Not every new fact warrants a revisit.
+   A layered rule — dirty-flagging, precise invalidation, then a
+   materiality threshold — decides when recomputation is required.
+
+## What is inside
+
+- An event-sourced, bitemporal store (append-only JSONL event log as
+  the write model, SQLite bitemporal tables as the read model).
+- A revisit loop using Jeffrey conditionalization for uncertain
+  evidence, with an early cutoff and materiality flags.
+- Joint likelihoods (noisy-AND / noisy-OR), Dempster–Shafer belief
+  intervals where ignorance must be explicit, and automatic
+  contradiction detection with entrenchment-ordered resolution.
+- Governance: writer trust tiers, signed verdicts (Ed25519), named
+  graph authority ceilings, and predicate policies — all stored as
+  bitemporal facts in the ledger they govern.
+- A hardened single-writer store with replay verification
+  (`epistemic-ledger verify <dir>`).
+- The five kill criteria the design set for itself, instrumented from
+  day one (`epistemic-ledger kill-metrics <dir>`).
+- An offline LLM consolidation pass and caller-owned abstention
+  policies.
+
+Standard library only. No dependencies, no network at runtime.
+
+## Command line
+
+```bash
+epistemic-ledger demo                      # end-to-end scenario
+epistemic-ledger verify path/to/ledger     # integrity check
+epistemic-ledger kill-metrics path/to/ledger
+```
+
+## Documentation
+
+Full documentation — the framing paper, the design memos, the measured
+results, and the API reference — is at
+https://epistemic-ledger.readthedocs.io/ and in the GitHub repository:
+https://github.com/AXIOVEX/epistemic-ledger
+
+## License
+
+The code is under the MIT License (see `LICENSE` in the repository).
+The framing paper, design memos, and research documents in `docs/`
+remain all rights reserved, © 2026 Axiovex Systems, LLC (see
+`LICENSE-DOCS.txt` in the repository).

epistemic_ledger-0.12.0/README-PyPI.md

@@ -0,0 +1,79 @@
+# Epistemic Ledger
+
+A living epistemic ledger: an append-only database where every
+conclusion carries a fluid certainty score, and new facts automatically
+trigger re-evaluation of the conclusions — and their dependents — that
+they affect, instead of any judgment ever being final.
+
+```bash
+pip install epistemic-ledger
+```
+
+```python
+from epistemic_ledger import Ledger
+
+ledger = Ledger("my-ledger")
+claim = ledger.assert_claim("the bridge design is safe", 0.60)
+fact = ledger.ingest_evidence("load test passed", 0.90)["fact_id"]
+ledger.add_support(claim, fact, "evidential", p_given=0.95, p_given_not=0.30)
+print(ledger.get_score(claim))  # the score moved; the history kept both
+```
+
+## The four properties
+
+1. **Append-only records.** Conclusions are never changed or deleted.
+   A correction is a new record that supersedes the old one; the full
+   history of what was believed, and when, stays queryable.
+2. **Fluid certainty scores.** Every conclusion carries a score that
+   moves as evidence accumulates — today's result is tomorrow's
+   starting point — instead of a one-time yes-or-no verdict.
+3. **Dependency-tracked revisits.** Each conclusion records *why* it
+   is held. When a new fact arrives, the change spreads along the
+   dependency graph and re-evaluates exactly the conclusions it
+   touches, plus their dependents.
+4. **A trigger discipline.** Not every new fact warrants a revisit.
+   A layered rule — dirty-flagging, precise invalidation, then a
+   materiality threshold — decides when recomputation is required.
+
+## What is inside
+
+- An event-sourced, bitemporal store (append-only JSONL event log as
+  the write model, SQLite bitemporal tables as the read model).
+- A revisit loop using Jeffrey conditionalization for uncertain
+  evidence, with an early cutoff and materiality flags.
+- Joint likelihoods (noisy-AND / noisy-OR), Dempster–Shafer belief
+  intervals where ignorance must be explicit, and automatic
+  contradiction detection with entrenchment-ordered resolution.
+- Governance: writer trust tiers, signed verdicts (Ed25519), named
+  graph authority ceilings, and predicate policies — all stored as
+  bitemporal facts in the ledger they govern.
+- A hardened single-writer store with replay verification
+  (`epistemic-ledger verify <dir>`).
+- The five kill criteria the design set for itself, instrumented from
+  day one (`epistemic-ledger kill-metrics <dir>`).
+- An offline LLM consolidation pass and caller-owned abstention
+  policies.
+
+Standard library only. No dependencies, no network at runtime.
+
+## Command line
+
+```bash
+epistemic-ledger demo                      # end-to-end scenario
+epistemic-ledger verify path/to/ledger     # integrity check
+epistemic-ledger kill-metrics path/to/ledger
+```
+
+## Documentation
+
+Full documentation — the framing paper, the design memos, the measured
+results, and the API reference — is at
+https://epistemic-ledger.readthedocs.io/ and in the GitHub repository:
+https://github.com/AXIOVEX/epistemic-ledger
+
+## License
+
+The code is under the MIT License (see `LICENSE` in the repository).
+The framing paper, design memos, and research documents in `docs/`
+remain all rights reserved, © 2026 Axiovex Systems, LLC (see
+`LICENSE-DOCS.txt` in the repository).

epistemic_ledger-0.12.0/README.md

@@ -0,0 +1,119 @@
+# Epistemic Ledger
+
+[![CI](https://github.com/AXIOVEX/epistemic-ledger/actions/workflows/ci.yml/badge.svg)](https://github.com/AXIOVEX/epistemic-ledger/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/AXIOVEX/epistemic-ledger/graph/badge.svg)](https://codecov.io/gh/AXIOVEX/epistemic-ledger)
+[![PyPI](https://img.shields.io/pypi/v/epistemic-ledger.svg)](https://pypi.org/project/epistemic-ledger/)
+[![Documentation](https://readthedocs.org/projects/epistemic-ledger/badge/?version=latest)](https://epistemic-ledger.readthedocs.io/)
+[![Python](https://img.shields.io/pypi/pyversions/epistemic-ledger.svg)](https://pypi.org/project/epistemic-ledger/)
+
+> A living epistemic scoring system where every conclusion lives in an append-only database with a fluid certainty score, and new facts automatically trigger re-evaluation of the conclusions — and their dependents — that they affect, instead of any judgment ever being final.
+
+Databases are deeply flawed: there is no built-in way to keep challenging the data, to know how true any of it is, or to update it as the evidence comes in. The epistemic ledger is an attempt to fix that — an append-only epistemic database over which an active feedback loop runs, so records are never destroyed but certainty stays fluid, and the system corrects itself, including its previously built structure.
+
+## Status
+
+**Implemented and validated** (v0.11.1, 2026-10-09). The framing below became a working prototype: an event-sourced, bitemporal ledger with a dependency-propagated revisit loop, learned entrenchment, Dempster-Shafer intervals, joint likelihoods, contradiction detection and resolution, governance (writer tiers, signed verdicts, escalation, named-graph authority ceilings, predicate policies), an offline LLM consolidation pass, and a hardened single-writer store with integrity verification. See [`docs/PAPER.md`](docs/PAPER.md) for the framing paper, `docs/DESIGN-*.md` for the design memos, and `docs/research/` for the raw research notes with provenance.
+
+Measured results so far, each with its own report in `docs/`:
+
+- **Revision value** (CONTEXT-CLEANUP-01, REPO-HISTORY-VALIDATION): the revisit loop eliminates 70.6% of naive staleness errors on dependency chains, 62.8% with joint likelihoods, 81.0% on this repository's own git history.
+- **Trigger discipline** (TRIGGER-STRESS-01): epsilon 0.005 balances recall 0.96 / precision 0.72; the cutoff earns its keep.
+- **Adversarial newsroom** (NEWSROOM-01, LOCAL-EXTRACTION-01): against adversarial sources the ledger eliminates 20.8% (modeled extraction) to 22.2% (real LLM extraction, local Qwen3-8B, $0) of a frozen baseline's errors — 51-61% on derived claims.
+- **Free prose** (FREETEXT-01): on authored non-template text the advantage thins to 16.8% / 43.5% derived and becomes seed-dependent; the report states the sensitivity plainly.
+- **Independent prose** (INDIE-CORPUS-01): on text authored by a different model family (GPT-4.1), the advantage reproduces at 21.1% / 49.7% derived with a different failure anatomy — the authorship caveat is retired.
+- **Kill bars** (KILL-BARS-01): every gate threshold re-measured across all workload families; two adjusted under a pre-stated rule, one held at its definitional value on the record.
+- **LLM consolidation** (CONSOLIDATION-01, LOCAL-CONSOLIDATION-01): the offline pass matches frontier-model precision/recall locally at $0 — in its thinking configuration; the no-thinking configuration fails, measurably.
+- **Churn and calibration** (CHURN-01, CALIBRATION-01): conflict-normalized material churn gates at 8; a proposed agent-tempering fix was tested and *refuted* — reported as a negative.
+- **Override loop** (OVERRIDE-CAL-01): v0.11.1 makes manual scores propagate through the revisit loop (they previously updated one claim and stopped); scripted-reviewer personas put the override-rate bar on a measurement for the first time (observed 0.020-0.035 vs the 0.20 bar). Human-reviewer calibration remains the honest residual.
+- **Real published copy** (REALWIRE-01): on verbatim sentences from the published record, extraction accuracy collapses to 0.481 — the local extractor answers "is this true?" instead of "what does this sentence say" — while the bookkeeping edge survives, compressed (4.1% facts / 17.6% derived, vs 21.1% / 49.7% on authored prose).
+- **Stance failure, diagnosed** (STANCE-01, STANCE-02): frozen diagnostic studies isolate the mechanism — proposition-level prior interference, with a dose-response over familiarity — and test the fixes: a hosted frontier model passes every bar (REALWIRE 0.977); prompt-level structure trades bias for abstention; proposition masking maps a structural ceiling on real copy.
+- **Proof package** (2026-10-09): the post-freeze claims re-measured on the frozen downstream protocol. A base-model upgrade (Qwen3.5-9B, identical prompts) cuts local downstream error 0.4637 → 0.3194; structured variants (0.3073, 0.3300) do not separate from the plain baseline outside seed noise. Production default: baseline prompt on Qwen3.5-9B, structured escalation where abstention is acceptable, frontier arm as the only strong-band configuration. A supervised fastText floor (0.618 on REALWIRE stance) and a five-model fold bench accompany the result.
+- **Ported into production tooling**: the measured defaults ship in the deterministic Applied Epistemic Engineering engine (`aee` 1.4.0 on PyPI — policy gates, per-source reliability, materiality review queue) and the Spec Kit AEE extension 1.2.0, with the transfer map recorded in that repository.
+- **Measured, killed** (LORA-01, 2026-10-20): a LoRA adapter trained on truth-orthogonal stance data improved held-out assertion accuracy (0.903 → 0.972) but failed the frozen primary bar (+0.10 improvement required, +0.069 measured) and learned to abstain on real published copy (14/131 REALWIRE sentences), regressing REALWIRE-T. Killed as a production candidate under its predeclared criteria; the production default (Q35A) is unchanged. Full record in docs/LORA-01.md.
+- **Measured, killed** (LORA-02, 2026-10-20): the successor adapter - trained with near-miss distractors against LORA-01's abstention failure and judged by headroom-based error-reduction bars - fixed every held-out assert error (0.958 to 1.000) but abstained on 30% of REALWIRE and damaged deny accuracy on real copy (REALWIRE-T deny 0.891 to 0.655). Killed under its frozen bars; across both LoRA studies, stance training on authored sentences does not transfer to real published copy. Production default (Q35A) unchanged. Full record in docs/LORA-02.md.
+
+## Install
+
+```bash
+pip install epistemic-ledger
+```
+
+```python
+from epistemic_ledger import Ledger
+
+ledger = Ledger("my-ledger")
+claim = ledger.assert_claim("the bridge design is safe", 0.60)
+fact = ledger.ingest_evidence("load test passed", 0.90)["fact_id"]
+ledger.add_support(claim, fact, "evidential", p_given=0.95, p_given_not=0.30)
+print(ledger.get_score(claim))
+```
+
+Command line: `epistemic-ledger demo`, `epistemic-ledger verify <dir>`,
+`epistemic-ledger kill-metrics <dir>`. Full documentation:
+https://epistemic-ledger.readthedocs.io/
+
+## The idea in brief
+
+1. **Append-only records.** Conclusions are never mutated or deleted. Corrections are new records that supersede old ones — the full history of what was believed, and when, stays queryable.
+2. **Fluid certainty scores.** Every conclusion carries a score that moves as evidence accumulates — today's posterior is tomorrow's prior — rather than a one-time binary verdict.
+3. **Dependency-tracked revisits.** Each conclusion records *why* it is held. When a new fact arrives, the system propagates the change along the dependency graph and re-evaluates exactly the conclusions it touches, plus their dependents.
+4. **A trigger discipline.** Not every new fact warrants a revisit. The system needs a principled answer to *when* — from coarse dirty-flagging up through precise invalidation to judgmental materiality thresholds.
+
+## Research foundations
+
+Eight threads were surveyed to frame the design (canonical references in [`docs/PAPER.md`](docs/PAPER.md)):
+
+| # | Thread | What it gives the ledger |
+|---|--------|--------------------------|
+| 1 | Bitemporal data modeling | Valid time vs. transaction time; retroactive correction without mutation |
+| 2 | Belief revision (AGM) | Minimal-change revision; epistemic entrenchment as the "what to give up" rule |
+| 3 | Truth maintenance (JTMS/ATMS) | Justification-tracked beliefs; dependency-directed retraction |
+| 4 | Event sourcing | Append-only log; state as replay; compensating events |
+| 5 | Incremental recomputation | Invalidation propagation; early cutoff; DBSP's formal delta theory |
+| 6 | Change-impact analysis | The trigger problem: dirty flags → precise invalidation → materiality |
+| 7 | Non-binary epistemic scoring | Sequential Bayes; Jeffrey kinematics for uncertain evidence |
+| 8 | LLM memory & context cleanup | Offline consolidation; RAG freshness; bitemporal knowledge graphs |
+
+The closest existing systems to the whole: **Zep/Graphiti**-style bitemporal knowledge graphs (event time + ingestion time per edge, non-lossy retroactive correction), with TOKI (bitemporal contradiction resolution for agent memory), SodaMem (temporal graph memory with provenance and supersession edges), Engram (bi-temporal memory with invalidation and supersession chains), and MemTX (belief-commit protocol that repairs derived records when a belief is retracted) as close on other axes — none carries a certainty score revised as evidence accumulates, and none has the ledger's materiality rule for when a change warrants a revisit.
+
+## Why this matters beyond one project
+
+The same machinery answers a pressing LLM problem: **context cleanup**. Retrieval freshness, offline memory consolidation, and principled invalidation of stale context are exactly the ledger's operations applied to an agent's working memory. Whatever is built here generalizes.
+
+## Repository layout
+
+```
+.
+├── README.md            # This file
+├── LICENSE              # MIT (code); docs/ stays all rights reserved — see NOTICE.md
+├── docs/
+│   ├── PAPER.md         # The framing paper
+│   ├── DESIGN-01-record-schema-scoring.md  # Record schema + scoring calculus
+│   ├── DESIGN-02-contradiction-resolution.md  # Entrenchment-ordered contraction
+│   ├── DESIGN-03-learned-entrenchment.md   # Calibration-derived entrenchment
+│   ├── DESIGN-04-ds-intervals.md           # D–S intervals: keep-or-cut verdict
+│   ├── TRIGGER-STRESS-01.md  # Trigger-discipline stress test report
+│   ├── CONTEXT-CLEANUP-01.md  # LLM context-cleanup experiment report
+│   └── research/        # Raw research notes with provenance (2026-09-30)
+│       └── BIBLIOGRAPHY.md  # Annotated bibliography: primary-source verification (2026-10-01)
+├── src/epistemic_ledger/  # The package (stdlib-only Python)
+├── tests/               # Test suite
+├── prototype/           # Research scripts + compatibility shims
+│   ├── validation/      # Measured-result harnesses (not shipped)
+│   └── demo.py          # End-to-end scenario
+└── .gitignore
+```
+
+## Prototype v0.1
+
+A working implementation of Design Memo 01's §8 scope — now the shipped package under `src/epistemic_ledger/`, with the research harnesses remaining in [`prototype/`](prototype/): append-only JSONL event log, SQLite bitemporal claim table, Jeffrey-update revisit loop with early cutoff, one materiality rule, the four queries (`BELIEVED_AT` / `CHANGED` / `DEPENDS_ON` / `WHY`), and all five kill criteria instrumented from day one.
+
+```bash
+pip install -e ".[dev]"   # from the repo root
+epistemic-ledger demo      # end-to-end scenario
+python -m pytest           # the full test suite
+```
+
+## License
+
+Code: MIT — see [LICENSE](LICENSE). The framing paper, design memos, and research documents under `docs/` remain all rights reserved, © 2026 Axiovex Systems, LLC — see [LICENSE-DOCS.txt](LICENSE-DOCS.txt) and [NOTICE.md](NOTICE.md).

epistemic_ledger-0.12.0/pyproject.toml

@@ -0,0 +1,117 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "epistemic-ledger"
+version = "0.12.0"
+description = "A living epistemic ledger: append-only conclusions with fluid certainty scores, revised as new facts arrive."
+readme = "README-PyPI.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Axiovex Systems, LLC" },
+]
+keywords = [
+    "epistemology",
+    "belief-revision",
+    "bitemporal",
+    "event-sourcing",
+    "truth-maintenance",
+    "agent-memory",
+    "knowledge-graph",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Database",
+    "Typing :: Typed",
+]
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8",
+    "pytest-cov>=5",
+    "hypothesis>=6",
+    "ruff>=0.6",
+    "mypy>=1.11",
+    "build>=1.2",
+    "twine>=5",
+]
+docs = [
+    "mkdocs>=1.6",
+    "mkdocs-material>=9.5",
+    "mkdocstrings[python]>=0.26",
+]
+
+[project.scripts]
+epistemic-ledger = "epistemic_ledger.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/AXIOVEX/epistemic-ledger"
+Documentation = "https://epistemic-ledger.readthedocs.io/"
+Repository = "https://github.com/AXIOVEX/epistemic-ledger"
+Issues = "https://github.com/AXIOVEX/epistemic-ledger/issues"
+Changelog = "https://github.com/AXIOVEX/epistemic-ledger/blob/main/CHANGELOG.md"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+epistemic_ledger = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+markers = [
+    "property: property-based tests (Hypothesis)",
+]
+
+[tool.coverage.run]
+source = ["epistemic_ledger"]
+branch = true
+omit = [
+    "*/epistemic_ledger/__main__.py",  # 3-line entry shim, exercised via the CLI tests' subprocess check
+]
+
+[tool.coverage.report]
+show_missing = true
+skip_covered = false
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = [
+    "E501",  # line length is a formatter concern; long data lines exist in the research-derived core
+    "B008",
+]
+
+[tool.ruff.lint.per-file-ignores]
+# The ported suite predates the package: it imports in per-feature
+# sections on purpose and keeps scenario-setup locals. Its behavior is
+# the contract; new test files are held to the full rule set.
+"tests/test_ledger.py" = ["E401", "E402", "I001", "F401", "F811", "F841", "UP031", "E741", "B007"]
+"tests/test_newsroom.py" = ["E402"]
+
+[tool.mypy]
+python_version = "3.10"
+warn_unused_ignores = false
+ignore_missing_imports = true
+# The core predates typing; strictness is being raised module by module.
+# The gate today: mypy must parse and check the package with no errors
+# under these settings; new modules (cli, __init__) are fully annotated
+# in practice and checked the same way.
+check_untyped_defs = true

epistemic_ledger-0.12.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

epistemic_ledger-0.12.0/src/epistemic_ledger/__init__.py

@@ -0,0 +1,55 @@
+"""Living Epistemic Ledger.
+
+An append-only epistemic database: every conclusion carries a fluid
+certainty score, and new facts trigger re-evaluation of the conclusions
+they touch, plus their dependents. Nothing is ever deleted; corrections
+are new records that supersede old ones.
+
+Public API:
+    Ledger            -- the ledger itself (event log + bitemporal store)
+    jeffrey           -- Jeffrey conditionalization for uncertain evidence
+    dempster_combine  -- Dempster's rule for belief masses
+    interval_to_mass  -- convert a [belief, plausibility] interval to a mass
+
+Submodules:
+    epistemic_ledger.ledger        -- core store, revisit loop, queries
+    epistemic_ledger.consolidation -- offline LLM consolidation pass
+    epistemic_ledger.policies      -- caller-owned abstention policies
+    epistemic_ledger.elicit        -- likelihood elicitation helpers
+    epistemic_ledger.ed25519       -- vendored Ed25519 (RFC 8032) for
+                                      signed governance verdicts
+"""
+
+from importlib.metadata import PackageNotFoundError, version
+
+from .ledger import (
+    COMBO_KINDS,
+    ENTRENCHMENT_TIERS,
+    GATED_ACTIONS,
+    SUPPORT_KINDS,
+    TIER_ENTRENCHMENT,
+    WRITER_TIERS,
+    Ledger,
+    dempster_combine,
+    interval_to_mass,
+    jeffrey,
+)
+
+try:
+    __version__ = version("epistemic-ledger")
+except PackageNotFoundError:  # source checkout without an install
+    __version__ = "0+unknown"
+
+__all__ = [
+    "COMBO_KINDS",
+    "ENTRENCHMENT_TIERS",
+    "GATED_ACTIONS",
+    "SUPPORT_KINDS",
+    "TIER_ENTRENCHMENT",
+    "WRITER_TIERS",
+    "Ledger",
+    "__version__",
+    "dempster_combine",
+    "interval_to_mass",
+    "jeffrey",
+]

epistemic_ledger-0.12.0/src/epistemic_ledger/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m epistemic_ledger`` as the CLI entry point."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

epistemic_ledger-0.12.0/src/epistemic_ledger/cli.py

@@ -0,0 +1,115 @@
+"""Command-line interface for the living epistemic ledger.
+
+Commands:
+    epistemic-ledger demo                     run the end-to-end scenario
+    epistemic-ledger verify <ledger-dir>      integrity-check a ledger store
+    epistemic-ledger kill-metrics <ledger-dir>
+                                              print the five kill metrics
+                                              as JSON
+
+Exit codes: 0 on success, 1 when a check reports problems, 2 on usage
+or open errors.
+"""
+
+import argparse
+import json
+import shutil
+import sys
+import tempfile
+
+from . import __version__
+from .ledger import Ledger
+
+
+def run_demo():
+    """The bridge scenario from the framing work, end to end."""
+    d = tempfile.mkdtemp(prefix="ledger-demo-")
+    try:
+        L = Ledger(d)
+
+        safe = L.assert_claim("bridge design is safe", 0.60)
+        ships = L.assert_claim("project ships on time", 0.55)
+        L.add_support(ships, safe, "deductive", p_given=0.90, p_given_not=0.20)
+        print(f"day 1: safe={L.get_score(safe):.3f} ships={L.get_score(ships):.3f}")
+
+        r = L.ingest_evidence("load test passed", 0.90)
+        fact = r["fact_id"]
+        before = L.get_score(safe)
+        L.add_support(safe, fact, "evidential", p_given=0.95, p_given_not=0.30)
+        L._revisit(fact, {fact: 0.90})
+        print(
+            f"day 2: load test passed -> safe={L.get_score(safe):.3f} "
+            f"({L.get_score(safe) - before:+.3f}), "
+            f"ships={L.get_score(ships):.3f}"
+        )
+
+        r = L.ingest_evidence("steel supplier delayed 6 weeks", 0.85)
+        delay = r["fact_id"]
+        before = L.get_score(ships)
+        L.add_support(ships, delay, "evidential", p_given=0.15, p_given_not=0.70)
+        r = L._revisit(delay, {delay: 0.85})
+        print(
+            f"day 3: supplier delay -> ships={L.get_score(ships):.3f} "
+            f"({L.get_score(ships) - before:+.3f}); "
+            f"flags raised: {len(r['flags'])}"
+        )
+
+        print("\nWHY(ships):")
+        for w in L.why(ships):
+            print(f"  <- {w['statement']!r} score={w['score']:.3f} kind={w['kind']}")
+        print(f"\nDEPENDS_ON(delay): {len(L.depends_on(delay))} claim(s) in closure")
+
+        L.record_outcome(safe, True)
+        L.record_outcome(ships, False)
+        m = L.kill_metrics()
+        print(
+            f"\nkill metrics: brier={m['brier']:.3f} "
+            f"fanout_max={m['fanout']['max']} "
+            f"override_rate={m['override_rate']} "
+            f"revisits={len(m['trigger_log'])}"
+        )
+        L.close()
+    finally:
+        shutil.rmtree(d, ignore_errors=True)
+    return 0
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(
+        prog="epistemic-ledger",
+        description="Living epistemic ledger: append-only conclusions "
+        "with fluid certainty scores.",
+    )
+    parser.add_argument(
+        "--version", action="version", version=f"epistemic-ledger {__version__}"
+    )
+    sub = parser.add_subparsers(dest="command", required=True)
+    sub.add_parser("demo", help="run the end-to-end demo scenario")
+    p_verify = sub.add_parser("verify", help="integrity-check a ledger store")
+    p_verify.add_argument("ledger_dir")
+    p_km = sub.add_parser("kill-metrics", help="print a ledger's kill metrics as JSON")
+    p_km.add_argument("ledger_dir")
+    args = parser.parse_args(argv)
+
+    if args.command == "demo":
+        return run_demo()
+    try:
+        L = Ledger(args.ledger_dir)
+    except Exception as exc:  # an unopenable store is a usage error
+        print(f"error: cannot open ledger at {args.ledger_dir}: {exc}", file=sys.stderr)
+        return 2
+    try:
+        if args.command == "verify":
+            result = L.verify_store()
+            print(json.dumps(result, indent=2, default=str))
+            return 0 if result.get("ok") else 1
+        if args.command == "kill-metrics":
+            print(json.dumps(L.kill_metrics(), indent=2, default=str))
+            return 0
+    finally:
+        L.close()
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())