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

package/lib/core/doctor/class-m-brain-smoke.cjs

@@ -2,14 +2,27 @@
 
 /**
  * Phase 127-02 BRAIN-MCP-127-08 (CONTEXT D4) -- Class M Brain smoke.
- * 6-layer composable probe replacing ~60% of doctor Brain-adjacent checks.
+ * 7-layer composable probe replacing ~60% of doctor Brain-adjacent checks.
+ * Grew from 6 to 7 layers in quick task 260911-axz (AXZ-01): L0 prepended.
  *
  * "Class M" rationale: CONTEXT D4 text reads "K" but letter K is already
  * taken in scripts/doctor.cjs by --stale-first-touch (SEED-007). A-L are
  * assigned. M is the next free letter. The CAPABILITY-MAP.md doc patch
  * lands in plan 127-03.
  *
- * Detects 12 Phase 126 taxonomy rows plus the store-identity sense:
+ * Detects 12 Phase 126 taxonomy rows plus the store-identity and
+ * origin-and-shadow senses:
+ *   L0 origin_shadow    quick task 260911-axz (AXZ-01): answers "which
+ *                       origin am I on, is it alive, and is anything
+ *                       shadowing my shim" in one row. Closes the exact
+ *                       blind spot that let a beta.33 install run Larry at
+ *                       Tier 0 for a whole session: a user-scope or
+ *                       local-scope `mindrian-brain` entry in
+ *                       ~/.claude.json can shadow the plugin's own
+ *                       `.mcp.json` stdio shim of the same name, and L1-L6
+ *                       below probe IN PROCESS through brain-client.cjs, so
+ *                       they cannot see it -- the probe was never wrong,
+ *                       it was blind to the one thing that mattered.
  *   L1 plugin_root      #5 install-cache stale, #9 install-state drift
  *   L2 key_resolver     #1 missing key, #2 perms-too-open, #8 env unreadable,
  *                       #13 Bearer format mismatch
@@ -28,16 +41,26 @@
  *   (active-plugin-root, resolve-brain-key, brain-client.schema). L4/L5
  *   stdio orchestration and L6 both reuse the brain-client stats and query
  *   chokepoints; L6 mints no new server-side tool for the GraphRagMeta
- *   stamp, it reads that through the existing bounded brain_query path.
+ *   stamp, it reads that through the existing bounded brain_query path. L0
+ *   reuses lib/core/integration-registry.cjs's readScopedMcpServers (the
+ *   ONE ~/.claude.json scoped mcpServers reader) rather than minting a
+ *   third config reader.
  * Canon Part 8 (graph boundary): probe queries the methodology schema
  *   handle only; zero user-content egress; every Brain payload routes
  *   through brain-client.cjs (the delegation chokepoint). L6 reads store
  *   metadata only (endpoint, node count, GraphRagMeta stamp fields) -- zero
- *   user content.
+ *   user content. L0's shadow scan is a STRUCTURAL secret-leak guard: the
+ *   integration-registry.cjs projection it consumes never carries headers,
+ *   the full url, or env, so no Authorization value or other header value
+ *   can reach this layer's output even by accident.
  *
- * fail-fast cascade: if layer N fails, layers N+1..6 are SKIPPED with
- *   reason="skipped-prior-layer-failed" so the report points at the FIRST
- *   failure, not the cascade noise.
+ * fail-fast cascade: if layer N fails (N >= 1), layers N+1..6 are SKIPPED
+ *   with reason="skipped-prior-layer-failed" so the report points at the
+ *   FIRST failure, not the cascade noise. L0 (index 0) is the one
+ *   exception: its own ok=false never triggers this skip (see the `i > 0`
+ *   gate in checkBrainSmoke below) -- a shadow finding is information
+ *   layered ON TOP of the in-process probe below it, never a substitute for
+ *   running that probe.
  *
  * HARD RULE: no em-dashes anywhere in this file.
  */
@@ -48,6 +71,7 @@ const { spawn } = require('node:child_process');
 
 // Layer registry. Wire-locked: the shell harness asserts id strings + order.
 const LAYERS = Object.freeze([
+  Object.freeze({ id: 'origin_shadow',    name: 'L0 origin and shadow connector' }),
   Object.freeze({ id: 'plugin_root',      name: 'L1 plugin-root-resolver' }),
   Object.freeze({ id: 'key_resolver',     name: 'L2 brain-key-resolver' }),
   Object.freeze({ id: 'https_schema',     name: 'L3 HTTPS schema probe' }),
@@ -79,9 +103,14 @@ const OVERALL_BUDGET_MS = 30000;
 //   client.cjs, never re-declared here) so a MINDRIAN_BRAIN_URL rollback to
 //   the incumbent restores the incumbent's 29000 floor in the same motion
 //   that moves the URL and the alias vocabulary back -- one lever, not two.
-//   THEO_NODE_FLOOR = 1000 is a FLOOR, not a target: Theo's canon is
-//   actively growing (1,253 nodes observed 2026-09-03, up from 712 the
-//   previous day), so a tight number would be stale within days.
+//   THEO_NODE_FLOOR moved from 1000 to 27000 in quick task 260911-axz
+//   (AXZ-01). The old prose argued a tight number would be stale within
+//   days because Theo's canon was growing from 712 to 1,253 nodes; that
+//   argument expired. Measured live on 2026-09-11, Theo holds 27,951 nodes,
+//   so 27,000 is a 3.4 percent margin below the measured floor -- close to
+//   the incumbent's own posture (29,000 against roughly 29,200, about 1
+//   percent). A floor of 1000 against a 27,951-node live store would pass a
+//   96 percent content loss; that is not a floor, it is a rubber stamp.
 // STALE_REPLICA_NODE_COUNT: the frozen, roughly-July signature of the
 //   retired replica store (the pre-migration onrender host, now decommissioned).
 //   Seeing exactly this count means the wire is pointed at a copy, not
@@ -95,7 +124,7 @@ const OVERALL_BUDGET_MS = 30000;
 const { THEO_ORIGINS } = require('../brain-client.cjs');
 const CANON_BRAIN_URL = 'https://theo-mcp.onrender.com';
 const CANON_NODE_FLOOR = 29000;
-const THEO_NODE_FLOOR = 1000;
+const THEO_NODE_FLOOR = 27000;
 const STALE_REPLICA_NODE_COUNT = 28325;
 
 // GraphRagMeta stamp read: one bounded LIMIT 1 read projecting only the
@@ -147,6 +176,84 @@ async function _runLayer(_name, fn) {
   }
 }
 
+// L0 -- origin and shadow connector (quick task 260911-axz, AXZ-01).
+//
+// Three things in one row, always attempted, never throwing to the caller:
+//
+// (a) Shadow scan. Reads Claude Code's OWN config (~/.claude.json by
+//     default) through the ONE scoped reader lib/core/integration-
+//     registry.cjs exports (readScopedMcpServers), never a second reader.
+//     Filters for name === 'mindrian-brain' at either scope Claude Code
+//     recognizes for this file (user = top-level mcpServers, local =
+//     projects[dir].mcpServers). A repo's own .mcp.json ("project" scope in
+//     Claude Code's vocabulary, where the plugin ships its stdio shim) is
+//     structurally never read by this reader, so it is never flagged.
+//
+// (b) Resolved-origin row, reported whether or not a shadow was found: the
+//     endpoint getBrainUrl() resolves to, whether it is a Theo origin, and
+//     whether MINDRIAN_BRAIN_URL overrode it. This is information, not a
+//     verdict; a non-Theo origin under an explicit override is not itself
+//     a failure (mirrors L6's own canon/override distinction).
+//
+// (c) theo_health, best effort, mirroring L6's GraphRagMeta stamp
+//     discipline: wrapped in try/catch, degrading silently to no health
+//     data on any rejection. It NEVER changes the verdict below. Only
+//     { mode, build_sha } are ever projected onto the payload --
+//     `instanceUri`, `quarantineCode`, and `serverAgent` are never copied
+//     (T-axz-02).
+//
+// Verdict: ok is false if and only if at least one mindrian-brain shadow
+// entry was found. The origin and health halves are information, never the
+// verdict, exactly as L6 treats canon/override as information separate from
+// its own count-floor verdict.
+async function _layer0(opts) {
+  const scopedServersFn = opts.mockScopedServers
+    || require('../integration-registry.cjs').readScopedMcpServers;
+  const scoped = scopedServersFn({ configPath: opts.claudeConfigPath, projectDir: opts.projectDir }) || [];
+  const shadows = scoped
+    .filter(function (e) { return e && e.name === 'mindrian-brain'; })
+    .map(function (e) { return { name: e.name, scope: e.scope, url_host: e.url_host }; });
+
+  const brainUrlFn = opts.mockBrainUrl || (() => require('../brain-client.cjs').getBrainUrl());
+  const resolved_origin = brainUrlFn();
+  const is_theo = THEO_ORIGINS.indexOf(resolved_origin) !== -1;
+  const override = !!(process.env.MINDRIAN_BRAIN_URL && process.env.MINDRIAN_BRAIN_URL.length > 0);
+
+  const payload = { resolved_origin: resolved_origin, is_theo: is_theo, override: override, shadows: shadows };
+
+  const theoHealthFn = opts.mockTheoHealth
+    || (async () => require('../brain-client.cjs').callTool('theo_health', {}));
+  try {
+    const health = await theoHealthFn();
+    if (health && typeof health === 'object') {
+      const theo_health = { mode: health.mode };
+      if (health.build_stamp && health.build_stamp.sha) theo_health.build_sha = health.build_stamp.sha;
+      payload.theo_health = theo_health;
+    }
+  } catch (_e) {
+    // Degrade to no theo_health silently -- never changes the verdict.
+  }
+
+  const scopeNote = 'this check reads Claude Code\'s ~/.claude.json only; Claude Desktop and Cowork '
+    + 'keep the mindrian-brain connector by design (docs/339-NOTE-theo-desktop-connector-key.md), '
+    + 'so a Desktop config is never read and never flagged';
+
+  if (shadows.length === 0) {
+    let reason = 'no shadowing mindrian-brain entry found; resolved origin=' + resolved_origin
+      + ' is_theo=' + is_theo + (override ? ' (MINDRIAN_BRAIN_URL override active)' : '') + '. ' + scopeNote + '.';
+    return { ok: true, reason: reason, payload: payload };
+  }
+
+  const shadowLines = shadows.map(function (s) {
+    return 'shadowing Claude Code MCP entry `mindrian-brain` at ' + s.scope + ' scope (host=' + s.url_host
+      + ') shadows the plugin\'s own stdio shim; the plugin provides this server, so remove the duplicate: '
+      + '`claude mcp remove mindrian-brain -s ' + s.scope + '`';
+  });
+  const reason = shadowLines.join(' | ') + '. resolved origin=' + resolved_origin + ' is_theo=' + is_theo
+    + '. ' + scopeNote + '.';
+  return { ok: false, reason: reason, payload: payload };
+}
+
 // L1 -- plugin-root-resolver. Reuses lib/core/active-plugin-root.cjs.
 async function _layer1(opts) {
   const fn = opts.mockResolveRoot
@@ -413,17 +520,21 @@ async function _layer6(opts) {
 }
 
 /**
- * Run the 6-layer Brain smoke probe with fail-fast cascade.
+ * Run the 7-layer Brain smoke probe with fail-fast cascade.
  *
  * @param {{
- *   mockResolveRoot?: function,
- *   mockResolveKey?:  function,
- *   mockSchema?:      function,
- *   mockSpawn?:       function,
- *   shimPath?:        string,
- *   mockBrainUrl?:    function,
- *   mockStats?:       function,
- *   mockQuery?:       function,
+ *   mockResolveRoot?:     function,
+ *   mockResolveKey?:      function,
+ *   mockSchema?:          function,
+ *   mockSpawn?:           function,
+ *   shimPath?:            string,
+ *   mockBrainUrl?:        function,
+ *   mockStats?:           function,
+ *   mockQuery?:           function,
+ *   mockScopedServers?:   function,
+ *   mockTheoHealth?:      function,
+ *   claudeConfigPath?:    string,
+ *   projectDir?:          string,
  * }} [opts]
  * @returns {Promise<{ok:boolean, layers:Array<{id,name,ok,reason,ms,payload?}>, overall_ms:number}>}
  */
@@ -432,7 +543,7 @@ async function checkBrainSmoke(opts) {
   const t0 = _now();
   const out = { ok: true, layers: [], overall_ms: 0 };
   let prevOk = true;
-  const layerFns = [_layer1, _layer2, _layer3, _layer4, _layer5, _layer6];
+  const layerFns = [_layer0, _layer1, _layer2, _layer3, _layer4, _layer5, _layer6];
   for (let i = 0; i < LAYERS.length; i++) {
     const meta = LAYERS[i];
     if (!prevOk) {
@@ -444,7 +555,18 @@ async function checkBrainSmoke(opts) {
     const row = { id: meta.id, name: meta.name, ok: r.ok, reason: r.reason, ms: r.ms };
     if (r.payload !== undefined) row.payload = r.payload;
     out.layers.push(row);
-    if (!r.ok) { prevOk = false; out.ok = false; }
+    if (!r.ok) {
+      out.ok = false;
+      // L0 (i === 0) is the one layer whose failure never blinds the
+      // cascade: the in-process probe through brain-client.cjs (L1-L6) is
+      // still valid and still worth running even when a shadow entry is
+      // present, so the report must carry BOTH the shadow finding and the
+      // six layers' own verdicts. A short circuit here would trade one
+      // blind spot (L1-L6 cannot see a Claude Code config shadow) for
+      // another (a shadow finding would hide whether the in-process probe
+      // itself is healthy).
+      if (i > 0) prevOk = false;
+    }
   }
   out.overall_ms = _now() - t0;
   if (out.overall_ms > OVERALL_BUDGET_MS) {
@@ -458,10 +580,10 @@ async function checkBrainSmoke(opts) {
 }
 
 /**
- * Class M is diagnostic-only. There is no auto-remediation path: the 6
+ * Class M is diagnostic-only. There is no auto-remediation path: the 7
  * failure surfaces require user action (install / set key / restart /
- * repoint the endpoint at canon). This function exists for symmetry with
- * classes that DO support --fix.
+ * repoint the endpoint at canon / remove a shadowing connector). This
+ * function exists for symmetry with classes that DO support --fix.
  *
  * @param {object} _result  the checkBrainSmoke result (unused; signature parity)
  * @returns {{fixed: false, reason: string}}
@@ -476,4 +598,16 @@ function fixBrainSmoke(_result) {
 // Phase 257 (LOCUS-01, D-03), Task 2 Arm 5: exported so
 // tests/test-257-refusal-egress-kind.cjs can assert the refusal-vocabulary /
 // doctor-recognizer coupling structurally, without re-declaring this list.
-module.exports = { checkBrainSmoke, LAYERS, fixBrainSmoke, STDIO_TIMEOUT_MS, STRUCTURED_REFUSAL_STATUSES, CANON_BRAIN_URL };
+// THEO_NODE_FLOOR / CANON_NODE_FLOOR additively exported (quick task
+// 260911-axz) so the floor is assertable without re-typing the number in a
+// test.
+module.exports = {
+  checkBrainSmoke,
+  LAYERS,
+  fixBrainSmoke,
+  STDIO_TIMEOUT_MS,
+  STRUCTURED_REFUSAL_STATUSES,
+  CANON_BRAIN_URL,
+  THEO_NODE_FLOOR,
+  CANON_NODE_FLOOR,
+};