@mindrian_os/cli 2.0.0-beta.31 → 2.0.0-beta.35

package/lib/core/integration-registry.cjs

@@ -1,19 +1,20 @@
 'use strict';
 
 /**
- * Integration Registry — detects available integrations from env, MCP config, filesystem.
+ * Integration Registry - detects available integrations from env, MCP config, filesystem.
  *
  * Zero npm dependencies. Pure Node.js built-ins only (Phase 10 pattern).
  *
  * Exports:
- *   INTEGRATION_CATALOG — all known integrations with detection config
- *   detectIntegrations(options) — scan all integrations, return structured status
- *   checkIntegration(name) — single integration check
- *   getContextTriggers(userMessage, roomState) — suggest integrations based on context
+ *   INTEGRATION_CATALOG - all known integrations with detection config
+ *   detectIntegrations(options) - scan all integrations, return structured status
+ *   checkIntegration(name) - single integration check
+ *   getContextTriggers(userMessage, roomState) - suggest integrations based on context
  */
 
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 
 /**
  * Catalog of all known integrations.
@@ -61,19 +62,92 @@ const INTEGRATION_CATALOG = {
   },
 };
 
+/**
+ * Read and JSON.parse a config file. Returns the parsed object, or null on
+ * any failure (missing file, unreadable, malformed JSON). Private: the one
+ * fs.readFileSync + JSON.parse site both parseMcpConfig() and
+ * readScopedMcpServers() delegate to, so there is exactly one place that
+ * touches disk for either reader (Canon Part 7, no third reader minted).
+ */
+function _readJsonConfig(configPath) {
+  try {
+    const raw = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(raw);
+  } catch (e) {
+    return null;
+  }
+}
+
 /**
  * Parse .mcp.json to extract configured MCP server keys.
  * Returns array of server key strings (lowercased).
+ * Byte-unchanged behavior from before the _readJsonConfig extraction: any
+ * read/parse failure still yields [].
  */
 function parseMcpConfig(mcpConfigPath) {
-  try {
-    const raw = fs.readFileSync(mcpConfigPath, 'utf-8');
-    const parsed = JSON.parse(raw);
-    const servers = parsed.mcpServers || parsed.servers || {};
-    return Object.keys(servers).map(k => k.toLowerCase());
-  } catch (e) {
-    return [];
+  const parsed = _readJsonConfig(mcpConfigPath);
+  if (!parsed) return [];
+  const servers = parsed.mcpServers || parsed.servers || {};
+  return Object.keys(servers).map(k => k.toLowerCase());
+}
+
+/**
+ * Read Claude Code's own MCP server config (~/.claude.json by default) and
+ * project the mcpServers entries at BOTH scopes Claude Code actually has for
+ * this file: top-level mcpServers (scope "user") and
+ * projects[projectDir].mcpServers (scope "local"). This intentionally never
+ * reads a repo's own .mcp.json ("project" scope in Claude Code's own
+ * vocabulary) -- that is a different file entirely and is out of scope for
+ * this reader by construction, never by discipline.
+ *
+ * SECURITY (Canon Part 8, quick task 260911-axz, T-axz-01): the returned
+ * shape is a STRUCTURAL secret-leak guard, not a discretionary one. Each
+ * entry is projected down to exactly { name, scope, url_host, type }. This
+ * function NEVER copies `headers`, NEVER copies the full `url` (only the
+ * host, derived via `new URL(entry.url).host`), and NEVER copies `env`, so
+ * no caller of this function -- today or in a future edit -- can leak a
+ * Bearer token, an API key, or any other header value even by accident:
+ * the bytes are never read into the return value in the first place.
+ *
+ * @param {{configPath?: string, projectDir?: string}} [opts]
+ * @returns {Array<{name: string, scope: 'user'|'local', url_host: string|null, type: string|null}>}
+ */
+function readScopedMcpServers(opts) {
+  const o = opts || {};
+  const configPath = o.configPath || path.join(os.homedir(), '.claude.json');
+  const projectDir = o.projectDir || process.cwd();
+
+  const parsed = _readJsonConfig(configPath);
+  if (!parsed) return [];
+
+  const out = [];
+  const pushScope = (serversObj, scope) => {
+    if (!serversObj || typeof serversObj !== 'object') return;
+    for (const name of Object.keys(serversObj)) {
+      const entry = serversObj[name] || {};
+      let url_host = null;
+      if (typeof entry.url === 'string' && entry.url.length > 0) {
+        try {
+          url_host = new URL(entry.url).host;
+        } catch (_e) {
+          url_host = null;
+        }
+      }
+      out.push({
+        name: name,
+        scope: scope,
+        url_host: url_host,
+        type: typeof entry.type === 'string' ? entry.type : null,
+      });
+    }
+  };
+
+  pushScope(parsed.mcpServers, 'user');
+  if (parsed.projects && typeof parsed.projects === 'object' && parsed.projects[projectDir]) {
+    pushScope(parsed.projects[projectDir].mcpServers, 'local');
   }
+
+  return out;
 }
 
 /**
@@ -98,8 +172,8 @@ function detectObsidianVault(workDir) {
 
 /**
  * Detect status of a single integration.
- * @param {string} name — integration key from INTEGRATION_CATALOG
- * @param {object} opts — { workDir, mcpKeys }
+ * @param {string} name - integration key from INTEGRATION_CATALOG
+ * @param {object} opts - { workDir, mcpKeys }
  * @returns {object} status object
  */
 function detectSingle(name, opts) {
@@ -147,8 +221,8 @@ function detectSingle(name, opts) {
 /**
  * Detect all integrations.
  * @param {object} options
- * @param {string} options.workDir — defaults to process.cwd()
- * @param {string} options.mcpConfig — path to .mcp.json (defaults to workDir/.mcp.json)
+ * @param {string} options.workDir - defaults to process.cwd()
+ * @param {string} options.mcpConfig - path to .mcp.json (defaults to workDir/.mcp.json)
  * @returns {object} keyed by integration name, each with status object
  */
 function detectIntegrations(options = {}) {
@@ -168,8 +242,8 @@ function detectIntegrations(options = {}) {
 
 /**
  * Check a single integration by name.
- * @param {string} name — integration key
- * @param {object} options — same as detectIntegrations
+ * @param {string} name - integration key
+ * @param {object} options - same as detectIntegrations
  * @returns {object} status object for that integration
  */
 function checkIntegration(name, options = {}) {
@@ -184,8 +258,8 @@ function checkIntegration(name, options = {}) {
  * Analyze user message + room state and return integration suggestions.
  * Returns at most 1 suggestion. Suppressed during active methodology.
  *
- * @param {string} userMessage — the user's current message
- * @param {object} roomState — current room state (activeMethodology truthy = suppress)
+ * @param {string} userMessage - the user's current message
+ * @param {object} roomState - current room state (activeMethodology truthy = suppress)
  * @returns {Array<{integration: string, reason: string, offer_text: string}>}
  */
 function getContextTriggers(userMessage, roomState = {}) {
@@ -229,4 +303,6 @@ module.exports = {
   detectIntegrations,
   checkIntegration,
   getContextTriggers,
+  parseMcpConfig,
+  readScopedMcpServers,
 };

package/lib/core/intel-pipeline.cjs

@@ -105,20 +105,35 @@ function isApproved(decision) {
 // -> wireAccept, run per dimension. Lazy-required so the module loads without
 // the heavy lens engine; a leg that is unavailable degrades to a disclosed
 // low-quality pass (SEED-059) rather than throwing. Exercised live at phase
-// verification (223-VALIDATION), never in the hermetic fixture.
+// verification (223-VALIDATION), never in the hermetic fixture. SAME research
+// pipe contract as lib/mcp/tool-router.cjs (extractContext takes one object;
+// the driver reads camelCase lensSet); the two callers must change together
+// until a shared adapter exists (Canon Part 7).
 async function defaultResearchFn(dimension, ctx) {
   const context = isPlainObject(ctx) ? ctx : {};
   try {
     // eslint-disable-next-line global-require
-    const extractor = require('./research-context-extractor.cjs');
+    const extractor = isPlainObject(context._extractor) ? context._extractor : require('./research-context-extractor.cjs');
     // eslint-disable-next-line global-require
-    const lensDriver = require('../lens-engine/source-lens-driver.cjs');
+    const lensDriver = isPlainObject(context._lensDriver) ? context._lensDriver : require('../lens-engine/source-lens-driver.cjs');
     const wirer = require('./findings-wirer.cjs');
+    // The topic is the roster cell handle when present, else the dimension
+    // label -- both are GENERIC handles (Part 8 rule at lines 217-219 above),
+    // never room content, so nothing user-specific becomes a corpus query.
+    const topic = typeof context.handle === 'string' && context.handle.length > 0 ? context.handle : String(dimension);
     const extracted = typeof extractor.extractContext === 'function'
-      ? await extractor.extractContext(context.roomDir, { dimension: dimension })
+      ? await extractor.extractContext({ roomDir: context.roomDir, topic: topic, db: context.db })
       : null;
     const lensed = typeof lensDriver.runSourceLens === 'function'
-      ? await lensDriver.runSourceLens(Object.assign({ dimension: dimension }, extracted || {}))
+      ? await lensDriver.runSourceLens({
+        roomDir: context.roomDir,
+        topic: topic,
+        lensSet: extracted ? extracted.lens_set : undefined,
+        preflight: extracted ? extracted.preflight : undefined,
+        stage: 'explore',
+        db: context.db,
+        dimension: dimension,
+      })
       : null;
     const findings = lensed && Array.isArray(lensed.findings) ? lensed.findings : [];
     const quality = lensed && typeof lensed.quality === 'string' ? lensed.quality : (findings.length > 0 ? 'ok' : 'low');
@@ -276,7 +291,8 @@ function rosterToCells(roster, axes) {
  *   gateFn(ctx)->approve, onHalt(info),
  *   jtbdFns?{getCurrent, ...write} (the JTBD read/write seam pair),
  *   planFn?, researchFn?, computeFn?,
- *   writeFn?, classifyFn?, bankRollupFn?, genericDims?, run_id?, dateStr?
+ *   writeFn?, classifyFn?, bankRollupFn?, genericDims?, run_id?, dateStr?,
+ *   _extractor?, _lensDriver? (test seams for the shipped defaultResearchFn)
  * }
  *
  * result: { ok, dry_run?, halted?, halt_stage?, stages:[{stage,status,disclosure?}],
@@ -428,6 +444,10 @@ async function runIntelPipeline(opts) {
     let pass;
     try {
       const researchCtx = { roomDir: roomDir, db: db, dimension: dim };
+      // Test seams for the shipped research pipe (quick-260910-dk1): threaded
+      // through only when the caller supplies a plain object, never faked up.
+      if (isPlainObject(o._extractor)) researchCtx._extractor = o._extractor;
+      if (isPlainObject(o._lensDriver)) researchCtx._lensDriver = o._lensDriver;
       if (cell) {
         researchCtx.entity = cell.entity;
         researchCtx.axis = cell.axis;
@@ -542,4 +562,5 @@ async function runIntelPipeline(opts) {
   return { ok: written ? written.ok !== false : false, halted: false, stages: stages, plan: plan, written: written };
 }
 
-module.exports = { runIntelPipeline, PIPELINE_STAGES, rosterToCells };
+// _internal.defaultResearchFn exposed for tests (private; do NOT consume in production)
+module.exports = { runIntelPipeline, PIPELINE_STAGES, rosterToCells, _internal: { defaultResearchFn } };

package/lib/core/part8-egress-guard.cjs

@@ -328,6 +328,16 @@ function _isFreeFormTool(toolName) {
 const TAXONOMY_RUNGS = Object.freeze(new Set(['undefined', 'ill-defined', 'well-defined', 'wicked']));
 const KNOWN_LABEL_MAX = 120;
 
+// Quick 260910-hni: recommend_chain's problem_type enum, the UNION of the
+// incumbent's canonical rung strings and Theo's own ids (both vocabularies
+// are live during the cutover soak; recommendChain() in brain-client.cjs
+// already selects the right table by origin, this recognizer just has to
+// accept whichever one the wrapper actually sent).
+const RECOMMEND_CHAIN_PROBLEM_TYPES = Object.freeze(new Set([
+  'Undefined Problem', 'Ill-Defined Problem', 'Well-Defined Problem',
+  'UnDefined', 'IllDefined', 'WellDefined', 'Wicked',
+]));
+
 // _isSafeShortLabel(v): a string, 1-120 chars, no CR/LF, and clears _safeAudit.
 // The length-and-single-line bound is label hygiene ("this is a node label,
 // not prose"), NOT the content defense -- step 1's default-deny scan is. It is
@@ -436,6 +446,23 @@ function _proveKnownToolShape(payload, toolName) {
     return { class: 'known_tool_shape', reason: 'taxonomy_ladder rung enum' };
   }
 
+  if (toolName.indexOf('recommend_chain') !== -1) {
+    // BOTH required, ZERO optional: recommendChain() (lib/core/brain-
+    // client.cjs) always sends both problem_type and max_steps, and an empty
+    // optional list is what makes this fail-closed on any extra key.
+    if (!_hasExactKeys(payload, ['problem_type', 'max_steps'], [])) return null;
+    if (typeof payload.problem_type !== 'string'
+        || !RECOMMEND_CHAIN_PROBLEM_TYPES.has(payload.problem_type)) return null;
+    if (!Number.isInteger(payload.max_steps)
+        || payload.max_steps < 1 || payload.max_steps > 6) return null;
+    // _normalizeBrainProblemType passes any well-shaped UNMAPPED token
+    // through unchanged, so an off-enum value (say 'Trinity') falls out of
+    // this arm to the terminal catch-all as ambiguous, which PROCEEDS with a
+    // disclosure rather than blocking: this change strictly NARROWS what is
+    // ambiguous and never widens what may carry content.
+    return { class: 'known_tool_shape', reason: 'recommend_chain problem_type enum' };
+  }
+
   return null;
 }
 

package/lib/mcp/brain-composition-census.cjs

@@ -77,15 +77,28 @@
  *     Section 3.5's explicit APPROVE condition) or validateSites() throws
  *     at module load.
  *
- * This module is a DECLARATION only: it requires nothing, executes
- * nothing, opens no wire. The scanner that reconciles it against source
- * lives in the test, not here -- that split is what lets this file hold
- * plain quoted path strings as DATA without ever matching its own
- * require-expression scan pattern.
+ * This module is a DECLARATION that requires exactly one pure-data leaf
+ * (brain-route-bound.cjs) and nothing else; it still EXECUTES nothing and
+ * OPENS NO WIRE (Quick 260911-ddd, DDD-02: the leaf itself requires nothing
+ * and opens no wire either, so this property still holds transitively).
+ * The scanner that reconciles this declaration against source lives in the
+ * test, not here -- that split is what lets this file hold plain quoted
+ * path strings as DATA without ever matching its own require-expression
+ * scan pattern. The new require names `brain-route-bound.cjs`, which
+ * matches neither the census scan's REACH_RE (brain-client|chain-
+ * recommender) nor its wire-pattern scan, so this file's own scan-safety
+ * property is unaffected.
  *
  * No em-dashes. CJS only.
  */
 
+// Quick 260911-ddd (DDD-02): the single source of the Tier 3 bound. Reading
+// the leaf here (rather than reading brain-router.cjs's own export) keeps
+// the DECLARATION direction correct: this census depends on the constant,
+// never on the implementation, so the declaration cannot silently drift
+// out of sync with a router edit.
+const { BRAIN_ROUTE_TIMEOUT_MS } = require('./brain-route-bound.cjs');
+
 const COMPOSITION_SITES = Object.freeze([
   Object.freeze({
     file: 'lib/mcp/brain-router.cjs',
@@ -94,7 +107,10 @@ const COMPOSITION_SITES = Object.freeze([
     via: "brainClient.ask(question) -- a generic problem-type/complexity enum question, never room content",
     reaches_brain: true,
     belt: 'callTool',
-    bound_ms: 2000,
+    // Quick 260911-ddd (DDD-02): bound_ms is the DEFAULT from the single
+    // source (lib/mcp/brain-route-bound.cjs); MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS
+    // can move the APPLIED bound at runtime without editing this file.
+    bound_ms: BRAIN_ROUTE_TIMEOUT_MS,
     frequency: 'one call per act* invocation, Tier 3 only (Tier 1 cache and Tier 2 local heuristic run first and can short-circuit before this call is made)',
     reason: "D-01 ratifies this as the orchestration tool's live Brain-grounded recommendation leg, shipped before this phase existed. Desktop and Cowork have no MCP hook surface, so this is their only Brain-grounded enrichment path for act*.",
     ratified_by: 'D-01',

package/lib/mcp/brain-route-bound.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Quick 260911-ddd (DDD-02) -- the single source of truth for
+ * brain-router.cjs's Tier 3 race bound. A pure-data leaf: requires nothing,
+ * opens no wire. lib/mcp/brain-router.cjs reads BRAIN_ROUTE_TIMEOUT_MS /
+ * resolveBrainRouteTimeoutMs() to build its Promise.race; brain-composition-
+ * census.cjs's bound_ms entry reads BRAIN_ROUTE_TIMEOUT_MS so the census
+ * DECLARATION depends on a constant instead of on the router's own
+ * implementation -- that direction (census -> leaf, never census -> router)
+ * is what keeps the census honest: a router edit can never silently move the
+ * bound the census reports without also moving this leaf.
+ *
+ * WHY 6000, MEASURED GROUND (not intuition):
+ *
+ * The raced call is brainClient.ask(), which since quick 260910-hni makes
+ * THREE sequential Theo calls (brain_ask, then recommend_chain, then
+ * brain_query). A Render instance waking from spin-down was measured at
+ * 2.034 s on the FIRST call alone, and Theo redeploys on every push to its
+ * main, opening a fresh cold window each time. So the old 2000 ms bound
+ * could not cover even a WARM three-call composition on a slow link, let
+ * alone a cold one -- every cold window silently degraded /mos:act to the
+ * local heuristic with no disclosure of why.
+ *
+ * 6000 is the measured 2.034 s cold wake plus two warm follow-on calls
+ * (roughly 1 s total) with roughly 2x headroom on top of that sum.
+ *
+ * THE ACCEPTED COST: when Theo is genuinely down, the race now rejects at
+ * 6 s instead of 2 s. This is a real cost, not hand-waved away -- but
+ * localRec (lib/mcp/brain-router.cjs's Tier 2 local heuristic) is already
+ * computed BEFORE the race starts, so the Tier 2 answer is instant once the
+ * race loses and /mos:act still resolves either way. The trade is a rarer
+ * 6 s worst case against a silently degraded recommendation on every cold
+ * window -- accepted (see the threat register, T-ddd-04).
+ *
+ * No em-dashes. CJS only.
+ */
+
+/**
+ * The default Tier 3 race bound in milliseconds. See the file header for
+ * the measured justification.
+ * @type {number}
+ */
+const BRAIN_ROUTE_TIMEOUT_MS = 6000;
+
+/**
+ * resolveBrainRouteTimeoutMs(env) -- honors MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS
+ * only when it parses to a finite integer strictly greater than 0;
+ * otherwise returns BRAIN_ROUTE_TIMEOUT_MS unchanged. A malformed operator
+ * env can never zero out or invert the bound.
+ *
+ * @param {object} [env] defaults to process.env
+ * @returns {number}
+ */
+function resolveBrainRouteTimeoutMs(env) {
+  const source = env || process.env;
+  const raw = source && source.MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS;
+  if (typeof raw !== 'string' || raw.trim().length === 0) return BRAIN_ROUTE_TIMEOUT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) return BRAIN_ROUTE_TIMEOUT_MS;
+  return parsed;
+}
+
+module.exports = { BRAIN_ROUTE_TIMEOUT_MS, resolveBrainRouteTimeoutMs };

package/lib/mcp/brain-router.cjs

@@ -6,7 +6,7 @@
  * 3-tier fallback for framework recommendations:
  *   Tier 1: In-memory cache (instant, 10-min TTL)
  *   Tier 2: Local heuristic from problem-types.md (~100ms)
- *   Tier 3: Brain API via brain-client.cjs (2s hard timeout)
+ *   Tier 3: Brain API via brain-client.cjs (bound: MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS, default 6000ms -- lib/mcp/brain-route-bound.cjs)
  *
  * RECOMMENDS only -- never executes frameworks.
  * Called by orchestration router for act*, suggest-next commands.
@@ -14,6 +14,12 @@
 
 const path = require('path');
 const { safeReadFile } = require('../core/index.cjs');
+// Quick 260911-ddd (DDD-02): the single source of the Tier 3 race bound.
+// See brain-route-bound.cjs's header for the measured 6000 ms justification
+// and brain-composition-census.cjs, whose bound_ms entry reads this SAME
+// leaf. brain-composition-census provenance: this file's Tier 3 race is
+// enumerated in lib/mcp/brain-composition-census.cjs.
+const { BRAIN_ROUTE_TIMEOUT_MS, resolveBrainRouteTimeoutMs } = require('./brain-route-bound.cjs');
 
 // ---------------------------------------------------------------------------
 // Cache (Tier 1)
@@ -287,11 +293,12 @@ function localRoute(roomDir, stateContent, intent) {
 // Phase 254 (COMP-01): this call is enumerated in
 // lib/mcp/brain-composition-census.cjs as the 'orchestration (act,
 // act-chain, act-dry-run, act-swarm)' reaching site -- reaches_brain: true,
-// belt: 'callTool', bound_ms: 2000 (the Promise.race wrap in recommend()
-// below). D-01 (254-CONTEXT.md) ratified this as SHIPPED, released
-// behaviour, not a new decision. A new composed Brain call anywhere under
-// lib/mcp/ requires an entry there or the build fails
-// (tests/test-254-composition-census.cjs).
+// belt: 'callTool', bound_ms: BRAIN_ROUTE_TIMEOUT_MS (Quick 260911-ddd,
+// DDD-02; the Promise.race wrap in recommend() below, default 6000ms,
+// overridable via MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS). D-01 (254-CONTEXT.md)
+// ratified this as SHIPPED, released behaviour, not a new decision. A new
+// composed Brain call anywhere under lib/mcp/ requires an entry there or
+// the build fails (tests/test-254-composition-census.cjs).
 async function brainRoute(roomDir, stateContent, intent) {
   // Phase 339 Plan 05 (D-03b), 2026-09-03: reset at entry so a value read
   // by a caller can only ever reflect THIS invocation's own outcome.
@@ -349,10 +356,31 @@ async function brainRoute(roomDir, stateContent, intent) {
     ? (brainResult.directive.guided.framework || null)
     : null;
 
-  // Build the chain: anchor first (if present + not already in options), then options[].framework.
+  // Build the chain: anchor first (if present + not already in options), then
+  // options[].commands (Quick 260910-hni), then options[].framework.
+  //
+  // Quick 260910-hni: KNOWN_METHODOLOGIES holds BARE command slugs (e.g.
+  // `find-bottlenecks`), so a Theo framework name like "Design Thinking"
+  // normalizes to `designthinking` and matches nothing below, while a slug
+  // like `find-bottlenecks` matches itself exactly -- pushing the command
+  // slugs ahead of the framework name lets this chain route even when the
+  // framework name alone would not.
+  //
+  // The Phase 339 D-03b BRAIN_ROUTE_NOTE_NO_NEXT_GATE disclosure (:344-346)
+  // now stops firing on the Theo path because the composed envelope carries
+  // `next_gate` again (Task 1, quick/260910-hni): that is the INTENDED
+  // outcome of this quick task, not a regression. The disclosure stays in
+  // place for any origin that still returns no `next_gate`.
   const rawChain = [];
   if (anchorFramework && typeof anchorFramework === 'string') rawChain.push(anchorFramework);
   for (const opt of options) {
+    if (opt && Array.isArray(opt.commands)) {
+      for (const slug of opt.commands) {
+        if (typeof slug === 'string' && slug.length > 0 && !rawChain.includes(slug)) {
+          rawChain.push(slug);
+        }
+      }
+    }
     if (opt && typeof opt.framework === 'string' && opt.framework.length > 0) {
       if (!rawChain.includes(opt.framework)) rawChain.push(opt.framework);
     }
@@ -401,7 +429,8 @@ async function brainRoute(roomDir, stateContent, intent) {
 
 /**
  * Get a framework recommendation for a room.
- * 3-tier fallback: cache -> local heuristic -> Brain API (2s timeout).
+ * 3-tier fallback: cache -> local heuristic -> Brain API (bound:
+ * MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS, default 6000ms).
  *
  * @param {string} roomDir - Path to room directory
  * @param {{ intent?: string, mode?: string }} [options]
@@ -436,11 +465,15 @@ async function recommend(roomDir, options = {}) {
   // Tier 2: Local heuristic (always computed as fallback)
   const localRec = localRoute(roomDir, stateContent, intent);
 
-  // Tier 3: Brain API (2s timeout, non-blocking)
+  // Tier 3: Brain API (bound: MINDRIAN_BRAIN_ROUTE_TIMEOUT_MS, default
+  // 6000ms; non-blocking -- localRec above is already computed, so the
+  // Tier 2 answer is instant once this race loses). Quick 260911-ddd
+  // (DDD-02): evaluated at CALL TIME so an env override is honored per
+  // call and is testable, rather than a frozen 2000 literal.
   try {
     const brainRec = await Promise.race([
       brainRoute(roomDir, stateContent, intent),
-      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 2000))
+      new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), resolveBrainRouteTimeoutMs()))
     ]);
     if (brainRec) {
       setCache(cacheKey, brainRec);
@@ -527,4 +560,7 @@ function validateChain(roomDir, chain) {
   return { valid: true };
 }
 
-module.exports = { recommend, validateChain };
+// Quick 260911-ddd (DDD-02): re-exported so the Tier 3 bound pin is
+// readable from either side (this file and brain-composition-census.cjs
+// both read the same lib/mcp/brain-route-bound.cjs leaf).
+module.exports = { recommend, validateChain, BRAIN_ROUTE_TIMEOUT_MS, resolveBrainRouteTimeoutMs };

package/lib/mcp/tool-router.cjs

@@ -541,6 +541,8 @@ async function runResearchPipeline(roomDir, topic, opts) {
   const options = (opts && typeof opts === 'object') ? opts : {};
 
   try {
+    // Same research pipe contract as lib/core/intel-pipeline.cjs defaultResearchFn
+    // (the second caller of extractContext + runSourceLens); change together.
     const extracted = extractContext({ roomDir, topic, db });
     let driverResult;
     try {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@mindrian_os/cli",
-  "version": "2.0.0-beta.31",
+  "version": "2.0.0-beta.35",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@mindrian_os/cli",
-      "version": "2.0.0-beta.31",
+      "version": "2.0.0-beta.35",
       "license": "BSL-1.1",
       "dependencies": {
         "@ig3/markdown-it-wikilinks": "^1.0.2",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mindrian_os/cli",
-  "version": "2.0.0-beta.31",
+  "version": "2.0.0-beta.35",
   "description": "Install MindrianOS into Claude Code with one command -- `npx @mindrian_os/cli`. 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/room-hierarchy-schema.md

@@ -3,6 +3,12 @@
 Schema for Room/RoomGroup hierarchy in both KuzuDB (local) and Neo4j Brain (remote).
 Added in Phase 59.2. Additive-only -- filesystem + registry.json remain operational truth.
 
+> **RETIRED (2026-09-10, quick task 260910-h32):** the Neo4j/Brain half of this
+> schema is retired. `scripts/sync-rooms-brain` was deleted because it egressed
+> room names, venture names, stages, statuses and paths to the Brain, a Canon
+> Part 8 breach. The KuzuDB/local half remains live via `scripts/sync-rooms-graph`.
+> This document is kept as the record of what the Brain-side schema WAS.
+
 ## Node Types
 
 ### Room
@@ -76,7 +82,7 @@ Connects Room to Framework nodes based on methodology commands run in that room.
 |------|----|------------|-------|
 | Room | Framework | first_used (datetime), usage_count (int) | Created from room/.analytics.json |
 
-Source: `track-analytics` records command usage per room. `sync-rooms-brain` maps commands to Framework node names.
+Source: `track-analytics` records command usage per room. `sync-rooms-brain` maps commands to Framework node names. (RETIRED 2026-09-10 with the script; kept as history.)
 
 ### SHARES_THEME (Brain only)
 Cross-room content similarity detected from problem-definition keywords.
@@ -201,12 +207,12 @@ RETURN r.name, s.name AS stage,
 | Script | Target | Trigger | Frequency |
 |--------|--------|---------|-----------|
 | `scripts/sync-rooms-graph` | KuzuDB local | session-start, room-registry create/archive | Every session + on room changes |
-| `scripts/sync-rooms-brain` | Neo4j Brain | session-start (when Brain available) | Best-effort, per session |
+| `scripts/sync-rooms-brain` | Neo4j Brain (RETIRED 2026-09-10) | none -- script deleted, Canon Part 8 | never |
 
-Both scripts are idempotent and fire-and-forget. Failure degrades gracefully:
-- Brain unavailable -> KuzuDB only
+The one surviving script is idempotent and fire-and-forget. Failure degrades
+gracefully across the two remaining tiers:
 - KuzuDB unavailable -> filesystem only (Tier 0)
-- Both unavailable -> everything still works from registry.json
+- Everything still works from registry.json even if KuzuDB never runs
 
 ## Additive-Only Rule (D-15 through D-18)