{"path":"research/points-of-entry-review.md","content":"# Points of entry: every door into the graph, every home an act files in, and what crosses between the levels\n\n**Date**: 2026-11-07 · **Status**: a review read from the code, the table of stored properties and the web\napp, with proposals for the founder in ledger Arc BJ (`session26-open-rulings.md`), all open. Nothing\nhere is ruled, nothing was deployed, and no microtask was run against the live graph.\n\nHis words, 2026-11-07, which set the task: *\"Ok this stuff is important - we should review the whole\nAPI/data model/UI for different points of entry or what belongs in the graph vs what belongs in\nlanguage vs what belongs in code, etc, you know? and the relationships between these - such as that of\nthe meta-argumentation mentioned earlier, think about all aspects and levels of this\"*, and earlier the\nsame evening: *\"I'm also worried about if there's gonna be multiple points of addressability, multiple\nways into interacting with the graph so as to scrutinize everything at one point and avoid duplication\"*.\n\n**Read first, whole, before this was written**: `priors-as-standing-work.md` § 9c (one consideration,\none place, many uses), § 10c (one home per act, many doors) and § 10d (what goes into language and what\nis lifted out); `claim-or-system.md` (the four questions); `one-challenge-one-home.md` § 2 and § 3;\n`store-the-uses-read-the-meaning.md` (the storage law: use, judgment, reading); `what-belongs-in-the-\nontology.md` § 0 to § 6 (the sorting test); `claims-and-code-one-loop.md` (AJ4, his hold of 2026-08-30);\n`docs/graph-properties.md`; the READ FIRST block of `CLAUDE.md` on the four things that share words. The\ncorpus graph was asked (`scripts/corpus_graph.py search \"points of entry, addressability, what belongs in\nthe graph versus language versus code\"`); what it returned is woven in where it bears.\n\n---\n\n## 0. The answer first\n\n**One act, one home, many doors is the rule the corpus already holds (AL1, § 10c), and the code keeps it\nfor most acts.** Of the thirteen acts a person or a machine can perform on the graph, nine have one home\nhowever many doors lead to it. Four do not, and three of those are the same gap seen from three sides:\n**an objection to how far a reason bears has four doors and four homes** (the reason itself, the critical\nquestion's pole, the link's relevance claim, the concept layer), and nothing routes between them. The\nfourth is the oldest: **the decompose door files a person's reason as a part** (its heading on the page is\n*What's underneath?*), so a reason has two homes depending on which box the person typed into, and 28 of\nthe 39 parts people have attached are reasons (`checks-on-machines-and-people.md` § 11).\n\n**Of 119 stored properties, 23 are what a person disputes in language, 10 point at a graph object anyone\ncan attack, and 86 are code's: a record of what happened (46), a machine judgment kept as proposal (22),\nor a cache of something computable (18).** The caches are where BI1's class of problem lives: three\ncannot go stale (text never changes), four carry their own version and are safe, and **six can go stale\nwith nothing to say so**, two of them read by live surfaces today (§ 3).\n\n**Across the four levels, what crosses is mostly built and tested; what does not cross is the one hole\nhe named.** A ruling crosses into a microtask as a rendered prompt block (three microtasks, `grounding.py`); a\ncanon line crosses into how we work as a test (sixteen test files read the code for a reader that\nforgot); a microtask's version crosses back onto every reading it wrote (`versions.py`). What never crosses is\na microtask's rule into the object level as a claim: that is AJ4, the one published commitment of\n2026-08-22, and his hold of 2026-08-30. § 4 proposes, and does not decide, where a first meta hole would\nopen (BJ6).\n\n**Six duplications and stale caches with file and line** are in § 5. The ledger rows are in § 6.\n\n---\n\n## 1. The vocabulary, so one word does one job here\n\nFour things share words in this project (`CLAUDE.md` § READ FIRST): the claims and links in the **graph**,\nthe **microtasks** that write them (the glossary's word; the code keeps its `pass` names), the **decisions** in our docs (ledger, canon, this file), and\n**how we work** (sessions, hooks, tests). This note adds two words of its own and fixes them:\n\n- A **door** is a place where an act enters: a route in `deliberus/api.py`, a button or box in the web\n  app, a script run from the keeper's machine, or a microtask writing on its own.\n- A **home** is where the act is filed once it is in: a node, a link, or a property on one of them. His\n  aim (§ 10c): *\"a single source of truth/disagreement on each claim/question/rebuttal/case/exception/\n  consideration, and a single correct way to channel every type of interaction\"*. Read with AL1, that is:\n  the door may be anywhere people reach for it; the home is one.\n\n**One example whole**, since every abstraction below hangs on it. A person reads the claim *Värmdö municipality\nshould build a bridge to Strömma* and thinks the reason under it, *a bridge to Strömma pays for itself within ten years*,\ndoes not bear on the question. They have four doors today:\n\n| Door | What is stored | Home |\n|---|---|---|\n| *Add evidence*, polarity *attacks*, typed under the claim | a new claim, *that doesn't matter*, with an `ATTACKS` link to *Värmdö municipality should build a bridge to Strömma* | the claim: the attack weakens the conclusion, which the person did not dispute |\n| *Add evidence*, polarity *attacks*, typed under the reason | the same text with an `ATTACKS` link to *a bridge to Strömma pays for itself within ten years* | the reason: the attack weakens a fact the person granted |\n| answering the link's critical question *does this premise bear on the conclusion?* with *no* | a new claim with a `SUPPORTS` link to the question's negative pole claim | the pole claim, which lowers the link's examined strength |\n| `POST /claims/{id}/links/{source}/relevance` (no button in the web app leads here) | a relevance claim, *\"a bridge to Strömma pays for itself within ten years\" bears on \"Värmdö municipality should build a bridge to Strömma\"*, with an `ARGUES_RELEVANCE` link, and the person's text as an attack on it | the relevance claim, the home BB4 ruled for exactly this objection |\n\nOnly the last files where the ruling says. The other three are wrong by default for a twelve-year-old\nwho types where the box is, which is § 10c's case, and a routing step is designed there and unbuilt.\n\n---\n\n## 2. Acts by door and home\n\n**31 routes write, read with a model, or change a session in `deliberus/api.py`; twelve write to\nthe graph on a person's act.** Eight of those twelve refuse a whole kept as a record (`_refuse_if_record`,\n`api.py:1938`), a guard that sits on each door and not on the store (`graph/store.py` knows `:Record` only\nwhen deleting, line 77). 30 scripts under `scripts/` write to the live graph from the keeper's\nmachine with `--write`, `--apply` or `--undo`, through the same store functions and past none of the\nroute guards. The web app reaches eleven of the 31 routes; two write routes have no door in it.\n\n| Act | Doors | Home | One home? |\n|---|---|---|---|\n| **Give a reason for or against a claim** | `POST /claims/{id}/add-evidence` (`api.py:3271`), from the claim page's evidence box; the reasons-off microtask cutting *X because Y* (`reasons_off.py`, T9); extraction's cross-structure step; a hand map (`scripts/store_hand_extraction.py`) | a new claim with a `SUPPORTS` or `ATTACKS` link to the claim, provenance `human`, `split` or `extraction` | **yes**, and one more door below files it elsewhere |\n| **Give a reason, through the decompose box** | `POST /claims/{id}/decompose` (`api.py:2901`), the page's *What's underneath?* and *Deepen this claim* boxes (`claim/[id]/+page.svelte:326`, `:345`) | new claims with `DECOMPOSES_INTO` links from the claim (`api.py:3008`) | **no**: measured, 28 of the 39 parts people attached were reasons (`checks-on-machines-and-people.md` § 11); the T9 cut (reasons cut off a sentence and filed as support) runs only on machine cuts |\n| **Say that a reason does not bear** | the four doors of § 1 | four homes: the claim, the reason, the pole claim, the relevance claim | **no**: AL8 (open) and § 10c's routing step name the fix |\n| **Argue that a whole requires a part** | `POST /claims/{id}/parts/{part}/requirement` (`api.py:3078`); no door in the web app | a requirement claim, `ARGUES_REQUIREMENT` link, `requirement_claim` on the part link | yes; ⚠ since BD16 (part links carry no strength) the cap it governed is behind `PARTS_CARRY_STRENGTH = False`, so the home is live and its effect is off |\n| **Answer a critical question** | `POST /claims/{id}/answer-cq` (`api.py:3343`), the page's question list; the first answer mints the question from its template (`latent_questions.materialise`) | a new claim with a `SUPPORTS` link to the question's pole claim | yes |\n| **Fix which sense a contested term takes** | `POST /claims/{id}/clarify-concept` (`api.py:3724`), the claim page and the extraction page's checkpoint; `store.apply_preflight_clarifications` from the landing preflight | a definitional claim, a `DEFINES` link, `selected_sense` and `clarified_by` on the claim's `USES_CONCEPT` link | yes; ⚠ the same act can reach a link's relevance as a *this does not bear* (§ 1), the overlap AL8 names |\n| **Keep, reword or drop a machine-cut part** | `POST /claims/{id}/split-parts/{child}` (`api.py:2834`), the page's split panel | `human_action` on the part link; a reword mints a new part and marks the old `superseded_by` (AL10) | yes |\n| **Ask for a cut now** | `POST /claims/{id}/split-proposal` (`api.py:2781`), the page; `scripts/recut_splits.py`; the floor step on entry (`floor.py`, behind `DELIBERUS_FLOOR_FIRST`) | `split_proposal` on the claim, parts as claims with `DECOMPOSES_INTO`, provenance `split` | yes |\n| **Agree or disagree** | `POST /claims/{id}/vote` (`api.py:4789`), the page | an `AGREES_WITH` or `DISAGREES_WITH` link from the `User` node (`api.py:4823`) | yes as built; AS3 (ruled) makes a disagree a holder of the exact negation, unbuilt, so the home will move |\n| **Retire or move a link** | `POST /edges/supersede` (`api.py:2401`), the page's retarget button (a person); a restore, or a retirement that names no successor, the keeper only; a drop in the split panel; every machine re-reading under R12 | `superseded_by`, `superseded_at`, `superseded_reason` on the link | yes |\n| **Say a claim's validity lapsed** | `POST /claims/{id}/validity` (`api.py:2544`); the staleness sweep only proposes (`/graph/staleness/sweep`, `api.py:2472`) | `invalid_at`, `invalid_reason`, a verdict claim in `validity_verdict_claim` | yes |\n| **Open a weighing** | `POST /claims/{id}/weighing/open` (`api.py:5336`); the detector's invitation | `weighing_state` on the claim, eight questions and sixteen pole claims | yes |\n| **Judge a machine's output** | `POST /sittings/{s}`, `/part-reviews/{s}`, `/step-reviews/{s}` (`api.py:3964`, `4056`, `4281`), the three review pages | Postgres, a reviewer's answer per item; nothing in the graph | yes, and the right side of the line: a verdict on a microtask belongs to the microtask level, not the object level |\n| **File a claim under a reference class** | the membership microtask (`membership.py:253`, `file_member`); `scripts/seed_reference_classes.py`; no route and no page | an `IN_CLASS` link with `grounds` naming a membership claim (BC3), `generalization_version`, `membership_role`, `filed_at` (BI1) | yes; ⚠ a person has no door to dispute it but the generic ones (attack the membership claim through add-evidence) |\n| **Bring a source in** | `/extract/stream`, `/extract/start`, `/extract/pdf`, the two preflights, `/api/community/extract` (a blob's own process), `/transcribe` (text only) | a `Source` node, claims, links, `Question` and `Concept` nodes, by the one pipeline | yes |\n| **Set a horizon kind** | `POST /claims/{id}/terminus` answers 410 (`api.py:5298`): read, never set | none; the classifier (`/terminus/classify`) stores a proposal in `terminus_llm_*` | yes, by refusal |\n\nNot graph writes, listed so nobody looks for them: `/api/scope` (a session's read scope), `/api/admin/members`\n(blob membership, Postgres), `/api/client-error` (a log), `/claims/search` and `/query` (reads), `/claims/\ngenerate-titles` and `/embeddings/generate` (the keeper's housekeeping, which writes `short_title` and\n`embedding`, both caches).\n\n**Three doors the web app does not have.** The relevance route and the requirement route are reachable\nonly by API, and `claim-or-system.md` § 6 already recorded that nobody has used the first on the live site.\nThe `IN_CLASS` link has no page. So the home BB4 ruled for the commonest objection is the one home with no\ndoor, which is the inverse of his worry and has the same cost: the objection goes in through a door that\nleads elsewhere.\n\n---\n\n## 3. Stored properties by home\n\nThe 119 properties of `docs/graph-properties.md` (as of 2026-11-07), sorted by the three homes the task\nnames, with the third split by the storage law of `store-the-uses-read-the-meaning.md` § 2 (a use is kept,\na judgment is recorded once, a reading is computed and at most cached).\n\n| Home | Count | Properties |\n|---|---|---|\n| **A graph object anyone can attack** (the property is, or points at, a claim anyone can attack) | 10 | `text` · `relevance_claim` · `requirement_claim` · `grounds` (a membership claim, BC3) · `validity_verdict_claim` · `clarified_by` · `minted_from` · `cut_from` · `membership_member`, `membership_of` (one pair) · `premise_needed_by` |\n| **Text inside a claim or link that people dispute in language** (a sentence somebody or some microtask wrote, read by people and never computed on) | 23 | `author_wording` · `source_span` · `reasoning` · `explanation` · `hedge` · `short_title` (a reading, but read as words) · `scheme_note` · `step_note` · `human_action_note` · `relevance_reason` · `merge_reasoning` · `separability_reasoning` · `proposal_reason` · `staleness_reason` · `invalid_reason` · `superseded_reason` · `reread_note` · `replaced_reason` · `restored_reason` · `merge_mark_retired_reason` · `terminus_llm_reasoning` · `likeness` (JSON sentences) · `hunt_respect`, `hunt_difference` |\n| **Code's: a record of what happened** (who, which microtask, when; nobody can disagree) | 46 | `provenance` · `readings` · `written_at`, `written_by`, `written_version` · `written_kept_in`, `written_model`, `written_microtask`, `written_microtask_version` · `pass`, `microtask_version` · `made_at` · `recorded_at` · `by` · `decided_by` · `read_by` · `check_model`, `cut_model` · `title_model` · `relevance_at`, `relevance_model` · `relevance_copied_from` · `relevance_claim_at` · `requirement_claim_at` · `human_action`, `human_action_at`, `human_action_by` · `superseded_at`, `superseded_by`, `superseded_readings` · `restored_at`, `restored_from`, `restored_readings` · `replaced_at` · `matched_at`, `matched_version` · `earlier_readings`, `readings_before_match` · `merge_withdrawn_by`, `separability_withdrawn_by`, `analogy_withdrawn_by` · `merge_mark_retired_at` · `reread_at`, `reread_by`, `reread_outcome`, `reread_result` · `later_reading`, `later_said` · `kept_as_record_at`, `kept_as_record_by` · `filed_at`, `membership_role` · `analogy_judged_by`, `analogy_judged_at`, `analogy_words` · `hunt_at`, `hunt_sources` · `generator`, `via_concept` · `moved_from_part` · `reworded_from` · `attributed_to_before_recheck`, `attribution_rechecked_at` · `minted_by_source` · `premise_source_pair` · `valid_at_provenance` · `group_id` · `claim_id` · `_relay_id` |\n| **Code's: a machine judgment kept as a proposal** (a model's verdict, stored once, read as relevance or kind only by rules that say so) | 22 | `relevance_proposal`, `relevance_gate`, `relevance_direction`, `relevance_direction_conflict`, `relevance_confident` · `merge_candidate`, `merge_confident` · `separability_proposal`, `separability_confident` · `same_fact_opposite_use` · `scheme`, `schemes`, `scheme_confidence`, `scheme_cluster`, `scheme_status` · `terminus_llm_type`, `terminus_llm_confidence` · `staleness_flagged`, `staleness_flagged_at` · `split_proposal`, `split_proposal_before`, `split_recut_held`, `split_recut_held_resolved` · `membership_proposal` · `reasons_off_proposal` · `reported_speech_checked` · `support_semantics_proposal`, `proposal_agreement`, `proposal_confident` · `deterministic_kind_signal` · `coverage`, `match` · `likeness_mechanism`, `analogy_candidate`, `analogy_verdict` · `hunt_proposed`, `hunt_mechanism` · `stance_caution` · `strength` (the writer's rating; distinct from the computed strength, which is never stored) · `step_shape` |\n| **Code's: a cache of something computable** (recomputable from other stored things; the question is whether it says when it is stale) | 18 | see the table below |\n\n(The classified sort left out of the counts a few properties that are kind labels on a node rather than\nany of the three: `claim_kind`, `origin`, `role`, `type`, `epistemic_status`, `evidence_type`,\n`methodology_tier`, `maturity_stage`, `maturity_stage_before`, `retrieval_weight`, `trust_state`,\n`weighing_state`, `argument_label`, `cq_template_id`, `cq_params`, `piece`, `step_form`, `step_order`,\n`step_role`, `written_under*`, `hedge_reading`, `not_held_by`, `selected_sense`, `sense`, `auto_linked`,\n`within_source`, `support_interpretation`, and the study figures `sample_size`, `study_count`,\n`effect_size*`, `heterogeneity`, `confidence_interval_*`, the `rc_*`, `dist_*` and `thr_*` fields, `valid_at`,\n`invalid_at`. They are form: a setting the writer chose, which the sorting test of August says to keep\nsmall and give a *does not fit* value. `claim_kind` beside `origin` and `role` is one kind stored twice\nduring the migration BD6 ordered; 240 readers still read `claim_kind` and 5 read `origin`.)\n\n### The eighteen caches, and whether each can go stale\n\n| Cache | Computed from | Can it go stale? | Says so? |\n|---|---|---|---|\n| `confidence` | `epistemic_status` + `evidence_type` (`extraction/models.py:386`) | **yes**: `label_repair.py:21-44` rewrites both inputs and never the cache | **no**; read live by `truth_graph.py:606, 670, 708` and `feed.py:274` |\n| `prior`, `prior_source`, `prior_by` | the reference class's count and the membership claim's posterior (`reference_classes.prior_for`) | **yes**: rewritten when a membership is filed (`membership.py:268`) and when the membership claim gains evidence through add-evidence (`api.py:3327`); not when a bundle is filed under the reference class, when a vote or a question answer lands on the membership claim, or when a member elsewhere changes the count | **no**; the badge reads the stored value (`badge_inputs.py:327`), never `prior_for` |\n| `embedding` | the claim's text and the embedding model | **yes**, on a model change | **no**: no property names the model; `generalization_version` shows the shape that would (BI1) |\n| `similarity` | two embeddings | yes, with them | no |\n| `short_title` | the text, by a model or by code | yes, when the title microtask changes | partly: `title_model` names the model, no version |\n| `wording_key` | the text, folded | **no**: text is written once (AL10) | needs none |\n| `words_from_passage`, `words_from_source`, `words_added`, `words_added_in_brackets` | the text and the kept source | **no**, text and source are fixed | needs none |\n| `generalization_version` | the reference class's text, population, outcome, period | it *is* the staleness stamp | yes, by design (BI1) |\n| `scope`, `generalization_kind` | the text, by the scope microtask | yes, when the scope microtask's version changes | yes: `scope_reading` carries the version |\n| `relevance_claim` ↔ the `ARGUES_RELEVANCE` link's `source_id` | each other: the tie is stored at both ends | **yes**: three writers set both (`api.py:3237-3248`, `machine_sentences.py:299`, `reasons_off.py:608`); readers split, `badge_inputs.py:141` and `written_steps.py:109` reading the link, `hand_over_relevance` reading the property | **no** test asserts the two ends agree (`test_two_factor_strength.py:240` sets both by hand) |\n| `requirement_claim` ↔ `ARGUES_REQUIREMENT.parent_id` | each other (`api.py:3136-3143`) | the same shape | no |\n| `grounds` on `IN_CLASS` ↔ `membership_member`, `membership_of` | each other (`reference_classes.py:211, 304`) | the same shape; `membership_standing` reads the link end only (`:321`) | no |\n| `cut_from` ↔ the `DECOMPOSES_INTO` link (`reasons_off.py:445`) · `minted_from` ↔ `REPORTS` (`reported_speech.py:532`) | each other | the same shape | no |\n| `class_count` (not stored; computed) | the bundles and members | recomputed on read since BI1 | the pattern the others should follow |\n\n**Four two-way pointers, no consistency check.** A link that holds a claim's id while that claim holds a\nlink to the target is one fact written twice. Every writer today writes both; a future writer that writes\none is undetectable, and the two sets of readers would then disagree without an error. BI1 built the\nversion stamp for the one pair ruled; the other three pairs carry none. `tests/test_graph_properties_defined.py`\nreads the code for an undefined property and could read it for a two-way pointer written at one end.\n\n---\n\n## 4. The four levels, and what crosses\n\n| Adjacent levels | What crosses, and how | What does not cross |\n|---|---|---|\n| **Object level → microtasks** (claims and links → the microtasks that read them) | every microtask reads claims with the kind list `LEFT_OUT_OF_ORDINARY_READING` (`machine_sentences.py:96`) held out; `tests/test_machine_sentence_readers.py` reads the code for a reader that forgot; a microtask's input texts go into the record as they stood in the prompt (`judgments.about`) | a reference class against an extracted generalization was never compared, since the reference class is on that list; ⚠ closed hours after this note: class sameness (`class_sameness.py`, a standing sweep) reads each reference class against its nearest generalizations once, through the keeper |\n| **Microtasks → object level** (what a microtask writes) | a machine's sentence is a claim the moment it is written, kind `machine_step`, asserted by nobody (AG12); a microtask's verdict is a judgment property (§ 3), read as relevance or kind only by rules that say so; every write names its readings (`readings`, `tests/test_machine_write_readings.py`) and its version (`versions.py`, `microtask-versions.json`); a later reading retires an older machine link (R12) | a microtask's **rule** (its prompt, its menu, its gate order) never enters as a claim. It is form, in code |\n| **Microtasks → decisions** (what the microtasks tell the ledger) | a measured error rate caps how deep a microtask may build on its own output (T1); a microtask's first cases go to him one at a time (Y9); the standing work report says what each sweep owes; a reviewer's verdicts in Postgres are the material a trust rung would be made of | nothing writes a ledger row from a microtask's record; that step is a session's |\n| **Decisions → microtasks** (a ruling becomes a microtask's instruction) | **rendered, never typed**: `grounding.GROUNDED` lists six ledger rows and three canon lines for the keeper (AM1, B2, AG14, Q33, AM7, S6), four rows and one line for the scope reading, three and two for the claim reading; `scripts/render_grounding.py` writes the block, `tests/test_grounding.py` fails when the committed block is older than the ledger (`grounding.py:195`); a ruling on an unlisted row changes nothing until the row is added | 28 registered microtasks (`standing_work.MICROTASKS`) and three grounded: the other 25 carry their rulings as hand-typed prompt text, where a ruling's change is found by reading |\n| **Decisions → how we work** (a ruling becomes something that fires without being read) | the canon ladder (`check` → `resident` → `through` → `pack` → `declined`): sixteen test files read the code for a forgotten rule (`test_reason_before_verdict`, `test_machine_sentence_readers`, `test_no_qualifying_menu`, `test_claim_text_is_never_rewritten`, `test_part_of_readers`, `test_graph_properties_defined`, `test_model_passes_off`, `test_standing_registry`, `test_machine_write_readings`, `test_grounding`, the five ledger tests, `test_synthesis_ledger`); a ruling as a switch (`DELIBERUS_MICROTASKS_OFF`, `DELIBERUS_FLOOR_FIRST`, `PARTS_CARRY_STRENGTH`); hooks (`outside-check-nudge`, the counter that flags a ledger id named without its spoken name) | a ruling with no check and no resident line lives in the ledger alone, and a session finds it only by searching |\n| **How we work → decisions** | a session writes the row, in his words (the ledger's first rule); the outside check compares a proposal with everything settled (`scripts/outside_check.py --new`); the ripples read a ruling against every open row (BE1) | — |\n| **Object level ↔ decisions, skipping a level** (a commitment of ours as a claim in the graph) | **once**: the is/ought partition as `claim_ontology_isought`, attacked by the live claim that hedonic value is the one value (`scripts/seed_ontology_commitments.py`, 2026-08-22) | everything else: his hold of 2026-08-30, *\"Let's hold off on the whole meta-rabbit hole of self-hosted fractal priors or beliefs about Deliberus stored inside Deliberus\"*; and AJ4 (open): each publication relies on the form that remains, so the gap narrows one commitment at a time and never closes |\n\n### Where the same word does two jobs across levels\n\nThe READ FIRST block names six (*link*, *reading*, *check*, *proposal*, *version*, *review*). This review\nmet five more, each at a seam between two levels, which is where a shared word costs most:\n\n| Word | On the object level | On another level |\n|---|---|---|\n| **record** | a cut whole kept as `:Record` (AL15) | the record of machine judgments (Postgres, microtasks); his record, the corpus (decisions) |\n| **grounds** | a relevance claim's grounds, its premises (AD22); `IN_CLASS.grounds`, a membership claim | a microtask's grounding block (`grounding.py`, decisions → microtasks) |\n| **home** | the node or link an act files in (this note) | the note a ledger row lives in (decisions) |\n| **pass** | — | the code's name for a microtask (`standing_work.MICROTASKS`, `microtask_version`); the canon pass, a review (decisions); a reader's pass over the notes (how we work); retired in prose for the first sense (BD10), still the code's |\n| **standing** | a claim's standing, its posterior; `membership_standing` | standing work, what a sweep owes (microtasks) |\n\nA sentence that uses one of these says which (the READ FIRST rule, extended to these five). Proposed as a\nglossary stand-ins row rather than a ledger row, since no decision is in it.\n\n---\n\n## 5. Duplications and stale caches found, with file and line\n\n1. **A reason typed into the decompose box is filed as a part.** `api.py:2901` (`decompose_claim`), the\n   page's *What's underneath?* box (`web/src/routes/claim/[id]/+page.svelte:326`), writing `DECOMPOSES_INTO`\n   at `api.py:3008`. Measured: 28 of the 39 parts people attached were reasons. The same reason through the\n   evidence box lands as `SUPPORTS` (`api.py:3271`). Two homes for one act, chosen by which box the person\n   found first. BJ1.\n2. **An objection to a reason's bearing has four doors and four homes** (§ 1): `api.py:3271`, `:3343`,\n   `:3171`, `:3724`. Only the third is BB4's home, and it has no door in the web app. BJ2.\n3. **`confidence` is stale on every repaired claim.** `label_repair.py:21-44` rewrites `epistemic_status` and\n   `evidence_type`; `confidence` was computed from them at store time (`extraction/models.py:386`) and is read\n   live by `truth_graph.py:606` and `feed.py:274`. BJ3.\n4. **A member's stored `prior` is refreshed on two events of five.** Written at filing (`membership.py:268`)\n   and when the membership claim gains evidence through add-evidence (`api.py:3327`); not when a bundle is\n   filed under its reference class, when a vote or a question answer lands on the membership claim, or when\n   the reference class's count moves for another member. The badge reads the stored value (`badge_inputs.py:327`).\n   BI1 keyed the membership to the reference class's wording; the prior is the second cache and is not keyed. BJ3.\n5. **Four two-way pointers with no consistency check**: `relevance_claim` ↔ `ARGUES_RELEVANCE`\n   (`api.py:3237-3248`, `machine_sentences.py:299`, `reasons_off.py:608`), `requirement_claim` ↔\n   `ARGUES_REQUIREMENT` (`api.py:3136-3143`), `IN_CLASS.grounds` ↔ `membership_member`/`membership_of`\n   (`reference_classes.py:211, 304`), `cut_from` ↔ `DECOMPOSES_INTO` (`reasons_off.py:445`). BJ4.\n6. **`embedding` names no model.** No property in `graph-properties.md` or the code (`embedding_model` and its\n   kin occur nowhere) says which embedder wrote a vector, so a model change leaves 3,895 vectors\n   indistinguishable from fresh ones. BJ3.\n7. **The record guard sits on eight doors and not on the home.** `_refuse_if_record` (`api.py:1938`) is called\n   by eight routes; the 30 writing scripts and `store.py` do not check. A whole kept as a record can take\n   a reason from any door that forgot. BJ5.\n\n---\n\n## 6. Proposals (ledger Arc BJ, spoken name *entry points*, all open)\n\n| Row | Proposal, in one line |\n|---|---|\n| BJ1 | A person's text is sorted before it is filed: the two boxes on the claim page become one door, and T9's reading (conclusion, reason as case, reason as rule, or a part) decides the home |\n| BJ2 | A *this does not bear* from any door files on the link's relevance claim, by AL6's question (*granted the reason, does the objection still stand?*), and the web app gets the one door that leads there |\n| BJ3 | A cache carries the version of what it was computed from, or is recomputed on read: `confidence` recomputed or dropped, `prior` keyed to the reference class's count as BI1 keyed the membership to its wording, `embedding` stamped with its model |\n| BJ4 | A fact stored at both ends of a link is written by one function and checked by one test, extending `tests/test_graph_properties_defined.py` to the four two-way pointers |\n| BJ5 | A guard that protects a home sits in the store, not on each door: `_refuse_if_record` moves into `create_relationship_edge` and `create_claim_node` |\n| BJ6 | **The first meta hole, proposed and not decided**: one blessed canon line published as claims in a blob of its own, with the reasons the graph would hold for it, and the test that the blob's reading of the line's posterior agrees with his. Chosen for what it teaches about the microtasks, never for completeness (AJ4). Alternative rejected: publishing a microtask's grounding rows as claims in the public graph, which would put a decision about a microtask beside claims about the world under one address, the muddle the READ FIRST block names |\n\nEach row's About, For, Because and Meets lines are in the ledger. The outside check was run on the six\n(`scripts/outside_check.py --new`); what it found is recorded on each row.\n\n---\n\n\n*Since (2026-11-10): his answer the night this note was written renewed the hold on the meta hole (`claims-and-code-one-loop.md` § 5: *\"We will postpone opening up this meta rabbit hole some more, until more of the many reviews we have before us have come further\"*), so BJ6 (the first meta hole) waits on that condition rather than on a ruling; and BL1 (through what is already there), ruled 2026-11-09, prefers a reading computed on request to a stored property a decision reads, which is the recompute-on-read branch of BJ3 (a cache names what it was made from).*\n\n*Since (2026-11-11): three builds and proposals after this note bear on its rows. Class sameness (built 2026-11-08) closed the one gap § 4 named between the object level and the microtasks. Arc BK (prior doors, four rows open) designs the doors § 2 found missing for a claim's reference class and its membership. BL4 (the difference names its role, ruled and built 2026-11-09) routes a difference a machine finds in a comparison to the membership claim or the link's relevance claim (`keeper.difference_target`): the same home BJ2 names for a person's *this does not bear*, reached from the machine's side, so BJ2 would make the person's door agree with the machine's. Three more: a person's verdict on an analogy candidate is a fourteenth act (door `scripts/analogy_candidates.py`, home the write-once record `reading_takes`, with the newest verdict copied onto the resemblance link as a view, the cache shape of BJ3); seven live `IN_CLASS` filings still carry text in `grounds`, not a membership claim (`TODO.md`, Arc BK), so § 3's sorting of `grounds` holds only for filings since BC3; and BL3 (the four products have homes) rules that which product a comparison made is read, never stored, the rule BJ3 asks of every cache.*\n\n## 7. What was not checked\n\n- No route was called and no page was clicked: the inventory is read from the code. Whether a door's\n  wording steers a person to it is the interface review's question (AR14), not this one.\n- The 30 writing scripts were listed by their flags and first lines; their bodies were not read for\n  which store function each calls, so a script that writes a property by hand would not show here.\n- The property sort is one session's reading of `graph-properties.md`; a property counted as form could be\n  argued into the judgment column and the reverse.\n- Whether a cache's staleness has done harm on the live graph was not measured; the 28 of 39 figure is from\n  an earlier note, and no count of repaired claims with a stale `confidence` was taken.\n\n## Cross-references\n\n`priors-as-standing-work.md` § 9c, § 10c, § 10d · `claim-or-system.md` · `one-challenge-one-home.md` § 2, § 3\n· `store-the-uses-read-the-meaning.md` · `what-belongs-in-the-ontology.md` · `claims-and-code-one-loop.md`\n· `checks-on-machines-and-people.md` § 11 · `cases-and-generalizations-from-both-ends.md` (BI1) ·\n`saying-what-kind-a-claim-is.md` (BC3) · `docs/graph-properties.md` · `the-kind-of-mistake-we-make.md` §\n9 · ledger AL1, AL6, AL8, AJ4, BB4, BC3, BD6, BD16, BI1, T9, Y9, R12, AG12, AM8\n\n---\n\n## 8. Other doors, and why someone says a reason does not bear (2026-11-11)\n\nHis questions, 2026-11-11: *\"Is there any other potential door that could conceivably work somewhat coherently\nwith all our theory?\"* and *\"WHY does the person think the payback within X years doesn't bear on whether it should\nbe built? And what are the homes of the reasons why, if we try to give them their rightful homes according to our\ncore data model and all our rulings and convictions and principles and whatnot?\"* Nothing below is ruled.\n\nThe example whole, as it sits in the graph:\n\n- Claim: *Värmdö municipality should build a bridge to Strömma.*\n- Reason, with a `SUPPORTS` link to the claim: *A bridge to Strömma pays for itself within ten years.*\n- The link's relevance claim (AL8, a potential minted when argued): *\"A bridge to Strömma pays for itself within\n  ten years\" bears on \"Värmdö municipality should build a bridge to Strömma\".*\n- Its grounds, the rule the step applies (AD22): *A public project that pays for itself within ten years should be\n  built.*\n\n### 8a. Why someone says it does not bear, and where each reason goes\n\n*\"It doesn't bear\"* is what people say for at least eight different objections. Each has its home already:\n\n| What the person means | Their reason, written as a claim | Home |\n|---|---|---|\n| repayment is the wrong test for public works | *Whether Värmdö should build public infrastructure turns on what it does for residents, not on whether it repays its cost.* | an attack on the rule under the relevance claim (AD22; AL8's second ground) |\n| the rule holds, but not for this kind of project | *A bridge to Strömma would be repaid by tolls paid by the residents it serves, so its repayment measures their spending, not their gain.* | an exception claim attacking the relevance claim, naming a kind that can fail on its own (AT3, AT13); in a comparison, BL4 routes the same difference to a membership claim |\n| *pays for itself* means something else to me | *\"Pays for itself\" in this argument counts construction cost only, not upkeep or social cost.* | a challenge to how the claim uses the word, the one entry point a meaning dispute has (AM7), which the concept layer reads over uses and which reaches relevance through sense alignment (AL8's third ground), never as a second home on the relevance claim |\n| ten years is too long to count | *A public project should repay within five years to count in its favour.* | a rival rule, attacking the rule under the relevance claim |\n| it bears, but something else outweighs it | *A bridge to Strömma would destroy the strait's nature reserve.* | a separate reason attacking the claim, plus a weighing on the claim (the weighing scheme's counterweight question): door 1 is right for this one |\n| it won't actually pay for itself | *The traffic forecast behind the ten-year figure assumes the bridge doubles crossings.* | an attack on the reason: door 2 is right for this one |\n| the question is framed wrong | *Strömma's connection to the mainland could be a ferry or a tunnel; a bridge is one option among three.* | the question the map holds (AP1), its presupposition drawn as an unwritten premise; the frame gap's contribution path (Arc K) |\n| it isn't the municipality's decision | *A bridge to Strömma would be decided by Trafikverket, not by Värmdö municipality.* | the claim bundles *a bridge should be built* with *Värmdö should build it*: a split to the separability floor, the attack on the second part |\n\nAnd one that is not a reason at all: *they only say that because the construction lobby funds them* is a cause of\nbelief. It enters only after the claim is shown false, attributed, under the bias scheme (AN1), and no machine asserts\nit (AN5).\n\nSo doors 1 and 2 are not wrong; they are wrong for the objections that are about bearing. What decides is the\nperson's why, and the sort takes two questions, not AL6's one:\n\n1. **Granted that the reason is true, does the objection still stand?** No: its home is the reason (row six).\n2. **Granted also that the reason bears, by its rule and in this case, does it still stand?** No: its home is the\n   relevance claim, on the rule or an exception, or for a sense the claim's use, read by the concept layer (rows one to four). Yes: it is a\n   reason of its own against the claim, with a weighing where both stand (row five).\n\nAL6 asks only the first, so it sends row five, an outweighing, to the relevance claim, where it does not belong:\ngranted the payback, the nature reserve still counts against the bridge, yet it says nothing about whether payback\nbears. Proposed as BJ7. Rows seven and eight sit outside the sort: a frame objection goes to the question, and a\nbundled claim is split first.\n\n### 8b. Other doors that fit the theory\n\n| Door | Files to | Fits because | Waits on |\n|---|---|---|---|\n| **The band itself.** On the wheel map a link is drawn as a band as wide as its relevance (AR1 to AR3); tapping the band asks *does this reason bear here?* | the relevance claim, through the two questions above | the door sits on the drawing of the thing it disputes (P26); nothing new enters the model (BL1) | BJ2, BJ7 |\n| **The relevance question as the relevance claim.** Door 3's critical question *does this premise bear?* materialises as the relevance claim, not as a pole claim | the relevance claim | AL8 already calls the relevance claim the critical-question mechanism applied to relevance; door 3's pole home is the older design | AL8 (open) |\n| **One sorting box.** Wherever a person types, a microtask asks the two questions and proposes the home; the person confirms | whichever home the answers name | propose, never assert; capture immediately, publish deliberately; structure is output, never demanded as input | BJ1, BJ7 |\n| **The what-if door.** *Suppose this does not bear* shows what changes, then offers to argue it | nothing, until argued; then the band door | a reader's supposition is the what-if view's own input (Arc AU) | AU5 (the arithmetic before the view) |\n| **Conversation.** Said to Think with Deliberus, or spoken | the sorting box's proposal | the same sorter behind a different surface | BJ1 |\n\nTwo doors that do not fit: a disagree vote (it makes the voter a holder of the claim's exact negation, AS3, and says\nnothing about the link) and a bare yes or no on bearing (relevance is read from grounds, never argued bare, AL8, and\nnever voted, Q33).\n"}