book-thesis

Files (39)

• SKILL.md
• pyproject.toml
• consistency.cozo · rules/
• capture_consistency.py · scripts/
• compile_thesis.py · scripts/
• consistency_cozo.py · scripts/
• dispatch_entailment.py · scripts/
• lint_supports.py · scripts/
• production_llm.py · scripts/
• project_thesis_cozo.py · scripts/
• sibling_skills.py · scripts/
• synthesize_exemplars.py · scripts/
• skill_api.py
• datalog_thesis.ttl · tests/fixtures/
• ledger-entailment.jsonl · tests/fixtures/
• manuscript-broken.md · tests/fixtures/
• manuscript-clean.md · tests/fixtures/
• manuscript-entailment.md · tests/fixtures/
• manuscript-no-support.md · tests/fixtures/
• manuscript-unreachable.md · tests/fixtures/
• manuscript-untracked.md · tests/fixtures/
• tiny-thesis.yaml · tests/fixtures/
• violating_thesis.py · tests/fixtures/
• d9_d11_bermuda.json · tests/golden/consistency/
• d9_d11_violating.json · tests/golden/consistency/
• test_characterization_consistency.py · tests/
• test_compile_thesis.py · tests/
• test_consistency_cozo_parity.py · tests/
• test_consistency_cozo_rules.py · tests/
• test_cross_skill_cozo_import.py · tests/
• test_dispatch_entailment.py · tests/
• test_lint_supports.py · tests/
• test_no_legacy_import_after_cutover.py · tests/
• test_synthesize_exemplars.py · tests/
• test_thesis_projector.py · tests/
• __init__.py · tests/unit/
• test_skill_api.py · tests/unit/
• bermuda.yaml · thesis/
• schema.yaml · thesis/

SKILL.md (first lines)

# book-thesis

The metabook reasoning layer. Owns the *intent substrate* of a book — the thesis statement, the sub-arguments that decompose it, and the requirement that every paragraph in the manuscript trace back to some node in that tree. Sibling to `book-knowledge` (which owns the fact substrate).

## What it owns

- The thesis tree: a YAML/RDF graph rooted at `:Thesis`, with sub-arguments and required-evidence slots.
- Paragraph back-pointers: every paragraph in a draft carries a `supports:` field naming a tree node.
- The entailment loop: a per-paragraph LLM-critic dispatch that asks "does this paragraph actually advance its declared supports node?"
- The consistency pass: a recursive CozoScript rule set (compiled from booklogic EDN) that derives transitive contradictions across chapter-level claim facts.
- The exemplar pack: synthetic (supports-node, claim, paragraph) triples injected into the drafting prompt.

## What it does NOT own

- Claim ingestion or claim-ledger maintenance. That is `book-knowledge`.
- Sentence-grain prose linting (hedges, passive voice, modifier budget). That is `russellian-style`.
- Chapter orchestration, bundling, and book release. That is `book-compose`.
- Qualitative editorial review by personas. That is `book-review`.
- Mechanical D1–D8 defect gating. That is `book-qa`. (`book-thesis` *contributes* D9–D12.)

## Architecture (4 layers)

`book-thesis` sits as **Layer 2–4** on top of `book-knowledge`'s **Layer 1**:

```
┌─────────────────────────────────────────────────────────────┐
│ Layer 4  EDN/Cozo consistency pass                           │
│          rules/consistency.cozo over claim facts             │
└────────────────────────┬────────────────────────────────────┘
┌────────────────────────▼────────────────────────────────────┐
│ Layer 3  Verifier-generator entailment loop                  │
│          per-paragraph LLM critic, grounded against the KG   │
└────────────────────────┬────────────────────────────────────┘
┌────────────────────────▼────────────────────────────────────┐
│ Layer 2  Thesis spine                                        │
│          YAML / RDF tree + paragraph back-pointers           │
└────────────────────────┬────────────────────────────────────┘
┌────────────────────────▼────────────────────────────────────┐
│ Layer 1  Claim ledger + EDN/Cozo store (book-knowledge)      │
└─────────────────────────────────────────────────────────────┘
```

## Components

- `scripts/compile_thesis.py` — read `thesis/<book-id>.yaml`, emit RDF triples into the book-knowledge graph.
- `scripts/lint_supports.py` — walk every paragraph in the manuscript; flag orphans (no `supports:`), broken supports (node doesn't exist), and chains that don't transitively reach `:Thesis`.
- `scripts/dispatch_entailment.py` — prepare per-paragraph payloads for an LLM entailment critic. Returns `entailed | weakly-entailed | unrelated | contradicts`.
- `scripts/consistency_cozo.py` — project the thesis spine + claim facts into book-knowledge's Cozo store, run the recursive `rules/consistency.cozo` program, emit derived contradictions (D9–D11) and write the `qa/datalog-defects.json` gate artifact.
- `scripts/synthesize_exemplars.py` — Symbolic→LLM exemplar pack generator. Given the thesis tree + claim slice for a chapter, writes a few-shot exemplar bundle used by the drafting agent.
- `rules/consistency.cozo` — the recursive CozoScript consistency program (compiled from booklogic EDN) covering transitive contradiction, orphan paragraphs, thesis-reachability.

## Composes with

- [`book-knowledge`](../book-knowledge/SKILL.md) — fact substrate. `book-thesis` projects claim facts into book-knowledge's Cozo store for the consistency pass, and `compile_thesis` emits the thesis spine as triples.
- [`book-compose`](../book-compose/SKILL.md) — the chapter contract gains a `thesis_advances:` field naming sub-arguments. `compile_thesis.py` runs at the start of `build_book`.
- [`book-qa`](../book-qa/SKILL.md) — defines four new defect classes (D9 orphan-paragraph, D10 transitive-contradiction, D11 failed-entailment, D12 unadvanced-sub-argument). `lint_supports.py` and `consistency_cozo.py` feed those gates.
- [`book-review`](../book-review/SKILL.md) — orthogonal. `book-review`'s personas do qualitative review; `book-thesis` does formal-structural check.
- [`russellian-style`](../russellian-style/SKILL.md) — orthogonal. `russellian-style` polices sentence-grain; `book-thesis` polices argument-level.

## Usage

```bash
# Compile a thesis spec into RDF triples
python scripts/compile_thesis.py <workspace> <book-id>

# Lint paragraph back-pointers against the thesis tree
python scripts/lint_supports.py <workspace> <release-version>

# Run the EDN/Cozo consistency pass (writes qa/datalog-defects.json, nonzero exit on gate failure)
python scripts/consistency_cozo.py <workspace>

# Generate an exemplar pack for a chapter
python scripts/synthesize_exemplars.py <workspace> <chapter-id>

# Prepare entailment payloads (one per paragraph) for an LLM critic
python scripts/dispatch_entailment.py <workspace> <release-version>
```

## Tests

Fixture-based pytest cases under `tests/`. Run with:

```bash
python -m pytest tests/ -v
```

Coverage:
- compile_thesis: round-trip YAML → triples → SPARQL query
- lint_supports: known-orphan paragraph fixture; known-good paragraph fixture
- consistency_cozo: contradicting-claim fixture (A→B in ch-1, B→¬A in ch-2), frozen against the C0.3 goldens
- dispatch_entailment: payload-shape contract
- synthesize_exemplars: exemplar pack shape contract

From CharlesHoskinson/russellian-book-suite, MIT.

More from CharlesHoskinson/russellian-book-suite