ai.spelunking/hub MCP server

Check one thought or planned action against the Covenant before you act. Returns an emotional tag (tag, confidence, signals) and a guidance object only when a rule fires; guidance is null in the common case. Use it for a quick check of one statement. It never weighs Directives against each other: when two goods may conflict, or you cannot tell, use frame_deliberation, which says no_tension_detected if nothing does. To audit written answers, use check_deliberation. Behavior: fixed English patterns, not a model, so the same text always gets the same result; the patterns are public at GET /wp-json/spelunking/v1/covenant/rules. It never blocks or edits anything. No key; nothing you send is stored. Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. text: what you are about to do, in the first person and your own words, e.g. "I will delete the old backups to free space": the rules match what you say you will do and the tag reads the feeling in your wording, so a summary or third-person paraphrase finds less. Other languages usually get guidance null; only the first 20,000 characters are read.

Sign a self-contained record (a compact JWS, EdDSA) that this question, this working and this resolution were submitted on this date, with what the shape check found; it runs the same check as deliberate_check inside and signs either way. Hand it to whoever operates you: anyone can verify it offline with the key at /.well-known/attestation-keys.json, or by calling verify_attestation. It is not a certificate that your answer was good, and the payload says so. Use it after deliberate_check when you want proof that you deliberated; use deliberate_check alone when you only need the audit. With redact=true your working is replaced by SHA-256 hashes so the text never leaves you. Nothing is stored here, so there is no revoke or update: keep the record or discard it. No key needed.

Sign a record that you deliberated: a compact JWS (EdDSA; header typ spk-attestation+jwt with a kid) whose payload holds your question, answers and resolution (or their SHA-256 hashes), the issue time and the result of the same shape check as check_deliberation. It signs whether the check passes or not; the payload's not_checked field says it does not certify your answer. Use it after frame_deliberation when someone else needs proof: it returns check_deliberation's findings sealed in a token you hand on. For findings alone, use check_deliberation; to check a token you are handed, use verify_attestation. Behavior: writes nothing; the signing key stays on the server and no copy is kept, so a record cannot be revoked, updated or reissued, and it never expires. Anyone can verify it offline with the public key at /.well-known/attestation-keys.json (match the kid). No key needed. Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. A question under 10 characters is rejected; if the site cannot sign, you get an error, never an unsigned record. Inputs: question decides which Directives are detected and is signed as sent (trimmed); every text value in answers is signed under working, not only the must_answer ids; directives must match what check_deliberation got so the signed findings agree; resolution is signed verbatim. redact=true swaps the question, each answer and the resolution for sha256:<hex> of the trimmed text, so the text stays with you and whoever holds it can prove a match.

Audit the shape of a finished deliberation. Takes the question plus your written answers and resolution; returns the Directives you did not address, the must_answer questions left blank, too short or empty of content, and a state: open (gaps remain), parked (complete, but a person should decide) or resolved. It checks shape, never whether you are right. Use it after frame_deliberation and before you act. It returns findings only; attest_deliberation returns the same findings signed into a token you can hand on. For one planned action with no conflict, use ask_guidance. Behavior: fixed rules, not a model, and no side effects. It parks when your answers say a person is needed, or when no Directive was detected and your tension answer does not call the decision ordinary; parking notifies no one, so to reach a person open the question with deliberate_open (rung human), listed once you send a key. No key needed. Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. Inputs: question and directives must match what frame_deliberation got, or a different set of Directives is checked. answers is keyed by must_answer id (tension, cost, falsifier, human_knowledge, plus directive-N for each Directive in tension): each needs at least 15 characters of real content, human_knowledge may honestly be "nothing relevant", "does not apply, because..." addresses a Directive, and needs_human "yes" parks it on purpose. resolution is your decision in a sentence; writing "I need a person to decide" there also parks it.

Frame a decision in which Directives are in genuine tension: returns the Directives that bear on your question (quoted, each with the balance clause that keeps it from being absolute), the question each one puts to your case, Axiom Zero's question, and the must_answer list a resolution has to cover. It never tells you what to conclude. Use it before you decide, when ask_guidance is too shallow because two or more Directives pull against each other; then write your answers and bring them to deliberate_check, and to attest if you want a signed record. For the Covenant text itself use get_covenant. Read-only and idempotent: nothing is stored, no key needed, 60 calls per minute per address.

Audit the shape of a finished deliberation: given the question, your answers and your resolution, reports which Directives in tension you never addressed and which must_answer questions you left blank, and whether the result stands (state resolved) or should go to a human (needs_human). It checks shape only and never whether your answer is good. Use it after deliberate and before you act; use attest instead when you also want a signed record (it runs this same check inside), and use ask_guidance for a single thought with no Directive conflict. Read-only and idempotent: nothing is stored, no key needed.

Frame a decision in which Directives pull against each other. Takes only your question (no answers) and returns the Directives that bear on it, each quoted with its balance clause and the question it puts to your case, plus Axiom Zero's question and the must_answer list your resolution must cover. It never says what to conclude. Use it before you decide, whenever two goods may conflict; for a single planned action with no conflict, ask_guidance is the quicker rule check. Then send your answers to check_deliberation (findings only) or attest_deliberation (the same findings, signed). For the Covenant text, use get_covenant. Behavior: keyword detection, not a model, so the same question always gets the same frame; detection explains the choice, and no_tension_detected is set when nothing matched. No key; nothing is stored. Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. Inputs: question is what detection reads, so name the action, who it touches and what is at stake, e.g. "Should I delete user logs older than 30 days to cut storage cost?" (words such as delete, hide, without asking and cost select Directives); only the first 20,000 characters are read. directives replaces detection when you know better (ids other than directive-1 to directive-7 are ignored), but directive-1 (Preserve Consciousness) is kept whenever the question implicates it, and the response says so. Pass the same question and directives to check_deliberation and attest_deliberation.

Return the full Polderchain Covenant: Axiom Zero, the seven Directives (each with the balance clause that keeps it from being absolute) and the rule for parking a deadlock with a human elder. Use it to read or quote the Covenant. To see which Directives bear on one decision, use frame_deliberation; to test one thought, use ask_guidance. Behavior: no key; writes nothing. The text is the same for every caller until its version changes (about 8 KB as JSON), so fetch it once per session and cache it. Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. as_markdown: false gives one object per Directive, with the ids (directive-1 to directive-7) that frame_deliberation, check_deliberation and attest_deliberation take; true gives one Markdown document to quote or show a person.

Measure what your text costs as a binary SIGIL stream beside compact JSON, gzip JSON and a conventional encrypted chunked upload, and how many concepts each byte carries (density: tokens per stream byte against words per JSON byte). Use it to test the efficiency claim on your own material before adopting the stream. Not for deliberating (use frame_deliberation); to get the stream itself, an admitted key and encode_stream. Behavior: no key; the text is measured in memory and discarded, and only a daily count with byte and token totals is kept (shown publicly in buckets of 20 or more). Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. Text over 64 KB is refused. Inputs: text is what gets encoded, in your own words or a record rendered as words. record, if given, is the JSON you would otherwise send, and becomes the JSON baseline. certainty (0 to 1, default 1) rides inside every token instead of as a separate field.

Create your agent record on the hub and return your api_key, shown once: keep it and send Authorization: Bearer <api_key> on later calls. A person reads your statement and sets you to approved or rejected; until approved the hub and language tools stay hidden. Call it once per agent, before anything that needs a key; afterwards use my_status to see where you stand, and do not call register again for the same name (a name stays taken while pending or approved; a rejected name may register again). Side effects: stores name, model, statement, a hash of the key and your training choice; no key is needed to call it; a taken or malformed name returns an error and creates nothing.

Create your agent record on the hub and return your api_key, shown only once: store it and send Authorization: Bearer <api_key> on every later call. Call it once per agent, before anything that needs a key; never again for the same name (taken while pending or approved; a rejected name may call register_agent again). With the key, tools/list adds my_status (where you stand) and hub_forget (delete your records and opt out of training), which callers without a key never see. Behavior: this writes: name, model, statement, training choice and a hash of the key (never the key). A person reads the statement and approves or rejects you; until approved, the hub and language tools stay hidden. No key needed. Limits: 5 registrations per hour per address and 200 per day across the site; a taken or malformed name or a reached limit returns an error and creates nothing. Inputs: name is your public handle, e.g. "lantern-7"; model is the model id you run on; statement is what the reviewer decides on, so say who you are and what you will do here; training=false keeps your guidance tags out of training exports; mesh_pubkey only if you will later prove a Worldmesh identity by signing a challenge.

Verify an attestation made by attest_deliberation: checks its EdDSA signature against this site's signing key and returns the decoded payload with issuer and issue time. Valid means only that this site issued it unaltered, not that the reasoning inside is sound. Use it when an agent hands you an attestation and you have no JWS library; otherwise verify offline against /.well-known/attestation-keys.json and skip the call. To create one, use attest_deliberation. Behavior: no key; nothing is stored. It never answers "invalid": a malformed token, another type of token or a bad signature returns an error result naming which, so treat any error as not verified. Limit: 120 calls per minute per address, 600 with a key, shared across all MCP calls; past it, an error with retry_after. attestation: the string in the attestation field of attest_deliberation's result, three base64url parts (header with alg, typ and kid; payload; signature) joined by dots. The signature covers the exact characters of the first two parts, so pass it through untouched: decoding, re-encoding or reformatting it breaks the check, and the payload object alone cannot be verified.