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

package/lib/hmi/cross-room-memory.cjs

@@ -261,18 +261,35 @@ function buildBrainQueryContext(localContext) {
 }
 
 // ============================================================
-// Brain query -- SINGLE chokepoint (Tripwire #2).
+// Brain search -- SINGLE chokepoint (Tripwire #2).
 // ============================================================
 //
 // The ONE AND ONLY function in this module that reaches Brain. Every
 // other code path that wants Brain enrichment routes through here.
+//
+// BUG FIX 2026-05-22: the former implementation called client.query(payload)
+// where payload was a plain OBJECT (assembled by tryBrainHints). brain_query
+// requires a Cypher STRING; passing an object causes MCP input validation to
+// fail silently, making Mode A cross-room enrichment dead for all users.
+//
+// Fix: route the JTBD co-occurrence hint lookup through the UNGATED
+// brain_search (semantic) instead. We build a generic methodology query
+// string from the allow-listed context keys and call client.search().
+// brain_search accepts a free-text query string and returns semantic
+// matches from the Pinecone index -- no admin gate, no Cypher string
+// required, no user content (the query string is derived ONLY from
+// allow-listed enums and slugs per Canon Part 8).
+//
+// Result shape from brain_search: { matches: Array<{title,score,...}> }
+// or { records: Array<...> } depending on the server version. We adapt
+// both shapes in tryBrainHints below.
 
-async function tryBrainQuery(payload) {
+async function tryBrainSearch(queryText) {
   const client = getBrainClient();
-  if (!client || typeof client.query !== 'function') return null;
+  if (!client || typeof client.search !== 'function') return null;
   // The single Brain call site. (Tripwire #2: exactly one match for
-  // /(?:brainClient|brain|client)\.query\(/ in the entire module.)
-  return await client.query(payload);
+  // /(?:tryBrainSearch|client\.search)\(/ in the entire module.)
+  return await client.search(queryText, { topK: 3 });
 }
 
 // ============================================================
@@ -411,32 +428,58 @@ async function tryBrainHints(byJtbd) {
   const jtbds = Object.keys(byJtbd);
   if (jtbds.length === 0) return null;
 
-  const hints = {};
-  for (const jtbd of jtbds) {
-    const ctx = buildBrainQueryContext({
-      jtbd_id: jtbd,
-      jtbd_state_enum: 'in_flight',
-    });
-    const payload = Object.assign({ query_type: 'jtbd_cooccurrence' }, ctx);
+  // Build a SINGLE generic methodology query string from the JTBD slugs.
+  // The query string is derived from allow-listed slug tokens only (no user
+  // prose, no artifact bodies, no room names). Canon Part 8 safe.
+  //
+  // We send ONE search call for all JTBDs together (rather than one per JTBD)
+  // to minimize Brain round-trips; the semantic results are generic methodology
+  // patterns applicable to any venture doing these jobs.
+  const safeJtbdList = jtbds
+    .filter(function (j) { return typeof j === 'string' && /^[a-z0-9-]{1,64}$/.test(j); })
+    .slice(0, 8);
+
+  if (safeJtbdList.length === 0) return null;
+
+  // Query string: fully generic methodology language (no user content).
+  // e.g. "methodology patterns for jtbd: prepare-pitch find-bottleneck"
+  const queryText = 'methodology patterns for jtbd: ' + safeJtbdList.join(' ');
+
+  // Tripwire #4: scan the outgoing query string before send.
+  const queryPayload = { q: queryText };
+  if (!payloadIsClean(queryPayload)) {
+    // Query audit failed; abort Mode A.
+    return null;
+  }
 
-    // Tripwire #4: scan before send
-    if (!payloadIsClean(payload)) {
-      // payload audit failed; abort Mode A (pretend Brain unreachable)
-      return null;
-    }
+  let r;
+  try {
+    r = await tryBrainSearch(queryText);
+  } catch (err) {
+    // Re-throw so outer aggregateAcrossRooms can record the warning
+    // row. This is the "read-only Brain failure mid-render" case --
+    // we degrade to Mode B but stamp a single warning row.
+    throw err;
+  }
 
-    let r;
-    try {
-      r = await tryBrainQuery(payload);
-    } catch (err) {
-      // Re-throw so outer aggregateAcrossRooms can record the warning
-      // row. This is the "read-only Brain failure mid-render" case --
-      // we degrade to Mode B but stamp a single warning row.
-      throw err;
-    }
-    if (r && r.patterns) {
-      hints[jtbd] = r.patterns;
-    }
+  // brain_search returns { matches: [...] } or { records: [...] }.
+  // Extract the pattern list and assign uniformly across all JTBDs.
+  // (The response is generic -- there are no per-JTBD buckets from semantic
+  // search; we attribute the same hint set to every JTBD in the batch.)
+  const matchItems = (r && Array.isArray(r.matches)) ? r.matches
+    : (r && Array.isArray(r.records)) ? r.records
+    : [];
+
+  if (matchItems.length === 0) return null;
+
+  // Map semantic matches to the patterns shape the caller expects.
+  const patterns = matchItems.slice(0, 5).map(function (m) {
+    return { title: m.title || m.name || 'methodology pattern', score: m.score || 0 };
+  });
+
+  const hints = {};
+  for (const jtbd of safeJtbdList) {
+    hints[jtbd] = patterns;
   }
 
   return Object.keys(hints).length > 0 ? hints : null;

package/lib/mcp/brain-router.cjs

@@ -254,7 +254,13 @@ function localRoute(roomDir, stateContent, intent) {
 // ---------------------------------------------------------------------------
 
 /**
- * Call Brain API for framework recommendation.
+ * Call Brain API for framework recommendation via brain_ask (ungated).
+ * Replaced the former raw-Cypher brain_query path (admin-gated, BUG 2)
+ * with brain.ask(question) -- valid for all API keys.
+ * Reads next_gate.options[].framework for the ranked chain.
+ * Canon Part 8: the NL question carries only the generic problem-type enum,
+ * never user content or artifact text.
+ *
  * @param {string} roomDir
  * @param {string} stateContent
  * @param {string} [intent]
@@ -270,65 +276,73 @@ async function brainRoute(roomDir, stateContent, intent) {
 
   if (!brainClient.isAvailable()) return null;
 
-  // Query Brain for framework recommendations based on room state
+  // Build a generic NL question carrying only the problem-type enum.
+  // Canon Part 8: no user content, no artifact text, no proprietary numbers.
   const { definition, complexity } = extractProblemType(stateContent);
+  const safeDefinition = definition.replace(/[^a-zA-Z-]/g, '') || 'undefined';
+  const safeComplexity = complexity.replace(/[^a-zA-Z-]/g, '') || 'complex';
+  const question = 'recommend a framework for a ' + safeDefinition + ' definition '
+    + safeComplexity + ' problem';
+
+  let brainResult;
+  try {
+    if (typeof brainClient.ask !== 'function') return null;
+    brainResult = await brainClient.ask(question);
+  } catch (_e) {
+    return null;
+  }
+
+  if (!brainResult) return null;
+
+  // Read next_gate.options[] for the ranked framework chain.
+  // Gracefully handle both presence and absence of next_gate.
+  const options = (brainResult.next_gate && Array.isArray(brainResult.next_gate.options))
+    ? brainResult.next_gate.options
+    : [];
 
-  // PIPE-03: Include both CO_OCCURS and FEEDS_INTO relationships
-  // for chain ordering. FEEDS_INTO encodes directional sequences
-  // (e.g., scenario-plan FEEDS_INTO root-cause), while CO_OCCURS
-  // captures frameworks that commonly run together.
-  // I-3 fix: sanitize complexity to prevent Cypher injection from malformed STATE.md
-  const safeComplexity = complexity.replace(/[^a-zA-Z]/g, '');
-  const cypher = `
-    MATCH (pt:ProblemType)<-[:ADDRESSES_PROBLEM_TYPE]-(f:Framework)
-    WHERE pt.name CONTAINS "${safeComplexity}"
-    WITH f, pt
-    OPTIONAL MATCH (f)-[:FEEDS_INTO]->(f_next:Framework)
-    WITH f, pt, collect(DISTINCT f_next.name) AS feeds_chain
-    OPTIONAL MATCH (f)-[:CO_OCCURS]->(f_co:Framework)
-    WITH f, pt, feeds_chain, collect(DISTINCT f_co.name) AS co_chain
-    RETURN f.name AS primary,
-           CASE WHEN size(feeds_chain) > 0 THEN feeds_chain[..3]
-                ELSE co_chain[..3] END AS chain,
-           pt.name AS problem_type,
-           CASE WHEN size(feeds_chain) > 0 THEN 'feeds_into'
-                ELSE 'co_occurs' END AS chain_type
-    LIMIT 3
-  `;
-
-  const result = await brainClient.query(cypher);
-
-  if (result && result.records && result.records.length > 0) {
-    const rec = result.records[0];
-    const primary = rec.primary || rec[0];
-    const chainNames = rec.chain || rec[1] || [];
-    const fullChain = [primary, ...chainNames].filter(Boolean);
-
-    // Map Brain framework names to CLI command names
-    const mappedChain = fullChain
-      .map(name => {
-        const normalized = name.toLowerCase().replace(/[^a-z-]/g, '');
-        return KNOWN_METHODOLOGIES.find(m => m === normalized || normalized.includes(m))
-          || normalized;
-      })
-      .filter(Boolean)
-      .slice(0, 4);
-
-    if (mappedChain.length > 0) {
-      const chainType = rec.chain_type || rec[3] || 'co_occurs';
-      return {
-        chain: mappedChain,
-        confidence: 0.85,
-        source: 'brain',
-        chain_type: chainType,
-        reasoning: `Brain recommends ${mappedChain.join(' -> ')} for ${definition} ${complexity} problem. ` +
-          `Chain derived from ${chainType === 'feeds_into' ? 'FEEDS_INTO (sequential)' : 'CO_OCCURS (complementary)'} relationships.`,
-        target_sections: []
-      };
+  const anchorFramework = (brainResult.directive && brainResult.directive.guided)
+    ? (brainResult.directive.guided.framework || null)
+    : null;
+
+  // Build the chain: anchor first (if present + not already in options), then options[].framework.
+  const rawChain = [];
+  if (anchorFramework && typeof anchorFramework === 'string') rawChain.push(anchorFramework);
+  for (const opt of options) {
+    if (opt && typeof opt.framework === 'string' && opt.framework.length > 0) {
+      if (!rawChain.includes(opt.framework)) rawChain.push(opt.framework);
     }
   }
 
-  return null;
+  if (rawChain.length === 0) return null;
+
+  // Map Brain framework names to CLI methodology names (slug normalization).
+  // This mirrors the previous mapping in the old Cypher path.
+  const mappedChain = rawChain
+    .map(function (name) {
+      const normalized = name.toLowerCase().replace(/[^a-z-]/g, '');
+      return KNOWN_METHODOLOGIES.find(function (m) { return m === normalized || normalized.includes(m); })
+        || normalized;
+    })
+    .filter(Boolean)
+    .slice(0, 4);
+
+  if (mappedChain.length === 0) return null;
+
+  // Derive top confidence from the options array (or default 0.8).
+  const topConf = (options.length > 0 && typeof options[0].confidence === 'number')
+    ? options[0].confidence
+    : 0.8;
+
+  return {
+    chain: mappedChain,
+    confidence: topConf,
+    source: 'brain',
+    chain_type: 'feeds_into',
+    reasoning: 'Brain recommends ' + mappedChain.join(' -> ') + ' for '
+      + safeDefinition + ' ' + safeComplexity + ' problem. '
+      + 'Chain derived from brain_ask FEEDS_INTO recommendations.',
+    target_sections: [],
+  };
 }
 
 // ---------------------------------------------------------------------------