@mindrian_os/install 1.13.0-beta.11

package/lib/memory/brain-server-resolution.test.cjs

@@ -0,0 +1,314 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Phase 94-03 -- canonical Brain MCP server-name resolution fence.
+ *
+ * BSL 1.1. Copyright (c) Mindrian 2026.
+ * (Business Source License 1.1; SPDX BUSL-1.1; see LICENSE.)
+ *
+ * Why this fixture exists.
+ *
+ *   The v1.11.0 QA harness (Lawrence's Dr. Miriam Kaplan persona, 2026-04-28)
+ *   surfaced a P0 ship-blocker (FIX-2): the Brain knowledge graph is alive
+ *   (7,353 LazyGraphConcept nodes, 119,706 CO_OCCURS edges, 20+ named PWS
+ *   frameworks) but unreachable from /mos:* commands. Root cause: plugin
+ *   command frontmatter declared THREE inconsistent server-name prefixes
+ *
+ *     mcp__neo4j-brain__       (5 commands)
+ *     mcp__mindrian-brain__    (6 commands -- already canonical)
+ *     mcp__pinecone-brain__    (3 commands)
+ *
+ *   while .mcp.json declared only `mindrian-os` (the plugin's own MCP
+ *   router, not the Brain). Result: every Brain-touching slash command
+ *   silently fell back to the graceful tier_0 path. Decision-traces
+ *   confirmed routing_source: legacy and brain_md_tier_mode: tier_0
+ *   on every session.
+ *
+ *   Plan 94-03 selects Option A from the QA handoff (cheapest path):
+ *   standardize the canonical server name across all 10 affected command
+ *   frontmatter files on `mindrian-brain`, document the user-side
+ *   .mcp.json snippet, and let users register their Neo4j MCP under the
+ *   canonical name. No alias system. No auto-detect. Both deferred to
+ *   v1.12 per Options B/C.
+ *
+ * Test map (5 cases, one-to-one with the PLAN <behavior> block).
+ *
+ *   T1  Every commands/*.md allowed-tools list mcp__*brain* reference
+ *       starts with the canonical prefix `mcp__mindrian-brain__`. We
+ *       walk the 10 affected files, parse each YAML frontmatter, collect
+ *       allowed-tools entries, and assert any tool matching /^mcp__\\S+brain\\S*__/
+ *       starts with `mcp__mindrian-brain__`.
+ *
+ *   T2  Zero `mcp__neo4j-brain__` references remain in any commands/*.md
+ *       (frontmatter OR body prose). grep -lE pattern.
+ *
+ *   T3  Zero `mcp__pinecone-brain__` references remain in any commands/*.md
+ *       (frontmatter OR body prose). grep -lE pattern.
+ *
+ *   T4  docs/install/BRAIN-SETUP.md exists and contains the literal
+ *       substring `mindrian-brain` (canonical name) AND the literal
+ *       substring `mcpServers` (user-side .mcp.json snippet shape).
+ *
+ *   T5  Optional gate: scripts/frontmatter-schema-validator.cjs (Phase
+ *       88.1-07) returns exit 0 against each of the 10 modified command
+ *       files. The validator is ADVISORY (PostToolUse) -- it always
+ *       exits 0 regardless of violations -- so this case is structural:
+ *       prove the validator is invokable against each file without
+ *       crashing. Skip gracefully (PASS-and-warn) if the validator is
+ *       absent in this checkout.
+ *
+ * Canon traceability.
+ *
+ *   Part 7 (Reuse Before Build): Option A is the cheapest sweep -- no
+ *   new alias system, no auto-detect, no new MCP server entry in the
+ *   plugin's .mcp.json. We compose existing command frontmatter into
+ *   a single canonical name.
+ *
+ *   Part 8 (Graph Boundary): the Brain query chokepoint behavior is
+ *   unchanged. This plan only standardizes the MCP server name passed
+ *   in. Zero user-data egress added or removed.
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const REPO = path.resolve(__dirname, '..', '..');
+const COMMANDS_DIR = path.join(REPO, 'commands');
+const SETUP_DOC = path.join(REPO, 'docs', 'install', 'BRAIN-SETUP.md');
+const VALIDATOR = path.join(REPO, 'scripts', 'frontmatter-schema-validator.cjs');
+
+// The 10 commands declared by the plan as carrying or potentially carrying
+// Brain MCP references. Order mirrors plan frontmatter files_modified.
+const AFFECTED_COMMANDS = [
+  'compare-ventures',
+  'suggest-next',
+  'find-analogies',
+  'brain-derive',
+  'query',
+  'rs-experts',
+  'rs-explain',
+  'rs-fetch',
+  'rs-thesis',
+  'admin',
+];
+
+const CANONICAL_PREFIX = 'mcp__mindrian-brain__';
+const FORBIDDEN_PREFIXES = ['mcp__neo4j-brain__', 'mcp__pinecone-brain__'];
+
+// ---------- Fixture helpers ----------
+
+function readFile(p) {
+  return fs.readFileSync(p, 'utf8');
+}
+
+/**
+ * Minimal single-key YAML frontmatter parser sufficient for allowed-tools.
+ * Returns the array of allowed-tools entries (raw strings, '- ' stripped),
+ * or [] if no allowed-tools section is found. Tolerant of:
+ *   - inline form: `allowed-tools: Bash(node *)`
+ *   - list form (multi-line dash-prefixed entries)
+ * Does NOT honor nested YAML structures or quoted values; the fixture
+ * does not need them for this contract.
+ */
+function parseAllowedTools(text) {
+  const m = text.match(/^---\n([\s\S]*?)\n---/);
+  if (!m) return [];
+  const fm = m[1];
+  const lines = fm.split('\n');
+  const tools = [];
+  let inList = false;
+  for (const raw of lines) {
+    const line = raw.replace(/\r$/, '');
+    if (/^allowed-tools:\s*$/.test(line)) {
+      inList = true;
+      continue;
+    }
+    if (/^allowed-tools:\s*\S/.test(line)) {
+      // Inline form: allowed-tools: Bash(node *)
+      const inline = line.replace(/^allowed-tools:\s*/, '').trim();
+      if (inline) tools.push(inline);
+      inList = false;
+      continue;
+    }
+    if (inList) {
+      if (/^\s+-\s+/.test(line)) {
+        const v = line.replace(/^\s+-\s+/, '').trim();
+        if (v) tools.push(v);
+        continue;
+      }
+      // Any non-list-item line ends the allowed-tools block.
+      if (/^\S/.test(line)) inList = false;
+    }
+  }
+  return tools;
+}
+
+// ---------- Tests ----------
+
+let passed = 0;
+let failed = 0;
+const fail = (name, msg) => {
+  failed++;
+  process.stderr.write('FAIL ' + name + ': ' + msg + '\n');
+};
+const pass = (name) => {
+  passed++;
+  process.stdout.write('PASS ' + name + '\n');
+};
+
+function t1_canonical_prefix_in_frontmatter() {
+  const name = 'T1 every brain reference in allowed-tools uses canonical prefix';
+  try {
+    const violations = [];
+    for (const cmd of AFFECTED_COMMANDS) {
+      const file = path.join(COMMANDS_DIR, cmd + '.md');
+      if (!fs.existsSync(file)) {
+        violations.push(cmd + ': file missing');
+        continue;
+      }
+      const txt = readFile(file);
+      const tools = parseAllowedTools(txt);
+      for (const tool of tools) {
+        if (/^mcp__\S+brain\S*__/.test(tool)) {
+          if (!tool.startsWith(CANONICAL_PREFIX)) {
+            violations.push(cmd + ': non-canonical brain tool ' + tool);
+          }
+        }
+      }
+    }
+    assert.equal(
+      violations.length,
+      0,
+      'Non-canonical brain tools found:\n  ' + violations.join('\n  ')
+    );
+    pass(name);
+  } catch (e) {
+    fail(name, e.message);
+  }
+}
+
+function t2_no_neo4j_brain_anywhere() {
+  const name = 'T2 zero mcp__neo4j-brain__ references in commands/*.md';
+  try {
+    const matches = [];
+    const files = fs.readdirSync(COMMANDS_DIR)
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => path.join(COMMANDS_DIR, f));
+    for (const f of files) {
+      const txt = readFile(f);
+      if (txt.includes('mcp__neo4j-brain__') || txt.includes('mcp__neo4j-brain ')) {
+        matches.push(path.relative(REPO, f));
+      }
+    }
+    assert.equal(
+      matches.length,
+      0,
+      'mcp__neo4j-brain__ references must be zero, found in:\n  ' + matches.join('\n  ')
+    );
+    pass(name);
+  } catch (e) {
+    fail(name, e.message);
+  }
+}
+
+function t3_no_pinecone_brain_anywhere() {
+  const name = 'T3 zero mcp__pinecone-brain__ references in commands/*.md';
+  try {
+    const matches = [];
+    const files = fs.readdirSync(COMMANDS_DIR)
+      .filter((f) => f.endsWith('.md'))
+      .map((f) => path.join(COMMANDS_DIR, f));
+    for (const f of files) {
+      const txt = readFile(f);
+      if (txt.includes('mcp__pinecone-brain__') || txt.includes('mcp__pinecone-brain ')) {
+        matches.push(path.relative(REPO, f));
+      }
+    }
+    assert.equal(
+      matches.length,
+      0,
+      'mcp__pinecone-brain__ references must be zero, found in:\n  ' + matches.join('\n  ')
+    );
+    pass(name);
+  } catch (e) {
+    fail(name, e.message);
+  }
+}
+
+function t4_brain_setup_doc_exists() {
+  const name = 'T4 docs/install/BRAIN-SETUP.md exists with canonical name + mcpServers snippet';
+  try {
+    assert.ok(
+      fs.existsSync(SETUP_DOC),
+      'docs/install/BRAIN-SETUP.md does not exist'
+    );
+    const txt = readFile(SETUP_DOC);
+    assert.ok(
+      txt.includes('mindrian-brain'),
+      'BRAIN-SETUP.md missing canonical name `mindrian-brain`'
+    );
+    assert.ok(
+      txt.includes('mcpServers'),
+      'BRAIN-SETUP.md missing user-side .mcp.json snippet (`mcpServers`)'
+    );
+    pass(name);
+  } catch (e) {
+    fail(name, e.message);
+  }
+}
+
+function t5_frontmatter_validator_runnable() {
+  const name = 'T5 frontmatter-schema-validator runnable on each modified file';
+  try {
+    if (!fs.existsSync(VALIDATOR)) {
+      // Skip gracefully -- validator is an optional Phase 88.1-07 artifact.
+      process.stdout.write(
+        'SKIP ' + name + ' (validator absent at ' +
+          path.relative(REPO, VALIDATOR) + ')\n'
+      );
+      passed++;
+      return;
+    }
+    // Phase 88.1-07 validator is a PostToolUse hook -- it reads JSON on stdin
+    // and emits a JSON response on stdout. Calling it without stdin will
+    // either no-op or error gracefully. We assert it does not crash with a
+    // non-zero exit on a benign invocation. This is a structural smoke
+    // (the validator is invokable in this checkout), not a content gate.
+    const res = spawnSync(process.execPath, [VALIDATOR, '--help'], {
+      input: '',
+      timeout: 5000,
+    });
+    // Accept exit 0 (help printed) OR exit codes from "missing stdin / not a
+    // hook context" branches. The validator is advisory and never blocks;
+    // the only failure mode that matters here is a hard crash (e.g. syntax
+    // error in the validator source).
+    assert.ok(
+      res.status === null || res.status === 0 || res.status === 1,
+      'frontmatter-schema-validator crashed with unexpected status ' + res.status +
+        ' (signal=' + res.signal + ')\n' +
+        'stderr: ' + (res.stderr ? res.stderr.toString() : '')
+    );
+    pass(name);
+  } catch (e) {
+    fail(name, e.message);
+  }
+}
+
+// ---------- Run ----------
+
+t1_canonical_prefix_in_frontmatter();
+t2_no_neo4j_brain_anywhere();
+t3_no_pinecone_brain_anywhere();
+t4_brain_setup_doc_exists();
+t5_frontmatter_validator_runnable();
+
+const total = passed + failed;
+process.stdout.write(
+  '\nbrain-server-resolution: ' + passed + '/' + total + ' passed\n'
+);
+process.exit(failed === 0 ? 0 : 1);

package/lib/memory/chain-recommender.test.cjs

@@ -0,0 +1,233 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Phase 122-03 -- chain-recommender tests (new suite; registered in the Feynman runner).
+ *
+ * Registered in lib/memory/run-feynman-tests.cjs TEST_FILES[] and in
+ * tests/run-all-122.sh CJS_SUITES (as ../lib/memory/chain-recommender.test.cjs).
+ * Run: node lib/memory/chain-recommender.test.cjs
+ * Exit 0 on pass; throws (node:assert) on any fail.
+ *
+ * Five assertion groups (per 122-03-PLAN.md Task 2 <behavior>):
+ *   1. recommendFrameworkChain({ problemType:'ill-defined' }) -> non-empty
+ *      ordered array of framework-name strings (length 1..4); element 0 is the
+ *      seed (here, the IDP family's first skill resolved through the registry).
+ *   2. recommendFrameworkChain({ currentFramework:'Beautiful Question Framework' })
+ *      -> that framework first; with offline FEEDS_INTO edges supplied via
+ *      roomState, its successors follow in order.
+ *   3. A seed framework with no outgoing FEEDS_INTO edge -> [seed] (degrades
+ *      cleanly, not a crash).
+ *   4. Brain unavailable (monkey-patch brain-client.isAvailable() -> false) ->
+ *      the recommender still returns a chain (offline FEEDS_INTO walk, or [seed]);
+ *      never throws, never returns null.
+ *   5. Canon Part 8: the recommender source contains NO command literal; any
+ *      Cypher-looking string it builds contains only $-bound params (framework
+ *      names / enums) -- no string interpolation of a command, no user-content
+ *      token. The recommender's return value is framework names only.
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..');
+const RECOMMENDER_PATH = path.join(REPO_ROOT, 'lib', 'brain', 'chain-recommender.cjs');
+const REGISTRY_PATH = path.join(REPO_ROOT, 'data', 'command-registry.json');
+
+const recommender = require('../brain/chain-recommender.cjs');
+const composer = require('../core/framework-chain-composer.cjs');
+const problemTypeRouter = require('../core/problem-type-router.cjs');
+const brainClient = require('../core/brain-client.cjs');
+
+const registry = JSON.parse(fs.readFileSync(REGISTRY_PATH, 'utf8'));
+
+let passed = 0;
+function test(name, fn) {
+  fn();
+  process.stdout.write('  ok  ' + name + '\n');
+  passed += 1;
+}
+
+// Derive what the IDP seed framework SHOULD be (so the test is retrofit-proof:
+// it does not hardcode "Beautiful Question Framework", it re-derives it the
+// way the recommender does -- router first skill -> registry first framework).
+function slugToFramework(slug) {
+  for (const c of registry.commands) {
+    if (!c || typeof c.command !== 'string') continue;
+    const parts = c.command.split(':');
+    if (parts.length >= 2 && parts.slice(1).join(':') === slug) {
+      return (Array.isArray(c.frameworks) && c.frameworks.length > 0) ? c.frameworks[0] : null;
+    }
+  }
+  return null;
+}
+const idpSkills = problemTypeRouter.routeByProblemType('IDP', null).recommended_skills;
+const expectedIdpSeed = slugToFramework(idpSkills[0]);
+assert.ok(expectedIdpSeed, 'the IDP family first skill must resolve to a framework via the registry');
+
+// ---------------------------------------------------------------------------
+// 1. seeded from problem-type, walked via FEEDS_INTO; seed is first
+// ---------------------------------------------------------------------------
+test('recommendFrameworkChain({problemType:"ill-defined"}) -> non-empty ordered framework-name array, seed first', function () {
+  const chain = recommender.recommendFrameworkChain({ problemType: 'ill-defined' });
+  assert.ok(Array.isArray(chain), 'returns an array');
+  assert.ok(chain.length >= 1 && chain.length <= 4, 'length 1..4, got ' + chain.length);
+  assert.ok(chain.every(function (x) { return typeof x === 'string' && x.length > 0; }), 'all elements are non-empty strings');
+  assert.strictEqual(chain[0], expectedIdpSeed, 'element 0 is the IDP seed framework');
+  // 'IDP' alias and the canonical token yield the same seed.
+  assert.strictEqual(recommender.recommendFrameworkChain({ problemType: 'IDP' })[0], expectedIdpSeed);
+  // The other problem-type families seed differently (UDP / WDP).
+  const udpSeed = slugToFramework(problemTypeRouter.routeByProblemType('UDP', null).recommended_skills[0]);
+  assert.strictEqual(recommender.recommendFrameworkChain({ problemType: 'undefined' })[0], udpSeed);
+});
+
+// ---------------------------------------------------------------------------
+// 2. currentFramework first; offline FEEDS_INTO successors follow
+// ---------------------------------------------------------------------------
+test('recommendFrameworkChain({currentFramework:X}) -> X first; supplied FEEDS_INTO edges add successors in order', function () {
+  // No offline edges -> degrades to [X].
+  const bare = recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework' });
+  assert.strictEqual(bare[0], 'Beautiful Question Framework');
+
+  // With a pre-parsed FEEDS_INTO edge array (the shape parseFrameworkChainSection
+  // returns) -> walk the chain via composer.proposeNextFramework.
+  const edges = [
+    { from: 'Beautiful Question Framework', to: 'Domain Selection', confidence: 0.9, phase_indicator: null },
+    { from: 'Domain Selection', to: 'Jobs to Be Done (JTBD)', confidence: 0.85, phase_indicator: null },
+    { from: 'Jobs to Be Done (JTBD)', to: 'PWS Value Proposition', confidence: 0.8, phase_indicator: null },
+    { from: 'PWS Value Proposition', to: 'Lean Canvas', confidence: 0.75, phase_indicator: null }, // would be 5th -> truncated
+  ];
+  const walked = recommender.recommendFrameworkChain({
+    currentFramework: 'Beautiful Question Framework',
+    roomState: { feedsIntoEdges: edges },
+  });
+  assert.deepStrictEqual(walked, ['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)', 'PWS Value Proposition']);
+  assert.ok(walked.length <= 4, 'chain is capped at 4');
+
+  // The same edges expressed as a BRAIN.md framework_chain_predictions section body.
+  const sectionBody =
+    'Beautiful Question Framework FEEDS_INTO Domain Selection (confidence: 0.9)\n' +
+    'Domain Selection FEEDS_INTO Jobs to Be Done (JTBD) (confidence: 0.85)';
+  const fromSection = recommender.recommendFrameworkChain({
+    currentFramework: 'Beautiful Question Framework',
+    roomState: { brainSection: { body: sectionBody } },
+  });
+  assert.deepStrictEqual(fromSection, ['Beautiful Question Framework', 'Domain Selection', 'Jobs to Be Done (JTBD)']);
+});
+
+// ---------------------------------------------------------------------------
+// 3. seed with no outgoing FEEDS_INTO edge -> [seed]
+// ---------------------------------------------------------------------------
+test('a seed with no outgoing FEEDS_INTO edge degrades to [seed] (no crash, never null)', function () {
+  const edges = [
+    { from: 'Some Other Framework', to: 'Yet Another', confidence: 0.9, phase_indicator: null },
+  ];
+  const chain = recommender.recommendFrameworkChain({
+    currentFramework: 'Beautiful Question Framework',
+    roomState: { feedsIntoEdges: edges },
+  });
+  assert.deepStrictEqual(chain, ['Beautiful Question Framework']);
+
+  // An edge below the composer noise floor (< 0.5) is not followed either.
+  const lowConf = [{ from: 'Beautiful Question Framework', to: 'Domain Selection', confidence: 0.3, phase_indicator: null }];
+  assert.deepStrictEqual(
+    recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework', roomState: { feedsIntoEdges: lowConf } }),
+    ['Beautiful Question Framework']
+  );
+
+  // Empty / no roomState -> [seed].
+  assert.deepStrictEqual(
+    recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework', roomState: {} }),
+    ['Beautiful Question Framework']
+  );
+  assert.deepStrictEqual(
+    recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework' }),
+    ['Beautiful Question Framework']
+  );
+
+  // No args at all -> the default seed, length 1.
+  const def = recommender.recommendFrameworkChain();
+  assert.ok(Array.isArray(def) && def.length >= 1 && typeof def[0] === 'string');
+  assert.strictEqual(def[0], recommender.DEFAULT_SEED);
+});
+
+// ---------------------------------------------------------------------------
+// 4. Brain unavailable -> still returns a chain; never throws, never null
+// ---------------------------------------------------------------------------
+test('Brain unavailable (isAvailable() -> false) still returns a chain; never throws, never null', function () {
+  const orig = brainClient.isAvailable;
+  try {
+    brainClient.isAvailable = function () { return false; };
+    const c1 = recommender.recommendFrameworkChain({ problemType: 'ill-defined' });
+    assert.ok(Array.isArray(c1) && c1.length >= 1 && c1.every(function (x) { return typeof x === 'string'; }));
+    assert.notStrictEqual(c1, null);
+    const edges = [{ from: 'Beautiful Question Framework', to: 'Domain Selection', confidence: 0.9, phase_indicator: null }];
+    const c2 = recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework', roomState: { feedsIntoEdges: edges } });
+    assert.deepStrictEqual(c2, ['Beautiful Question Framework', 'Domain Selection']);
+  } finally {
+    brainClient.isAvailable = orig;
+  }
+  // And with Brain "available" (the real isAvailable, which is false on a CI box
+  // without a key -- so this also exercises the no-key path) it still works.
+  const c3 = recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework' });
+  assert.deepStrictEqual(c3, ['Beautiful Question Framework']);
+});
+
+// ---------------------------------------------------------------------------
+// 5. Canon Part 8: no command literal; Cypher carries only $-bound params; FW names only
+// ---------------------------------------------------------------------------
+test('Canon Part 8: chain-recommender source has no command literal; any Cypher uses only $-bound params', function () {
+  const src = fs.readFileSync(RECOMMENDER_PATH, 'utf8');
+  // No /mos: command literal anywhere (the pre-commit / 122-02 grep guard too).
+  assert.ok(!/\/mos:/.test(src), 'no /mos: command literal in chain-recommender.cjs');
+
+  // Any Cypher-looking string (a line containing MATCH ... FEEDS_INTO ...) must
+  // bind its inputs as $-params, never interpolate them, and never carry a
+  // command token or a user-content token.
+  const lines = src.split(/\r?\n/);
+  let sawCypher = false;
+  for (const line of lines) {
+    if (!/FEEDS_INTO/.test(line) || !/MATCH/i.test(line)) continue;
+    sawCypher = true;
+    assert.ok(/\$seed/.test(line) || /\$[a-zA-Z_]/.test(line), 'FEEDS_INTO Cypher binds inputs via $-params: ' + line.trim());
+    assert.ok(!/\$\{/.test(line), 'no template-literal interpolation in the Cypher: ' + line.trim());
+    assert.ok(!/\/mos:/.test(line), 'no command literal in the Cypher: ' + line.trim());
+  }
+  // The exported Cypher constant, if present, must also satisfy this.
+  if (typeof recommender.FEEDS_INTO_CYPHER === 'string') {
+    assert.ok(/\$seed/.test(recommender.FEEDS_INTO_CYPHER), 'FEEDS_INTO_CYPHER binds $seed');
+    assert.ok(!/\$\{/.test(recommender.FEEDS_INTO_CYPHER), 'FEEDS_INTO_CYPHER has no template interpolation');
+    assert.ok(!/\/mos:/.test(recommender.FEEDS_INTO_CYPHER), 'FEEDS_INTO_CYPHER has no command literal');
+  }
+  assert.ok(sawCypher || typeof recommender.FEEDS_INTO_CYPHER === 'string', 'a FEEDS_INTO Cypher template exists (source line or exported constant)');
+
+  // The return value is framework names only -- never a command string.
+  const chain = recommender.recommendFrameworkChain({ problemType: 'ill-defined' });
+  assert.ok(chain.every(function (x) { return typeof x === 'string' && !/\/mos:/.test(x); }), 'returned chain is framework names, no command strings');
+
+  // It reuses framework-chain-composer + problem-type-router (not hand-rolled).
+  assert.ok(/framework-chain-composer/.test(src), 'requires framework-chain-composer');
+  assert.ok(/problem-type-router/.test(src), 'requires problem-type-router');
+});
+
+// ---------------------------------------------------------------------------
+// Bonus: composeWorkflow(recommendFrameworkChain(...)) -- the resolver attaches commands
+// ---------------------------------------------------------------------------
+test('composeWorkflow(recommendFrameworkChain(...)) attaches commands (the resolver does it, not the recommender)', function () {
+  const resolver = require('../workflow/command-resolver.cjs');
+  const edges = [
+    { from: 'Beautiful Question Framework', to: 'Domain Selection', confidence: 0.9, phase_indicator: null },
+    { from: 'Domain Selection', to: 'Jobs to Be Done (JTBD)', confidence: 0.85, phase_indicator: null },
+  ];
+  const chain = recommender.recommendFrameworkChain({ currentFramework: 'Beautiful Question Framework', roomState: { feedsIntoEdges: edges } });
+  const wf = resolver.composeWorkflow(chain);
+  assert.strictEqual(wf.length, 3);
+  assert.strictEqual(wf[0].step, 1);
+  wf.forEach(function (s, i) { assert.strictEqual(s.step, i + 1); assert.ok('command' in s); assert.ok('optional' in s); });
+  // All three of these frameworks ARE mapped post-retrofit -> commands filled.
+  assert.ok(wf.every(function (s) { return s.command !== null; }));
+});
+
+process.stdout.write('\nchain-recommender.test.cjs: ' + passed + ' assertion groups PASSED\n');
+process.exit(0);

package/lib/memory/chat-context.test.cjs

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * chat-context.test.cjs -- Phase 87-09 context-injection fence.
+ *
+ * BSL 1.1. Copyright (c) Mindrian 2026.
+ * (Business Source License 1.1; SPDX BUSL-1.1; see LICENSE.)
+ *
+ * Proves:
+ *   - classifyIntent covers all 5 buckets: contradicts, converges,
+ *     stakeholders, gaps, briefing, plus the default-fallback path
+ *   - buildContext returns a numeric tokenEstimate on EVERY code path
+ *   - Every pattern stays under the 5K token budget on the cascade-e2e
+ *     seed-room fixture
+ *   - Pattern 3 (stakeholders) gracefully early-returns when the
+ *     stakeholders table is empty -- it does NOT fabricate attribution
+ *     (R6 / Phase 84-05 Pattern 3 contract)
+ *
+ * Exit codes:
+ *   0  -> PASS
+ *   1  -> FAIL (budget blown, or early-return missing, or class drift)
+ */
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { buildContext, classifyIntent } = require('../core/chat-context-builder.cjs');
+const { runCascade } = require('../core/intelligence-cascade.cjs');
+
+const FIXTURE = path.resolve(__dirname, '../../test/fixtures/cascade-e2e/seed-room');
+const MAX_TOKENS = 5000;
+
+async function run() {
+  /* Intent classification: all 5 named buckets + default fallback. */
+  assert.strictEqual(classifyIntent('what contradicts x?'), 'contradicts');
+  assert.strictEqual(classifyIntent('what is converging?'), 'converges');
+  assert.strictEqual(classifyIntent('who said what?'), 'stakeholders');
+  assert.strictEqual(classifyIntent('what gaps to fill?'), 'gaps');
+  assert.strictEqual(classifyIntent('briefing please'), 'briefing');
+  assert.strictEqual(classifyIntent('random unrelated text'), 'briefing');
+
+  /* Seed a hermetic room under /rooms/ so intelligence-cascade's
+   * isRoomFile() guard passes, then run the cascade against the three
+   * seeded artifacts so room.db + schema exist. */
+  const tmpParent = fs.mkdtempSync(path.join(os.tmpdir(), 'chatctx-'));
+  const roomsDir = path.join(tmpParent, 'rooms');
+  const roomDir = path.join(roomsDir, 'fixture');
+  fs.mkdirSync(roomsDir, { recursive: true });
+
+  try {
+    fs.cpSync(FIXTURE, roomDir, { recursive: true });
+    await runCascade(roomDir, {
+      trigger: 'test',
+      filePath: path.join(roomDir, 'problem-definition', 'jtbd-underservice.md'),
+      section: 'problem-definition',
+    });
+
+    /* Pattern 1: contradicts */
+    const c1 = await buildContext(roomDir, 'what contradicts market-analysis?');
+    assert.strictEqual(c1.intent, 'contradicts');
+    assert.strictEqual(c1.earlyReturn, false);
+    assert.ok(typeof c1.tokenEstimate === 'number', 'tokenEstimate must be a number');
+    assert.ok(c1.tokenEstimate < MAX_TOKENS,
+      'contradicts tokenEstimate must be <' + MAX_TOKENS + ' (got ' + c1.tokenEstimate + ')');
+
+    /* Pattern 2: converges */
+    const c2 = await buildContext(roomDir, 'what patterns are converging across sections?');
+    assert.strictEqual(c2.intent, 'converges');
+    assert.strictEqual(c2.earlyReturn, false);
+    assert.ok(typeof c2.tokenEstimate === 'number', 'tokenEstimate must be a number');
+    assert.ok(c2.tokenEstimate < MAX_TOKENS,
+      'converges tokenEstimate must be <' + MAX_TOKENS + ' (got ' + c2.tokenEstimate + ')');
+
+    /* Pattern 3: stakeholders -- empty table, earlyReturn=true must be asserted */
+    const c3 = await buildContext(roomDir, 'who said what?');
+    assert.strictEqual(c3.intent, 'stakeholders');
+    assert.strictEqual(c3.earlyReturn, true,
+      'empty stakeholders table must trigger earlyReturn=true (no fabrication)');
+    assert.ok(/stakeholder/i.test(c3.userPrompt),
+      'early-return message must mention stakeholders');
+    assert.ok(typeof c3.tokenEstimate === 'number',
+      'tokenEstimate must be present even on earlyReturn');
+    assert.ok(c3.tokenEstimate < MAX_TOKENS,
+      'stakeholders tokenEstimate must be <' + MAX_TOKENS + ' (got ' + c3.tokenEstimate + ')');
+
+    /* Pattern 4: gaps */
+    const c4 = await buildContext(roomDir, 'what gaps should I fill?');
+    assert.strictEqual(c4.intent, 'gaps');
+    assert.strictEqual(c4.earlyReturn, false);
+    assert.ok(typeof c4.tokenEstimate === 'number', 'tokenEstimate must be a number');
+    assert.ok(c4.tokenEstimate < MAX_TOKENS,
+      'gaps tokenEstimate must be <' + MAX_TOKENS + ' (got ' + c4.tokenEstimate + ')');
+
+    /* Pattern 5: briefing */
+    const c5 = await buildContext(roomDir, 'give me an intelligence briefing');
+    assert.strictEqual(c5.intent, 'briefing');
+    assert.strictEqual(c5.earlyReturn, false);
+    assert.ok(typeof c5.tokenEstimate === 'number', 'tokenEstimate must be a number');
+    assert.ok(c5.tokenEstimate < MAX_TOKENS,
+      'briefing tokenEstimate must be <' + MAX_TOKENS + ' (got ' + c5.tokenEstimate + ')');
+
+    /* Default-fallback path: unclassified input routes to briefing */
+    const c6 = await buildContext(roomDir, 'random unrelated question');
+    assert.strictEqual(c6.intent, 'briefing', 'default fallback must be briefing');
+    assert.ok(c6.tokenEstimate < MAX_TOKENS,
+      'fallback tokenEstimate must be <' + MAX_TOKENS + ' (got ' + c6.tokenEstimate + ')');
+
+    process.stdout.write(
+      'chat-context: all 5 intent patterns tested, all token budgets <' + MAX_TOKENS +
+      ' (contradicts=' + c1.tokenEstimate +
+      ' converges=' + c2.tokenEstimate +
+      ' stakeholders=' + c3.tokenEstimate + '[earlyReturn]' +
+      ' gaps=' + c4.tokenEstimate +
+      ' briefing=' + c5.tokenEstimate +
+      ' fallback=' + c6.tokenEstimate + ')\n'
+    );
+    process.exit(0);
+  } catch (e) {
+    process.stderr.write((e && e.stack) ? e.stack + '\n' : String(e) + '\n');
+    process.exit(1);
+  } finally {
+    try { fs.rmSync(tmpParent, { recursive: true, force: true }); } catch (_) { /* ignore */ }
+  }
+}
+
+run();