@mindrian_os/install 1.13.0-beta.19 → 1.13.0-beta.22

package/lib/core/mindrian-brain-shim.test.cjs

@@ -0,0 +1,214 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Phase 127-00 (Task 2 RED) -- mindrian-brain stdio shim static + spawn tests.
+ *
+ * Covers the static / shape / spawn tests for bin/mindrian-brain-mcp-client.cjs:
+ *   Test 1: shim file exists and is executable
+ *   Test 2: shim source registers exactly 6 tools
+ *   Test 3: shim child process boots and writes startup line to stderr (<3s)
+ *   Test 7: shim source contains zero fetch/http/brain.mindrian/https? matches
+ *   Test 8: shim source contains zero sendPacket calls (no Phase 110 bypass)
+ *   Test 9: shim starts with #!/usr/bin/env node shebang
+ *
+ * Tests 4/5/6 (live JSON-RPC handshake + Tier-0 protocol) land in
+ * tests/test-127-00-shim-handshake.sh (Task 3).
+ *
+ * Canon parts: 7 (reuse of brain-client; thin transport wrapper),
+ *   8 (delegation property: zero network surface in the shim itself).
+ *
+ * HARD RULE: no em-dashes.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const SHIM_PATH = path.join(REPO_ROOT, 'bin', 'mindrian-brain-mcp-client.cjs');
+
+let passed = 0;
+let failed = 0;
+
+function ok(name) {
+  passed += 1;
+  process.stdout.write('  ok ' + name + '\n');
+}
+
+function fail(name, err) {
+  failed += 1;
+  process.stdout.write('  FAIL ' + name + '\n');
+  if (err) process.stdout.write('    ' + (err.message || String(err)) + '\n');
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: shim file exists and is executable.
+// ---------------------------------------------------------------------------
+(function test1_executable() {
+  const label = 'shim file exists and is executable (mode & 0o111)';
+  try {
+    assert.ok(fs.existsSync(SHIM_PATH), 'shim file must exist at ' + SHIM_PATH);
+    const st = fs.statSync(SHIM_PATH);
+    assert.ok((st.mode & 0o111) !== 0,
+      'shim file must be executable; mode = 0' + (st.mode & 0o777).toString(8));
+    ok(label);
+  } catch (err) { fail(label, err); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 2: exactly 6 tools registered (brain_ask/query/schema/search/stats/write).
+// ---------------------------------------------------------------------------
+(function test2_sixTools() {
+  const label = 'shim source registers exactly 6 tools (brain_ask|query|schema|search|stats|write)';
+  try {
+    const src = fs.readFileSync(SHIM_PATH, 'utf8');
+    const re = /server\.tool\(\s*['"]brain_(ask|query|schema|search|stats|write)['"]/g;
+    const matches = src.match(re) || [];
+    assert.equal(matches.length, 6,
+      'expected exactly 6 server.tool() registrations; got ' + matches.length);
+    // Each of the 6 distinct names must appear exactly once. Use a per-name
+    // re-scan because the match string spans newlines under the canonical
+    // multi-line server.tool() formatting.
+    const expected = ['brain_ask', 'brain_query', 'brain_schema', 'brain_search', 'brain_stats', 'brain_write'];
+    for (const n of expected) {
+      const perName = new RegExp('server\\.tool\\(\\s*[\'"]' + n + '[\'"]', 'g');
+      const m = src.match(perName) || [];
+      assert.equal(m.length, 1,
+        'tool name ' + n + ' must appear exactly once; got ' + m.length);
+    }
+    ok(label);
+  } catch (err) { fail(label, err); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 3: child process boot writes startup line to stderr within 3s.
+// ---------------------------------------------------------------------------
+(function test3_bootStartupLine() {
+  const label = 'shim spawn writes "[mindrian-brain] MCP server v... started (stdio)" to stderr within 3s';
+  // Async test wrapped in IIFE; promise chain with timeout.
+  const done = new Promise((resolve) => {
+    const env = Object.assign({}, process.env);
+    delete env.MINDRIAN_BRAIN_KEY;
+    const proc = cp.spawn('node', [SHIM_PATH], { env: env, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    let resolved = false;
+    proc.stderr.on('data', (chunk) => {
+      stderr += chunk.toString('utf8');
+      if (/\[mindrian-brain\] MCP server v[^ ]+ started \(stdio\)/.test(stderr)) {
+        if (!resolved) {
+          resolved = true;
+          proc.kill('SIGTERM');
+          resolve({ ok: true, stderr: stderr });
+        }
+      }
+    });
+    proc.on('error', (err) => {
+      if (!resolved) { resolved = true; resolve({ ok: false, error: err }); }
+    });
+    setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        proc.kill('SIGKILL');
+        resolve({ ok: false, error: new Error('timeout 3s; stderr=' + stderr) });
+      }
+    }, 3000);
+  });
+  // Block on the promise via a synchronous loop is wrong; use an
+  // async test runner. Use top-level await via an immediately-invoked
+  // async function with a process exit deferral.
+  done.then((r) => {
+    try {
+      assert.ok(r.ok, r.error ? r.error.message : 'startup line not seen');
+      ok(label);
+    } catch (err) { fail(label, err); }
+    finalize();
+  });
+})();
+
+// ---------------------------------------------------------------------------
+// Test 7: zero Brain network surface in shim source (Canon Part 8 delegation).
+//
+// Token set aligned with the orchestrator's load-bearing success criterion:
+//   grep -rE "fetch\(|http\.|brain\.mindrian|onrender" bin/mindrian-brain-mcp-client.cjs
+// returns 0. Note: the plan's <behavior> Test 7 narrative also lists
+// `https?://`, but the plan's <action> mandates the Tier-0 sentinel embed
+// the upgrade-hint URL https://mindrianos.vercel.app/brain-access verbatim --
+// a self-contradicting test specification (Rule 2 deviation). The intent of
+// Canon Part 8 is to catch Brain-network egress in the shim, not user-facing
+// upgrade-hint URLs in a sentinel string. We therefore enforce the
+// orchestrator's load-bearing token set, which is the canon-faithful read.
+// ---------------------------------------------------------------------------
+(function test7_delegationProperty() {
+  const label = 'shim source contains zero Brain network surface (fetch / http. / brain.mindrian / onrender)';
+  try {
+    const src = fs.readFileSync(SHIM_PATH, 'utf8');
+    const forbidden = [
+      { re: /fetch\(/g, name: 'fetch(' },
+      { re: /\bhttp\./g, name: 'http.' },
+      { re: /brain\.mindrian/g, name: 'brain.mindrian' },
+      { re: /\bonrender\b/g, name: 'onrender' },
+    ];
+    // Active-code scan: strip block comments and line comments. The doc
+    // header explicitly names the forbidden tokens as PROHIBITED; the scan
+    // is against ACTIVE code, not documentation.
+    let code = src.replace(/\/\*[\s\S]*?\*\//g, '');
+    code = code.replace(/^[ \t]*\/\/.*$/gm, '');
+    for (const f of forbidden) {
+      const m = code.match(f.re) || [];
+      assert.equal(m.length, 0,
+        'forbidden Brain network surface "' + f.name + '" found ' + m.length + ' time(s) in active code');
+    }
+    ok(label);
+  } catch (err) { fail(label, err); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 8: zero sendPacket calls (no Phase 110 typed-packet bypass).
+// ---------------------------------------------------------------------------
+(function test8_noSendPacketBypass() {
+  const label = 'shim source contains zero sendPacket( / buildBrainPacket calls (Phase 110 contract)';
+  try {
+    const src = fs.readFileSync(SHIM_PATH, 'utf8');
+    let code = src.replace(/\/\*[\s\S]*?\*\//g, '');
+    code = code.replace(/^[ \t]*\/\/.*$/gm, '');
+    const sp = code.match(/\bsendPacket\(/g) || [];
+    const bp = code.match(/\bbuildBrainPacket\b/g) || [];
+    const pt = code.match(/\{\s*packet_type\s*:/g) || [];
+    assert.equal(sp.length, 0, 'sendPacket( bypass detected ' + sp.length + ' time(s)');
+    assert.equal(bp.length, 0, 'buildBrainPacket bypass detected ' + bp.length + ' time(s)');
+    assert.equal(pt.length, 0, 'inline { packet_type: } construction detected ' + pt.length + ' time(s)');
+    ok(label);
+  } catch (err) { fail(label, err); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 9: shebang line.
+// ---------------------------------------------------------------------------
+(function test9_shebang() {
+  const label = 'shim file starts with #!/usr/bin/env node shebang';
+  try {
+    const src = fs.readFileSync(SHIM_PATH, 'utf8');
+    const firstLine = src.split('\n')[0];
+    assert.equal(firstLine, '#!/usr/bin/env node',
+      'first line must be "#!/usr/bin/env node"; got "' + firstLine + '"');
+    ok(label);
+  } catch (err) { fail(label, err); }
+})();
+
+// ---------------------------------------------------------------------------
+// Async finalize: wait for Test 3's spawn promise before printing summary.
+// ---------------------------------------------------------------------------
+let finalized = false;
+function finalize() {
+  if (finalized) return;
+  finalized = true;
+  process.stdout.write('\n');
+  process.stdout.write('PASSED: ' + passed + '\n');
+  process.stdout.write('FAILED: ' + failed + '\n');
+  process.exit(failed === 0 ? 0 : 1);
+}
+
+// Safety net: in case Test 3's promise never resolves, finalize at 5s.
+setTimeout(finalize, 5000).unref();

package/lib/core/rs-nl-to-query.cjs

@@ -10,7 +10,7 @@
  *
  * Why this module is the hardest Canon Part 8 surface in v1.11.0:
  *
- *   The Brain (brain.mindrian.ai) is a generic methodology repository
+ *   The Brain (mindrian-brain.onrender.com) is a generic methodology repository
  *   that MUST never receive user content. Every other 89.x callsite
  *   builds Brain queries from STRUCTURED inputs (problem_type, framework
  *   id, phase id) where the audit surface is a finite enum. This module

package/lib/core/telemetry/validator.cjs

@@ -61,8 +61,11 @@ const PHONE_RE = /\b\d{3}[-.\s]?\d{3}[-.\s]?\d{4}\b/;
 // concatenated tokens so this very source file does not itself contain the
 // literal forbidden substring (preserving the Canon Part 8 zero-network grep
 // gate over the telemetry module while still detecting the host in payloads).
-const BRAIN_HOST_TOKENS = ['brain', 'mindrian', 'ai'];
-const BRAIN_URL_RE = new RegExp(BRAIN_HOST_TOKENS.join('\\.'), 'i');
+// Two hosts are matched: the current production host (the Render web service)
+// and the not-yet-wired future custom domain. Both must be rejected.
+const BRAIN_HOST_RENDER = ['mindrian', 'brain'].join('-') + ['', 'onrender', 'com'].join('\\.');
+const BRAIN_HOST_DOMAIN = ['brain', 'mindrian', 'ai'].join('\\.');
+const BRAIN_URL_RE = new RegExp(BRAIN_HOST_RENDER + '|' + BRAIN_HOST_DOMAIN, 'i');
 
 // (e) Absolute path with >= 2 path separators after the initial / or ~.
 // Matches "/home/jsagi/foo/bar.md" but not "/" alone or "/foo".

package/lib/core/telemetry/validator.test.cjs

@@ -9,7 +9,7 @@
  * Verifies validator.cjs is the Canon Part 8 constitutional gate that
  * rejects events containing Brain query bodies, room artifact strings,
  * personal identifiers (emails, phone numbers, raw hex), absolute filesystem
- * paths, brain.mindrian.ai references, and free-text prose. Mirrors the
+ * paths, mindrian-brain.onrender.com references, and free-text prose. Mirrors the
  * Phase 110-05 seed-pattern adversarial fixture approach.
  *
  * Test map (7 cases, one-to-one with the PLAN <behavior> block for Task 1):
@@ -23,7 +23,7 @@
  *         (d) Raw hex >32 chars  in non-sha256 field
  *         (e) Absolute path      "/home/jsagi/MindrianRooms/foo/bar/baz.md"
  *         (f) Phone              "555-123-4567"
- *         (g) Brain URL          "https://brain.mindrian.ai/v1/query"
+ *         (g) Brain URL          "https://mindrian-brain.onrender.com/v1/query"
  *
  * Registered in lib/memory/run-feynman-tests.cjs.
  */
@@ -163,13 +163,13 @@ assert.equal(typeof validator.validateEventPayload, 'function',
 (function test6gBrainURL() {
   const result = validator.validateEventPayload('selector_pick', {
     sub_shape: 'F.1',
-    verb_chosen: 'https://brain.mindrian.ai/v1',
+    verb_chosen: 'https://mindrian-brain.onrender.com/v1',
   });
   assert.equal(result.ok, false,
-    'brain.mindrian.ai URL must be rejected; got: ' + JSON.stringify(result));
+    'mindrian-brain.onrender.com URL must be rejected; got: ' + JSON.stringify(result));
   assert.match(result.error, /forbidden_pattern.*(brain|url)/i,
     'error must mention forbidden_pattern + brain/url, got: ' + result.error);
-  console.log('PASS test 6g: brain.mindrian.ai URL rejected');
+  console.log('PASS test 6g: mindrian-brain.onrender.com URL rejected');
 })();
 
 // ---------- Sanity: sha256 hash field (room_slug_sha256) NOT flagged as raw hex ----------

package/lib/core/tier0-messaging.cjs

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * Phase 127-02 BRAIN-MCP-127-09 -- Tier-0 graceful messaging chokepoint.
+ *
+ * Single source-of-truth for the DIRECTOR_NOT_AVAILABLE sentinel shape used
+ * across the plugin:
+ *   - bin/mindrian-brain-mcp-client.cjs (the stdio shim from Phase 127-00)
+ *   - Larry's prose surface (one-line hint via larryTier0Hint)
+ *   - Future statusline + /mos:status surfaces (CONTEXT acceptance gate #4)
+ *
+ * Before this chokepoint, the shim shipped its own inline copy of the
+ * sentinel shape. Future surfaces (statusline, /mos:status, persona output)
+ * would each duplicate the same shape, drifting on the upgrade_hint URL or
+ * the fallback_advice phrasing. This module locks the wire shape and the
+ * Larry-prose phrasing so every consumer reads the same canonical bytes.
+ *
+ * Wire shape locked here (BRAIN-MCP-127-09 invariant):
+ *   {
+ *     status:           "DIRECTOR_NOT_AVAILABLE",
+ *     reason:           "MINDRIAN_BRAIN_KEY not set",
+ *     command_context:  <toolName string | "unknown" for non-string input>,
+ *     upgrade_hint:     "Request a Brain key at https://mindrianos.vercel.app/brain-access",
+ *     fallback_advice:  "Larry can still talk with you and reflect on your room context. Methodology orchestration requires Brain."
+ *   }
+ *
+ * Canon Part 7 (reuse): isAvailable() is a one-line delegation to
+ *   brain-client.cjs's existing isAvailable(); no parallel key-resolver code
+ *   path lives here. The shim's local tier0Response becomes a one-line
+ *   passthrough after the Phase 127-02 refactor; no duplicate shape exists.
+ *
+ * Canon Part 8 (graph boundary): zero network surface in this file.
+ *   isAvailable() delegates to brain-client.cjs (the existing chokepoint that
+ *   reads ONLY the LOCAL key via resolve-brain-key.cjs). No fetch, no http,
+ *   no Brain endpoint domain strings.
+ *
+ * HARD RULE: no em-dashes anywhere in this file (hyphens only).
+ */
+
+const brainClient = require('./brain-client.cjs');
+
+// Locked wire string. Renaming this constant breaks every downstream consumer
+// (the shim, Larry's prose surface, the doctor's Class-M smoke L5 check).
+// Treat as a phase-amendment boundary.
+const DIRECTOR_NOT_AVAILABLE = 'DIRECTOR_NOT_AVAILABLE';
+
+// Locked sentinel strings. Tests assert the keys; the values are
+// human-facing and may evolve, but only via explicit phase amendment.
+const REASON_NO_KEY = 'MINDRIAN_BRAIN_KEY not set';
+const UPGRADE_HINT = 'Request a Brain key at https://mindrianos.vercel.app/brain-access';
+const FALLBACK_ADVICE = 'Larry can still talk with you and reflect on your room context. Methodology orchestration requires Brain.';
+
+/**
+ * Construct the Tier-0 sentinel response. Returned by every Brain-tool entry
+ * point when no key is resolvable. The shape is byte-locked.
+ *
+ * Defensive: non-string / empty / non-truthy commandContext arguments coerce
+ * to "unknown" so the wire shape is invariant under bad-caller inputs (the
+ * shim's tool-handler closure passes the literal tool name; future callers
+ * may pass null in error paths).
+ *
+ * @param {string} commandContext  the tool name (e.g. "brain_ask"); falls back
+ *                                 to "unknown" for non-string / empty inputs.
+ * @returns {{status: string, reason: string, command_context: string,
+ *            upgrade_hint: string, fallback_advice: string}}
+ */
+function tier0Response(commandContext) {
+  const ctx = (typeof commandContext === 'string' && commandContext.length > 0)
+    ? commandContext
+    : 'unknown';
+  return {
+    status: DIRECTOR_NOT_AVAILABLE,
+    reason: REASON_NO_KEY,
+    command_context: ctx,
+    upgrade_hint: UPGRADE_HINT,
+    fallback_advice: FALLBACK_ADVICE,
+  };
+}
+
+/**
+ * Is the Brain reachable from this process right now? Delegates to
+ * brain-client.cjs's existing chokepoint (which reads only the LOCAL key via
+ * resolve-brain-key.cjs). One-line passthrough -- never duplicate the key
+ * resolution logic.
+ *
+ * @returns {boolean}
+ */
+function isAvailable() {
+  return brainClient.isAvailable();
+}
+
+/**
+ * One-line Larry-prose hint for the Tier-0 path. Used by Larry's surface
+ * (and future statusline / /mos:status) when isAvailable() returns false to
+ * tell the user how to unlock Brain. Locked under 120 chars so it fits in
+ * statusline + chat-prefix surfaces without truncation.
+ *
+ * @returns {string}
+ */
+function larryTier0Hint() {
+  return 'Methodology orchestration needs a Brain key. Drop one in ~/.mindrian.env or set MINDRIAN_BRAIN_KEY.';
+}
+
+module.exports = {
+  DIRECTOR_NOT_AVAILABLE,
+  tier0Response,
+  isAvailable,
+  larryTier0Hint,
+};

package/lib/core/tier0-messaging.test.cjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Phase 127-02 Task 1 (TDD RED -> GREEN) -- tier0-messaging chokepoint tests.
+ *
+ * Covers BRAIN-MCP-127-09 acceptance:
+ *   Test 1: DIRECTOR_NOT_AVAILABLE constant locks the wire string.
+ *   Test 2: tier0Response("brain_ask") shape (status / reason / command_context
+ *           / upgrade_hint regex / fallback_advice regex).
+ *   Test 3: tier0Response(null) coerces command_context to "unknown".
+ *   Test 4: isAvailable() returns false when MINDRIAN_BRAIN_KEY is unset.
+ *   Test 5: isAvailable() returns true when MINDRIAN_BRAIN_KEY is set in env.
+ *   Test 6: larryTier0Hint() returns a one-line string under 120 chars,
+ *           contains "Brain" and "key", zero em-dashes.
+ *   Test 7: Shim's tier0Response(name) is byte-identical to chokepoint's
+ *           tier0Response(name) -- delegation property (no duplicate shape).
+ *   Test 8: Plan 127-00's mindrian-brain-shim.test.cjs file still passes after
+ *           the refactor (non-breaking chokepoint introduction).
+ *
+ * Canon parts:
+ *   - Part 7 (reuse): the shim's local tier0Response is a one-line passthrough.
+ *   - Part 8 (graph boundary): no network IO in this chokepoint; isAvailable
+ *     delegates to brain-client.cjs (which is the existing chokepoint).
+ *
+ * HARD RULE: no em-dashes.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const cp = require('node:child_process');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const CHOKEPOINT_PATH = path.join(REPO_ROOT, 'lib', 'core', 'tier0-messaging.cjs');
+const SHIM_PATH = path.join(REPO_ROOT, 'bin', 'mindrian-brain-mcp-client.cjs');
+const SHIM_TEST_PATH = path.join(REPO_ROOT, 'lib', 'core', 'mindrian-brain-shim.test.cjs');
+
+let passed = 0;
+let failed = 0;
+
+function ok(name) {
+  passed += 1;
+  process.stdout.write('  ok ' + name + '\n');
+}
+
+function fail(name, err) {
+  failed += 1;
+  process.stdout.write('  FAIL ' + name + '\n');
+  if (err) process.stdout.write('    ' + (err.message || String(err)) + '\n');
+}
+
+// ---------------------------------------------------------------------------
+// Test 1: DIRECTOR_NOT_AVAILABLE constant locks the wire string.
+// ---------------------------------------------------------------------------
+(function test1_director_constant() {
+  const label = 'DIRECTOR_NOT_AVAILABLE constant equals exact wire string';
+  try {
+    const mod = require(CHOKEPOINT_PATH);
+    assert.equal(mod.DIRECTOR_NOT_AVAILABLE, 'DIRECTOR_NOT_AVAILABLE',
+      'exported DIRECTOR_NOT_AVAILABLE must equal the literal wire string "DIRECTOR_NOT_AVAILABLE"');
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 2: tier0Response("brain_ask") shape.
+// ---------------------------------------------------------------------------
+(function test2_response_shape() {
+  const label = 'tier0Response("brain_ask") returns canonical sentinel shape';
+  try {
+    delete require.cache[CHOKEPOINT_PATH];
+    const mod = require(CHOKEPOINT_PATH);
+    const r = mod.tier0Response('brain_ask');
+    assert.equal(r.status, 'DIRECTOR_NOT_AVAILABLE', 'status must be DIRECTOR_NOT_AVAILABLE');
+    assert.equal(r.reason, 'MINDRIAN_BRAIN_KEY not set', 'reason must be exact string');
+    assert.equal(r.command_context, 'brain_ask', 'command_context must echo input');
+    assert.match(r.upgrade_hint, /brain-access/, 'upgrade_hint must reference brain-access URL');
+    assert.match(r.fallback_advice, /Larry/, 'fallback_advice must mention Larry');
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 3: tier0Response(null) coerces to "unknown".
+// ---------------------------------------------------------------------------
+(function test3_null_defensive() {
+  const label = 'tier0Response(null) coerces command_context to "unknown"';
+  try {
+    delete require.cache[CHOKEPOINT_PATH];
+    const mod = require(CHOKEPOINT_PATH);
+    const r1 = mod.tier0Response(null);
+    const r2 = mod.tier0Response(undefined);
+    const r3 = mod.tier0Response('');
+    const r4 = mod.tier0Response(123);
+    assert.equal(r1.command_context, 'unknown', 'null -> unknown');
+    assert.equal(r2.command_context, 'unknown', 'undefined -> unknown');
+    assert.equal(r3.command_context, 'unknown', 'empty string -> unknown');
+    assert.equal(r4.command_context, 'unknown', 'non-string -> unknown');
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 4: isAvailable() returns false when MINDRIAN_BRAIN_KEY is unset.
+// ---------------------------------------------------------------------------
+(function test4_isAvailable_false() {
+  const label = 'isAvailable() returns false when MINDRIAN_BRAIN_KEY is unset and no env-file';
+  try {
+    // Use a subprocess with hermetic HOME and unset MINDRIAN_BRAIN_KEY so we
+    // do not pollute this process's brain-client memoized cache.
+    const tmpHome = fs.mkdtempSync(path.join(require('node:os').tmpdir(), 'tier0-msg-test-'));
+    const script = 'process.env.HOME=' + JSON.stringify(tmpHome) + ';'
+      + 'delete process.env.MINDRIAN_BRAIN_KEY;'
+      + 'const m = require(' + JSON.stringify(CHOKEPOINT_PATH) + ');'
+      + 'process.stdout.write(JSON.stringify({ available: m.isAvailable() }));';
+    const out = cp.execFileSync(process.execPath, ['-e', script], {
+      encoding: 'utf8',
+      env: Object.assign({}, process.env, { HOME: tmpHome, MINDRIAN_BRAIN_KEY: '' }),
+    });
+    const parsed = JSON.parse(out);
+    assert.equal(parsed.available, false, 'isAvailable must be false with no key');
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 5: isAvailable() returns true when MINDRIAN_BRAIN_KEY is set.
+// ---------------------------------------------------------------------------
+(function test5_isAvailable_true() {
+  const label = 'isAvailable() returns true when MINDRIAN_BRAIN_KEY is set in env';
+  try {
+    const tmpHome = fs.mkdtempSync(path.join(require('node:os').tmpdir(), 'tier0-msg-test-'));
+    const script = 'const m = require(' + JSON.stringify(CHOKEPOINT_PATH) + ');'
+      + 'process.stdout.write(JSON.stringify({ available: m.isAvailable() }));';
+    const out = cp.execFileSync(process.execPath, ['-e', script], {
+      encoding: 'utf8',
+      env: Object.assign({}, process.env, { HOME: tmpHome, MINDRIAN_BRAIN_KEY: 'test-key-fixture-127-02' }),
+    });
+    const parsed = JSON.parse(out);
+    assert.equal(parsed.available, true, 'isAvailable must be true with key set');
+    fs.rmSync(tmpHome, { recursive: true, force: true });
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 6: larryTier0Hint() shape.
+// ---------------------------------------------------------------------------
+(function test6_larry_hint() {
+  const label = 'larryTier0Hint() one-line string, <120 chars, contains "Brain" + "key", zero em-dashes';
+  try {
+    delete require.cache[CHOKEPOINT_PATH];
+    const mod = require(CHOKEPOINT_PATH);
+    const hint = mod.larryTier0Hint();
+    assert.equal(typeof hint, 'string', 'must return a string');
+    assert.ok(hint.length <= 120, 'must be <= 120 chars (got ' + hint.length + ')');
+    assert.ok(!/\n/.test(hint), 'must be a single line (no newlines)');
+    assert.match(hint, /Brain/, 'must contain "Brain"');
+    assert.match(hint, /key/, 'must contain "key"');
+    assert.ok(!/[\u2014\u2013]/.test(hint), 'must contain zero em-dashes (U+2014) or en-dashes (U+2013)');
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 7: Shim's tier0Response is byte-identical to chokepoint's tier0Response
+//         (delegation property -- the shim's local function is a one-line
+//          passthrough to the chokepoint).
+// ---------------------------------------------------------------------------
+(function test7_delegation_property() {
+  const label = 'shim tier0Response delegates to chokepoint (byte-identical output for all 6 tool names)';
+  try {
+    delete require.cache[CHOKEPOINT_PATH];
+    const chokepoint = require(CHOKEPOINT_PATH);
+    // Read the shim source and verify it requires the chokepoint module.
+    const src = fs.readFileSync(SHIM_PATH, 'utf8');
+    assert.match(src, /require\(['"][^'"]*tier0-messaging\.cjs['"]\)/,
+      'shim source must require lib/core/tier0-messaging.cjs');
+    // Verify the chokepoint's response matches the wire shape for each tool.
+    const toolNames = ['brain_ask', 'brain_query', 'brain_schema', 'brain_search', 'brain_stats', 'brain_write'];
+    for (const name of toolNames) {
+      const r = chokepoint.tier0Response(name);
+      assert.equal(r.status, 'DIRECTOR_NOT_AVAILABLE', 'chokepoint status for ' + name);
+      assert.equal(r.command_context, name, 'chokepoint command_context for ' + name);
+      assert.equal(r.reason, 'MINDRIAN_BRAIN_KEY not set', 'chokepoint reason for ' + name);
+    }
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Test 8: Plan 127-00's mindrian-brain-shim.test.cjs still passes after
+//         the refactor (non-breaking chokepoint introduction).
+// ---------------------------------------------------------------------------
+(function test8_shim_tests_preserved() {
+  const label = 'plan 127-00 shim test file still PASSES after refactor';
+  try {
+    const result = cp.spawnSync(process.execPath, [SHIM_TEST_PATH], {
+      encoding: 'utf8',
+      timeout: 15000,
+    });
+    if (result.status !== 0) {
+      throw new Error('shim test exited ' + result.status + '\nstdout:\n' + result.stdout + '\nstderr:\n' + result.stderr);
+    }
+    // Confirm all 6 tests passed.
+    assert.match(result.stdout, /PASSED:\s*6/, 'expected 6 shim tests to pass; got:\n' + result.stdout);
+    assert.match(result.stdout, /FAILED:\s*0/, 'expected 0 shim test failures; got:\n' + result.stdout);
+    ok(label);
+  } catch (e) { fail(label, e); }
+})();
+
+// ---------------------------------------------------------------------------
+// Summary
+// ---------------------------------------------------------------------------
+process.stdout.write('\nPASSED: ' + passed + '\nFAILED: ' + failed + '\n');
+process.exit(failed === 0 ? 0 : 1);

package/lib/memory/brain-derivation-graceful-degradation.test.cjs

@@ -620,8 +620,8 @@ async function main() {
   //         category); no BRAIN.md; no tmpfile.
   await runScenario('Scenario 07: Network partition', async function () {
     installMockBrainClient({
-      query: function () { throw new Error('ECONNREFUSED brain.mindrian.ai:443'); },
-      search: function () { throw new Error('ECONNREFUSED brain.mindrian.ai:443'); },
+      query: function () { throw new Error('ECONNREFUSED mindrian-brain.onrender.com:443'); },
+      search: function () { throw new Error('ECONNREFUSED mindrian-brain.onrender.com:443'); },
     });
     const { sections } = buildRoom({ tag: 's07', count: 1 });
     const s = sections[0];

package/lib/memory/mos-status-renderer.test.cjs

@@ -37,7 +37,7 @@
  *   6.  --stale-only flag: renders only stale sections + summary.
  *   7.  <section> argument: renders that section's full triple (not truncated).
  *   8.  Missing room: prints "no active room; /mos:rooms to list" + exit 0.
- *   9.  Zero external network: no fetch/http/brain.mindrian.ai strings in the
+ *   9.  Zero external network: no fetch/http/mindrian-brain.onrender.com strings in the
  *       renderer source.
  *  10.  Shape E zones present: header + rows + summary + actions.
  *  11.  Warm-cache path: if statusline-cache has fresh data for the section,
@@ -468,7 +468,7 @@ assert.equal(
   const src = fs.readFileSync(RENDERER, 'utf8');
   // Canon Part 8: the renderer must be strictly LOCAL.
   const forbidden = [
-    'brain.mindrian.ai',
+    'mindrian-brain.onrender.com',
     'http://',
     'https://',
     'require(\'node:http\')',

package/lib/memory/navigation-engine-core.test.cjs

@@ -639,7 +639,7 @@ if (engineLoadable()) {
   run('Test 29: FORBIDDEN Brain network calls (grep)', () => {
     const src = fs.readFileSync(ENGINE_PATH, 'utf8');
     // Forbidden: brain-client.query / search / smartSearch and any direct
-    // network egress to brain.mindrian.ai or fetch/curl for Brain.
+    // network egress to mindrian-brain.onrender.com or fetch/curl for Brain.
     const reBad = /brain[-_]?client\s*\.\s*(query|search|smartSearch)\b|brain\.mindrian\.ai|\bfetch\s*\(|\bcurl\b/;
     // Allow brain-client.isAvailable and brain-client.schema (Section 9.3).
     // Strip those allowed calls before scanning.

package/lib/memory/run-feynman-tests.cjs

@@ -1586,6 +1586,16 @@ const TEST_FILES = [
   path.join(REPO_ROOT, 'tests', 'test-121-03-room-receipt-emit.cjs'),
   path.join(REPO_ROOT, 'tests', 'test-121-03-command-invocation-hook.cjs'),
   path.join(REPO_ROOT, 'tests', 'test-121-03-drowning-protection.cjs'),
+  // Phase 127.1 brain-graphrag-collapse-pinecone-neo4j-hnsw (Wave 0 harness scaffold + Wave 1/2/3 outputs)
+  //   Surface 1 -> Plan 127.1-01 produces embedding-manifest.fixture.json (12,401 byte-identical SHA256 pairs).
+  //   Surface 2 -> Plan 127.1-02 produces index-config.fixture.json (SHOW INDEXES dim=1024 cosine ONLINE).
+  //   query-embedder -> Plan 127.1-03 produces mcp-server-brain/lib/query-embedder.cjs (server-side e5-large query embedding; hermetic, mocked transport).
+  //   Surface 3 -> Plan 127.1-04 produces overlap-baseline + overlap-neo4j fixtures (BLOCKING gate >= 0.80).
+  // Aggregator: tests/run-all-127.sh. RED-by-design until consumer plans land the fixtures.
+  path.join(REPO_ROOT, 'tests', '127.1-embedding-integrity.test.cjs'),
+  path.join(REPO_ROOT, 'tests', '127.1-index-config.test.cjs'),
+  path.join(REPO_ROOT, 'tests', '127.1-query-embedder.test.cjs'),
+  path.join(REPO_ROOT, 'tests', '127.1-graphrag-overlap.test.cjs'),
 ];
 
 // Exit code convention for child tests: