@mindrian_os/install 1.13.0-beta.17 → 1.13.0-beta.21

package/lib/core/first-touch-version-stamper.cjs

@@ -0,0 +1,113 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * first-touch-version-stamper.cjs
+ * --------------------------------
+ * Phase 121.5-05 Sub-plan F (SEED-007 absorption).
+ *
+ * Pure function module that returns the canonical version stamp for each
+ * first-touch surface (banner / splash / onboard / sessionstart /
+ * operator-update / larry-extended). The string the user sees -- "MindrianOS
+ * v<version>" -- is derived once, here, so the per-surface emission stays in
+ * lock-step with .claude-plugin/plugin.json.
+ *
+ * Source finding (SEED-007, 2026-05-09): a v1.12.0 "Three ways to do this"
+ * greeting was rendering on a stale Windows install with NO version-of-record
+ * visible. The user could not answer "what version am I running?" by LOOKING
+ * at the terminal. This module is the canonical answer to that question.
+ *
+ * Canon Part 7 (Reuse Before Build): the version-of-record source is
+ * .claude-plugin/plugin.json -- the same one scripts/banner already reads via
+ * lib/core/platform.cjs::readPluginJsonVersion. This module wraps that source
+ * with the per-surface rendering contract; it does NOT introduce a second
+ * version-of-record surface.
+ *
+ * Canon Part 8: local-only; no fetch, no Brain, no telemetry egress.
+ *
+ * No emoji. No em-dashes. ASCII-clean source.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SURFACES_PATH = path.join(__dirname, '..', '..', 'data', 'first-touch-surfaces.json');
+const PLUGIN_JSON_PATH = path.join(__dirname, '..', '..', '.claude-plugin', 'plugin.json');
+
+const KNOWN_SURFACES = new Set([
+  'banner',
+  'splash',
+  'onboard',
+  'sessionstart',
+  'operator-update',
+  'larry-extended',
+]);
+
+function readSurfaces() {
+  return JSON.parse(fs.readFileSync(SURFACES_PATH, 'utf8'));
+}
+
+function resolveCurrentVersion() {
+  try {
+    return JSON.parse(fs.readFileSync(PLUGIN_JSON_PATH, 'utf8')).version;
+  } catch (_e) {
+    return 'unknown';
+  }
+}
+
+function stampVersion(surfaceId, version) {
+  if (!KNOWN_SURFACES.has(surfaceId)) {
+    throw new Error('unknown_surface: ' + surfaceId);
+  }
+  const v = version || resolveCurrentVersion();
+  switch (surfaceId) {
+    case 'banner':
+      return 'MindrianOS v' + v;
+    case 'splash':
+      return 'MindrianOS v' + v + ' -- conversation as the product surface';
+    case 'onboard':
+      return 'Welcome to MindrianOS v' + v + '. Let me show you around.';
+    case 'sessionstart':
+    case 'operator-update':
+    case 'larry-extended':
+      return 'MindrianOS v' + v;
+    default:
+      // unreachable: KNOWN_SURFACES gates entry
+      throw new Error('unknown_surface: ' + surfaceId);
+  }
+}
+
+// U+2014 EM DASH detector -- the no-em-dash hard rule scanner uses this
+// (CLAUDE.md / MEMORY feedback_no_emdashes). Written as an escape so this
+// source file stays ASCII-clean.
+const EM_DASH = '\u2014';
+
+function hasEmDash(text) {
+  return typeof text === 'string' && text.indexOf(EM_DASH) >= 0;
+}
+
+module.exports = {
+  stampVersion,
+  resolveCurrentVersion,
+  readSurfaces,
+  hasEmDash,
+  KNOWN_SURFACES,
+};
+
+// Allow CLI invocation: `node lib/core/first-touch-version-stamper.cjs banner`
+if (require.main === module) {
+  const surfaceArg = process.argv[2];
+  if (!surfaceArg) {
+    process.stdout.write(stampVersion('banner') + '\n');
+    process.exit(0);
+  }
+  try {
+    process.stdout.write(stampVersion(surfaceArg) + '\n');
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write('first-touch-version-stamper: ' + e.message + '\n');
+    process.exit(2);
+  }
+}

package/lib/core/larry-thinness-acknowledgment.cjs

@@ -0,0 +1,64 @@
+'use strict';
+/*
+ * Phase 119-02 -- Larry thinness-acknowledgment voice + thin-finding detector.
+ *
+ * Per CONTEXT.md D-05: when Phase 117's composeAutoExploreFinding returns
+ * thin output (null OR <= 1 finding), the room is still scaffolded but
+ * Larry's voice acknowledges thinness honestly via the verbatim copy below.
+ *
+ * The verbatim copy is LOCKED per .planning/phases/119-room-as-receipt-invariant/
+ * 119-02-PLAN.md objective block (lines 89-93). Do NOT paraphrase.
+ *
+ * Em-dash HARD RULE: uses `--` (two ASCII hyphens) NEVER `-` (U+2014).
+ * Smart-quote BAN: uses ASCII apostrophe `'` (0x27) only -- never `’`.
+ *
+ * Canon Part 8 invariant: pure-local module; no Brain call, no telemetry
+ * egress; the voice line is a static string with zero outbound surface.
+ * Canon Part 10 sub-claim 1: Larry IS the product -- the voice line is
+ * the conversational anchor that makes "rooms are receipts" feel honest
+ * rather than apologetic when the source material is thin (D-05).
+ */
+
+// The verbatim D-05 voice line. Locked per the plan. Length: 152 chars (ASCII).
+// Composed via two string literals (concat) for readability; the runtime
+// value is one continuous string.
+const THINNESS_VOICE_LINE =
+  "I made a room around this -- it's mostly empty until we have more to work with. " +
+  "Want to keep going and see what fills in?";
+
+/**
+ * Decide whether the room should surface the thinness acknowledgment to the user.
+ *
+ * Per .planning/phases/119-room-as-receipt-invariant/119-02-PLAN.md Task 1
+ * <behavior> Test 6: D-05 threshold is "2+ findings = substantive; <=1 finding
+ * = thin". The detector treats null / undefined / non-object / missing
+ * findings array / empty findings array / single-finding all as thin.
+ *
+ * @param {object|null} autoExploreFinding  the JSON shape Phase 117 writes
+ *                                          to .mindrian/auto-explore-<material_id>.json
+ *                                          (shape: { material_id, findings: [...], composed_at_ms })
+ * @returns {boolean}  true if Larry should render the thinness voice line
+ */
+function shouldAcknowledgeThinness(autoExploreFinding) {
+  if (autoExploreFinding === null || autoExploreFinding === undefined) return true;
+  if (typeof autoExploreFinding !== 'object') return true;
+  const findings = Array.isArray(autoExploreFinding.findings) ? autoExploreFinding.findings : [];
+  return findings.length <= 1;
+}
+
+/**
+ * Return the verbatim D-05 thinness voice line. Single source of truth -- callers
+ * MUST use this function (or the THINNESS_VOICE_LINE constant) rather than
+ * inlining the string. This avoids cross-file string drift.
+ *
+ * @returns {string}  the locked verbatim voice line
+ */
+function voiceLine() {
+  return THINNESS_VOICE_LINE;
+}
+
+module.exports = {
+  THINNESS_VOICE_LINE: THINNESS_VOICE_LINE,
+  shouldAcknowledgeThinness: shouldAcknowledgeThinness,
+  voiceLine: voiceLine,
+};

package/lib/core/larry-thinness-acknowledgment.test.cjs

@@ -0,0 +1,97 @@
+'use strict';
+/*
+ * Phase 119-02 Task 1 -- test suite for larry-thinness-acknowledgment.cjs.
+ *
+ * Verifies (per CONTEXT.md D-05 verbatim copy lock + the 11 behavior tests in
+ * .planning/phases/119-room-as-receipt-invariant/119-02-PLAN.md Task 1):
+ *   1. THINNESS_VOICE_LINE returns exact verbatim string.
+ *   2. voiceLine() returns the same string as THINNESS_VOICE_LINE.
+ *   3. shouldAcknowledgeThinness(null) -> true.
+ *   4. shouldAcknowledgeThinness({findings:[]}) -> true.
+ *   5. shouldAcknowledgeThinness({findings:[a,b]}) -> false (substantive).
+ *   6. shouldAcknowledgeThinness({findings:[a]}) -> true (D-05 threshold 2+).
+ *   7-10. Template files exist + valid frontmatter (verified by Task 2 + bash gate).
+ *   11. No smart quotes / em-dashes in the verbatim string (ASCII only).
+ */
+
+const assert = require('node:assert');
+const test = require('node:test');
+
+const {
+  THINNESS_VOICE_LINE,
+  shouldAcknowledgeThinness,
+  voiceLine,
+} = require('./larry-thinness-acknowledgment.cjs');
+
+const EXPECTED =
+  "I made a room around this -- it's mostly empty until we have more to work with. " +
+  "Want to keep going and see what fills in?";
+
+test('Test 1: THINNESS_VOICE_LINE is the verbatim D-05 string', () => {
+  assert.strictEqual(THINNESS_VOICE_LINE, EXPECTED);
+});
+
+test('Test 2: voiceLine() returns same string as THINNESS_VOICE_LINE (single source of truth)', () => {
+  assert.strictEqual(voiceLine(), THINNESS_VOICE_LINE);
+});
+
+test('Test 3: shouldAcknowledgeThinness(null) returns true', () => {
+  assert.strictEqual(shouldAcknowledgeThinness(null), true);
+});
+
+test('Test 4: shouldAcknowledgeThinness(undefined) returns true', () => {
+  assert.strictEqual(shouldAcknowledgeThinness(undefined), true);
+});
+
+test('Test 5: shouldAcknowledgeThinness({findings: []}) returns true (empty findings)', () => {
+  assert.strictEqual(shouldAcknowledgeThinness({ findings: [] }), true);
+});
+
+test('Test 6: shouldAcknowledgeThinness({findings: [a, b]}) returns false (substantive, 2+ findings)', () => {
+  const finding = {
+    findings: [
+      { source_pipeline: 'whitespace', hsi_score: 0.7 },
+      { source_pipeline: 'cross-domain', hsi_score: 0.6 },
+    ],
+  };
+  assert.strictEqual(shouldAcknowledgeThinness(finding), false);
+});
+
+test('Test 7: shouldAcknowledgeThinness({findings: [a]}) returns true (1-finding edge case, D-05 threshold)', () => {
+  const finding = {
+    findings: [{ source_pipeline: 'whitespace', hsi_score: 0.3 }],
+  };
+  assert.strictEqual(shouldAcknowledgeThinness(finding), true);
+});
+
+test('Test 8: shouldAcknowledgeThinness on non-object returns true (defensive)', () => {
+  assert.strictEqual(shouldAcknowledgeThinness('not an object'), true);
+  assert.strictEqual(shouldAcknowledgeThinness(42), true);
+});
+
+test('Test 9: shouldAcknowledgeThinness on object without findings array returns true', () => {
+  assert.strictEqual(shouldAcknowledgeThinness({}), true);
+  assert.strictEqual(shouldAcknowledgeThinness({ findings: null }), true);
+});
+
+test('Test 10: THINNESS_VOICE_LINE has no em-dash (em-dash HARD RULE)', () => {
+  // Construct via charCode so this test source itself contains no literal
+  // em-dash (which would self-trip the shell-harness em-dash invariant).
+  const EMDASH = String.fromCharCode(0x2014);
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf(EMDASH), -1, 'em-dash U+2014 present');
+});
+
+test('Test 11: THINNESS_VOICE_LINE has no smart-quote characters (ASCII only)', () => {
+  // Right single quote U+2019, left single quote U+2018, right double U+201D, left double U+201C
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('’'), -1, 'right single quote U+2019 present');
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('‘'), -1, 'left single quote U+2018 present');
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('”'), -1, 'right double quote U+201D present');
+  assert.strictEqual(THINNESS_VOICE_LINE.indexOf('“'), -1, 'left double quote U+201C present');
+});
+
+test('Test 12: THINNESS_VOICE_LINE contains the locked phrase fragments', () => {
+  assert.ok(THINNESS_VOICE_LINE.includes('I made a room around this'), 'opener missing');
+  assert.ok(THINNESS_VOICE_LINE.includes("it's mostly empty"), 'middle (ASCII apostrophe) missing');
+  assert.ok(THINNESS_VOICE_LINE.includes('Want to keep going'), 'continuation invite missing');
+  assert.ok(THINNESS_VOICE_LINE.includes('see what fills in?'), 'closing question missing');
+});

package/lib/core/llm-name-suggester.cjs

@@ -0,0 +1,194 @@
+'use strict';
+/*
+ * Phase 119-01 -- LLM-suggested room name resolver.
+ *
+ * One-shot Haiku 4.5 call seeded with LOCAL Phase 117 auto-explore finding +
+ * Phase 118 MVA brief sentence. Returns a venture-shaped slug suggestion (e.g.
+ * 'acme-robotics', 'quantum-imaging', 'biotech-translation').
+ *
+ * Canon Part 8 invariant: this module MUST NOT invoke any Brain endpoint.
+ * The Brain repository holds GENERIC methodology -- framework chaining rules,
+ * phase progressions -- never user-specific content. A LLM call seeded with
+ * the user's auto-explore output + MVA brief sentence is purely LOCAL: the
+ * model sees the user's content directly via the local Anthropic API path,
+ * and the model's response is consumed locally.
+ *
+ * Canon Part 8 NOTE (REVISION 2026-05-16 Warning 5 fix): this module's fetch
+ * carries user content (the auto_explore_finding summary + the mva_brief_sentence)
+ * to api.anthropic.com. Per the standard plugin LLM usage pattern (precedent:
+ * lib/core/mva-classifier.cjs, lib/agents/mva/*.cjs, lib/chat/fabric-chat.cjs),
+ * this is acceptable: the Anthropic API is the LOCAL LLM transport for the
+ * plugin. The Canon Part 8 boundary covers ONLY the Mindrian-owned Brain MCP
+ * host (the Mindrian-owned methodology repository that must never receive user
+ * data) -- NOT api.anthropic.com (the Anthropic LLM transport). The two are
+ * distinct: Brain is a Mindrian-owned methodology repository that must never
+ * receive user data; api.anthropic.com is a stateless LLM transport.
+ *
+ * Tripwire: scaffold harness Gate 3 + Test 9 grep this module for any Brain-host
+ * substring AND any brain-client require AND any fetch to a brain.* URL; all
+ * three must return 0. This module body therefore avoids the literal Brain-host
+ * hostname string entirely (the scaffold harness uses literal-grep on the
+ * forbidden substring).
+ *
+ * Cost: ~$0.0005 per first-MVA completion (Haiku 4.5 input ~800 tokens,
+ * output ~10 tokens). See CONTEXT.md Architectural Decisions item 1.
+ *
+ * Em-dash discipline: uses `--` never the U+2014 character per memory
+ * feedback_no_emdashes.md.
+ *
+ * Graceful degradation: on LLM error, returns {ok: false, suggested_name:
+ * 'untitled', ...} so the F.1 selector still renders correctly with the
+ * fallback label `[name this room: untitled]`.
+ */
+
+const FALLBACK_SUGGESTION = 'untitled';
+
+// Phase 119-01 REVISION 2026-05-16 (Blocker 2 Option A): HAIKU_MODEL_ID is the
+// project-wide source-of-truth constant. The plan's REVISION text says to
+// import HAIKU_MODEL from lib/core/mva-classifier.cjs::HAIKU_MODEL, BUT
+// inspection of that module's module.exports (verified at lib/core/mva-classifier.cjs
+// line 359-370) shows HAIKU_MODEL is a module-internal const NOT exported. Per
+// Rule 1 deviation, the constant is inlined here with provenance pointing to
+// the source-of-truth declaration at lib/core/mva-classifier.cjs:53. If a
+// future phase exports HAIKU_MODEL, replace the inline literal with a require.
+const HAIKU_MODEL_ID = 'claude-haiku-4-5';
+
+/**
+ * suggestRoomName({auto_explore_finding, mva_brief_sentence, opts})
+ * @returns {Promise<{ok, suggested_name, model_used, latency_ms, error_short?}>}
+ */
+async function suggestRoomName(args) {
+  const opts = (args && typeof args === 'object') ? args : {};
+  const autoExploreFinding = opts.auto_explore_finding || null;
+  const mvaBriefSentence = (typeof opts.mva_brief_sentence === 'string') ? opts.mva_brief_sentence : '';
+  const llmClient = opts.llmClient || null;
+
+  const t0 = Date.now();
+  try {
+    const client = llmClient || _resolveProductionLlmClient();
+    const prompt = _buildLocalPrompt(autoExploreFinding, mvaBriefSentence);
+    const response = await client.complete({
+      model: HAIKU_MODEL_ID,
+      messages: [{ role: 'user', content: prompt }],
+      max_tokens: 20,
+    });
+    const raw = (response && typeof response.content === 'string') ? response.content : '';
+    const normalized = _normalizeSlug(raw);
+    const latency_ms = Date.now() - t0;
+    if (!normalized || normalized.length === 0) {
+      return { ok: false, suggested_name: FALLBACK_SUGGESTION, model_used: HAIKU_MODEL_ID, latency_ms, error_short: 'empty_response' };
+    }
+    return { ok: true, suggested_name: normalized, model_used: HAIKU_MODEL_ID, latency_ms };
+  } catch (err) {
+    const latency_ms = Date.now() - t0;
+    const error_short = String(err && err.message || err).slice(0, 60);
+    return { ok: false, suggested_name: FALLBACK_SUGGESTION, model_used: HAIKU_MODEL_ID, latency_ms, error_short };
+  }
+}
+
+function _buildLocalPrompt(autoExploreFinding, mvaBriefSentence) {
+  // Build a short prompt from LOCAL signals ONLY. The findings array carries
+  // the top whitespace + reverse-salient + cross-domain hits from Phase 117;
+  // the MVA brief sentence is the user's first conversational turn (already
+  // local). NEVER include any Brain-derived suggestion in this prompt.
+  const findingsSummary = _summarizeFindings(autoExploreFinding);
+  return [
+    'You are naming a venture. Suggest a 2-3 word kebab-case slug that captures',
+    'the core domain. Return ONLY the slug -- no prose, no quotes, no markdown.',
+    '',
+    'Brief: ' + (mvaBriefSentence || '(no brief)'),
+    'Findings: ' + findingsSummary,
+    '',
+    'Slug:',
+  ].join('\n');
+}
+
+function _summarizeFindings(autoExploreFinding) {
+  if (!autoExploreFinding || typeof autoExploreFinding !== 'object') return '(none)';
+  const findings = Array.isArray(autoExploreFinding.findings) ? autoExploreFinding.findings : [];
+  if (findings.length === 0) return '(empty)';
+  return findings.slice(0, 3).map(function (f) {
+    const sp = (typeof f.source_pipeline === 'string') ? f.source_pipeline : 'unknown';
+    const hsi = (typeof f.hsi_score === 'number') ? f.hsi_score.toFixed(2) : '?';
+    return sp + ':' + hsi;
+  }).join(', ');
+}
+
+function _normalizeSlug(raw) {
+  if (typeof raw !== 'string') return '';
+  let slug = raw.trim().toLowerCase();
+  // Collapse whitespace to single hyphen; drop everything that's not [a-z0-9-].
+  slug = slug.replace(/\s+/g, '-');
+  slug = slug.replace(/[^a-z0-9-]/g, '');
+  slug = slug.replace(/-{2,}/g, '-');
+  slug = slug.replace(/^-+|-+$/g, '');
+  return slug;
+}
+
+// Phase 119-01 REVISION 2026-05-16 (Blocker 2 Option A): mva-agent-contract.cjs
+// exports {runAgent, validateAgentResult, AGENT_RESULT_SHAPE} ONLY -- no
+// createLlmClient factory exists. The project-wide LLM-call idiom is direct
+// fetch to https://api.anthropic.com/v1/messages with x-api-key header
+// (precedent: lib/core/mva-classifier.cjs::_callHaiku same Haiku 4.5 model,
+// same anthropic-version header pattern, same AbortController timeout).
+//
+// This module mirrors that precedent verbatim. No @anthropic-ai/sdk dependency
+// added. Canon Part 8 invariant preserved: api.anthropic.com is the LOCAL
+// Anthropic API endpoint; the Mindrian-owned Brain MCP host is NEVER contacted.
+const ANTHROPIC_URL = 'https://api.anthropic.com/v1/messages';
+const ANTHROPIC_VERSION = '2023-06-01';
+const LLM_TIMEOUT_MS = 5000;
+
+function _resolveProductionLlmClient() {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey || typeof apiKey !== 'string' || apiKey.length === 0) {
+    throw new Error('anthropic_api_key_missing');
+  }
+  if (typeof fetch !== 'function') {
+    throw new Error('global_fetch_unavailable');
+  }
+  return {
+    complete: async function (req) {
+      const model = req.model || HAIKU_MODEL_ID;
+      const messages = Array.isArray(req.messages) ? req.messages : [];
+      const max_tokens = (typeof req.max_tokens === 'number') ? req.max_tokens : 20;
+      const ctrl = (typeof AbortController === 'function') ? new AbortController() : null;
+      const timer = ctrl ? setTimeout(function () { try { ctrl.abort(); } catch (_e) {} }, LLM_TIMEOUT_MS) : null;
+      try {
+        const res = await fetch(ANTHROPIC_URL, {
+          method: 'POST',
+          headers: {
+            'content-type': 'application/json',
+            'x-api-key': apiKey,
+            'anthropic-version': ANTHROPIC_VERSION,
+          },
+          body: JSON.stringify({ model: model, max_tokens: max_tokens, messages: messages }),
+          signal: ctrl ? ctrl.signal : undefined,
+        });
+        if (!res || !res.ok) {
+          throw new Error('anthropic_http_' + (res ? res.status : 'no_response'));
+        }
+        const j = await res.json();
+        let text = '';
+        if (j && Array.isArray(j.content)) {
+          for (const blk of j.content) {
+            if (blk && blk.type === 'text' && typeof blk.text === 'string') {
+              text += blk.text;
+            }
+          }
+        }
+        return { content: text };
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    },
+  };
+}
+
+module.exports = {
+  suggestRoomName: suggestRoomName,
+  FALLBACK_SUGGESTION: FALLBACK_SUGGESTION,
+  HAIKU_MODEL_ID: HAIKU_MODEL_ID,
+  _normalizeSlug: _normalizeSlug,
+  _buildLocalPrompt: _buildLocalPrompt,
+};

package/lib/core/llm-name-suggester.test.cjs

@@ -0,0 +1,132 @@
+'use strict';
+// Phase 119-01 Task 1 tests for lib/core/llm-name-suggester.cjs.
+// Validates HAIKU_MODEL_ID + FALLBACK_SUGGESTION + suggestRoomName happy path +
+// graceful degradation + Canon Part 8 LOCAL invariant (zero brain.mindrian
+// substrings in module source) + EVENT_TYPES floor + room_discard_partial_failure
+// membership.
+
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const crypto = require('node:crypto');
+
+const suggester = require('./llm-name-suggester.cjs');
+const memoryEvents = require('./navigation/memory-events.cjs');
+
+// ---------------------------------------------------------------------------
+// EVENT_TYPES tests (floor + named membership)
+// ---------------------------------------------------------------------------
+
+test('Test 1: EVENT_TYPES Set size grows by at least 1 above the Plan 119-00 baseline (floor >= 42)', function () {
+  assert.ok(memoryEvents.EVENT_TYPES.size >= 42,
+    'EVENT_TYPES.size must be >= 42 (38 baseline + 3 from Plan 119-00 + 1 from this plan); got ' + memoryEvents.EVENT_TYPES.size);
+});
+
+test('Test 2: room_discard_partial_failure is in EVENT_TYPES; regression check on Plan 119-00 strings preserved', function () {
+  assert.ok(memoryEvents.EVENT_TYPES.has('room_discard_partial_failure'), 'room_discard_partial_failure missing');
+  assert.ok(memoryEvents.EVENT_TYPES.has('room_auto_created'), 'Plan 119-00 string room_auto_created regressed');
+  assert.ok(memoryEvents.EVENT_TYPES.has('room_naming_decided'), 'Plan 119-00 string room_naming_decided regressed');
+  assert.ok(memoryEvents.EVENT_TYPES.has('room_discarded'), 'Plan 119-00 string room_discarded regressed');
+});
+
+test('Test 3: EVENT_TYPES object is Object.frozen (own-properties invariant)', function () {
+  assert.ok(Object.isFrozen(memoryEvents.EVENT_TYPES),
+    'EVENT_TYPES Set must be Object.frozen (own-properties; the internal Set slot is documentation-only frozen per ECMAScript spec)');
+});
+
+test('Test 4: logEvent acceptance round-trip for room_discard_partial_failure', function () {
+  // Use a real tmp room.db via room-db.cjs::openRoomDb (the canonical opener).
+  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'lln-suggester-test-'));
+  try {
+    const { openRoomDb, closeRoomDb } = require('./room-db.cjs');
+    const db = openRoomDb(tmpRoot);
+    try {
+      const result = memoryEvents.logEvent(db, 'room_discard_partial_failure', {
+        previous_slug: 'untitled-2026-05-16-1845',
+        partial_state: { fs_removed: true, registry_purged: false },
+        error_short: 'EBUSY',
+        source_path: 'system:room-discard-cascade',
+        created_by: 'system',
+      });
+      assert.strictEqual(result.ok, true, 'logEvent must accept room_discard_partial_failure as a valid event_type');
+      assert.match(result.eventId, /^memory_event:room_discard_partial_failure:\d+:[0-9a-f]{8}$/);
+    } finally {
+      closeRoomDb(db);
+    }
+  } finally {
+    try { fs.rmSync(tmpRoot, { recursive: true, force: true }); } catch (_e) {}
+  }
+});
+
+// ---------------------------------------------------------------------------
+// suggestRoomName tests
+// ---------------------------------------------------------------------------
+
+test('Test 5: HAIKU_MODEL_ID constant equals claude-haiku-4-5 (mirrors lib/core/mva-classifier.cjs:53)', function () {
+  assert.strictEqual(suggester.HAIKU_MODEL_ID, 'claude-haiku-4-5');
+});
+
+test('Test 6: FALLBACK_SUGGESTION constant equals untitled (verbatim)', function () {
+  assert.strictEqual(suggester.FALLBACK_SUGGESTION, 'untitled');
+});
+
+test('Test 7: suggestRoomName happy path returns normalized slug', async function () {
+  const stub = { complete: async function () { return { content: 'acme-robotics' }; } };
+  const r = await suggester.suggestRoomName({
+    auto_explore_finding: { findings: [{ source_pipeline: 'whitespace', hsi_score: 0.83 }] },
+    mva_brief_sentence: 'Robotic precision for industrial automation.',
+    llmClient: stub,
+  });
+  assert.strictEqual(r.ok, true);
+  assert.strictEqual(r.suggested_name, 'acme-robotics');
+  assert.strictEqual(r.model_used, 'claude-haiku-4-5');
+  assert.ok(typeof r.latency_ms === 'number' && r.latency_ms >= 0);
+});
+
+test('Test 8: suggestRoomName graceful degradation on LLM error -> FALLBACK_SUGGESTION', async function () {
+  const stub = { complete: async function () { throw new Error('timeout'); } };
+  const r = await suggester.suggestRoomName({
+    auto_explore_finding: null,
+    mva_brief_sentence: '',
+    llmClient: stub,
+  });
+  assert.strictEqual(r.ok, false);
+  assert.strictEqual(r.suggested_name, 'untitled');
+  assert.strictEqual(r.model_used, 'claude-haiku-4-5');
+  assert.ok(typeof r.latency_ms === 'number' && r.latency_ms >= 0);
+  assert.ok(typeof r.error_short === 'string' && r.error_short.length > 0);
+});
+
+test('Test 9: Canon Part 8 LOCAL invariant -- grep tripwire on llm-name-suggester source', function () {
+  const src = fs.readFileSync(require.resolve('./llm-name-suggester.cjs'), 'utf8');
+  // The forbidden Brain coupling regex (from the plan scaffold harness Gate 3):
+  // brain.mindrian | require.+brain-client | fetch.+brain
+  assert.ok(!/brain\.mindrian/.test(src), 'source contains brain.mindrian substring (Canon Part 8 breach)');
+  assert.ok(!/require\([^)]*brain-client[^)]*\)/.test(src), 'source requires a brain-client module (Canon Part 8 breach)');
+  // The fetch.+brain regex would match commentary about "brain" near a fetch
+  // discussion; we narrow to actual fetch() invocations to brain.* hosts:
+  assert.ok(!/fetch\([^)]*['\"][^'\"]*brain[^'\"]*['\"]/.test(src), 'source fetches a brain.* URL (Canon Part 8 breach)');
+});
+
+test('Test 10: Canon Part 8 LOCAL invariant -- payload audit (constructed prompt contains no Brain handle)', function () {
+  const prompt = suggester._buildLocalPrompt({
+    findings: [{ source_pipeline: 'whitespace', hsi_score: 0.5 }],
+  }, 'AI-assisted protein folding for drug discovery.');
+  const serialized = JSON.stringify(prompt);
+  assert.ok(serialized.indexOf('brain.mindrian') === -1, 'prompt must not contain brain.mindrian');
+  assert.ok(serialized.indexOf('brain-client') === -1, 'prompt must not contain brain-client handle');
+});
+
+// ---------------------------------------------------------------------------
+// Em-dash invariant on the test file itself + module source
+// ---------------------------------------------------------------------------
+
+test('Test 11: zero em-dashes in llm-name-suggester source + this test file', function () {
+  const EMDASH = String.fromCharCode(0x2014);
+  const src = fs.readFileSync(require.resolve('./llm-name-suggester.cjs'), 'utf8');
+  const testSrc = fs.readFileSync(__filename, 'utf8');
+  assert.ok(src.indexOf(EMDASH) === -1, 'em-dash present in llm-name-suggester.cjs (HARD RULE)');
+  assert.ok(testSrc.indexOf(EMDASH) === -1, 'em-dash present in llm-name-suggester.test.cjs (HARD RULE)');
+});

package/lib/core/mcp-profiles.cjs

@@ -19,7 +19,7 @@ const { safeReadFile } = require('./index.cjs');
  *   - maxTools: soft limit on exposed tools (for context budget)
  *
  * Server keys map to entries in .mcp.json:
- *   - brain: brain.mindrian.ai (remote, Streamable HTTP)
+ *   - brain: mindrian-brain.onrender.com (remote, Streamable HTTP)
  *   - mindrian: MindrianOS local MCP server
  *   - research: web research tools
  *   - pinecone: vector search