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

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "mos",
   "description": "MindrianOS -- Your AI innovation co-founder. Larry thinks with you through PWS methodology, builds your Data Room as you explore, and chains frameworks intelligently. Install and go.",
-  "version": "2.0.0-beta.31",
+  "version": "2.0.0-beta.33",
   "author": {
     "name": "Jonathan Sagir",
     "url": "https://mindrian-os.com"

package/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [2.0.0-beta.33] - 2026-09-10
+
+### Fixed - Theo answers Larry end to end (quick task 260910-hni)
+
+- `brain_ask` through the plugin no longer returns an empty DirectiveEnvelope on every Theo answer.
+  `lib/core/brain-client.cjs` `ask()` now composes `directive.guided.framework`, `next_gate.options`
+  (ranked framework chain with the `/mos:` commands Theo links to each framework) and a new additive
+  `grounding` field (Theo's ranked book rows: chapterId, section, score, snippet) from Theo's
+  `structured_rows` + `recommend_chain`. The question's own words are never echoed back (Canon Part 8).
+  Incumbent-shaped responses pass through byte-unchanged. Live e2e through the MCP shim: framework
+  Design Thinking, 4 chain options, 8 grounding rows.
+- `askOp()` accepts Theo's op-mode shape (`rows` + `coverage`); it had been degrading every curated op to
+  zero rows because Theo never sends a `count` key.
+- `lib/mcp/brain-router.cjs` routes `/mos:act` chains from the commands Theo attaches to each framework,
+  so Tier 3 is graph-grounded again instead of silently falling to the local heuristic.
+- `lib/core/part8-egress-guard.cjs` recognizes the `recommend_chain` payload shape (rung enum +
+  step budget) as a known safe shape. `tests/run-all-339.sh` now counts a `.cjs` leg that prints SKIP
+  as skipped, not passed.
+- Larry's thin-grounding clause (`skills/larry-personality/SKILL.md`) keys on an empty `grounding.rows`
+  instead of the retired "empty signals set" wording.
+
+### Removed - Canon Part 8 (quick task 260910-h32)
+
+- `scripts/sync-rooms-brain` and its three detached spawns (`scripts/session-start`, twice in
+  `scripts/room-registry`). It string-interpolated every room's name, venture, stage, status and path
+  into `brain_write` Cypher and sent it to the Brain origin on every SessionStart (observed: 1,498
+  POSTs, 55 rooms, Authorization header on each). Room state already lives in local SQLite via
+  `sync-rooms-graph`. A default-deny census test (`tests/test-quick-260910-h32-no-brain-write-from-scripts.cjs`,
+  registered in `run-all-257.sh`) keeps it from coming back.
+
 ## [2.0.0-beta.31] - 2026-09-10
 
 ### Changed - install and update overhaul, Phase 341 waves 1-5 (SEED teardown 2026-09-09)

package/bin/mindrian-brain-mcp-client.cjs

@@ -163,7 +163,7 @@ const server = new McpServer({ name: 'mindrian-brain', version: version });
 server.registerTool(
   'brain_ask',
   {
-    description: 'Ask the remote teaching graph a natural-language methodology question. Routing happens server-side. Returns a DirectiveEnvelope carrying the directive content; the envelope degrades harmlessly to an empty signals set when the upstream response carries none. Reach for this first for an open methodology question; use brain_search when you already know the topic and want matching nodes directly.',
+    description: 'Ask the remote teaching graph a natural-language methodology question. Routing happens server-side. Returns a DirectiveEnvelope whose directive and next_gate are composed from the graph-grounded rows behind the answer plus a recommended framework chain; grounding.rows names the rows the answer stands on, and an empty grounding.rows means thin footing, not a clean answer. Reach for this first for an open methodology question; use brain_search when you already know the topic and want matching nodes directly.',
     inputSchema: z.strictObject({ question: z.string().describe('A methodology question (generic framework handles only -- never user artifacts or personal data per Canon Part 8).') }),
   },
   async ({ question }) => {

package/lib/core/brain-client.cjs

@@ -1110,6 +1110,200 @@ async function schema() {
   return result;
 }
 
+/**
+ * _inferRungFromQuestion(question) -> one of the four Theo rung ids.
+ *
+ * Theo's `classify_problem_type` tool takes NO parameters (the caller
+ * classifies), and there is no free-text rung classifier anywhere in this
+ * repo (`brain-derivation.cjs::classifyProblemType` scores MINTO triples,
+ * not text). This helper fills that local gap. It is PURE and LOCAL: it
+ * never sends the question anywhere, which is the whole reason it exists
+ * (Canon Part 8 -- the question is user data and stays local).
+ *
+ * Precedence is FIXED and load-bearing (do not reorder): Wicked is the
+ * orthogonal stakeholder-conflict axis and wins outright; UnDefined's
+ * markers are the least ambiguous of the remaining three; WellDefined's
+ * markers are next; IllDefined's markers are the broadest and are also the
+ * default, so they run last and cost nothing when they lose.
+ *
+ * Multi-word markers match as a substring; single-word markers match on a
+ * word boundary so `which` does not fire inside `whichever`. Non-string or
+ * empty input returns `'IllDefined'` and never throws.
+ *
+ * @param {*} question
+ * @returns {'Wicked'|'UnDefined'|'WellDefined'|'IllDefined'}
+ */
+const _RUNG_MARKERS = [
+  { rung: 'Wicked', markers: ['stakeholder', 'disagree', 'values', 'political'] },
+  { rung: 'UnDefined', markers: ['future of', 'no boundary', 'unbounded'] },
+  { rung: 'WellDefined', markers: ['measure', 'spec', 'test', 'kpi', 'how do we'] },
+  { rung: 'IllDefined', markers: ['next big thing', 'which', 'should we', 'opportunity'] },
+];
+
+function _matchesRungMarker(text, marker) {
+  if (marker.indexOf(' ') !== -1) return text.indexOf(marker) !== -1;
+  return new RegExp('\\b' + marker + '\\b').test(text);
+}
+
+function _inferRungFromQuestion(question) {
+  if (typeof question !== 'string' || !question.trim()) return 'IllDefined';
+  const lc = question.trim().toLowerCase();
+  for (let i = 0; i < _RUNG_MARKERS.length; i++) {
+    const entry = _RUNG_MARKERS[i];
+    for (let j = 0; j < entry.markers.length; j++) {
+      if (_matchesRungMarker(lc, entry.markers[j])) return entry.rung;
+    }
+  }
+  return 'IllDefined';
+}
+
+/**
+ * _composeTheoAsk(payload, question, deps) -> composed envelope payload.
+ *
+ * Composes `directive`, `next_gate` and `grounding` onto a Theo
+ * `answer_mode: 'structured_rows'` payload so downstream consumers
+ * (`wrapDirective`, `brainRoute`, `rs-chain-feeder.cjs`) get a real
+ * framework and chain instead of an empty scaffold. `deps` is the
+ * injectable wire seam (`{ recommendChain, query }`) the offline test suite
+ * drives; it defaults to this module's own wrappers so production behavior
+ * needs no injection.
+ *
+ * Runs entirely inside one outer try/catch and NEVER throws: on any failure
+ * it still returns the same object shape with `options: []` and
+ * `chain_status: 'unreachable'`, so a rows response with a failed chain
+ * still returns `grounding`.
+ *
+ * Canon Part 8: the only two extra wire calls this makes carry a closed
+ * rung enum (`recommendChain`) and framework names Theo itself just
+ * returned (`query`, label-anchored on `(f:Framework)`, never
+ * relationship-first -- Theo's read allow-list refuses
+ * `DirectedRelationshipTypeScan`). `query_terms` (the question's own words)
+ * is the ONLY key removed from the payload, because it is the question
+ * echoed back; the row projection is by the four NAMED keys
+ * (chapterId/section/score/snippet), never a blind row copy, for the same
+ * reason plus shape stability.
+ *
+ * @param {object} payload - the raw Theo structured_rows payload
+ * @param {string} question - the original question (local only, never sent)
+ * @param {{recommendChain?: Function, query?: Function}} [deps]
+ * @returns {Promise<object>}
+ */
+function _projectGroundingRows(rows) {
+  return Array.isArray(rows)
+    ? rows
+        .filter((r) => r && typeof r === 'object')
+        .map((r) => ({ chapterId: r.chapterId, section: r.section, score: r.score, snippet: r.snippet }))
+    : [];
+}
+
+async function _composeTheoAsk(payload, question, deps) {
+  deps = deps || {};
+  const recommend = deps.recommendChain || recommendChain;
+  const runQuery = deps.query || query;
+
+  try {
+    const rung = _inferRungFromQuestion(question);
+
+    let chainRes = null;
+    let chainStatus;
+    try {
+      chainRes = await recommend(rung, 4);
+      if (chainRes == null || chainRes.error || !Array.isArray(chainRes.chain)) {
+        chainStatus = 'unreachable';
+      } else if (chainRes.chain.length === 0) {
+        chainStatus = 'empty';
+      } else {
+        chainStatus = 'ok';
+      }
+    } catch (_e) {
+      chainStatus = 'unreachable';
+    }
+    const steps = chainStatus === 'ok' ? chainRes.chain : [];
+
+    // COMMANDS: exactly one runQuery call, only when there are steps, in its
+    // own try/catch (on any failure every option gets commands: []).
+    // Label-anchored and never relationship-first: Theo's read allow-list
+    // refuses a template that starts from [:USES_FRAMEWORK].
+    const commandsByFramework = new Map();
+    if (steps.length > 0) {
+      try {
+        const names = steps
+          .map((s) => s && s.framework)
+          .filter((n) => typeof n === 'string');
+        const result = await runQuery(
+          'MATCH (f:Framework) WHERE f.name IN $names OPTIONAL MATCH (c:MindrianCommand)-[:USES_FRAMEWORK]->(f) RETURN f.name AS framework, collect(DISTINCT c.name) AS commands',
+          { names: names }
+        );
+        const records = (result && Array.isArray(result.records)) ? result.records : [];
+        for (const rec of records) {
+          if (!rec || typeof rec.framework !== 'string') continue;
+          const slugs = Array.isArray(rec.commands)
+            ? rec.commands
+                .filter((c) => typeof c === 'string' && c.length > 0)
+                .map((c) => c.replace(/^\/mos:/, ''))
+            : [];
+          commandsByFramework.set(rec.framework, slugs);
+        }
+      } catch (_e) {
+        // any failure here -> every option gets commands: [] below (Map stays empty)
+      }
+    }
+
+    // CONFIDENCE: top step reads exactly 0.9; a missing/non-finite degree -> 0.5.
+    const top = steps.reduce((max, s) => {
+      const d = s && Number.isFinite(s.degree) ? s.degree : 0;
+      return d > max ? d : max;
+    }, 0);
+    const options = steps.map((s) => {
+      const degree = s && s.degree;
+      let confidence = 0.5;
+      if (top > 0 && Number.isFinite(degree)) {
+        confidence = Math.max(0.5, Math.min(0.9, Math.round((0.5 + 0.4 * (degree / top)) * 100) / 100));
+      }
+      return {
+        framework: s && s.framework,
+        confidence: confidence,
+        commands: commandsByFramework.get(s && s.framework) || [],
+      };
+    });
+
+    const out = Object.assign({}, payload);
+    delete out.query_terms;
+    out.directive = {
+      guided: { questions: [], framework: (steps[0] && steps[0].framework) || null, stage: rung },
+    };
+    out.next_gate = { sub_shape: 'F.1', options: options };
+    out.grounding = {
+      source: 'theo',
+      answer_mode: payload.answer_mode,
+      rows: _projectGroundingRows(payload.rows),
+      problem_type: rung,
+      problem_type_source: 'heuristic',
+      chain_coverage: (chainRes && chainRes.coverage && typeof chainRes.coverage === 'object') ? chainRes.coverage : null,
+      chain_status: chainStatus,
+      confidence_source: 'theo_degree_normalized',
+    };
+    return out;
+  } catch (_e) {
+    const rung = _inferRungFromQuestion(question);
+    const out = Object.assign({}, payload);
+    delete out.query_terms;
+    out.directive = { guided: { questions: [], framework: null, stage: rung } };
+    out.next_gate = { sub_shape: 'F.1', options: [] };
+    out.grounding = {
+      source: 'theo',
+      answer_mode: payload.answer_mode,
+      rows: _projectGroundingRows(payload.rows),
+      problem_type: rung,
+      problem_type_source: 'heuristic',
+      chain_coverage: null,
+      chain_status: 'unreachable',
+      confidence_source: 'theo_degree_normalized',
+    };
+    return out;
+  }
+}
+
 /**
  * Natural-language methodology question against the Brain (wraps brain_ask).
  *
@@ -1119,9 +1313,14 @@ async function schema() {
  * question. Canon Part 8: the question string carries only generic methodology
  * language -- never user artifacts, meeting text, or personal identifiers.
  *
- * Returns the parsed brain_ask payload ({ question, keyword, source, count,
- * results: [...] }) on success; a { text: 'Error: ...' } / { error: ... }
- * passthrough on a server-side error; null when the Brain is unreachable or no
+ * Two response shapes on success:
+ *   - INCUMBENT: carries `directive` already -- returned BYTE-UNCHANGED, the
+ *     same object reference, no copy.
+ *   - THEO structured_rows: `{ answer_mode: 'structured_rows', rows: [...] }`
+ *     with no `directive` -- composed through `_composeTheoAsk` into a full
+ *     envelope payload (`directive`, `next_gate`, `grounding` added).
+ * A `{ text: 'Error: ...' } / { error: ... }` sentinel passes through
+ * UNCHANGED on a server-side error; null when the Brain is unreachable or no
  * API key is configured (graceful degradation -- mirrors query()).
  *
  * @param {string} question
@@ -1129,7 +1328,15 @@ async function schema() {
  */
 async function ask(question) {
   if (typeof question !== 'string' || !question.trim()) return null;
-  return callTool('brain_ask', { question: question });
+  const raw = await callTool('brain_ask', { question: question });
+  if (raw == null) return raw; // transport-null contract, byte-locked
+  if (typeof raw !== 'object' || Array.isArray(raw)) return raw;
+  if (raw.error) return raw; // egress_blocked / tier_denied / rate_limited / invalid_key
+  if (raw.directive) return raw; // incumbent proof -- same object reference
+  if (raw.answer_mode === 'structured_rows' && Array.isArray(raw.rows)) {
+    return _composeTheoAsk(raw, question);
+  }
+  return raw;
 }
 
 /**
@@ -1162,24 +1369,64 @@ async function ask(question) {
  * @param {object} [params]  - generic-handles-only params object
  * @returns {Promise<{op: string, source?: string, count: number, rows: Array, degraded?: boolean}>}
  */
+/**
+ * _normalizeAskOpResult(result, operation) -- the askOp() shape recognizer,
+ * extracted so tests can drive it directly with zero network. Copies the
+ * dual-shape recognizer STRUCTURE from
+ * lib/core/enrichment-queue.cjs::captureReadinessMiss: one entry point, arms
+ * keyed on payload SHAPE never on key presence alone.
+ *
+ * Theo op answers carry `coverage`, never `count`, so a `count`-keyed
+ * recognizer alone reads a live three-row answer as a degraded zero. Arms,
+ * in order:
+ *   1. INCUMBENT: `count` is a number and `rows` is an array -- the exact
+ *      object askOp built before this task. MUST run first so an incumbent
+ *      payload can never take arm 2.
+ *   2. THEO: `rows` is an array (no numeric `count` required) -- reports
+ *      `coverage.matched` as `count` when it is a finite number, else
+ *      `rows.length`.
+ *   3. Everything else (null, an `{error:...}` sentinel, a `{text:...}`
+ *      passthrough, a non-array `rows`) -- the existing degraded sentinel.
+ * Degrade ONLY when `rows` is not an array.
+ *
+ * @param {*} result
+ * @param {string} operation
+ * @returns {{op: string, source?: string, count: number, rows: Array, coverage?: object, degraded?: boolean}}
+ */
+function _normalizeAskOpResult(result, operation) {
+  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 } : {}),
+    };
+  }
+  if (result && typeof result === 'object' && Array.isArray(result.rows)) {
+    const coverage = result.coverage;
+    const matched = (coverage && typeof coverage === 'object' && Number.isFinite(coverage.matched))
+      ? coverage.matched
+      : result.rows.length;
+    const out = {
+      op: result.op || operation,
+      source: 'theo',
+      count: matched,
+      rows: result.rows,
+    };
+    if (coverage && typeof coverage === 'object') out.coverage = coverage;
+    return out;
+  }
+  return { op: operation, count: 0, rows: [], degraded: true };
+}
+
 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 };
+    return _normalizeAskOpResult(
+      await callTool('brain_ask', { op: operation, params: params || {} }),
+      operation
+    );
   } catch (_err) {
     return { op: operation, count: 0, rows: [], degraded: true };
   }
@@ -2300,6 +2547,10 @@ module.exports = {
   smartSearch,
   ask,
   askOp,
+  // Quick 260910-hni: the pure local rung heuristic ask()/_composeTheoAsk
+  // uses to classify a question before the one recommend_chain wire call.
+  // A NAMED export per the locked design, not a _test-only member.
+  _inferRungFromQuestion,
   schema,
   stats,
   getBrainUrl,
@@ -2361,5 +2612,10 @@ module.exports = {
     // so the exact D-01/D-02 schedule is unit-tested with zero sleeps.
     _parseRetryAfterMs,
     _rateLimitWaitMs,
+    // Quick 260910-hni test surface: the composer's injectable deps seam
+    // and the widened askOp recognizer, both offline-drivable with zero
+    // network (see tests/test-339-theo-ask-compose.cjs).
+    _composeTheoAsk,
+    _normalizeAskOpResult,
   },
 };

package/lib/core/directive-envelope.cjs

@@ -159,6 +159,15 @@ function _copyIfPlainObject(value) {
  * `lib/mcp/no-instructions.test.cjs` exists to prevent). When neither field
  * is present, the returned object keeps the exact same seven keys in the
  * exact same insertion order it had before this change.
+ *
+ * Quick 260910-hni adds `grounding` as a THIRD named additive field, same
+ * shape guard and same reason: an untyped top-level copy would let
+ * arbitrary Brain-returned keys reach the model, exactly the leakage class
+ * `lib/mcp/no-instructions.test.cjs` exists to prevent. `_copyIfPlainObject`
+ * is a SHALLOW copy, so `grounding.rows` stays the same array reference,
+ * exactly as `refusal.next_moves` already behaves. Absence of `grounding`
+ * leaves the seven keys and their insertion order untouched
+ * (`tests/test-257-envelope-passthrough.cjs` Arm 3 pins this).
  * @param {object|null} brainResponse
  * @param {object} signals
  * @returns {object} DirectiveEnvelope per CAPABILITY-MAP spec.
@@ -206,6 +215,10 @@ function wrapDirective(brainResponse, signals) {
   if (refusal !== null) {
     envelope.refusal = refusal;
   }
+  const grounding = _copyIfPlainObject(brainResponse.grounding);
+  if (grounding !== null) {
+    envelope.grounding = grounding;
+  }
 
   return envelope;
 }

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-router.cjs

@@ -349,10 +349,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);
     }

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.33",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@mindrian_os/cli",
-      "version": "2.0.0-beta.31",
+      "version": "2.0.0-beta.33",
       "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.33",
   "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)