diff --git a/.specify/memory/constitution.md b/.specify/memory/constitution.md
index 9256cda..b2c51d0 100644
--- a/.specify/memory/constitution.md
+++ b/.specify/memory/constitution.md
@@ -1,8 +1,10 @@
 <!--
 Sync Impact Report
 ==================
-Version change: 0.0.0 → 1.0.0
-Modified principles: N/A (initial constitution)
+Version change: 1.0.0 → 1.1.0
+Modified principles:
+  - IV. Antagonistic Testing — antagonist agent changed from Gemini (external CLI)
+    to Fable (Claude model, run as a subagent). Role and rules unchanged.
 Added sections:
   - Core Principles (6 principles)
   - Architecture Constraints
@@ -65,11 +67,11 @@ Every `sys.call` MUST return the same shape:
 
 ### IV. Antagonistic Testing
 
-Tests are specifications. Claude designs, Gemini challenges, then implement.
+Tests are specifications. Claude designs, Fable challenges, then implement.
 
 - Claude (primary agent) designs first pass of tc tests
-- Gemini (antagonist) reviews tests, finds blind spots, suggests harder cases
-- After Gemini review, tests are LOCKED
+- Fable (antagonist) reviews tests, finds blind spots, suggests harder cases
+- After the antagonist review, tests are LOCKED
 - Human checkpoint ONLY when stuck (cannot make tests pass)
 - Tests MUST exist before implementation
 
@@ -130,7 +132,7 @@ Brane uses two databases, each optimized for its domain:
 
 1. **Design Interface** — Define sys.call paths (public API only)
 2. **Design Tests (Claude)** — Write tc test cases with input.json/expected.json
-3. **Review Tests (Gemini)** — Antagonist review, incorporate suggestions
+3. **Review Tests (Fable)** — Antagonist review, incorporate suggestions
 4. **Implement** — Write code (handlers thin, logic functional)
 5. **Loop Until Green** — Fix failures, re-run tests
 6. **If Stuck → Human Checkpoint** — Only when tests cannot pass
@@ -152,7 +154,7 @@ tests/{handler}/
 ### Never
 
 - Implement without tests
-- Skip Gemini review
+- Skip the antagonist review
 - Change tests after review without human approval
 - Move to next task with failing tests
 - Use classes for data structures
@@ -181,4 +183,4 @@ Constitution follows semantic versioning:
 - Complexity MUST be justified against Principle VI
 - Violations require explicit justification and human approval
 
-**Version**: 1.0.0 | **Ratified**: 2026-01-27 | **Last Amended**: 2026-01-27
+**Version**: 1.1.0 | **Ratified**: 2026-01-27 | **Last Amended**: 2026-08-19
diff --git a/CLAUDE.md b/CLAUDE.md
index 1cc40ce..b858968 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -26,6 +26,7 @@ const result = await sys.call("/namespace/method", data)
 
 - `./dna/product/ROADMAP.md` - **START HERE** — Driving task list for all development
 - `./dna/product/prd.md` - Full PRD (Split-Brain architecture)
+- `./dna/product/vision-spec-machine.md` - **Vision v4.0** — brane as the regenerative specification substrate (#112)
 - `./.specify/memory/constitution.md` - Project principles (6 core rules)
 - `./dna/technical/development-loop.md` - Antagonistic Testing process
 - `./ai/MEMORY.md` - AI's long-term memory
@@ -35,10 +36,11 @@ const result = await sys.call("/namespace/method", data)
 
 **See:** `./dna/technical/development-loop.md` and `.specify/memory/constitution.md`
 
-1. Design interface → 2. Design tests (Claude) → 3. Review tests (Gemini)
+1. Design interface → 2. Design tests (Claude) → 3. Review tests (Fable)
 4. Implement → 5. Loop until green → 6. **⛔ HUMAN CHECKPOINT** (only if stuck)
 
-**Gemini** = antagonist agent. Reviews tests, finds blind spots.
+**Fable** = antagonist agent. Reviews tests, finds blind spots. Run as a subagent
+(Agent tool, `model: fable`), not an external CLI.
 Human checkpoint is for failure resolution, not pre-approval.
 
 ## Coding Conventions Summary
@@ -79,7 +81,7 @@ ai/                   # AI agent resources
 2. Run `/speckit.specify` — creates `specs/{feature}/spec.md`
 3. Open PR for human review
 4. After approval: `/speckit.plan` → `/speckit.tasks`
-5. Review tests with Gemini (antagonist)
+5. Review tests with Fable (antagonist)
 6. Implement via `/speckit.implement`
 7. If stuck (tests won't pass) → Human checkpoint
 8. On completion → Update ROADMAP.md, mark feature complete
@@ -91,7 +93,7 @@ ai/                   # AI agent resources
 - Return different shapes from handlers
 - Skip the Result envelope
 - Implement without tests
-- Skip Gemini review
+- Skip the antagonist review
 - Change tests after review without human approval
 
 ## Active Technologies
@@ -126,6 +128,7 @@ ai/                   # AI agent resources
 - CozoDB mind.db (RocksDB backend) — new `episodes` relation + HNSW index (034-episodic-memory)
 
 ## Recent Changes
+- 067-claim-authority: First-class claims carrying authority tier + source; contradiction representable as data (#113). Schema v1.13.0, 8 sys.call paths, `contradictions` built-in rule, `brane claim` / `brane authority` CLI
 - 021-vector-search: Added semantic search via `/mind/search` endpoint with local embeddings (fastembed-js BGESmallEN, 384 dims)
 - 016-rules-define: Added TypeScript (Bun 1.x) + CozoDB (Datalog), existing mind.ts utilities
 
@@ -164,3 +167,54 @@ echo '{"query": "authentication", "limit": 5}' | bun run src/cli.ts /mind/search
   }
 }
 ```
+
+
+## Spec Machine Reframe (#112)
+
+**See:** `dna/product/vision-spec-machine.md` (v4.0)
+
+Brane is being repositioned from "memory for agents" to **the regenerative specification substrate** —
+the durable, queryable, provenance-backed graph that implementations are generated FROM and validated
+AGAINST. The existing graph, provenance, Datalog rules, lenses, and extraction pipeline are ~70% of it.
+
+Four gaps close the rest:
+
+| Gap | Feature | Issue | Status |
+|---|---|---|---|
+| Claim + authority model (contradiction as data) | `067-claim-authority` | [#113](https://github.com/ahoward/brane/issues/113) | ✅ Done (PR #117) |
+| Observation → requirement promotion gate | `068-promotion-gate` | [#114](https://github.com/ahoward/brane/issues/114) | Next — #113 is done, so it is unblocked |
+| Regeneration → test → feedback (**keystone**) | `069-regeneration-spike` | [#115](https://github.com/ahoward/brane/issues/115) | Unblocked; not started |
+| Production-as-teacher ingestion | `070-production-teacher` | [#116](https://github.com/ahoward/brane/issues/116) | Unblocked; not started |
+
+Two principles govern the claim work and should be preserved by anything built on it:
+
+1. **Strict about authority, loose about vocabulary.** Authority tiers are registered and ranked;
+   predicates and assertions are never validated against a vocabulary.
+2. **Contradiction is data, not a defect.** Competing claims coexist. Resolution is a read-time
+   projection by authority rank — never a write-time deletion. Ties do not resolve.
+
+### Claims (067-claim-authority)
+
+```bash
+brane claim create --concept 1 --predicate refund_window \
+  --assertion "30 days" --authority product --source dna/product/prd.md
+brane claim conflicts          # where the graph contradicts itself
+brane claim list --concept 1 --resolve   # one answer, losers still stored
+brane authority list           # observation < implementation < product < legal < manual
+brane verify --rule contradictions
+```
+
+Invariants anything built on claims must preserve:
+
+- Authority tiers are registered and ranked (**strict**); predicates and assertions are never
+  validated against a vocabulary (**loose**).
+- Rank is joined at read time; claims store the tier *name* only, so re-ranking never rewrites history.
+- Resolution is a read-time projection. Ties at the top rank do **not** resolve.
+- Claims are immutable — correction is delete + re-assert.
+- `cascade_claims()` in `src/lib/claims.ts` is the single deletion seam. Every path that removes a
+  concept or edge (delete handlers, `prune`, re-extraction) calls it.
+- The `contradictions` rule body positionally matches the 8-column `claims` relation. Adding a column
+  (#114's binding flag) means updating that body in the same migration.
+
+**Cozo gotcha:** string literals use backslash escapes, not SQL doubling. Use `esc_cozo()` from
+`src/lib/mind.ts`. `'it''s'` is a parse error.
diff --git a/README.md b/README.md
index fbe2d74..b1cf24b 100644
--- a/README.md
+++ b/README.md
@@ -229,6 +229,7 @@ bun run repl          # interactive mode
 ## more
 
 - [dna/product/ROADMAP.md](dna/product/ROADMAP.md) — what's next
+- [dna/product/vision-spec-machine.md](dna/product/vision-spec-machine.md) — where this is going: brane as the regenerative specification substrate
 - [dna/product/prd.md](dna/product/prd.md) — full PRD
 - [.specify/memory/constitution.md](.specify/memory/constitution.md) — project principles
 
diff --git a/ai/MEMORY.md b/ai/MEMORY.md
index a32e59f..7ff7035 100644
--- a/ai/MEMORY.md
+++ b/ai/MEMORY.md
@@ -133,7 +133,7 @@ We aim for Unix-clean, not JS-clean:
 
 **Antagonistic Testing** - Having one agent suggest tests for the other to find blind spots.
 
-The primary agent (Claude) has the most context, so it designs the first pass. The review agent (Gemini) plays adversary - finding edge cases, questioning assumptions, suggesting harder tests.
+The primary agent (Claude) has the most context, so it designs the first pass. The review agent (Fable) plays adversary - finding edge cases, questioning assumptions, suggesting harder tests.
 
 This creates tension that produces better specifications.
 
@@ -142,38 +142,44 @@ This creates tension that produces better specifications.
 | Agent | Platform | Role |
 |-------|----------|------|
 | **Claude** | Claude Code | Primary. Has context. Designs first pass of tests. Implements. |
-| **Gemini** | Google Gemini CLI | Antagonist. Reviews tests. Suggests harder cases. Finds blind spots. |
+| **Fable** | Claude Code subagent (`model: fable`) | Antagonist. Reviews tests. Suggests harder cases. Finds blind spots. |
 | **Human** | - | Checkpoint authority. Final say on test boundaries. |
 
-### Running Gemini
+### Running the Antagonist (Fable)
 
-Claude runs Gemini directly via CLI with `--resume` for session continuity:
+**Changed 2026-08-19.** The antagonist was Google Gemini via CLI. It is now **Fable**, run as a
+Claude Code subagent. Constitution 1.1.0 records the amendment. `gemini` is not installed and is no
+longer part of the loop.
 
-```bash
-gemini --resume latest "review prompt here"
+```
+Agent tool → subagent_type: "general-purpose", model: "fable"
 ```
 
-**Context to include in review prompts:**
-- Relevant conventions from `ai/MEMORY.md`
-- The specific test files being reviewed
-- What kind of feedback is wanted (edge cases, consistency, etc.)
+**What to put in the review prompt:**
+- Point it at the actual files (spec, tests, fixtures) - it reads the repo itself
+- Name the conventions it should check against (`.specify/memory/constitution.md`, `ai/MEMORY.md`)
+- Name the existing code it should check the design *fits* (handlers, migrations, tc fixtures)
+- Say what kind of feedback is wanted, and tell it to be genuinely adversarial rather than agreeable
+- Ask for severity-ranked findings with concrete fixes, and a ready/not-ready verdict
 
-This allows Gemini to build memory of project conventions across reviews.
+**Always verify its findings against the tree before acting.** It is a reviewer, not an oracle. In
+practice its blockers have been real, but the cost of checking is one grep.
 
-### Gemini (Antagonist) - IMPORTANT
+### Fable (Antagonist) - IMPORTANT
 
-- **Platform:** Google Gemini CLI
+- **Platform:** Claude Code subagent, `model: fable`
 - **Role:** Test reviewer, antagonist
 - **When to use:** After designing tc tests, BEFORE implementing
-- **How to run:** `gemini --continue` (Claude runs this directly)
+- **Also useful:** reviewing a spec/plan package before implementation starts
 
-Gemini reviews test designs and suggests:
+Fable reviews test designs and suggests:
 - Missing edge cases
 - Interface inconsistencies
 - Better error scenarios
 - Clearer expected outputs
+- Fixtures the change breaks that nobody listed
 
-**Never proceed past test boundary without Gemini's review.**
+**Never proceed past the test boundary without the antagonist review.**
 
 ---
 
@@ -182,7 +188,7 @@ Gemini reviews test designs and suggests:
 See: `dna/technical/development-loop.md`
 
 ```
-Design Interface → Design Tests (Claude) → Review Tests (Gemini)
+Design Interface → Design Tests (Claude) → Review Tests (Fable)
     → Implement → Loop Until Green → ⛔ HUMAN CHECKPOINT (only if stuck)
 ```
 
@@ -191,7 +197,7 @@ Design Interface → Design Tests (Claude) → Review Tests (Gemini)
 The human checkpoint is for **failure resolution**, not pre-approval:
 
 1. Design tests (Claude)
-2. Review tests (Gemini antagonist)
+2. Review tests (Fable antagonist)
 3. Implement code
 4. Run tests, loop until green
 5. **ONLY IF STUCK** (can't make tests pass) → Human decides: fix tests or fix code
@@ -200,8 +206,8 @@ Tests are the spec. Claude implements against them. Human intervenes only when t
 
 ### Never
 
-- Alter tests after Gemini review without human approval
-- Skip Gemini review
+- Alter tests after the antagonist review without human approval
+- Skip the antagonist review
 - Move to next task with failing tests
 - Treat test failure as "change the tests" (ask human first)
 
@@ -228,7 +234,7 @@ Tests are the spec. Claude implements against them. Human intervenes only when t
 
 1. Design sys.call interface
 2. Write tc tests (input.json, expected.json)
-3. Send to Ali (Gemini) for review
+3. Send to the antagonist (Fable) for review
 4. Incorporate feedback
 5. Create skip tests
 6. **STOP** - Wait for human
@@ -314,6 +320,45 @@ const native = require('./native/6/cozo_node_prebuilt.node');  // static
 
 ---
 
+### Spec Machine Reframe (2026-08-19)
+
+**Decision:** brane is repositioned from "memory for agents" to **the regenerative specification
+substrate** (Chad Fowler, "The Specification Is Not a Document"). Vision doc:
+`dna/product/vision-spec-machine.md` (v4.0). Umbrella issue #112.
+
+The existing substrate — graph, provenance, Datalog rules, lenses, extraction pipeline — is ~70% of
+Fowler's spec machine. Four gaps close it: claims+authority (#113), promotion gate (#114), regeneration
+(#115, keystone + research risk), production-as-teacher (#116).
+
+**Invariants established in `067-claim-authority` that later work must not break:**
+
+- Authority tiers are registered and ranked (strict); predicates and assertions are free-form (loose).
+- Competing claims coexist. Resolution is a **read-time projection**, never a write-time deletion.
+- Authority rank is joined at read time — claims store the tier *name* only, so re-ranking never
+  rewrites history.
+- Ties at the top rank do **not** resolve. `resolution: null`, `unresolved: true`. No tiebreak by
+  recency or ID.
+- Claims are immutable. Correction = delete + re-assert.
+- Conflict comparison is trim-then-exact and **case-sensitive** — case folding would silently hide
+  conflicts, which is the failure this feature exists to prevent.
+
+**Gotchas found while implementing #113:**
+
+- The built-in `contradictions` Datalog rule positionally matches the 8-column `claims` arity. Any
+  feature adding a claims column (e.g. #114's binding flag) must update the rule body in the same
+  migration.
+- **CozoDB string literals use backslash escapes, not SQL doubling.** `'it''s'` is a parse error;
+  `'it\\'s'` is correct. `src/handlers/mind/rules/create.ts` had been doing it the SQL way since it
+  was written — any rule body containing an apostrophe silently failed to save. Fixed via
+  `esc_cozo()` in `src/lib/mind.ts`; use it for every interpolated string. Query parameters (`$val`)
+  also work and avoid the question entirely.
+- `/mind/provenance/create` validates the file against body.db, so tests that need *stale* provenance
+  must add the body row, create the link, then delete the row (see `tests/mind/prune/run`).
+- `prune` only removes concepts whose provenance is **entirely** stale. A concept with no provenance
+  at all is never an orphan and is never pruned.
+
+---
+
 ## Version History
 
 | Date | Change |
@@ -322,3 +367,6 @@ const native = require('./native/6/cozo_node_prebuilt.node');  // static
 | 2026-01-26 | Added multi-agent system (Ali/Gemini). Development loop defined. |
 | 2026-01-28 | CozoDB decision: Keep it, fix bundler via PR to upstream. |
 | 2026-01-28 | Multi-platform compilation working. src/lib/cozo.ts + CI workflow. |
+| 2026-08-19 | Spec machine reframe (#112). vision-spec-machine.md v4.0. 067-claim-authority spec + plan (PR #117). |
+| 2026-08-19 | Antagonist changed from Gemini CLI to Fable subagent. Constitution 1.0.0 → 1.1.0. |
+| 2026-08-21 | 067-claim-authority implemented. mind.db schema v1.13.0. Cozo escaping bug found and fixed. |
diff --git a/dna/product/ROADMAP.md b/dna/product/ROADMAP.md
index 00a9340..d3d7b44 100644
--- a/dna/product/ROADMAP.md
+++ b/dna/product/ROADMAP.md
@@ -12,7 +12,7 @@ specs/{NN-feature}/spec.md      ← /speckit.specify → PR for human review
 specs/{NN-feature}/plan.md      ← /speckit.plan
 specs/{NN-feature}/tasks.md     ← /speckit.tasks
     ↓
-Gemini review                   ← Antagonistic test review (tc tests)
+Fable review                    ← Antagonistic test review (tc tests)
     ↓
 Implementation                  ← /speckit.implement
     ↓
@@ -91,6 +91,15 @@ The hippocampus: 3 verbs, dual-write graph + audit trail, trust tiers. The agent
 - [x] `108-graph-backed-recall` — Auto-connect on remember, graph context in recall ([#108](https://github.com/ahoward/brane/issues/108))
 - [x] `109-append-only-consolidation` — New concepts + CAUSED_BY edges, never mutate sources ([#109](https://github.com/ahoward/brane/issues/109))
 
+### Spec Machine — brane as the regenerative specification substrate ([#112](https://github.com/ahoward/brane/issues/112))
+
+Vision: `dna/product/vision-spec-machine.md` (v4.0). Closing the 30% gap between "memory for agents" and Fowler's spec machine.
+
+- [x] `067-claim-authority` — First-class claims carrying authority tier + source; contradiction as data ([#113](https://github.com/ahoward/brane/issues/113), [PR #117](https://github.com/ahoward/brane/pull/117))
+- [ ] `068-promotion-gate` — Observation → requirement promotion with human ratification ([#114](https://github.com/ahoward/brane/issues/114))
+- [ ] `069-regeneration-spike` — **Keystone**: regenerate from graph → test → feed failures back ([#115](https://github.com/ahoward/brane/issues/115))
+- [ ] `070-production-teacher` — Ingest prod traces / incidents / evals as evidence ([#116](https://github.com/ahoward/brane/issues/116))
+
 ### Deferred
 
 - [ ] `028-verifier-node` — Headless verification node
@@ -104,6 +113,7 @@ The hippocampus: 3 verbs, dual-write graph + audit trail, trust tiers. The agent
 
 | Feature | PR | Date |
 |---------|-----|------|
+| `067-claim-authority` | #117 | 2026-08-21 |
 | `102-109-hippocampus-v2` | #110 | 2026-05-30 |
 | `058-status-dashboard` | #81 | 2026-03-27 |
 | `057-cli-ingest-sessions` | #80 | 2026-03-27 |
@@ -185,3 +195,4 @@ The hippocampus: 3 verbs, dual-write graph + audit trail, trust tiers. The agent
 - **032-corpus complete!** — Adversarial test material: surveillance, dark patterns, COPPA violations, alignment-washing
 - **049-schema-migrations complete!** — Versioned mind.db upgrades with backup/restore, Gemini-reviewed
 - **053-fuzzy-dedup complete!** — Length-scaled Levenshtein prevents false matches on short concept names
+- **067-claim-authority complete!** — Claims carry authority tier + source; contradiction is data. Schema v1.13.0, `contradictions` built-in rule, Fable-reviewed (2 rounds, 3 blockers), 432 tests
diff --git a/dna/technical/development-loop.md b/dna/technical/development-loop.md
index 2b259db..06f0291 100644
--- a/dna/technical/development-loop.md
+++ b/dna/technical/development-loop.md
@@ -8,12 +8,12 @@ This project uses **Antagonistic Testing** - a rigorous test-first process where
 
 ## Antagonistic Testing
 
-The primary agent (Claude) has the most context, so it designs the first pass of tests. The review agent (Gemini) plays **antagonist** - questioning assumptions, finding edge cases, suggesting harder tests.
+The primary agent (Claude) has the most context, so it designs the first pass of tests. The review agent (Fable) plays **antagonist** - questioning assumptions, finding edge cases, suggesting harder tests.
 
 This tension produces better specifications than either agent alone.
 
 ```
-Claude (context)  →  designs tests  →  Gemini (antagonist)  →  challenges  →  better tests
+Claude (context)  →  designs tests  →  Fable (antagonist)  →  challenges  →  better tests
 ```
 
 The antagonist asks:
@@ -44,8 +44,8 @@ Neither agent proceeds alone. Both must agree before the test boundary.
 └─────────────────────────────────────────────────────────────────┘
                               ↓
 ┌─────────────────────────────────────────────────────────────────┐
-│  3. REVIEW TESTS (Gemini)                                       │
-│     - Send tests to Gemini for antagonist review                │
+│  3. REVIEW TESTS (Fable)                                        │
+│     - Send tests to Fable for antagonist review                 │
 │     - Incorporate suggestions                                   │
 │     - Tests are now LOCKED (no changes without human approval)  │
 └─────────────────────────────────────────────────────────────────┘
@@ -87,7 +87,7 @@ Neither agent proceeds alone. Both must agree before the test boundary.
 
 The human checkpoint is for **failure resolution**, not pre-approval.
 
-After Gemini review, tests are LOCKED. Claude implements against them.
+After the antagonist review, tests are LOCKED. Claude implements against them.
 
 **Human intervenes ONLY when:**
 - Claude cannot make tests pass after good-faith effort
@@ -99,7 +99,7 @@ After Gemini review, tests are LOCKED. Claude implements against them.
 Every test suite goes through adversarial review:
 
 1. **Claude** (primary, has context) - Designs initial tests based on full project understanding
-2. **Gemini** (antagonist) - Challenges tests, finds blind spots, suggests harder cases
+2. **Fable** (antagonist) - Challenges tests, finds blind spots, suggests harder cases
 
 The antagonist's job is to **break** the tests - find what Claude missed. This tension produces robust specifications.
 
@@ -108,7 +108,7 @@ Neither agent proceeds alone. Both must agree on the test design.
 ### Never Skip the Loop
 
 - No implementing without tests
-- No tests without Gemini review
+- No tests without an antagonist review
 - No changing tests after review without human approval
 - No moving to next task until current tests pass
 
@@ -122,11 +122,12 @@ Neither agent proceeds alone. Both must agree on the test design.
 - Has full project context (dna/, ai/MEMORY.md, codebase)
 - Designs `sys.call` interface (public API only)
 - Writes **first pass** of tc tests
-- Implements after Gemini review (no pre-approval needed)
+- Implements after the antagonist review (no pre-approval needed)
 - Updates `ai/NOTES.md` and `ai/MEMORY.md`
 
-### Gemini (Antagonist)
+### Fable (Antagonist)
 
+- Run as a subagent (Agent tool, `model: fable`) - not an external CLI
 - Receives test designs from Claude
 - **Plays adversary** - tries to break the tests
 - Asks "what if?" questions
@@ -138,7 +139,7 @@ Neither agent proceeds alone. Both must agree on the test design.
 
 - Intervenes **only when Claude is stuck** (can't make tests pass)
 - Decides: fix tests OR fix code
-- Final authority on test changes after Gemini review
+- Final authority on test changes after the antagonist review
 - Does NOT need to pre-approve implementation
 
 ---
@@ -198,7 +199,7 @@ tests/body/files/hash/data/
     └── expected.json   # { "status": "error", "errors": { "path": [...] } }
 ```
 
-**Step 3: Review (Gemini)**
+**Step 3: Review (Fable)**
 - "Add test for permission denied"
 - "Add test for directory (not file)"
 - Claude incorporates feedback
diff --git a/specs/067-claim-authority/contracts/authorities.md b/specs/067-claim-authority/contracts/authorities.md
new file mode 100644
index 0000000..16bc1bc
--- /dev/null
+++ b/specs/067-claim-authority/contracts/authorities.md
@@ -0,0 +1,75 @@
+# Contract: `/mind/authorities/*`
+
+Standard envelope. Error codes: `required`, `invalid`, `not_found`, `conflict`, `not_initialized`.
+
+---
+
+## `/mind/authorities/list`
+
+**Params**: none.
+
+**Result**
+
+```json
+{
+  "authorities": [
+    { "name": "manual",         "rank": 100, "description": "Direct human assertion; highest standing" },
+    { "name": "legal",          "rank": 40,  "description": "Legal or regulatory constraint" },
+    { "name": "product",        "rank": 30,  "description": "Product intent" },
+    { "name": "implementation", "rank": 20,  "description": "What the code actually does" },
+    { "name": "observation",    "rank": 10,  "description": "Recorded from experience; non-binding by default" }
+  ],
+  "count": 5
+}
+```
+
+Ordered by `rank` descending, then `name` ascending. A freshly initialized mind.db returns exactly these
+five seeded tiers (FR-005, spec 5.1).
+
+---
+
+## `/mind/authorities/create`
+
+Register a tier, or update one that already exists (upsert — spec 5.3).
+
+**Params**
+
+| field | type | required | notes |
+|---|---|---|---|
+| `name` | string | yes | trimmed then stored, ≤ 64, non-empty after trim |
+| `rank` | int | yes | non-negative integer |
+| `description` | string | no | on create defaults to `""`; on update of an existing tier, **omitting it preserves the current description** — it is never blanked by a rank-only update |
+
+**Result**
+
+```json
+{ "name": "security", "rank": 35, "description": "Security review finding", "created": true }
+```
+
+`created` is `false` when an existing tier was updated. Updating a rank does **not** rewrite claims —
+they pick up the new rank on the next read (FR-012, D2).
+
+**Errors**
+
+| condition | field | code |
+|---|---|---|
+| missing `name` or `rank` | that field | `required` |
+| `rank` non-integer or negative | `rank` | `invalid` |
+| `name` empty after trim or over cap | `name` | `invalid` |
+| mind.db not initialized | `mind` | `not_initialized` |
+
+---
+
+## `/mind/authorities/delete`
+
+**Params**: `{ "name": "security" }` (required)
+
+**Result**: `{ "name": "security", "deleted": true }`
+
+**Errors**
+
+| condition | field | code |
+|---|---|---|
+| missing `name` | `name` | `required` |
+| tier does not exist | `name` | `not_found` |
+| one or more claims reference the tier | `name` | `conflict` — message names the referencing claim count; nothing is deleted (D8, spec 5.4) |
diff --git a/specs/067-claim-authority/contracts/claims.md b/specs/067-claim-authority/contracts/claims.md
new file mode 100644
index 0000000..2c47326
--- /dev/null
+++ b/specs/067-claim-authority/contracts/claims.md
@@ -0,0 +1,180 @@
+# Contract: `/mind/claims/*`
+
+All paths return the standard envelope:
+
+```json
+{ "status": "success" | "error", "result": T | null, "errors": ErrorMap | null,
+  "meta": { "path": "...", "timestamp": "...", "duration_ms": 0 } }
+```
+
+Error codes used: `required`, `invalid`, `not_found`, `not_initialized`.
+
+---
+
+## `/mind/claims/create`
+
+Assert a claim. Idempotent on the full 5-tuple (D4).
+
+**Params**
+
+| field | type | required | notes |
+|---|---|---|---|
+| `subject_type` | string | yes | `"concept"` or `"edge"` |
+| `subject_id` | int | yes | must exist |
+| `predicate` | string | yes | free-form, trimmed then stored, ≤ 256 after trim |
+| `assertion` | string | yes | free-form, trimmed then stored, ≤ 4096 after trim |
+| `authority` | string | yes | trimmed; must be a registered tier |
+| `source` | string | yes | opaque provenance, trimmed then stored, ≤ 1024 after trim |
+
+All four are trimmed at the boundary (FR-016b) so every downstream comparison — idempotency, conflict
+grouping, and Datalog — sees identical strings.
+
+**Result**
+
+```json
+{
+  "id": 1,
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "rank": 30,
+  "source": "dna/product/prd.md",
+  "created_at": "2026-08-19T00:00:00.000Z",
+  "created": true
+}
+```
+
+`created` is `false` when an identical claim already existed (idempotent re-assertion); the existing
+row is returned unchanged, including its original `id` and `created_at`.
+
+**Errors**
+
+| condition | field | code |
+|---|---|---|
+| missing any required field | that field | `required` |
+| `subject_type` not `concept`/`edge` | `subject_type` | `invalid` |
+| subject does not exist | `subject_id` | `not_found` |
+| authority tier not registered | `authority` | `not_found` |
+| field exceeds cap or empty after trim | that field | `invalid` |
+| mind.db not initialized | `mind` | `not_initialized` |
+
+---
+
+## `/mind/claims/get`
+
+**Params**: `{ "id": 1 }` (required)
+
+**Result**: a single claim object, same shape as create's result minus `created`.
+
+**Errors**: `id` `required`; `id` `not_found`.
+
+---
+
+## `/mind/claims/list`
+
+**Params** (all optional; AND-combined)
+
+| field | type | notes |
+|---|---|---|
+| `subject_type` | string | `"concept"` or `"edge"` |
+| `subject_id` | int | matches claims on either subject type unless `subject_type` is also given |
+| `predicate` | string | exact match |
+| `authority` | string | tier name, exact match |
+| `resolve` | bool | default `false`. When `true`, returns only the highest-rank claim per `(subject_type, subject_id, predicate)` |
+| `limit` | int | default 100 |
+
+**Result**
+
+```json
+{
+  "claims": [
+    { "id": 2, "subject_type": "concept", "subject_id": 1, "predicate": "refund_window",
+      "assertion": "14 days", "authority": "legal", "rank": 40,
+      "source": "legal/policy.md", "created_at": "..." }
+  ],
+  "count": 1,
+  "resolved": false
+}
+```
+
+Ordering: `rank` descending, then `id` ascending.
+
+With `resolve: true`, `resolved` is `true` and resolution is per `(subject_type, subject_id,
+predicate)` group — **not** a global maximum. Ties at the top rank return **all** tied claims for that
+group (spec 4.2); the list shape carries no per-group flag, so a caller who needs to know a group is
+unresolved asks `/mind/claims/conflicts`. Resolution performs **no writes** (SC-002).
+
+Empty match → `{"claims": [], "count": 0, "resolved": false}` with `status: "success"` (FR-018).
+
+---
+
+## `/mind/claims/conflicts`
+
+Groups where one subject+predicate carries two or more distinct assertions.
+
+**Params** (all optional)
+
+| field | type | notes |
+|---|---|---|
+| `subject_type` | string | filter |
+| `subject_id` | int | filter |
+| `predicate` | string | filter |
+
+**Result**
+
+```json
+{
+  "conflicts": [
+    {
+      "subject_type": "concept",
+      "subject_id": 1,
+      "predicate": "refund_window",
+      "claims": [
+        { "id": 2, "assertion": "14 days", "authority": "legal",          "rank": 40, "source": "legal/policy.md",  "created_at": "..." },
+        { "id": 1, "assertion": "30 days", "authority": "product",        "rank": 30, "source": "dna/product/prd.md", "created_at": "..." },
+        { "id": 3, "assertion": "45 days", "authority": "implementation", "rank": 20, "source": "src/billing.ts",   "created_at": "..." }
+      ],
+      "resolution": { "id": 2, "assertion": "14 days", "authority": "legal", "rank": 40 },
+      "unresolved": false
+    }
+  ],
+  "count": 1
+}
+```
+
+Tie at top rank → `"resolution": null, "unresolved": true`.
+No conflicts → `{"conflicts": [], "count": 0}`, `status: "success"`.
+Groups are never truncated (spec edge case).
+
+Group ordering: `subject_type` ascending, then `subject_id` ascending, then `predicate` ascending.
+Claims within a group: `rank` descending, then `id` ascending. Edge subjects produce conflict groups
+here even though the built-in `contradictions` rule is concept-only (research D7).
+
+---
+
+## `/mind/claims/delete`
+
+**Params**: `{ "id": 1 }` (required)
+
+**Result**: `{ "id": 1, "deleted": true }`
+
+**Errors**: `id` `required`; `id` `not_found`.
+
+**Implementation note**: `claims` is an all-key relation, so `:rm` needs the full 8-column row. Read the
+row by `id`, then remove it — the same read-then-remove shape as `annotations/delete.ts`.
+
+---
+
+## Cascade shape changes on existing paths
+
+Claims cascade wherever their subject is removed (D8), and the affected handlers report it:
+
+| path | change |
+|---|---|
+| `/mind/concepts/delete` | `cascade` object gains `claims_removed` — counts claims on the concept **and** on the edges that deletion cascades away |
+| `/mind/edges/delete` | result gains `claims_removed` alongside `deleted` |
+| `/mind/prune` | prunes claims for pruned concepts and edges |
+
+These change locked fixtures; see research D11.
diff --git a/specs/067-claim-authority/data-model.md b/specs/067-claim-authority/data-model.md
new file mode 100644
index 0000000..77ec7aa
--- /dev/null
+++ b/specs/067-claim-authority/data-model.md
@@ -0,0 +1,179 @@
+# Phase 1 Data Model: Claim + Authority
+
+**Feature**: `067-claim-authority` | **Schema**: mind.db v1.12.0 → **v1.13.0**
+
+---
+
+## Relation: `claims`
+
+```datalog
+:create claims {
+  id: Int,
+  subject_type: String,
+  subject_id: Int,
+  predicate: String,
+  assertion: String,
+  authority: String,
+  source: String,
+  created_at: String
+}
+```
+
+| Field | Type | Notes |
+|---|---|---|
+| `id` | Int | Sequential handle, allocated by `get_next_claim_id()` — same pattern as concepts/edges/episodes. **Not a declared primary key** (see Key semantics below). |
+| `subject_type` | String | `"concept"` or `"edge"`. Validated on write. |
+| `subject_id` | Int | Must exist in `concepts` or `edges` per `subject_type`. |
+| `predicate` | String | Free-form label, e.g. `refund_window`. **Never validated against a vocabulary.** Stored trimmed. ≤ 256 chars after trim. |
+| `assertion` | String | Free-form value, e.g. `30 days`. **Never validated.** Stored trimmed. ≤ 4096 chars after trim. |
+| `authority` | String | Tier **name**, must exist in `authorities`. Stored trimmed. Rank is *not* stored here (D2). |
+| `source` | String | Opaque provenance: file URL, session id, agent id, or human identifier. Not validated against body.db. Stored trimmed. ≤ 1024 chars after trim. |
+| `created_at` | String | ISO 8601, server-generated. |
+
+**Invariants**
+
+1. `subject_type ∈ {"concept", "edge"}`.
+2. The subject exists at write time (FR-002).
+3. `authority` names a registered tier at write time (FR-003).
+4. `predicate`, `assertion`, `authority`, `source` are trimmed at write time and non-empty after trim (FR-016b).
+5. No two rows share the tuple `(subject_type, subject_id, predicate, assertion, authority, source)` — idempotency (D4), enforced by the pre-insert lookup, compared on stored (trimmed) values.
+6. Rows are **immutable**. No update path. Correction = delete + re-assert (spec Assumptions).
+
+**Key semantics** — the declaration has no `=>`, so, per this repo's convention (see the comment in
+`src/lib/mind.ts` and the `concepts`/`edges`/`annotations` declarations), **all 8 columns form the
+composite key**. Three consequences the implementation must honor:
+
+- `id` uniqueness is enforced by the allocator, not by the schema.
+- `:rm` requires the **full 8-column row**. Deletion must read-then-remove, exactly as
+  `annotations/delete.ts` and `edges/delete.ts` already do. There is no delete-by-id shortcut.
+- Invariant 5 is application-enforced. The composite key alone would not catch a re-assert, because
+  `created_at` differs on every attempt.
+
+**Arity coupling**: 8 columns. The built-in `contradictions` rule body positionally matches this shape.
+Any future column (e.g. #114's `binding`) MUST update the rule body in the same migration. The tc suite
+asserts the rule executes without error, which is what makes an arity break fail loudly — built-in rules
+are seeded by raw `:put` and are **not** syntax-validated at init.
+
+---
+
+## Relation: `authorities`
+
+```datalog
+:create authorities {
+  name: String
+  =>
+  rank: Int,
+  description: String
+}
+```
+
+| Field | Type | Notes |
+|---|---|---|
+| `name` | String | PK. Tier identifier, e.g. `legal`. ≤ 64 chars, non-empty after trim. |
+| `rank` | Int | Higher = more authoritative. Must be a non-negative integer. |
+| `description` | String | Human-readable purpose. May be empty. |
+
+**Invariants**
+
+1. `name` is unique — re-registering an existing name is an **update**, not a duplicate (FR-006, spec 5.3). An upsert that omits `description` **preserves** the existing description rather than blanking it.
+2. `rank` is a non-negative integer; non-integer or negative is a validation error (spec 5.5).
+3. A tier referenced by any claim cannot be deleted (FR-006, D8).
+4. Ranks need not be unique — two tiers may tie, which is precisely what produces `unresolved` groups.
+
+**Naming note**: `authority` now means three unrelated things in mind.db. `annotations.authority` is
+always the literal `"infinity"`; `golden_types.authority` / `golden_relations.authority` is `"lens"` or
+`"manual"` and records where an ontology entry came from; `claims.authority` is a tier name in this
+registry. They are unrelated fields that happen to share a word. Only the third is ranked.
+
+**Seeded on init and on migration** (D6):
+
+| name | rank | description |
+|---|---|---|
+| `observation` | 10 | Recorded from experience; non-binding by default |
+| `implementation` | 20 | What the code actually does |
+| `product` | 30 | Product intent |
+| `legal` | 40 | Legal or regulatory constraint |
+| `manual` | 100 | Direct human assertion; highest standing |
+
+---
+
+## Derived: Conflict Group
+
+**Not stored.** Computed per request by `/mind/claims/conflicts` and by `list` with `resolve: true`.
+
+```json
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "claims": [
+    { "id": 2, "assertion": "14 days", "authority": "legal",          "rank": 40, "source": "legal/policy.md",  "created_at": "..." },
+    { "id": 1, "assertion": "30 days", "authority": "product",        "rank": 30, "source": "dna/product/prd.md", "created_at": "..." },
+    { "id": 3, "assertion": "45 days", "authority": "implementation", "rank": 20, "source": "src/billing.ts",   "created_at": "..." }
+  ],
+  "resolution": { "id": 2, "assertion": "14 days", "authority": "legal", "rank": 40 },
+  "unresolved": false
+}
+```
+
+**Construction**
+
+1. Fetch claims (filtered), left-joined to `authorities` for `rank`.
+2. Group by `(subject_type, subject_id, predicate)`.
+3. A group is a **conflict** when it holds ≥ 2 distinct trimmed `assertion` values (D3). Same assertion
+   from two authorities is agreement — not a conflict (spec 3.3).
+4. `claims` within a group are ordered by `rank` descending, then `id` ascending (stable output).
+5. `resolution` = the single highest-rank claim. If two or more claims tie at the top rank *with
+   different assertions*, `resolution` is `null` and `unresolved` is `true` (spec 3.4). Never break a tie.
+
+**Missing tier edge case**: a claim whose tier was somehow removed (should be impossible per invariant 3)
+reads with `rank: null` and sorts last; it never wins a resolution.
+
+---
+
+## Cascades and referential rules
+
+All concept/edge removal flows through one lib function, `cascade_claims(db, subject_type, ids)`, so no
+path can forget (D8).
+
+| Event | Effect |
+|---|---|
+| `/mind/concepts/delete` | Removes claims on the concept **and** claims on every edge that the concept's deletion cascades away. The handler already collects those edges to `:rm` them; the same ID set feeds `cascade_claims`. Reported as `cascade.claims_removed`. |
+| `/mind/edges/delete` | Removes claims with `subject_type = "edge"` and matching `subject_id`. Reported as `claims_removed`. |
+| `/mind/prune` | Removes claims for every concept and edge it prunes. Prune deletes directly, bypassing the handlers — annotations already dangle here, and claims must not repeat that (D8). |
+| `calabi/extract` re-extraction | Same: claims for replaced concepts/edges are removed via `cascade_claims`. |
+| `/mind/authorities/delete` on a referenced tier | **Refused.** Error, no change (D8). |
+| `/mind/authorities/create` on an existing name | Rank/description updated in place. Existing claims reflect the new rank on the next read — no rewrite (D2, FR-012). |
+| `/mind/claims/delete` | Removes one row. Conflict groups recompute on the next query (spec 7.3). |
+
+---
+
+## Built-in rule: `contradictions`
+
+Registered alongside `cycles` and `orphans` in `BUILTIN_RULES` (init) and `BUILTIN_RULE_NAMES` (lib/mind.ts).
+
+```datalog
+contradictions[id, name] :=
+  *concepts[id, name, _, _, _],
+  *claims[c1, 'concept', id, pred, a1, _, _, _],
+  *claims[c2, 'concept', id, pred, a2, _, _, _],
+  c1 < c2,
+  a1 != a2
+```
+
+Returns `[id, name]` — the fixed contract consumed by `/mind/rules/query`, `/mind/verify`, and
+`pr-verify` (`execute_rule` in `src/handlers/mind/verify.ts`). No changes to those consumers.
+
+**Known gap**: concept subjects only. Edge-subject contradictions are visible through
+`/mind/claims/conflicts` but not through the rule, because the `[id, name]` contract cannot distinguish
+an edge ID from a concept ID (D7).
+
+---
+
+## Schema version
+
+`LATEST_VERSION` in `src/lib/migrate.ts`: `1.12.0` → `1.13.0`.
+`SCHEMA_VERSION` in `src/handlers/mind/init.ts`: `1.12.0` → `1.13.0`.
+
+A freshly initialized v1.13.0 database and a v1.12.0 database migrated to v1.13.0 MUST be
+indistinguishable — same relations, same seeded tiers, same built-in rules.
diff --git a/specs/067-claim-authority/plan.md b/specs/067-claim-authority/plan.md
new file mode 100644
index 0000000..c21e118
--- /dev/null
+++ b/specs/067-claim-authority/plan.md
@@ -0,0 +1,145 @@
+# Implementation Plan: First-Class Claim + Authority Model
+
+**Branch**: `067-claim-authority` | **Date**: 2026-08-19 | **Spec**: [spec.md](./spec.md)
+**Issue**: [#113](https://github.com/ahoward/brane/issues/113) | **Umbrella**: [#112](https://github.com/ahoward/brane/issues/112)
+**Input**: Feature specification from `/specs/067-claim-authority/spec.md`
+
+## Summary
+
+Add two CozoDB relations to `mind.db` — `claims` (assertions about concepts/edges) and `authorities`
+(a ranked, registered tier set) — plus eight sys.call handlers, one built-in Datalog rule, a schema
+migration, and CLI surfaces.
+
+The whole design turns on one decision: **authority rank is joined at read time, never copied into the
+claim row, and resolution is a projection that never writes.** That is what keeps contradiction durable
+instead of collapsing it on insert.
+
+## Technical Context
+
+**Language/Version**: TypeScript 5.x on Bun 1.x
+**Primary Dependencies**: cozo-node (CozoDB, RocksDB backend), citty (CLI) — all existing
+**Storage**: CozoDB `mind.db` — two new relations (`claims`, `authorities`), schema v1.12.0 → v1.13.0
+**Testing**: tc suites (`tests/mind/claims/`, `tests/mind/authorities/`), shell runner + JSON fixtures
+**Target Platform**: Linux/macOS CLI, local-first, offline
+**Project Type**: Single project (existing brane layout)
+**Performance Goals**: claim/conflict/resolved queries < 1s at 10,000 claims (SC-007)
+**Constraints**: No new dependencies. No embeddings (conflict is exact-match, not semantic). Migration
+must preserve all existing data and be backup/restore-safe.
+**Scale/Scope**: 8 handlers, 1 migration, 1 built-in rule, 2 CLI command groups, ~2 lib modules touched
+
+## Constitution Check
+
+*GATE: passed before Phase 0, re-checked after Phase 1 design.*
+
+| Principle | Compliance |
+|---|---|
+| I. POD only | Claims, tiers, conflict groups are interfaces over plain JSON. No classes. |
+| II. Result envelope | All 8 handlers return `success()` / `error()` from `lib/result.ts`. |
+| III. sys.call public API only | Handlers are thin; shared logic lands in `src/lib/claims.ts` as plain functions. |
+| IV. Antagonistic testing | tc suites written and Fable-reviewed before implementation. Tests lock after review. |
+| V. Unix-clean | `null` over `undefined`, JSON on stdout, non-zero exit on error, snake_case fields. |
+| VI. Simplicity (YAGNI) | No `binding` flag, no retraction audit, no semantic conflict detection, no claim→claim edges. All deferred to #114/#115/#116 and recorded in spec Out of Scope. |
+
+**Complexity to justify**: one — a second new relation (`authorities`) rather than a hardcoded tier
+constant. Justified in Complexity Tracking below.
+
+**Post-design re-check**: passed. Design adds no classes, no exceptions-for-control-flow, no new
+dependencies, and no handler that returns a non-envelope shape.
+
+## Project Structure
+
+### Documentation (this feature)
+
+```text
+specs/067-claim-authority/
+├── spec.md              # Feature specification (merged in PR #117)
+├── plan.md              # This file
+├── research.md          # Phase 0: decisions + rationale
+├── data-model.md        # Phase 1: relations, fields, invariants
+├── contracts/           # Phase 1: sys.call request/response contracts
+│   ├── claims.md
+│   └── authorities.md
+├── quickstart.md        # Phase 1: the refund scenario, end to end
+└── tasks.md             # Phase 2
+```
+
+### Source Code (repository root)
+
+```text
+src/
+├── lib/
+│   ├── claims.ts                       # NEW — id allocation, validation, rank join, conflict grouping, cascade_claims()
+│   ├── mind.ts                         # MODIFIED — BUILTIN_RULE_NAMES += "contradictions"
+│   └── migrate.ts                      # MODIFIED — v1.12.0 → v1.13.0 migration, LATEST_VERSION bump
+├── handlers/mind/
+│   ├── init.ts                         # MODIFIED — schema v1.13.0, new relations, seed tiers, new builtin rule
+│   ├── claims/
+│   │   ├── create.ts                   # NEW — /mind/claims/create
+│   │   ├── get.ts                      # NEW — /mind/claims/get
+│   │   ├── list.ts                     # NEW — /mind/claims/list (filters + resolve)
+│   │   ├── delete.ts                   # NEW — /mind/claims/delete
+│   │   └── conflicts.ts                # NEW — /mind/claims/conflicts
+│   ├── authorities/
+│   │   ├── create.ts                   # NEW — /mind/authorities/create (upsert)
+│   │   ├── list.ts                     # NEW — /mind/authorities/list
+│   │   └── delete.ts                   # NEW — /mind/authorities/delete (refuses if referenced)
+│   ├── concepts/delete.ts              # MODIFIED — cascade claims (incl. claims on cascaded edges)
+│   ├── edges/delete.ts                 # MODIFIED — cascade claims
+│   └── prune.ts                        # MODIFIED — cascade claims for pruned concepts/edges
+├── cli/
+│   ├── commands/claim.ts               # NEW — brane claim create|list|get|delete|conflicts
+│   ├── commands/authority.ts           # NEW — brane authority list|create|delete
+│   └── main.ts                         # MODIFIED — register both under admin + backward-compat top level
+└── index.ts                            # MODIFIED — sys.register the 8 new paths
+
+src/handlers/calabi/extract.ts          # MODIFIED — cascade claims on re-extraction
+
+tests/mind/
+├── claims/                             # NEW — run + data/NN-case/{params,result}.json
+├── authorities/                        # NEW — run + data/NN-case/{params,result}.json
+├── verify/, rules/list/, init/, concepts/delete/   # MODIFIED fixtures — see research D11
+```
+
+**Structure Decision**: Existing single-project brane layout. Handlers map to sys.call paths one-to-one
+(`/mind/claims/create` → `src/handlers/mind/claims/create.ts`), matching the annotations and episodes
+precedent exactly. Shared non-handler logic goes in `src/lib/claims.ts` per constitution III.
+
+## Phase 0 — Research
+
+See [research.md](./research.md). Ten decisions recorded, including the three the spec deferred to this
+phase:
+
+- **Case sensitivity** → conflict comparison is trim-then-exact, **case-sensitive**.
+- **Rank storage** → registry lookup at read time; claims store the tier *name* only.
+- **Idempotency** → pre-insert lookup on the full 5-tuple, no content hash.
+
+## Phase 1 — Design
+
+- [data-model.md](./data-model.md) — the two relations, field types, invariants, cascade rules, and the
+  derived conflict-group shape.
+- [contracts/claims.md](./contracts/claims.md) — request/response for the five claim paths.
+- [contracts/authorities.md](./contracts/authorities.md) — request/response for the three authority paths.
+- [quickstart.md](./quickstart.md) — the refund 30/14/45 walkthrough as a copy-pasteable session.
+
+## Phase 2 — Tasks
+
+Generated into [tasks.md](./tasks.md). Ordering is **tests first**, per constitution IV: fixture
+reconciliation and tc authoring → Fable antagonist review (lock) → schema/migration → lib → handlers →
+CLI → green. No implementation task, including the shared library, precedes the lock.
+
+## Risks
+
+| Risk | Mitigation |
+|---|---|
+| Cozo arity coupling — the built-in `contradictions` rule hardcodes the 8-column `claims` shape; a later column addition (e.g. #114's `binding`) breaks it | Document the coupling in `data-model.md`; #114 must update the rule body in the same migration. **Built-in rules are seeded by raw `:put` and are not syntax-validated at init** — a break surfaces at query time as a caught per-rule `error` string, which is quiet. The real safety net is the tc case asserting `contradictions` executes with `error: null`. |
+| Claims dangling after `prune` or re-extraction, which delete concepts/edges without going through the delete handlers (annotations already dangle there) | One `cascade_claims()` lib function called from all four deletion sites, rather than per-handler cascade code. Costs one function; the alternative ships a known integrity hole in a feature about integrity. |
+| Locked fixtures break on the version bump and the third built-in rule | Enumerated in research D11 and given an explicit human-approved task (T003). Not folded silently into implementation. |
+| Migration on a live db | Reuse the existing backup/restore path in `migrate.ts` — no new machinery. New relations only; no data rewrite, so restore is cheap. |
+| Idempotency pre-insert lookup cost at scale | The 5-tuple lookup is a filtered scan; acceptable at the 10k target. Revisit with an index only if SC-007 fails. |
+| `resolve: true` and conflict grouping done in TypeScript rather than Datalog | Deliberate — grouping/tie logic in Datalog is opaque and hard to test. Rows come back from a single query; grouping is in-memory. Revisit if 10k claims breaches SC-007. |
+
+## Complexity Tracking
+
+| Violation | Why Needed | Simpler Alternative Rejected Because |
+|-----------|------------|-------------------------------------|
+| Second new relation (`authorities`) instead of a hardcoded `AUTHORITY_TIERS` constant | Spec FR-006 requires projects to register their own tiers (`security`, `sre`, `compliance`) and FR-012 requires re-ranking without rewriting claims. A constant makes both impossible. | A hardcoded tier list would make "strict about authority" mean "strict about *brane's* authorities", which is not the principle. The registry is 3 fields and 3 handlers — the smallest thing that satisfies FR-004/006/012. |
diff --git a/specs/067-claim-authority/quickstart.md b/specs/067-claim-authority/quickstart.md
new file mode 100644
index 0000000..9a8559c
--- /dev/null
+++ b/specs/067-claim-authority/quickstart.md
@@ -0,0 +1,145 @@
+# Quickstart: The Refund Contradiction
+
+The scenario from `dna/product/vision-spec-machine.md`: product says 30-day refunds, legal says 14, the
+implementation shows 45. Three claims, three authorities, three sources — represented, not hidden.
+
+```bash
+brane init
+```
+
+## 1. The subject
+
+```bash
+brane concept create --name RefundWindow --type Entity
+# => { "id": 1, "name": "RefundWindow", "type": "Entity" }
+```
+
+## 2. Three claims, three authorities
+
+```bash
+brane claim create --concept 1 --predicate refund_window \
+  --assertion "30 days" --authority product --source dna/product/prd.md
+
+brane claim create --concept 1 --predicate refund_window \
+  --assertion "14 days" --authority legal --source legal/policy.md
+
+brane claim create --concept 1 --predicate refund_window \
+  --assertion "45 days" --authority implementation --source src/billing.ts
+```
+
+Nothing was overwritten. Three rows exist.
+
+## 3. All three are still there
+
+```bash
+brane claim list --concept 1
+```
+
+```json
+{
+  "claims": [
+    { "id": 2, "assertion": "14 days", "authority": "legal",          "rank": 40, "source": "legal/policy.md" },
+    { "id": 1, "assertion": "30 days", "authority": "product",        "rank": 30, "source": "dna/product/prd.md" },
+    { "id": 3, "assertion": "45 days", "authority": "implementation", "rank": 20, "source": "src/billing.ts" }
+  ],
+  "count": 3,
+  "resolved": false
+}
+```
+
+## 4. The contradiction, named
+
+```bash
+brane claim conflicts
+```
+
+```json
+{
+  "conflicts": [{
+    "subject_type": "concept", "subject_id": 1, "predicate": "refund_window",
+    "claims": [ /* all three */ ],
+    "resolution": { "id": 2, "assertion": "14 days", "authority": "legal", "rank": 40 },
+    "unresolved": false
+  }],
+  "count": 1
+}
+```
+
+Legal wins by rank. Product and implementation are **still in the group** — the conflict did not
+disappear because it was resolved.
+
+## 5. One answer, when you need one
+
+```bash
+brane claim list --concept 1 --resolve
+# => 14 days / legal
+
+brane claim list --concept 1
+# => all three, unchanged. Resolution wrote nothing.
+```
+
+## 6. The validator arm sees it
+
+```bash
+brane verify --rule contradictions
+```
+
+```json
+{
+  "passed": false,
+  "summary": { "rules_passed": 0, "rules_failed": 1, "total_violations": 1 },
+  "rules": [{ "name": "contradictions", "passed": false,
+              "violations": [{ "id": 1, "name": "RefundWindow" }], "error": null }]
+}
+```
+
+`pr-verify` consumes the same rule. A change that introduces a contradiction can now fail a PR.
+
+Note the rule fires even though `legal` wins cleanly — it reports that the graph disagrees with itself,
+not whether the disagreement has a winner. Use `/mind/claims/conflicts` when you care about resolution.
+
+## 7. Re-ranking, without rewriting history
+
+Your org decides security outranks legal:
+
+```bash
+brane authority create --name security --rank 45 --description "Security review finding"
+brane claim create --concept 1 --predicate refund_window \
+  --assertion "7 days" --authority security --source security/audit-2026-08.md
+
+brane claim conflicts
+# => four claims in the group, resolution is now security / 7 days
+```
+
+No claim row was rewritten. Rank is joined at read time.
+
+## 8. Ties do not resolve
+
+```bash
+brane authority create --name legal_eu --rank 40 --description "EU legal constraint"
+brane claim create --concept 1 --predicate refund_window \
+  --assertion "30 days" --authority legal_eu --source legal/eu.md
+brane authority create --name security --rank 20   # demote security below the tie
+                                                  # (description omitted → preserved, not blanked)
+
+brane claim conflicts
+# => "resolution": null, "unresolved": true
+```
+
+Two tiers at rank 40 disagree. Brane does not pick. A human does — that is #114.
+
+---
+
+## sys.call equivalents
+
+Every CLI command above is a thin wrapper:
+
+```bash
+echo '{"subject_type":"concept","subject_id":1,"predicate":"refund_window",
+       "assertion":"30 days","authority":"product","source":"dna/product/prd.md"}' \
+  | brane /mind/claims/create
+
+echo '{"subject_id":1}'                | brane /mind/claims/conflicts
+echo '{"subject_id":1,"resolve":true}' | brane /mind/claims/list
+echo '{}'                              | brane /mind/authorities/list
+```
diff --git a/specs/067-claim-authority/research.md b/specs/067-claim-authority/research.md
new file mode 100644
index 0000000..53bd2e7
--- /dev/null
+++ b/specs/067-claim-authority/research.md
@@ -0,0 +1,261 @@
+# Phase 0 Research: Claim + Authority Model
+
+**Feature**: `067-claim-authority` | **Spec**: [spec.md](./spec.md) | **Plan**: [plan.md](./plan.md)
+
+Ten decisions. Three of them resolve items the spec deferred to this phase (D2, D3, D6).
+
+---
+
+## D1 — Two relations, not one
+
+**Decision**: `claims` (Int-keyed, one row per assertion) and `authorities` (String-keyed by tier name).
+
+**Rationale**: Claims are append-heavy and identified by surrogate ID like concepts/edges/episodes.
+Tiers are a small keyed lookup like `golden_types`. Both precedents already exist in the schema; no new
+pattern is invented.
+
+**Alternatives rejected**:
+- One relation with the rank inlined → breaks FR-012 (re-ranking would require rewriting every claim).
+- Tiers as a TypeScript constant → breaks FR-006 (project-defined tiers). See plan Complexity Tracking.
+
+---
+
+## D2 — Rank is joined at read time *(resolves a spec deferral)*
+
+**Decision**: `claims` stores the authority tier **name** only. Rank comes from `authorities` on every
+read (list, get, conflicts, rules).
+
+**Rationale**: FR-012 and spec edge case "authority rank changed after claims exist". Copying rank into
+the claim row would freeze the graph's precedence at write time and make re-ranking a migration.
+
+**Cost**: one extra join per read. Cheap — `authorities` is a handful of rows.
+
+**Consequence for Datalog**: a rule that needs rank must join `*claims` → `*authorities` itself. The
+built-in `contradictions` rule deliberately does **not** — it reports that a concept disagrees with
+itself, independent of who wins (D7). User-defined rules are free to join for rank; the join is
+validated in data-model.md.
+
+---
+
+## D3 — Conflict comparison is trim-then-exact, case-sensitive *(resolves a spec deferral)*
+
+**Decision**: `predicate`, `assertion`, `authority`, and `source` are **trimmed at write time and
+stored trimmed** (FR-016b). Every comparison downstream — conflict grouping, idempotency, and Datalog —
+is then plain exact equality on stored values, **case-sensitive**.
+
+Two claims conflict when `subject_type`, `subject_id`, and `predicate` are equal and `assertion` differs.
+
+**Why trim at write, not at read**: the conflict endpoint compares in TypeScript and the built-in rule
+compares in Datalog (`a1 != a2`). Trimming in only one of them makes `"30 days"` and `"30 days "`
+agreement to one read path and a violation to the other — SC-004 fails and the two arms of the feature
+disagree about what a contradiction is. Normalizing once, at the boundary, removes the whole class of
+divergence. It also makes the D4 idempotency tuple unambiguous: it compares stored values.
+
+**Rationale**: "Loose about vocabulary" means brane does not decide that `30 Days` and `30 days` mean
+the same thing — that is a semantic judgment, and guessing it wrong silently *hides* a conflict, which
+is the exact failure mode this feature exists to prevent. Trimming is safe (whitespace carries no
+meaning); case folding is not.
+
+**Trade-off accepted**: `30 days` vs `one month` is two claims and no detected conflict. Already
+recorded as a known limitation in spec Out of Scope. Semantic conflict detection is a later feature.
+
+**Alternatives rejected**:
+- Case-insensitive → silently merges assertions that may differ in meaning (`ID` vs `id` in a schema
+  claim).
+- Full normalization (units, synonyms) → out of scope; needs a vocabulary layer that does not exist.
+
+---
+
+## D4 — Idempotency by pre-insert lookup on the 5-tuple *(resolves a spec deferral)*
+
+**Decision**: Before inserting, query for an existing claim matching
+`(subject_type, subject_id, predicate, assertion, authority, source)`. If found, return it unchanged
+with the same success envelope. Otherwise allocate the next ID and insert.
+
+**Rationale**: FR-008 and spec scenario 2.2. A pre-insert lookup is one query and needs no new column.
+
+**Alternatives rejected**:
+- Content hash column → an extra field and a hashing decision for a constraint one query already
+  enforces. YAGNI.
+- Cozo composite primary key on the 5-tuple → loses the stable Int ID that `get`/`delete`/cascade all
+  need, and makes long assertion strings part of the key.
+
+**Note**: `source` is part of the identity tuple. The same assertion from two different sources is two
+claims — that is corroboration, and the spec keeps it (scenario 2.3 for authority; same logic for source).
+
+---
+
+## D5 — Resolution is a TypeScript projection, not a Datalog aggregate
+
+**Decision**: `list` with `resolve: true` and `conflicts` both fetch the relevant claim rows (joined
+with rank) in one query, then group and rank in TypeScript.
+
+**Rationale**: The tie rule (equal top rank → no winner, `unresolved: true`) is awkward and opaque in
+Datalog and trivial in TypeScript. Constitution VI favors the readable version. Grouping in memory also
+keeps `conflicts` returning whole groups with no silent truncation (spec edge case).
+
+**Revisit if**: SC-007 (< 1s at 10k claims) fails. Recorded as a risk in the plan.
+
+---
+
+## D6 — Default tiers seeded at ranks with gaps
+
+**Decision**: Seed five tiers on init and on migration:
+
+| tier | rank | description |
+|---|---|---|
+| `observation` | 10 | Recorded from experience; non-binding by default |
+| `implementation` | 20 | What the code actually does |
+| `product` | 30 | Product intent |
+| `legal` | 40 | Legal or regulatory constraint |
+| `manual` | 100 | Direct human assertion; highest standing |
+
+**Rationale**: Covers FR-005's required minimum and the vision doc's refund scenario exactly
+(product < legal, implementation below both). Steps of 10 let a project insert `security` at 35 without
+renumbering (spec Assumptions). `manual` at 100 mirrors the `infinity` authority annotations already
+carry, without changing annotations.
+
+**Note**: `observation` sitting lowest is the hook #114 needs — "most observations stay observations".
+This feature does not act on that; it just makes the ordering available.
+
+---
+
+## D7 — Built-in `contradictions` rule joins claims to concepts
+
+**Decision**: Ship a third built-in rule alongside `cycles` and `orphans`:
+
+```datalog
+contradictions[id, name] :=
+  *concepts[id, name, _, _, _],
+  *claims[c1, 'concept', id, pred, a1, _, _, _],
+  *claims[c2, 'concept', id, pred, a2, _, _, _],
+  c1 < c2,
+  a1 != a2
+```
+
+**Rationale**: FR-013 and user story 6. Rules return `[id, name]` concept pairs — that is the fixed
+contract `verify`, `pr-verify`, and `/mind/rules/query` all consume (see `execute_rule` in
+`src/handlers/mind/verify.ts`). Matching that contract means claims plug into the existing validator arm
+with zero changes to verify.
+
+**`c1 < c2`** dedupes the symmetric pair so each contradicting concept appears once.
+
+**Scope note**: the rule covers concept subjects only. Edge-subject contradictions are representable and
+queryable via `/mind/claims/conflicts`, but the `[id, name]` rule contract has no room for an edge — edge
+IDs would collide with concept IDs in the violations list. Documented as a known gap; a rules-contract
+change is its own feature.
+
+**Validated**: the rule body and the D2 rank join were executed against an in-memory CozoDB with the
+exact relation shapes from data-model.md. The rule returned only the contradicting concept and omitted
+a concept whose two claims agreed; the rank join ordered legal(40) > product(30) > implementation(20).
+Syntax and semantics confirmed before implementation.
+
+**Scope**: the rule flags every contradiction, including ones that resolve cleanly by rank (quickstart
+step 6 shows `verify` failing while `legal` wins). That is intended — the rule answers "does this graph
+disagree with itself", and rank-aware filtering is what `/mind/claims/conflicts` is for. A rank-aware
+rule variant is bigger, needs the authorities join, and has no requirement asking for it.
+
+**Coupling risk**: the rule body hardcodes the 8-column `claims` arity. #114 adding a column must update
+this rule body in the same migration.
+
+**Correction to an earlier assumption**: built-in rules are seeded by raw `:put` in `init.ts` and are
+**not** syntax-validated — `validate_rule_syntax` runs only in `/mind/rules/create`. A broken built-in
+surfaces at query time as a per-rule `error` string that `execute_rule` catches, which is quiet. The
+safety net is therefore a test, not a runtime check: the tc suite asserts `contradictions` executes
+without an `error` field, so an arity break fails the suite loudly. #114 inherits that test.
+
+---
+
+## D8 — Cascade on subject deletion, refuse on tier deletion
+
+**Decision**: Deleting a concept or edge deletes its claims. Deleting an authority tier that any claim
+references returns an error and changes nothing.
+
+**Rationale**: FR-015 and FR-006. Asymmetric on purpose — a claim about a deleted concept is meaningless
+and cannot be repaired, while a claim under a deleted tier is meaningful and *would* be corrupted by
+losing its standing. Refusing the tier deletion is the only option that never orphans a claim.
+
+**Two traps found while reviewing the existing deletion paths, both of which naive cascades miss:**
+
+1. **Concept deletion already cascades edges.** `concepts/delete.ts` removes every edge touching the
+   concept with a direct `:rm edges`. A cascade that only deletes `subject_type = "concept"` claims
+   leaves the claims on those removed edges dangling. Concept deletion must delete claims on the
+   cascaded edge IDs too.
+2. **`prune` and re-extraction delete concepts and edges without going through the delete handlers**
+   (`src/handlers/mind/prune.ts`, `src/handlers/calabi/extract.ts`). Annotations already dangle on those
+   paths — an existing bug this feature must not copy, because a claim store whose rows outlive their
+   subjects is exactly the integrity failure the feature exists to prevent.
+
+**Consequence**: cascade logic lives in one lib function, `cascade_claims(db, subject_type, ids)`, called
+from all four sites rather than reimplemented per handler. That is a deliberate small expansion of scope
+over "just the two delete handlers" — justified because the alternative ships a known dangling-data path
+on day one.
+
+---
+
+## D9 — Migration v1.12.0 → v1.13.0
+
+**Decision**: One migration step: create `claims`, create `authorities`, seed the five default tiers,
+insert the `contradictions` built-in rule. No existing relation is touched.
+
+**Rationale**: Reuses the existing backup/restore harness in `src/lib/migrate.ts`. Additive-only, so
+restore-on-failure is cheap and the SC-006 preservation guarantee is structural rather than tested by
+hope.
+
+**Care**: `init.ts` (`SCHEMA_QUERIES` + `BUILTIN_RULES`) and `migrate.ts` must produce byte-identical
+schemas. A fresh init and a migrated db must be indistinguishable — the existing suite's precedent.
+
+---
+
+## D10 — Field caps
+
+**Decision**: `predicate` ≤ 256 chars, `assertion` ≤ 4096 chars, `source` ≤ 1024 chars, tier `name`
+≤ 64 chars. All non-empty after trim.
+
+**Rationale**: 4096 matches `ANNOTATION_MAX_TEXT_LENGTH` — same discipline, same reason (bound the row,
+reject the pathological input at the top of the handler per the guard-early convention). The other caps
+are sized to their role: a predicate is a label, a source is a URL or identifier.
+
+---
+
+## D11 — Existing fixtures must change, and that is not a test rewrite
+
+**Decision**: Adding a third built-in rule and bumping the schema version breaks locked fixtures that
+pin the old values. Those fixtures are updated as an explicit, human-approved task — not quietly.
+
+Affected (verified against the tree; tc's `deep_match` requires exact key sets and values):
+
+| fixture | pins |
+|---|---|
+| `tests/mind/verify/data/{00,01,02,03,06}-*/result.json` | `rules_passed: 2`, enumerates `cycles` + `orphans` |
+| `tests/mind/rules/list/data/{00,01}-*/result.json` | counts `2` and `3` |
+| `tests/mind/init/data/{00,01,02}-*/result.json` | `schema_version: "1.12.0"` |
+| `tests/mind/concepts/delete/data/00-success-delete/result.json` | cascade shape, gains `claims_removed` |
+| `tests/mind/edges/delete/data/00-success-delete/result.json` | result gains `claims_removed` |
+| `tests/calabi/pr-verify/data/{00,01,02}-*/result.json` | `rules_passed` and the enumerated rule list — pr-verify runs every rule through the same path as verify |
+
+`tests/mind/verify/data/02-*` and `tests/calabi/pr-verify/data/03-*` filter to `["cycles"]` and are
+correctly unaffected.
+
+**Rationale**: constitution IV forbids changing tests after review without human approval. These changes
+are mechanical consequences of a version bump and a new built-in, not adjustments to make a failing
+implementation pass — but the distinction has to be *stated and approved*, not assumed. SC-005 is worded
+to match.
+
+---
+
+## D12 — Cascade result shape
+
+**Decision**: `/mind/concepts/delete` gains `claims_removed` in its existing `cascade` object.
+`/mind/edges/delete` gains a `claims_removed` field alongside `deleted`.
+
+**Rationale**: the concept handler already reports `edges_removed`, `annotations_removed`, and
+`provenance_removed`; claims belong in the same place. Silence about a cascade the caller cannot
+otherwise observe is worse than a fixture update.
+
+---
+
+## Resolved unknowns
+
+Nothing remains marked NEEDS CLARIFICATION. The three spec-level deferrals (case sensitivity, rank
+storage, idempotency mechanism) are decided in D3, D2, and D4.
diff --git a/specs/067-claim-authority/spec.md b/specs/067-claim-authority/spec.md
new file mode 100644
index 0000000..696cf5d
--- /dev/null
+++ b/specs/067-claim-authority/spec.md
@@ -0,0 +1,339 @@
+# Feature Specification: First-Class Claim + Authority Model
+
+**Feature Branch**: `067-claim-authority`
+**Created**: 2026-08-19
+**Status**: Draft
+**Issue**: [#113](https://github.com/ahoward/brane/issues/113) (umbrella [#112](https://github.com/ahoward/brane/issues/112))
+**Vision**: `dna/product/vision-spec-machine.md` (v4.0), principles 1–2
+**Input**: User description: "elevate brane from provenance + trust tiers to a first-class **claim** carrying **authority** (tier + source), so **contradiction is representable as data**"
+
+## Why
+
+Today brane can say *"a concept named `RefundWindow` exists, extracted from `billing.ts`"*. It cannot say
+*"product asserts the refund window is 30 days, legal asserts 14, the implementation shows 45 — all three
+at once, each with its own standing and source."*
+
+Documents force one of those to win by structure. A spec machine represents all three and keeps the
+contradiction visible. That is this feature.
+
+The two principles being implemented:
+
+1. **Strict about authority, loose about vocabulary** — the *tier* an assertion is made under is a
+   registered, ranked, closed set. *What* is asserted (predicate + assertion text) is free-form.
+2. **Contradiction is data, not a defect** — competing claims coexist. Resolution is a *query-time
+   projection*, never a write-time deletion.
+
+## User Scenarios & Testing *(mandatory)*
+
+### User Story 1 — Assert a Claim (Priority: P1)
+
+A human, an agent, or the extraction pipeline records an assertion about a concept or edge: what is
+asserted, under which authority tier, and where it came from. The claim is stored alongside — not
+merged into — whatever else the graph already holds about that subject.
+
+**Why this priority**: The write path. Nothing else in the feature exists without it, and #114
+(promotion gate) and #116 (production-as-teacher) both write through it.
+
+**Independent Test**: Create a claim against an existing concept with predicate `refund_window`,
+assertion `30 days`, authority `product`, source `dna/product/prd.md`. Verify it is stored with an
+auto-generated ID, timestamp, and the resolved authority rank.
+
+**Acceptance Scenarios**:
+
+1. **Given** an initialized mind.db and an existing concept, **When** a claim is created with subject,
+   predicate, assertion, authority, and source, **Then** it is stored with a unique ID and ISO 8601
+   `created_at`, and is retrievable by ID.
+2. **Given** an existing edge, **When** a claim is created with `subject_type: "edge"` and that edge's
+   ID, **Then** the claim is stored against the edge.
+3. **Given** a claim create with an authority tier that is not registered, **When** it is submitted,
+   **Then** a validation error is returned and no claim is written.
+4. **Given** a claim create referencing a subject ID that does not exist, **When** it is submitted,
+   **Then** a validation error is returned and no claim is written.
+5. **Given** a claim create missing `assertion`, `predicate`, `authority`, or `source`, **When** it is
+   submitted, **Then** a validation error naming the missing field is returned.
+6. **Given** an unregistered predicate string (any free-form text), **When** a claim is created,
+   **Then** it succeeds — vocabulary is not validated.
+
+---
+
+### User Story 2 — Hold Contradiction Without Resolving It (Priority: P1)
+
+Product says 30 days. Legal says 14. The implementation shows 45. All three are written. Nothing is
+overwritten, deduplicated, or silently reconciled. A later reader sees three claims.
+
+**Why this priority**: This *is* the feature. A claim store that collapses conflicts is just a
+key-value store with extra ceremony.
+
+**Independent Test**: Write three claims with the same subject and predicate, different assertions and
+authorities. List claims for that subject and verify all three come back with their authorities and
+sources intact.
+
+**Acceptance Scenarios**:
+
+1. **Given** three claims on the same subject+predicate with different assertions, **When** listing
+   claims for that subject, **Then** all three are returned, each with its authority tier, rank, and
+   source.
+2. **Given** those three claims, **When** the same claim (identical subject, predicate, assertion,
+   authority, source) is asserted a second time, **Then** it is not duplicated — the existing claim is
+   returned unchanged (idempotent re-assertion).
+3. **Given** two claims with the same subject, predicate, and assertion but *different* authorities,
+   **Then** both are retained — agreement from two authorities is two claims, not one.
+4. **Given** a claim written by a low-authority source and a later claim by a high-authority source,
+   **When** listing, **Then** the low-authority claim still exists and is still returned.
+
+---
+
+### User Story 3 — See the Conflicts (Priority: P1)
+
+A user or agent asks: *where does this graph contradict itself?* The answer is a list of conflict
+groups — each a subject+predicate with two or more distinct assertions — showing every competing claim
+and which one wins by authority, with the conflict still visible.
+
+**Why this priority**: Contradiction that cannot be queried is contradiction that is hidden. This is
+the read path that makes principle 2 real.
+
+**Independent Test**: Write the 30/14/45 refund claims, then query conflicts. Verify one conflict group
+comes back containing three claims, with `legal` (highest rank) marked as the resolution and the other
+two present and unmarked.
+
+**Acceptance Scenarios**:
+
+1. **Given** claims 30d/product, 14d/legal, 45d/implementation on one subject+predicate, **When**
+   querying conflicts, **Then** one conflict group is returned containing all three claims.
+2. **Given** that conflict group, **Then** the highest-rank claim is identified as the resolution and
+   every competing claim remains present in the group.
+3. **Given** two claims on the same subject+predicate with *identical* assertions, **When** querying
+   conflicts, **Then** no conflict group is returned — same assertion is agreement, not conflict.
+4. **Given** two claims with the same subject+predicate, different assertions, and *equal* authority
+   rank, **When** querying conflicts, **Then** the group is returned with `resolution: null` and
+   `unresolved: true` — a tie is not broken arbitrarily.
+5. **Given** a graph with no competing claims, **When** querying conflicts, **Then** an empty list with
+   count 0 is returned.
+6. **Given** conflicts across many subjects, **When** querying with a subject filter, **Then** only
+   that subject's conflict groups are returned.
+
+---
+
+### User Story 4 — Resolve by Authority on Demand (Priority: P2)
+
+An agent that needs *one* answer asks for the resolved view: for each subject+predicate, the claim with
+the highest authority rank. Resolution is a projection over the same immutable claims — asking for it
+never mutates the store.
+
+**Why this priority**: Consumers (context queries, generation in #115) need a single answer sometimes.
+But it must be derived, not stored, or contradiction leaks away.
+
+**Independent Test**: With the three refund claims present, request the resolved view and verify a
+single 14-day/legal claim comes back; then list claims again and verify all three are still there.
+
+**Acceptance Scenarios**:
+
+1. **Given** competing claims, **When** listing with `resolve: true`, **Then** one claim per
+   subject+predicate is returned — the highest-rank one.
+2. **Given** competing claims at equal top rank, **When** listing with `resolve: true`, **Then** all
+   tied claims are returned for that subject+predicate and the group is flagged unresolved.
+3. **Given** a resolved list has been requested, **When** listing without `resolve`, **Then** every
+   original claim is still present — resolution has no write side effect.
+
+---
+
+### User Story 5 — Manage the Authority Registry (Priority: P2)
+
+Authority tiers are a small, ordered, explicit set. Brane ships defaults; a project can add its own
+(`security`, `compliance`, `sre`) with a rank. Tiers cannot be referenced before they are registered.
+
+**Why this priority**: "Strict about authority" requires a registry to be strict against. Ships with
+usable defaults so the feature works out of the box.
+
+**Independent Test**: List authorities on a fresh mind.db and verify the seeded defaults with their
+ranks. Register a new tier, use it on a claim, and verify the claim carries the new tier's rank.
+
+**Acceptance Scenarios**:
+
+1. **Given** a freshly initialized mind.db, **When** listing authorities, **Then** the seeded default
+   tiers are returned in rank order.
+2. **Given** a new tier registered with a name, rank, and description, **When** a claim is created
+   under it, **Then** the claim succeeds and carries that rank.
+3. **Given** an attempt to register a tier whose name already exists, **When** submitted, **Then** the
+   tier is updated (rank/description) rather than duplicated, and existing claims under that tier
+   reflect the new rank on read.
+4. **Given** an attempt to delete a tier that claims reference, **When** submitted, **Then** an error is
+   returned and the tier is retained — no orphaned claims.
+5. **Given** a tier registered with a non-integer or negative rank, **When** submitted, **Then** a
+   validation error is returned.
+
+---
+
+### User Story 6 — Rules Can Reason Over Claims (Priority: P2)
+
+Datalog rules — the validator layer brane already ships — can join against claims and authority. A
+built-in `contradictions` rule surfaces every concept that carries competing claims, so `verify` and
+`pr-verify` can fail a change that introduces an unresolved contradiction.
+
+**Why this priority**: Connects the new model to the enforcement arm that already exists. Without it,
+claims are inert data.
+
+**Independent Test**: Write competing claims on a concept, run the built-in `contradictions` rule via
+the existing rules-query path, and verify the concept is returned.
+
+**Acceptance Scenarios**:
+
+1. **Given** a concept with competing claims, **When** the built-in `contradictions` rule is queried,
+   **Then** that concept is in the matches.
+2. **Given** a concept whose claims all agree, **When** the rule is queried, **Then** it is not in the
+   matches.
+3. **Given** a user-defined rule body referencing the claims relation and authority rank, **When**
+   created and queried, **Then** it executes and returns concept matches.
+4. **Given** competing claims exist, **When** `verify` runs, **Then** the `contradictions` rule
+   participates in the report like any other rule.
+
+---
+
+### User Story 7 — Delete a Claim (Priority: P3)
+
+A claim entered in error is removable by ID.
+
+**Why this priority**: Hygiene. Deliberately minimal — *retraction with audit* is #114's promotion/
+demotion gate, not this feature.
+
+**Independent Test**: Create a claim, delete by ID, verify get returns not found and conflicts recompute
+without it.
+
+**Acceptance Scenarios**:
+
+1. **Given** an existing claim, **When** deleting by ID, **Then** it is removed and get returns not found.
+2. **Given** a non-existent claim ID, **When** deleting, **Then** a not-found error is returned.
+3. **Given** a deleted claim that was one of three in a conflict group, **When** querying conflicts,
+   **Then** the group reflects the two remaining claims.
+4. **Given** a concept is deleted, **When** claims referenced it, **Then** its claims are removed with it
+   (same cascade behavior as annotations).
+
+---
+
+### Edge Cases
+
+- **Subject does not exist** → validation error on create; never a dangling claim.
+- **Unregistered authority tier** → validation error on create. Strict, by design.
+- **Free-form predicate/assertion** → always accepted. Loose, by design.
+- **Tie at top authority rank** → no winner. `resolution: null`, `unresolved: true`. Never break ties by
+  recency, ID order, or insertion order.
+- **Authority rank changed after claims exist** → resolution recomputes on next read; stored claims are
+  untouched. Rank is looked up, not copied into the claim row.
+- **Same claim asserted twice** → idempotent, no duplicate row.
+- **Assertion text exceeding the length cap** → validation error (same cap discipline as annotations).
+- **Claim against an edge whose endpoints are later deleted** → claim is removed with the edge.
+- **Very large conflict group** (many authorities on one predicate) → returned whole; no silent truncation.
+- **Existing databases** → migration adds the relations and seeds defaults without touching existing data.
+
+## Requirements *(mandatory)*
+
+### Functional Requirements
+
+- **FR-001**: System MUST store claims as first-class records with: unique ID, subject type
+  (`concept` | `edge`), subject ID, predicate, assertion, authority tier, source, and `created_at`.
+- **FR-002**: System MUST validate that the subject exists before writing a claim.
+- **FR-003**: System MUST validate that the authority tier is registered before writing a claim, and
+  MUST NOT validate predicate or assertion vocabulary.
+- **FR-004**: System MUST persist an authority registry of tiers, each with a unique name, an integer
+  rank (higher = more authoritative), and a description.
+- **FR-005**: System MUST seed the registry on init with a default ordered set of tiers covering at
+  minimum: observation (lowest), implementation, product, legal, and manual/human (highest).
+- **FR-006**: System MUST support registering, updating, listing, and deleting authority tiers, and MUST
+  refuse deletion of a tier that any claim references.
+- **FR-007**: System MUST store competing claims (same subject + predicate, different assertion) side by
+  side without overwrite, merge, or precedence applied at write time.
+- **FR-008**: System MUST treat re-assertion of an identical claim (same subject, predicate, assertion,
+  authority, source) as idempotent — no duplicate row.
+- **FR-009**: System MUST support listing claims filtered by subject, subject type, predicate, and
+  authority tier.
+- **FR-010**: System MUST expose a conflict query returning conflict groups; each group carries its
+  subject, predicate, all competing claims with authority tier and rank, the highest-rank claim as the
+  resolution, and an `unresolved` flag when the top rank is tied.
+- **FR-011**: System MUST support a resolved projection (highest-rank claim per subject+predicate) that
+  performs no writes and does not remove or hide the losing claims from unresolved queries.
+- **FR-012**: System MUST resolve authority rank at read time from the registry, so rank changes take
+  effect without rewriting claims.
+- **FR-013**: System MUST expose claims and authority rank to Datalog rules, and MUST ship a built-in
+  `contradictions` rule matching concepts that carry competing claims.
+- **FR-014**: System MUST support getting a claim by ID and deleting a claim by ID.
+- **FR-015**: System MUST cascade claim deletion when the referenced concept or edge is deleted, on
+  every path that deletes a concept or edge — the delete handlers, `prune`, and re-extraction. Deleting
+  a concept also cascades the claims on the edges that concept's deletion removes.
+- **FR-016**: System MUST upgrade existing mind.db databases via the migration system with no data loss,
+  seeding default authority tiers during migration.
+- **FR-016b**: System MUST trim `predicate`, `assertion`, `authority`, and `source` at write time and
+  store the trimmed values, so every read path — list, conflicts, and Datalog rules alike — compares
+  identical strings.
+- **FR-017**: All new operations MUST follow the sys.call Result envelope, POD-only, snake_case
+  conventions in the constitution.
+- **FR-018**: System MUST return an empty list with count 0 — not an error — for claim and conflict
+  queries with no matches.
+
+### Key Entities
+
+- **Claim**: An assertion about a subject, made under an authority, from a source. Fields: `id`,
+  `subject_type` (`concept` | `edge`), `subject_id`, `predicate` (free-form, e.g. `refund_window`),
+  `assertion` (free-form, e.g. `30 days`), `authority` (registered tier name), `source` (provenance
+  string: file URL, session, agent id, or human identifier), `created_at`.
+- **Authority Tier**: A registered standing under which claims are made. Fields: `name` (unique),
+  `rank` (integer, higher wins), `description`. Strict/closed set; project-extensible.
+- **Conflict Group**: A derived (not stored) view: one subject+predicate with two or more distinct
+  assertions, carrying every competing claim, the highest-rank resolution, and an `unresolved` flag.
+
+## Success Criteria *(mandatory)*
+
+### Measurable Outcomes
+
+- **SC-001**: The refund scenario round-trips end to end: three claims written (product=30d, legal=14d,
+  implementation=45d), all three retrievable, one conflict group reported, `legal` identified as the
+  resolution, and all three claims still present after resolution is requested.
+- **SC-002**: Zero writes occur during any read path — claims, conflicts, and resolved views are
+  byte-identical before and after any number of resolution queries.
+- **SC-003**: An unregistered authority tier is rejected 100% of the time; a novel predicate string is
+  accepted 100% of the time.
+- **SC-004**: The built-in `contradictions` rule returns exactly the concepts carrying competing claims
+  — no false positives on concepts whose claims agree. Because assertions are stored trimmed
+  (FR-016b), the rule and `/mind/claims/conflicts` never disagree about what counts as agreement.
+- **SC-005**: All existing tests pass after the planned fixture updates — no behavioral regressions in
+  concepts, edges, provenance, annotations, episodes, rules, verify, or lenses. A third built-in rule
+  and a schema version bump necessarily change fixtures that pin the built-in rule count (`verify`,
+  `rules/list`), the schema version (`init`), and the concept-delete cascade shape. Those updates are an
+  expected, human-approved consequence of the feature — not a test rewrite to make failures go away.
+- **SC-006**: Migration from the current schema version preserves every existing concept, edge,
+  provenance record, annotation, rule, and episode, and seeds the default authority tiers.
+- **SC-007**: Claim, conflict, and resolved queries complete in under 1 second on a database holding
+  10,000 claims.
+
+## Out of Scope
+
+Explicitly deferred so this feature stays foundational (constitution principle VI):
+
+- **Binding / constraining claims and the promotion gate** — #114. Claims here are recorded, not
+  enforced as requirements. No `binding` flag in this feature.
+- **Retraction with audit trail and demotion** — #114.
+- **Regeneration from claims** — #115.
+- **Ingesting production signals as claims** — #116.
+- **Automatic conflict resolution policies** beyond highest-rank (recency weighting, quorum, decay).
+- **Semantic conflict detection** — conflict is exact-assertion mismatch on the same predicate, not
+  embedding similarity. "30 days" vs "one month" is two claims, not a detected conflict. Noted as a
+  known limitation for a later feature.
+- **Claim-to-claim edges** (supports/contradicts links between claims). Subject is a concept or edge only.
+- **Multi-subject claims.** Issue #113 phrases this as "a claim references concept(s)/edge(s)"; a claim
+  here has exactly one subject. A claim spanning several subjects is representable as several claims
+  sharing a predicate and source, and the single-subject shape keeps conflict grouping unambiguous.
+  Revisit if the promotion gate (#114) needs genuinely joint assertions.
+
+## Assumptions
+
+- Predicate and assertion are free-form strings. Normalization (casing, units, synonyms) is a later
+  concern; the loose-vocabulary principle says do not enforce one now.
+- `source` is an opaque provenance string, consistent with how the existing provenance relation stores
+  `file_url`. It is not validated against body.db.
+- Authority rank is a plain integer with room between defaults (e.g. steps of 10) so projects can insert
+  tiers between shipped ones without renumbering.
+- Annotations keep their existing `infinity` authority and are not migrated into claims by this feature;
+  a future feature may unify them.
+- Conflict detection compares assertions exactly (after trim). Case sensitivity is a clarification item
+  for the plan phase.
+- Claims are immutable once written — correcting one means delete + re-assert. Updating in place would
+  erase the contradiction record this feature exists to keep.
diff --git a/specs/067-claim-authority/tasks.md b/specs/067-claim-authority/tasks.md
new file mode 100644
index 0000000..3e68ecd
--- /dev/null
+++ b/specs/067-claim-authority/tasks.md
@@ -0,0 +1,201 @@
+---
+description: "Task list for 067-claim-authority"
+---
+
+# Tasks: First-Class Claim + Authority Model
+
+**Input**: `/specs/067-claim-authority/` — spec.md, plan.md, research.md, data-model.md, contracts/
+**Issue**: [#113](https://github.com/ahoward/brane/issues/113)
+
+**Tests**: Required and **first**. Constitution IV — tc tests are authored and antagonist-reviewed
+(Fable) before any implementation task, including the shared library, and locked after review.
+
+## Format: `[ID] [P?] [Story] Description`
+
+- **[P]** — parallelizable (different files, no dependency)
+- **[Story]** — the user story from spec.md (US1…US7), or `FND` for foundational
+
+---
+
+## Phase 1: Test Design (BEFORE any implementation — constitution IV)
+
+- [x] **T001** [P] Write `tests/mind/claims/run` + `data/NN-*/{params,result}.json` covering US1–US4 and US7:
+  create (success, edge subject, unregistered authority, missing subject, each missing field, free-form
+  predicate accepted, over-cap assertion, whitespace trimmed on write), idempotent re-assert (including
+  re-assert whose only difference is untrimmed whitespace), get, list (each filter, limit, empty),
+  `resolve` projection, delete (success, not found, conflict recomputes), read-then-remove on the all-key
+  relation.
+- [x] **T002** [P] Write `tests/mind/authorities/run` + fixtures covering US5: seeded defaults on fresh
+  init, register new tier, upsert existing tier, **upsert omitting `description` preserves it**, delete
+  unreferenced tier, refuse delete of referenced tier, invalid rank (negative, non-integer), empty name.
+- [x] **T003** ⛔ **Human-approved fixture reconciliation** (research D11). Update the locked fixtures that
+  a third built-in rule and a schema bump necessarily break. Get explicit approval before touching them:
+  - `tests/mind/verify/data/{00,01,02,03,06}-*/result.json` — `rules_passed`/`rules_failed` and the rule list
+  - `tests/mind/rules/list/data/{00,01}-*/result.json` — counts 2 → 3 and 3 → 4
+  - `tests/mind/init/data/{00,01,02}-*/result.json` — `schema_version` 1.12.0 → 1.13.0
+  - `tests/mind/concepts/delete/data/00-success-delete/result.json` — `cascade` gains `claims_removed`
+- [x] **T004** [P] [US6] Extend `tests/mind/rules/`: `contradictions` returns a concept with competing
+  claims, omits a concept whose claims agree, **executes with `error: null`** (the arity-break safety net,
+  research D7), and a user-defined rule joining `*claims`/`*authorities` for rank executes.
+- [x] **T005** [P] Extend the verify suite: `contradictions` participates in `/mind/verify` like any other
+  rule, and fires even when the contradiction resolves cleanly by rank (spec US6, research D7).
+- [x] **T006** [P] Cascade tests: deleting a concept removes its claims **and the claims on the edges that
+  deletion cascades away** (research D8 trap 1); deleting an edge removes its claims; `prune` removes
+  claims for pruned concepts and edges (trap 2).
+- [x] **T007** Migration test (SC-006). Mechanism, since the binary ships at 1.13.0 and a RocksDB fixture
+  directory cannot be checked in: init fresh, downgrade in place (`::remove claims`, `::remove
+  authorities`, `:rm` the `contradictions` rule row, stamp `schema_meta` to `1.12.0`), then reopen through
+  a handler that calls `open_mind` — note `/mind/init` does **not** migrate; only `open_mind` does. Assert
+  concepts, edges, provenance, annotations, rules, and episodes survive and the five tiers appear.
+- [x] **T008** SC-001 end-to-end: the refund 30/14/45 scenario from quickstart.md — three claims written,
+  all three listed, one conflict group, `legal` as resolution, all three still present after `resolve`.
+- [x] **T009** ⛔ **Fable antagonist review** of T001–T008. Two rounds. Round 1 returned three blockers
+  (pr-verify and edges/delete fixtures missed in the sweep; the prune cascade case unpassable) plus 11
+  should-fixes; round 2 confirmed the fixture blockers fixed and caught that the prune fix was still
+  wrong — `/mind/provenance/create` validates against body.db, so the setup needs the prune suite's
+  add-then-delete pattern. All applied. **Tests LOCK here.** Blocks every task below.
+
+  Changing anything below this line now requires a human checkpoint (constitution IV).
+
+---
+
+## Phase 2: Schema & Migration
+
+- [x] **T010** [FND] Add `claims` and `authorities` relations to `SCHEMA_QUERIES` in
+  `src/handlers/mind/init.ts`, exactly as declared in data-model.md (all-key `claims`, `=>`-keyed
+  `authorities`).
+- [x] **T011** [FND] Seed the five default authority tiers (research D6) on init.
+- [x] **T012** [FND] Add the `contradictions` built-in rule to `BUILTIN_RULES` in `init.ts`.
+- [x] **T013** [FND] Bump `SCHEMA_VERSION` to `1.13.0` in `init.ts`.
+- [x] **T014** [FND] Add the v1.12.0 → v1.13.0 migration in `src/lib/migrate.ts`: both relations, the five
+  tiers, the `contradictions` rule. Bump `LATEST_VERSION`.
+- [x] **T015** [FND] Add `"contradictions"` to `BUILTIN_RULE_NAMES` in `src/lib/mind.ts`.
+- [x] **T016** [FND] Verify init-vs-migrate parity: a fresh v1.13.0 db and a migrated v1.12.0 db are
+  indistinguishable — relations, seeded tiers, built-in rules (research D9).
+
+T010–T013 are sequential: same file.
+
+---
+
+## Phase 3: Shared Library
+
+- [x] **T017** [FND] Create `src/lib/claims.ts` with constants: `SUBJECT_TYPES`,
+  `CLAIM_MAX_PREDICATE_LENGTH` (256), `CLAIM_MAX_ASSERTION_LENGTH` (4096), `CLAIM_MAX_SOURCE_LENGTH`
+  (1024), `AUTHORITY_MAX_NAME_LENGTH` (64), `DEFAULT_AUTHORITIES`.
+- [x] **T018** [FND] `get_next_claim_id(db)` — same pattern as `get_next_annotation_id`.
+- [x] **T019** [FND] `authority_exists(db, name)` and `get_authorities(db)`.
+- [x] **T020** [FND] `edge_exists(db, id)` in `src/lib/mind.ts` (mirrors `concept_exists`);
+  `subject_exists(db, subject_type, subject_id)` in `claims.ts` dispatching to it.
+- [x] **T021** [FND] `normalize_claim_fields(params)` — trim `predicate`/`assertion`/`authority`/`source`
+  at the boundary so every downstream comparison is exact equality (FR-016b, research D3).
+- [x] **T022** [FND] `find_claim(db, tuple)` — the 5-tuple idempotency lookup on stored (trimmed) values.
+- [x] **T023** [FND] `fetch_claims_with_rank(db, filters)` — single query joining `claims` → `authorities`.
+- [x] **T024** [FND] `group_conflicts(rows)` — grouping, exact assertion comparison, rank-desc/id-asc
+  ordering, `resolution`, `unresolved` tie flag (research D5).
+- [x] **T025** [FND] `cascade_claims(db, subject_type, ids)` — the single cascade path used by all four
+  deletion sites (research D8). Read-then-`:rm` on the all-key relation.
+
+---
+
+## Phase 4: Handlers — Claims (US1–US4, US7)
+
+- [x] **T026** [US1] `src/handlers/mind/claims/create.ts` — guard-early validation per contracts, trim via
+  T021, idempotent insert, `created` flag.
+- [x] **T027** [P] [US1] `src/handlers/mind/claims/get.ts` — by ID, with joined rank.
+- [x] **T028** [US2] [US4] `src/handlers/mind/claims/list.ts` — filters, `limit`, `resolve` projection,
+  rank-desc/id-asc ordering, empty → count 0.
+- [x] **T029** [US3] `src/handlers/mind/claims/conflicts.ts` — groups via `group_conflicts`, filters, no
+  truncation.
+- [x] **T030** [P] [US7] `src/handlers/mind/claims/delete.ts` — read-then-remove by ID, not-found error.
+
+---
+
+## Phase 5: Cascades (US7, FR-015)
+
+- [x] **T031** [US7] `src/handlers/mind/concepts/delete.ts` — call `cascade_claims` for the concept **and
+  for the edge IDs the handler already collects to `:rm`** (research D8 trap 1). Report
+  `cascade.claims_removed`.
+- [x] **T032** [P] [US7] `src/handlers/mind/edges/delete.ts` — `cascade_claims` for the edge; report
+  `claims_removed`.
+- [x] **T033** [US7] `src/handlers/mind/prune.ts` — `cascade_claims` for pruned concepts and edges
+  (research D8 trap 2).
+- [x] **T034** [US7] `src/handlers/calabi/extract.ts` — `cascade_claims` on the re-extraction delete path.
+
+---
+
+## Phase 6: Handlers — Authorities (US5)
+
+- [x] **T035** [P] [US5] `src/handlers/mind/authorities/list.ts` — rank-desc, name-asc.
+- [x] **T036** [US5] `src/handlers/mind/authorities/create.ts` — upsert, rank validation, `created` flag,
+  **description preserved when omitted on update**.
+- [x] **T037** [US5] `src/handlers/mind/authorities/delete.ts` — refuse with `conflict` when referenced.
+
+---
+
+## Phase 7: Registration & CLI
+
+- [x] **T038** Register all 8 paths in `src/index.ts`.
+- [x] **T039** [P] `src/cli/commands/claim.ts` — `create|list|get|delete|conflicts`.
+- [x] **T040** [P] `src/cli/commands/authority.ts` — `list|create|delete`.
+- [x] **T041** Wire both into `src/cli/main.ts` under `admin` plus the backward-compat top level, matching
+  how `annotation` is wired.
+
+---
+
+## Phase 8: Green & Document
+
+- [x] **T042** Run `bun test`. Loop until green. If stuck after good-faith effort → ⛔ human checkpoint.
+- [x] **T043** Confirm no behavioral regressions across concepts, edges, provenance, annotations,
+  episodes, rules, verify, lenses (SC-005). The only fixture diffs should be the T003 set.
+- [x] **T044** [P] Update `CLAUDE.md` Recent Changes + the Spec Machine table status for `067`.
+- [x] **T045** [P] Mark `067-claim-authority` complete in `dna/product/ROADMAP.md` and move it to the
+  Completed table.
+- [x] **T046** Comment the verdict on #113 and note what #114 inherits: the `observation` tier, claim
+  immutability, the 8-column arity coupling in the `contradictions` rule body, and the `cascade_claims`
+  seam.
+
+---
+
+## Dependencies
+
+```
+Phase 1 tests (T001–T008) ──> T009 Fable review [LOCK]
+                                    │
+                                    v
+                          Phase 2 schema (T010–T016)
+                                    v
+                          Phase 3 lib (T017–T025)
+                          ┌─────────┴─────────┬──────────────┐
+                          v                   v              v
+                  Phase 4 claims       Phase 5 cascades  Phase 6 authorities
+                  (T026–T030)          (T031–T034)       (T035–T037)
+                          └─────────┬─────────┴──────────────┘
+                                    v
+                          Phase 7 CLI (T038–T041)
+                                    v
+                          Phase 8 green (T042–T046)
+```
+
+- **T009 blocks everything below it.** No implementation — including the library — before the lock.
+- T003 needs human approval before the fixtures are touched (constitution IV).
+- T020 blocks T026 (edge-subject validation).
+- T023 blocks T028 and T029; T024 blocks T029.
+- T025 blocks T031–T034.
+- T019 blocks T036/T037.
+
+## Parallelization
+
+Safe together: T001+T002+T004+T005+T006 (distinct suites), T027+T030, T032 alongside T031's
+non-overlapping files, T039+T040, T044+T045.
+
+Sequential: T010–T013 (same file), T031 and T033 if prune reuses concept-delete internals.
+
+## MVP boundary
+
+Phases 1–4 plus T035 deliver the P1 stories (US1, US2, US3): claims can be asserted, contradiction is
+held, conflicts are queryable. Phases 5–7 complete the feature.
+
+## Antagonist
+
+T009 runs **Fable** as a subagent (constitution 1.1.0). No external CLI, nothing to install — the
+earlier "blocked on Gemini" note is obsolete.
diff --git a/src/cli/commands/authority.ts b/src/cli/commands/authority.ts
new file mode 100644
index 0000000..3b09be1
--- /dev/null
+++ b/src/cli/commands/authority.ts
@@ -0,0 +1,60 @@
+//
+// authority.ts - brane authority [list|create|delete]
+//
+// The registry claims are made under. Strict about authority, loose about
+// vocabulary: tiers are registered and ranked, predicates are not.
+//
+
+import { defineCommand } from "citty"
+import { sys } from "../../index.ts"
+import { output } from "../output.ts"
+
+export const authority = defineCommand({
+  meta: {
+    name: "authority",
+    description: "Manage authority tiers that claims are made under",
+  },
+  subCommands: {
+    list: defineCommand({
+      meta: { name: "list", description: "List authority tiers, highest rank first" },
+      args: {
+        json: { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const result = await sys.call("/mind/authorities/list", {})
+        output(result, { json: args.json })
+      },
+    }),
+
+    create: defineCommand({
+      meta: { name: "create", description: "Register a tier, or re-rank an existing one" },
+      args: {
+        name:        { type: "string", alias: "n", description: "Tier name", required: true },
+        rank:        { type: "string", alias: "r", description: "Rank (higher wins)", required: true },
+        description: { type: "string", alias: "d", description: "What this tier means" },
+        json:        { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const params: any = { name: args.name, rank: parseInt(args.rank) }
+
+        // omitted description preserves the existing one
+        if (args.description !== undefined) params.description = args.description
+
+        const result = await sys.call("/mind/authorities/create", params)
+        output(result, { json: args.json })
+      },
+    }),
+
+    delete: defineCommand({
+      meta: { name: "delete", description: "Delete an unreferenced tier" },
+      args: {
+        name: { type: "positional", description: "Tier name", required: true },
+        json: { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const result = await sys.call("/mind/authorities/delete", { name: args.name })
+        output(result, { json: args.json })
+      },
+    }),
+  },
+})
diff --git a/src/cli/commands/claim.ts b/src/cli/commands/claim.ts
new file mode 100644
index 0000000..9e1ae50
--- /dev/null
+++ b/src/cli/commands/claim.ts
@@ -0,0 +1,121 @@
+//
+// claim.ts - brane claim [create|list|get|delete|conflicts]
+//
+
+import { defineCommand } from "citty"
+import { sys } from "../../index.ts"
+import { output } from "../output.ts"
+
+function subject(args: { concept?: string; edge?: string }): { subject_type: string; subject_id: number } | null {
+  if (args.edge)    return { subject_type: "edge",    subject_id: parseInt(args.edge) }
+  if (args.concept) return { subject_type: "concept", subject_id: parseInt(args.concept) }
+  return null
+}
+
+export const claim = defineCommand({
+  meta: {
+    name: "claim",
+    description: "Assert and query claims (contradiction is data, not a defect)",
+  },
+  subCommands: {
+    create: defineCommand({
+      meta: { name: "create", description: "Assert a claim about a concept or edge" },
+      args: {
+        concept:   { type: "string", alias: "c", description: "Concept ID (subject)" },
+        edge:      { type: "string", alias: "e", description: "Edge ID (subject)" },
+        predicate: { type: "string", alias: "p", description: "What is being asserted about", required: true },
+        assertion: { type: "string", alias: "a", description: "The assertion itself", required: true },
+        authority: { type: "string", description: "Authority tier (must be registered)", required: true },
+        source:    { type: "string", alias: "s", description: "Where this came from", required: true },
+        json:      { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const subj = subject(args)
+
+        if (!subj) {
+          console.error("brane: a subject is required (--concept ID or --edge ID)")
+          process.exit(1)
+        }
+
+        const result = await sys.call("/mind/claims/create", {
+          ...subj,
+          predicate: args.predicate,
+          assertion: args.assertion,
+          authority: args.authority,
+          source:    args.source,
+        })
+        output(result, { json: args.json })
+      },
+    }),
+
+    list: defineCommand({
+      meta: { name: "list", description: "List claims" },
+      args: {
+        concept:   { type: "string", alias: "c", description: "Filter by concept ID" },
+        edge:      { type: "string", alias: "e", description: "Filter by edge ID" },
+        predicate: { type: "string", alias: "p", description: "Filter by predicate" },
+        authority: { type: "string", description: "Filter by authority tier" },
+        resolve:   { type: "boolean", alias: "r", description: "Project to the winner per subject+predicate" },
+        limit:     { type: "string", alias: "n", description: "Max results" },
+        json:      { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const params: any = {}
+        const subj = subject(args)
+
+        if (subj) Object.assign(params, subj)
+        if (args.predicate) params.predicate = args.predicate
+        if (args.authority) params.authority = args.authority
+        if (args.resolve)   params.resolve   = true
+        if (args.limit)     params.limit     = parseInt(args.limit)
+
+        const result = await sys.call("/mind/claims/list", params)
+        output(result, { json: args.json })
+      },
+    }),
+
+    conflicts: defineCommand({
+      meta: { name: "conflicts", description: "Where the graph contradicts itself" },
+      args: {
+        concept:   { type: "string", alias: "c", description: "Filter by concept ID" },
+        edge:      { type: "string", alias: "e", description: "Filter by edge ID" },
+        predicate: { type: "string", alias: "p", description: "Filter by predicate" },
+        json:      { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const params: any = {}
+        const subj = subject(args)
+
+        if (subj) Object.assign(params, subj)
+        if (args.predicate) params.predicate = args.predicate
+
+        const result = await sys.call("/mind/claims/conflicts", params)
+        output(result, { json: args.json })
+      },
+    }),
+
+    get: defineCommand({
+      meta: { name: "get", description: "Get a claim by ID" },
+      args: {
+        id:   { type: "positional", description: "Claim ID", required: true },
+        json: { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const result = await sys.call("/mind/claims/get", { id: parseInt(args.id) })
+        output(result, { json: args.json })
+      },
+    }),
+
+    delete: defineCommand({
+      meta: { name: "delete", description: "Delete a claim by ID" },
+      args: {
+        id:   { type: "positional", description: "Claim ID", required: true },
+        json: { type: "boolean", alias: "j", description: "Output as JSON" },
+      },
+      async run({ args }) {
+        const result = await sys.call("/mind/claims/delete", { id: parseInt(args.id) })
+        output(result, { json: args.json })
+      },
+    }),
+  },
+})
diff --git a/src/cli/main.ts b/src/cli/main.ts
index e2420bc..7236b3f 100644
--- a/src/cli/main.ts
+++ b/src/cli/main.ts
@@ -24,6 +24,8 @@ import { rule } from "./commands/rule.ts"
 import { body } from "./commands/body.ts"
 import { fts } from "./commands/fts.ts"
 import { annotation } from "./commands/annotation.ts"
+import { claim } from "./commands/claim.ts"
+import { authority } from "./commands/authority.ts"
 import { provenance } from "./commands/provenance.ts"
 import { context } from "./commands/context.ts"
 import { prVerify } from "./commands/pr-verify.ts"
@@ -68,6 +70,8 @@ const admin = defineCommand({
     rule,
     annotation,
     provenance,
+    claim,
+    authority,
 
     // Subsystem commands
     body,
@@ -126,6 +130,8 @@ export const main = defineCommand({
     rule,
     annotation,
     provenance,
+    claim,
+    authority,
     body,
     fts,
     context,
diff --git a/src/handlers/calabi/extract.ts b/src/handlers/calabi/extract.ts
index a279919..9dc50f3 100644
--- a/src/handlers/calabi/extract.ts
+++ b/src/handlers/calabi/extract.ts
@@ -5,6 +5,7 @@
 import type { Params, Result, Emit } from "../../lib/types.ts"
 import { success, error } from "../../lib/result.ts"
 import { open_mind, is_mind_error, is_valid_concept_type, is_valid_edge_relation, get_next_concept_id, get_next_edge_id } from "../../lib/mind.ts"
+import { cascade_claims } from "../../lib/claims.ts"
 import { file_exists_in_body } from "../../lib/body.ts"
 
 interface ConceptInput {
@@ -326,6 +327,14 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Extra
         continue
       }
 
+      // Claims about this concept and its edges go with them - re-extraction
+      // replaces the concept, so anything asserted about the old one is stale.
+      const claim_edge_ids = await db.run(`
+        ?[id] := *edges[id, source, target, _, _, _], source = ${old_id} or target = ${old_id}
+      `)
+      await cascade_claims(db, "edge", (claim_edge_ids.rows as number[][]).map(r => r[0]))
+      await cascade_claims(db, "concept", [old_id])
+
       // Remove edges where this concept is source
       const source_edges = await db.run(`
         ?[id, source, target, relation, weight, agent_id] := *edges[id, source, target, relation, weight, agent_id], source = ${old_id}
diff --git a/src/handlers/mind/authorities/create.ts b/src/handlers/mind/authorities/create.ts
new file mode 100644
index 0000000..faa5d75
--- /dev/null
+++ b/src/handlers/mind/authorities/create.ts
@@ -0,0 +1,92 @@
+//
+// create.ts - register an authority tier, or re-rank an existing one
+//
+// Upsert. Re-ranking does NOT rewrite claims: rank is joined at read time, so
+// existing claims pick up the new standing on their next read.
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import {
+  AUTHORITY_MAX_NAME_LENGTH,
+  get_authority,
+  esc
+} from "../../../lib/claims.ts"
+
+interface CreateParams {
+  name?:        string
+  rank?:        number
+  description?: string
+}
+
+interface CreateResult {
+  name:        string
+  rank:        number
+  description: string
+  created:     boolean
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<CreateResult>> {
+  const p = (params ?? {}) as CreateParams
+
+  if (p.name === undefined || p.name === null || p.name === "") {
+    return error({ name: [{ code: "required", message: "name is required" }] })
+  }
+
+  if (p.rank === undefined || p.rank === null) {
+    return error({ rank: [{ code: "required", message: "rank is required" }] })
+  }
+
+  if (typeof p.rank !== "number" || !Number.isInteger(p.rank) || p.rank < 0) {
+    return error({ rank: [{ code: "invalid", message: "rank must be a non-negative integer" }] })
+  }
+
+  const name = p.name.trim()
+
+  if (name === "") {
+    return error({ name: [{ code: "invalid", message: "name must not be empty" }] })
+  }
+
+  if (name.length > AUTHORITY_MAX_NAME_LENGTH) {
+    return error({
+      name: [{ code: "invalid", message: `name exceeds ${AUTHORITY_MAX_NAME_LENGTH} characters` }]
+    })
+  }
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    const existing = await get_authority(db, name)
+
+    // an omitted description on an update preserves what is already there -
+    // a rank-only change must not blank the tier's meaning
+    const description = p.description !== undefined && p.description !== null
+      ? p.description.trim()
+      : (existing ? existing.description : "")
+
+    await db.run(`
+      ?[name, rank, description] <- [['${esc(name)}', ${p.rank}, '${esc(description)}']]
+      :put authorities { name => rank, description }
+    `)
+
+    db.close()
+
+    return success({
+      name:        name,
+      rank:        p.rank,
+      description: description,
+      created:     existing === null
+    })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ authority: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/authorities/delete.ts b/src/handlers/mind/authorities/delete.ts
new file mode 100644
index 0000000..889671c
--- /dev/null
+++ b/src/handlers/mind/authorities/delete.ts
@@ -0,0 +1,77 @@
+//
+// delete.ts - remove an authority tier
+//
+// Refused while any claim references it. A claim under a deleted tier would
+// lose its standing, which is worse than keeping an unused tier around.
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import {
+  get_authority,
+  count_claims_for_authority,
+  esc
+} from "../../../lib/claims.ts"
+
+interface DeleteParams {
+  name?: string
+}
+
+interface DeleteResult {
+  name:    string
+  deleted: boolean
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<DeleteResult>> {
+  const p = (params ?? {}) as DeleteParams
+
+  if (p.name === undefined || p.name === null || p.name === "") {
+    return error({ name: [{ code: "required", message: "name is required" }] })
+  }
+
+  const name = p.name.trim()
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    const existing = await get_authority(db, name)
+
+    if (!existing) {
+      db.close()
+      return error({ name: [{ code: "not_found", message: `authority tier not found: ${name}` }] })
+    }
+
+    const referencing = await count_claims_for_authority(db, name)
+
+    if (referencing > 0) {
+      db.close()
+      const plural = referencing === 1 ? "claim" : "claims"
+      return error({
+        name: [{
+          code:    "conflict",
+          message: `authority tier is referenced by ${referencing} ${plural}: ${name}`
+        }]
+      })
+    }
+
+    await db.run(`
+      ?[name] <- [['${esc(name)}']]
+      :rm authorities { name }
+    `)
+
+    db.close()
+
+    return success({ name: name, deleted: true })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ authority: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/authorities/list.ts b/src/handlers/mind/authorities/list.ts
new file mode 100644
index 0000000..4129fe9
--- /dev/null
+++ b/src/handlers/mind/authorities/list.ts
@@ -0,0 +1,34 @@
+//
+// list.ts - the authority registry, rank descending
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import { get_authorities, type Authority } from "../../../lib/claims.ts"
+
+interface ListResult {
+  authorities: Authority[]
+  count:       number
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<ListResult>> {
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    const authorities = await get_authorities(db)
+    db.close()
+
+    return success({ authorities: authorities, count: authorities.length })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ authorities: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/claims/conflicts.ts b/src/handlers/mind/claims/conflicts.ts
new file mode 100644
index 0000000..f46e020
--- /dev/null
+++ b/src/handlers/mind/claims/conflicts.ts
@@ -0,0 +1,69 @@
+//
+// conflicts.ts - where does this graph contradict itself?
+//
+// A conflict group is one subject+predicate carrying two or more distinct
+// assertions. Every competing claim stays in the group; the highest-rank one
+// is named as the resolution, and a tie at the top does not resolve at all.
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import {
+  SUBJECT_TYPES,
+  is_valid_subject_type,
+  fetch_claims_with_rank,
+  group_conflicts,
+  type ConflictGroup
+} from "../../../lib/claims.ts"
+
+interface ConflictsParams {
+  subject_type?: string
+  subject_id?:   number
+  predicate?:    string
+}
+
+interface ConflictsResult {
+  conflicts: ConflictGroup[]
+  count:     number
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<ConflictsResult>> {
+  const p = (params ?? {}) as ConflictsParams
+
+  if (p.subject_type !== undefined && p.subject_type !== null && !is_valid_subject_type(p.subject_type)) {
+    return error({
+      subject_type: [{
+        code:    "invalid",
+        message: `subject_type must be one of: ${SUBJECT_TYPES.join(", ")}`
+      }]
+    })
+  }
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    const claims = await fetch_claims_with_rank(db, {
+      subject_type: p.subject_type ?? undefined,
+      subject_id:   p.subject_id ?? undefined,
+      predicate:    p.predicate ?? undefined
+    })
+
+    db.close()
+
+    // groups are returned whole - no truncation, or the contradiction is hidden
+    const conflicts = group_conflicts(claims)
+
+    return success({ conflicts: conflicts, count: conflicts.length })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ conflicts: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/claims/create.ts b/src/handlers/mind/claims/create.ts
new file mode 100644
index 0000000..e824f72
--- /dev/null
+++ b/src/handlers/mind/claims/create.ts
@@ -0,0 +1,217 @@
+//
+// create.ts - assert a claim about a concept or edge
+//
+// Idempotent on the full identity tuple: re-asserting an identical claim
+// returns the existing row rather than a duplicate.
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import {
+  SUBJECT_TYPES,
+  is_valid_subject_type,
+  CLAIM_MAX_PREDICATE_LENGTH,
+  CLAIM_MAX_ASSERTION_LENGTH,
+  CLAIM_MAX_SOURCE_LENGTH,
+  authority_exists,
+  get_authority,
+  subject_exists,
+  find_claim,
+  get_next_claim_id,
+  esc
+} from "../../../lib/claims.ts"
+
+interface CreateParams {
+  subject_type?: string
+  subject_id?:   number
+  predicate?:    string
+  assertion?:    string
+  authority?:    string
+  source?:       string
+}
+
+interface CreateResult {
+  id:           number
+  subject_type: string
+  subject_id:   number
+  predicate:    string
+  assertion:    string
+  authority:    string
+  rank:         number | null
+  source:       string
+  created_at:   string
+  created:      boolean
+}
+
+//
+// Trim, then check. Trimming after the empty check would let "   " through.
+//
+function normalize(v: string): string {
+  return v.trim()
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<CreateResult>> {
+  const p = (params ?? {}) as CreateParams
+
+  // --- guard: required fields ---
+
+  if (p.subject_type === undefined || p.subject_type === null || p.subject_type === "") {
+    return error({ subject_type: [{ code: "required", message: "subject_type is required" }] })
+  }
+
+  if (p.subject_id === undefined || p.subject_id === null) {
+    return error({ subject_id: [{ code: "required", message: "subject_id is required" }] })
+  }
+
+  if (p.predicate === undefined || p.predicate === null || p.predicate === "") {
+    return error({ predicate: [{ code: "required", message: "predicate is required" }] })
+  }
+
+  if (p.assertion === undefined || p.assertion === null || p.assertion === "") {
+    return error({ assertion: [{ code: "required", message: "assertion is required" }] })
+  }
+
+  if (p.authority === undefined || p.authority === null || p.authority === "") {
+    return error({ authority: [{ code: "required", message: "authority is required" }] })
+  }
+
+  if (p.source === undefined || p.source === null || p.source === "") {
+    return error({ source: [{ code: "required", message: "source is required" }] })
+  }
+
+  // --- guard: subject type is a closed set ---
+
+  const subject_type = normalize(p.subject_type)
+
+  if (!is_valid_subject_type(subject_type)) {
+    return error({
+      subject_type: [{
+        code:    "invalid",
+        message: `subject_type must be one of: ${SUBJECT_TYPES.join(", ")}`
+      }]
+    })
+  }
+
+  // --- normalize at the boundary, so every downstream comparison is exact ---
+
+  const predicate = normalize(p.predicate)
+  const assertion = normalize(p.assertion)
+  const authority = normalize(p.authority)
+  const source    = normalize(p.source)
+
+  if (predicate === "") {
+    return error({ predicate: [{ code: "invalid", message: "predicate must not be empty" }] })
+  }
+  if (assertion === "") {
+    return error({ assertion: [{ code: "invalid", message: "assertion must not be empty" }] })
+  }
+  if (authority === "") {
+    return error({ authority: [{ code: "invalid", message: "authority must not be empty" }] })
+  }
+  if (source === "") {
+    return error({ source: [{ code: "invalid", message: "source must not be empty" }] })
+  }
+
+  if (predicate.length > CLAIM_MAX_PREDICATE_LENGTH) {
+    return error({
+      predicate: [{ code: "invalid", message: `predicate exceeds ${CLAIM_MAX_PREDICATE_LENGTH} characters` }]
+    })
+  }
+  if (assertion.length > CLAIM_MAX_ASSERTION_LENGTH) {
+    return error({
+      assertion: [{ code: "invalid", message: `assertion exceeds ${CLAIM_MAX_ASSERTION_LENGTH} characters` }]
+    })
+  }
+  if (source.length > CLAIM_MAX_SOURCE_LENGTH) {
+    return error({
+      source: [{ code: "invalid", message: `source exceeds ${CLAIM_MAX_SOURCE_LENGTH} characters` }]
+    })
+  }
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    // --- guard: the subject exists ---
+
+    if (!await subject_exists(db, subject_type, p.subject_id)) {
+      db.close()
+      return error({
+        subject_id: [{ code: "not_found", message: `${subject_type} not found: ${p.subject_id}` }]
+      })
+    }
+
+    // --- guard: strict about authority ---
+
+    if (!await authority_exists(db, authority)) {
+      db.close()
+      return error({
+        authority: [{ code: "not_found", message: `authority tier not registered: ${authority}` }]
+      })
+    }
+
+    const tuple = {
+      subject_type: subject_type,
+      subject_id:   p.subject_id,
+      predicate:    predicate,
+      assertion:    assertion,
+      authority:    authority,
+      source:       source
+    }
+
+    const tier = await get_authority(db, authority)
+
+    // --- idempotent: the same assertion from the same source under the same
+    // authority is one claim, not two ---
+
+    const existing = await find_claim(db, tuple)
+
+    if (existing) {
+      db.close()
+      return success({
+        ...tuple,
+        id:         existing.id,
+        rank:       tier ? tier.rank : null,
+        created_at: existing.created_at,
+        created:    false
+      })
+    }
+
+    const id         = await get_next_claim_id(db)
+    const created_at = new Date().toISOString()
+
+    await db.run(`
+      ?[id, subject_type, subject_id, predicate, assertion, authority, source, created_at] <- [[
+        ${id},
+        '${esc(subject_type)}',
+        ${p.subject_id},
+        '${esc(predicate)}',
+        '${esc(assertion)}',
+        '${esc(authority)}',
+        '${esc(source)}',
+        '${esc(created_at)}'
+      ]]
+      :put claims { id, subject_type, subject_id, predicate, assertion, authority, source, created_at }
+    `)
+
+    db.close()
+
+    return success({
+      ...tuple,
+      id:         id,
+      rank:       tier ? tier.rank : null,
+      created_at: created_at,
+      created:    true
+    })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ claim: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/claims/delete.ts b/src/handlers/mind/claims/delete.ts
new file mode 100644
index 0000000..a2df4f9
--- /dev/null
+++ b/src/handlers/mind/claims/delete.ts
@@ -0,0 +1,60 @@
+//
+// delete.ts - remove a claim by id
+//
+// claims is an all-key relation, so :rm needs the full row: read, then remove.
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+
+interface DeleteParams {
+  id?: number
+}
+
+interface DeleteResult {
+  id:      number
+  deleted: boolean
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<DeleteResult>> {
+  const p = (params ?? {}) as DeleteParams
+
+  if (p.id === undefined || p.id === null) {
+    return error({ id: [{ code: "required", message: "id is required" }] })
+  }
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    const match = `*claims[id, subject_type, subject_id, predicate, assertion, authority, source, created_at], id = ${p.id}`
+
+    const existing = await db.run(`
+      ?[id, subject_type, subject_id, predicate, assertion, authority, source, created_at] := ${match}
+    `)
+
+    if ((existing.rows as unknown[][]).length === 0) {
+      db.close()
+      return error({ id: [{ code: "not_found", message: `claim not found: ${p.id}` }] })
+    }
+
+    await db.run(`
+      ?[id, subject_type, subject_id, predicate, assertion, authority, source, created_at] := ${match}
+      :rm claims { id, subject_type, subject_id, predicate, assertion, authority, source, created_at }
+    `)
+
+    db.close()
+
+    return success({ id: p.id, deleted: true })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ claim: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/claims/get.ts b/src/handlers/mind/claims/get.ts
new file mode 100644
index 0000000..71be309
--- /dev/null
+++ b/src/handlers/mind/claims/get.ts
@@ -0,0 +1,43 @@
+//
+// get.ts - fetch a single claim by id, with its authority rank
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import { fetch_claims_with_rank, type Claim } from "../../../lib/claims.ts"
+
+interface GetParams {
+  id?: number
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<Claim>> {
+  const p = (params ?? {}) as GetParams
+
+  if (p.id === undefined || p.id === null) {
+    return error({ id: [{ code: "required", message: "id is required" }] })
+  }
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    const claims = await fetch_claims_with_rank(db, { id: p.id })
+    db.close()
+
+    if (claims.length === 0) {
+      return error({ id: [{ code: "not_found", message: `claim not found: ${p.id}` }] })
+    }
+
+    return success(claims[0])
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ claim: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/claims/list.ts b/src/handlers/mind/claims/list.ts
new file mode 100644
index 0000000..ac1d771
--- /dev/null
+++ b/src/handlers/mind/claims/list.ts
@@ -0,0 +1,90 @@
+//
+// list.ts - list claims, optionally projected to the winner per subject+predicate
+//
+// `resolve` is a read-time projection. It never writes, and it never removes
+// the losing claims from an unresolved query.
+//
+
+import type { Params, Result, Emit } from "../../../lib/types.ts"
+import { success, error } from "../../../lib/result.ts"
+import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import {
+  SUBJECT_TYPES,
+  is_valid_subject_type,
+  fetch_claims_with_rank,
+  resolve_claims,
+  type Claim
+} from "../../../lib/claims.ts"
+
+const DEFAULT_LIMIT = 100
+
+interface ListParams {
+  subject_type?: string
+  subject_id?:   number
+  predicate?:    string
+  authority?:    string
+  resolve?:      boolean
+  limit?:        number
+}
+
+interface ListResult {
+  claims:   Claim[]
+  count:    number
+  resolved: boolean
+}
+
+export async function handler(params: Params, emit?: Emit): Promise<Result<ListResult>> {
+  const p = (params ?? {}) as ListParams
+
+  if (p.subject_type !== undefined && p.subject_type !== null && !is_valid_subject_type(p.subject_type)) {
+    return error({
+      subject_type: [{
+        code:    "invalid",
+        message: `subject_type must be one of: ${SUBJECT_TYPES.join(", ")}`
+      }]
+    })
+  }
+
+  const limit = p.limit ?? DEFAULT_LIMIT
+
+  if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1) {
+    return error({ limit: [{ code: "invalid", message: "limit must be a positive integer" }] })
+  }
+
+  const mind = await open_mind()
+
+  if (is_mind_error(mind)) {
+    return error({ mind: [{ code: mind.code, message: mind.message }] })
+  }
+
+  const { db } = mind
+
+  try {
+    let claims = await fetch_claims_with_rank(db, {
+      subject_type: p.subject_type ?? undefined,
+      subject_id:   p.subject_id ?? undefined,
+      predicate:    p.predicate ?? undefined,
+      authority:    p.authority ?? undefined
+    })
+
+    const resolved = p.resolve === true
+
+    if (resolved) {
+      claims = resolve_claims(claims)
+    }
+
+    db.close()
+
+    const page = claims.slice(0, limit)
+
+    return success({
+      claims:   page,
+      count:    page.length,
+      resolved: resolved
+    })
+  } catch (err) {
+    db.close()
+    const message = err instanceof Error ? err.message : (err as { message?: string })?.message ?? String(err)
+    return error({ claims: [{ code: "db_error", message }] })
+  }
+}
diff --git a/src/handlers/mind/concepts/delete.ts b/src/handlers/mind/concepts/delete.ts
index dbc7e66..8550839 100644
--- a/src/handlers/mind/concepts/delete.ts
+++ b/src/handlers/mind/concepts/delete.ts
@@ -5,6 +5,7 @@
 import type { Params, Result, Emit } from "../../../lib/types.ts"
 import { success, error } from "../../../lib/result.ts"
 import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import { cascade_claims } from "../../../lib/claims.ts"
 
 interface DeleteParams {
   id?: number
@@ -16,6 +17,7 @@ interface DeleteResult {
     edges_removed: number
     annotations_removed: number
     provenance_removed: number
+    claims_removed: number
   }
 }
 
@@ -64,11 +66,15 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Delet
       })
     }
 
-    // Cascade: remove edges where this concept is source or target
+    // Cascade: remove edges where this concept is source or target.
+    // Collect their ids first - the claims on those edges have to go too, or
+    // they outlive their subject.
     let edges_removed = 0
+    let cascaded_edge_ids: number[] = []
     try {
-      const edge_count = await db.run(`?[count(id)] := *edges[id, source, target, _, _, _], source = ${p.id} or target = ${p.id}`)
-      edges_removed = (edge_count.rows[0]?.[0] as number) ?? 0
+      const edge_ids = await db.run(`?[id] := *edges[id, source, target, _, _, _], source = ${p.id} or target = ${p.id}`)
+      cascaded_edge_ids = (edge_ids.rows as number[][]).map(r => r[0])
+      edges_removed = cascaded_edge_ids.length
       if (edges_removed > 0) {
         await db.run(`
           ?[id, source, target, relation, weight, agent_id] := *edges[id, source, target, relation, weight, agent_id], source = ${p.id} or target = ${p.id}
@@ -90,6 +96,11 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Delet
       }
     } catch { /* annotations relation may not exist */ }
 
+    // Cascade: remove claims on this concept and on the edges just removed
+    let claims_removed = 0
+    claims_removed += await cascade_claims(db, "concept", [p.id])
+    claims_removed += await cascade_claims(db, "edge", cascaded_edge_ids)
+
     // Cascade: remove provenance links for this concept
     let provenance_removed = 0
     try {
@@ -117,6 +128,7 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Delet
         edges_removed,
         annotations_removed,
         provenance_removed,
+        claims_removed,
       },
     })
   } catch (err) {
diff --git a/src/handlers/mind/edges/delete.ts b/src/handlers/mind/edges/delete.ts
index 8feff74..6298ada 100644
--- a/src/handlers/mind/edges/delete.ts
+++ b/src/handlers/mind/edges/delete.ts
@@ -5,6 +5,7 @@
 import type { Params, Result, Emit } from "../../../lib/types.ts"
 import { success, error } from "../../../lib/result.ts"
 import { open_mind, is_mind_error } from "../../../lib/mind.ts"
+import { cascade_claims } from "../../../lib/claims.ts"
 
 interface DeleteParams {
   id?: number
@@ -12,6 +13,7 @@ interface DeleteParams {
 
 interface DeleteResult {
   deleted: boolean
+  claims_removed: number
 }
 
 export async function handler(params: Params, emit?: Emit): Promise<Result<DeleteResult>> {
@@ -61,6 +63,9 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Delet
 
     const [id, source, target, relation, weight, agent_id] = rows[0]
 
+    // Cascade: claims about this edge go with it
+    const claims_removed = await cascade_claims(db, "edge", [id])
+
     // Delete edge
     await db.run(`
       ?[id, source, target, relation, weight, agent_id] <- [[${id}, ${source}, ${target}, '${relation}', ${weight}, '${agent_id}']]
@@ -70,7 +75,8 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Delet
     db.close()
 
     return success({
-      deleted: true
+      deleted: true,
+      claims_removed
     })
   } catch (err) {
     db.close()
diff --git a/src/handlers/mind/init.ts b/src/handlers/mind/init.ts
index 36f2a84..6ba4c91 100644
--- a/src/handlers/mind/init.ts
+++ b/src/handlers/mind/init.ts
@@ -8,6 +8,12 @@ import { resolve } from "node:path"
 import { existsSync, rmSync } from "node:fs"
 import { CozoDb } from "../../lib/cozo"
 import { EMBED_DIM } from "../../lib/embed.ts"
+import {
+  CLAIMS_RELATION,
+  AUTHORITIES_RELATION,
+  CONTRADICTIONS_RULE,
+  seed_authorities
+} from "../../lib/claims.ts"
 
 interface InitParams {
   force?:      boolean
@@ -20,7 +26,7 @@ interface InitResult {
   schema_version: string
 }
 
-const SCHEMA_VERSION = "1.12.0"
+const SCHEMA_VERSION = "1.13.0"
 
 //
 // Built-in rules for graph integrity checks
@@ -39,7 +45,8 @@ reachable[x, y] := *edges[_, x, z, 'DEPENDS_ON', _, _], reachable[z, y]`,
     description: "Detects concepts with no edges (disconnected)",
     body: `orphans[id, name] := *concepts[id, name, _, _, _], not *edges[_, id, _, _, _, _], not *edges[_, _, id, _, _, _]`,
     builtin: true
-  }
+  },
+  CONTRADICTIONS_RULE
 ]
 
 //
@@ -192,7 +199,16 @@ const SCHEMA_QUERIES = [
     =>
     access_count: Int default 0,
     last_accessed: String default ""
-  }`
+  }`,
+
+  // Claims - assertions about a concept or edge, made under an authority
+  // tier, from a source. Competing claims coexist; contradiction is data.
+  // All 8 columns are the key, so :rm needs the full row.
+  CLAIMS_RELATION,
+
+  // Authority registry - strict about authority, loose about vocabulary.
+  // rank is joined at read time, never copied onto a claim.
+  AUTHORITIES_RELATION
 ]
 
 //
@@ -264,6 +280,9 @@ async function create_schema(db: CozoDb): Promise<void> {
     `)
   }
 
+  // Seed the default authority tiers
+  await seed_authorities(db)
+
   // Seed default lens
   await db.run(`
     ?[key, value] <- [
diff --git a/src/handlers/mind/prune.ts b/src/handlers/mind/prune.ts
index 26a990f..69c5592 100644
--- a/src/handlers/mind/prune.ts
+++ b/src/handlers/mind/prune.ts
@@ -5,6 +5,7 @@
 import type { Params, Result, Emit } from "../../lib/types.ts"
 import { success, error } from "../../lib/result.ts"
 import { open_mind, is_mind_error } from "../../lib/mind.ts"
+import { cascade_claims } from "../../lib/claims.ts"
 import { resolve_lens_paths } from "../../lib/state.ts"
 import { existsSync } from "node:fs"
 import Database from "bun:sqlite"
@@ -146,6 +147,12 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Prune
 
     // Step 8: Delete (unless dry_run)
     if (!dry_run) {
+      // Claims go with their subjects. prune deletes concepts and edges
+      // directly rather than through the delete handlers, so it has to
+      // cascade claims itself or they outlive what they describe.
+      await cascade_claims(db, "edge", dangling_edges.map(e => e.id))
+      await cascade_claims(db, "concept", [...orphan_ids])
+
       // Delete edges (need all columns including agent_id for :rm)
       if (dangling_edges.length > 0) {
         const edge_data = dangling_edges.map(e => `[${e.id}, ${e.source}, ${e.target}, '${e.relation.replace(/'/g, "''")}', 1.0, '']`).join(", ")
diff --git a/src/handlers/mind/rules/create.ts b/src/handlers/mind/rules/create.ts
index 957010f..82da943 100644
--- a/src/handlers/mind/rules/create.ts
+++ b/src/handlers/mind/rules/create.ts
@@ -4,7 +4,7 @@
 
 import type { Params, Result, Emit } from "../../../lib/types.ts"
 import { success, error } from "../../../lib/result.ts"
-import { open_mind, is_mind_error, get_rule_by_name, is_builtin_rule, validate_rule_syntax, type Rule } from "../../../lib/mind.ts"
+import { open_mind, is_mind_error, get_rule_by_name, is_builtin_rule, validate_rule_syntax, esc_cozo, type Rule } from "../../../lib/mind.ts"
 
 interface CreateParams {
   name?:        string
@@ -95,9 +95,9 @@ export async function handler(params: Params, emit?: Emit): Promise<Result<Rule>
     }
 
     // Insert rule
-    const escapedName = p.name.replace(/'/g, "''")
-    const escapedDesc = p.description.replace(/'/g, "''")
-    const escapedBody = p.body.replace(/'/g, "''")
+    const escapedName = esc_cozo(p.name)
+    const escapedDesc = esc_cozo(p.description)
+    const escapedBody = esc_cozo(p.body)
     await db.run(`
       ?[name, description, body, builtin] <- [['${escapedName}', '${escapedDesc}', '${escapedBody}', false]]
       :put rules { name, description, body, builtin }
diff --git a/src/index.ts b/src/index.ts
index f964999..41adebd 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -37,6 +37,14 @@ import { handler as mind_rules_list_handler } from "./handlers/mind/rules/list.t
 import { handler as mind_rules_get_handler } from "./handlers/mind/rules/get.ts"
 import { handler as mind_verify_handler } from "./handlers/mind/verify.ts"
 import { handler as mind_annotations_create_handler } from "./handlers/mind/annotations/create.ts"
+import { handler as mind_claims_create_handler } from "./handlers/mind/claims/create.ts"
+import { handler as mind_claims_get_handler } from "./handlers/mind/claims/get.ts"
+import { handler as mind_claims_list_handler } from "./handlers/mind/claims/list.ts"
+import { handler as mind_claims_delete_handler } from "./handlers/mind/claims/delete.ts"
+import { handler as mind_claims_conflicts_handler } from "./handlers/mind/claims/conflicts.ts"
+import { handler as mind_authorities_create_handler } from "./handlers/mind/authorities/create.ts"
+import { handler as mind_authorities_list_handler } from "./handlers/mind/authorities/list.ts"
+import { handler as mind_authorities_delete_handler } from "./handlers/mind/authorities/delete.ts"
 import { handler as mind_annotations_list_handler } from "./handlers/mind/annotations/list.ts"
 import { handler as mind_annotations_get_handler } from "./handlers/mind/annotations/get.ts"
 import { handler as mind_annotations_delete_handler } from "./handlers/mind/annotations/delete.ts"
@@ -113,6 +121,14 @@ sys.register("/mind/rules/list", mind_rules_list_handler)
 sys.register("/mind/rules/get", mind_rules_get_handler)
 sys.register("/mind/verify", mind_verify_handler)
 sys.register("/mind/annotations/create", mind_annotations_create_handler)
+sys.register("/mind/claims/create", mind_claims_create_handler)
+sys.register("/mind/claims/get", mind_claims_get_handler)
+sys.register("/mind/claims/list", mind_claims_list_handler)
+sys.register("/mind/claims/delete", mind_claims_delete_handler)
+sys.register("/mind/claims/conflicts", mind_claims_conflicts_handler)
+sys.register("/mind/authorities/create", mind_authorities_create_handler)
+sys.register("/mind/authorities/list", mind_authorities_list_handler)
+sys.register("/mind/authorities/delete", mind_authorities_delete_handler)
 sys.register("/mind/annotations/list", mind_annotations_list_handler)
 sys.register("/mind/annotations/get", mind_annotations_get_handler)
 sys.register("/mind/annotations/delete", mind_annotations_delete_handler)
diff --git a/src/lib/claims.ts b/src/lib/claims.ts
new file mode 100644
index 0000000..a3748d5
--- /dev/null
+++ b/src/lib/claims.ts
@@ -0,0 +1,458 @@
+//
+// claims.ts - first-class claims carrying authority (#113)
+//
+// A claim is an assertion about a concept or edge, made under a registered
+// authority tier, from a source. Competing claims coexist; resolution is a
+// read-time projection, never a write-time deletion.
+//
+
+import type { CozoDb } from "./cozo"
+import { esc_cozo as esc } from "./mind.ts"
+
+//
+// Subject types a claim can attach to
+//
+export const SUBJECT_TYPES = ["concept", "edge"] as const
+export type SubjectType = typeof SUBJECT_TYPES[number]
+
+export function is_valid_subject_type(t: string): t is SubjectType {
+  return (SUBJECT_TYPES as readonly string[]).includes(t)
+}
+
+//
+// Field caps. 4096 matches ANNOTATION_MAX_TEXT_LENGTH - same discipline.
+//
+export const CLAIM_MAX_PREDICATE_LENGTH = 256
+export const CLAIM_MAX_ASSERTION_LENGTH = 4096
+export const CLAIM_MAX_SOURCE_LENGTH    = 1024
+export const AUTHORITY_MAX_NAME_LENGTH  = 64
+
+//
+// Seeded authority tiers. Steps of 10 so a project can insert its own
+// (security at 35, say) without renumbering. `manual` at 100 mirrors the
+// `infinity` authority annotations carry.
+//
+export const DEFAULT_AUTHORITIES: { name: string; rank: number; description: string }[] = [
+  { name: "observation",    rank: 10,  description: "Recorded from experience; non-binding by default" },
+  { name: "implementation", rank: 20,  description: "What the code actually does" },
+  { name: "product",        rank: 30,  description: "Product intent" },
+  { name: "legal",          rank: 40,  description: "Legal or regulatory constraint" },
+  { name: "manual",         rank: 100, description: "Direct human assertion; highest standing" }
+]
+
+//
+// The built-in contradictions rule. Defined here so init.ts and migrate.ts
+// cannot drift - a fresh v1.13.0 db and a migrated one must be identical.
+//
+// Positionally matches the 8-column claims relation. A future column (#114's
+// binding flag) MUST update this body in the same migration.
+//
+// Concept subjects only: the [id, name] rule contract cannot distinguish an
+// edge id from a concept id. Edge contradictions surface via /mind/claims/conflicts.
+//
+export const CONTRADICTIONS_RULE = {
+  name:        "contradictions",
+  description: "Detects concepts carrying competing claims (contradiction)",
+  body: `contradictions[id, name] :=
+  *concepts[id, name, _, _, _],
+  *claims[c1, 'concept', id, pred, a1, _, _, _],
+  *claims[c2, 'concept', id, pred, a2, _, _, _],
+  c1 < c2,
+  a1 != a2`,
+  builtin: true
+}
+
+//
+// Relation definitions, shared by init and migrate
+//
+export const CLAIMS_RELATION = `:create claims {
+    id: Int,
+    subject_type: String,
+    subject_id: Int,
+    predicate: String,
+    assertion: String,
+    authority: String,
+    source: String,
+    created_at: String
+  }`
+
+export const AUTHORITIES_RELATION = `:create authorities {
+    name: String
+    =>
+    rank: Int,
+    description: String
+  }`
+
+//
+// POD shapes
+//
+
+export interface Claim {
+  id:           number
+  subject_type: string
+  subject_id:   number
+  predicate:    string
+  assertion:    string
+  authority:    string
+  rank:         number | null
+  source:       string
+  created_at:   string
+}
+
+export interface Authority {
+  name:        string
+  rank:        number
+  description: string
+}
+
+export interface GroupClaim {
+  id:         number
+  assertion:  string
+  authority:  string
+  rank:       number | null
+  source:     string
+  created_at: string
+}
+
+export interface ConflictGroup {
+  subject_type: string
+  subject_id:   number
+  predicate:    string
+  claims:       GroupClaim[]
+  resolution:   { id: number; assertion: string; authority: string; rank: number } | null
+  unresolved:   boolean
+}
+
+//
+// escape a string for a single-quoted Cozo literal
+//
+export { esc }
+
+//
+// Seed the authority registry. Used by init and by the v1.13.0 migration.
+//
+export async function seed_authorities(db: CozoDb): Promise<void> {
+  const rows = DEFAULT_AUTHORITIES
+    .map(a => `['${esc(a.name)}', ${a.rank}, '${esc(a.description)}']`)
+    .join(", ")
+
+  await db.run(`
+    ?[name, rank, description] <- [${rows}]
+    :put authorities { name => rank, description }
+  `)
+}
+
+//
+// Seed the contradictions built-in rule. Used by init and by the migration.
+//
+export async function seed_contradictions_rule(db: CozoDb): Promise<void> {
+  const r = CONTRADICTIONS_RULE
+  await db.run(`
+    ?[name, description, body, builtin] <- [["${r.name}", "${r.description}", "${r.body}", true]]
+    :put rules { name, description, body, builtin }
+  `)
+}
+
+//
+// Next claim ID (auto-increment, same counter pattern as annotations/episodes)
+//
+export async function get_next_claim_id(db: CozoDb): Promise<number> {
+  const result = await db.run(`
+    ?[value] := *schema_meta['claim_next_id', value]
+  `)
+
+  const rows = result.rows as string[][]
+  let next_id = 1
+
+  if (rows.length > 0) {
+    next_id = parseInt(rows[0][0], 10)
+  }
+
+  await db.run(`
+    ?[key, value] <- [['claim_next_id', '${next_id + 1}']]
+    :put schema_meta { key => value }
+  `)
+
+  return next_id
+}
+
+//
+// Authority registry lookups
+//
+
+export async function authority_exists(db: CozoDb, name: string): Promise<boolean> {
+  const result = await db.run(`
+    ?[rank] := *authorities['${esc(name)}', rank, _]
+  `)
+  return (result.rows as unknown[][]).length > 0
+}
+
+export async function get_authority(db: CozoDb, name: string): Promise<Authority | null> {
+  const result = await db.run(`
+    ?[rank, description] := *authorities['${esc(name)}', rank, description]
+  `)
+  const rows = result.rows as [number, string][]
+  if (rows.length === 0) return null
+  return { name, rank: rows[0][0], description: rows[0][1] }
+}
+
+export async function get_authorities(db: CozoDb): Promise<Authority[]> {
+  const result = await db.run(`
+    ?[name, rank, description] := *authorities[name, rank, description]
+  `)
+  const rows = result.rows as [string, number, string][]
+
+  return rows
+    .map(([name, rank, description]) => ({ name, rank, description }))
+    .sort((a, b) => b.rank - a.rank || a.name.localeCompare(b.name))
+}
+
+//
+// Count claims referencing an authority tier
+//
+export async function count_claims_for_authority(db: CozoDb, name: string): Promise<number> {
+  const result = await db.run(`
+    ?[count(id)] := *claims[id, _, _, _, _, '${esc(name)}', _, _]
+  `)
+  const rows = result.rows as number[][]
+  return rows[0]?.[0] ?? 0
+}
+
+//
+// Does the subject exist? Dispatches on subject_type - validating everything
+// against concepts would silently accept any edge id.
+//
+export async function subject_exists(db: CozoDb, subject_type: string, subject_id: number): Promise<boolean> {
+  const query = subject_type === "edge"
+    ? `?[id] := *edges[id, _, _, _, _, _], id = ${subject_id}`
+    : `?[id] := *concepts[id, _, _, _, _], id = ${subject_id}`
+
+  const result = await db.run(query)
+  return (result.rows as unknown[][]).length > 0
+}
+
+//
+// The idempotency tuple. Compared on stored (trimmed) values.
+// `source` is part of the identity: the same assertion from two sources is
+// corroboration, and both are kept.
+//
+export interface ClaimTuple {
+  subject_type: string
+  subject_id:   number
+  predicate:    string
+  assertion:    string
+  authority:    string
+  source:       string
+}
+
+export async function find_claim(db: CozoDb, t: ClaimTuple): Promise<{ id: number; created_at: string } | null> {
+  const result = await db.run(`
+    ?[id, created_at] := *claims[
+      id,
+      '${esc(t.subject_type)}',
+      ${t.subject_id},
+      '${esc(t.predicate)}',
+      '${esc(t.assertion)}',
+      '${esc(t.authority)}',
+      '${esc(t.source)}',
+      created_at
+    ]
+  `)
+  const rows = result.rows as [number, string][]
+  if (rows.length === 0) return null
+  return { id: rows[0][0], created_at: rows[0][1] }
+}
+
+//
+// Fetch claims joined to authority rank. Rank is looked up here, never stored
+// on the claim - so re-ranking a tier changes resolution without a rewrite.
+//
+export interface ClaimFilters {
+  id?:           number
+  subject_type?: string
+  subject_id?:   number
+  predicate?:    string
+  authority?:    string
+}
+
+export async function fetch_claims_with_rank(db: CozoDb, f: ClaimFilters = {}): Promise<Claim[]> {
+  const conditions: string[] = []
+
+  if (f.id !== undefined)           conditions.push(`id = ${f.id}`)
+  if (f.subject_type !== undefined) conditions.push(`subject_type = '${esc(f.subject_type)}'`)
+  if (f.subject_id !== undefined)   conditions.push(`subject_id = ${f.subject_id}`)
+  if (f.predicate !== undefined)    conditions.push(`predicate = '${esc(f.predicate)}'`)
+  if (f.authority !== undefined)    conditions.push(`authority = '${esc(f.authority)}'`)
+
+  const where = conditions.length > 0 ? ", " + conditions.join(", ") : ""
+
+  const result = await db.run(`
+    ?[id, subject_type, subject_id, predicate, assertion, authority, source, created_at] :=
+      *claims[id, subject_type, subject_id, predicate, assertion, authority, source, created_at]${where}
+  `)
+
+  const rows = result.rows as [number, string, number, string, string, string, string, string][]
+
+  // rank comes from the registry, not the row
+  const ranks = new Map<string, number>()
+  for (const a of await get_authorities(db)) {
+    ranks.set(a.name, a.rank)
+  }
+
+  const claims: Claim[] = rows.map(r => ({
+    id:           r[0],
+    subject_type: r[1],
+    subject_id:   r[2],
+    predicate:    r[3],
+    assertion:    r[4],
+    authority:    r[5],
+    rank:         ranks.has(r[5]) ? ranks.get(r[5])! : null,
+    source:       r[6],
+    created_at:   r[7]
+  }))
+
+  return sort_claims(claims)
+}
+
+//
+// rank descending, then id ascending. A claim whose tier vanished sorts last
+// and never wins a resolution.
+//
+export function sort_claims<T extends { rank: number | null; id: number }>(claims: T[]): T[] {
+  return claims.sort((a, b) => {
+    const ra = a.rank ?? -1
+    const rb = b.rank ?? -1
+    return rb - ra || a.id - b.id
+  })
+}
+
+function group_key(c: Claim): string {
+  return `${c.subject_type} ${c.subject_id} ${c.predicate}`
+}
+
+function strip(c: Claim): GroupClaim {
+  return {
+    id:         c.id,
+    assertion:  c.assertion,
+    authority:  c.authority,
+    rank:       c.rank,
+    source:     c.source,
+    created_at: c.created_at
+  }
+}
+
+//
+// Group claims by subject+predicate and decide resolution.
+//
+// A group is a CONFLICT when it holds two or more distinct assertions. Same
+// assertion from two authorities is agreement, not conflict.
+//
+// A tie at the top rank between different assertions does NOT resolve. No
+// tiebreak by recency or id - the disagreement stands until a human settles it.
+//
+export function group_conflicts(claims: Claim[], conflicts_only = true): ConflictGroup[] {
+  const groups = new Map<string, Claim[]>()
+
+  for (const c of claims) {
+    const k = group_key(c)
+    const list = groups.get(k) ?? []
+    list.push(c)
+    groups.set(k, list)
+  }
+
+  const out: ConflictGroup[] = []
+
+  for (const list of groups.values()) {
+    const sorted = sort_claims(list.slice())
+    const distinct = new Set(sorted.map(c => c.assertion))
+
+    if (conflicts_only && distinct.size < 2) continue
+
+    const top = sorted[0]
+    const top_rank = top.rank ?? -1
+    const tied = sorted.filter(c => (c.rank ?? -1) === top_rank)
+    const unresolved = new Set(tied.map(c => c.assertion)).size > 1
+
+    out.push({
+      subject_type: top.subject_type,
+      subject_id:   top.subject_id,
+      predicate:    top.predicate,
+      claims:       sorted.map(strip),
+      resolution:   unresolved
+        ? null
+        : { id: top.id, assertion: top.assertion, authority: top.authority, rank: top_rank },
+      unresolved:   unresolved
+    })
+  }
+
+  // subject_type asc, subject_id asc, predicate asc
+  return out.sort((a, b) =>
+    a.subject_type.localeCompare(b.subject_type) ||
+    a.subject_id - b.subject_id ||
+    a.predicate.localeCompare(b.predicate)
+  )
+}
+
+//
+// Resolve: one claim per subject+predicate group - the highest-rank one, or
+// every claim tied at the top when the tie is unresolved. Reads only.
+//
+export function resolve_claims(claims: Claim[]): Claim[] {
+  const groups = new Map<string, Claim[]>()
+
+  for (const c of claims) {
+    const k = group_key(c)
+    const list = groups.get(k) ?? []
+    list.push(c)
+    groups.set(k, list)
+  }
+
+  const out: Claim[] = []
+
+  for (const list of groups.values()) {
+    const sorted = sort_claims(list.slice())
+    const top_rank = sorted[0].rank ?? -1
+    const tied = sorted.filter(c => (c.rank ?? -1) === top_rank)
+    const distinct = new Set(tied.map(c => c.assertion))
+
+    // a tie between different assertions returns all of them; agreement collapses to one
+    out.push(...(distinct.size > 1 ? tied : [sorted[0]]))
+  }
+
+  return sort_claims(out)
+}
+
+//
+// Remove every claim attached to these subjects. One function, called from
+// every deletion path - concepts/delete, edges/delete, prune, re-extraction -
+// so no path can forget and leave a claim outliving its subject.
+//
+// claims is an all-key relation, so :rm needs the full row: read, then remove.
+//
+export async function cascade_claims(db: CozoDb, subject_type: string, ids: number[]): Promise<number> {
+  if (ids.length === 0) return 0
+
+  try {
+    const id_list = ids.join(", ")
+    const match = `*claims[id, subject_type, subject_id, predicate, assertion, authority, source, created_at],
+        subject_type = '${esc(subject_type)}',
+        subject_id in [${id_list}]`
+
+    const result = await db.run(`
+      ?[id, subject_type, subject_id, predicate, assertion, authority, source, created_at] := ${match}
+    `)
+
+    const rows = result.rows as unknown[][]
+    if (rows.length === 0) return 0
+
+    await db.run(`
+      ?[id, subject_type, subject_id, predicate, assertion, authority, source, created_at] := ${match}
+      :rm claims { id, subject_type, subject_id, predicate, assertion, authority, source, created_at }
+    `)
+
+    return rows.length
+  } catch {
+    // claims relation may not exist yet on an un-migrated db
+    return 0
+  }
+}
diff --git a/src/lib/migrate.ts b/src/lib/migrate.ts
index 899c9e6..331f8f2 100644
--- a/src/lib/migrate.ts
+++ b/src/lib/migrate.ts
@@ -9,12 +9,18 @@
 import type { CozoDb } from "./cozo"
 import { dirname, resolve } from "node:path"
 import { EMBED_DIM } from "./embed.ts"
+import {
+  CLAIMS_RELATION,
+  AUTHORITIES_RELATION,
+  seed_authorities,
+  seed_contradictions_rule
+} from "./claims.ts"
 
 //
 // The latest schema version this binary supports.
 // Bump this when adding a new migration.
 //
-export const LATEST_VERSION = "1.12.0"
+export const LATEST_VERSION = "1.13.0"
 
 //
 // A single migration step: transforms schema from one version to the next.
@@ -299,6 +305,20 @@ const MIGRATIONS: Migration[] = [
       `)
     }
   },
+
+  // v1.12.0 -> v1.13.0: claims + authority registry (#113)
+  // Additive only: two new relations, the seeded tiers, and one built-in rule.
+  // Definitions are shared with init.ts so a fresh db and a migrated db match.
+  {
+    from: "1.12.0",
+    to:   "1.13.0",
+    apply: async (db: CozoDb) => {
+      await db.run(CLAIMS_RELATION)
+      await db.run(AUTHORITIES_RELATION)
+      await seed_authorities(db)
+      await seed_contradictions_rule(db)
+    }
+  },
 ]
 
 //
diff --git a/src/lib/mind.ts b/src/lib/mind.ts
index 0c9dbc9..d82e5c6 100644
--- a/src/lib/mind.ts
+++ b/src/lib/mind.ts
@@ -158,6 +158,14 @@ export async function get_next_edge_id(db: CozoDb): Promise<number> {
 // Check if concept exists
 //
 
+export async function edge_exists(db: CozoDb, id: number): Promise<boolean> {
+  const result = await db.run(`
+    ?[id] := *edges[id, _, _, _, _, _], id = ${id}
+  `)
+  const rows = result.rows as unknown[][]
+  return rows.length > 0
+}
+
 export async function concept_exists(db: CozoDb, id: number): Promise<boolean> {
   const result = await db.run(`
     ?[id] := *concepts[id, _, _, _, _], id = ${id}
@@ -181,7 +189,7 @@ export interface Rule {
 // Built-in rule names (cannot be deleted or overwritten)
 //
 
-export const BUILTIN_RULE_NAMES = ["cycles", "orphans"] as const
+export const BUILTIN_RULE_NAMES = ["cycles", "orphans", "contradictions"] as const
 
 export function is_builtin_rule(name: string): boolean {
   return BUILTIN_RULE_NAMES.includes(name as typeof BUILTIN_RULE_NAMES[number])
@@ -211,6 +219,17 @@ export async function get_rule_by_name(db: CozoDb, name: string): Promise<Rule |
   }
 }
 
+//
+// Escape a string for a single-quoted CozoDB literal.
+//
+// Cozo uses backslash escapes, NOT SQL-style doubling: 'it''s' is a parse
+// error, 'it\'s' is correct. Getting this wrong silently rejects any value
+// containing an apostrophe.
+//
+export function esc_cozo(s: string): string {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")
+}
+
 //
 // Validate rule syntax using CozoDB's ::explain
 //
diff --git a/tests/calabi/pr-verify/data/00-success-no-violations/result.json b/tests/calabi/pr-verify/data/00-success-no-violations/result.json
index fc35328..178be25 100644
--- a/tests/calabi/pr-verify/data/00-success-no-violations/result.json
+++ b/tests/calabi/pr-verify/data/00-success-no-violations/result.json
@@ -15,13 +15,29 @@
     },
     "verification": {
       "summary": {
-        "rules_passed": 2,
+        "rules_passed": 3,
         "rules_failed": 0,
         "total_violations": 0
       },
       "rules": [
-        { "name": "cycles", "passed": true, "violations": [], "error": null },
-        { "name": "orphans", "passed": true, "violations": [], "error": null }
+        {
+          "name": "contradictions",
+          "passed": true,
+          "violations": [],
+          "error": null
+        },
+        {
+          "name": "cycles",
+          "passed": true,
+          "violations": [],
+          "error": null
+        },
+        {
+          "name": "orphans",
+          "passed": true,
+          "violations": [],
+          "error": null
+        }
       ]
     }
   },
diff --git a/tests/calabi/pr-verify/data/01-success-with-violations/result.json b/tests/calabi/pr-verify/data/01-success-with-violations/result.json
index 525b2ab..1ebbf93 100644
--- a/tests/calabi/pr-verify/data/01-success-with-violations/result.json
+++ b/tests/calabi/pr-verify/data/01-success-with-violations/result.json
@@ -15,13 +15,34 @@
     },
     "verification": {
       "summary": {
-        "rules_passed": 1,
+        "rules_passed": 2,
         "rules_failed": 1,
         "total_violations": 1
       },
       "rules": [
-        { "name": "cycles", "passed": true, "violations": [], "error": null },
-        { "name": "orphans", "passed": false, "violations": [{ "id": 1, "name": "Orphan" }], "error": null }
+        {
+          "name": "contradictions",
+          "passed": true,
+          "violations": [],
+          "error": null
+        },
+        {
+          "name": "cycles",
+          "passed": true,
+          "violations": [],
+          "error": null
+        },
+        {
+          "name": "orphans",
+          "passed": false,
+          "violations": [
+            {
+              "id": 1,
+              "name": "Orphan"
+            }
+          ],
+          "error": null
+        }
       ]
     }
   },
diff --git a/tests/calabi/pr-verify/data/02-success-no-changes/result.json b/tests/calabi/pr-verify/data/02-success-no-changes/result.json
index fc35328..178be25 100644
--- a/tests/calabi/pr-verify/data/02-success-no-changes/result.json
+++ b/tests/calabi/pr-verify/data/02-success-no-changes/result.json
@@ -15,13 +15,29 @@
     },
     "verification": {
       "summary": {
-        "rules_passed": 2,
+        "rules_passed": 3,
         "rules_failed": 0,
         "total_violations": 0
       },
       "rules": [
-        { "name": "cycles", "passed": true, "violations": [], "error": null },
-        { "name": "orphans", "passed": true, "violations": [], "error": null }
+        {
+          "name": "contradictions",
+          "passed": true,
+          "violations": [],
+          "error": null
+        },
+        {
+          "name": "cycles",
+          "passed": true,
+          "violations": [],
+          "error": null
+        },
+        {
+          "name": "orphans",
+          "passed": true,
+          "violations": [],
+          "error": null
+        }
       ]
     }
   },
diff --git a/tests/mind/authorities/data/00-success-list-defaults/params.json b/tests/mind/authorities/data/00-success-list-defaults/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/authorities/data/00-success-list-defaults/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/authorities/data/00-success-list-defaults/result.json b/tests/mind/authorities/data/00-success-list-defaults/result.json
new file mode 100644
index 0000000..bc1fd1d
--- /dev/null
+++ b/tests/mind/authorities/data/00-success-list-defaults/result.json
@@ -0,0 +1,39 @@
+{
+  "status": "success",
+  "result": {
+    "authorities": [
+      {
+        "name": "manual",
+        "rank": 100,
+        "description": "Direct human assertion; highest standing"
+      },
+      {
+        "name": "legal",
+        "rank": 40,
+        "description": "Legal or regulatory constraint"
+      },
+      {
+        "name": "product",
+        "rank": 30,
+        "description": "Product intent"
+      },
+      {
+        "name": "implementation",
+        "rank": 20,
+        "description": "What the code actually does"
+      },
+      {
+        "name": "observation",
+        "rank": 10,
+        "description": "Recorded from experience; non-binding by default"
+      }
+    ],
+    "count": 5
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/01-success-create/params.json b/tests/mind/authorities/data/01-success-create/params.json
new file mode 100644
index 0000000..1f47927
--- /dev/null
+++ b/tests/mind/authorities/data/01-success-create/params.json
@@ -0,0 +1,5 @@
+{
+  "name": "security",
+  "rank": 35,
+  "description": "Security review finding"
+}
diff --git a/tests/mind/authorities/data/01-success-create/result.json b/tests/mind/authorities/data/01-success-create/result.json
new file mode 100644
index 0000000..5ba4765
--- /dev/null
+++ b/tests/mind/authorities/data/01-success-create/result.json
@@ -0,0 +1,15 @@
+{
+  "status": "success",
+  "result": {
+    "name": "security",
+    "rank": 35,
+    "description": "Security review finding",
+    "created": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/02-success-upsert-existing/params.json b/tests/mind/authorities/data/02-success-upsert-existing/params.json
new file mode 100644
index 0000000..33cdbf9
--- /dev/null
+++ b/tests/mind/authorities/data/02-success-upsert-existing/params.json
@@ -0,0 +1,5 @@
+{
+  "name": "product",
+  "rank": 35,
+  "description": "Product intent, re-ranked"
+}
diff --git a/tests/mind/authorities/data/02-success-upsert-existing/result.json b/tests/mind/authorities/data/02-success-upsert-existing/result.json
new file mode 100644
index 0000000..1df9814
--- /dev/null
+++ b/tests/mind/authorities/data/02-success-upsert-existing/result.json
@@ -0,0 +1,15 @@
+{
+  "status": "success",
+  "result": {
+    "name": "product",
+    "rank": 35,
+    "description": "Product intent, re-ranked",
+    "created": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/03-success-upsert-preserves-description/params.json b/tests/mind/authorities/data/03-success-upsert-preserves-description/params.json
new file mode 100644
index 0000000..d3ba9b1
--- /dev/null
+++ b/tests/mind/authorities/data/03-success-upsert-preserves-description/params.json
@@ -0,0 +1,4 @@
+{
+  "name": "security",
+  "rank": 45
+}
diff --git a/tests/mind/authorities/data/03-success-upsert-preserves-description/result.json b/tests/mind/authorities/data/03-success-upsert-preserves-description/result.json
new file mode 100644
index 0000000..80fe162
--- /dev/null
+++ b/tests/mind/authorities/data/03-success-upsert-preserves-description/result.json
@@ -0,0 +1,15 @@
+{
+  "status": "success",
+  "result": {
+    "name": "security",
+    "rank": 45,
+    "description": "Security review finding",
+    "created": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/04-success-delete-unreferenced/params.json b/tests/mind/authorities/data/04-success-delete-unreferenced/params.json
new file mode 100644
index 0000000..11ba47b
--- /dev/null
+++ b/tests/mind/authorities/data/04-success-delete-unreferenced/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "security"
+}
diff --git a/tests/mind/authorities/data/04-success-delete-unreferenced/result.json b/tests/mind/authorities/data/04-success-delete-unreferenced/result.json
new file mode 100644
index 0000000..41cf6be
--- /dev/null
+++ b/tests/mind/authorities/data/04-success-delete-unreferenced/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "name": "security",
+    "deleted": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/05-error-delete-referenced/params.json b/tests/mind/authorities/data/05-error-delete-referenced/params.json
new file mode 100644
index 0000000..a8763bb
--- /dev/null
+++ b/tests/mind/authorities/data/05-error-delete-referenced/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "legal"
+}
diff --git a/tests/mind/authorities/data/05-error-delete-referenced/result.json b/tests/mind/authorities/data/05-error-delete-referenced/result.json
new file mode 100644
index 0000000..c2fe330
--- /dev/null
+++ b/tests/mind/authorities/data/05-error-delete-referenced/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "name": [
+      {
+        "code": "conflict",
+        "message": "authority tier is referenced by 1 claim: legal"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/06-error-delete-not-found/params.json b/tests/mind/authorities/data/06-error-delete-not-found/params.json
new file mode 100644
index 0000000..6d7e307
--- /dev/null
+++ b/tests/mind/authorities/data/06-error-delete-not-found/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "nope"
+}
diff --git a/tests/mind/authorities/data/06-error-delete-not-found/result.json b/tests/mind/authorities/data/06-error-delete-not-found/result.json
new file mode 100644
index 0000000..bcbe484
--- /dev/null
+++ b/tests/mind/authorities/data/06-error-delete-not-found/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "name": [
+      {
+        "code": "not_found",
+        "message": "authority tier not found: nope"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/07-error-rank-negative/params.json b/tests/mind/authorities/data/07-error-rank-negative/params.json
new file mode 100644
index 0000000..9be5a2d
--- /dev/null
+++ b/tests/mind/authorities/data/07-error-rank-negative/params.json
@@ -0,0 +1,4 @@
+{
+  "name": "weird",
+  "rank": -1
+}
diff --git a/tests/mind/authorities/data/07-error-rank-negative/result.json b/tests/mind/authorities/data/07-error-rank-negative/result.json
new file mode 100644
index 0000000..aef317c
--- /dev/null
+++ b/tests/mind/authorities/data/07-error-rank-negative/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "rank": [
+      {
+        "code": "invalid",
+        "message": "rank must be a non-negative integer"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/08-error-rank-non-integer/params.json b/tests/mind/authorities/data/08-error-rank-non-integer/params.json
new file mode 100644
index 0000000..c952b46
--- /dev/null
+++ b/tests/mind/authorities/data/08-error-rank-non-integer/params.json
@@ -0,0 +1,4 @@
+{
+  "name": "weird",
+  "rank": 3.5
+}
diff --git a/tests/mind/authorities/data/08-error-rank-non-integer/result.json b/tests/mind/authorities/data/08-error-rank-non-integer/result.json
new file mode 100644
index 0000000..aef317c
--- /dev/null
+++ b/tests/mind/authorities/data/08-error-rank-non-integer/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "rank": [
+      {
+        "code": "invalid",
+        "message": "rank must be a non-negative integer"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/09-error-name-required/params.json b/tests/mind/authorities/data/09-error-name-required/params.json
new file mode 100644
index 0000000..1a816d0
--- /dev/null
+++ b/tests/mind/authorities/data/09-error-name-required/params.json
@@ -0,0 +1,3 @@
+{
+  "rank": 10
+}
diff --git a/tests/mind/authorities/data/09-error-name-required/result.json b/tests/mind/authorities/data/09-error-name-required/result.json
new file mode 100644
index 0000000..53dcccb
--- /dev/null
+++ b/tests/mind/authorities/data/09-error-name-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "name": [
+      {
+        "code": "required",
+        "message": "name is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/10-error-not-initialized/params.json b/tests/mind/authorities/data/10-error-not-initialized/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/authorities/data/10-error-not-initialized/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/authorities/data/10-error-not-initialized/result.json b/tests/mind/authorities/data/10-error-not-initialized/result.json
new file mode 100644
index 0000000..51b6d52
--- /dev/null
+++ b/tests/mind/authorities/data/10-error-not-initialized/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "mind": [
+      {
+        "code": "not_initialized",
+        "message": "mind not initialized (run brane mind init)"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/11-success-rerank-reorders-without-rewrite/params.json b/tests/mind/authorities/data/11-success-rerank-reorders-without-rewrite/params.json
new file mode 100644
index 0000000..1bd17eb
--- /dev/null
+++ b/tests/mind/authorities/data/11-success-rerank-reorders-without-rewrite/params.json
@@ -0,0 +1,3 @@
+{
+  "subject_id": 1
+}
diff --git a/tests/mind/authorities/data/11-success-rerank-reorders-without-rewrite/result.json b/tests/mind/authorities/data/11-success-rerank-reorders-without-rewrite/result.json
new file mode 100644
index 0000000..257e4da
--- /dev/null
+++ b/tests/mind/authorities/data/11-success-rerank-reorders-without-rewrite/result.json
@@ -0,0 +1,48 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 3,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "45 days",
+        "authority": "implementation",
+        "rank": 100,
+        "source": "src/billing.ts",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "30 days",
+        "authority": "product",
+        "rank": 30,
+        "source": "dna/product/prd.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 3,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/12-error-rank-required/params.json b/tests/mind/authorities/data/12-error-rank-required/params.json
new file mode 100644
index 0000000..11ba47b
--- /dev/null
+++ b/tests/mind/authorities/data/12-error-rank-required/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "security"
+}
diff --git a/tests/mind/authorities/data/12-error-rank-required/result.json b/tests/mind/authorities/data/12-error-rank-required/result.json
new file mode 100644
index 0000000..b92e6bf
--- /dev/null
+++ b/tests/mind/authorities/data/12-error-rank-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "rank": [
+      {
+        "code": "required",
+        "message": "rank is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/13-success-list-rank-tie-name-asc/params.json b/tests/mind/authorities/data/13-success-list-rank-tie-name-asc/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/authorities/data/13-success-list-rank-tie-name-asc/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/authorities/data/13-success-list-rank-tie-name-asc/result.json b/tests/mind/authorities/data/13-success-list-rank-tie-name-asc/result.json
new file mode 100644
index 0000000..e92f021
--- /dev/null
+++ b/tests/mind/authorities/data/13-success-list-rank-tie-name-asc/result.json
@@ -0,0 +1,44 @@
+{
+  "status": "success",
+  "result": {
+    "authorities": [
+      {
+        "name": "manual",
+        "rank": 100,
+        "description": "Direct human assertion; highest standing"
+      },
+      {
+        "name": "legal",
+        "rank": 40,
+        "description": "Legal or regulatory constraint"
+      },
+      {
+        "name": "legal_eu",
+        "rank": 40,
+        "description": "EU legal constraint"
+      },
+      {
+        "name": "product",
+        "rank": 30,
+        "description": "Product intent"
+      },
+      {
+        "name": "implementation",
+        "rank": 20,
+        "description": "What the code actually does"
+      },
+      {
+        "name": "observation",
+        "rank": 10,
+        "description": "Recorded from experience; non-binding by default"
+      }
+    ],
+    "count": 6
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/data/14-error-name-too-long/params.json b/tests/mind/authorities/data/14-error-name-too-long/params.json
new file mode 100644
index 0000000..da8ecf8
--- /dev/null
+++ b/tests/mind/authorities/data/14-error-name-too-long/params.json
@@ -0,0 +1,4 @@
+{
+  "name": "nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn",
+  "rank": 10
+}
diff --git a/tests/mind/authorities/data/14-error-name-too-long/result.json b/tests/mind/authorities/data/14-error-name-too-long/result.json
new file mode 100644
index 0000000..9d057c3
--- /dev/null
+++ b/tests/mind/authorities/data/14-error-name-too-long/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "name": [
+      {
+        "code": "invalid",
+        "message": "name exceeds 64 characters"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/authorities/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/authorities/run b/tests/mind/authorities/run
new file mode 100755
index 0000000..d206b78
--- /dev/null
+++ b/tests/mind/authorities/run
@@ -0,0 +1,112 @@
+#!/usr/bin/env bash
+#
+# Test runner for /mind/authorities/*
+#
+set -e
+
+BRANE_ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$BRANE_ROOT/tests/lib.sh"
+
+INPUT=$(cat)
+workspace
+
+create_claim() {
+  echo "$1" | brane /mind/claims/create > /dev/null 2>&1
+}
+
+create_authority() {
+  echo "$1" | brane /mind/authorities/create > /dev/null 2>&1
+}
+
+case "$TC_CASE_NAME" in
+  # FR-005: the registry ships usable.
+  00-success-list-defaults)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/list
+    ;;
+
+  01-success-create)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  02-success-upsert-existing)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  # Rank-only update must not blank the description it did not mention.
+  03-success-upsert-preserves-description)
+    init_mind
+    create_authority '{"name":"security","rank":35,"description":"Security review finding"}'
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  04-success-delete-unreferenced)
+    init_mind
+    create_authority '{"name":"security","rank":35,"description":"Security review finding"}'
+    echo "$INPUT" | brane /mind/authorities/delete
+    ;;
+
+  # A referenced tier cannot be deleted: that would orphan a claim's standing.
+  05-error-delete-referenced)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"legal/policy.md"}'
+    echo "$INPUT" | brane /mind/authorities/delete
+    ;;
+
+  06-error-delete-not-found)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/delete
+    ;;
+
+  07-error-rank-negative)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  08-error-rank-non-integer)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  09-error-name-required)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  10-error-not-initialized)
+    init_body
+    echo "$INPUT" | brane /mind/authorities/list
+    ;;
+
+  # FR-012 / research D2: rank is joined at read time. Re-ranking a tier changes
+  # resolution order with no claim row rewritten - same ids, same timestamps.
+  11-success-rerank-reorders-without-rewrite)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"dna/product/prd.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"legal/policy.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"45 days","authority":"implementation","source":"src/billing.ts"}'
+    create_authority '{"name":"implementation","rank":100}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  12-error-rank-required)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+
+  # Ranks may tie; the list falls back to name ascending.
+  13-success-list-rank-tie-name-asc)
+    init_mind
+    create_authority '{"name":"legal_eu","rank":40,"description":"EU legal constraint"}'
+    echo "$INPUT" | brane /mind/authorities/list
+    ;;
+
+  14-error-name-too-long)
+    init_mind
+    echo "$INPUT" | brane /mind/authorities/create
+    ;;
+esac
diff --git a/tests/mind/claims/data/00-success-create/params.json b/tests/mind/claims/data/00-success-create/params.json
new file mode 100644
index 0000000..8130494
--- /dev/null
+++ b/tests/mind/claims/data/00-success-create/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "dna/product/prd.md"
+}
diff --git a/tests/mind/claims/data/00-success-create/result.json b/tests/mind/claims/data/00-success-create/result.json
new file mode 100644
index 0000000..2e80cf1
--- /dev/null
+++ b/tests/mind/claims/data/00-success-create/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 1,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "refund_window",
+    "assertion": "30 days",
+    "authority": "product",
+    "rank": 30,
+    "source": "dna/product/prd.md",
+    "created_at": "<timestamp>",
+    "created": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/01-success-create-edge-subject/params.json b/tests/mind/claims/data/01-success-create-edge-subject/params.json
new file mode 100644
index 0000000..715e70e
--- /dev/null
+++ b/tests/mind/claims/data/01-success-create-edge-subject/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "edge",
+  "subject_id": 1,
+  "predicate": "strength",
+  "assertion": "hard",
+  "authority": "implementation",
+  "source": "src/a.ts"
+}
diff --git a/tests/mind/claims/data/01-success-create-edge-subject/result.json b/tests/mind/claims/data/01-success-create-edge-subject/result.json
new file mode 100644
index 0000000..3552e58
--- /dev/null
+++ b/tests/mind/claims/data/01-success-create-edge-subject/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 1,
+    "subject_type": "edge",
+    "subject_id": 1,
+    "predicate": "strength",
+    "assertion": "hard",
+    "authority": "implementation",
+    "rank": 20,
+    "source": "src/a.ts",
+    "created_at": "<timestamp>",
+    "created": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/02-error-not-initialized/params.json b/tests/mind/claims/data/02-error-not-initialized/params.json
new file mode 100644
index 0000000..5e95995
--- /dev/null
+++ b/tests/mind/claims/data/02-error-not-initialized/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/02-error-not-initialized/result.json b/tests/mind/claims/data/02-error-not-initialized/result.json
new file mode 100644
index 0000000..4e1eed4
--- /dev/null
+++ b/tests/mind/claims/data/02-error-not-initialized/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "mind": [
+      {
+        "code": "not_initialized",
+        "message": "mind not initialized (run brane mind init)"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/03-error-subject-not-found/params.json b/tests/mind/claims/data/03-error-subject-not-found/params.json
new file mode 100644
index 0000000..d9b0b14
--- /dev/null
+++ b/tests/mind/claims/data/03-error-subject-not-found/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 999,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/03-error-subject-not-found/result.json b/tests/mind/claims/data/03-error-subject-not-found/result.json
new file mode 100644
index 0000000..3d068ce
--- /dev/null
+++ b/tests/mind/claims/data/03-error-subject-not-found/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "subject_id": [
+      {
+        "code": "not_found",
+        "message": "concept not found: 999"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/04-error-authority-not-registered/params.json b/tests/mind/claims/data/04-error-authority-not-registered/params.json
new file mode 100644
index 0000000..5b1d497
--- /dev/null
+++ b/tests/mind/claims/data/04-error-authority-not-registered/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "vibes",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/04-error-authority-not-registered/result.json b/tests/mind/claims/data/04-error-authority-not-registered/result.json
new file mode 100644
index 0000000..0637b42
--- /dev/null
+++ b/tests/mind/claims/data/04-error-authority-not-registered/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "authority": [
+      {
+        "code": "not_found",
+        "message": "authority tier not registered: vibes"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/05-error-assertion-required/params.json b/tests/mind/claims/data/05-error-assertion-required/params.json
new file mode 100644
index 0000000..479434a
--- /dev/null
+++ b/tests/mind/claims/data/05-error-assertion-required/params.json
@@ -0,0 +1,7 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/05-error-assertion-required/result.json b/tests/mind/claims/data/05-error-assertion-required/result.json
new file mode 100644
index 0000000..b5b1cd9
--- /dev/null
+++ b/tests/mind/claims/data/05-error-assertion-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "assertion": [
+      {
+        "code": "required",
+        "message": "assertion is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/06-error-source-required/params.json b/tests/mind/claims/data/06-error-source-required/params.json
new file mode 100644
index 0000000..40ba12f
--- /dev/null
+++ b/tests/mind/claims/data/06-error-source-required/params.json
@@ -0,0 +1,7 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product"
+}
diff --git a/tests/mind/claims/data/06-error-source-required/result.json b/tests/mind/claims/data/06-error-source-required/result.json
new file mode 100644
index 0000000..8d65cd9
--- /dev/null
+++ b/tests/mind/claims/data/06-error-source-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "source": [
+      {
+        "code": "required",
+        "message": "source is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/07-error-invalid-subject-type/params.json b/tests/mind/claims/data/07-error-invalid-subject-type/params.json
new file mode 100644
index 0000000..8864d6f
--- /dev/null
+++ b/tests/mind/claims/data/07-error-invalid-subject-type/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "episode",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/07-error-invalid-subject-type/result.json b/tests/mind/claims/data/07-error-invalid-subject-type/result.json
new file mode 100644
index 0000000..65827b7
--- /dev/null
+++ b/tests/mind/claims/data/07-error-invalid-subject-type/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "subject_type": [
+      {
+        "code": "invalid",
+        "message": "subject_type must be one of: concept, edge"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/08-error-assertion-too-long/params.json b/tests/mind/claims/data/08-error-assertion-too-long/params.json
new file mode 100644
index 0000000..5a338cf
--- /dev/null
+++ b/tests/mind/claims/data/08-error-assertion-too-long/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/08-error-assertion-too-long/result.json b/tests/mind/claims/data/08-error-assertion-too-long/result.json
new file mode 100644
index 0000000..2bcb2c6
--- /dev/null
+++ b/tests/mind/claims/data/08-error-assertion-too-long/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "assertion": [
+      {
+        "code": "invalid",
+        "message": "assertion exceeds 4096 characters"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/09-success-freeform-predicate/params.json b/tests/mind/claims/data/09-success-freeform-predicate/params.json
new file mode 100644
index 0000000..bc56673
--- /dev/null
+++ b/tests/mind/claims/data/09-success-freeform-predicate/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "whatever_nobody_registered",
+  "assertion": "anything at all",
+  "authority": "observation",
+  "source": "session"
+}
diff --git a/tests/mind/claims/data/09-success-freeform-predicate/result.json b/tests/mind/claims/data/09-success-freeform-predicate/result.json
new file mode 100644
index 0000000..8812862
--- /dev/null
+++ b/tests/mind/claims/data/09-success-freeform-predicate/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 1,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "whatever_nobody_registered",
+    "assertion": "anything at all",
+    "authority": "observation",
+    "rank": 10,
+    "source": "session",
+    "created_at": "<timestamp>",
+    "created": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/10-success-trim-on-write/params.json b/tests/mind/claims/data/10-success-trim-on-write/params.json
new file mode 100644
index 0000000..e9a8172
--- /dev/null
+++ b/tests/mind/claims/data/10-success-trim-on-write/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "  refund_window  ",
+  "assertion": "  30 days  ",
+  "authority": " product ",
+  "source": "  prd.md  "
+}
diff --git a/tests/mind/claims/data/10-success-trim-on-write/result.json b/tests/mind/claims/data/10-success-trim-on-write/result.json
new file mode 100644
index 0000000..280c412
--- /dev/null
+++ b/tests/mind/claims/data/10-success-trim-on-write/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 1,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "refund_window",
+    "assertion": "30 days",
+    "authority": "product",
+    "rank": 30,
+    "source": "prd.md",
+    "created_at": "<timestamp>",
+    "created": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/11-success-idempotent-reassert/params.json b/tests/mind/claims/data/11-success-idempotent-reassert/params.json
new file mode 100644
index 0000000..8130494
--- /dev/null
+++ b/tests/mind/claims/data/11-success-idempotent-reassert/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "dna/product/prd.md"
+}
diff --git a/tests/mind/claims/data/11-success-idempotent-reassert/result.json b/tests/mind/claims/data/11-success-idempotent-reassert/result.json
new file mode 100644
index 0000000..cac1fda
--- /dev/null
+++ b/tests/mind/claims/data/11-success-idempotent-reassert/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 1,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "refund_window",
+    "assertion": "30 days",
+    "authority": "product",
+    "rank": 30,
+    "source": "dna/product/prd.md",
+    "created_at": "<timestamp>",
+    "created": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/12-success-idempotent-whitespace-variant/params.json b/tests/mind/claims/data/12-success-idempotent-whitespace-variant/params.json
new file mode 100644
index 0000000..7e26890
--- /dev/null
+++ b/tests/mind/claims/data/12-success-idempotent-whitespace-variant/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window ",
+  "assertion": " 30 days",
+  "authority": "product",
+  "source": "dna/product/prd.md "
+}
diff --git a/tests/mind/claims/data/12-success-idempotent-whitespace-variant/result.json b/tests/mind/claims/data/12-success-idempotent-whitespace-variant/result.json
new file mode 100644
index 0000000..cac1fda
--- /dev/null
+++ b/tests/mind/claims/data/12-success-idempotent-whitespace-variant/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 1,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "refund_window",
+    "assertion": "30 days",
+    "authority": "product",
+    "rank": 30,
+    "source": "dna/product/prd.md",
+    "created_at": "<timestamp>",
+    "created": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/13-success-get/params.json b/tests/mind/claims/data/13-success-get/params.json
new file mode 100644
index 0000000..18ee12c
--- /dev/null
+++ b/tests/mind/claims/data/13-success-get/params.json
@@ -0,0 +1,3 @@
+{
+  "id": 2
+}
diff --git a/tests/mind/claims/data/13-success-get/result.json b/tests/mind/claims/data/13-success-get/result.json
new file mode 100644
index 0000000..9d81e64
--- /dev/null
+++ b/tests/mind/claims/data/13-success-get/result.json
@@ -0,0 +1,20 @@
+{
+  "status": "success",
+  "result": {
+    "id": 2,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "refund_window",
+    "assertion": "14 days",
+    "authority": "legal",
+    "rank": 40,
+    "source": "legal/policy.md",
+    "created_at": "<timestamp>"
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/get",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/14-error-get-not-found/params.json b/tests/mind/claims/data/14-error-get-not-found/params.json
new file mode 100644
index 0000000..d4bd3e4
--- /dev/null
+++ b/tests/mind/claims/data/14-error-get-not-found/params.json
@@ -0,0 +1,3 @@
+{
+  "id": 999
+}
diff --git a/tests/mind/claims/data/14-error-get-not-found/result.json b/tests/mind/claims/data/14-error-get-not-found/result.json
new file mode 100644
index 0000000..de7c56e
--- /dev/null
+++ b/tests/mind/claims/data/14-error-get-not-found/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "id": [
+      {
+        "code": "not_found",
+        "message": "claim not found: 999"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/get",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/15-success-list-all/params.json b/tests/mind/claims/data/15-success-list-all/params.json
new file mode 100644
index 0000000..1bd17eb
--- /dev/null
+++ b/tests/mind/claims/data/15-success-list-all/params.json
@@ -0,0 +1,3 @@
+{
+  "subject_id": 1
+}
diff --git a/tests/mind/claims/data/15-success-list-all/result.json b/tests/mind/claims/data/15-success-list-all/result.json
new file mode 100644
index 0000000..d509d29
--- /dev/null
+++ b/tests/mind/claims/data/15-success-list-all/result.json
@@ -0,0 +1,48 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "30 days",
+        "authority": "product",
+        "rank": 30,
+        "source": "dna/product/prd.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 3,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "45 days",
+        "authority": "implementation",
+        "rank": 20,
+        "source": "src/billing.ts",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 3,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/16-success-list-filter-predicate/params.json b/tests/mind/claims/data/16-success-list-filter-predicate/params.json
new file mode 100644
index 0000000..35138ca
--- /dev/null
+++ b/tests/mind/claims/data/16-success-list-filter-predicate/params.json
@@ -0,0 +1,4 @@
+{
+  "subject_id": 1,
+  "predicate": "refund_window"
+}
diff --git a/tests/mind/claims/data/16-success-list-filter-predicate/result.json b/tests/mind/claims/data/16-success-list-filter-predicate/result.json
new file mode 100644
index 0000000..d509d29
--- /dev/null
+++ b/tests/mind/claims/data/16-success-list-filter-predicate/result.json
@@ -0,0 +1,48 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "30 days",
+        "authority": "product",
+        "rank": 30,
+        "source": "dna/product/prd.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 3,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "45 days",
+        "authority": "implementation",
+        "rank": 20,
+        "source": "src/billing.ts",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 3,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/17-success-list-filter-authority/params.json b/tests/mind/claims/data/17-success-list-filter-authority/params.json
new file mode 100644
index 0000000..ee51f65
--- /dev/null
+++ b/tests/mind/claims/data/17-success-list-filter-authority/params.json
@@ -0,0 +1,4 @@
+{
+  "subject_id": 1,
+  "authority": "legal"
+}
diff --git a/tests/mind/claims/data/17-success-list-filter-authority/result.json b/tests/mind/claims/data/17-success-list-filter-authority/result.json
new file mode 100644
index 0000000..6239497
--- /dev/null
+++ b/tests/mind/claims/data/17-success-list-filter-authority/result.json
@@ -0,0 +1,26 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 1,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/18-success-list-empty/params.json b/tests/mind/claims/data/18-success-list-empty/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/18-success-list-empty/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/18-success-list-empty/result.json b/tests/mind/claims/data/18-success-list-empty/result.json
new file mode 100644
index 0000000..c0d4f07
--- /dev/null
+++ b/tests/mind/claims/data/18-success-list-empty/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [],
+    "count": 0,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/19-success-list-resolve/params.json b/tests/mind/claims/data/19-success-list-resolve/params.json
new file mode 100644
index 0000000..cc5873d
--- /dev/null
+++ b/tests/mind/claims/data/19-success-list-resolve/params.json
@@ -0,0 +1,4 @@
+{
+  "subject_id": 1,
+  "resolve": true
+}
diff --git a/tests/mind/claims/data/19-success-list-resolve/result.json b/tests/mind/claims/data/19-success-list-resolve/result.json
new file mode 100644
index 0000000..49a0616
--- /dev/null
+++ b/tests/mind/claims/data/19-success-list-resolve/result.json
@@ -0,0 +1,26 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 1,
+    "resolved": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/20-success-list-unchanged-after-resolve/params.json b/tests/mind/claims/data/20-success-list-unchanged-after-resolve/params.json
new file mode 100644
index 0000000..1bd17eb
--- /dev/null
+++ b/tests/mind/claims/data/20-success-list-unchanged-after-resolve/params.json
@@ -0,0 +1,3 @@
+{
+  "subject_id": 1
+}
diff --git a/tests/mind/claims/data/20-success-list-unchanged-after-resolve/result.json b/tests/mind/claims/data/20-success-list-unchanged-after-resolve/result.json
new file mode 100644
index 0000000..d509d29
--- /dev/null
+++ b/tests/mind/claims/data/20-success-list-unchanged-after-resolve/result.json
@@ -0,0 +1,48 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "30 days",
+        "authority": "product",
+        "rank": 30,
+        "source": "dna/product/prd.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 3,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "45 days",
+        "authority": "implementation",
+        "rank": 20,
+        "source": "src/billing.ts",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 3,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/21-success-conflicts/params.json b/tests/mind/claims/data/21-success-conflicts/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/21-success-conflicts/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/21-success-conflicts/result.json b/tests/mind/claims/data/21-success-conflicts/result.json
new file mode 100644
index 0000000..c19ffd2
--- /dev/null
+++ b/tests/mind/claims/data/21-success-conflicts/result.json
@@ -0,0 +1,52 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "claims": [
+          {
+            "id": 2,
+            "assertion": "14 days",
+            "authority": "legal",
+            "rank": 40,
+            "source": "legal/policy.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 1,
+            "assertion": "30 days",
+            "authority": "product",
+            "rank": 30,
+            "source": "dna/product/prd.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 3,
+            "assertion": "45 days",
+            "authority": "implementation",
+            "rank": 20,
+            "source": "src/billing.ts",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 2,
+          "assertion": "14 days",
+          "authority": "legal",
+          "rank": 40
+        },
+        "unresolved": false
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/22-success-conflicts-agreement-is-not-conflict/params.json b/tests/mind/claims/data/22-success-conflicts-agreement-is-not-conflict/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/22-success-conflicts-agreement-is-not-conflict/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/22-success-conflicts-agreement-is-not-conflict/result.json b/tests/mind/claims/data/22-success-conflicts-agreement-is-not-conflict/result.json
new file mode 100644
index 0000000..8c6c46d
--- /dev/null
+++ b/tests/mind/claims/data/22-success-conflicts-agreement-is-not-conflict/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [],
+    "count": 0
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/23-success-conflicts-tie-unresolved/params.json b/tests/mind/claims/data/23-success-conflicts-tie-unresolved/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/23-success-conflicts-tie-unresolved/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/23-success-conflicts-tie-unresolved/result.json b/tests/mind/claims/data/23-success-conflicts-tie-unresolved/result.json
new file mode 100644
index 0000000..e77c2b9
--- /dev/null
+++ b/tests/mind/claims/data/23-success-conflicts-tie-unresolved/result.json
@@ -0,0 +1,39 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "claims": [
+          {
+            "id": 1,
+            "assertion": "14 days",
+            "authority": "legal",
+            "rank": 40,
+            "source": "legal/us.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 2,
+            "assertion": "30 days",
+            "authority": "legal_eu",
+            "rank": 40,
+            "source": "legal/eu.md",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": null,
+        "unresolved": true
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/24-success-conflicts-empty/params.json b/tests/mind/claims/data/24-success-conflicts-empty/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/24-success-conflicts-empty/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/24-success-conflicts-empty/result.json b/tests/mind/claims/data/24-success-conflicts-empty/result.json
new file mode 100644
index 0000000..8c6c46d
--- /dev/null
+++ b/tests/mind/claims/data/24-success-conflicts-empty/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [],
+    "count": 0
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/25-success-delete/params.json b/tests/mind/claims/data/25-success-delete/params.json
new file mode 100644
index 0000000..e93da38
--- /dev/null
+++ b/tests/mind/claims/data/25-success-delete/params.json
@@ -0,0 +1,3 @@
+{
+  "id": 3
+}
diff --git a/tests/mind/claims/data/25-success-delete/result.json b/tests/mind/claims/data/25-success-delete/result.json
new file mode 100644
index 0000000..c6c145b
--- /dev/null
+++ b/tests/mind/claims/data/25-success-delete/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "id": 3,
+    "deleted": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/26-error-delete-not-found/params.json b/tests/mind/claims/data/26-error-delete-not-found/params.json
new file mode 100644
index 0000000..d4bd3e4
--- /dev/null
+++ b/tests/mind/claims/data/26-error-delete-not-found/params.json
@@ -0,0 +1,3 @@
+{
+  "id": 999
+}
diff --git a/tests/mind/claims/data/26-error-delete-not-found/result.json b/tests/mind/claims/data/26-error-delete-not-found/result.json
new file mode 100644
index 0000000..fee15ea
--- /dev/null
+++ b/tests/mind/claims/data/26-error-delete-not-found/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "id": [
+      {
+        "code": "not_found",
+        "message": "claim not found: 999"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/27-success-delete-recomputes-conflicts/params.json b/tests/mind/claims/data/27-success-delete-recomputes-conflicts/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/27-success-delete-recomputes-conflicts/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/27-success-delete-recomputes-conflicts/result.json b/tests/mind/claims/data/27-success-delete-recomputes-conflicts/result.json
new file mode 100644
index 0000000..4326bb0
--- /dev/null
+++ b/tests/mind/claims/data/27-success-delete-recomputes-conflicts/result.json
@@ -0,0 +1,44 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "claims": [
+          {
+            "id": 2,
+            "assertion": "14 days",
+            "authority": "legal",
+            "rank": 40,
+            "source": "legal/policy.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 1,
+            "assertion": "30 days",
+            "authority": "product",
+            "rank": 30,
+            "source": "dna/product/prd.md",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 2,
+          "assertion": "14 days",
+          "authority": "legal",
+          "rank": 40
+        },
+        "unresolved": false
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/28-success-cascade-concept-delete/params.json b/tests/mind/claims/data/28-success-cascade-concept-delete/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/28-success-cascade-concept-delete/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/28-success-cascade-concept-delete/result.json b/tests/mind/claims/data/28-success-cascade-concept-delete/result.json
new file mode 100644
index 0000000..c0d4f07
--- /dev/null
+++ b/tests/mind/claims/data/28-success-cascade-concept-delete/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [],
+    "count": 0,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/29-success-cascade-concept-delete-takes-edge-claims/params.json b/tests/mind/claims/data/29-success-cascade-concept-delete-takes-edge-claims/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/29-success-cascade-concept-delete-takes-edge-claims/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/29-success-cascade-concept-delete-takes-edge-claims/result.json b/tests/mind/claims/data/29-success-cascade-concept-delete-takes-edge-claims/result.json
new file mode 100644
index 0000000..c0d4f07
--- /dev/null
+++ b/tests/mind/claims/data/29-success-cascade-concept-delete-takes-edge-claims/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [],
+    "count": 0,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/30-success-cascade-edge-delete/params.json b/tests/mind/claims/data/30-success-cascade-edge-delete/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/30-success-cascade-edge-delete/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/30-success-cascade-edge-delete/result.json b/tests/mind/claims/data/30-success-cascade-edge-delete/result.json
new file mode 100644
index 0000000..c0d4f07
--- /dev/null
+++ b/tests/mind/claims/data/30-success-cascade-edge-delete/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [],
+    "count": 0,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/31-success-cascade-prune/params.json b/tests/mind/claims/data/31-success-cascade-prune/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/31-success-cascade-prune/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/31-success-cascade-prune/result.json b/tests/mind/claims/data/31-success-cascade-prune/result.json
new file mode 100644
index 0000000..c0d4f07
--- /dev/null
+++ b/tests/mind/claims/data/31-success-cascade-prune/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [],
+    "count": 0,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/32-success-list-resolve-tie/params.json b/tests/mind/claims/data/32-success-list-resolve-tie/params.json
new file mode 100644
index 0000000..cc5873d
--- /dev/null
+++ b/tests/mind/claims/data/32-success-list-resolve-tie/params.json
@@ -0,0 +1,4 @@
+{
+  "subject_id": 1,
+  "resolve": true
+}
diff --git a/tests/mind/claims/data/32-success-list-resolve-tie/result.json b/tests/mind/claims/data/32-success-list-resolve-tie/result.json
new file mode 100644
index 0000000..2b5c9f2
--- /dev/null
+++ b/tests/mind/claims/data/32-success-list-resolve-tie/result.json
@@ -0,0 +1,37 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/us.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "30 days",
+        "authority": "legal_eu",
+        "rank": 40,
+        "source": "legal/eu.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 2,
+    "resolved": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/33-success-list-resolve-multiple-groups/params.json b/tests/mind/claims/data/33-success-list-resolve-multiple-groups/params.json
new file mode 100644
index 0000000..cc5873d
--- /dev/null
+++ b/tests/mind/claims/data/33-success-list-resolve-multiple-groups/params.json
@@ -0,0 +1,4 @@
+{
+  "subject_id": 1,
+  "resolve": true
+}
diff --git a/tests/mind/claims/data/33-success-list-resolve-multiple-groups/result.json b/tests/mind/claims/data/33-success-list-resolve-multiple-groups/result.json
new file mode 100644
index 0000000..657cc7f
--- /dev/null
+++ b/tests/mind/claims/data/33-success-list-resolve-multiple-groups/result.json
@@ -0,0 +1,37 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 4,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "owner",
+        "assertion": "billing-team",
+        "authority": "product",
+        "rank": 30,
+        "source": "dna/product/prd.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 2,
+    "resolved": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/34-success-list-agreement-retained/params.json b/tests/mind/claims/data/34-success-list-agreement-retained/params.json
new file mode 100644
index 0000000..1bd17eb
--- /dev/null
+++ b/tests/mind/claims/data/34-success-list-agreement-retained/params.json
@@ -0,0 +1,3 @@
+{
+  "subject_id": 1
+}
diff --git a/tests/mind/claims/data/34-success-list-agreement-retained/result.json b/tests/mind/claims/data/34-success-list-agreement-retained/result.json
new file mode 100644
index 0000000..44836b6
--- /dev/null
+++ b/tests/mind/claims/data/34-success-list-agreement-retained/result.json
@@ -0,0 +1,37 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "color",
+        "assertion": "blue",
+        "authority": "legal",
+        "rank": 40,
+        "source": "b.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "color",
+        "assertion": "blue",
+        "authority": "product",
+        "rank": 30,
+        "source": "a.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 2,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/35-success-create-different-source-is-new-claim/params.json b/tests/mind/claims/data/35-success-create-different-source-is-new-claim/params.json
new file mode 100644
index 0000000..4572c36
--- /dev/null
+++ b/tests/mind/claims/data/35-success-create-different-source-is-new-claim/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "docs/handbook.md"
+}
diff --git a/tests/mind/claims/data/35-success-create-different-source-is-new-claim/result.json b/tests/mind/claims/data/35-success-create-different-source-is-new-claim/result.json
new file mode 100644
index 0000000..5e6cc2d
--- /dev/null
+++ b/tests/mind/claims/data/35-success-create-different-source-is-new-claim/result.json
@@ -0,0 +1,21 @@
+{
+  "status": "success",
+  "result": {
+    "id": 2,
+    "subject_type": "concept",
+    "subject_id": 1,
+    "predicate": "refund_window",
+    "assertion": "30 days",
+    "authority": "product",
+    "rank": 30,
+    "source": "docs/handbook.md",
+    "created_at": "<timestamp>",
+    "created": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/36-success-conflicts-filter-subject/params.json b/tests/mind/claims/data/36-success-conflicts-filter-subject/params.json
new file mode 100644
index 0000000..1bd17eb
--- /dev/null
+++ b/tests/mind/claims/data/36-success-conflicts-filter-subject/params.json
@@ -0,0 +1,3 @@
+{
+  "subject_id": 1
+}
diff --git a/tests/mind/claims/data/36-success-conflicts-filter-subject/result.json b/tests/mind/claims/data/36-success-conflicts-filter-subject/result.json
new file mode 100644
index 0000000..c19ffd2
--- /dev/null
+++ b/tests/mind/claims/data/36-success-conflicts-filter-subject/result.json
@@ -0,0 +1,52 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "claims": [
+          {
+            "id": 2,
+            "assertion": "14 days",
+            "authority": "legal",
+            "rank": 40,
+            "source": "legal/policy.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 1,
+            "assertion": "30 days",
+            "authority": "product",
+            "rank": 30,
+            "source": "dna/product/prd.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 3,
+            "assertion": "45 days",
+            "authority": "implementation",
+            "rank": 20,
+            "source": "src/billing.ts",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 2,
+          "assertion": "14 days",
+          "authority": "legal",
+          "rank": 40
+        },
+        "unresolved": false
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/37-success-conflicts-two-groups/params.json b/tests/mind/claims/data/37-success-conflicts-two-groups/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/37-success-conflicts-two-groups/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/37-success-conflicts-two-groups/result.json b/tests/mind/claims/data/37-success-conflicts-two-groups/result.json
new file mode 100644
index 0000000..1a0d6f8
--- /dev/null
+++ b/tests/mind/claims/data/37-success-conflicts-two-groups/result.json
@@ -0,0 +1,82 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "claims": [
+          {
+            "id": 2,
+            "assertion": "14 days",
+            "authority": "legal",
+            "rank": 40,
+            "source": "legal/policy.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 1,
+            "assertion": "30 days",
+            "authority": "product",
+            "rank": 30,
+            "source": "dna/product/prd.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 3,
+            "assertion": "45 days",
+            "authority": "implementation",
+            "rank": 20,
+            "source": "src/billing.ts",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 2,
+          "assertion": "14 days",
+          "authority": "legal",
+          "rank": 40
+        },
+        "unresolved": false
+      },
+      {
+        "subject_type": "concept",
+        "subject_id": 2,
+        "predicate": "color",
+        "claims": [
+          {
+            "id": 5,
+            "assertion": "red",
+            "authority": "legal",
+            "rank": 40,
+            "source": "b.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 4,
+            "assertion": "blue",
+            "authority": "product",
+            "rank": 30,
+            "source": "a.md",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 5,
+          "assertion": "red",
+          "authority": "legal",
+          "rank": 40
+        },
+        "unresolved": false
+      }
+    ],
+    "count": 2
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/38-error-predicate-required/params.json b/tests/mind/claims/data/38-error-predicate-required/params.json
new file mode 100644
index 0000000..e116087
--- /dev/null
+++ b/tests/mind/claims/data/38-error-predicate-required/params.json
@@ -0,0 +1,7 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/38-error-predicate-required/result.json b/tests/mind/claims/data/38-error-predicate-required/result.json
new file mode 100644
index 0000000..bd06599
--- /dev/null
+++ b/tests/mind/claims/data/38-error-predicate-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "predicate": [
+      {
+        "code": "required",
+        "message": "predicate is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/39-error-authority-required/params.json b/tests/mind/claims/data/39-error-authority-required/params.json
new file mode 100644
index 0000000..f2f07cf
--- /dev/null
+++ b/tests/mind/claims/data/39-error-authority-required/params.json
@@ -0,0 +1,7 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/39-error-authority-required/result.json b/tests/mind/claims/data/39-error-authority-required/result.json
new file mode 100644
index 0000000..406c346
--- /dev/null
+++ b/tests/mind/claims/data/39-error-authority-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "authority": [
+      {
+        "code": "required",
+        "message": "authority is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/40-error-subject-type-required/params.json b/tests/mind/claims/data/40-error-subject-type-required/params.json
new file mode 100644
index 0000000..d30ddec
--- /dev/null
+++ b/tests/mind/claims/data/40-error-subject-type-required/params.json
@@ -0,0 +1,7 @@
+{
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/40-error-subject-type-required/result.json b/tests/mind/claims/data/40-error-subject-type-required/result.json
new file mode 100644
index 0000000..5440c7c
--- /dev/null
+++ b/tests/mind/claims/data/40-error-subject-type-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "subject_type": [
+      {
+        "code": "required",
+        "message": "subject_type is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/41-error-subject-id-required/params.json b/tests/mind/claims/data/41-error-subject-id-required/params.json
new file mode 100644
index 0000000..25b9b30
--- /dev/null
+++ b/tests/mind/claims/data/41-error-subject-id-required/params.json
@@ -0,0 +1,7 @@
+{
+  "subject_type": "concept",
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/41-error-subject-id-required/result.json b/tests/mind/claims/data/41-error-subject-id-required/result.json
new file mode 100644
index 0000000..9b5c30f
--- /dev/null
+++ b/tests/mind/claims/data/41-error-subject-id-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "subject_id": [
+      {
+        "code": "required",
+        "message": "subject_id is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/42-error-assertion-blank-after-trim/params.json b/tests/mind/claims/data/42-error-assertion-blank-after-trim/params.json
new file mode 100644
index 0000000..0555a91
--- /dev/null
+++ b/tests/mind/claims/data/42-error-assertion-blank-after-trim/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "   ",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/42-error-assertion-blank-after-trim/result.json b/tests/mind/claims/data/42-error-assertion-blank-after-trim/result.json
new file mode 100644
index 0000000..6ddc6f1
--- /dev/null
+++ b/tests/mind/claims/data/42-error-assertion-blank-after-trim/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "assertion": [
+      {
+        "code": "invalid",
+        "message": "assertion must not be empty"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/43-error-edge-subject-not-found/params.json b/tests/mind/claims/data/43-error-edge-subject-not-found/params.json
new file mode 100644
index 0000000..07e2119
--- /dev/null
+++ b/tests/mind/claims/data/43-error-edge-subject-not-found/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "edge",
+  "subject_id": 999,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/43-error-edge-subject-not-found/result.json b/tests/mind/claims/data/43-error-edge-subject-not-found/result.json
new file mode 100644
index 0000000..730a965
--- /dev/null
+++ b/tests/mind/claims/data/43-error-edge-subject-not-found/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "subject_id": [
+      {
+        "code": "not_found",
+        "message": "edge not found: 999"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/44-success-concept-delete-reports-claims-removed/params.json b/tests/mind/claims/data/44-success-concept-delete-reports-claims-removed/params.json
new file mode 100644
index 0000000..2572ae5
--- /dev/null
+++ b/tests/mind/claims/data/44-success-concept-delete-reports-claims-removed/params.json
@@ -0,0 +1,3 @@
+{
+  "id": 1
+}
diff --git a/tests/mind/claims/data/44-success-concept-delete-reports-claims-removed/result.json b/tests/mind/claims/data/44-success-concept-delete-reports-claims-removed/result.json
new file mode 100644
index 0000000..4cad1e1
--- /dev/null
+++ b/tests/mind/claims/data/44-success-concept-delete-reports-claims-removed/result.json
@@ -0,0 +1,18 @@
+{
+  "status": "success",
+  "result": {
+    "deleted": true,
+    "cascade": {
+      "edges_removed": 1,
+      "annotations_removed": 0,
+      "provenance_removed": 0,
+      "claims_removed": 3
+    }
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/concepts/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/45-success-list-filter-subject-type/params.json b/tests/mind/claims/data/45-success-list-filter-subject-type/params.json
new file mode 100644
index 0000000..2c3caab
--- /dev/null
+++ b/tests/mind/claims/data/45-success-list-filter-subject-type/params.json
@@ -0,0 +1,3 @@
+{
+  "subject_type": "edge"
+}
diff --git a/tests/mind/claims/data/45-success-list-filter-subject-type/result.json b/tests/mind/claims/data/45-success-list-filter-subject-type/result.json
new file mode 100644
index 0000000..e29ad63
--- /dev/null
+++ b/tests/mind/claims/data/45-success-list-filter-subject-type/result.json
@@ -0,0 +1,26 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "edge",
+        "subject_id": 1,
+        "predicate": "note",
+        "assertion": "on the edge",
+        "authority": "observation",
+        "rank": 10,
+        "source": "session",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 1,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/46-error-predicate-too-long/params.json b/tests/mind/claims/data/46-error-predicate-too-long/params.json
new file mode 100644
index 0000000..cc636ba
--- /dev/null
+++ b/tests/mind/claims/data/46-error-predicate-too-long/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "prd.md"
+}
diff --git a/tests/mind/claims/data/46-error-predicate-too-long/result.json b/tests/mind/claims/data/46-error-predicate-too-long/result.json
new file mode 100644
index 0000000..aaec6b5
--- /dev/null
+++ b/tests/mind/claims/data/46-error-predicate-too-long/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "predicate": [
+      {
+        "code": "invalid",
+        "message": "predicate exceeds 256 characters"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/47-error-source-too-long/params.json b/tests/mind/claims/data/47-error-source-too-long/params.json
new file mode 100644
index 0000000..81b7eda
--- /dev/null
+++ b/tests/mind/claims/data/47-error-source-too-long/params.json
@@ -0,0 +1,8 @@
+{
+  "subject_type": "concept",
+  "subject_id": 1,
+  "predicate": "refund_window",
+  "assertion": "30 days",
+  "authority": "product",
+  "source": "sssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss"
+}
diff --git a/tests/mind/claims/data/47-error-source-too-long/result.json b/tests/mind/claims/data/47-error-source-too-long/result.json
new file mode 100644
index 0000000..8deab6a
--- /dev/null
+++ b/tests/mind/claims/data/47-error-source-too-long/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "source": [
+      {
+        "code": "invalid",
+        "message": "source exceeds 1024 characters"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/48-success-list-limit/params.json b/tests/mind/claims/data/48-success-list-limit/params.json
new file mode 100644
index 0000000..1b52ec2
--- /dev/null
+++ b/tests/mind/claims/data/48-success-list-limit/params.json
@@ -0,0 +1,4 @@
+{
+  "subject_id": 1,
+  "limit": 2
+}
diff --git a/tests/mind/claims/data/48-success-list-limit/result.json b/tests/mind/claims/data/48-success-list-limit/result.json
new file mode 100644
index 0000000..d252fb5
--- /dev/null
+++ b/tests/mind/claims/data/48-success-list-limit/result.json
@@ -0,0 +1,37 @@
+{
+  "status": "success",
+  "result": {
+    "claims": [
+      {
+        "id": 2,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "14 days",
+        "authority": "legal",
+        "rank": 40,
+        "source": "legal/policy.md",
+        "created_at": "<timestamp>"
+      },
+      {
+        "id": 1,
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "refund_window",
+        "assertion": "30 days",
+        "authority": "product",
+        "rank": 30,
+        "source": "dna/product/prd.md",
+        "created_at": "<timestamp>"
+      }
+    ],
+    "count": 2,
+    "resolved": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/49-error-get-id-required/params.json b/tests/mind/claims/data/49-error-get-id-required/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/49-error-get-id-required/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/49-error-get-id-required/result.json b/tests/mind/claims/data/49-error-get-id-required/result.json
new file mode 100644
index 0000000..22392d1
--- /dev/null
+++ b/tests/mind/claims/data/49-error-get-id-required/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "id": [
+      {
+        "code": "required",
+        "message": "id is required"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/claims/get",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/50-success-conflicts-edge-subject/params.json b/tests/mind/claims/data/50-success-conflicts-edge-subject/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/50-success-conflicts-edge-subject/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/50-success-conflicts-edge-subject/result.json b/tests/mind/claims/data/50-success-conflicts-edge-subject/result.json
new file mode 100644
index 0000000..a6c1ead
--- /dev/null
+++ b/tests/mind/claims/data/50-success-conflicts-edge-subject/result.json
@@ -0,0 +1,44 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "edge",
+        "subject_id": 1,
+        "predicate": "strength",
+        "claims": [
+          {
+            "id": 2,
+            "assertion": "soft",
+            "authority": "product",
+            "rank": 30,
+            "source": "prd.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 1,
+            "assertion": "hard",
+            "authority": "implementation",
+            "rank": 20,
+            "source": "src/a.ts",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 2,
+          "assertion": "soft",
+          "authority": "product",
+          "rank": 30
+        },
+        "unresolved": false
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/data/51-success-conflicts-orders-concept-before-edge/params.json b/tests/mind/claims/data/51-success-conflicts-orders-concept-before-edge/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/claims/data/51-success-conflicts-orders-concept-before-edge/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/claims/data/51-success-conflicts-orders-concept-before-edge/result.json b/tests/mind/claims/data/51-success-conflicts-orders-concept-before-edge/result.json
new file mode 100644
index 0000000..c8687bd
--- /dev/null
+++ b/tests/mind/claims/data/51-success-conflicts-orders-concept-before-edge/result.json
@@ -0,0 +1,74 @@
+{
+  "status": "success",
+  "result": {
+    "conflicts": [
+      {
+        "subject_type": "concept",
+        "subject_id": 1,
+        "predicate": "color",
+        "claims": [
+          {
+            "id": 4,
+            "assertion": "red",
+            "authority": "legal",
+            "rank": 40,
+            "source": "b.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 3,
+            "assertion": "blue",
+            "authority": "product",
+            "rank": 30,
+            "source": "a.md",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 4,
+          "assertion": "red",
+          "authority": "legal",
+          "rank": 40
+        },
+        "unresolved": false
+      },
+      {
+        "subject_type": "edge",
+        "subject_id": 1,
+        "predicate": "strength",
+        "claims": [
+          {
+            "id": 2,
+            "assertion": "soft",
+            "authority": "product",
+            "rank": 30,
+            "source": "prd.md",
+            "created_at": "<timestamp>"
+          },
+          {
+            "id": 1,
+            "assertion": "hard",
+            "authority": "implementation",
+            "rank": 20,
+            "source": "src/a.ts",
+            "created_at": "<timestamp>"
+          }
+        ],
+        "resolution": {
+          "id": 2,
+          "assertion": "soft",
+          "authority": "product",
+          "rank": 30
+        },
+        "unresolved": false
+      }
+    ],
+    "count": 2
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/claims/conflicts",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/claims/run b/tests/mind/claims/run
new file mode 100755
index 0000000..50084ce
--- /dev/null
+++ b/tests/mind/claims/run
@@ -0,0 +1,424 @@
+#!/usr/bin/env bash
+#
+# Test runner for /mind/claims/*
+#
+set -e
+
+BRANE_ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$BRANE_ROOT/tests/lib.sh"
+
+INPUT=$(cat)
+workspace
+
+# Same shape as tests/mind/prune/run: provenance/create validates the file
+# against body.db, so the row has to exist first and be deleted afterwards.
+create_stale_provenance() {
+  local concept_id="$1" file_url="$2"
+  add_body_file "$file_url" "fakehash" 100 1000
+  create_provenance "{\"concept_id\": $concept_id, \"file_url\": \"$file_url\"}"
+  sqlite3 .brane/body.db "DELETE FROM files WHERE url = '$file_url';"
+}
+
+create_claim() {
+  echo "$1" | brane /mind/claims/create > /dev/null 2>&1
+}
+
+create_authority() {
+  echo "$1" | brane /mind/authorities/create > /dev/null 2>&1
+}
+
+# The refund scenario from the vision doc: product=30d, legal=14d, impl=45d
+seed_refund() {
+  create_concept '{"name": "RefundWindow", "type": "Entity"}'
+  create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"dna/product/prd.md"}'
+  create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"legal/policy.md"}'
+  create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"45 days","authority":"implementation","source":"src/billing.ts"}'
+}
+
+case "$TC_CASE_NAME" in
+  00-success-create)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  01-success-create-edge-subject)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  02-error-not-initialized)
+    init_body
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  03-error-subject-not-found)
+    init_mind
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  04-error-authority-not-registered)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  05-error-assertion-required)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  06-error-source-required)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  07-error-invalid-subject-type)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  08-error-assertion-too-long)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  # Loose about vocabulary: a predicate nobody registered is still valid.
+  09-success-freeform-predicate)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  # FR-016b: trimmed at the boundary, stored trimmed.
+  10-success-trim-on-write)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  11-success-idempotent-reassert)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"dna/product/prd.md"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  # The whitespace variant must collapse onto the same claim, not create a second.
+  12-success-idempotent-whitespace-variant)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"dna/product/prd.md"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  13-success-get)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/get
+    ;;
+
+  14-error-get-not-found)
+    init_mind
+    echo "$INPUT" | brane /mind/claims/get
+    ;;
+
+  # Contradiction held: three claims, none overwritten.
+  15-success-list-all)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  16-success-list-filter-predicate)
+    init_mind
+    seed_refund
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"owner","assertion":"billing-team","authority":"product","source":"dna/product/prd.md"}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  17-success-list-filter-authority)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  18-success-list-empty)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  19-success-list-resolve)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  # SC-002: resolution is a projection. Asking for it must not delete the losers.
+  20-success-list-unchanged-after-resolve)
+    init_mind
+    seed_refund
+    echo '{"subject_id":1,"resolve":true}' | brane /mind/claims/list > /dev/null 2>&1
+    echo '{"subject_id":1,"resolve":true}' | brane /mind/claims/list > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  21-success-conflicts)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  # Same assertion from two authorities is agreement, not conflict.
+  22-success-conflicts-agreement-is-not-conflict)
+    init_mind
+    create_concept '{"name": "Palette", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"product","source":"a.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"legal","source":"b.md"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  # Equal top rank, different assertions: brane does not pick a winner.
+  23-success-conflicts-tie-unresolved)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_authority '{"name":"legal_eu","rank":40,"description":"EU legal constraint"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"legal/us.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"legal_eu","source":"legal/eu.md"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  24-success-conflicts-empty)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  25-success-delete)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/delete
+    ;;
+
+  26-error-delete-not-found)
+    init_mind
+    echo "$INPUT" | brane /mind/claims/delete
+    ;;
+
+  # Deleting one of three leaves a two-claim group.
+  27-success-delete-recomputes-conflicts)
+    init_mind
+    seed_refund
+    echo '{"id":3}' | brane /mind/claims/delete > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  28-success-cascade-concept-delete)
+    init_mind
+    seed_refund
+    echo '{"id":1}' | brane /mind/concepts/delete > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  # research D8 trap 1: concept deletion cascades edges, so it must cascade
+  # the claims on those edges too, or they dangle.
+  29-success-cascade-concept-delete-takes-edge-claims)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"hard","authority":"implementation","source":"src/a.ts"}'
+    echo '{"id":1}' | brane /mind/concepts/delete > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  30-success-cascade-edge-delete)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"hard","authority":"implementation","source":"src/a.ts"}'
+    echo '{"id":1}' | brane /mind/edges/delete > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  # research D8 trap 2: prune deletes concepts directly, bypassing the handler.
+  31-success-cascade-prune)
+    init_mind
+    create_concept '{"name": "Orphan", "type": "Entity"}'
+    # prune only removes concepts whose provenance is ALL stale - a concept with
+    # no provenance at all is never an orphan, so it needs a dead file link.
+    create_stale_provenance 1 "file:///project/gone.ts"
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"note","assertion":"unreferenced","authority":"observation","source":"session"}'
+    echo '{}' | brane /mind/prune > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+  # spec 4.2: resolve must not break a top-rank tie.
+  32-success-list-resolve-tie)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_authority '{"name":"legal_eu","rank":40,"description":"EU legal constraint"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"legal/us.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"legal_eu","source":"legal/eu.md"}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  # resolve is per subject+predicate, not a global max.
+  33-success-list-resolve-multiple-groups)
+    init_mind
+    seed_refund
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"owner","assertion":"billing-team","authority":"product","source":"dna/product/prd.md"}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  # spec 2.3: agreement from two authorities is two claims, not one.
+  34-success-list-agreement-retained)
+    init_mind
+    create_concept '{"name": "Palette", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"product","source":"a.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"legal","source":"b.md"}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  # D4: source is part of the identity tuple. Same assertion, new source = new claim.
+  35-success-create-different-source-is-new-claim)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"dna/product/prd.md"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  36-success-conflicts-filter-subject)
+    init_mind
+    seed_refund
+    create_concept '{"name": "Palette", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":2,"predicate":"color","assertion":"blue","authority":"product","source":"a.md"}'
+    create_claim '{"subject_type":"concept","subject_id":2,"predicate":"color","assertion":"red","authority":"legal","source":"b.md"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  # Two groups: ordering is subject_type asc, subject_id asc, predicate asc.
+  37-success-conflicts-two-groups)
+    init_mind
+    seed_refund
+    create_concept '{"name": "Palette", "type": "Entity"}'
+    create_claim '{"subject_type":"concept","subject_id":2,"predicate":"color","assertion":"blue","authority":"product","source":"a.md"}'
+    create_claim '{"subject_type":"concept","subject_id":2,"predicate":"color","assertion":"red","authority":"legal","source":"b.md"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  38-error-predicate-required)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  39-error-authority-required)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  40-error-subject-type-required)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  41-error-subject-id-required)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  # FR-016b: trim runs BEFORE the empty check.
+  42-error-assertion-blank-after-trim)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  # Subject validation must dispatch on subject_type, not always hit concepts.
+  43-error-edge-subject-not-found)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  # D8 trap 1, pinned as a number: 2 concept claims + 1 claim on the cascaded edge.
+  44-success-concept-delete-reports-claims-removed)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"prd.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"policy.md"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"hard","authority":"implementation","source":"src/a.ts"}'
+    echo "$INPUT" | brane /mind/concepts/delete
+    ;;
+
+  45-success-list-filter-subject-type)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"note","assertion":"on the concept","authority":"observation","source":"session"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"note","assertion":"on the edge","authority":"observation","source":"session"}'
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  46-error-predicate-too-long)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  47-error-source-too-long)
+    init_mind
+    create_concept '{"name": "RefundWindow", "type": "Entity"}'
+    echo "$INPUT" | brane /mind/claims/create
+    ;;
+
+  48-success-list-limit)
+    init_mind
+    seed_refund
+    echo "$INPUT" | brane /mind/claims/list
+    ;;
+
+  49-error-get-id-required)
+    init_mind
+    echo "$INPUT" | brane /mind/claims/get
+    ;;
+
+  # Conflicts are representable on edges even though the builtin rule is concept-only.
+  50-success-conflicts-edge-subject)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"hard","authority":"implementation","source":"src/a.ts"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"soft","authority":"product","source":"prd.md"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+
+  # Group ordering across subject types: "concept" sorts before "edge".
+  51-success-conflicts-orders-concept-before-edge)
+    init_mind
+    create_concept '{"name": "A", "type": "Entity"}'
+    create_concept '{"name": "B", "type": "Entity"}'
+    create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"hard","authority":"implementation","source":"src/a.ts"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"soft","authority":"product","source":"prd.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"product","source":"a.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"red","authority":"legal","source":"b.md"}'
+    echo "$INPUT" | brane /mind/claims/conflicts
+    ;;
+esac
diff --git a/tests/mind/concepts/delete/data/00-success-delete/result.json b/tests/mind/concepts/delete/data/00-success-delete/result.json
index 49f9417..891ee85 100644
--- a/tests/mind/concepts/delete/data/00-success-delete/result.json
+++ b/tests/mind/concepts/delete/data/00-success-delete/result.json
@@ -5,7 +5,8 @@
     "cascade": {
       "edges_removed": "<number>",
       "annotations_removed": "<number>",
-      "provenance_removed": "<number>"
+      "provenance_removed": "<number>",
+      "claims_removed": "<number>"
     }
   },
   "errors": null,
diff --git a/tests/mind/edges/delete/data/00-success-delete/result.json b/tests/mind/edges/delete/data/00-success-delete/result.json
index a04d00e..192f85a 100644
--- a/tests/mind/edges/delete/data/00-success-delete/result.json
+++ b/tests/mind/edges/delete/data/00-success-delete/result.json
@@ -1,7 +1,8 @@
 {
   "status": "success",
   "result": {
-    "deleted": true
+    "deleted": true,
+    "claims_removed": 0
   },
   "errors": null,
   "meta": {
diff --git a/tests/mind/init/data/00-success-new-init/result.json b/tests/mind/init/data/00-success-new-init/result.json
index ca82f57..8c94e0c 100644
--- a/tests/mind/init/data/00-success-new-init/result.json
+++ b/tests/mind/init/data/00-success-new-init/result.json
@@ -3,7 +3,7 @@
   "result": {
     "path": "<string>",
     "created": true,
-    "schema_version": "1.12.0"
+    "schema_version": "1.13.0"
   },
   "errors": null,
   "meta": {
diff --git a/tests/mind/init/data/01-success-idempotent/result.json b/tests/mind/init/data/01-success-idempotent/result.json
index 02eb9c3..9fe16f5 100644
--- a/tests/mind/init/data/01-success-idempotent/result.json
+++ b/tests/mind/init/data/01-success-idempotent/result.json
@@ -3,7 +3,7 @@
   "result": {
     "path": "<string>",
     "created": false,
-    "schema_version": "1.12.0"
+    "schema_version": "1.13.0"
   },
   "errors": null,
   "meta": {
diff --git a/tests/mind/init/data/02-success-force-reinit/result.json b/tests/mind/init/data/02-success-force-reinit/result.json
index ca82f57..8c94e0c 100644
--- a/tests/mind/init/data/02-success-force-reinit/result.json
+++ b/tests/mind/init/data/02-success-force-reinit/result.json
@@ -3,7 +3,7 @@
   "result": {
     "path": "<string>",
     "created": true,
-    "schema_version": "1.12.0"
+    "schema_version": "1.13.0"
   },
   "errors": null,
   "meta": {
diff --git a/tests/mind/migration/data/00-success-migrate-seeds-authorities/params.json b/tests/mind/migration/data/00-success-migrate-seeds-authorities/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/migration/data/00-success-migrate-seeds-authorities/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/migration/data/00-success-migrate-seeds-authorities/result.json b/tests/mind/migration/data/00-success-migrate-seeds-authorities/result.json
new file mode 100644
index 0000000..bc1fd1d
--- /dev/null
+++ b/tests/mind/migration/data/00-success-migrate-seeds-authorities/result.json
@@ -0,0 +1,39 @@
+{
+  "status": "success",
+  "result": {
+    "authorities": [
+      {
+        "name": "manual",
+        "rank": 100,
+        "description": "Direct human assertion; highest standing"
+      },
+      {
+        "name": "legal",
+        "rank": 40,
+        "description": "Legal or regulatory constraint"
+      },
+      {
+        "name": "product",
+        "rank": 30,
+        "description": "Product intent"
+      },
+      {
+        "name": "implementation",
+        "rank": 20,
+        "description": "What the code actually does"
+      },
+      {
+        "name": "observation",
+        "rank": 10,
+        "description": "Recorded from experience; non-binding by default"
+      }
+    ],
+    "count": 5
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/authorities/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/01-success-migrate-preserves-concepts/params.json b/tests/mind/migration/data/01-success-migrate-preserves-concepts/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/migration/data/01-success-migrate-preserves-concepts/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/migration/data/01-success-migrate-preserves-concepts/result.json b/tests/mind/migration/data/01-success-migrate-preserves-concepts/result.json
new file mode 100644
index 0000000..4d74ba1
--- /dev/null
+++ b/tests/mind/migration/data/01-success-migrate-preserves-concepts/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "concepts": "<array:2>",
+    "total": 2
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/concepts/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/02-success-migrate-stamps-version/params.json b/tests/mind/migration/data/02-success-migrate-stamps-version/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/migration/data/02-success-migrate-stamps-version/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/migration/data/02-success-migrate-stamps-version/result.json b/tests/mind/migration/data/02-success-migrate-stamps-version/result.json
new file mode 100644
index 0000000..9fe16f5
--- /dev/null
+++ b/tests/mind/migration/data/02-success-migrate-stamps-version/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "path": "<string>",
+    "created": false,
+    "schema_version": "1.13.0"
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/init",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/03-success-migrate-adds-builtin-rule/params.json b/tests/mind/migration/data/03-success-migrate-adds-builtin-rule/params.json
new file mode 100644
index 0000000..b79055c
--- /dev/null
+++ b/tests/mind/migration/data/03-success-migrate-adds-builtin-rule/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "contradictions"
+}
diff --git a/tests/mind/migration/data/03-success-migrate-adds-builtin-rule/result.json b/tests/mind/migration/data/03-success-migrate-adds-builtin-rule/result.json
new file mode 100644
index 0000000..1843de8
--- /dev/null
+++ b/tests/mind/migration/data/03-success-migrate-adds-builtin-rule/result.json
@@ -0,0 +1,15 @@
+{
+  "status": "success",
+  "result": {
+    "name": "contradictions",
+    "description": "Detects concepts carrying competing claims (contradiction)",
+    "body": "contradictions[id, name] :=\n  *concepts[id, name, _, _, _],\n  *claims[c1, 'concept', id, pred, a1, _, _, _],\n  *claims[c2, 'concept', id, pred, a2, _, _, _],\n  c1 < c2,\n  a1 != a2",
+    "builtin": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/get",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/04-success-migrate-preserves-custom-rule/params.json b/tests/mind/migration/data/04-success-migrate-preserves-custom-rule/params.json
new file mode 100644
index 0000000..7705962
--- /dev/null
+++ b/tests/mind/migration/data/04-success-migrate-preserves-custom-rule/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "custom_rule"
+}
diff --git a/tests/mind/migration/data/04-success-migrate-preserves-custom-rule/result.json b/tests/mind/migration/data/04-success-migrate-preserves-custom-rule/result.json
new file mode 100644
index 0000000..ab01d35
--- /dev/null
+++ b/tests/mind/migration/data/04-success-migrate-preserves-custom-rule/result.json
@@ -0,0 +1,15 @@
+{
+  "status": "success",
+  "result": {
+    "name": "custom_rule",
+    "description": "Keep me",
+    "body": "custom_rule[id, name] := *concepts[id, name, _, _, _]",
+    "builtin": false
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/get",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/05-success-migrate-preserves-annotations/params.json b/tests/mind/migration/data/05-success-migrate-preserves-annotations/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/migration/data/05-success-migrate-preserves-annotations/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/migration/data/05-success-migrate-preserves-annotations/result.json b/tests/mind/migration/data/05-success-migrate-preserves-annotations/result.json
new file mode 100644
index 0000000..c06208c
--- /dev/null
+++ b/tests/mind/migration/data/05-success-migrate-preserves-annotations/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "annotations": "<array:1>",
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/annotations/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/06-success-migrate-preserves-episodes/params.json b/tests/mind/migration/data/06-success-migrate-preserves-episodes/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/migration/data/06-success-migrate-preserves-episodes/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/migration/data/06-success-migrate-preserves-episodes/result.json b/tests/mind/migration/data/06-success-migrate-preserves-episodes/result.json
new file mode 100644
index 0000000..7e5c667
--- /dev/null
+++ b/tests/mind/migration/data/06-success-migrate-preserves-episodes/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "episodes": "<array:1>",
+    "total": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/episodes/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/data/07-success-migrate-preserves-edges/params.json b/tests/mind/migration/data/07-success-migrate-preserves-edges/params.json
new file mode 100644
index 0000000..0967ef4
--- /dev/null
+++ b/tests/mind/migration/data/07-success-migrate-preserves-edges/params.json
@@ -0,0 +1 @@
+{}
diff --git a/tests/mind/migration/data/07-success-migrate-preserves-edges/result.json b/tests/mind/migration/data/07-success-migrate-preserves-edges/result.json
new file mode 100644
index 0000000..70b2de5
--- /dev/null
+++ b/tests/mind/migration/data/07-success-migrate-preserves-edges/result.json
@@ -0,0 +1,13 @@
+{
+  "status": "success",
+  "result": {
+    "edges": "<array:1>",
+    "total": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/edges/list",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/migration/downgrade.ts b/tests/mind/migration/downgrade.ts
new file mode 100644
index 0000000..4d859a9
--- /dev/null
+++ b/tests/mind/migration/downgrade.ts
@@ -0,0 +1,42 @@
+//
+// downgrade.ts - test helper: walk a v1.13.0 mind.db back to v1.12.0
+//
+// A RocksDB directory cannot sensibly be checked in as a fixture, and the
+// binary always initializes at the latest version. So the migration test
+// builds a current db, downgrades it in place, then reopens it through a
+// handler - open_mind() is what runs migrate(), not /mind/init.
+//
+// Usage: bun run downgrade.ts <path-to-mind.db>
+//
+
+import { CozoDb } from "../../../src/lib/cozo"
+
+const db_path = process.argv[2] ?? ".brane/mind.db"
+const db = new CozoDb("rocksdb", db_path)
+
+// Drop the v1.13.0 relations
+for (const rel of ["claims", "authorities"]) {
+  try {
+    await db.run(`::remove ${rel}`)
+  } catch {
+    // already absent
+  }
+}
+
+// Drop the contradictions built-in rule row
+try {
+  await db.run(`
+    ?[name, description, body, builtin] := *rules[name, description, body, builtin], name = 'contradictions'
+    :rm rules { name, description, body, builtin }
+  `)
+} catch {
+  // already absent
+}
+
+// Stamp the version back
+await db.run(`
+  ?[key, value] <- [['version', '1.12.0']]
+  :put schema_meta { key => value }
+`)
+
+db.close()
diff --git a/tests/mind/migration/run b/tests/mind/migration/run
new file mode 100755
index 0000000..8f28c26
--- /dev/null
+++ b/tests/mind/migration/run
@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+#
+# Test runner for the v1.12.0 -> v1.13.0 schema migration (claims + authorities)
+#
+set -e
+
+BRANE_ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
+source "$BRANE_ROOT/tests/lib.sh"
+
+INPUT=$(cat)
+workspace
+
+# Build a populated current-version db, then walk it back to v1.12.0 so the
+# next open_mind() has a real migration to perform.
+seed_and_downgrade() {
+  init_mind
+  create_concept '{"name": "Survivor", "type": "Entity"}'
+  create_concept '{"name": "AlsoSurvivor", "type": "Entity"}'
+  create_edge '{"source": 1, "target": 2, "relation": "DEPENDS_ON"}'
+  echo '{"target": 1, "text": "keep me", "type": "note"}' | brane /mind/annotations/create > /dev/null 2>&1
+  echo '{"name": "custom_rule", "description": "Keep me", "body": "custom_rule[id, name] := *concepts[id, name, _, _, _]"}' | brane /mind/rules/create > /dev/null 2>&1
+  echo '{"agent_id": "test", "observation": "keep me too"}' | brane /mind/episodes/create > /dev/null 2>&1
+  bun run "$BRANE_ROOT/tests/mind/migration/downgrade.ts" "$PWD/.brane/mind.db" > /dev/null 2>&1
+}
+
+case "$TC_CASE_NAME" in
+  # Migration seeds the default authority tiers.
+  00-success-migrate-seeds-authorities)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/authorities/list
+    ;;
+
+  # SC-006: nothing that existed before the migration is lost.
+  01-success-migrate-preserves-concepts)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/concepts/list
+    ;;
+
+  # The migrated db reports the new version.
+  02-success-migrate-stamps-version)
+    seed_and_downgrade
+    echo '{}' | brane /mind/authorities/list > /dev/null 2>&1
+    echo "$INPUT" | brane /mind/init
+    ;;
+
+  # The contradictions built-in arrives with the migration, not just with init.
+  03-success-migrate-adds-builtin-rule)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/rules/get
+    ;;
+
+  # SC-006, one relation per case: the seed creates all of these before the
+  # downgrade, so each must still be there after the migration runs.
+  04-success-migrate-preserves-custom-rule)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/rules/get
+    ;;
+
+  05-success-migrate-preserves-annotations)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/annotations/list
+    ;;
+
+  06-success-migrate-preserves-episodes)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/episodes/list
+    ;;
+
+  07-success-migrate-preserves-edges)
+    seed_and_downgrade
+    echo "$INPUT" | brane /mind/edges/list
+    ;;
+esac
diff --git a/tests/mind/rules/create/data/08-error-overwrite-contradictions/params.json b/tests/mind/rules/create/data/08-error-overwrite-contradictions/params.json
new file mode 100644
index 0000000..00d3b29
--- /dev/null
+++ b/tests/mind/rules/create/data/08-error-overwrite-contradictions/params.json
@@ -0,0 +1,5 @@
+{
+  "name": "contradictions",
+  "description": "hijack",
+  "body": "contradictions[id, name] := *concepts[id, name, _, _, _]"
+}
diff --git a/tests/mind/rules/create/data/08-error-overwrite-contradictions/result.json b/tests/mind/rules/create/data/08-error-overwrite-contradictions/result.json
new file mode 100644
index 0000000..d3ce98e
--- /dev/null
+++ b/tests/mind/rules/create/data/08-error-overwrite-contradictions/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "name": [
+      {
+        "code": "protected",
+        "message": "cannot overwrite built-in rule"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/rules/create",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/create/run b/tests/mind/rules/create/run
index d696e87..3d2e132 100755
--- a/tests/mind/rules/create/run
+++ b/tests/mind/rules/create/run
@@ -38,6 +38,9 @@ case "$TC_CASE_NAME" in
     # Initialize body but not mind
     init_body
     ;;
+  08-error-overwrite-contradictions)
+    init_mind
+    ;;
 esac
 
 echo "$INPUT" | brane /mind/rules/create
diff --git a/tests/mind/rules/delete/data/05-error-contradictions-protected/params.json b/tests/mind/rules/delete/data/05-error-contradictions-protected/params.json
new file mode 100644
index 0000000..b79055c
--- /dev/null
+++ b/tests/mind/rules/delete/data/05-error-contradictions-protected/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "contradictions"
+}
diff --git a/tests/mind/rules/delete/data/05-error-contradictions-protected/result.json b/tests/mind/rules/delete/data/05-error-contradictions-protected/result.json
new file mode 100644
index 0000000..c2987a4
--- /dev/null
+++ b/tests/mind/rules/delete/data/05-error-contradictions-protected/result.json
@@ -0,0 +1,17 @@
+{
+  "status": "error",
+  "result": null,
+  "errors": {
+    "name": [
+      {
+        "code": "protected",
+        "message": "cannot delete built-in rule"
+      }
+    ]
+  },
+  "meta": {
+    "path": "/mind/rules/delete",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/delete/run b/tests/mind/rules/delete/run
index bc2c8fb..6a8cde6 100755
--- a/tests/mind/rules/delete/run
+++ b/tests/mind/rules/delete/run
@@ -29,6 +29,10 @@ case "$TC_CASE_NAME" in
     # Initialize body but not mind
     init_body
     ;;
+  # The new builtin must be registered in BUILTIN_RULE_NAMES, not just seeded.
+  05-error-contradictions-protected)
+    init_mind
+    ;;
 esac
 
 echo "$INPUT" | brane /mind/rules/delete
diff --git a/tests/mind/rules/get/data/05-success-get-contradictions/params.json b/tests/mind/rules/get/data/05-success-get-contradictions/params.json
new file mode 100644
index 0000000..b79055c
--- /dev/null
+++ b/tests/mind/rules/get/data/05-success-get-contradictions/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "contradictions"
+}
diff --git a/tests/mind/rules/get/data/05-success-get-contradictions/result.json b/tests/mind/rules/get/data/05-success-get-contradictions/result.json
new file mode 100644
index 0000000..1843de8
--- /dev/null
+++ b/tests/mind/rules/get/data/05-success-get-contradictions/result.json
@@ -0,0 +1,15 @@
+{
+  "status": "success",
+  "result": {
+    "name": "contradictions",
+    "description": "Detects concepts carrying competing claims (contradiction)",
+    "body": "contradictions[id, name] :=\n  *concepts[id, name, _, _, _],\n  *claims[c1, 'concept', id, pred, a1, _, _, _],\n  *claims[c2, 'concept', id, pred, a2, _, _, _],\n  c1 < c2,\n  a1 != a2",
+    "builtin": true
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/get",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/get/run b/tests/mind/rules/get/run
index e00b81b..b07fa26 100755
--- a/tests/mind/rules/get/run
+++ b/tests/mind/rules/get/run
@@ -29,6 +29,11 @@ case "$TC_CASE_NAME" in
     # Initialize body but not mind
     init_body
     ;;
+  # D9: a fresh v1.13.0 db and a migrated one must be indistinguishable. The
+  # migration suite pins this same body; init.ts and migrate.ts must not drift.
+  05-success-get-contradictions)
+    init_mind
+    ;;
 esac
 
 echo "$INPUT" | brane /mind/rules/get
diff --git a/tests/mind/rules/list/data/00-success-list-all/result.json b/tests/mind/rules/list/data/00-success-list-all/result.json
index 13f7caf..efc1781 100644
--- a/tests/mind/rules/list/data/00-success-list-all/result.json
+++ b/tests/mind/rules/list/data/00-success-list-all/result.json
@@ -2,6 +2,11 @@
   "status": "success",
   "result": {
     "rules": [
+      {
+        "name": "contradictions",
+        "description": "Detects concepts carrying competing claims (contradiction)",
+        "builtin": true
+      },
       {
         "name": "cycles",
         "description": "Detects circular dependencies via DEPENDS_ON edges",
@@ -18,7 +23,7 @@
         "builtin": false
       }
     ],
-    "count": 3
+    "count": 4
   },
   "errors": null,
   "meta": {
diff --git a/tests/mind/rules/list/data/01-success-list-empty-custom/result.json b/tests/mind/rules/list/data/01-success-list-empty-custom/result.json
index 8817dd7..b8c762c 100644
--- a/tests/mind/rules/list/data/01-success-list-empty-custom/result.json
+++ b/tests/mind/rules/list/data/01-success-list-empty-custom/result.json
@@ -2,6 +2,11 @@
   "status": "success",
   "result": {
     "rules": [
+      {
+        "name": "contradictions",
+        "description": "Detects concepts carrying competing claims (contradiction)",
+        "builtin": true
+      },
       {
         "name": "cycles",
         "description": "Detects circular dependencies via DEPENDS_ON edges",
@@ -13,7 +18,7 @@
         "builtin": true
       }
     ],
-    "count": 2
+    "count": 3
   },
   "errors": null,
   "meta": {
diff --git a/tests/mind/rules/query/data/10-success-contradictions-found/params.json b/tests/mind/rules/query/data/10-success-contradictions-found/params.json
new file mode 100644
index 0000000..b79055c
--- /dev/null
+++ b/tests/mind/rules/query/data/10-success-contradictions-found/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "contradictions"
+}
diff --git a/tests/mind/rules/query/data/10-success-contradictions-found/result.json b/tests/mind/rules/query/data/10-success-contradictions-found/result.json
new file mode 100644
index 0000000..110c654
--- /dev/null
+++ b/tests/mind/rules/query/data/10-success-contradictions-found/result.json
@@ -0,0 +1,19 @@
+{
+  "status": "success",
+  "result": {
+    "rule": "contradictions",
+    "matches": [
+      {
+        "id": 1,
+        "name": "RefundWindow"
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/query",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/query/data/11-success-contradictions-none/params.json b/tests/mind/rules/query/data/11-success-contradictions-none/params.json
new file mode 100644
index 0000000..b79055c
--- /dev/null
+++ b/tests/mind/rules/query/data/11-success-contradictions-none/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "contradictions"
+}
diff --git a/tests/mind/rules/query/data/11-success-contradictions-none/result.json b/tests/mind/rules/query/data/11-success-contradictions-none/result.json
new file mode 100644
index 0000000..345bfaa
--- /dev/null
+++ b/tests/mind/rules/query/data/11-success-contradictions-none/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "rule": "contradictions",
+    "matches": [],
+    "count": 0
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/query",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/query/data/12-success-custom-rule-joins-claims/params.json b/tests/mind/rules/query/data/12-success-custom-rule-joins-claims/params.json
new file mode 100644
index 0000000..eb6d414
--- /dev/null
+++ b/tests/mind/rules/query/data/12-success-custom-rule-joins-claims/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "high_authority"
+}
diff --git a/tests/mind/rules/query/data/12-success-custom-rule-joins-claims/result.json b/tests/mind/rules/query/data/12-success-custom-rule-joins-claims/result.json
new file mode 100644
index 0000000..5e9c1ec
--- /dev/null
+++ b/tests/mind/rules/query/data/12-success-custom-rule-joins-claims/result.json
@@ -0,0 +1,19 @@
+{
+  "status": "success",
+  "result": {
+    "rule": "high_authority",
+    "matches": [
+      {
+        "id": 1,
+        "name": "RefundWindow"
+      }
+    ],
+    "count": 1
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/query",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/query/data/13-success-contradictions-ignores-edge-claims/params.json b/tests/mind/rules/query/data/13-success-contradictions-ignores-edge-claims/params.json
new file mode 100644
index 0000000..b79055c
--- /dev/null
+++ b/tests/mind/rules/query/data/13-success-contradictions-ignores-edge-claims/params.json
@@ -0,0 +1,3 @@
+{
+  "name": "contradictions"
+}
diff --git a/tests/mind/rules/query/data/13-success-contradictions-ignores-edge-claims/result.json b/tests/mind/rules/query/data/13-success-contradictions-ignores-edge-claims/result.json
new file mode 100644
index 0000000..345bfaa
--- /dev/null
+++ b/tests/mind/rules/query/data/13-success-contradictions-ignores-edge-claims/result.json
@@ -0,0 +1,14 @@
+{
+  "status": "success",
+  "result": {
+    "rule": "contradictions",
+    "matches": [],
+    "count": 0
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/rules/query",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/rules/query/run b/tests/mind/rules/query/run
index 7775090..a24c693 100755
--- a/tests/mind/rules/query/run
+++ b/tests/mind/rules/query/run
@@ -10,6 +10,10 @@ source "$BRANE_ROOT/tests/lib.sh"
 INPUT=$(cat)
 workspace
 
+create_claim() {
+  echo "$1" | brane /mind/claims/create > /dev/null 2>&1
+}
+
 case "$TC_CASE_NAME" in
   00-success-cycles-found)
     init_mind
@@ -66,6 +70,38 @@ case "$TC_CASE_NAME" in
     create_concepts '[{"name": "SelfOnly", "type": "Entity"}, {"name": "RealOrphan", "type": "Entity"}]'
     create_edges '[{"source": 1, "target": 1, "relation": "DEPENDS_ON"}]'
     ;;
+  # Built-in contradictions rule: concept 1 carries competing refund claims.
+  10-success-contradictions-found)
+    init_mind
+    create_concepts '[{"name": "RefundWindow", "type": "Entity"}, {"name": "Quiet", "type": "Entity"}]'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"prd.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"policy.md"}'
+    ;;
+  # Two authorities asserting the same thing is agreement, not contradiction.
+  11-success-contradictions-none)
+    init_mind
+    create_concepts '[{"name": "Palette", "type": "Entity"}]'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"product","source":"a.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"color","assertion":"blue","authority":"legal","source":"b.md"}'
+    ;;
+  # User-defined rules can join claims and authority rank.
+  12-success-custom-rule-joins-claims)
+    init_mind
+    create_concepts '[{"name": "RefundWindow", "type": "Entity"}, {"name": "Casual", "type": "Entity"}]'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"policy.md"}'
+    create_claim '{"subject_type":"concept","subject_id":2,"predicate":"note","assertion":"whatever","authority":"observation","source":"session"}'
+    echo '{"name": "high_authority", "description": "Concepts carrying a claim at rank 40 or above", "body": "high_authority[id, name] := *concepts[id, name, _, _, _], *claims[_, '"'"'concept'"'"', id, _, _, auth, _, _], *authorities[auth, rank, _], rank >= 40"}' | brane /mind/rules/create > /dev/null 2>&1
+    ;;
+  # D7 scope: the builtin is concept-only. Edge contradictions are real and
+  # visible through /mind/claims/conflicts, but must NOT surface here - an edge
+  # id would be indistinguishable from a concept id in the [id, name] contract.
+  13-success-contradictions-ignores-edge-claims)
+    init_mind
+    create_concepts '[{"name": "A", "type": "Entity"}, {"name": "B", "type": "Entity"}]'
+    create_edges '[{"source": 1, "target": 2, "relation": "DEPENDS_ON"}]'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"hard","authority":"implementation","source":"src/a.ts"}'
+    create_claim '{"subject_type":"edge","subject_id":1,"predicate":"strength","assertion":"soft","authority":"product","source":"prd.md"}'
+    ;;
 esac
 
 echo "$INPUT" | brane /mind/rules/query
diff --git a/tests/mind/verify/data/00-success-no-violations/result.json b/tests/mind/verify/data/00-success-no-violations/result.json
index f6c7099..1746599 100644
--- a/tests/mind/verify/data/00-success-no-violations/result.json
+++ b/tests/mind/verify/data/00-success-no-violations/result.json
@@ -3,11 +3,17 @@
   "result": {
     "passed": true,
     "summary": {
-      "rules_passed": 2,
+      "rules_passed": 3,
       "rules_failed": 0,
       "total_violations": 0
     },
     "rules": [
+      {
+        "name": "contradictions",
+        "passed": true,
+        "violations": [],
+        "error": null
+      },
       {
         "name": "cycles",
         "passed": true,
diff --git a/tests/mind/verify/data/01-success-with-violations/result.json b/tests/mind/verify/data/01-success-with-violations/result.json
index 7cffe20..3f1faa4 100644
--- a/tests/mind/verify/data/01-success-with-violations/result.json
+++ b/tests/mind/verify/data/01-success-with-violations/result.json
@@ -3,18 +3,33 @@
   "result": {
     "passed": false,
     "summary": {
-      "rules_passed": 0,
+      "rules_passed": 1,
       "rules_failed": 2,
       "total_violations": 4
     },
     "rules": [
+      {
+        "name": "contradictions",
+        "passed": true,
+        "violations": [],
+        "error": null
+      },
       {
         "name": "cycles",
         "passed": false,
         "violations": [
-          {"id": 1, "name": "A"},
-          {"id": 2, "name": "B"},
-          {"id": 3, "name": "C"}
+          {
+            "id": 1,
+            "name": "A"
+          },
+          {
+            "id": 2,
+            "name": "B"
+          },
+          {
+            "id": 3,
+            "name": "C"
+          }
         ],
         "error": null
       },
@@ -22,7 +37,10 @@
         "name": "orphans",
         "passed": false,
         "violations": [
-          {"id": 4, "name": "Orphan"}
+          {
+            "id": 4,
+            "name": "Orphan"
+          }
         ],
         "error": null
       }
diff --git a/tests/mind/verify/data/03-success-no-rules/result.json b/tests/mind/verify/data/03-success-no-rules/result.json
index f6c7099..1746599 100644
--- a/tests/mind/verify/data/03-success-no-rules/result.json
+++ b/tests/mind/verify/data/03-success-no-rules/result.json
@@ -3,11 +3,17 @@
   "result": {
     "passed": true,
     "summary": {
-      "rules_passed": 2,
+      "rules_passed": 3,
       "rules_failed": 0,
       "total_violations": 0
     },
     "rules": [
+      {
+        "name": "contradictions",
+        "passed": true,
+        "violations": [],
+        "error": null
+      },
       {
         "name": "cycles",
         "passed": true,
diff --git a/tests/mind/verify/data/06-success-rule-execution-error/result.json b/tests/mind/verify/data/06-success-rule-execution-error/result.json
index d3dc41f..5fbfaa2 100644
--- a/tests/mind/verify/data/06-success-rule-execution-error/result.json
+++ b/tests/mind/verify/data/06-success-rule-execution-error/result.json
@@ -3,7 +3,7 @@
   "result": {
     "passed": false,
     "summary": {
-      "rules_passed": 2,
+      "rules_passed": 3,
       "rules_failed": 1,
       "total_violations": 0
     },
@@ -14,6 +14,12 @@
         "violations": [],
         "error": "Cannot find requested stored relation 'nonexistent_relation'"
       },
+      {
+        "name": "contradictions",
+        "passed": true,
+        "violations": [],
+        "error": null
+      },
       {
         "name": "cycles",
         "passed": true,
diff --git a/tests/mind/verify/data/07-success-contradictions-fires-when-resolved/params.json b/tests/mind/verify/data/07-success-contradictions-fires-when-resolved/params.json
new file mode 100644
index 0000000..dae7146
--- /dev/null
+++ b/tests/mind/verify/data/07-success-contradictions-fires-when-resolved/params.json
@@ -0,0 +1,5 @@
+{
+  "rules": [
+    "contradictions"
+  ]
+}
diff --git a/tests/mind/verify/data/07-success-contradictions-fires-when-resolved/result.json b/tests/mind/verify/data/07-success-contradictions-fires-when-resolved/result.json
new file mode 100644
index 0000000..9a8cad8
--- /dev/null
+++ b/tests/mind/verify/data/07-success-contradictions-fires-when-resolved/result.json
@@ -0,0 +1,30 @@
+{
+  "status": "success",
+  "result": {
+    "passed": false,
+    "summary": {
+      "rules_passed": 0,
+      "rules_failed": 1,
+      "total_violations": 1
+    },
+    "rules": [
+      {
+        "name": "contradictions",
+        "passed": false,
+        "violations": [
+          {
+            "id": 1,
+            "name": "RefundWindow"
+          }
+        ],
+        "error": null
+      }
+    ]
+  },
+  "errors": null,
+  "meta": {
+    "path": "/mind/verify",
+    "timestamp": "<timestamp>",
+    "duration_ms": "<number>"
+  }
+}
diff --git a/tests/mind/verify/run b/tests/mind/verify/run
index 56c914a..d81af06 100755
--- a/tests/mind/verify/run
+++ b/tests/mind/verify/run
@@ -10,6 +10,10 @@ source "$BRANE_ROOT/tests/lib.sh"
 INPUT=$(cat)
 workspace
 
+create_claim() {
+  echo "$1" | brane /mind/claims/create > /dev/null 2>&1
+}
+
 case "$TC_CASE_NAME" in
   00-success-no-violations)
     init_mind
@@ -53,6 +57,14 @@ case "$TC_CASE_NAME" in
     # Create a custom rule with invalid body that will fail at execution
     echo '{"name": "bad_rule", "description": "Bad rule", "body": "bad_rule[id, name] := *nonexistent_relation[id, name]"}' | brane /mind/rules/create > /dev/null 2>&1
     ;;
+  # The rule fires even though legal outranks product: it reports that the
+  # graph disagrees with itself, not whether the disagreement has a winner.
+  07-success-contradictions-fires-when-resolved)
+    init_mind
+    create_concepts '[{"name": "RefundWindow", "type": "Entity"}]'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"30 days","authority":"product","source":"prd.md"}'
+    create_claim '{"subject_type":"concept","subject_id":1,"predicate":"refund_window","assertion":"14 days","authority":"legal","source":"policy.md"}'
+    ;;
 esac
 
 echo "$INPUT" | brane /mind/verify