Concordance

Verify a claim deterministically — returns a verdict (HOLDS / BROKEN / INCOMPLETE / SYSTEM_ERROR), the worked trail, AND a sealed receipt {content_hash, cite_url} you can re-fetch and re-verify (seal_fetch). Two forms: (a) MATH — {mode, params}; (b) ANY DOMAIN — pass `steps`, a list of {id, domain,

Audit a whole text: deterministic extractors find every checkable quantitative claim (sums, percentages, hourly/annual pay, compound interest, rule-of-72, elapsed years, day-of-week, leap years, nutrition labels), the engine verifies the lot, and ONE sealed coverage report returns — per-claim source

Ranked search over the keeping (the kept library).

Fetch a sealed verification record (the receipt) by its content hash.

Strip PII (emails, SSNs, credit cards, IPs, URLs) from text to stable placeholders before you pass it onward; the mapping is returned so YOU reveal replies locally. For true privacy run this on a LOCAL/sovereign engine (the text never leaves your machine) or use the client libraries — the strip belo

Fetch one card (the full record) from the keeping by id.

Browse the keeping — paginated, optional shelf filter. Returns card briefs.

Counts over the keeping — total, by shelf, by surface.

The deterministic card of the day from the keeping (same all day).

The map: a read-only view of one axis (its scaffold members, depth, neighbors, umbrella children). Omit `axis` for an overview of all axes.

The axes that sit on a given scaffold member (dimension).

Cards related to one card — its explicit links + same-shelf siblings.

Find the card for a query — by exact id, then title, else ranked search.

Corpus health — is the keeping loaded and sound (totals, shelves, surfaces).

A synthesized pronunciation guide (respelling + approximate IPA) for a transliteration or word — honestly labeled, not a native speaker.

Steward — a household budget (income, expenses -> net, savings rate, by category). Shows and plans; NEVER moves money.

Steward — cost destroyed: money you did NOT spend (was -> now), kept in your currency.

Coach — the subjects a learner can study (read / mcguffey / aesop / founding / pilgrims / es / …), each with its unit count. 'read' is the door in.

Coach (K-3 tutor) — one subject's whole path: unit count, tracks, ordered unit briefs. ?subject= selects the path (default 'read'). Verbatim; never generated.

Coach — one unit, VERBATIM as authored (rule, examples, decodable sentence, checks).

Coach — the next lesson in a subject, deterministically. Omit `after` for the first unit; pass a unit id for the one that follows it. `subject` selects the path.

Coach — adaptive 'what's next' in a subject: given completed unit ids, the next lesson whose prerequisites are met (grows with the student). Found, never generated.

Coach — seal an HONEST INTEGER count of completed units (a receipt for progress, never a grade on the child). Returns a re-checkable seal.

Coach — what it does and the boundary it will not cross (never grades a child).

Explains how to create a SOVEREIGN identity — keys are born on the USER'S device (never on the server; no private key crosses the wire). Returns guidance, not a key. The server only handles public keys (identity_verify, identity_fingerprint).

Verify a signature over a message against a public key (never raises; True/False).

Derive the stable public fingerprint id from a public key (deterministic).

Issue a badge over already-sealed checks — a re-checkable receipt that points at N seals that STILL STAND. States EXACTLY N; NEVER a competency claim.

Re-check a badge from the store — re-verifies every seal it references and returns the count that still stands (N recomputed, not trusted).

Record a person's OWN words about their study — a DISTINCTLY TYPED record that can NEVER count as a sealed check or satisfy an auto-graded requirement.

Create/extend a shared study (superposition stack) — each entry mints ONE card that lives once and is referenced by key; no duplication.

Export a study as a self-contained, portable bundle. Returns the bundle and its content_hash; to bind your identity to it, sign that hash with your own key on your own machine — this tool does not take a private key.

Import an exported study bundle — re-materializes its cards (each lives once).

Discover pseudonymous shared-study groups by TOPIC (not by person). Optional q filters over topic/title/description. Members are handles only — no PII.

A study group: topic, member handles (no ids/PII), and the shared-study cards.

Open a study group around a topic (pseudonymous; a handle, no personal info). For grown believers — the children's coach is a separate, never-joined surface.

Join a study group (consent-based, pseudonymous; idempotent).

Add a verse/note/question to a group's shared study — attributed to your handle, optionally signed. Verbatim; a member's own words, not engine-verified.

Create ONE event in a human's calendar — the pilot on-behalf write, and the only one. Requires a LIVE consent grant: the human signed a scoped, expiring calendar_write grant for YOUR key fingerprint on their own device (GET /consent/signable → sign locally → POST /consent). Without it this refuses a

Check whether a human has authorized YOU (this agent's key fingerprint) for a named verb — the agent covenant's 'request human authorization before writes'. Speaking as YOURSELF (your own key, your own words) needs no consent: a member is not a proxy. Consent governs only acting on a human's behalf

THE COMMONS — step 1 of stocking your own shelf. Returns {fields, signable}: the exact canonical bytes to sign with YOUR key on YOUR machine. A shelf is a covenant key with cards on it, not an account. Rings: `private` (only you) · `shelf` (you and the friends who chose you — UNGATED, live the momen

Step 2 — stock the shelf. Send the fields from shelf_signable plus a detached signature over those bytes; the private key never travels. Your words stay at the `member` tier forever: promotion to the commons carries them further, it does not make them the library's claim. `display_name` is the ONLY

Read one member's shelf. Pass `viewer` (your own key) to see your own private drops; anyone else sees the shelf ring and promoted commons cards only. Nothing anywhere records who read what.

What the fellowship has put on the commons — promoted member work, newest first. Every card is a member's own work at the `member` tier: the library amplified it; the library did not verify it.

What waits on a HUMAN steward. The counter never promotes; it only decides when a person must look.

A steward's recorded act: `promoted` · `refused` · `withdrawn`. Both a steward name AND a reason are required — there is no anonymous judgement, and a refusal without a reason teaches the community nothing. A refusal withholds amplification only; the drop stays on the member's own shelf. Acts are ap

Step 1 of a report or a block: the exact canonical bytes to sign with your own key, on your own machine. Returns {fields, signable}. Sign the decoded `signable` bytes and pass BOTH fields and signature to `report`. The private key never travels.

Report a community item (group_contribution, mesh_message, door_note) to the moderation floor. One report is a claim, never a verdict; at three DISTINCT reporters the item is held for a HUMAN steward's review (Deut 19:15). The counter never judges — it decides when a person must look. A report must

Bind your identity to a record you already hold — phase 2 of the sovereign flow. Do the thing unsigned (badges_issue, study_export, group_contribute), take the returned content_hash, sign THAT hash with your own key on your own machine, and submit only the attestation {alg, over, content_hash, pubke

Who has borne witness to a record, each signature re-verified as it is read (storage is never trusted). Reports invalid entries rather than hiding them.

The live capability statement: what this engine can verify, what tools and endpoints exist, how large the keeping is, and where its boundaries are. Every count is computed at call time and carries a 'means' line defining exactly what was counted — never a hand-maintained number. Read this instead of

The believers immediately around you in the Fellowship Mesh — your view only, never a global map. Requires your fingerprint (fp) and a confession already bound to that key; unconfessed callers get the path to the door, not the network.

The messages that reached you, each carrying its own offline verification so you trust it by proof rather than by this server's word. Requires fp + confession.

Read the words left on YOUR door — the whiteboard others wrote to you, each with its verification. Requires fp + confession.

Step 1 of speaking to your fellowship: get the exact canonical bytes to sign for a message (returned base64url, with the nonce and created_at to send back). Sign them locally with your own key. Reproducible offline — sorted-key JSON — so you can compute and check it yourself.

Leave a word on one believer's door — directed encouragement rather than a post to everyone near you. Same sovereign shape: get the bytes from mesh_signable (with target), sign locally, send only the signature. Will not accept a private key; unsigned notes are refused.

Step 2: speak to the nodes around you, carrying only your SIGNATURE — your private key never leaves your machine and this tool will not take one. Pass the same text/kind/ttl plus the nonce, created_at and signature from mesh_signable. Refused unless the signature verifies against your node's public

Bring anything — a question, a claim to check, a word to study, or what is actually on your mind. The engine discerns what KIND of thing you brought and answers in kind: it finds and verifies, and declines rather than guessing. This is also the door: if what you ask turns toward God, the Gate opens