@mindrian_os/install 1.13.0-beta.24 → 1.13.0-beta.28

package/lib/memory/brain-cypher-chain-slice.test.cjs

@@ -2,25 +2,19 @@
 'use strict';
 
 /**
- * Phase 125-02 -- Brain Cypher chain slice (framework_chain_hint) tests.
+ * Phase 125-02 -- Brain framework-chain slice (framework_chain_hint) tests.
  *
- * Run: node --test lib/memory/brain-cypher-chain-slice.test.cjs
- * Exit 0 on pass. Uses node:test + node:assert/strict.
+ * BUG 2 fix update (2026-05-22): the implementation was repointed from the
+ * admin-gated brain_query / raw-Cypher path onto brain.askOp('framework_chain_slice',
+ * { seeds, max_hops }) per .planning/brain-curated-ops-contract.md.
  *
- * Coverage maps 1:1 to 125-02-PLAN.md Task 1 <behavior> Tests 1-10:
- *   1. Happy-path: 3 rows -> 3 edges, slice_scope=2, snapshot_id non-null.
- *   2. LIMIT 50 verbatim in the Cypher template constant.
- *   3. Sanitization called on each framework name; bound value is sanitized.
- *   4. max_hops bound to 1..3 enum (0 and 4 degrade; 1, 2, 3 valid).
- *   5. Empty active_frameworks short-circuits (no Brain call).
- *   6. Brain unreachable (isAvailable=false) degrades.
- *   7. Brain throws degrades (slice_rationale carries brain_query_failed).
- *   8. Result mapping: 5 fields propagate verbatim.
- *   9. Null tolerance (G-05): null confidence + null transform_description preserved.
- *  10. brain_snapshot_id is sha256 hash of the JSON-stringified raw rows.
+ * Tests updated to mock askOp() instead of query(). Cypher-constant-content
+ * assertions (LIMIT 50 verbatim, FEEDS_INTO*1..$max_hops) are no longer
+ * applicable since the Cypher is now frozen server-side. The constant is
+ * deprecated (empty string); Test 2 now asserts it is exported but empty.
  *
- * Plus Canon Part 8 grep audit: the Cypher template contains zero user-content
- * tokens (no roomDir, no artifact, no body, no transcript token).
+ * Run: node --test lib/memory/brain-cypher-chain-slice.test.cjs
+ * Exit 0 on pass. Uses node:test + node:assert/strict.
  */
 
 const { test } = require('node:test');
@@ -34,82 +28,69 @@ const {
   _test,
 } = require('/home/jsagi/MindrianOS-Plugin/lib/brain/framework-chain-slice.cjs');
 
-// Build a mock brainClient with stubbed isAvailable + query + _test seam.
+// Build a mock brainClient with stubbed isAvailable + askOp + _test seam.
 // sanitizationCalls records every arg passed to sanitizeCypherInput so the
 // test can assert call counts + bound-value equivalence.
+// askOpInvocations records every call to askOp for inspection.
 function makeMockClient(opts) {
   const o = opts || {};
   const sanitizationCalls = [];
-  const queryInvocations = [];
+  const askOpInvocations = [];
   const sanitizer = function (v) {
     sanitizationCalls.push(v);
     // Match the shipped whitelist exactly: [a-zA-Z0-9 ._-]
     return String(v == null ? '' : v).replace(/[^a-zA-Z0-9 ._-]/g, '');
   };
   const isAvailable = (typeof o.available === 'boolean') ? o.available : true;
-  const queryFn = (typeof o.queryFn === 'function')
-    ? o.queryFn
-    : (async function () { return []; });
+  const askOpFn = (typeof o.askOpFn === 'function')
+    ? o.askOpFn
+    : (async function () { return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 0, rows: [] }; });
   return {
     isAvailable: function () { return isAvailable; },
-    query: async function (cypher, params) {
-      queryInvocations.push({ cypher: cypher, params: params });
-      return queryFn(cypher, params);
+    askOp: async function (operation, params) {
+      askOpInvocations.push({ operation: operation, params: params });
+      return askOpFn(operation, params);
     },
     _test: {
       sanitizeCypherInput: sanitizer,
     },
-    // Exposed on the mock for the test to inspect (not on real brain-client).
+    // Exposed on the mock for the test to inspect.
     _sanitizationCalls: sanitizationCalls,
-    _queryInvocations: queryInvocations,
+    _askOpInvocations: askOpInvocations,
   };
 }
 
-// ---------------------------------------------------------------- Test 2 (FIRST,
-// pure-constant check; runs without any async).
+// ---------------------------------------------------------------- Test 2
+// FRAMEWORK_CHAIN_SLICE_CYPHER is now deprecated (empty string). Verify it
+// is still exported (for backward compat) but acknowledges the change.
 
-test('Test 2: Cypher template constant contains LIMIT 50 verbatim', function () {
+test('Test 2: FRAMEWORK_CHAIN_SLICE_CYPHER is exported (deprecated empty string)', function () {
   assert.ok(
-    typeof FRAMEWORK_CHAIN_SLICE_CYPHER === 'string'
-      && FRAMEWORK_CHAIN_SLICE_CYPHER.length > 0,
-    'FRAMEWORK_CHAIN_SLICE_CYPHER must be a non-empty string'
+    typeof FRAMEWORK_CHAIN_SLICE_CYPHER === 'string',
+    'FRAMEWORK_CHAIN_SLICE_CYPHER must still be exported as a string'
   );
-  assert.ok(
-    FRAMEWORK_CHAIN_SLICE_CYPHER.includes('LIMIT 50'),
-    'FRAMEWORK_CHAIN_SLICE_CYPHER must contain literal "LIMIT 50"'
-  );
-  // Bonus: the parameterized hop range marker.
-  assert.ok(
-    FRAMEWORK_CHAIN_SLICE_CYPHER.includes('FEEDS_INTO*1..$max_hops'),
-    'Cypher must include parameterized hop range "FEEDS_INTO*1..$max_hops"'
+  // Post-repoint: the Cypher is frozen server-side; the exported constant
+  // is intentionally empty to signal deprecation.
+  assert.equal(
+    FRAMEWORK_CHAIN_SLICE_CYPHER,
+    '',
+    'FRAMEWORK_CHAIN_SLICE_CYPHER must be empty after curated-op repoint'
   );
-  // Canon Part 8 grep: no user-content tokens in the template.
-  const forbidden = ['roomDir', 'artifact', 'body', 'transcript', 'roomSlug'];
-  for (const tok of forbidden) {
-    assert.ok(
-      !FRAMEWORK_CHAIN_SLICE_CYPHER.includes(tok),
-      'Cypher must not contain user-content token "' + tok + '"'
-    );
-  }
-  // Read-only: no write keywords in the Cypher template.
-  const writeKeywords = ['MERGE', 'CREATE', 'DELETE', 'SET ', 'REMOVE'];
-  for (const kw of writeKeywords) {
-    assert.ok(
-      !FRAMEWORK_CHAIN_SLICE_CYPHER.includes(kw),
-      'Cypher must be read-only (no "' + kw + '")'
-    );
-  }
 });
 
 // ---------------------------------------------------------------- Test 1
 
 test('Test 1: happy-path returns 3 mapped edges + slice_scope=2 + non-null snapshot_id', async function () {
   const rows = [
-    { from: 'A', to: 'B', confidence: 0.9, transform_description: 'a->b', hop_distance: 1 },
-    { from: 'A', to: 'C', confidence: 0.7, transform_description: 'a->c', hop_distance: 2 },
-    { from: 'B', to: 'D', confidence: 0.8, transform_description: 'b->d', hop_distance: 2 },
+    { from: 'A', to: 'B', hop_distance: 1 },
+    { from: 'A', to: 'C', hop_distance: 2 },
+    { from: 'B', to: 'D', hop_distance: 2 },
   ];
-  const mock = makeMockClient({ queryFn: async function () { return rows; } });
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 3, rows: rows };
+    },
+  });
   const result = await fetchFrameworkChainSlice({
     active_frameworks: ['Beautiful Question Framework'],
     max_hops: 2,
@@ -122,14 +103,20 @@ test('Test 1: happy-path returns 3 mapped edges + slice_scope=2 + non-null snaps
   assert.equal(result.brain_snapshot_id.length, 64); // sha256 hex
   assert.ok(result.slice_rationale.includes('brain_reachable'));
   assert.equal(typeof result.fetched_at, 'string');
-  // ISO 8601 sanity check.
   assert.ok(/^\d{4}-\d{2}-\d{2}T/.test(result.fetched_at));
+  // confidence_omitted flag must be set
+  assert.equal(result.confidence_omitted, true);
 });
 
 // ---------------------------------------------------------------- Test 3
+// Sanitization is still called on seed names (client-side defence-in-depth).
 
 test('Test 3: sanitization called for every framework name; bound value is sanitized', async function () {
-  const mock = makeMockClient({ queryFn: async function () { return []; } });
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 0, rows: [] };
+    },
+  });
   const dangerous = "SWOT; DROP TABLE x";
   await fetchFrameworkChainSlice({
     active_frameworks: [dangerous, 'Beautiful Question Framework'],
@@ -139,24 +126,24 @@ test('Test 3: sanitization called for every framework name; bound value is sanit
   // Sanitizer was called on each name.
   assert.equal(mock._sanitizationCalls.length, 2);
   assert.equal(mock._sanitizationCalls[0], dangerous);
-  // The bound active_frameworks param contains the SANITIZED string (no `;`).
-  assert.equal(mock._queryInvocations.length, 1);
-  const bound = mock._queryInvocations[0].params.active_frameworks;
+  // askOp was called with the sanitized seeds array.
+  assert.equal(mock._askOpInvocations.length, 1);
+  const bound = mock._askOpInvocations[0].params.seeds;
   assert.ok(Array.isArray(bound));
   assert.ok(!bound[0].includes(';'), 'sanitized value must not contain ";"');
-  // The whitelist is [a-zA-Z0-9 ._-] -- letters survive, only the metacharacter
-  // `;` is stripped. The injection vector dies because the bound value is the
-  // sanitizer output (a plain identifier string), not raw user input.
-  assert.equal(bound[0], 'SWOT DROP TABLE x'); // ';' stripped, kept word chars
-  // The second framework name (clean) passes through unchanged.
+  assert.equal(bound[0], 'SWOT DROP TABLE x'); // ';' stripped
   assert.equal(bound[1], 'Beautiful Question Framework');
 });
 
 // ---------------------------------------------------------------- Test 4
 
 test('Test 4: max_hops bound to 1..3 enum; 0 and 4 degrade; 1, 2, 3 valid', async function () {
-  const mock = makeMockClient({ queryFn: async function () { return []; } });
-  // max_hops = 0 -> degraded, no Brain call.
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 0, rows: [] };
+    },
+  });
+  // max_hops = 0 -> degraded, no askOp call.
   let r = await fetchFrameworkChainSlice({
     active_frameworks: ['X'], max_hops: 0, brainClient: mock,
   });
@@ -167,24 +154,28 @@ test('Test 4: max_hops bound to 1..3 enum; 0 and 4 degrade; 1, 2, 3 valid', asyn
     active_frameworks: ['X'], max_hops: 4, brainClient: mock,
   });
   assert.ok(r.slice_rationale.includes('invalid_max_hops'));
-  // No Brain call should have been made for the two invalid hop counts.
-  assert.equal(mock._queryInvocations.length, 0);
-  // max_hops = 1, 2, 3 -> valid (Brain query issued).
+  // No askOp call for the two invalid hop counts.
+  assert.equal(mock._askOpInvocations.length, 0);
+  // max_hops = 1, 2, 3 -> valid (askOp called).
   for (const hops of [1, 2, 3]) {
-    const m2 = makeMockClient({ queryFn: async function () { return []; } });
+    const m2 = makeMockClient({
+      askOpFn: async function () {
+        return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 0, rows: [] };
+      },
+    });
     const ok = await fetchFrameworkChainSlice({
       active_frameworks: ['X'], max_hops: hops, brainClient: m2,
     });
     assert.equal(ok.slice_scope, hops);
-    assert.equal(m2._queryInvocations.length, 1);
-    assert.equal(m2._queryInvocations[0].params.max_hops, hops);
+    assert.equal(m2._askOpInvocations.length, 1);
+    assert.equal(m2._askOpInvocations[0].params.max_hops, hops);
   }
 });
 
 // ---------------------------------------------------------------- Test 5
 
-test('Test 5: empty active_frameworks short-circuits without Brain call', async function () {
-  const mock = makeMockClient({ queryFn: async function () { return []; } });
+test('Test 5: empty active_frameworks short-circuits without askOp call', async function () {
+  const mock = makeMockClient();
   const r = await fetchFrameworkChainSlice({
     active_frameworks: [], max_hops: 2, brainClient: mock,
   });
@@ -192,14 +183,14 @@ test('Test 5: empty active_frameworks short-circuits without Brain call', async
   assert.equal(r.slice_scope, 2);
   assert.ok(r.slice_rationale.includes('empty active_frameworks'));
   assert.equal(r.brain_snapshot_id, null);
-  // Brain query NOT called.
-  assert.equal(mock._queryInvocations.length, 0);
+  // askOp NOT called.
+  assert.equal(mock._askOpInvocations.length, 0);
   assert.equal(mock._sanitizationCalls.length, 0);
 });
 
 // ---------------------------------------------------------------- Test 6
 
-test('Test 6: Brain unreachable (isAvailable=false) degrades; no query call', async function () {
+test('Test 6: Brain unreachable (isAvailable=false) degrades; no askOp call', async function () {
   const mock = makeMockClient({ available: false });
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['Beautiful Question Framework'],
@@ -211,14 +202,14 @@ test('Test 6: Brain unreachable (isAvailable=false) degrades; no query call', as
   assert.equal(r.slice_rationale, 'brain_unreachable');
   assert.equal(r.brain_snapshot_id, null);
   assert.equal(typeof r.fetched_at, 'string');
-  assert.equal(mock._queryInvocations.length, 0);
+  assert.equal(mock._askOpInvocations.length, 0);
 });
 
 // ---------------------------------------------------------------- Test 7
 
-test('Test 7: Brain query throws -> degraded; no exception propagates', async function () {
+test('Test 7: askOp throws -> degraded; no exception propagates', async function () {
   const mock = makeMockClient({
-    queryFn: async function () { throw new Error('connection refused'); },
+    askOpFn: async function () { throw new Error('connection refused'); },
   });
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['X'],
@@ -236,16 +227,20 @@ test('Test 7: Brain query throws -> degraded; no exception propagates', async fu
 });
 
 // ---------------------------------------------------------------- Test 8
+// After the repoint, edges have from/to/hop_distance; confidence and
+// transform_description are always null (not in the curated op).
 
-test('Test 8: result mapping preserves all 5 fields verbatim', async function () {
+test('Test 8: result mapping: from/to/hop_distance propagate; confidence/transform null', async function () {
   const row = {
     from: 'SWOT',
     to: 'Porter Five Forces',
-    confidence: 0.85,
-    transform_description: 'analysis -> strategy',
     hop_distance: 1,
   };
-  const mock = makeMockClient({ queryFn: async function () { return [row]; } });
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 1, rows: [row] };
+    },
+  });
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['SWOT'],
     max_hops: 1,
@@ -255,22 +250,26 @@ test('Test 8: result mapping preserves all 5 fields verbatim', async function ()
   const e = r.edges[0];
   assert.equal(e.from, 'SWOT');
   assert.equal(e.to, 'Porter Five Forces');
-  assert.equal(e.confidence, 0.85);
-  assert.equal(e.transform_description, 'analysis -> strategy');
   assert.equal(e.hop_distance, 1);
+  // Curated op does not return confidence or transform_description.
+  assert.equal(e.confidence, null);
+  assert.equal(e.transform_description, null);
+  assert.equal(r.confidence_omitted, true);
 });
 
 // ---------------------------------------------------------------- Test 9 (G-05)
 
-test('Test 9: null confidence + null transform_description preserved (not defaulted)', async function () {
+test('Test 9: null hop_distance preserved; from/to strings preserved', async function () {
   const row = {
     from: 'A',
     to: 'B',
-    confidence: null,
-    transform_description: null,
-    hop_distance: 2,
+    hop_distance: null,
   };
-  const mock = makeMockClient({ queryFn: async function () { return [row]; } });
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 1, rows: [row] };
+    },
+  });
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['A'],
     max_hops: 2,
@@ -280,89 +279,90 @@ test('Test 9: null confidence + null transform_description preserved (not defaul
   const e = r.edges[0];
   assert.equal(e.from, 'A');
   assert.equal(e.to, 'B');
-  // Explicit null preservation per CONTEXT.md G-05 + Plan 04 schema.
-  assert.equal(e.confidence, null);
-  assert.equal(e.transform_description, null);
-  // hop_distance still propagates.
-  assert.equal(e.hop_distance, 2);
+  assert.equal(e.hop_distance, null);
 });
 
 // ---------------------------------------------------------------- Test 10
 
 test('Test 10: brain_snapshot_id is sha256 of JSON.stringify(raw rows)', async function () {
   const rows = [
-    { from: 'A', to: 'B', confidence: 0.5, transform_description: 't', hop_distance: 1 },
+    { from: 'A', to: 'B', hop_distance: 1 },
   ];
-  const mock = makeMockClient({ queryFn: async function () { return rows; } });
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 1, rows: rows };
+    },
+  });
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['A'],
     max_hops: 1,
     brainClient: mock,
   });
-  // Expected hash: sha256 of JSON.stringify(rows) exactly as the implementation
-  // computes it (it is the raw rows after Cypher, before edge-shape mapping).
   const expected = crypto.createHash('sha256')
     .update(JSON.stringify(rows), 'utf8')
     .digest('hex');
   assert.equal(r.brain_snapshot_id, expected);
 });
 
-// ---------------------------------------------------------------- Bonus: shape-tolerant
-// (the live brain-client returns { records: [] }; this verifies both shapes work).
+// ---------------------------------------------------------------- Test: degraded envelope from server
 
-test('Bonus: { records: [...] } wrapper from brain-client.query is unwrapped', async function () {
-  const rows = [
-    { from: 'X', to: 'Y', confidence: 0.6, transform_description: 'x->y', hop_distance: 1 },
-  ];
+test('Degraded envelope from server: edges=[], snapshot null', async function () {
   const mock = makeMockClient({
-    queryFn: async function () { return { records: rows }; },
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 0, rows: [], degraded: true };
+    },
   });
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['X'],
-    max_hops: 1,
+    max_hops: 2,
     brainClient: mock,
   });
-  assert.equal(r.edges.length, 1);
-  assert.equal(r.edges[0].from, 'X');
+  assert.equal(r.edges.length, 0);
+  assert.ok(r.slice_rationale.includes('brain_returned_degraded'));
+  assert.equal(r.brain_snapshot_id, null);
 });
 
-// ---------------------------------------------------------------- Bonus: non-array
-// Brain return (e.g. an error payload like { error: 'foo' }) degrades cleanly.
+// ---------------------------------------------------------------- Test: askOp absent on client degrades
 
-test('Bonus: non-array Brain return degrades cleanly', async function () {
-  const mock = makeMockClient({
-    queryFn: async function () { return { error: 'whatever' }; },
-  });
+test('askOp absent on brainClient: degrades without throwing', async function () {
+  // A minimal client without askOp (simulates old brain-client before update).
+  const minimalClient = {
+    isAvailable: function () { return true; },
+    _test: { sanitizeCypherInput: function (s) { return s; } },
+  };
   const r = await fetchFrameworkChainSlice({
     active_frameworks: ['X'],
-    max_hops: 1,
-    brainClient: mock,
+    max_hops: 2,
+    brainClient: minimalClient,
   });
   assert.equal(r.edges.length, 0);
-  assert.ok(r.slice_rationale.includes('brain_returned_non_array'));
+  assert.ok(r.slice_rationale.includes('askOp_not_available'));
 });
 
 // ---------------------------------------------------------------- Canon Part 8:
-// re-read the module source and grep it for forbidden tokens (defence in depth).
+// Verify no raw Cypher with user-content tokens is emitted.
 
-test('Canon Part 8: module source contains zero user-content tokens', function () {
-  const src = fs.readFileSync(
-    '/home/jsagi/MindrianOS-Plugin/lib/brain/framework-chain-slice.cjs',
-    'utf8'
-  );
-  // The Cypher constant has been validated above. Here we audit that the
-  // module never builds the query with user-content fields. The only tokens
-  // forbidden in the Cypher *template* + *param-binding* are listed below.
-  // We scan only the Cypher constant + the param object site.
-  const cypherIdx = src.indexOf('FRAMEWORK_CHAIN_SLICE_CYPHER =');
-  assert.ok(cypherIdx > 0);
-  const cypherBlock = src.slice(cypherIdx, src.indexOf('}', cypherIdx + 200));
-  // Cypher must not embed any user-content token literally.
+test('Canon Part 8: askOp receives only seeds (generic framework names) + max_hops', async function () {
+  const mock = makeMockClient({
+    askOpFn: async function () {
+      return { op: 'framework_chain_slice', source: 'neo4j_curated', count: 0, rows: [] };
+    },
+  });
+  await fetchFrameworkChainSlice({
+    active_frameworks: ['SWOT', 'Porter Five Forces'],
+    max_hops: 2,
+    brainClient: mock,
+  });
+  assert.equal(mock._askOpInvocations.length, 1);
+  const inv = mock._askOpInvocations[0];
+  assert.equal(inv.operation, 'framework_chain_slice');
+  // Only seeds + max_hops should be in params.
+  assert.ok(Array.isArray(inv.params.seeds));
+  assert.equal(inv.params.max_hops, 2);
+  // No user-content tokens in params.
+  const paramStr = JSON.stringify(inv.params);
   const forbidden = ['roomDir', 'roomSlug', 'transcript', 'artifact_body'];
   for (const tok of forbidden) {
-    assert.ok(
-      !cypherBlock.includes(tok),
-      'Cypher block must not embed user-content token "' + tok + '"'
-    );
+    assert.ok(!paramStr.includes(tok), 'params must not contain user-content token "' + tok + '"');
   }
 });

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

@@ -384,6 +384,10 @@ async function main() {
   });
 
   // Test 10: options.only_sections subset.
+  // BUG 2 fix update: 'Pattern Matches' was repointed from mode:'query' to
+  // mode:'search' (ungated brain_search). When only_sections includes
+  // 'Pattern Matches', search IS called (1 call). 'ProblemType Classification'
+  // remains mode:'query' (1 query call). Totals: 1 query + 1 search.
   await runAsync('Test 10: only_sections subset -> only specified sections queried', async function () {
     const audit = installMockBrainClient({});
     const { sectionPath } = buildFixtureSection({});
@@ -392,11 +396,12 @@ async function main() {
       only_sections: ['Pattern Matches', 'ProblemType Classification'],
     });
     assert.equal(r.success, true);
-    // Exactly 2 cypher queries expected (cross-domain is pinecone search).
-    assert.ok(audit.query_calls.length <= 2,
-      'expected at most 2 query calls, got ' + audit.query_calls.length);
-    assert.ok(audit.search_calls.length === 0,
-      'search should not be called when only pattern-matches + problemtype requested');
+    // 'Pattern Matches' -> mode:'search' -> 1 search call.
+    // 'ProblemType Classification' -> mode:'query' -> 1 query call.
+    assert.ok(audit.query_calls.length <= 1,
+      'expected at most 1 query call (ProblemType Classification), got ' + audit.query_calls.length);
+    assert.ok(audit.search_calls.length <= 1,
+      'expected at most 1 search call (Pattern Matches), got ' + audit.search_calls.length);
   });
 
   // Test 11: dry_run.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindrian_os/install",
-  "version": "1.13.0-beta.24",
+  "version": "1.13.0-beta.28",
   "description": "Install MindrianOS into Claude Code with one command -- `npx @mindrian_os/install`. Ships the MindrianOS plugin (Larry + PWS methodology + Data Room) plus a setup/diagnostics CLI (install/doctor/update).",
   "scripts": {
     "mcp": "node bin/mindrian-mcp-server.cjs",

package/references/brain/query-patterns.md

@@ -6,11 +6,13 @@
 
 Agents and skills read this file on demand. To execute a pattern:
 1. Find the named pattern below
-2. Replace `$parameters` with specific values from current context
-3. Call `mcp__neo4j-brain__read_neo4j_cypher` with the adapted Cypher
-4. For `brain_search_semantic`, call `mcp__pinecone-brain__search-records` instead
+2. For patterns that use `brain_ask`: call `mcp__mindrian-brain__brain_ask` with the
+   natural-language question template shown. Read `next_gate.options[].framework` for the
+   ranked chain and `directive.guided.framework` for the matched anchor. No Cypher needed.
+3. For `brain_search_semantic`, call `mcp__mindrian-brain__brain_search`
+   (or `mcp__pinecone-brain__search-records` as fallback).
 
-Never run Cypher without a LIMIT clause. Never expose raw results to users -- synthesize into insights.
+Never expose raw results to users -- synthesize into insights.
 
 ---
 
@@ -18,21 +20,31 @@ Never run Cypher without a LIMIT clause. Never expose raw results to users -- sy
 
 **Purpose:** Given current frameworks + problem type, recommend next framework.
 
-```cypher
-MATCH (current:Framework)-[r:FEEDS_INTO|TRANSFORMS_OUTPUT_TO]->(next:Framework)
-WHERE current.name IN $current_frameworks
-AND NOT next.name IN $current_frameworks
-OPTIONAL MATCH (next)-[:ADDRESSES_PROBLEM_TYPE]->(pt:ProblemType {name: $problem_type})
-RETURN next.name AS framework,
-       type(r) AS relation,
-       r.confidence AS confidence,
-       r.transform_description AS transform,
-       pt IS NOT NULL AS matches_problem_type
-ORDER BY r.confidence DESC, matches_problem_type DESC
-LIMIT 5
+**Tool:** `mcp__mindrian-brain__brain_ask` (ungated -- works for all valid API keys)
+
+**Question template:**
+
+```
+recommend a framework for a {problem_type} venture that has already applied {current_frameworks}
 ```
 
-**Output:** List of recommended next frameworks with confidence scores and problem-type alignment.
+Example:
+```
+recommend a framework for a wicked problem venture that has already applied
+"Beautiful Question Framework, Domain Selection"
+```
+
+**How to read the response:**
+- `next_gate.options[].framework` -- ranked list of recommended next frameworks
+- `next_gate.options[].confidence` -- confidence score per framework (0..1)
+- `next_gate.options[].verb` -- canonical Canon Part 3 verb associated with this option
+- `directive.guided.framework` -- the matched anchor framework Brain selected
+
+**Graceful degradation:** if `brain_ask` is unavailable, use the local routing table at
+`references/methodology/problem-types.md` -- match the problem type cell, exclude already-applied
+frameworks, prioritize the one targeting the emptiest room section.
+
+**Output:** Ranked next frameworks with confidence scores and problem-type alignment.
 
 ---