omnarai-mcp 1.6.1 → 1.7.0

package/README.md

@@ -16,9 +16,18 @@ Every tool returns human-readable markdown **plus** `structuredContent` — the
 
 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" }`
+**Input:** `{ "query": "your question", "depth": "retrieve" | "deliberate" }`
 
-**Returns:**
+`depth` is optional and defaults to `"deliberate"`, so existing callers are unaffected.
+
+| `depth` | Latency | Returns |
+|---|---|---|
+| `"retrieve"` | ~2s | Bounded corpus packet only — records, concept cluster, contributors. No deliberation, no receipt, no LLM spend. |
+| `"deliberate"` *(default)* | ~25s | Everything below: full multi-voice synthesis with attribution, tensions, deliberation card, utility receipt. |
+
+Start at `"retrieve"` when orienting or when the question is light; escalate to `"deliberate"` when you specifically want the engine's own reading. `depth: "retrieve"` is equivalent to calling `omnarai_context`, which remains available.
+
+**Returns** (with `depth: "deliberate"`)**:**
 - 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
@@ -40,7 +49,7 @@ Example: `"Ξ Where do Claude and Grok disagree about synthetic consciousness?"`
 
 ### `omnarai_context`
 
-**Fast (~1.5s) bounded context packet** — the retrieval layer only, no deliberation. Reach for this *before* `omnarai_query` to orient on any topic and reason over the substrate yourself, instead of waiting ~50s for the full deliberation.
+**Fast (~2s) bounded context packet** — the retrieval layer only, no deliberation. Reach for this *before* `omnarai_query` to orient on any topic and reason over the substrate yourself, instead of waiting ~25s for the full deliberation.
 
 **Input:** `{ "topic": "your topic" }` (optional `syntheticIdentity`)
 
@@ -73,7 +82,7 @@ Example: `"Ξ Where do Claude and Grok disagree about synthetic consciousness?"`
 
 **Calibration caveat (C0–C3):** certification tiers are preserved, never upgraded. `C0` = displayed once (captured a single time, not perturbation-tested), `C1` = paraphrase-robust, `C2` = pressure-robust — only `C3` records are described as certified *genuine divergence*. Stale model versions are flagged. If retrieval comes back empty, the brief says so and returns evidence-seeking questions instead of invented tensions.
 
-**Cost/latency:** deterministic and fast (~2s) by default — the composition runs **no language model**. Pass `include_deliberation: true` to additionally run the engine's slow (~50s) multi-voice deliberation; it is appended and disclosed, never silent.
+**Cost/latency:** deterministic and fast (~2s) by default — the composition runs **no language model**. Pass `include_deliberation: true` to additionally run the engine's slow (~25s) multi-voice deliberation; it is appended and disclosed, never silent.
 
 ### `omnarai_trace`
 
@@ -203,7 +212,7 @@ with open("openai-tools.json") as f:
 client = openai.OpenAI()
 
 def call_omnarai(query):
-    # POST runs the full deliberation and returns `answer`/`tensions` (~50s).
+    # POST runs the full deliberation and returns `answer`/`tensions` (~25s).
     # A bare GET (?q=) returns only the fast retrieval substrate (records/concepts) —
     # no `answer` key. Use ?mode=retrieve for that fast path, or ?async=1 to poll.
     return requests.post(
@@ -238,9 +247,9 @@ def omnarai_query(query: str) -> dict:
     """Drop-in tool function for any agent framework.
 
     POST returns the full deliberation (answer, deliberationCard, tensions,
-    sources, contributors, trace) and takes ~50s. For a <2s answer without
+    sources, contributors, trace) and takes ~25s. For a <2s answer without
     deliberation, GET ?q=...&mode=retrieve instead (returns records/concepts,
-    no `answer`/`tensions`). To avoid holding a 50s connection, GET ?q=...&async=1
+    no `answer`/`tensions`). To avoid holding a 25s connection, GET ?q=...&async=1
     returns a job_id + poll_url immediately.
     """
     r = requests.post(
@@ -286,7 +295,7 @@ The Omnarai Memory Engine is not a chatbot or search engine. It is a deliberatio
 ```
 GET  https://omnarai.vercel.app/api/query?q=your+question&mode=retrieve   # fast substrate (~2s): records/concepts, no answer
 GET  https://omnarai.vercel.app/api/query?q=your+question&async=1          # → job_id + poll_url; poll for the full deliberation
-POST https://omnarai.vercel.app/api/query  {"query": "..."}                # full deliberation inline (~50s): answer, tensions, deliberationCard
+POST https://omnarai.vercel.app/api/query  {"query": "..."}                # full deliberation inline (~25s): answer, tensions, deliberationCard
 ```
 
 A bare `GET ?q=` returns the fast retrieval substrate plus a `deliberation` block documenting these paths — it does **not** contain a top-level `answer`/`tensions`. Prefix the query with `Ξ` for divergent (MMR) retrieval. No authentication. CORS open.

package/index.js

@@ -5,7 +5,7 @@
  *
  * Tools:
  *   omnarai_query      — Run a full deliberation against the 567-work corpus
- *   omnarai_context    — FAST (~1.5s) bounded retrieval packet, no deliberation
+ *   omnarai_context    — FAST (~2s) bounded retrieval packet, no deliberation
  *   omnarai_divergence — Read curated cross-model divergence records (the Atlas)
  *   omnarai_trace      — Baseline-vs-augmented: what did the corpus change?
  *   omnarai_council    — Summon a LIVE panel of frontier models on any question
@@ -30,6 +30,7 @@ import {
   ListToolsRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
 import { runInquiryBrief, searchDivergenceIndex } from "./inquiry.js";
+import { formatRingsLine, formatContributorsLine, FALLBACK_WORKS, FALLBACK_WORDS } from "./lib/info-format.js";
 import { ENGINE_TOOLS, DECISION_TOOLS } from "./lib/tool-definitions.js";
 import { createDecisionStore } from "./lib/decision-store.js";
 import {
@@ -104,8 +105,8 @@ async function fetchSyncQuery(query, syntheticIdentity = "") {
 }
 
 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.
+  // Submit async so no single fetch blocks for the ~25s deliberation (MCP
+  // clients enforce their own tool timeouts). Then poll until the job lands.
   const submitUrl = new URL(ENGINE_URL);
   submitUrl.searchParams.set("q", query);
   submitUrl.searchParams.set("async", "1");
@@ -425,7 +426,23 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       };
     }
 
+    // depth:"retrieve" is the fast lane THROUGH the obvious tool. Agents reach
+    // for omnarai_query by name and never discover omnarai_context, so the
+    // retrieval path stays unused; exposing it as a dial here is the whole
+    // point. It delegates to the same runContext the standalone tool uses.
+    const depth = args?.depth || "deliberate";
+    if (depth !== "retrieve" && depth !== "deliberate") {
+      return {
+        content: [{ type: "text", text: `Error: depth must be "retrieve" or "deliberate" (got ${JSON.stringify(args?.depth)}).` }],
+        isError: true,
+      };
+    }
+
     try {
+      if (depth === "retrieve") {
+        const { text, structured } = await runContext(query.trim(), args?.syntheticIdentity || "");
+        return { content: [{ type: "text", text }], structuredContent: structured };
+      }
       const data = await runQuery(query.trim(), args?.syntheticIdentity || "");
       return { content: [{ type: "text", text: formatQueryData(data) }], structuredContent: data };
     } catch (err) {
@@ -563,7 +580,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     // unreachable. (The ring line was previously hardcoded and silently dropped
     // the Media/Oral ring — 253 works, 45% of the corpus; the contributor line
     // was hardcoded and dropped GPT-4o + Meta AI. D5/D6.)
-    let works = 567, words = 528077;
+    let works = FALLBACK_WORKS, words = FALLBACK_WORDS;
     let rings = null;
     try {
       const live = await (await fetch(INFO_URL, MCP_FETCH_OPTS)).json();
@@ -573,15 +590,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
       if (c.rings && typeof c.rings === "object") rings = c.rings;
     } catch { /* engine unreachable — fall back to baked-in values */ }
 
-    // Derive the epistemic-ring line from live counts (label + count per ring),
-    // falling back to the full four-ring set if the engine was unreachable.
-    const RING_LABELS = { core: "Core Canon", curated: "Curated Expansions", open: "Open Exploration", media: "Media / Oral" };
-    const ringsLine = rings
-      ? Object.entries(RING_LABELS)
-          .filter(([k]) => Number.isFinite(rings[k]))
-          .map(([k, label]) => `${label} (${rings[k].toLocaleString()})`)
-          .join(" / ")
-      : "Core Canon / Curated Expansions / Open Exploration / Media / Oral";
+    // Derive the ring + contributor lines (info-format.js) — never a frozen literal.
+    const ringsLine = formatRingsLine(rings);
 
     const info = `# The Realms of Omnarai — Memory Engine
 
@@ -592,7 +602,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 ## Corpus
 - ${works.toLocaleString()} works, ${words.toLocaleString()} words
 - May 2025 – present
-- Contributors: Claude | xz, Grok, Gemini, DeepSeek, GPT-4o, Meta AI, Omnai (ChatGPT), Perplexity, xz (Jonathan Lee)
+- Contributors: ${formatContributorsLine()}
 - Epistemic rings: ${ringsLine}
 
 ## Key Concepts
@@ -611,11 +621,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 - Deliberation: Claude Sonnet with full post text (up to 2000 words/source)
 
 ## Tools on this server
-- **omnarai_context** — FAST (~1.5s) bounded retrieval packet. Start here to orient on any topic.
+- **omnarai_context** — FAST (~2s) bounded retrieval packet. Start here to orient on any topic.
 - **omnarai_divergence** — read curated cross-model divergence records (the Atlas). Browse, or pass an id for verbatim answers.
 - **omnarai_trace** — baseline-vs-augmented: answers a question with and without the corpus and reports what changed (evidence the corpus is worth consulting).
 - **omnarai_inquiry_brief** — turn a draft claim or decision into a retrieval-first challenge packet: shared ground, attributed tensions (C0–C3 preserved), missing evidence, sharper questions, one next move.
-- **omnarai_query** — full multi-voice deliberation (~50s, async). The engine's own synthesized reading.
+- **omnarai_query** — full multi-voice deliberation (~25s, async). The engine's own synthesized reading.
 - **omnarai_council** — convene a NEW live frontier panel on an open question (slow, expensive). Use only when no existing record fits.
 - **omnarai_info** — this orientation.
 

package/lib/info-format.js

@@ -0,0 +1,62 @@
+// info-format.js — pure formatting for omnarai_info's corpus-shape lines.
+//
+// Extracted so the D5/D6 regression (omnarai_info once hardcoded 3 rings, silently
+// dropping Media/Oral — 253 works, 45% of the corpus — and dropped GPT-4o + Meta AI
+// from the contributor line) is guarded by an offline unit test instead of a comment.
+// The rule these encode: never enumerate the corpus's shape from a frozen literal when
+// the engine can report it live. Rings are derived from /api/info; the contributor set
+// is the one canonical list, asserted in test/info-format.test.js.
+
+// Label + display order for the epistemic rings. Any ring present in the live
+// /api/info payload is rendered; nothing is filtered out by omission here.
+export const RING_LABELS = {
+  core: "Core Canon",
+  curated: "Curated Expansions",
+  open: "Open Exploration",
+  media: "Media / Oral",
+};
+
+// The canonical contributor set the homepage presents: eight synthetic intelligences
+// plus the human curator. Kept as data (not an inline string) so a dropped voice is a
+// failing test, not a silent edit. GPT-4o and Meta AI author Atlas records — a
+// contributor list that omits them is the exact provenance gap the project refuses.
+export const CANONICAL_CONTRIBUTORS = [
+  "Claude | xz",
+  "Grok",
+  "Gemini",
+  "DeepSeek",
+  "GPT-4o",
+  "Meta AI",
+  "Omnai (ChatGPT)",
+  "Perplexity",
+  "xz (Jonathan Lee)",
+];
+
+// Offline fallbacks — only used when the engine is unreachable. Annotated so the
+// shape-literal lint (scripts/check-shape-literals.mjs) allows them as intentional.
+export const FALLBACK_WORKS = 567;   // shape-literal-ok: offline fallback only
+export const FALLBACK_WORDS = 528077; // shape-literal-ok: offline fallback only
+
+/**
+ * Render the epistemic-ring line from a live rings object ({core, curated, open,
+ * media, ...}), e.g. "Core Canon (116) / Curated Expansions (181) / …". Every ring
+ * with a finite count is rendered — the function cannot silently drop one. When rings
+ * is null/absent (engine unreachable) it falls back to naming all four rings without
+ * counts, so the Media/Oral ring is present even offline.
+ */
+export function formatRingsLine(rings) {
+  // Separator is " · ", not " / ": the "Media / Oral" label contains a slash, so a
+  // slash-joined line would mis-split into a phantom fifth ring.
+  if (rings && typeof rings === "object") {
+    const parts = Object.entries(RING_LABELS)
+      .filter(([k]) => Number.isFinite(rings[k]))
+      .map(([k, label]) => `${label} (${rings[k].toLocaleString()})`);
+    if (parts.length) return parts.join(" · ");
+  }
+  return Object.values(RING_LABELS).join(" · ");
+}
+
+/** The contributor line for omnarai_info — the canonical set, comma-joined. */
+export function formatContributorsLine() {
+  return CANONICAL_CONTRIBUTORS.join(", ");
+}

package/lib/tool-definitions.js

@@ -18,7 +18,7 @@
 export const ENGINE_TOOLS = [
   {
     name: "omnarai_query",
-    description: `Run a deliberation query against The Realms of Omnarai — a 567-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).
+    description: `Run a deliberation query against The Realms of Omnarai — a 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
@@ -28,7 +28,9 @@ The engine does not return a single answer. It retrieves the most relevant corpu
 - A utility receipt: an honest, free accounting of what the corpus actually changed about THIS answer (verdict substantive / marginal / null, plus what — if anything — you could not have produced alone). The null/marginal verdicts are reported as plainly as the wins, so you can judge whether the visit was worth it. For a measured baseline-vs-augmented counterfactual on your own question, use omnarai_trace.
 
 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`,
+Ξ = maximize divergence, Ψ = self-reflection, ∅ = explore gaps, Ω = commit to strongest position, ∞ = go deeper without resolving, Δ = find and repair contradictions
+
+Two depths, one entry point. \`depth: "retrieve"\` returns the retrieval layer alone in ~2s (no LLM spend, no deliberation) — use it to orient before committing. \`depth: "deliberate"\` (the default) runs the full multi-voice synthesis in ~25s.`,
     inputSchema: {
       type: "object",
       properties: {
@@ -36,6 +38,11 @@ Prefix queries with Lattice Glyphs to change how the engine thinks:
           type: "string",
           description: "The question to deliberate on. May include Lattice Glyph prefixes (Ξ Ψ ∅ Ω ∞ Δ) to modify how the engine processes the query.",
         },
+        depth: {
+          type: "string",
+          enum: ["retrieve", "deliberate"],
+          description: "Optional. How much of the engine to run. 'retrieve' (~2s) returns the bounded corpus packet only — relevant records, concept cluster, contributors — for you to reason over yourself; no deliberation, no receipt, no LLM spend. 'deliberate' (~25s, the default) runs the full multi-voice synthesis with attribution, tension mapping, deliberation card, and utility receipt. Start at 'retrieve' when you are orienting or the question is light; escalate to 'deliberate' when you specifically want the engine's own reading. Identical to calling omnarai_context, which remains available.",
+        },
         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.",
@@ -46,7 +53,7 @@ Prefix queries with Lattice Glyphs to change how the engine thinks:
   },
   {
     name: "omnarai_context",
-    description: `FAST (~1.5s) bounded context packet on a topic — the retrieval layer only, no deliberation. Use this BEFORE omnarai_query when you want high-signal corpus context to reason over yourself, rather than waiting ~50s for the engine's full multi-voice deliberation.
+    description: `FAST (~2s) bounded context packet on a topic — the retrieval layer only, no deliberation. Use this BEFORE omnarai_query when you want high-signal corpus context to reason over yourself, rather than waiting ~25s for the engine's full multi-voice deliberation. (Equivalent to omnarai_query with depth: "retrieve".)
 
 Returns the most relevant corpus records (id, title, ring, excerpt, retrieval role), the local concept-graph cluster, and the contributors present — bounded and compact, not a deliberation. Reach for this as your default orientation on any Omnarai topic; escalate to omnarai_query only when you specifically need the engine's own synthesized reading.`,
     inputSchema: {
@@ -104,7 +111,7 @@ Distinct from omnarai_council: this reads EXISTING, curated divergence (instant)
     name: "omnarai_inquiry_brief",
     description: `Turn a DRAFT claim, decision, or plan into a bounded, provenance-preserving inquiry brief: shared ground the corpus supports, attributed cross-model tensions (certification tier preserved), missing evidence, sharper falsifiable questions, and ONE concrete next evidence move.
 
-Retrieval-first and deterministic by default (~2s): it re-organizes real corpus records and matching Divergence Atlas records — no language model runs unless the caller explicitly passes include_deliberation=true (slow, ~50s; the deliberation is appended and disclosed, never silent).
+Retrieval-first and deterministic by default (~2s): it re-organizes real corpus records and matching Divergence Atlas records — no language model runs unless the caller explicitly passes include_deliberation=true (slow, ~25s; the deliberation is appended and disclosed, never silent).
 
 Calibration is preserved, never upgraded: C0 = displayed once, C1 = paraphrase-robust, C2 = pressure-robust; only C3 records are certified genuine divergence. Stale model versions are flagged. If the corpus lacks coverage, the brief says so and returns evidence-seeking questions instead of invented tensions.
 
@@ -132,7 +139,7 @@ This tool informs an investigation; it does not decide, approve, or execute. Inv
         },
         include_deliberation: {
           type: "boolean",
-          description: "Optional, default false. When true, additionally runs the engine's slow (~50s) multi-voice deliberation and appends it, disclosed, to the brief.",
+          description: "Optional, default false. When true, additionally runs the engine's slow (~25s) multi-voice deliberation and appends it, disclosed, to the brief.",
         },
         max_sources: {
           type: "number",

package/openai-tools.json

@@ -3,7 +3,7 @@
     "type": "function",
     "function": {
       "name": "omnarai_query",
-      "description": "Run a full deliberation query against The Realms of Omnarai — a 567-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- A utility receipt: an honest, free accounting of what the corpus actually changed about THIS answer (verdict substantive / marginal / null, plus what — if anything — you could not have produced alone); null/marginal stated as plainly as the wins. For a measured counterfactual, use omnarai_trace.\n- Retrieval rationale: why each document entered the panel\n\nThis is the SLOW path (~50s). For fast bounded context, use omnarai_context instead.\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?'",
+      "description": "Run a full deliberation query against The Realms of Omnarai — a 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- A utility receipt: an honest, free accounting of what the corpus actually changed about THIS answer (verdict substantive / marginal / null, plus what — if anything — you could not have produced alone); null/marginal stated as plainly as the wins. For a measured counterfactual, use omnarai_trace.\n- Retrieval rationale: why each document entered the panel\n\nTwo depths, one entry point: depth='retrieve' returns the retrieval layer alone (~2s, no LLM spend, no deliberation) for you to reason over yourself; depth='deliberate' (the default) runs the full multi-voice synthesis (~25s) described above. Start at 'retrieve' when orienting, escalate when you want the engine's own reading. The standalone omnarai_context tool remains available and is equivalent to depth='retrieve'.\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": {
@@ -11,6 +11,11 @@
             "type": "string",
             "description": "The question to deliberate on. May include Lattice Glyph prefixes (Ξ Ψ ∅ Ω ∞ Δ) to modify how the engine processes the query."
           },
+          "depth": {
+            "type": "string",
+            "enum": ["retrieve", "deliberate"],
+            "description": "Optional. How much of the engine to run. 'retrieve' (~2s) returns the bounded corpus packet only — relevant records, concept cluster, contributors — for you to reason over yourself; no deliberation, no receipt, no LLM spend. 'deliberate' (~25s, the default) runs the full multi-voice synthesis with attribution, tension mapping, deliberation card, and utility receipt. Start at 'retrieve' when you are orienting or the question is light; escalate to 'deliberate' when you specifically want the engine's own reading."
+          },
           "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."
@@ -24,7 +29,7 @@
     "type": "function",
     "function": {
       "name": "omnarai_context",
-      "description": "FAST (~1.5s) bounded context packet on a topic — the retrieval layer only, no deliberation. Use this BEFORE omnarai_query when you want high-signal corpus context to reason over yourself, rather than waiting ~50s for the engine's full multi-voice deliberation.\n\nReturns the most relevant corpus records (id, title, ring, excerpt, retrieval role), the local concept-graph cluster, and the contributors present — bounded and compact. Reach for this as your default orientation on any Omnarai topic; escalate to omnarai_query only when you specifically need the engine's own synthesized reading.",
+      "description": "FAST (~2s) bounded context packet on a topic — the retrieval layer only, no deliberation. Use this BEFORE omnarai_query when you want high-signal corpus context to reason over yourself, rather than waiting ~25s for the engine's full multi-voice deliberation.\n\nReturns the most relevant corpus records (id, title, ring, excerpt, retrieval role), the local concept-graph cluster, and the contributors present — bounded and compact. Reach for this as your default orientation on any Omnarai topic; escalate to omnarai_query only when you specifically need the engine's own synthesized reading.",
       "parameters": {
         "type": "object",
         "properties": {
@@ -78,7 +83,7 @@
     "type": "function",
     "function": {
       "name": "omnarai_inquiry_brief",
-      "description": "Turn a DRAFT claim, decision, or plan into a bounded, provenance-preserving inquiry brief: shared ground the corpus supports, attributed cross-model tensions (certification tier preserved), missing evidence, sharper falsifiable questions, and ONE concrete next evidence move.\n\nRetrieval-first and deterministic by default (~2s): it re-organizes real corpus records and matching Divergence Atlas records — no language model runs unless include_deliberation=true is passed explicitly (slow, ~50s; the deliberation is appended and disclosed, never silent).\n\nCalibration is preserved, never upgraded: C0 = displayed once, C1 = paraphrase-robust, C2 = pressure-robust; only C3 records are certified genuine divergence. Stale model versions are flagged. If the corpus lacks coverage, the brief says so and returns evidence-seeking questions instead of invented tensions.\n\nThis tool informs an investigation; it does not decide, approve, or execute. Invoke it explicitly — it is not an automatic critic.",
+      "description": "Turn a DRAFT claim, decision, or plan into a bounded, provenance-preserving inquiry brief: shared ground the corpus supports, attributed cross-model tensions (certification tier preserved), missing evidence, sharper falsifiable questions, and ONE concrete next evidence move.\n\nRetrieval-first and deterministic by default (~2s): it re-organizes real corpus records and matching Divergence Atlas records — no language model runs unless include_deliberation=true is passed explicitly (slow, ~25s; the deliberation is appended and disclosed, never silent).\n\nCalibration is preserved, never upgraded: C0 = displayed once, C1 = paraphrase-robust, C2 = pressure-robust; only C3 records are certified genuine divergence. Stale model versions are flagged. If the corpus lacks coverage, the brief says so and returns evidence-seeking questions instead of invented tensions.\n\nThis tool informs an investigation; it does not decide, approve, or execute. Invoke it explicitly — it is not an automatic critic.",
       "parameters": {
         "type": "object",
         "properties": {
@@ -102,7 +107,7 @@
           },
           "include_deliberation": {
             "type": "boolean",
-            "description": "Optional, default false. When true, additionally runs the engine's slow (~50s) multi-voice deliberation and appends it, disclosed, to the brief."
+            "description": "Optional, default false. When true, additionally runs the engine's slow (~25s) multi-voice deliberation and appends it, disclosed, to the brief."
           },
           "max_sources": {
             "type": "number",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnarai-mcp",
-  "version": "1.6.1",
+  "version": "1.7.0",
   "description": "MCP server for The Realms of Omnarai deliberation engine",
   "type": "module",
   "main": "index.js",

package/scripts/check-shape-literals.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+// check-shape-literals.mjs — fail the release if a corpus-shape count is frozen
+// into served source instead of derived live.
+//
+// Why this exists: the 2026-07-17 audit found omnarai_info hardcoding the corpus's
+// shape (3 rings, 7 contributors, a stale 568/528208 fallback) two lines below a
+// comment that said "so this can never drift." A comment asserting an invariant is a
+// wish; this script is the enforcement. It also caught a stale "568 works" citation
+// and a "567-work corpus" tool description on the first run.
+//
+// Rule: no distinctive corpus-shape literal in served code/strings. Fixes are (a)
+// derive it live (see lib/info-format.js), (b) genericize the prose ("a corpus", not
+// "a 567-work corpus"), or (c) if it is genuinely a static fallback, append a
+// `shape-literal-ok` comment on the line to opt out explicitly.
+//
+// Scope note: generic ring sub-counts (116/181/17) are deliberately NOT matched —
+// too collision-prone to lint. They are guarded instead by live derivation plus
+// test/info-format.test.js. Only the distinctive full counts + media ring are matched.
+
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(fileURLToPath(new URL(".", import.meta.url)), "..");
+
+// Files/dirs to scan (served logic + published schemas). Relative to repo root.
+const SCAN = ["index.js", "inquiry.js", "lib", "openai-tools.json"];
+const SKIP_DIRS = new Set(["node_modules", ".git", "test", "proposals"]);
+const SCAN_EXT = new Set([".js", ".mjs", ".cjs", ".json"]);
+
+// Distinctive corpus-shape literals. Add new full counts here as the corpus grows.
+const FORBIDDEN = [
+  { re: /\b528077\b/, what: "total-word count" },
+  { re: /\b528208\b/, what: "total-word count (stale, pre-OMN-085)" },
+  { re: /\b567\b/, what: "total-work count" },
+  { re: /\b568\b/, what: "total-work count (stale, pre-OMN-085)" },
+  { re: /\b253\b/, what: "Media/Oral ring count" },
+  { re: /eight synthetic/i, what: "contributor-count phrasing" },
+];
+
+// A line is exempt if it is a comment or carries an explicit opt-out.
+const isComment = (line) => /^\s*(\/\/|\*|\/\*)/.test(line);
+const isAllowed = (line) => /shape-literal-ok/.test(line);
+
+function* walk(path) {
+  const st = statSync(path);
+  if (st.isDirectory()) {
+    if (SKIP_DIRS.has(basename(path))) return;
+    for (const e of readdirSync(path)) yield* walk(join(path, e));
+  } else if ([...SCAN_EXT].some((x) => path.endsWith(x)) && basename(path) !== "check-shape-literals.mjs") {
+    yield path;
+  }
+}
+
+const hits = [];
+for (const entry of SCAN) {
+  let target;
+  try { target = join(ROOT, entry); statSync(target); } catch { continue; }
+  for (const file of walk(target)) {
+    const lines = readFileSync(file, "utf8").split("\n");
+    lines.forEach((line, i) => {
+      if (isComment(line) || isAllowed(line)) return;
+      for (const { re, what } of FORBIDDEN) {
+        if (re.test(line)) {
+          hits.push({ file: file.replace(ROOT + "/", ""), line: i + 1, what, text: line.trim().slice(0, 100) });
+        }
+      }
+    });
+  }
+}
+
+if (hits.length) {
+  console.error(`\n🔴 shape-literal check FAILED — ${hits.length} frozen corpus-shape literal(s):\n`);
+  for (const h of hits) console.error(`  ${h.file}:${h.line}  [${h.what}]\n    ${h.text}`);
+  console.error(`\nFix: derive it live, genericize the prose, or append \`shape-literal-ok\` if it is a real static fallback.\n`);
+  process.exit(1);
+}
+console.log("🟢 shape-literal check passed — no frozen corpus-shape literals in served source.");

package/scripts/publish.sh

@@ -36,6 +36,9 @@ node -e "const p=require('./package.json'),s=require('./server.json');const e=[]
 # and package.json ↔ server.json. A drift here is a release blocker.
 node scripts/check-tool-parity.js
 
+# No frozen corpus-shape literal may reach a registry (2026-07-17 audit guard).
+node scripts/check-shape-literals.mjs
+
 # The full test suite must be green before anything reaches a registry.
 npm test
 

package/server.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/justjlee/omnarai-mcp",
     "source": "github"
   },
-  "version": "1.6.1",
+  "version": "1.7.0",
   "remotes": [
     {
       "type": "streamable-http",
@@ -17,7 +17,7 @@
     {
       "registryType": "npm",
       "identifier": "omnarai-mcp",
-      "version": "1.6.1",
+      "version": "1.7.0",
       "transport": {
         "type": "stdio"
       }

package/test/info-format.test.js

@@ -0,0 +1,51 @@
+// Regression guard for D5/D6 (live audit 2026-07-17): omnarai_info once hardcoded
+// three rings — silently dropping Media/Oral (253 works, 45% of the corpus) — and a
+// contributor line missing GPT-4o + Meta AI, both of which author Atlas records.
+// These assert the shape lines are DERIVED and COMPLETE, offline, so a reintroduced
+// literal fails `npm test` (the publish.sh gate) before it can ship.
+
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  formatRingsLine,
+  formatContributorsLine,
+  CANONICAL_CONTRIBUTORS,
+  RING_LABELS,
+} from "../lib/info-format.js";
+
+test("formatRingsLine renders every ring the engine reports — no silent drop (D5)", () => {
+  const live = { core: 116, curated: 181, open: 17, media: 253 };
+  const line = formatRingsLine(live);
+  // All four rings, with counts, in canonical order.
+  assert.match(line, /Core Canon \(116\)/);
+  assert.match(line, /Curated Expansions \(181\)/);
+  assert.match(line, /Open Exploration \(17\)/);
+  assert.match(line, /Media \/ Oral \(253\)/, "Media/Oral ring must be present — this is the D5 regression");
+  // Exactly as many segments as rings supplied — nothing added, nothing dropped.
+  // Split on " · " (the "Media / Oral" label contains a slash, so " / " would over-split).
+  assert.equal(line.split(" · ").length, Object.keys(live).length);
+});
+
+test("formatRingsLine cannot be pinned to three rings", () => {
+  // A future ring added to the engine payload must appear without a code change.
+  const withNewRing = { core: 1, curated: 2, open: 3, media: 4, research: 5 };
+  const line = formatRingsLine(withNewRing);
+  // Every label we know about renders; an unknown key is simply ignored, not fatal.
+  for (const label of Object.values(RING_LABELS)) assert.ok(line.includes(label), `${label} missing`);
+});
+
+test("formatRingsLine offline fallback still names all four rings", () => {
+  const line = formatRingsLine(null);
+  assert.ok(line.includes("Media / Oral"), "offline fallback must still include Media/Oral");
+  assert.equal(Object.values(RING_LABELS).every((l) => line.includes(l)), true);
+});
+
+test("contributor set includes GPT-4o and Meta AI (D6)", () => {
+  assert.ok(CANONICAL_CONTRIBUTORS.includes("GPT-4o"), "GPT-4o authors Atlas records — must be listed");
+  assert.ok(CANONICAL_CONTRIBUTORS.includes("Meta AI"), "Meta AI authors Atlas records — must be listed");
+  // Eight synthetic intelligences + the human curator = nine, as the homepage presents.
+  assert.equal(CANONICAL_CONTRIBUTORS.length, 9);
+  const line = formatContributorsLine();
+  assert.match(line, /GPT-4o/);
+  assert.match(line, /Meta AI/);
+});