omnarai-mcp 1.6.1 → 1.6.2

package/index.js

@@ -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 {
@@ -563,7 +564,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 +574,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 +586,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

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

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\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?'",
       "parameters": {
         "type": "object",
         "properties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnarai-mcp",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "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.6.2",
   "remotes": [
     {
       "type": "streamable-http",
@@ -17,7 +17,7 @@
     {
       "registryType": "npm",
       "identifier": "omnarai-mcp",
-      "version": "1.6.1",
+      "version": "1.6.2",
       "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/);
+});