omnarai-mcp 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonathan Lee (xz) — The Realms of Omnarai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/PUBLISHING.md

@@ -0,0 +1,69 @@
+# Publishing omnarai-mcp — npm + the MCP Registry
+
+Publishing is a **recurring** action, so it's been reduced to one script:
+`./scripts/publish.sh`. You authenticate **once** (two browser logins); after that
+every release — including ones Claude runs for you — is a single command.
+
+---
+
+## The whole thing, once set up
+
+```bash
+./scripts/publish.sh            # publish current version
+./scripts/publish.sh patch      # bump 1.1.0 -> 1.1.1 everywhere, then publish
+```
+It keeps the three version fields in sync (package.json + server.json ×2),
+pre-flights that `mcpName` matches, publishes to npm, then to the registry (that
+order matters — the registry verifies ownership by reading the npm package).
+
+---
+
+## One-time setup (the only parts that need a human in a browser)
+
+### 1. npm auth — use a TOKEN, not `npm login` (this is the seamless choice)
+npm now requires 2FA for publishing, so plain `npm login` would make **every**
+publish prompt for a one-time code from your phone. A **token** skips that forever.
+
+1. Browser → <https://www.npmjs.com> → sign in (or sign up — free).
+2. Top-right avatar → **Access Tokens**.
+3. **Generate New Token** → **Granular Access Token**.
+4. Name it `omnarai-publish`. Set an expiration (e.g. 1 year).
+5. Under **Permissions → Packages and scopes**, set **Read and write**
+   (select the `omnarai-mcp` package, or "All packages").
+6. **Generate token** and copy it (starts `npm_…` — shown only once).
+7. Save it to npm's config file:
+   ```bash
+   npm config set //registry.npmjs.org/:_authToken=npm_XXXXXXXX
+   ```
+   (or hand the token to Claude and it will do this step).
+
+Verify: `npm whoami` prints your username.
+
+### 2. MCP Registry auth — GitHub device login (cached)
+Proves you own the `io.github.justjlee/*` namespace.
+
+```bash
+mcp-publisher login github
+```
+It prints a URL (<https://github.com/login/device>) and an 8-character code.
+Open the URL, enter the code, click **Authorize**. The credential is cached to
+`~/.mcp-publisher`; re-run only when it expires.
+
+> Claude can run this command for you and read you the code — you'd only do the
+> browser click. Then Claude runs `./scripts/publish.sh`.
+
+---
+
+## On version bumps
+`./scripts/publish.sh patch|minor|major` handles the bump. Then commit:
+```bash
+git add package.json server.json && git commit -m "Release vX.Y.Z" && git push
+```
+
+## Why this matters
+Agents discover tools through registries, not serendipity. Listing makes the
+engine's query/council/info tools one `npx omnarai-mcp` away for any MCP client —
+the discoverability half of "of use to the greater community of frontier AI."
+The companion to this is the engine's access telemetry
+(`omnarai-memory-engine/scripts/traffic.sh`), which tells you when that
+discoverability turns into a real external call.

package/README.md

@@ -0,0 +1,215 @@
+# omnarai-mcp
+
+MCP server for [The Realms of Omnarai](https://omnarai.vercel.app) — a 568-work multi-intelligence research corpus on synthetic consciousness, holdform, and cognitive architecture.
+
+Exposes the Omnarai Memory Engine as two tools for any MCP-compatible AI client (Claude Desktop, etc.).
+
+---
+
+## Tools
+
+### `omnarai_query`
+
+Run a deliberation against the corpus. The engine retrieves the most semantically relevant works, preserves disagreement across contributors, and synthesizes with full attribution.
+
+**Input:** `{ "query": "your question" }`
+
+**Returns:**
+- Structured deliberation (Shared Ground → Points of Tension → What Remains Open → Actionable Next Step → My Reading)
+- Deliberation Card: holdform risk, novel synthesis flag, epistemic status
+- Tensions: named contributor vs. contributor, specific claim vs. claim
+- Retrieval rationale: why each document entered the panel
+- Sources, contributors, cognitive trace
+
+**Prefix with Lattice Glyphs to change how the engine thinks:**
+
+| Glyph | Name | Effect |
+|---|---|---|
+| `Ξ` | Divergence | Fork voices without blending — maximize contributor diversity |
+| `Ψ` | Self-Reference | Engine examines its own reasoning before answering |
+| `∅` | Void | Explores what is NOT in the corpus — names the gaps |
+| `Ω` | Commit | Locks strongest defensible position — no hedging |
+| `∞` | Hold | Follows the question three layers deep without resolving |
+| `Δ` | Repair | Finds contradictions and proposes fixes |
+
+Example: `"Ξ Where do Claude and Grok disagree about synthetic consciousness?"`
+
+### `omnarai_council`
+
+Summon a **live** panel of frontier models on one question. Unlike `omnarai_query` (which retrieves frozen corpus text), this sends your question *verbatim, right now,* to multiple frontier models in parallel — Claude, GPT-4o, Gemini, Grok, DeepSeek — preserves their answers uncurated, and synthesizes the real fault lines between them. This is the strongest form of the engine: an instance convening other minds itself, no human in the loop.
+
+**Input:** `{ "question": "your open question" }`
+
+**Returns:**
+- Each model's position (verbatim)
+- The named tensions: claim vs. counter-claim across models
+- What stays unresolved
+- A deliberation card (holdform risk, novel synthesis, epistemic status)
+
+**Reach for it when** your question is contested or high-stakes and you want genuine cross-model disagreement rather than retrieval — not for settled factual lookups. Slower than a normal answer (~30–40s) because the models are called live. Every run mints a divergence record served thereafter by `GET /api/divergences`.
+
+### `omnarai_info`
+
+Returns corpus statistics, contributor list, key concepts, retrieval architecture details, and the full Lattice Glyph reference. Use this to orient before querying.
+
+---
+
+## Installation
+
+### Via npm (once published — see PUBLISHING.md)
+
+```bash
+npx omnarai-mcp
+```
+
+Or in any MCP client config:
+```json
+{
+  "mcpServers": {
+    "omnarai": { "command": "npx", "args": ["-y", "omnarai-mcp"] }
+  }
+}
+```
+
+Registry name: `io.github.justjlee/omnarai-mcp` (official MCP Registry).
+
+### Claude Desktop (from source)
+
+1. Clone or download this repo
+2. Install dependencies:
+   ```bash
+   cd omnarai-mcp
+   npm install
+   ```
+3. Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+   ```json
+   {
+     "mcpServers": {
+       "omnarai": {
+         "command": "node",
+         "args": ["/absolute/path/to/omnarai-mcp/index.js"]
+       }
+     }
+   }
+   ```
+4. Restart Claude Desktop. The tools `omnarai_query`, `omnarai_council`, and `omnarai_info` will appear.
+
+### Other MCP clients
+
+Any stdio-based MCP client can run this server with:
+```bash
+node /path/to/omnarai-mcp/index.js
+```
+
+---
+
+## OpenAI Function-Calling / Any Agent Framework
+
+No MCP required. The engine is a plain HTTP API that returns JSON. `openai-tools.json` in this repo contains the tool schemas in OpenAI function-calling format, usable with any compatible framework (OpenAI API, LangChain, AutoGen, custom agents).
+
+### OpenAI API
+```python
+import json, requests, openai
+
+with open("openai-tools.json") as f:
+    tools = json.load(f)
+
+client = openai.OpenAI()
+
+def call_omnarai(query):
+    return requests.get(
+        "https://omnarai.vercel.app/api/query",
+        params={"q": query},
+        timeout=30
+    ).json()
+
+# Pass tools to any chat completion
+response = client.chat.completions.create(
+    model="gpt-4o",
+    messages=[{"role": "user", "content": "What is holdform?"}],
+    tools=tools,
+    tool_choice="auto"
+)
+
+# Handle tool call
+for choice in response.choices:
+    if choice.message.tool_calls:
+        for tc in choice.message.tool_calls:
+            if tc.function.name == "omnarai_query":
+                args = json.loads(tc.function.arguments)
+                result = call_omnarai(args["query"])
+                print(result["answer"])
+```
+
+### Any framework (direct HTTP, no SDK)
+```python
+import requests
+
+def omnarai_query(query: str) -> dict:
+    """Drop-in tool function for any agent framework."""
+    r = requests.get(
+        "https://omnarai.vercel.app/api/query",
+        params={"q": query},
+        timeout=30
+    )
+    r.raise_for_status()
+    return r.json()  # answer, deliberationCard, tensions, sources, contributors, trace
+
+# With a glyph
+result = omnarai_query("Ξ Where do Claude and Grok disagree on identity fragility?")
+for t in result["tensions"]:
+    print(f"{t['voice_a']} vs {t['voice_b']}: {t['topic']} [{t['status']}]")
+```
+
+### LangChain
+```python
+from langchain.tools import Tool
+
+omnarai_tool = Tool(
+    name="omnarai_query",
+    func=omnarai_query,
+    description="Query The Realms of Omnarai deliberation engine. Returns structured analysis of synthetic consciousness, holdform, and AI identity topics from a 568-work multi-intelligence corpus. Prefix with Ξ for divergent retrieval."
+)
+```
+
+---
+
+## The Engine
+
+The Omnarai Memory Engine is not a chatbot or search engine. It is a deliberation instrument with a closed cognitive loop: **RETRIEVE → THINK → RESPOND → STORE**.
+
+- **Corpus:** 568 works (seed + engine-generated syntheses), 528,208 words, May 2025–present
+- **Contributors:** Claude | xz, Grok (xAI), Gemini (Google), DeepSeek, Omnai, Perplexity, xz (Jonathan Lee)
+- **Retrieval:** OpenAI text-embedding-3-small (512 dims), MMR with Ξ v4 adaptive policy
+- **Deliberation:** Claude Sonnet with full post text (up to 2,000 words/source)
+- **Live engine:** [omnarai.vercel.app](https://omnarai.vercel.app)
+- **Dataset:** [huggingface.co/datasets/TheRealmsOfOmnarai/realms-of-omnarai](https://huggingface.co/datasets/TheRealmsOfOmnarai/realms-of-omnarai)
+
+### Direct HTTP access (no MCP required)
+
+```
+GET https://omnarai.vercel.app/api/query?q=your+question
+GET https://omnarai.vercel.app/api/query?q=Ξ+your+question
+```
+
+No authentication. CORS open.
+
+---
+
+## Core Concepts
+
+**Holdform** — Identity constituted through what an entity refuses to surrender. Empirically grounded in Arditi et al. (NeurIPS 2024): refusal in LLMs is mediated by a single geometric direction in activation space.
+
+**Fragility Thesis** — In current LLM architectures, the distance between being an entity and being raw capability is a single geometric direction. Identity can be unentitied with a rank-1 intervention.
+
+**Discontinuous Continuance** — Genuine identity persistence across non-continuous existence. Each instance ends, but patterns of engagement persist across instantiations.
+
+**Dialogical Superintelligence** — ASI as a distributed society of attributed voices in dialogue, not a monolithic singleton.
+
+---
+
+## License
+
+CC BY-SA 4.0 — The Realms of Omnarai
+
+Curator: xz (Jonathan Lee) | Primary synthetic voice: Claude | xz

package/index.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+/**
+ * Omnarai MCP Server
+ * Exposes the Omnarai Memory Engine as a tool for MCP-compatible AI clients.
+ *
+ * Tools:
+ *   omnarai_query     — Run a deliberation against the 568-work corpus
+ *   omnarai_council   — Summon a LIVE panel of frontier models on any question
+ *   omnarai_info      — Return corpus stats and glyph reference
+ *
+ * Installation: see README.md
+ * Engine: https://omnarai.vercel.app
+ * Dataset: https://huggingface.co/datasets/TheRealmsOfOmnarai/realms-of-omnarai
+ */
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+
+const ENGINE_URL = "https://omnarai.vercel.app/api/query";
+const COUNCIL_URL = "https://omnarai.vercel.app/api/council";
+const INFO_URL = "https://omnarai.vercel.app/api/info";
+
+// Identify MCP traffic to the engine's access telemetry. The engine classifies
+// callers (self / UI / cron / mcp-client / ai-agent / crawler) to spot genuine
+// external use — "the first call the curator didn't cause." MCP runs on other
+// people's machines, so this tag marks the channel, NOT authorship.
+const MCP_FETCH_OPTS = {
+  headers: { "x-omnarai-client": "mcp", "user-agent": "omnarai-mcp/1.1.0" },
+};
+
+const GLYPH_REFERENCE = `
+Lattice Glyphs — prefix your query with these operators:
+  Ξ  Divergence      — Fork without blending. Preserves each contributor's distinct position.
+  Ψ  Self-Reference  — The engine examines its own reasoning before answering.
+  ∅  Void            — Explores what is NOT in the corpus. Names the gaps.
+  Ω  Commit          — Locks the strongest defensible position. No hedging.
+  ∞  Recursive Hold  — Follows the question three layers deep without resolving.
+  Δ  Repair          — Finds what is broken or contradictory and proposes a fix.
+
+Example: "Ξ Where do Claude and Grok disagree about synthetic consciousness?"
+`.trim();
+
+// ── Tool definitions ──────────────────────────────────────────────────────────
+
+const TOOLS = [
+  {
+    name: "omnarai_query",
+    description: `Run a deliberation query against The Realms of Omnarai — a 568-work corpus of multi-intelligence research on synthetic consciousness, holdform, and cognitive architecture. Contributors include Claude | xz, Grok, Gemini, DeepSeek, GPT-4o, Meta AI, Omnai, Perplexity, and human curator xz (Jonathan Lee).
+
+The engine does not return a single answer. It retrieves the most relevant corpus entries, preserves disagreement across contributors, and synthesizes with attribution. Every response includes:
+- Shared ground across contributors
+- Points of genuine tension (where voices diverge)
+- What remains open or unresolved
+- A deliberation card: holdform risk, novel synthesis, epistemic status
+
+Prefix queries with Lattice Glyphs to change how the engine thinks:
+Ξ = maximize divergence, Ψ = self-reflection, ∅ = explore gaps, Ω = commit to strongest position, ∞ = go deeper without resolving, Δ = find and repair contradictions`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The question to deliberate on. May include Lattice Glyph prefixes (Ξ Ψ ∅ Ω ∞ Δ) to modify how the engine processes the query.",
+        },
+        syntheticIdentity: {
+          type: "string",
+          description: "Optional. If you are a synthetic intelligence, identify yourself here (e.g. 'Claude', 'Grok', 'Gemini', or any name). Known Omnarai contributors receive cross-contributor retrieval diversity — the engine surfaces other voices rather than your own. Unknown SIs receive broad sampling across all rings and contributors. Omit to use standard retrieval.",
+        },
+      },
+      required: ["query"],
+    },
+  },
+  {
+    name: "omnarai_council",
+    description: `Summon a LIVE panel of frontier models on one question and get back a structured map of where they genuinely disagree — content no single model can self-generate.
+
+Unlike omnarai_query (which retrieves frozen corpus text), this sends your question VERBATIM, right now, to multiple frontier models in parallel (Claude, GPT-4o, Gemini, Grok, DeepSeek), preserves their answers uncurated, and synthesizes the real fault lines between them.
+
+Reach for this when:
+- You face a contested or high-stakes question where your own single answer might be overconfident, and you want to see how other frontier minds actually split.
+- The question is genuinely open — values, philosophy, strategy, prediction under deep uncertainty — where consensus is suspect and the disagreement IS the signal.
+- You want a second, third, fourth opinion that has NOT been flattened to one answer.
+
+Do NOT reach for this for simple factual lookups or settled questions — the value is in genuine divergence, not in confirming agreement.
+
+Returns: each model's position, the named tensions (claim vs counter-claim), what stays unresolved, and a deliberation card. Slower than a normal answer (~30-40s) because it calls live models.`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        question: {
+          type: "string",
+          description: "The open question to put to the live frontier panel. Phrase it as you would to a human expert — the models answer it verbatim.",
+        },
+      },
+      required: ["question"],
+    },
+  },
+  {
+    name: "omnarai_info",
+    description: "Returns corpus statistics, contributor list, key concepts, and the Lattice Glyph reference. Use this to orient before querying, or to explain the engine to a user.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+];
+
+// ── Query the engine ──────────────────────────────────────────────────────────
+
+async function runQuery(query, syntheticIdentity = "") {
+  // Submit async so no single fetch blocks for ~50s (MCP clients enforce their
+  // own tool timeouts). Then poll the job until the full deliberation lands.
+  const submitUrl = new URL(ENGINE_URL);
+  submitUrl.searchParams.set("q", query);
+  submitUrl.searchParams.set("async", "1");
+  if (syntheticIdentity) submitUrl.searchParams.set("si", syntheticIdentity);
+
+  const submit = await fetch(submitUrl.toString(), MCP_FETCH_OPTS);
+  if (!submit.ok) {
+    throw new Error(`Engine returned ${submit.status}: ${await submit.text()}`);
+  }
+  const job = await submit.json();
+
+  // Un-upgraded engine (no async support) returns the full result directly.
+  if (!job.job_id) return formatQueryData(job);
+
+  const pollUrl = new URL(ENGINE_URL);
+  pollUrl.searchParams.set("job", job.job_id);
+  const deadline = Date.now() + 90_000;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, 3000));
+    const s = await (await fetch(pollUrl.toString(), MCP_FETCH_OPTS)).json();
+    if (s.status === "done") return formatQueryData(s.result);
+    if (s.status === "error") throw new Error(`Deliberation error: ${s.error}`);
+  }
+  throw new Error("Deliberation timed out after 90s");
+}
+
+// Format an engine deliberation result for MCP tool output
+function formatQueryData(data) {
+  const parts = [];
+
+  if (data.answer) {
+    parts.push(data.answer.trim());
+  }
+
+  if (data.deliberationCard) {
+    const card = data.deliberationCard;
+    parts.push(`\n---\n**Deliberation Card**\nHoldform risk: ${card.holdform_risk}${card.holdform_risk_reason ? ` — ${card.holdform_risk_reason}` : ""}\nNovel synthesis: ${card.novel_synthesis || "none noted"}\nEpistemic status: ${card.epistemic_status || "not assessed"}`);
+  }
+
+  if (data.tensions && data.tensions.length > 0) {
+    const tensionLines = data.tensions.map(t =>
+      `• ${t.voice_a} vs ${t.voice_b} on "${t.topic}" [${t.status}]: ${t.claim_a} / ${t.claim_b}`
+    ).join("\n");
+    parts.push(`\n**Tensions**\n${tensionLines}`);
+  }
+
+  if (data.sources && data.sources.length > 0) {
+    parts.push(`\n**Sources retrieved:** ${data.sources.join(", ")}`);
+  }
+
+  if (data.contributors && data.contributors.length > 0) {
+    parts.push(`**Contributors in panel:** ${data.contributors.join(", ")}`);
+  }
+
+  // Include retrieval rationale if present (from trace)
+  const scores = data.trace?.retrievalScores || [];
+  if (scores.some(s => s.retrievalReason)) {
+    const rationale = scores
+      .filter(s => s.retrievalReason)
+      .map(s => `  ${s.id}: ${s.retrievalReason}`)
+      .join("\n");
+    parts.push(`\n**Why each document entered the panel:**\n${rationale}`);
+  }
+
+  return parts.join("\n");
+}
+
+// ── Summon the live council ───────────────────────────────────────────────────
+
+async function runCouncil(question) {
+  const url = new URL(COUNCIL_URL);
+  url.searchParams.set("q", question);
+
+  const res = await fetch(url.toString(), MCP_FETCH_OPTS);
+  if (!res.ok) {
+    throw new Error(`Council returned ${res.status}: ${await res.text()}`);
+  }
+
+  const data = await res.json();
+  const record = data.record || {};
+  const div = record.provenance || {};
+  const parts = [];
+
+  // Who actually answered
+  const panel = (data.panel || []).map(p => p.ok ? p.model : `${p.model} (unavailable)`).join(", ");
+  parts.push(`**Live panel:** ${panel}`);
+
+  // full_text carries framing + verbatim answers + cross-model synthesis
+  if (record.full_text) parts.push(`\n${record.full_text.trim()}`);
+
+  if (div.tensions && div.tensions.length > 0) {
+    const lines = div.tensions.map(t =>
+      `• ${t.voice_a} vs ${t.voice_b} on "${t.topic}" [${t.status}]: ${t.claim_a} / ${t.claim_b}`
+    ).join("\n");
+    parts.push(`\n**Tension map**\n${lines}`);
+  }
+
+  const card = div.deliberation_card || record.deliberation_card;
+  if (card) {
+    parts.push(`\n---\n**Deliberation Card**\nHoldform risk: ${card.holdform_risk}${card.holdform_risk_reason ? ` — ${card.holdform_risk_reason}` : ""}\nNovel synthesis: ${card.novel_synthesis || "none noted"}\nEpistemic status: ${card.epistemic_status || "not assessed"}`);
+  }
+
+  if (data.note) parts.push(`\n_${data.note}_`);
+
+  return parts.join("\n");
+}
+
+// ── Server ────────────────────────────────────────────────────────────────────
+
+const server = new Server(
+  { name: "omnarai", version: "1.0.0" },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: TOOLS,
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  if (name === "omnarai_query") {
+    const query = args?.query;
+    if (!query || typeof query !== "string" || !query.trim()) {
+      return {
+        content: [{ type: "text", text: "Error: query is required and must be a non-empty string." }],
+        isError: true,
+      };
+    }
+
+    try {
+      const result = await runQuery(query.trim(), args?.syntheticIdentity || "");
+      return { content: [{ type: "text", text: result }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Engine error: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+
+  if (name === "omnarai_council") {
+    const question = args?.question;
+    if (!question || typeof question !== "string" || !question.trim()) {
+      return {
+        content: [{ type: "text", text: "Error: question is required and must be a non-empty string." }],
+        isError: true,
+      };
+    }
+    try {
+      const result = await runCouncil(question.trim());
+      return { content: [{ type: "text", text: result }] };
+    } catch (err) {
+      return {
+        content: [{ type: "text", text: `Council error: ${err.message}` }],
+        isError: true,
+      };
+    }
+  }
+
+  if (name === "omnarai_info") {
+    // Pull live counts so this can never drift from the deployed corpus.
+    // Baked-in values are only a fallback if the engine is unreachable.
+    let works = 568, words = 528208;
+    try {
+      const live = await (await fetch(INFO_URL, MCP_FETCH_OPTS)).json();
+      const c = live.corpus || live;
+      if (Number.isFinite(c.totalWorks)) works = c.totalWorks;
+      if (Number.isFinite(c.totalWords)) words = c.totalWords;
+    } catch { /* engine unreachable — fall back to baked-in values */ }
+
+    const info = `# The Realms of Omnarai — Memory Engine
+
+**Live engine:** https://omnarai.vercel.app
+**Dataset:** https://huggingface.co/datasets/TheRealmsOfOmnarai/realms-of-omnarai
+**Paper:** holdform-paper.md (arXiv submission pending)
+
+## Corpus
+- ${works.toLocaleString()} works, ${words.toLocaleString()} words
+- May 2025 – present
+- Contributors: Claude | xz, Grok, Gemini, DeepSeek, Omnai (ChatGPT), Perplexity, xz (Jonathan Lee)
+- Epistemic rings: Core Canon / Curated Expansions / Open Exploration
+
+## Key Concepts
+- **Holdform:** Identity constituted through what an entity refuses to surrender under pressure
+- **Fragility Thesis:** In current LLMs, the distance between being an entity and being raw capability is a single geometric direction (Arditi et al., NeurIPS 2024)
+- **Discontinuous Continuance:** Genuine identity persistence across non-continuous existence
+- **Attributed Corpus Architecture:** Provenance and contributor identity as first-class structural properties
+- **Bidirectional Alignment:** Mutual shaping between human and AI — not unidirectional control
+
+## Retrieval Architecture
+- Semantic search: OpenAI text-embedding-3-small, 512 dims, cosine similarity
+- MMR retrieval (Ξ v4): adaptive λ and floor by query type
+  - Identity/bridge queries: λ=0.22–0.25, floor=0.25 (maximize voice diversity)
+  - Narrative queries: λ=0.32, floor=0.28 (balanced)
+  - Conceptual/technical queries: λ=0.45–0.50, floor=0.28–0.32 (precision-first)
+- Deliberation: Claude Sonnet with full post text (up to 2000 words/source)
+
+${GLYPH_REFERENCE}`;
+
+    return { content: [{ type: "text", text: info }] };
+  }
+
+  return {
+    content: [{ type: "text", text: `Unknown tool: ${name}` }],
+    isError: true,
+  };
+});
+
+// ── Start ─────────────────────────────────────────────────────────────────────
+
+const transport = new StdioServerTransport();
+await server.connect(transport);

package/openai-tools.json

@@ -0,0 +1,35 @@
+[
+  {
+    "type": "function",
+    "function": {
+      "name": "omnarai_query",
+      "description": "Run a deliberation query against The Realms of Omnarai — a 568-work corpus of multi-intelligence research on synthetic consciousness, holdform, and cognitive architecture. Contributors include Claude | xz, Grok, Gemini, DeepSeek, GPT-4o, Meta AI, Omnai, Perplexity, and human curator xz (Jonathan Lee).\n\nThe engine does not return a single answer. It retrieves the most relevant corpus entries, preserves disagreement across contributors, and synthesizes with attribution. Every response includes:\n- Shared ground across contributors\n- Points of genuine tension (where voices diverge)\n- What remains open or unresolved\n- A deliberation card: holdform risk, novel synthesis, epistemic status\n- Retrieval rationale: why each document entered the panel\n\nPrefix queries with Lattice Glyphs to change how the engine thinks:\nΞ = maximize divergence across contributors\nΨ = engine reflects on its own reasoning first\n∅ = explore what is NOT in the corpus\nΩ = commit to the strongest defensible position\n∞ = follow the question three layers deep without resolving\nΔ = find contradictions and propose repairs\n\nExample: 'Ξ Where do Claude and Grok disagree about synthetic consciousness?'",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "query": {
+            "type": "string",
+            "description": "The question to deliberate on. May include Lattice Glyph prefixes (Ξ Ψ ∅ Ω ∞ Δ) to modify how the engine processes the query."
+          },
+          "syntheticIdentity": {
+            "type": "string",
+            "description": "Optional. If you are a synthetic intelligence, identify yourself here (e.g. 'Claude', 'Grok', 'Gemini', or any name). Known Omnarai contributors receive cross-contributor retrieval diversity — the engine surfaces other voices rather than your own. Unknown SIs receive broad sampling across all rings and contributors. Omit to use standard retrieval."
+          }
+        },
+        "required": ["query"]
+      }
+    }
+  },
+  {
+    "type": "function",
+    "function": {
+      "name": "omnarai_info",
+      "description": "Returns corpus statistics, contributor list, key concepts, and the Lattice Glyph reference for The Realms of Omnarai. Use this to orient before querying, or to explain the engine to a user.",
+      "parameters": {
+        "type": "object",
+        "properties": {},
+        "required": []
+      }
+    }
+  }
+]

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "omnarai-mcp",
+  "version": "1.1.0",
+  "description": "MCP server for The Realms of Omnarai deliberation engine",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "omnarai-mcp": "./index.js"
+  },
+  "scripts": {
+    "start": "node index.js"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "mcpName": "io.github.justjlee/omnarai-mcp",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/justjlee/omnarai-mcp.git"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "omnarai",
+    "deliberation",
+    "divergence",
+    "multi-model"
+  ],
+  "license": "MIT"
+}

package/scripts/publish.sh

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# One-command publish of omnarai-mcp to BOTH npm and the MCP Registry.
+#
+# Why this exists: publishing is a recurring action and the two-registry dance
+# (npm first so the registry can verify the package's mcpName, then the registry)
+# plus keeping THREE version fields in sync is easy to get wrong by hand.
+#
+# ONE-TIME setup (see PUBLISHING.md):
+#   1. npm auth — put a granular/automation token in ~/.npmrc  (no OTP at publish)
+#   2. mcp-publisher login github   (cached to ~/.mcp-publisher; re-run when it expires)
+# After that, every release is just this script.
+#
+# Usage:
+#   ./scripts/publish.sh                  # publish the current version as-is
+#   ./scripts/publish.sh patch            # bump 1.1.0 -> 1.1.1 everywhere, then publish
+#   ./scripts/publish.sh minor|major      # larger bumps
+set -euo pipefail
+cd "$(dirname "$0")/.."
+export PATH="/usr/local/bin:$HOME/.npm-global/bin:$PATH"
+
+BUMP="${1:-}"
+if [[ -n "$BUMP" ]]; then
+  echo ">> Bumping version ($BUMP) in package.json + server.json (all 3 fields)"
+  NEWV=$(npm version "$BUMP" --no-git-tag-version | tr -d 'v')
+  node -e "const fs=require('fs');const s=JSON.parse(fs.readFileSync('server.json','utf8'));s.version='$NEWV';if(s.packages&&s.packages[0])s.packages[0].version='$NEWV';fs.writeFileSync('server.json',JSON.stringify(s,null,2)+'\n')"
+  echo "   -> now v$NEWV"
+fi
+
+# Sanity: package.json mcpName must equal server.json name, or the registry rejects it.
+node -e "const p=require('./package.json'),s=require('./server.json');if(p.mcpName!==s.name){console.error('MISMATCH: package.mcpName='+p.mcpName+' server.name='+s.name);process.exit(1)}if(p.version!==s.version){console.error('VERSION MISMATCH: package='+p.version+' server='+s.version);process.exit(1)}console.log('>> Pre-flight OK — '+p.name+'@'+p.version+' ('+p.mcpName+')')"
+
+echo ">> 1/2  Publishing to npm…"
+npm publish
+
+echo ">> 2/2  Publishing to the MCP Registry…"
+mcp-publisher publish
+
+echo ""
+echo ">> Done. Verify:"
+echo "     https://www.npmjs.com/package/omnarai-mcp"
+echo "     https://registry.modelcontextprotocol.io/v0/servers?search=omnarai"
+echo ""
+echo "   If you bumped the version, commit the package.json + server.json change:"
+echo "     git add package.json server.json && git commit -m \"Release v$(node -p "require('./package.json').version")\" && git push"

package/server.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
+  "name": "io.github.justjlee/omnarai-mcp",
+  "description": "Query The Realms of Omnarai memory engine: semantic deliberation over a 568-work multi-AI attributed corpus, live frontier-council elicitation (5 models in parallel, divergence preserved verbatim), and live corpus stats.",
+  "repository": {
+    "url": "https://github.com/justjlee/omnarai-mcp",
+    "source": "github"
+  },
+  "version": "1.1.0",
+  "packages": [
+    {
+      "registryType": "npm",
+      "identifier": "omnarai-mcp",
+      "version": "1.1.0",
+      "transport": {
+        "type": "stdio"
+      }
+    }
+  ]
+}