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

package/lib/brain/framework-chain-slice.cjs

@@ -1,33 +1,46 @@
 'use strict';
-// Phase 125-02 -- Brain Cypher slice query (parameterized 1-3 hop FEEDS_INTO; LIMIT 50).
-// CONTEXT.md Scope IN section B item 4 -- the LOCKED Cypher. Async wrapper over
-// brain-client.query that produces the framework_chain_hint shape Plan 03 stitches
-// into the packet's local_graph_summary.
+// Phase 125-02 -- Brain framework-chain slice (FEEDS_INTO 1-3 hops).
+// CONTEXT.md Scope IN section B item 4.
 //
-// Canon Part 8: only $active_frameworks (array of generic framework name strings,
-// each passed through sanitizeCypherInput) + $max_hops (1|2|3 int) cross the wire.
-// No user content. No artifact text. No room identifiers in the query.
+// Repointed (BUG 2 fix) from the admin-gated brain_query / raw-Cypher path
+// onto the curated brain.askOp('framework_chain_slice', { seeds, max_hops })
+// surface so any valid API key can call it.
 //
-// Graceful degradation: any failure path (Brain unreachable, query throws, invalid
-// max_hops, empty active_frameworks, all-rejected-by-sanitizer, non-array result)
-// returns a degraded result envelope rather than throwing. Tier 0 stays functional.
+// Contract (from .planning/brain-curated-ops-contract.md):
+//   brain.askOp('framework_chain_slice', { seeds: string[], max_hops?: 1|2|3 })
+//   -> { op, source, count, rows: Array<{from, to, hop_distance}>, degraded? }
+//
+// INTEGRATOR NOTE -- partial substitute:
+//   The old Cypher returned `confidence` and `transform_description` per edge.
+//   The curated op returns ONLY `from`, `to`, `hop_distance` (no confidence,
+//   no transform_description). Downstream consumers that used those fields will
+//   receive `null` after this change. Flag logged in fetchFrameworkChainSlice
+//   return envelope as `confidence_omitted: true` so callers can detect this.
+//   A future curated-op extension could re-expose the fields if needed.
+//
+// Canon Part 8: seeds are generic framework-name strings (allow-listed by
+// the server); max_hops is a clamped integer 1-3. No user content crosses the
+// wire. The curated op enforces this server-side; no caller Cypher ever.
+//
+// Graceful degradation: any failure path (Brain unreachable, askOp throws,
+// invalid max_hops, empty seeds, non-array result, degraded envelope) returns
+// a degraded result envelope rather than throwing. Tier 0 stays functional.
+//
+// BACKWARD-COMPAT SURFACE: the module still exports FRAMEWORK_CHAIN_SLICE_CYPHER
+// as an empty string so existing test-seam checks that assert on the exported
+// constant do not break (tests/brain-cypher-chain-slice.test.cjs Test 2 checks
+// that the CYPHER includes 'LIMIT 50' and 'FEEDS_INTO*1..$max_hops'; those
+// tests will need updating now that the Cypher is server-side). The constant is
+// deprecated; callers should NOT use it.
 
 const crypto = require('node:crypto');
 const defaultBrainClient = require('../core/brain-client.cjs');
 
-// LOCKED Cypher template per CONTEXT.md Scope IN section B item 4.
-// READ-ONLY (MATCH/RETURN/LIMIT only -- no MERGE/CREATE/DELETE). The two $-bound
-// params ($active_frameworks, $max_hops) are the ONLY values that cross the wire;
-// every framework name in $active_frameworks is sanitized via the brain-client
-// sanitizeCypherInput whitelist before binding (Canon Part 8 invariant).
-const FRAMEWORK_CHAIN_SLICE_CYPHER =
-  'MATCH (f:Framework)-[r:FEEDS_INTO*1..$max_hops]->(g:Framework) ' +
-  'WHERE f.name IN $active_frameworks ' +
-  'RETURN f.name AS from, g.name AS to, ' +
-  '       r.confidence AS confidence, ' +
-  '       r.transform_description AS transform_description, ' +
-  '       length(r) AS hop_distance ' +
-  'LIMIT 50';
+// DEPRECATED: the Cypher is now frozen server-side inside the curated op.
+// Retained as an empty string to avoid hard breaking any import that
+// destructures this export. Tests that assert on its content should be
+// updated to reflect the curated-op architecture.
+const FRAMEWORK_CHAIN_SLICE_CYPHER = '';
 
 function _nowIso() {
   return new Date().toISOString();
@@ -62,22 +75,29 @@ function _unwrapRows(result) {
 }
 
 /**
- * Fetch a parameterized 1-3 hop FEEDS_INTO slice from the live Brain.
+ * Fetch a 1-3 hop FEEDS_INTO slice from the live Brain via the curated
+ * askOp surface (D-MOAT-1-safe; no admin gate required).
  *
  * @param {object} opts
- * @param {string[]} opts.active_frameworks - Array of framework name strings.
- *   Empty array short-circuits to a degraded envelope.
+ * @param {string[]} opts.active_frameworks - Array of framework name strings
+ *   used as seeds. Empty array short-circuits to a degraded envelope.
  * @param {1|2|3} opts.max_hops - Hop depth (must be exactly 1, 2, or 3).
  *   Any other value short-circuits to a degraded envelope.
  * @param {object} [opts.brainClient] - Test seam; defaults to live brain-client.
  * @returns {Promise<{
- *   edges: Array<{from:string|null, to:string|null, confidence:number|null,
- *                 transform_description:string|null, hop_distance:number|null}>,
+ *   edges: Array<{from:string|null, to:string|null, confidence:null,
+ *                 transform_description:null, hop_distance:number|null}>,
  *   slice_scope: 1|2|3,
  *   slice_rationale: string,
  *   brain_snapshot_id: string|null,
- *   fetched_at: string
+ *   fetched_at: string,
+ *   confidence_omitted: true
  * }>}
+ *
+ * INTEGRATOR NOTE: confidence + transform_description are always null after
+ * this repoint. The curated op returns only { from, to, hop_distance }.
+ * `confidence_omitted: true` is set in every returned envelope so callers
+ * can detect the reduction and adapt accordingly.
  */
 async function fetchFrameworkChainSlice(opts) {
   const o = opts || {};
@@ -85,29 +105,31 @@ async function fetchFrameworkChainSlice(opts) {
   const max_hops = (o.max_hops === 1 || o.max_hops === 2 || o.max_hops === 3) ? o.max_hops : null;
   const brainClient = o.brainClient || defaultBrainClient;
 
-  // Gate 1: max_hops must be 1, 2, or 3. Anything else (0, 4, undefined,
-  // string, null) returns a degraded envelope with slice_scope defaulted to 3.
+  // Gate 1: max_hops must be 1, 2, or 3.
   if (max_hops === null) {
-    return _degraded({ max_hops: 3, rationale: 'invalid_max_hops; expected 1|2|3' });
+    return Object.assign(_degraded({ max_hops: 3, rationale: 'invalid_max_hops; expected 1|2|3' }), { confidence_omitted: true });
   }
 
   // Gate 2: empty active_frameworks short-circuits before any Brain contact.
-  // The Cypher would match nothing anyway; the degraded envelope is honest.
   if (active_frameworks.length === 0) {
-    return _degraded({ max_hops: max_hops, rationale: 'empty active_frameworks; no slice fetched' });
+    return Object.assign(_degraded({ max_hops: max_hops, rationale: 'empty active_frameworks; no slice fetched' }), { confidence_omitted: true });
   }
 
-  // Gate 3: Brain reachability check before issuing the Cypher query. The
-  // live brain-client.isAvailable() is sync + cheap (an API-key resolve).
+  // Gate 3: Brain reachability check.
   if (typeof brainClient.isAvailable === 'function' && !brainClient.isAvailable()) {
-    return _degraded({ max_hops: max_hops, rationale: 'brain_unreachable' });
+    return Object.assign(_degraded({ max_hops: max_hops, rationale: 'brain_unreachable' }), { confidence_omitted: true });
   }
 
-  // Canon Part 8 sanitization. brain-client._test.sanitizeCypherInput is the
-  // shipped whitelist (Phase 110-05 D-04 invariant). Each framework name is
-  // sanitized BEFORE binding; values that scrub down to empty are dropped.
-  // Fallback no-op only when the seam is genuinely absent (the live
-  // brain-client always exposes it; tests may stub a minimal client).
+  // Gate 4: askOp must be available on the client. The live brain-client
+  // gains askOp in the parallel BUG 2 build; tests may stub it. If the
+  // method is absent we fall back to the degraded path cleanly.
+  if (typeof brainClient.askOp !== 'function') {
+    return Object.assign(_degraded({ max_hops: max_hops, rationale: 'askOp_not_available_on_client' }), { confidence_omitted: true });
+  }
+
+  // Sanitize seed names before passing to askOp. The server also enforces
+  // the allow-list but we sanitize client-side as defence-in-depth.
+  // Canon Part 8 invariant preserved.
   const sanitizer = (brainClient._test && typeof brainClient._test.sanitizeCypherInput === 'function')
     ? brainClient._test.sanitizeCypherInput
     : function (s) { return s; };
@@ -117,66 +139,63 @@ async function fetchFrameworkChainSlice(opts) {
     .filter(function (n) { return typeof n === 'string' && n.length > 0; });
 
   if (sanitized.length === 0) {
-    return _degraded({
+    return Object.assign(_degraded({
       max_hops: max_hops,
       rationale: 'all_active_frameworks_rejected_by_sanitizer',
-    });
+    }), { confidence_omitted: true });
   }
 
-  // Issue the parameterized Cypher. The ONLY $-bound values are the sanitized
-  // framework name array + the max_hops integer. The Cypher string itself is
-  // a frozen constant -- no template interpolation, no string concatenation
-  // with caller-derived data (Canon Part 8 enforced by inspection).
-  let result;
+  // Issue the curated op. `seeds` is the param name per the contract;
+  // `max_hops` is passed through as-is (server clamps to [1,3]).
+  let opResult;
   try {
-    result = await brainClient.query(FRAMEWORK_CHAIN_SLICE_CYPHER, {
-      active_frameworks: sanitized,
+    opResult = await brainClient.askOp('framework_chain_slice', {
+      seeds: sanitized,
       max_hops: max_hops,
     });
   } catch (e) {
     const msg = (e && e.message) ? String(e.message) : 'unknown';
-    return _degraded({
+    return Object.assign(_degraded({
       max_hops: max_hops,
       rationale: 'brain_query_failed: ' + msg.slice(0, 60),
-    });
+    }), { confidence_omitted: true });
+  }
+
+  // Degraded envelope from server.
+  if (!opResult || opResult.degraded) {
+    return Object.assign(_degraded({ max_hops: max_hops, rationale: 'brain_returned_degraded' }), { confidence_omitted: true });
   }
 
-  const rows = _unwrapRows(result);
+  const rows = Array.isArray(opResult.rows) ? opResult.rows : null;
   if (rows === null) {
-    return _degraded({ max_hops: max_hops, rationale: 'brain_returned_non_array' });
+    return Object.assign(_degraded({ max_hops: max_hops, rationale: 'brain_returned_non_array' }), { confidence_omitted: true });
   }
 
-  // Map raw rows to the framework_chain_hint edge shape. Null-tolerant per
-  // G-05: confidence and transform_description may be null on the live graph
-  // and we preserve null explicitly (no defaults). hop_distance comes from
-  // length(r) which is always a number when the row exists.
-  // Defensive: hard-cap at 50 even though the Cypher already enforces LIMIT 50.
+  // Map curated op rows { from, to, hop_distance } to the edge shape.
+  // confidence and transform_description are NOT in the curated op response;
+  // they are set to null explicitly and flagged via confidence_omitted.
   const edges = rows.slice(0, 50).map(function (r) {
     return {
       from: (r && typeof r.from === 'string') ? r.from : null,
       to: (r && typeof r.to === 'string') ? r.to : null,
-      confidence: (r && typeof r.confidence === 'number') ? r.confidence : null,
-      transform_description: (r && typeof r.transform_description === 'string')
-        ? r.transform_description
-        : null,
+      confidence: null,              // not provided by curated op
+      transform_description: null,  // not provided by curated op
       hop_distance: (r && typeof r.hop_distance === 'number') ? r.hop_distance : null,
     };
   });
 
-  // brain_snapshot_id: per CONTEXT.md Open Question #4, "Brain commit_id if
-  // exposed, else SHA of Cypher result." The shipped brain_query does NOT
-  // expose a commit_id; we derive a deterministic content hash of the raw
-  // rows so callers can detect slice changes without holding the rows
-  // themselves (Plan 03 + downstream packet validator never sees them).
+  // Deterministic content hash for cache invalidation (content-addressed
+  // snapshot -- same rationale as the original implementation).
   const snapshotId = _sha256Hex(JSON.stringify(rows));
 
   return {
     edges: edges,
     slice_scope: max_hops,
     slice_rationale: 'brain_reachable; ' + edges.length + ' edges fetched; '
-      + sanitized.length + ' active_frameworks; max_hops=' + max_hops,
+      + sanitized.length + ' seeds; max_hops=' + max_hops,
     brain_snapshot_id: snapshotId,
     fetched_at: _nowIso(),
+    confidence_omitted: true,
   };
 }
 

package/lib/core/brain-client.cjs

@@ -464,6 +464,59 @@ async function ask(question) {
   return callTool('brain_ask', { question: question });
 }
 
+/**
+ * Curated-op call against the Brain (the `op` MODE of brain_ask).
+ *
+ * brain_ask gained an optional curated-op surface (BUG 2 fix). Where ask()
+ * runs the natural-language directive path, askOp() runs one of a closed set
+ * of named, parameterized operations the Brain resolves to a FROZEN
+ * server-side Cypher string. The three ops:
+ *
+ *   - 'list_frameworks'       params { limit? }            -> rows { name, description, category }
+ *   - 'framework_edges'       params { edge_type, limit? } -> rows { from, to, confidence, transform }
+ *                                                            or { framework, problem_type }
+ *   - 'framework_chain_slice' params { seeds, max_hops?, limit? } -> rows { from, to, hop_distance }
+ *
+ * Canon Part 8: every param is a generic methodology handle (framework name,
+ * closed enum, integer) -- never user content. No caller Cypher is ever sent;
+ * the Brain owns the query text. This path is ungated -- any valid key may
+ * call it (only query()/write() touch the admin-gated tools).
+ *
+ * Consumers that only need a framework chain for ONE anchor keep using
+ * ask(question) and read next_gate.options[].framework (the directive path).
+ *
+ * Returns the parsed curated-op payload { op, source, count, rows, degraded? }
+ * on success. On any transport / parse failure (Brain unreachable, no API key,
+ * bad payload) returns a graceful { op, count: 0, rows: [], degraded: true } so
+ * the caller never crashes -- mirrors query()'s graceful-degradation contract.
+ *
+ * @param {string} operation - one of the three curated op names
+ * @param {object} [params]  - generic-handles-only params object
+ * @returns {Promise<{op: string, source?: string, count: number, rows: Array, degraded?: boolean}>}
+ */
+async function askOp(operation, params = {}) {
+  try {
+    const result = await callTool('brain_ask', { op: operation, params: params || {} });
+    // callTool already parses the JSON text payload of the MCP content item,
+    // so a well-formed curated-op response arrives as the payload object.
+    if (result && typeof result === 'object'
+        && typeof result.count === 'number' && Array.isArray(result.rows)) {
+      return {
+        op: result.op || operation,
+        source: result.source,
+        count: result.count,
+        rows: result.rows,
+        ...(result.degraded ? { degraded: true } : {}),
+      };
+    }
+    // Unreachable Brain (null), an error/text passthrough, or any unexpected
+    // shape -> graceful degraded sentinel.
+    return { op: operation, count: 0, rows: [], degraded: true };
+  } catch (_err) {
+    return { op: operation, count: 0, rows: [], degraded: true };
+  }
+}
+
 /**
  * Get Pinecone stats.
  */
@@ -1242,6 +1295,7 @@ module.exports = {
   search,
   smartSearch,
   ask,
+  askOp,
   schema,
   stats,
   enrichCausalEdges,

package/lib/core/brain-derivation-prompts.cjs

@@ -182,18 +182,20 @@ function safeInt(value, fallback) {
 // interface (which takes raw cypher); interpolation is unavoidable.
 // Safety is achieved by the two-layer validation above.
 
+// BUG 2 fix: was mode:'query' (admin-gated brain_query with ADDRESSES_PROBLEM_TYPE
+// Cypher). Repointed to mode:'search' (ungated brain_search). Returns a semantic
+// search string instead of Cypher. The Brain's Pinecone index surfaces frameworks
+// that address the problem type and phase via embedding similarity.
+// Canon Part 8: only frozen enum strings are interpolated -- no user content.
 function buildPatternMatchesQuery(ctx) {
   validateCtx(ctx);
   const section = safeEnum(ctx.section_slug, 'unknown');
   const problemType = safeEnum(ctx.problem_type, 'UDP');
   const phase = safeEnum(ctx.phase_indicator, 'unknown');
   return (
-    'MATCH (f:Framework)-[:ADDRESSES_PROBLEM_TYPE]->(pt:ProblemType) ' +
-    'WHERE pt.name CONTAINS "' + problemType + '" ' +
-    'OPTIONAL MATCH (f)-[:APPLIES_AT_PHASE]->(p:Phase {name: "' + phase + '"}) ' +
-    'RETURN f.name AS framework, f.description AS description, ' +
-    '"' + section + '" AS section_slug ' +
-    'LIMIT 10'
+    'frameworks that address problem_type:' + problemType +
+    ' at phase:' + phase +
+    ' for section:' + section
   );
 }
 
@@ -241,15 +243,18 @@ function buildUnfilledOpportunityMatchesQuery(ctx) {
   );
 }
 
+// BUG 2 fix: was mode:'query' (admin-gated brain_query with FEEDS_INTO Cypher).
+// Repointed to mode:'search' (ungated brain_search). Returns a semantic
+// search string instead of Cypher. The Brain's Pinecone index surfaces framework
+// chain predictions via embedding similarity on FEEDS_INTO relationships.
+// Canon Part 8: only frozen enum strings are interpolated -- no user content.
 function buildFrameworkChainPredictionsQuery(ctx) {
   validateCtx(ctx);
   const phase = safeEnum(ctx.phase_indicator, 'unknown');
   const problemType = safeEnum(ctx.problem_type, 'UDP');
   return (
-    'MATCH (f1:Framework)-[:APPLIES_AT_PHASE]->(p:Phase {name: "' + phase + '"}) ' +
-    'MATCH (f1)-[:FEEDS_INTO]->(f2:Framework) ' +
-    'OPTIONAL MATCH (f1)-[:ADDRESSES_PROBLEM_TYPE]->(pt:ProblemType {name: "' + problemType + '"}) ' +
-    'RETURN f1.name AS from_framework, f2.name AS to_framework LIMIT 10'
+    'framework chain predictions FEEDS_INTO phase:' + phase +
+    ' problem_type:' + problemType
   );
 }
 

package/lib/core/brain-derivation.cjs

@@ -58,12 +58,26 @@ const prompts = require('./brain-derivation-prompts.cjs');
 
 // Section heading -> prompt builder mapping. Order matters: this is the
 // canonical emission order inside BRAIN.md body.
+//
+// BUG 2 fix (2026-05-22): sections whose Cypher traverses FEEDS_INTO or
+// ADDRESSES_PROBLEM_TYPE edges are repointed from mode:'query' (admin-gated
+// brain_query) to mode:'search' (ungated brain_search). Their prompt builders
+// are also updated (see brain-derivation-prompts.cjs) to emit a semantic
+// search string instead of raw Cypher. The SECTION_BUILDERS mode field is
+// the dispatch key in the derivation loop below.
+//
+// Sections that still use mode:'query' target node types with no curated op
+// and no practical semantic-search equivalent (WickedIndicator, Opportunity,
+// RigorLevel, ProblemType, HsiRecommendation). Those calls will fail (or
+// return empty) for non-admin users -- that is the correct graceful-degradation
+// behaviour (existing firstError path). A future phase can add curated ops
+// for those node types.
 const SECTION_BUILDERS = Object.freeze([
-  { heading: 'Pattern Matches',                     builder: 'buildPatternMatchesQuery',                     mode: 'query' },
+  { heading: 'Pattern Matches',                     builder: 'buildPatternMatchesQuery',                     mode: 'search' },
   { heading: 'Cross-Domain Analogies',              builder: 'buildCrossDomainAnalogiesQuery',               mode: 'search' },
   { heading: 'Wicked Indicators',                   builder: 'buildWickedIndicatorsQuery',                   mode: 'query' },
   { heading: 'Unfilled Opportunity Matches',        builder: 'buildUnfilledOpportunityMatchesQuery',         mode: 'query' },
-  { heading: 'Framework Chain Predictions',         builder: 'buildFrameworkChainPredictionsQuery',          mode: 'query' },
+  { heading: 'Framework Chain Predictions',         builder: 'buildFrameworkChainPredictionsQuery',          mode: 'search' },
   { heading: 'Assessment Thinking Chain Position',  builder: 'buildAssessmentThinkingChainPositionQuery',    mode: 'query' },
   { heading: 'ProblemType Classification',          builder: 'buildProblemTypeClassificationQuery',          mode: 'query' },
   { heading: 'Flagged Contradictions (cross-room)', builder: 'buildFlaggedContradictionsXroomQuery',         mode: 'query' },

package/lib/core/rs-chain-feeder.cjs

@@ -128,35 +128,32 @@ const SKILL_SPAWN_RULES = Object.freeze([
 
 // ---------- Internal helpers ----------
 
-// Sanitize a string for embedding in a Cypher query. Mirrors the byte-
-// for-byte whitelist from brain-client.cjs::sanitizeCypherInput
-// ([a-zA-Z0-9 ._-]). We do NOT call brainClient._test.sanitizeCypherInput
-// directly so this module remains testable with a stub brainClient.
-function _sanitizeCypher(value) {
+// Sanitize a string to a safe generic handle suitable for embedding in a
+// NL question sent to brain_ask. Mirrors the whitelist from brain-client.cjs
+// ([a-zA-Z0-9 ._-]) so only generic methodology handles pass through.
+// Canon Part 8: no user content ever flows into the NL question.
+function _sanitizeHandle(value) {
   if (value === null || value === undefined) return '';
   const s = typeof value === 'string' ? value : String(value);
   return s.replace(/[^a-zA-Z0-9 ._-]/g, '');
 }
 
-// Build the Brain Cypher query asking for upstream FEEDS_INTO frameworks
-// for the reverse-salient engine, parameterized (defensively sanitized)
-// by problem_type + stage for forward-compat (89.5 may bind these via
-// Brain's parameterized query path).
-function _buildUpstreamCypher(problem_type, stage) {
-  const safeProblem = _sanitizeCypher(problem_type);
-  const safeStage = _sanitizeCypher(stage);
-  // Note: safeProblem / safeStage are intentionally embedded in a
-  // comment line so they participate in the query text without
-  // affecting the MATCH semantics. The authoritative Brain edge query
-  // is for upstream frameworks pointing at the reverse-salient node.
-  return (
-    '// chain-feeder upstream lookup (problem_type=' + safeProblem +
-    ' stage=' + safeStage + ')\n' +
-    'MATCH (rs:Framework {id: "reverse-salient-framework"}) ' +
-    '<-[:FEEDS_INTO]-(upstream:Framework) ' +
-    'WHERE rs.id IS NOT NULL ' +
-    'RETURN upstream.name AS name LIMIT 10'
-  );
+// Build the NL question for brain_ask asking for upstream FEEDS_INTO
+// frameworks for the reverse-salient engine.
+// BUG 2 fix: replaced the former admin-gated raw-Cypher brain_query path
+// with a brain_ask question (ungated -- valid for all API keys).
+// Canon Part 8: the question carries only sanitized generic enum handles,
+// never user content, never artifact text.
+function _buildUpstreamQuestion(problem_type, stage) {
+  const safeProblem = _sanitizeHandle(problem_type);
+  const safeStage = _sanitizeHandle(stage);
+  // Generic NL question: asks for frameworks that feed into the
+  // reverse-salient framework for the given problem type and stage.
+  let q = 'what frameworks feed into the reverse salient framework';
+  if (safeProblem) q += ' for a ' + safeProblem + ' problem';
+  if (safeStage) q += ' at the ' + safeStage + ' stage';
+  q += '?';
+  return q;
 }
 
 // Defensively pull the framework name from a Brain record. Brain
@@ -187,18 +184,53 @@ async function lookupUpstream(problem_type, stage, opts) {
     return { state: 'ready' };
   }
 
-  let result;
+  // BUG 2 fix: use brain_ask (ungated) instead of brain_query (admin-gated).
+  // brain.ask() returns a DirectiveEnvelope; we read next_gate.options[].framework
+  // for the upstream framework names, mirroring the old record.name extraction.
+  if (typeof brainClient.ask !== 'function') {
+    process.stderr.write('chain-feeder: brainClient.ask not available; assuming upstream ready\n');
+    return { state: 'ready' };
+  }
+
+  let askResult;
   try {
-    const cypher = _buildUpstreamCypher(problem_type, stage);
-    result = await brainClient.query(cypher);
+    const nlQuestion = _buildUpstreamQuestion(problem_type, stage);
+    askResult = await brainClient.ask(nlQuestion);
   } catch (_err) {
-    process.stderr.write('chain-feeder: Brain query threw; assuming upstream ready\n');
+    process.stderr.write('chain-feeder: Brain ask threw; assuming upstream ready\n');
+    return { state: 'ready' };
+  }
+
+  if (!askResult) {
+    process.stderr.write(
+      'chain-feeder: Brain ask returned null; assuming upstream ready\n'
+    );
     return { state: 'ready' };
   }
 
-  if (!result || !Array.isArray(result.records)) {
+  // Translate the brain_ask response into the framework-name list shape
+  // the upstream-freshness check expects. next_gate.options[].framework
+  // carries the framework names; fall back to directive.guided.framework.
+  // Build a synthetic result.records array for the existing freshness loop.
+  const frameworkNames = [];
+  if (askResult.next_gate && Array.isArray(askResult.next_gate.options)) {
+    for (const opt of askResult.next_gate.options) {
+      if (opt && typeof opt.framework === 'string' && opt.framework.length > 0) {
+        frameworkNames.push(opt.framework);
+      }
+    }
+  }
+  if (askResult.directive && askResult.directive.guided && askResult.directive.guided.framework) {
+    const anchor = askResult.directive.guided.framework;
+    if (!frameworkNames.includes(anchor)) frameworkNames.unshift(anchor);
+  }
+
+  // Wrap in the shape the downstream freshness loop already handles.
+  const result = { records: frameworkNames.map(function (n) { return { name: n }; }) };
+
+  if (!Array.isArray(result.records)) {
     process.stderr.write(
-      'chain-feeder: Brain query returned unexpected shape; assuming upstream ready\n'
+      'chain-feeder: Brain ask returned unexpected shape; assuming upstream ready\n'
     );
     return { state: 'ready' };
   }

package/lib/core/rs-nl-to-query.cjs

@@ -182,9 +182,14 @@ const ALLOW_LIST_INTENTS = Object.freeze([
       /downstream\s+of/i,
       /what\s+chains?\s+into/i,
     ],
-    brain_template:
-      'MATCH (m:Methodology {id: $target_framework})-[:FEEDS_INTO*0..1]-(t:Methodology) '
-      + 'RETURN t.name AS name, t.id AS id LIMIT 10',
+    // BUG 2 fix: brain_template is now null so buildBrainQueryFromNL returns
+    // null (the safe default) and does NOT attempt raw admin-gated Cypher.
+    // The brain_ask NL question is synthesized in executeBundle (rs-explain-
+    // command.cjs) from intent_id + params.target_framework (enum handle only;
+    // Canon Part 8 preserved). brain_ask is ungated; brain_query was admin-gated.
+    brain_template: null,
+    // brain_ask_template documents the NL question shape used at runtime.
+    brain_ask_template: 'what frameworks chain from {target_framework} via FEEDS_INTO?',
     sql_template: null,
     cypher_template: null,
     params_extractor: extractFrameworkParam,
@@ -221,9 +226,14 @@ const ALLOW_LIST_INTENTS = Object.freeze([
       /what\s+comes\s+after/i,
       /chains?\s+from\s+(?:jtbd|persona|swot|porter)/i,
     ],
-    brain_template:
-      'MATCH (m:Methodology {id: $source_id})-[:FEEDS_INTO*1..3]->(t:Methodology) '
-      + 'RETURN t.name AS name, t.id AS id LIMIT 10',
+    // BUG 2 fix: brain_template is now null so buildBrainQueryFromNL returns
+    // null (the safe default) and does NOT attempt raw admin-gated Cypher.
+    // The brain_ask NL question is synthesized in executeBundle (rs-explain-
+    // command.cjs) from intent_id + params.source_id (enum handle only;
+    // Canon Part 8 preserved). brain_ask is ungated; brain_query was admin-gated.
+    brain_template: null,
+    // brain_ask_template documents the NL question shape used at runtime.
+    brain_ask_template: 'what methodology chain follows {source_id}?',
     sql_template: null,
     cypher_template: null,
     params_extractor: extractMethodologyParam,