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

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/core/venture-shape-nudge.cjs

@@ -0,0 +1,163 @@
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Phase 119-00 Wave 1 -- Venture-Shaped-Turn Nudge (D-02 detector).
+ *
+ * shouldSurfaceNudge(roomDir, opts) -> {surface, turn_count, threshold, skip_reason?}
+ *
+ * D-02 invariant: after N=3 consecutive venture-shaped conversational turns
+ * with no upload AND no active room, surface an F.1 selector offering
+ * [upload material] / [/mos:new-project] / [keep talking]. This is the ONLY
+ * auto-create-adjacent path for prompt-only sessions (D-01 prohibits
+ * auto-creating from prompts alone).
+ *
+ * D-01 invariant: the upload path takes precedence. If any
+ * 'auto_explore_fired' event appears in the recent window, the nudge does
+ * NOT surface -- the Phase 117 detector is already handling first-material.
+ *
+ * Canon Part 8 boundary -- user_text classification:
+ *   The user-conversational "venture-shaped" classification CANNOT run on
+ *   raw user text inside this module. The event-log schema (per Canon Part
+ *   8 fence + Phase 90-06 cross-room aggregator) structurally excludes
+ *   user_text -- the memory_event log is queried by cross-room aggregators
+ *   and storing raw user content there would breach the boundary.
+ *
+ *   Alternative signal contract: the upstream telemetry surface (the
+ *   PostToolUse / UserPromptSubmit hook OR the Phase 115 dual-path-detector
+ *   seam) classifies sentences at WRITE TIME via
+ *   lib/core/mva-classifier.cjs::classify and stores ONLY a scalar boolean
+ *   `venture_classified` + classification_source enum in
+ *   f_selector_decision.properties. The nudge module reads the scalar at
+ *   decision time.
+ *
+ *   v1.13.0 safe-default: if `properties.venture_classified` is structurally
+ *   absent at execution time, the nudge degrades to surface:false with
+ *   skip_reason:'venture_classification_unavailable'. A v1.14.0 phase wires
+ *   the upstream classification at the f_selector_decision emission site.
+ *
+ * Canon Part 9 chokepoint:
+ *   - All reads route through lib/core/navigation.cjs::findRecentChanges.
+ *   - room.db is opened via node:sqlite DatabaseSync directly (mirrors the
+ *     Phase 117 scripts/auto-explore-fingerprint.cjs pattern; node:sqlite
+ *     usage from a CLI-adjacent module is not a chokepoint violation per
+ *     the Phase 109-06 pre-commit hook which gates only direct require of
+ *     room-db.cjs).
+ *
+ * Pure CJS, node built-ins + lib/core/navigation. NO require of room-db.cjs.
+ * NO require of dual-path-detector.cjs at read-time (the upstream
+ * classification has already happened at write-time per the alternative
+ * signal contract above). NO require of brain-client. Canon Part 8 preserved.
+ */
+
+const path = require('node:path');
+const fs = require('node:fs');
+
+const VENTURE_NUDGE_THRESHOLD = 3;
+
+/**
+ * shouldSurfaceNudge(roomDir, opts) -> { surface, turn_count, threshold, skip_reason? }
+ *
+ * @param {string} roomDir - absolute path to a room directory.
+ * @param {object} [opts]  - reserved for future extension (D-02 threshold override).
+ * @returns {object}
+ */
+function shouldSurfaceNudge(roomDir, opts) {
+  const options = opts || {};
+  const threshold = Number.isInteger(options.threshold) && options.threshold > 0
+    ? options.threshold
+    : VENTURE_NUDGE_THRESHOLD;
+
+  // Guard 1: no roomDir -> safe default.
+  if (!roomDir || typeof roomDir !== 'string') {
+    return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'no_room_dir' };
+  }
+
+  // Guard 2: room.db missing -> cold-start safe default. No false positives.
+  const dbPath = path.join(roomDir, '.mindrian', 'room.db');
+  if (!fs.existsSync(dbPath)) {
+    return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'no_room_db' };
+  }
+
+  // Open the db read-only via node:sqlite DatabaseSync. Mirrors the Phase 117
+  // scripts/auto-explore-fingerprint.cjs::dailyCapHit() pattern. Lazy-require
+  // so environments lacking node:sqlite degrade to surface:false.
+  let DatabaseSync;
+  try {
+    ({ DatabaseSync } = require('node:sqlite'));
+  } catch (_e) {
+    return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'no_sqlite' };
+  }
+
+  let db;
+  try {
+    db = new DatabaseSync(dbPath);
+  } catch (_e) {
+    return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'db_open_failed' };
+  }
+
+  let recent;
+  try {
+    const navigation = require('./navigation.cjs');
+    // Window = last 24 hours; cap at 200 events for safety.
+    const sinceMs = Date.now() - (24 * 60 * 60 * 1000);
+    recent = navigation.findRecentChanges(db, sinceMs, { limit: 200 });
+  } catch (_e) {
+    try { db.close(); } catch (_ignore) { /* graceful */ }
+    return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'navigation_query_failed' };
+  } finally {
+    try { db.close(); } catch (_ignore) { /* graceful */ }
+  }
+
+  if (!Array.isArray(recent)) {
+    return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'empty_window' };
+  }
+
+  // D-01 invariant short-circuit: upload path takes precedence.
+  for (const event of recent) {
+    if (event && event.eventType === 'auto_explore_fired') {
+      return { surface: false, turn_count: 0, threshold: threshold, skip_reason: 'upload_path_active' };
+    }
+  }
+
+  // Filter to user-conversational-turn signal events. For v1.13.0-beta.18
+  // scope, "conversational turn" is approximated by f_selector_decision
+  // (the event that fires on every meaningful F-shape selection per Phase
+  // 125-06). focus_changed is intentionally excluded -- it is a navigation
+  // event, not a conversation turn. Precise per-turn detection is deferred
+  // to Phase 121 trajectory telemetry.
+  //
+  // Per Canon Part 8 alternative signal contract: count only events where
+  // properties.venture_classified === true. If the field is structurally
+  // absent (NO event in the window carries it), degrade to safe-default
+  // skip_reason:'venture_classification_unavailable' -- the v1.14.0
+  // upstream-classification surface has not yet wired the scalar.
+  let turnCount = 0;
+  let sawClassifiedField = false;
+  for (const event of recent) {
+    if (!event || event.eventType !== 'f_selector_decision') continue;
+    const props = event.properties || {};
+    if (typeof props.venture_classified === 'boolean') {
+      sawClassifiedField = true;
+      if (props.venture_classified === true) turnCount += 1;
+    }
+  }
+
+  if (!sawClassifiedField) {
+    return {
+      surface: false,
+      turn_count: 0,
+      threshold: threshold,
+      skip_reason: 'venture_classification_unavailable',
+    };
+  }
+
+  const surface = turnCount >= threshold;
+  return { surface: surface, turn_count: turnCount, threshold: threshold };
+}
+
+module.exports = {
+  shouldSurfaceNudge: shouldSurfaceNudge,
+  VENTURE_NUDGE_THRESHOLD: VENTURE_NUDGE_THRESHOLD,
+};

package/lib/core/venture-shape-nudge.test.cjs

@@ -0,0 +1,161 @@
+'use strict';
+
+/*
+ * Phase 119-00 Wave 1 -- venture-shape-nudge module tests.
+ *
+ * Mirrors the lib/memory/selector-decisions.test.cjs fixture pattern
+ * (fs.mkdtempSync + openRoomDb). Tests are allowed to require room-db.cjs
+ * directly per the Phase 109-06 pre-commit chokepoint allow-list for tests/.
+ *
+ * Covers the 7 behavior axes from 119-00-PLAN.md Task 1:
+ *   Test 1 -- cold-start floor (Test 5 in plan: no room.db -> surface false)
+ *   Test 2 -- venture-shape accumulation to threshold (Test 6)
+ *   Test 3 -- D-01 invariant: auto_explore_fired short-circuits (Test 7)
+ *   Test 4 -- venture_classification_unavailable safe-default (Test 7b)
+ *   Test 5 -- venture_classified present happy-path (Test 7c)
+ *   Test 6 -- no Brain client require (Test 8; source-grep audit)
+ *   Test 7 -- no-room-dir guard
+ */
+
+const { test } = require('node:test');
+const { strict: assert } = require('node:assert');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const { openRoomDb } = require(path.join(REPO_ROOT, 'lib', 'core', 'room-db.cjs'));
+const navigation = require(path.join(REPO_ROOT, 'lib', 'core', 'navigation.cjs'));
+const ventureShapeNudge = require(path.join(REPO_ROOT, 'lib', 'core', 'venture-shape-nudge.cjs'));
+
+function freshRoom() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'p119-00-nudge-'));
+  fs.mkdirSync(path.join(dir, '.mindrian'), { recursive: true });
+  const db = openRoomDb(dir);
+  return { dir, db };
+}
+
+function closeQuiet(db) {
+  try { db.close(); } catch (_e) { /* graceful */ }
+}
+
+test('Test 1: cold-start floor -- no events in db returns surface:false with venture_classification_unavailable', () => {
+  const { dir, db } = freshRoom();
+  closeQuiet(db);
+  const r = ventureShapeNudge.shouldSurfaceNudge(dir, {});
+  assert.equal(r.surface, false);
+  assert.equal(r.turn_count, 0);
+  assert.equal(r.threshold, 3);
+  assert.equal(r.skip_reason, 'venture_classification_unavailable');
+});
+
+test('Test 2: 3 venture_classified=true events reach threshold (surface=true)', () => {
+  const { dir, db } = freshRoom();
+  for (let i = 0; i < 3; i++) {
+    const result = navigation.logMemoryEvent(db, 'f_selector_decision', {
+      venture_classified: true,
+      classification_source: 'haiku-4-5',
+      source_path: 'test:venture-shape-nudge',
+      created_by: 'system',
+    });
+    assert.equal(result.ok, true, 'logMemoryEvent should accept f_selector_decision; got reason=' + (result.reason || ''));
+  }
+  closeQuiet(db);
+  const r = ventureShapeNudge.shouldSurfaceNudge(dir, {});
+  assert.equal(r.surface, true);
+  assert.equal(r.turn_count, 3);
+  assert.equal(r.threshold, 3);
+  assert.equal(r.skip_reason, undefined);
+});
+
+test('Test 3: D-01 invariant -- auto_explore_fired short-circuits regardless of turn count', () => {
+  const { dir, db } = freshRoom();
+  // Seed 5 venture-shaped turns AND one auto_explore_fired event.
+  for (let i = 0; i < 5; i++) {
+    navigation.logMemoryEvent(db, 'f_selector_decision', {
+      venture_classified: true,
+      classification_source: 'haiku-4-5',
+      source_path: 'test:venture-shape-nudge',
+    });
+  }
+  navigation.logMemoryEvent(db, 'auto_explore_fired', {
+    material_id: 'abcd1234',
+    relative_file_path: 'docs/sample.md',
+    room_slug: 'test-room',
+    tier: 1,
+    surfacing_count: 0,
+    brain_baseline_present: false,
+    source_path: 'test:venture-shape-nudge',
+  });
+  closeQuiet(db);
+  const r = ventureShapeNudge.shouldSurfaceNudge(dir, {});
+  assert.equal(r.surface, false);
+  assert.equal(r.skip_reason, 'upload_path_active');
+});
+
+test('Test 4: venture_classification_unavailable safe-default when field absent', () => {
+  const { dir, db } = freshRoom();
+  // Seed events without venture_classified field at all.
+  for (let i = 0; i < 5; i++) {
+    navigation.logMemoryEvent(db, 'f_selector_decision', {
+      command: 'mos:test',
+      framework: 'test-framework',
+      source_path: 'test:venture-shape-nudge',
+    });
+  }
+  closeQuiet(db);
+  const r = ventureShapeNudge.shouldSurfaceNudge(dir, {});
+  assert.equal(r.surface, false);
+  assert.equal(r.skip_reason, 'venture_classification_unavailable');
+  assert.equal(r.turn_count, 0);
+});
+
+test('Test 5: mixed venture_classified true/false -- only true counts toward threshold', () => {
+  const { dir, db } = freshRoom();
+  // 3 true + 1 false; threshold=3 met.
+  for (let i = 0; i < 3; i++) {
+    navigation.logMemoryEvent(db, 'f_selector_decision', {
+      venture_classified: true,
+      classification_source: 'haiku-4-5',
+      source_path: 'test:venture-shape-nudge',
+    });
+  }
+  navigation.logMemoryEvent(db, 'f_selector_decision', {
+    venture_classified: false,
+    classification_source: 'haiku-4-5',
+    source_path: 'test:venture-shape-nudge',
+  });
+  closeQuiet(db);
+  const r = ventureShapeNudge.shouldSurfaceNudge(dir, {});
+  assert.equal(r.surface, true);
+  assert.equal(r.turn_count, 3);
+});
+
+test('Test 6: no Brain client require -- source-grep audit', () => {
+  const src = fs.readFileSync(path.join(REPO_ROOT, 'lib', 'core', 'venture-shape-nudge.cjs'), 'utf8');
+  // Canon Part 8: zero brain-client require, zero mcp-server-brain require,
+  // zero fetch to brain.mindrian.
+  assert.equal(/require\([^)]*brain-client/.test(src), false, 'brain-client require detected');
+  assert.equal(/require\([^)]*mcp-server-brain/.test(src), false, 'mcp-server-brain require detected');
+  assert.equal(/brain\.mindrian/.test(src), false, 'brain.mindrian fetch reference detected');
+  // Canon Part 9: zero direct room-db.cjs require.
+  assert.equal(/require\([^)]*room-db\.cjs/.test(src), false, 'direct room-db.cjs require detected');
+});
+
+test('Test 7: no-room-dir guard returns safe default', () => {
+  const r = ventureShapeNudge.shouldSurfaceNudge('', {});
+  assert.equal(r.surface, false);
+  assert.equal(r.skip_reason, 'no_room_dir');
+
+  const r2 = ventureShapeNudge.shouldSurfaceNudge(null, {});
+  assert.equal(r2.surface, false);
+
+  // Non-existent path -> no_room_db.
+  const r3 = ventureShapeNudge.shouldSurfaceNudge('/tmp/p119-nonexistent-' + Date.now(), {});
+  assert.equal(r3.surface, false);
+  assert.equal(r3.skip_reason, 'no_room_db');
+});
+
+test('Test 8: VENTURE_NUDGE_THRESHOLD constant exported and equals 3', () => {
+  assert.equal(ventureShapeNudge.VENTURE_NUDGE_THRESHOLD, 3);
+});

package/lib/core/visual-ops.cjs

@@ -173,8 +173,19 @@ function formatSectionHeader(sectionName, entryCount, stage) {
 // MERMAID DIAGRAM GENERATORS
 // ═══════════════════════════════════════════════════════════════
 
-// De Stijl hex colors for Mermaid style directives (no ANSI in diagrams)
-const DS_HEX = {
+// De Stijl hex colors for Mermaid style directives (no ANSI in diagrams).
+//
+// Phase 121.5-03: DS_HEX is now SOURCED FROM references/visual/palette.json
+// (the canonical De Stijl source-of-truth per ODD 3 resolution + Canon Part 7).
+// The literal fallback below is graceful degradation only -- if palette.json
+// fails to load (unlikely in a properly-installed plugin), the shipping
+// values are frozen here verbatim from the pre-121.5 hardcoded DS_HEX so
+// downstream Mermaid + dashboard rendering keeps working.
+//
+// Test seam: MINDRIAN_PALETTE_PATH env var overrides the default palette
+// path. Used by lib/memory/statusline-two-row.test.cjs (test 11) to verify
+// the wiring without touching the live palette.json.
+const FALLBACK_DS_HEX = {
   red: '#A63D2F',
   blue: '#1E3A6E',
   yellow: '#C8A43C',
@@ -186,6 +197,63 @@ const DS_HEX = {
   bg: '#0D0D0D'
 };
 
+/**
+ * Compose DS_HEX from references/visual/palette.json. Preserves the legacy
+ * key names (red / blue / yellow / green / sienna / amethyst / cream / muted
+ * / bg) so existing consumers (Mermaid generators, dashboard exporters) keep
+ * working byte-identical. Also exposes the palette tier keys via dot
+ * extension for new consumers (e.g. mondrian_red, muted_green, saturated_blue).
+ */
+function loadPaletteDsHex() {
+  const path = require('path');
+  const fs = require('fs');
+  const candidate = process.env.MINDRIAN_PALETTE_PATH ||
+    path.join(__dirname, '..', '..', 'references', 'visual', 'palette.json');
+  try {
+    const palette = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+    const base = palette.base || {};
+    const a = palette.palette_a_discovery || {};
+    const b = palette.palette_b_build || {};
+    const ext = palette.extended || {};
+    const composed = {
+      // Legacy DS_HEX keys (preserve backward compat for Mermaid + dashboard)
+      red:      base.mondrian_red    || FALLBACK_DS_HEX.red,
+      blue:     base.mondrian_blue   || FALLBACK_DS_HEX.blue,
+      yellow:   base.mondrian_yellow || FALLBACK_DS_HEX.yellow,
+      green:    base.success_green   || FALLBACK_DS_HEX.green,
+      sienna:   ext.sienna           || FALLBACK_DS_HEX.sienna,
+      amethyst: base.amethyst        || FALLBACK_DS_HEX.amethyst,
+      cream:    base.cream           || FALLBACK_DS_HEX.cream,
+      muted:    base.gray_meta       || FALLBACK_DS_HEX.muted,
+      bg:       ext.bg               || base.mondrian_black || FALLBACK_DS_HEX.bg,
+      // Tier-keyed mirrors (new consumers can use the explicit names)
+      mondrian_red:    base.mondrian_red,
+      mondrian_blue:   base.mondrian_blue,
+      mondrian_yellow: base.mondrian_yellow,
+      mondrian_black:  base.mondrian_black,
+      mondrian_white:  base.mondrian_white,
+      gray_meta:       base.gray_meta,
+      success_green:   base.success_green,
+      muted_red:       a.muted_red,
+      muted_green:     a.muted_green,
+      teal_accent:     a.teal_accent,
+      saturated_red:    b.saturated_red,
+      saturated_blue:   b.saturated_blue,
+      saturated_yellow: b.saturated_yellow,
+    };
+    return composed;
+  } catch (e) {
+    // Graceful degradation per Canon Part 7. One warning to stderr, then
+    // fall back to the frozen literal.
+    if (process.env.MINDRIAN_PALETTE_DEBUG) {
+      try { process.stderr.write('[visual-ops] palette.json load failed: ' + e.message + '\n'); } catch (_) {}
+    }
+    return Object.assign({}, FALLBACK_DS_HEX);
+  }
+}
+
+const DS_HEX = loadPaletteDsHex();
+
 // Map stage names to hex colors for Mermaid
 const STAGE_HEX = {
   preopportunity: DS_HEX.muted,