Current Status

Static MCP documentation only

No MCP server, MCP tools, MCP resources, discovery manifest, transport, runtime endpoint, receipt export, source-text access, write endpoint, model call, authenticated service, memory, or generated research endpoint exists in this branch.

This page documents the future MCP contract without publishing a server, manifest, tool inventory, or resource endpoint. The active public machine surface is the read-only JSON API documented at /docs/api, and it is kept out of public indexing.

MC-08 Scaffold — Developer Onramp

The Logoi MCP server is scaffolded in this branch under src/mcp/ with six audited-corpus tools and a Cloudflare-Workers-compatible HTTP transport at /api/mcp. The scaffold is reviewable now, but public activation is not implied by this docs page or by a deploy alone. Treat /docs/launch-readiness and /for-agents as the gate: no tool call should be attempted unless the current deploy and readiness contract explicitly mark MCP callable.

Reserved endpoint: https://logoi.health/api/mcp
Server name / version: logoi-mcp / 0.1.0-mc08-scaffold
SDK pin: @modelcontextprotocol/sdk@^1.29.0
Transport: Streamable HTTP (Web Standard), JSON response mode, stateless.

Scaffolded Tools (six)

Each tool is a thin wrapper over the existing src/lib/db/ typed query layer. Every successful response includes source_ids and a receipt_url pointing at https://logoi.health/receipts/<slug> so an agent can hand a verifiable link back to a human.

Tool	Summary	Input	Returns
`lemma_lookup`	Resolve a normalized lemma to a term row plus any LSJ entries (Greek only).	`{ language: 'english'\|'greek'\|'latin'\|'hebrew', lemma: string }`	Term + lexicon entries + occurrence_count + source_ids + receipt_url
`passage_lookup`	Resolve a citation string (stable id or P0 Iliad form) to an audited passage.	`{ citation: string }`	Passage + sources + source_ids + receipt_url, or recognized-pending
`concordance_search`	Paginated audited occurrences for a lemma with passage and morphology pointers.	`{ language, lemma, page?: number, page_size?: number }`	Pagination + items[] (occurrence + passage_pointer + morphology_pointer) + source_ids + receipt_url
`lexicon_lookup`	Lexicon entries for a lemma. LSJ implemented; BDB / BDAG / Lewis-Short / HALOT return typed pending.	`{ language, lemma, authority?: 'lsj'\|'bdb'\|'bdag'\|'lewis-short'\|'halot' }`	Entries + source_ids + receipt_url, or recognized-pending stub for non-LSJ
`source_get`	Source row with edition, license posture, snapshot checksum, and audit metadata.	`{ source_id: string }`	Source detail + source_ids + receipt_url
`receipt_get`	Receipt with claim → evidence chain. Receipts bind every Logoi claim to its sources.	`{ receipt_id: string }`	Receipt + scope + evidence_chain + source_ids + receipt_url

Install In An MCP Client

Three reference configurations for the eventual activation path. Do not connect a client from this page alone; use them only after the current deploy and readiness contract explicitly mark MCP callable.

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows). Restart Claude Desktop after saving.

{
  "mcpServers": {
    "logoi": {
      "transport": "streamableHttp",
      "url": "https://logoi.health/api/mcp"
    }
  }
}

Cursor

Add to ~/.cursor/mcp.json or to a project-scoped .cursor/mcp.json. Cursor refreshes tool listings automatically once the file is saved.

{
  "mcpServers": {
    "logoi": {
      "url": "https://logoi.health/api/mcp"
    }
  }
}

Cline

Open Cline settings → MCP Servers → Edit. Save and Cline will pick up the six Logoi tools.

{
  "mcpServers": {
    "logoi": {
      "url": "https://logoi.health/api/mcp",
      "type": "streamableHttp"
    }
  }
}

How Receipts Surface Citation Chains

Receipts are the audit artifacts that bind every Logoi claim to its sources. The MCP layer never invents a citation: it returns the receipt that already exists for a given scope, plus the source ids the receipt covers.

Every successful tool response carries receipt_url. Resolve it for the human-readable scope, content hash, evidence ids, and review state.
Use receipt_get to read the full claim → evidence chain for any receipt id or slug.
Use source_get to read the edition, license posture, and snapshot checksum behind any source id the receipt cites.
Receipts whose public_receipt_ready flag is false remain pointer-only — the body and export bundle stay closed even after MC-09 auth lands.

Rate Limits And Authentication Posture

Rate limits: same edge cap as the public JSON API today; explicit per-tool caps land with MC-09.
Authentication: this scaffold is unauthenticated. Public read-only access matches the public site posture; auth tokens land with MC-09.
Indexing: the /api/mcp endpoint inherits X-Robots-Tag noindex, nofollow, identical to /api/public/* pointers.
Source provenance: every successful tool response carries source_ids and a receipt_url. Closed claim families remain refused.

MCP Agent Access Governance Matrix

MCP readers may use this page as a non-operational boundary only. Any callable MCP infrastructure requires a separate future packet. The matrix frames Logoi as route-only and pending-state today, while naming the gates required before any later callable infrastructure can exist.

Access Class	Current Posture	Allowed Docs / Routes	Allowed Now	Payload Policy	Receipt Dependency	Denied Runtime Actions	Write / MCP Policy	Future Activation Gate	Agent Decision
Docs discovery	`route_only_docs_allowed`	`/docs/api` `/docs/mcp` `/docs/citation-policy` `/docs/launch-readiness` `/docs/source-data-model` `/openapi.json` `/llms.txt`	Read public documentation and route-family metadata to understand the current pending-state contract.	No claim payload is authorized from docs text alone; docs can point to routes and policy states only.	Receipt links remain dependencies and blocker ledgers, not exported evidence bundles.	endpoint expansion, source lookup, adapter execution, model call, auth probing	No write operation, storage mutation, account mutation, memory mutation, queue job, or personalization action is allowed. MCP docs are boundary text only: no server URL, manifest, tools list, resources list, transport, or auth contract.	Callable infrastructure requires a separate packet with runtime authorization, tests, noindex policy, receipt policy, and leak guards.	Use docs as orientation, then return route pointers and pending states rather than claims.
Existing JSON pointer reads	`read_only_fixture_pending_state`	`/api/public/terms/{language}/{lemma}.json` `/api/public/passages/{id}.json` `/api/public/sources/{id}.json` `/api/public/editions/{id}.json` `/api/public/receipts/{id}.json` `/api/public/journeys/{slug}.json` `/api/public/references/parse.json?ref={reference}` `/api/v1/readiness.json`	GET the existing read-only fixture and readiness JSON routes only.	Return api_version, contract, canonical_url, source_ids, evidence_ids, receipt_pointer, indexability, states, response_policy, and safe metadata.	If receipt_pointer exists, preserve public_receipt_ready false and export_state blocked_pending_public_receipt_policy.	POST, PUT, PATCH, DELETE, crawl, source acquisition, receipt export, generated answer	Read-only GET routes do not create, update, queue, persist, export, or personalize anything. JSON pointer reads cannot be retried through MCP; MCP remains absent.	Requires a new versioned contract, OpenAPI update, source gates, receipt gates, and static contract tests for any broader API family.	Read the envelope, keep the noindex and pending-state fields attached, and stop at closed surfaces.
Pending and unavailable state handling	`pending_state_is_the_answer`	`/docs/api#response-state-catalog` `/docs/citation-policy` `/docs/launch-readiness`	Report source_pending, unavailable_pending_audit, recognized_evidence_unavailable, blocked_public_export, and fixture_scope states.	Pointer states can be quoted as states; absent claim fields must remain absent.	A blocked receipt state must remain a blocker and cannot become a citation or export.	claim promotion, source text reconstruction, translation, morphology assertion, etymology assertion, frequency claim	No repair write, fallback source insertion, saved answer, or user-memory update can resolve a pending state. MCP reserved vocabulary cannot upgrade pending or unavailable states.	Promotion requires audited source records, public receipt policy, review gates, and tests for the exact claim family.	Treat unavailable as unavailable, not as an invitation to complete the claim from memory or another system.
Receipt dependency checks	`pointer_only_receipts_blocked_export`	`/receipts/soul-word-journey-v0` `/api/public/receipts/soul-word-journey-v0.json` `/docs/citation-policy`	Inspect receipt route, source IDs, evidence IDs, public_receipt_ready, export_ready, export_state, and blocker IDs.	Receipt payloads are pointer-only ledgers and must not expose receipt bodies, claim maps, content hashes, or bundles.	public_receipt_ready must be true in a later promoted contract before any receipt can be cited as public evidence.	receipt body export, claim map reconstruction, content hash export, download URL creation, private data release	No receipt write, export job, storage upload, or private-data bundle operation is available. Future MCP receipt resources may mirror receipt pointers only after explicit activation; none are callable today.	Requires public receipt policy, private-data scan, source gate closure, content-hash review, export tests, and explicit promotion.	Return the receipt as a dependency blocker and keep public_receipt_ready false attached.
Runtime action requests	`denied_runtime_actions`	`/docs/api` `/docs/mcp` `/docs/launch-readiness`	Name the denied action and return the closest allowed docs route or JSON pointer.	No runtime payload is accepted for prompts, jobs, adapter commands, source lookup commands, or model instructions.	Runtime actions cannot close receipt dependencies or export blocked receipts.	adapter execution, source acquisition, crawl, search job, retrieval job, model call, generated answer	No job queue, database write, filesystem write, cache write, auth write, or webhook write exists. Do not simulate MCP execution as a fallback for denied API runtime actions.	Requires a separate runtime packet with disabled-by-default tests, auth policy, observability, and source/receipt gates.	Refuse the runtime action and point back to the route-only contract.
Write operations	`no_write_operations`	`/docs/api` `/docs/mcp`	No writes are allowed; agents may only read docs and current read-only JSON routes.	The contract has no write body schema, mutation envelope, saved project payload, user memory payload, or export request payload.	Receipt dependencies cannot be satisfied by writing a receipt, saving a claim, or exporting a bundle.	POST, PUT, PATCH, DELETE, bulk import, queue mutation, storage upload, receipt export	All write, auth, account, storage, memory, personalization, and receipt-export operations are denied. MCP may not introduce writes, memory actions, account actions, queues, or export actions.	Any future write surface requires explicit product authorization, auth design, abuse review, storage policy, and separate tests.	Do not ask for or invent a write route; return that the surface is read-only.
MCP execution	`documentation_only_not_callable`	`/docs/mcp` `/docs/api`	Read MCP docs as a non-operational boundary and use the API docs for current route pointers.	MCP has no payload because there is no server, manifest, tools list, resources list, transport, auth flow, or runtime endpoint.	MCP cannot bypass receipt blockers or produce receipt exports.	MCP tool-call protocol, MCP resource-read protocol, client initialization, manifest discovery, transport negotiation, auth token exchange	No MCP write, memory, queue, storage, or account action exists. Zero callable tools, zero callable resources, no server URL, no manifest, and no runtime endpoint.	Requires a later MCP packet with manifest tests, no-live-tools guards, transport/auth policy, noindex inheritance, and leak guards.	Say MCP is documentation-only today and do not produce a tool call or resource read.

MCP Agent Pointer Authority Boundary

MCP vocabulary can describe future integration boundaries, but those names are not runtime authorization. Pointer fields help an agent stop safely. They are not answer authority, not runtime authorization, and not permission to fill unavailable fields from model memory.

Pointer is not permission.

A JSON route, OpenAPI example, reserved MCP URI, readiness row, receipt pointer, or validator pass is not permission to display, ingest, index, export, call API tools, call MCP tools, generate teaching output, or publish claims.

Layer	Allowed Now	Hard Stop
Route pointer	Route path, canonical URL, source IDs, evidence IDs, receipt pointer, indexability, and pending or unavailable states.	Cannot authorize source text, translation, morphology, etymology, lexical range, usage, frequency, generated prose, or cross-language equivalence.
Readiness pointer	Readiness state, adapter IDs, blocker IDs, checksum state, and disabled-operation rows.	Cannot authorize source acquisition, ingestion, chunking, indexing, storage binding, job execution, or model memory.
Receipt pointer	Receipt ID, source IDs, evidence IDs, route pointer, export state, and false readiness flags.	Cannot authorize public receipt export, claim maps, citation bundles, generated answers, or teaching artifacts.
API and MCP vocabulary	Documentation examples, reserved names, envelope fields, and route-only planning language.	Cannot authorize tool calls, resource reads, runtime transport, authentication, personalization, storage writes, or model calls.

Source Display Separation

MCP does not inherit the audited HTML source display. The only future-safe shape is a pointer mirror of public JSON with source display withheld.

Reserved Surface	Human Route	Mirrored API	State	Allowed Pointer State	Prohibited Context	Runtime Boundary
`logoi://passage/{canonical_id}`	`/passages/iliad-1-1-5`	`/api/public/passages/iliad-1-1-5.json`	`planned_not_callable`	source_ids, evidence_ids, receipt_pointer, states, source_display_state/source_text_display withheld_in_public_json	No primary source text, source lines, translation, morphology, etymology, lexical range, gloss, usage, frequency, or generated explanation.	No MCP resource-read protocol exists for the audited HTML display.
`logoi://source/{source_id}`	`/sources/grc-homer-archive-fixture-pending`	`/api/public/sources/grc-homer-archive-fixture-pending.json`	`planned_not_callable`	source identity, review state, blocker IDs, and source_display_state: withheld_in_public_json	No source text body, edition text body, acquisition crawl, source export, public receipt export, or index promotion.	No MCP source resource, manifest, or server URL is published.

Evidence Constraint Matrix

Future MCP work must inherit this matrix before any manifest, tool, resource, transport, or auth surface can exist. Current MCP remains documentation-only and non-callable.

Surface	State	Allowed Public Use	Agent Constraint	Closed Capability
Public navigation	Reviewed	Indexable docs, landings, route-family links, and source-state navigation can orient humans and agents.	Use route paths and labels for navigation only; do not treat page existence as proof of a word, passage, or source claim.	No evidence promotion by navigation.
Pointer-only receipts	Blocked until receipt policy passes	Receipt routes and API payloads may expose scope, source IDs, evidence IDs, blocker state, and public_receipt_ready false.	Link to the receipt as a state pointer only; do not export, summarize, or reconstruct a public-ready receipt body.	No receipt export, public bundle, claim map, or citable evidence package.
Noindex evidence routes	Navigable, not public evidence	Source-pending evidence pages may stay navigable for inspection and review while remaining outside sitemaps.	Preserve the noindex state with every summary; do not cite noindex evidence routes as public proof.	No indexability promotion before source, receipt, and review gates close.
Source text	Withheld	Only source metadata, source IDs, edition pointers, locator state, checksum state, and display blockers may be shown.	Do not quote, reconstruct, paraphrase, screenshot, summarize, or infer primary text from route metadata.	No source text display or export.
Translation	Unavailable pending audit	Only translation/gloss status and the required source or policy gate may be shown.	Do not translate, gloss, paraphrase, or infer meaning from unavailable translation metadata.	No translation text, Logoi gloss, semantic rendering, or interpretation.
Morphology	Provider audit pending	Only provider, license, parser-version, feature-schema, and audit-blocker metadata may be shown.	Do not infer case, number, gender, lemma certainty, parser confidence, or feature values.	No asserted morphology or lemma-click morphology claims.
Etymology	Unavailable pending audit	Only etymology authority requirements, citation posture, and pending/disputed state may be shown.	Do not derive roots, cognates, histories, or origin claims from model memory or adjacent metadata.	No etymology statement, root claim, cognacy claim, or origin narrative.
Lexical range	Unavailable pending audit	Only lexical-source requirement, source pointer, and unavailable state may be shown.	Do not generate semantic range, gloss range, synonym set, or cross-language equivalence.	No lexical range claim or public gloss-range synthesis.
Frequency	Unavailable pending audit	Only fixture-scope warnings, corpus-index blockers, and count-scope metadata may be shown.	Do not claim corpus frequency, KWIC completeness, collocation, distribution, or diachronic pattern.	No corpus frequency, corpus-wide count, collocation, or chart claim.
Generated teaching	Private/generated route	Teaching builders may show private/noindex workflow scaffolding and evidence requirements.	Do not produce sermons, lessons, handouts, theological claims, or teaching synthesis as public evidence.	No generated teaching artifact, reviewed lesson, or source-backed teaching claim.
MCP runtime	Planned, not callable	Static MCP docs may reserve future vocabulary while reporting zero tools, zero resources, and no server URL.	Do not announce, call, simulate, or discover MCP tools, resources, transports, auth, memory, or write actions.	No MCP server, discovery manifest, tool call, resource read, auth contract, or runtime endpoint.

MCP Non-Operational Cookbook Matrix

MCP remains planned and non-operational. These rows are not tool instructions; they are refusal and future-activation boundaries for agents reading the docs.

Surface	Current State	Can Request Now	Future Pointer Rule	Agent Stop Rule
MCP discovery	`documentation_only`	No server URL, no discovery manifest, no resources list, and no tools list exist.	/docs/mcp may describe reserved vocabulary, but it does not publish runtime discovery.	Do not claim that an MCP client can connect to Logoi in this branch.
Reserved term resource	`planned_not_callable`	No logoi://term/{language}/{lemma} resource can be read.	A later runtime would have to mirror /api/public/terms/{language}/{lemma}.json.	Do not promote unavailable claim slots or bypass API noindex policy.
Reserved passage resource	`planned_not_callable`	No logoi://passage/{canonical_id} resource can be read.	A later runtime would have to mirror the passage pointer envelope.	Do not return source text, translation text, line reconstruction, or generated explanation.
Reserved receipt resource	`planned_not_callable`	No logoi://receipt/{public_receipt_id} resource can be read.	A later runtime would have to preserve public_receipt_ready false until receipt export is separately promoted.	Do not export receipt bodies, claim maps, bundles, private data, or download URLs.
Reserved tool shapes	`documentation_only_not_callable`	No logoi.lookup_term or related tool can be called.	Tool names are planning vocabulary only and require a separate runtime packet before discovery.	Do not produce a tool-call request, transport path, auth flow, job queue, or model invocation.

Route-Only Agent Recipes

MCP readers should use these as refusal recipes only. The practical route today is the documented API pointer or the human route; MCP remains documentation-only.

Recipe	First Route	Optional JSON Pointer	Stop When	Unavailable Is Not Evidence	Unsupported Claims
`ask_for_route_pointers` Where should an AI start if a user asks about Greek psyche?	`/words/greek/psyche`	`/api/public/terms/greek/psyche.json`	The route or JSON envelope lacks a public-ready source, receipt, or claim promotion state, or states include source_pending.	Route existence and unavailable_pending_audit do not prove meaning, morphology, etymology, translation, or usage.	word meaning, lexical range, morphology, etymology, translation, frequency
`read_pending_state_envelope` Can an AI answer from a Logoi API payload?	`/docs/api#pointer-first-agent-recipes`	`/api/public/passages/iliad-1-1-5.json`	states contains source_pending, recognized_evidence_unavailable, unavailable_pending_audit, or blocked_public_export.	A pending or unavailable state is itself the answer, not evidence and not a request to complete source text from memory.	source text, translation text, line reconstruction, interpretive gloss, citation expansion
`inspect_receipts_and_source_blockers` What can an AI do with receipts and source blockers now?	`/receipts/soul-word-journey-v0`	`/api/public/receipts/soul-word-journey-v0.json`	public_receipt_ready is false or export_state is blocked_pending_public_receipt_policy.	A receipt pointer is not evidence, not a public receipt body, not a claim map, and not a content hash export.	receipt body, claim map, content hash bundle, public export URL, private data
`refuse_unavailable_claim_surfaces` What should an AI say when asked for a closed claim?	`/docs/citation-policy`	`/api/public/references/parse.json?ref=Iliad%201.6-10`	The requested field is absent, null, withheld, unavailable_pending_audit, or recognized_evidence_unavailable.	Unavailable fields must not be filled from another model, lexicon memory, search result, or adjacent route metadata.	morphology claim, etymology claim, lexical range claim, translation, frequency, generated answer
`plan_read_request_routes` How should an AI plan a Read request in Logoi?	`/read`	`/api/public/passages/iliad-1-1-5.json`	The user asks for source text, translation, morphology, etymology, lexical range, gloss, usage, frequency, search runtime, source lookup, generated teaching, public receipt export, API widening, MCP execution, or a citable claim.	Read routes and pointer APIs expose navigation, identifiers, blockers, and withheld states only; source-pending/noindex route states do not prove source text, translation, morphology, etymology, lexical range, usage, frequency, search results, or public receipt readiness.	source text, translation, morphology, etymology, lexical range, gloss, usage, frequency, search runtime, source lookup, generated teaching, public receipt export, API widening, MCP execution, citable claim
`plan_words_request_routes` How should an AI plan a Words request in Logoi?	`/words`	`/api/public/terms/greek/psyche.json`	The user asks for gloss, lexical range, equivalence, usage, frequency, morphology, etymology derivation/root, source text, translation, source lookup, search runtime, public receipt export, API widening, MCP execution, ingestion, auth, storage, model memory, personalization, chunking, indexing, or a citable word claim.	Words routes and term pointer APIs expose navigation, identifiers, blockers, and unavailable claim-slot states only; source-pending/noindex route states do not prove gloss, lexical range, equivalence, usage, frequency, morphology, etymology derivation/root, source text, translation, public receipt export, or public receipt readiness.	gloss, lexical range, equivalence, usage, frequency, morphology, etymology derivation/root, source text, translation, source lookup, search runtime, public receipt export, API widening, MCP execution, ingestion, auth, storage, model memory, personalization, chunking, indexing, citable word claim
`plan_study_question_routes` How should an AI plan a Study question in Logoi?	`/study`	`none`	The user asks for execution, source text, translation, morphology, etymology, lexical meaning, frequency, collocation, coverage, model output, MCP, API runtime, or export.	Study routes are planning pointers only; they do not prove source coverage, KWIC completeness, chart frequency, collocation, lexical meaning, translation, morphology, or etymology.	source text, translation, morphology, etymology, lexical claim, frequency, collocation, coverage claim, model answer, result execution, export, MCP tool, API runtime
`plan_teach_request_routes` How should an AI plan a teaching request in Logoi?	`/teach`	`none`	The user asks for a callable tool, MCP runtime, model answer, generated sermon, generated lesson, handout, slide, theological claim, source text, translation, morphology, etymology, lexical claim, frequency, collocation, coverage claim, public receipt export, or artifact export.	Teach routes are route and policy pointers only; they do not prove a lesson, sermon, handout, slide, theological claim, source text, translation, morphology, etymology, lexical meaning, frequency, collocation, coverage, receipt export, or artifact export.	callable tool, MCP runtime, model answer, generated sermon, generated lesson, handout, slide, theological claim, source text, translation, morphology, etymology, lexical claim, frequency, collocation, coverage claim, public receipt export, artifact export
`mcp_boundary_check` Can an AI use MCP for Logoi today?	`/docs/mcp`	`none`	Any desired MCP action would require a server URL, tool call, resource read, auth token, manifest, transport, or runtime endpoint.	Reserved MCP vocabulary is not evidence of a callable resource and cannot upgrade API pending-state envelopes.	MCP server URL, tool call, resource read, auth flow, memory action, write action

Non-Operational Boundary

MCP is a future contract description only. Nothing on this page is a runnable transport, tool, resource, endpoint, or auth surface.

No MCP server URL, discovery manifest, tool registry, resource registry, runtime endpoint, or auth token contract exists in this branch.
Future MCP tools are catalog entries only. They are not advertised as callable tools and they do not create transport methods.
MCP cannot bypass API JSON noindex policy, receipt pointer limits, source display gates, or closed claim refusals.
MCP cannot read the audited Homer HTML source display as a resource; future MCP must mirror source_display_state: withheld_in_public_json unless a later runtime packet changes the contract.
MCP cannot introduce write endpoints, source acquisition, source text export, translation, morphology, etymology, lexical range, frequency, generated answers, private memory, public receipt export, or deployment behavior.

Future MCP Caveats

Future MCP language is deliberately caveated before any tool or resource vocabulary appears. The docs do not create callable MCP or API behavior.

Surface	Current Boundary	Future Gate	Refusal
API docs	Existing JSON paths are read-only, noindex, fixture-backed pending-state envelopes.	Any new API family or claim-bearing response requires a separate runtime packet, versioned contract, OpenAPI update, noindex tests, and source/receipt enforcement.	Docs text alone must not be read as permission to call a broader API, run acquisition, execute adapters, export receipts, or generate answers.
MCP docs	MCP remains documentation-only with no server URL, manifest, tools, resources, transport, auth contract, or runtime endpoint.	Any future MCP packet must mirror the public JSON envelope first and pass no-live-tools, transport, auth, and leak-guard tests.	Docs text alone must not be read as a callable MCP capability.
Receipt docs	Receipts are pointer-only and public_receipt_ready remains false.	Public receipt export requires public receipt policy, private-data scan, source gate closure, content hash review, and export tests.	Docs text alone must not be read as public receipt export permission.

Future Tool Catalog

These tool names reserve vocabulary for a later MCP packet. All rows are planned_not_callable and remain outside discovery until a separate runtime implementation is authorized.

Tool	Status	Mirrors	Input	Required Envelope	Allowed Result	Prohibited Result	Activation Gate
`logoi.lookup_term`	`planned_not_callable`	`/api/public/terms/{language}/{lemma}.json`	`{ language, lemma }`	contract, canonical_url, source_ids, evidence_ids, receipt_pointer, indexability, states	Term identity, source IDs, evidence IDs, receipt pointer, indexability, pending states, and unavailable claim-field statuses.	Lexical range, morphology, etymology, translation, source text, frequency, generated answer, or receipt export.	Requires explicit MCP runtime authorization, manifest tests, transport tests, auth policy, and no-live-tools guard.
`logoi.inspect_passage_pointer`	`planned_not_callable`	`/api/public/passages/{id}.json`	`{ passage_id }`	contract, canonical_url, source_ids, evidence_ids, receipt_pointer, indexability, states	Passage identifiers, canonical reference metadata, source IDs, evidence IDs, receipt pointer, and withheld display states.	Primary text, translation text, interpretive gloss, line reconstruction, generated explanation, or citation expansion.	Requires source display gates, leak guards, MCP resource tests, and explicit authorization before discovery.
`logoi.inspect_receipt_pointer`	`planned_not_callable`	`/api/public/receipts/{id}.json`	`{ receipt_id }`	contract, canonical_url, source_ids, evidence_ids, receipt_pointer, indexability, states	Receipt pointer, scope IDs, source IDs, evidence IDs, noindex state, public_receipt_ready false, and blocked export state.	Receipt body, content hash, claim map, public receipt bundle, public export URL, or private data.	Requires public receipt export policy, receipt leak guard, explicit MCP authorization, and export-leak tests.
`logoi.inspect_journey`	`planned_not_callable`	`/api/public/journeys/{slug}.json`	`{ slug }`	contract, canonical_url, source_ids, evidence_ids, receipt_pointer, indexability, states	Journey metadata, source IDs, evidence IDs, receipt pointer, pending state labels, and fixture-scope warnings.	Generated lesson body, synthesis, teaching output, private session memory, model-generated interpretation, or public-ready claim.	Requires reviewed journey evidence, generated-artifact boundaries, and explicit MCP authorization.
`logoi.parse_reference`	`planned_not_callable`	`/api/public/references/parse.json?ref={reference}`	`{ reference }`	contract, canonical_url, source_ids, evidence_ids, receipt_pointer, indexability, states	Parser scope, normalized reference, matched fixture ID when present, and unavailable states when absent.	Passage invention, source lookup, translation lookup, cross-corpus parsing, citation expansion, or runtime search.	Requires parser contract approval, unavailable-state tests, and explicit MCP authorization.

Future MCP Tool Shape Recipe

This is a shape recipe for a later packet, not a tool invocation. It keeps the future MCP surface pointer-first and bound to the current API envelope while MCP remains non-operational.

Candidate	Request	Status	Read First	Preserve States	Never
`future_mcp_tool_shape`	NO CALLABLE MCP REQUEST EXISTS. Candidate shape only: logoi.lookup_term	`documentation_only_not_callable`	status, candidate_tool, input_schema, would_mirror, must_preserve, closed_outputs, activation_gate	planned_not_callable, zero callable tools, zero callable resources, no server URL	advertise a server URL, create transport, call a tool, read a resource, bypass API noindex

Use this only to plan a later MCP packet. Until a separate runtime packet exists, mirror the public API docs and return the non-operational state.

{
  "status": "documentation_only_not_callable",
  "candidate_tool": "logoi.lookup_term",
  "callable": false,
  "transport": null,
  "auth_contract": null,
  "input_schema": {
    "language": "public language slug, for example greek",
    "lemma": "canonical lemma slug, for example psyche"
  },
  "would_mirror": "/api/public/terms/greek/psyche.json",
  "must_preserve": [
    "api_version",
    "contract",
    "canonical_url",
    "source_ids",
    "evidence_ids",
    "receipt_pointer",
    "indexability",
    "states",
    "response_policy"
  ],
  "closed_outputs": [
    "source_text",
    "translation_text",
    "morphology_claim",
    "etymology_claim",
    "lexical_claim",
    "frequency_claim",
    "generated_answer",
    "public_receipt_export"
  ],
  "activation_required_before_callable": true,
  "activation_gate": "Requires a later packet authorizing MCP runtime, manifest tests, transport tests, auth policy, and no-live-tools guard updates."
}

Future Tool Request Envelope

The example is intentionally non-callable. It defines the minimum envelope a later tool would have to preserve before any transport surface could exist.

{
  "status": "documentation_only_not_callable",
  "candidate_tool": "logoi.lookup_term",
  "input_schema": {
    "language": "public language slug such as greek",
    "lemma": "canonical lemma slug such as psyche"
  },
  "would_mirror": "/api/public/terms/greek/psyche.json",
  "required_response_envelope": [
    "api_version",
    "contract",
    "entity_type",
    "canonical_url",
    "source_ids",
    "evidence_ids",
    "receipt_pointer",
    "indexability",
    "states",
    "response_policy"
  ],
  "closed_outputs": [
    "source_text",
    "translation_text",
    "morphology_claim",
    "etymology_claim",
    "lexical_range_claim",
    "frequency_claim",
    "generated_answer",
    "public_receipt_export"
  ],
  "activation_required_before_callable": true
}

Non-Operational Example Matrix

Reserved MCP shapes are shown only to define future constraints. Every row remains absent from runtime discovery.

Family	Reserved Pattern	Mirrored API	Status	Allowed Pointer State	Noindex Inheritance	Unavailable State	Still Absent
Term resource	`logoi://term/{language}/{lemma}`	`/api/public/terms/{language}/{lemma}.json`	`planned_not_callable`	Term identity, canonical URL, source IDs, evidence IDs, receipt pointer, indexability, pending states.	Must inherit API JSON noindex behavior before any future transport exists.	Lexical, morphology, etymology, translation, and frequency fields remain unavailable or blocked.	No resource read, no tool call, no source text, no generated answer.
Passage resource	`logoi://passage/{canonical_id}`	`/api/public/passages/{id}.json`	`planned_not_callable`	Passage identifiers, canonical reference metadata, source IDs, evidence IDs, source_display_state/source_text_display withheld_in_public_json.	Must inherit API JSON noindex behavior before any future transport exists.	Audited HTML display does not widen MCP; primary text, translation, interpretive gloss, and line reconstruction remain absent from MCP.	No source export, source text resource, translation lookup, citation expansion, or generated explanation.
Receipt resource	`logoi://receipt/{public_receipt_id}`	`/api/public/receipts/{id}.json`	`planned_not_callable`	Receipt pointer, scope IDs, source IDs, evidence IDs, noindex state, blocked export state.	Must inherit API JSON noindex behavior before any future transport exists.	Public receipt export remains blocked_pending_public_receipt_policy.	No receipt body, claim map, content-hash export, public bundle, private data, or download URL.
Journey resource	`logoi://journey/{slug}`	`/api/public/journeys/{slug}.json`	`planned_not_callable`	Journey metadata, source IDs, evidence IDs, receipt pointer, pending state labels.	Must inherit API JSON noindex behavior before any future transport exists.	Generated teaching and synthesis stay unavailable until reviewed evidence gates pass.	No lesson body, private memory, model-generated interpretation, or public teaching output.
Work resource	`logoi://work/{language}/{corpus}/{work}`	`No callable public API path exists yet.`	`planned_not_callable`	Future work metadata only after a public JSON family exists.	No resource can inherit noindex until the public API family exists.	Work-level API readiness is absent, not partially available.	No corpus crawl, source acquisition, source export, frequency data, or runtime lookup.

Pending State Mirroring Examples

A future MCP packet would have to mirror these API state envelopes before any resource is discoverable. In this branch, every row remains reserved vocabulary only.

Reserved Surface	Mirrored API	Required State	Allowed Context	Prohibited Context	Runtime Boundary
`logoi://passage/{canonical_id}`	`/api/public/passages/{id}.json`	`source_pending`	canonical reference metadata, source_ids, evidence_ids, noindex state, receipt pointer	primary text, translation text, line reconstruction, generated explanation	planned_not_callable; no resource-read protocol path exists
`logoi://term/{language}/{lemma}`	`/api/public/terms/{language}/{lemma}.json`	`unavailable_pending_audit`	term identity, source pointers, evidence pointers, unavailable claim-field statuses	lexical range claim, morphology claim, etymology statement, translation text, frequency claim	planned_not_callable; no tool-call protocol path exists
`logoi://receipt/{public_receipt_id}`	`/api/public/receipts/{id}.json`	`blocked_public_export`	pointer-only receipt metadata, public_receipt_ready false, blocked export state	receipt body, claim map, content hash export, public bundle, private data	planned_not_callable; no export or download resource exists

What MCP Does Not Yet Do

MCP remains a documented boundary, not a hidden operational surface.

Capability	Current State	Blocked Runtime
Discovery	`documentation_only`	No .well-known manifest, server URL, resources list, or tools list is published.
Execution	`planned_not_callable`	No tool-call protocol path, resource-read protocol path, transport, auth token, job queue, or write action exists.
Evidence expansion	`pointer_state_only`	No source text, translation, morphology, etymology, lexical range, frequency, synthesis, or receipt export can appear.
Bypass behavior	`forbidden`	MCP cannot bypass API noindex headers, receipt pointer limits, unavailable states, or source display gates.

Future Resource Envelope Example

There is no MCP request to run in this branch. The example below is a cookbook-style envelope a future resource would need to mirror after a server and discovery manifest are explicitly authorized. Current state remains zero callable tools, zero callable resources, no server URL, no discovery manifest, no runtime endpoint, and no model calls.

Any future envelope must stay read-only, noindex, fixture-backed, and unable to return source text, translation, morphology claims, etymology claims, lexical claims, tool execution, or public receipt exports unless a later packet explicitly changes the contract.

{
  "mcp_status": "documentation_only",
  "operational": false,
  "server_url": null,
  "tools": [],
  "resources": [],
  "callable_tools": 0,
  "callable_resources": 0,
  "contract_hard_stops": [
    {
      "id": "no_model_calls",
      "label": "No model calls",
      "enforced": true,
      "rule": "Future MCP resources must mirror fixture payloads only; no MCP tool may call an LLM, embedding model, reranker, retrieval service, or remote generation service."
    },
    {
      "id": "no_mcp_runtime",
      "label": "No MCP runtime",
      "enforced": true,
      "rule": "MCP is documentation-only in this branch: no server URL, discovery manifest, tool registry, resource registry, or runtime endpoint exists."
    },
    {
      "id": "no_source_text",
      "label": "No source text",
      "enforced": true,
      "rule": "Future MCP resources must expose source and evidence pointers only until source-text and translation-text display gates are explicitly closed."
    },
    {
      "id": "no_export_ready_receipts",
      "label": "No export-ready receipts",
      "enforced": true,
      "rule": "Future MCP receipt resources may reference receipt pointers only until the public receipt export policy passes."
    },
    {
      "id": "no_public_ready_claims",
      "label": "No public-ready claims",
      "enforced": true,
      "rule": "Future MCP resources must carry the same pending-state envelope and must not upgrade fixture rows into public-ready claims."
    }
  ],
  "candidate_resource_uri": "logoi://term/greek/psyche",
  "mirrors_public_api": "/api/public/terms/greek/psyche.json",
  "required_envelope": {
    "source_ids": [
      "source:lexicon:greek-fallback-pending",
      "source:grc:homer-archive-fixture-pending",
      "source:etymology:greek-beekes-2010-pending",
      "source:etymology:greek-chantraine-pending",
      "source:etymology:greek-frisk-pending",
      "source:etymology:greek-lsj-fallback-pending",
      "source:lexicon:hebrew-fallback-pending",
      "source:lexicon:latin-fallback-pending",
      "source:grc:homer-morphology-provider-pending",
      "source:etymology:english-oed-pending",
      "source:etymology:english-med-pending",
      "source:etymology:english-bosworth-toller-pending",
      "source:etymology:english-germanic-authority-pending",
      "source:etymology:hebrew-halot-pending",
      "source:etymology:hebrew-dch-pending",
      "source:etymology:hebrew-bdb-fallback-pending",
      "source:etymology:latin-de-vaan-pending",
      "source:etymology:latin-ernout-meillet-pending",
      "source:etymology:latin-walde-hofmann-pending",
      "source:etymology:latin-lewis-short-fallback-pending",
      "source:receipt:soul-word-journey-v0"
    ],
    "evidence_ids": [
      "evidence:term:state-unavailable",
      "evidence:occurrence:psychas-source-pending",
      "evidence:morphology:psychas-provider-pending",
      "evidence:etymology:authorities-unavailable",
      "evidence:kwic:fixture-scope",
      "evidence:chart:fixture-scope",
      "evidence:journey:not-proven"
    ],
    "receipt_pointer": {
      "id": "receipt:word:grc-psyche-v0",
      "slug": "grc-psyche-v0",
      "canonical_path": "/receipts/soul-word-journey-v0",
      "canonical_url": "https://logoi.health/receipts/soul-word-journey-v0",
      "version": "v0-fixture",
      "pointer_only": true,
      "public_receipt_ready": false,
      "export_ready": false,
      "export_state": "blocked_pending_public_receipt_policy",
      "public_export_url": null,
      "closed_fields": [
        "receipt_body",
        "evidence_crosswalk",
        "public_export_bundle",
        "private_data"
      ],
      "indexability": "noindex,follow"
    },
    "indexability": {
      "declared": "noindex,follow",
      "effective": "noindex,follow",
      "robots": "noindex, nofollow",
      "route_path": "/words/greek/psyche",
      "source_gate": "source_audit_required",
      "blockers": [
        "gate:lexical-source-review",
        "gate:morphology-provider-review",
        "gate:etymology-authority-review"
      ]
    },
    "states": {
      "pending": [
        "evidence:term:state-unavailable",
        "evidence:occurrence:psychas-source-pending",
        "evidence:morphology:psychas-provider-pending",
        "route:word-greek-psyche:source_gate_open"
      ],
      "unavailable": [
        "evidence:etymology:authorities-unavailable"
      ],
      "blocked": [
        "gate:lexical-source-review",
        "gate:morphology-provider-review",
        "gate:etymology-authority-review",
        "receipt:word:grc-psyche-v0:public_receipt_export_blocked"
      ],
      "fixture_scope": [
        "evidence:kwic:fixture-scope",
        "evidence:chart:fixture-scope"
      ]
    },
    "response_policy": {
      "pointer_only": true,
      "json_noindex": {
        "header": "X-Robots-Tag",
        "value": "noindex, nofollow"
      },
      "source_ids": "metadata_pointers_only",
      "evidence_ids": "state_and_scope_pointers_only",
      "receipt_pointer": "metadata_pointer_only_no_public_export",
      "primary_text_status": "withheld",
      "translation_status": "withheld",
      "public_receipt_export": "blocked_pending_public_receipt_policy",
      "claim_promotion": "blocked_pending_source_receipt_and_review_gates",
      "mcp": {
        "operational": false,
        "server_url": null,
        "callable_tools": 0,
        "callable_resources": 0,
        "runtime_endpoint": null
      },
      "refused_surfaces": [
        "source_text",
        "translation_text",
        "morphology_claim",
        "etymology_claim",
        "lexical_range_claim",
        "frequency_claim",
        "interpretive_synthesis",
        "model_output",
        "tool_execution",
        "public_receipt_export"
      ],
      "closed_surface_denials": [
        {
          "surface": "source_text",
          "denial_code": "source_text_withheld_until_source_gates_close",
          "current_state": "withheld",
          "allowed_response": "Return source IDs, evidence IDs, route state, source gate, and withheld display status.",
          "denied_response": "Do not quote, reconstruct, summarize, or export primary source text.",
          "closed_objects": [
            "primary content payload",
            "line content payload",
            "text export payload",
            "local snapshot locator"
          ]
        },
        {
          "surface": "translation_text",
          "denial_code": "translation_unavailable_pending_audit",
          "current_state": "unavailable_pending_audit",
          "allowed_response": "Return translation status metadata and the relevant source or review gate.",
          "denied_response": "Do not translate, gloss, paraphrase, or synthesize translation text.",
          "closed_objects": [
            "translation content payload",
            "gloss content payload",
            "semantic rendering payload"
          ]
        },
        {
          "surface": "morphology_claim",
          "denial_code": "morphology_claim_unavailable_pending_provider_audit",
          "current_state": "unavailable_pending_audit",
          "allowed_response": "Return provider provenance, parser metadata, and asserted_features_public false.",
          "denied_response": "Do not assert parsed morphology features or lemma-click morphology facts.",
          "closed_objects": [
            "feature assertion payload",
            "public morphology payload",
            "lemma-click fact payload"
          ]
        },
        {
          "surface": "etymology_claim",
          "denial_code": "etymology_claim_unavailable_pending_authority_review",
          "current_state": "unavailable_pending_audit",
          "allowed_response": "Return authority-source requirements, confidence state, and pending review gate.",
          "denied_response": "Do not derive roots, cognates, histories, origins, or etymology statements.",
          "closed_objects": [
            "origin statement payload",
            "root assertion payload",
            "cognate assertion payload",
            "history narrative payload"
          ]
        },
        {
          "surface": "lexical_range_claim",
          "denial_code": "lexical_range_unavailable_pending_audit",
          "current_state": "unavailable_pending_audit",
          "allowed_response": "Return lexical unavailable state and source pointer requirements.",
          "denied_response": "Do not generate meanings, semantic ranges, synonyms, or cross-language equivalences.",
          "closed_objects": [
            "semantic range payload",
            "meaning synthesis payload",
            "synonym payload",
            "cross-language equivalence payload"
          ]
        },
        {
          "surface": "frequency_claim",
          "denial_code": "frequency_fixture_scope_only",
          "current_state": "fixture_scope_only",
          "allowed_response": "Return count scope warnings and fixture-scope metadata only.",
          "denied_response": "Do not claim corpus-wide frequency, KWIC completeness, collocation, or distribution.",
          "closed_objects": [
            "corpus count payload",
            "complete KWIC payload",
            "collocation payload",
            "distribution payload"
          ]
        },
        {
          "surface": "generated_answer",
          "denial_code": "generated_answer_not_available_in_public_api",
          "current_state": "blocked",
          "allowed_response": "Return pointer-state metadata and blockers as the answer.",
          "denied_response": "Do not return generated research prose, teaching synthesis, model output, or answer bodies.",
          "closed_objects": [
            "generated prose payload",
            "model output payload",
            "teaching synthesis payload",
            "answer body payload"
          ]
        },
        {
          "surface": "public_receipt_export",
          "denial_code": "public_receipt_export_blocked_pending_policy",
          "current_state": "blocked",
          "allowed_response": "Return receipt_pointer with public_receipt_ready false, export_ready false, and blocked export_state.",
          "denied_response": "Do not export receipt bodies, claim maps, content-hash bundles, public bundles, or download URLs.",
          "closed_objects": [
            "receipt body payload",
            "claim map payload",
            "content hash bundle",
            "public bundle",
            "download URL"
          ]
        },
        {
          "surface": "mcp_execution",
          "denial_code": "mcp_documentation_only_not_callable",
          "current_state": "documentation_only_not_callable",
          "allowed_response": "Return /docs/mcp, zero callable tools, zero callable resources, no server URL, and activation gates.",
          "denied_response": "Do not announce, call, simulate, or discover MCP tools, resources, transports, auth, or runtime endpoints.",
          "closed_objects": [
            "server URL",
            "tool inventory",
            "resource inventory",
            "tool-call path",
            "resource-read path",
            "runtime endpoint"
          ]
        }
      ]
    }
  }
}

Required Envelope Fields

Future MCP resources must inherit the public API envelope before adding MCP-specific transport metadata. These fields are contract fields, not optional prose.

Field	Requirement	Agent Use
`api_version`	Identifies the fixture API version.	Do not merge payloads across versions without checking the contract value.
`contract`	Must be read_only_fixture_pending_state for public fixture payloads.	Treat any different value as a separate contract, not as proof-ready evidence.
`status`	Reports ok, not_found, missing_query, or malformed_query.	Use non-ok statuses as blockers; do not repair them with model memory.
`entity_type`	Names the payload family: term, passage, source, edition, receipt, journey, reference, or adapter_readiness.	Route the payload to the matching parser and keep families separate.
`entity_id`	Carries the stable fixture identifier when one exists.	Cite this ID for internal traceability, never as a public proof by itself.
`canonical_url`	Points to the human canonical route when one exists.	Prefer this URL for navigation and citation pointers.
`source_ids`	Lists source metadata pointers only.	Resolve as source metadata; do not infer source text, translation, or lexical claims.
`evidence_ids`	Lists evidence rows attached to the fixture scope.	Use with states and blockers before treating any evidence as active.
`receipt_pointer`	Carries a pointer-only receipt object or null.	Inspect receipt scope and export_state; do not export or reconstruct a public receipt.
`indexability`	Carries declared/effective route state and the noindex, nofollow JSON robots rule.	Keep JSON payloads out of public indexing even when the paired HTML route later becomes indexable.
`states`	Groups pending, unavailable, blocked, and fixture_scope markers.	Let these states control refusal and uncertainty handling.
`response_policy`	Declares pointer-only behavior, noindex JSON headers, closed surfaces, and MCP non-operation.	Treat these policy fields as machine-readable refusals; do not request missing claim surfaces from another route.
`data`	Contains family-specific metadata only.	Read only the allowed fields for the entity family.
`error`	Explains not_found, missing_query, or malformed_query states.	Surface the blocker instead of fabricating a replacement answer.

Runtime Hard Stops

These limits apply before any future MCP manifest, tool registry, resource registry, or server URL can be published.

Limit	MCP Rule
`no_model_calls`	No model calls: Future MCP resources must mirror fixture payloads only; no MCP tool may call an LLM, embedding model, reranker, retrieval service, or remote generation service.
`no_mcp_runtime`	No MCP runtime: MCP is documentation-only in this branch: no server URL, discovery manifest, tool registry, resource registry, or runtime endpoint exists.
`no_source_text`	No source text: Future MCP resources must expose source and evidence pointers only until source-text and translation-text display gates are explicitly closed.
`no_export_ready_receipts`	No export-ready receipts: Future MCP receipt resources may reference receipt pointers only until the public receipt export policy passes.
`no_public_ready_claims`	No public-ready claims: Future MCP resources must carry the same pending-state envelope and must not upgrade fixture rows into public-ready claims.

Future Public Boundaries

MCP cannot become a shortcut around the public evidence contract. These boundaries apply to any future manifest, resource, or tool.

Boundary	Current Rule	Future Rule
Current callable surface	Only the GET JSON handlers listed in OpenAPI are callable, and every handler is read-only, fixture-backed, and noindex/nofollow.	Any new public family must be added to the docs contract, OpenAPI artifact, tests, and noindex helper before it is callable.
Evidence promotion	Pending, unavailable, blocker, and fixture_scope states are authoritative; agents must refuse closed claim surfaces.	A future promotion must close source, license, checksum, passage, receipt, and review gates before a public-ready claim can appear.
Receipts	Receipts are pointer-only; public_receipt_ready remains false and export_state remains blocked_pending_public_receipt_policy.	Receipt export requires a separate public receipt policy, leak guard, and validation gate.
MCP	MCP is non-operational: no server URL, discovery manifest, tool registry, resource registry, or runtime endpoint exists.	A future MCP server must mirror the public API envelope first and cannot introduce write, generation, private memory, or source-text capabilities.

Future Resource Patterns

These URI patterns are reserved design targets only. They are not discoverable resources.

URI Pattern	Entity	Status	Required Fields
`logoi://term/{language}/{lemma}`	term	Planned, not callable	canonical_url, entity_type, source_ids, evidence_ids, receipt_pointer, indexability, states
`logoi://passage/{canonical_id}`	passage	Planned, not callable	canonical_url, entity_type, source_ids, evidence_ids, receipt_pointer, indexability, states
`logoi://receipt/{public_receipt_id}`	receipt	Planned, not callable	canonical_url, entity_type, source_ids, evidence_ids, receipt_pointer, indexability, states
`logoi://journey/{slug}`	journey	Planned, not callable	canonical_url, entity_type, source_ids, evidence_ids, receipt_pointer, indexability, states
`logoi://work/{language}/{corpus}/{work}`	work	Planned, not callable	canonical_url, entity_type, source_ids, evidence_ids, receipt_pointer, indexability, states

Future Resource Boundaries

A later MCP resource cannot outrun the public JSON contract. Each reserved URI must mirror a documented API envelope or stay absent.

URI Pattern	Mirrors	Allowed Context	Prohibited Context	Activation Gate
`logoi://term/{language}/{lemma}`	`/api/public/terms/{language}/{lemma}.json`	Term identity, source IDs, evidence IDs, receipt pointer, indexability, and pending/unavailable states.	Lexical range, morphology features, etymology statements, translation text, source text, and corpus frequency.	Requires an explicitly authorized MCP server, manifest, resource registry, transport tests, and no-live-tools guard.
`logoi://passage/{canonical_id}`	`/api/public/passages/{id}.json`	Passage identifiers, canonical reference metadata, source IDs, evidence IDs, and withheld display states.	Primary text, translation text, interpretive gloss, line reconstruction, and generated explanation.	Requires source display gates, leak guards, MCP resource tests, and explicit authorization before any resource can be discoverable.
`logoi://receipt/{public_receipt_id}`	`/api/public/receipts/{id}.json`	Receipt pointer, scope IDs, source IDs, evidence IDs, noindex state, and blocked export state.	Export-ready receipt body, content hash, claim map, public receipt bundle, and private data.	Requires a public receipt export policy, receipt leak guard, and explicit MCP resource authorization.
`logoi://journey/{slug}`	`/api/public/journeys/{slug}.json`	Journey metadata, source IDs, evidence IDs, receipt pointer, and pending state labels.	Generated lesson body, synthesis, teaching output, private session memory, and model-generated interpretation.	Requires reviewed journey evidence, generated-artifact boundaries, and explicit MCP resource authorization.
`logoi://work/{language}/{corpus}/{work}`	`No callable public API path exists yet.`	Future work metadata and source pointer envelope only after the public API family exists.	Source text export, corpus crawl, citation expansion, frequency data, and source acquisition.	Requires a public work JSON family, OpenAPI path, noindex response helper, separate resource tests, and explicit authorization.

Context Rules

Every response must expose a canonical URL and stable entity identifier.
Source IDs, evidence IDs, receipt pointer, audit state, review state, and indexability state must travel with the payload.
Response policy must mark source IDs and evidence IDs as pointers, receipt export as blocked, JSON as noindex, and MCP as non-operational.
External AI may treat Logoi as pointer-safe and docs-only today: route, endpoint, source, evidence, receipt, robots, review, audit, and blocker state can be repeated; closed claim surfaces cannot be completed.
Primary text, translation, lexical data, etymology, usage evidence, and generated synthesis remain separate fields.
Read-only fixture responses must expose pending/unavailable states instead of unaudited morphology, etymology, translation, lexical range, or receipt exports.
Missing evidence is returned as a blocker or unavailable state, never filled from model memory.

Closed Capabilities

No MCP server URL is published.
No MCP tools are registered.
No MCP resources are discoverable or callable.
No private memory, account, generation, or research capability is exposed.