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

package/lib/core/brain-client.cjs

@@ -1250,29 +1250,68 @@ async function _composeTheoAsk(payload, question, deps) {
     }
 
     // CONFIDENCE: top step reads exactly 0.9; a missing/non-finite degree -> 0.5.
+    // theo_rank and the command-bearing-first sort below never touch this
+    // computation -- the sort reorders `options`, it never recomputes a
+    // confidence value (Quick 260911-ddd, DDD-01).
     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 options = steps.map((s, idx) => {
       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));
       }
+      // Quick 260911-ddd (DDD-01): theo_rank carries Theo's own rank so it
+      // is never lost by the reorder below. Theo's `step` field when it is
+      // a finite number, else the 1-based index of this step WITHIN Theo's
+      // own chain array, computed here before any sort so a later reorder
+      // can never leak into this number.
+      const theoRank = (s && Number.isFinite(s.step)) ? s.step : idx + 1;
       return {
         framework: s && s.framework,
         confidence: confidence,
         commands: commandsByFramework.get(s && s.framework) || [],
+        theo_rank: theoRank,
       };
     });
 
+    // Quick 260911-ddd (DDD-01): stable partition, command-bearing options
+    // first, Theo's relative order preserved inside each group. Theo's
+    // ranking is NEVER altered at the source -- this reorders the plugin's
+    // OWN options array only. A single forward pass into two queues, then
+    // concatenated, is stable BY CONSTRUCTION; it does not rest on
+    // Array.prototype.sort's engine-stability semantics. When every option
+    // or no option carries a command, one queue is empty and the
+    // concatenation is the identity, so Theo's order survives unchanged
+    // for free.
+    //
+    // DOWNSTREAM CONSEQUENCE, stated here so it is not mistaken for a
+    // regression later: lib/mcp/brain-router.cjs:398 derives topConf from
+    // options[0].confidence. On a chain whose top-ranked framework has no
+    // command, the routed confidence now reads the first command-bearing
+    // option's confidence (0.83 on the live IllDefined shape, previously
+    // 0.9) -- that is the intended meaning of the change (confidence
+    // describes the option actually surfaced to the user), not a bug.
+    // brain-router.cjs is deliberately NOT touched to compensate for this.
+    const commandBearing = [];
+    const commandLess = [];
+    for (const opt of options) {
+      if (Array.isArray(opt.commands) && opt.commands.length > 0) {
+        commandBearing.push(opt);
+      } else {
+        commandLess.push(opt);
+      }
+    }
+    const sortedOptions = commandBearing.concat(commandLess);
+
     const out = Object.assign({}, payload);
     delete out.query_terms;
     out.directive = {
-      guided: { questions: [], framework: (steps[0] && steps[0].framework) || null, stage: rung },
+      guided: { questions: [], framework: (sortedOptions[0] && sortedOptions[0].framework) || null, stage: rung },
     };
-    out.next_gate = { sub_shape: 'F.1', options: options };
+    out.next_gate = { sub_shape: 'F.1', options: sortedOptions };
     out.grounding = {
       source: 'theo',
       answer_mode: payload.answer_mode,
@@ -1282,6 +1321,10 @@ async function _composeTheoAsk(payload, question, deps) {
       chain_coverage: (chainRes && chainRes.coverage && typeof chainRes.coverage === 'object') ? chainRes.coverage : null,
       chain_status: chainStatus,
       confidence_source: 'theo_degree_normalized',
+      // Quick 260911-ddd (DDD-01): names the applied ordering so a
+      // consumer never has to branch on the key's presence -- present here
+      // AND on the trailing catch path below.
+      option_order: 'command_bearing_first',
     };
     return out;
   } catch (_e) {
@@ -1299,6 +1342,7 @@ async function _composeTheoAsk(payload, question, deps) {
       chain_coverage: null,
       chain_status: 'unreachable',
       confidence_source: 'theo_degree_normalized',
+      option_order: 'command_bearing_first',
     };
     return out;
   }

package/lib/core/brain-prewarm.cjs

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * Copyright (c) 2026 Mindrian. BSL 1.1.
+ *
+ * Quick 260911-ddd (DDD-02) -- a content-free Brain pre-warm fired at MCP
+ * shim startup so the Brain is already warm by the time the first question
+ * arrives, instead of leaving every cold Render wake to silently degrade
+ * /mos:act's Tier 3 race to the local heuristic (see
+ * lib/mcp/brain-route-bound.cjs for the measured cold-wake numbers this
+ * exists to cover).
+ *
+ * WHY THE TIMEOUT DOES NOT BOUND THE WAKE ITSELF: the request reaching
+ * Render is what wakes the instance; aborting our own wait does not cancel
+ * that in-flight wake on Render's side. The timeout here only bounds how
+ * long THIS PROCESS holds the marker write open waiting for a verdict --
+ * which is why 15000 ms is generous without costing anyone anything: even
+ * if we give up waiting, the wake we triggered keeps running on Render and
+ * the NEXT real call benefits from it.
+ *
+ * CANON PART 8 (D-02): the probe sends theo_health with NO ARGUMENTS
+ * (`callTool('theo_health', {})`, the exact shape class-m-brain-smoke.cjs:225
+ * already ships) and the marker persists ONLY {at, ok, origin_host} --
+ * never a response body, never a header value, never a question. Every fs
+ * and network failure is swallowed; this function NEVER throws and NEVER
+ * rejects.
+ *
+ * MCP STDIO SAFETY: this file writes NOTHING to stdout, ever, because it
+ * can run inside an MCP stdio process where a stray stdout byte corrupts
+ * the JSON-RPC transport. A single stderr line only when MINDRIAN_DEBUG is
+ * set.
+ *
+ * The deps seam ({ probe, originHost, now, homeDir, timeoutMs }, all
+ * optional) mirrors the same injectable-probe discipline
+ * lib/core/doctor/class-m-brain-smoke.cjs already uses for its own
+ * theoHealthFn seam, so a test drives every arm through deps and never
+ * touches a real Brain.
+ *
+ * No em-dashes. CJS only.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const DEFAULT_PREWARM_TIMEOUT_MS = 15000;
+
+const debugLog = (msg) => {
+  if (!process.env.MINDRIAN_DEBUG) return;
+  try {
+    process.stderr.write('[brain-prewarm] ' + msg + '\n');
+  } catch (_e) {
+    // swallow -- this function must never throw
+  }
+};
+
+/**
+ * Derive the timeout (ms) for the probe race. Reads
+ * MINDRIAN_BRAIN_PREWARM_TIMEOUT_MS when it parses to a finite positive
+ * integer; otherwise DEFAULT_PREWARM_TIMEOUT_MS.
+ * @returns {number}
+ */
+function _resolveTimeoutMs() {
+  const raw = process.env.MINDRIAN_BRAIN_PREWARM_TIMEOUT_MS;
+  if (typeof raw !== 'string' || raw.trim().length === 0) return DEFAULT_PREWARM_TIMEOUT_MS;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) return DEFAULT_PREWARM_TIMEOUT_MS;
+  return parsed;
+}
+
+/**
+ * Reduce a Brain origin URL to its host only (never the full URL, never a
+ * path, never a query string -- the marker holds origin_host, not the URL).
+ * @param {string} url
+ * @returns {string|null}
+ */
+function _hostOnly(url) {
+  if (typeof url !== 'string' || url.length === 0) return null;
+  try {
+    return new URL(url).host || null;
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * markerPath(homeDir) -- the on-disk location of the pre-warm marker.
+ * @param {string} [homeDir] defaults to MINDRIAN_HOME or ~/.mindrian
+ * @returns {string}
+ */
+function markerPath(homeDir) {
+  const home = homeDir || process.env.MINDRIAN_HOME || path.join(os.homedir(), '.mindrian');
+  return path.join(home, 'brain-prewarm.json');
+}
+
+/**
+ * prewarm(deps) -- fires one content-free theo_health probe and persists a
+ * minimal marker. NEVER throws, NEVER rejects, NEVER writes to stdout.
+ *
+ * @param {object} [deps]
+ * @param {() => Promise<any>} [deps.probe] defaults to
+ *   `() => require('./brain-client.cjs').callTool('theo_health', {})`,
+ *   required LAZILY so importing this module costs nothing.
+ * @param {string} [deps.originHost] defaults to the host of
+ *   `require('./brain-client.cjs').getBrainUrl()`.
+ * @param {() => Date} [deps.now] defaults to `() => new Date()`.
+ * @param {string} [deps.homeDir] defaults to MINDRIAN_HOME or ~/.mindrian.
+ * @param {number} [deps.timeoutMs] defaults to
+ *   MINDRIAN_BRAIN_PREWARM_TIMEOUT_MS or 15000.
+ * @returns {Promise<{ at: string, ok: boolean, origin_host: string|null }>}
+ */
+async function prewarm(deps) {
+  deps = deps || {};
+  const probe = deps.probe || (() => require('./brain-client.cjs').callTool('theo_health', {}));
+  const originHost = (typeof deps.originHost === 'string')
+    ? deps.originHost
+    : _hostOnly((() => {
+        try {
+          return require('./brain-client.cjs').getBrainUrl();
+        } catch (_e) {
+          return null;
+        }
+      })());
+  const now = deps.now || (() => new Date());
+  const homeDir = deps.homeDir;
+  const timeoutMs = Number.isFinite(deps.timeoutMs) && deps.timeoutMs > 0 ? deps.timeoutMs : _resolveTimeoutMs();
+
+  let ok = false;
+  try {
+    const TIMEOUT_SENTINEL = Symbol('brain-prewarm-timeout');
+    const result = await Promise.race([
+      Promise.resolve()
+        .then(() => probe())
+        .catch(() => null),
+      new Promise((resolve) => setTimeout(() => resolve(TIMEOUT_SENTINEL), timeoutMs)),
+    ]);
+    ok = !!(result && result !== TIMEOUT_SENTINEL && typeof result === 'object');
+  } catch (_e) {
+    ok = false;
+  }
+
+  // Canon Part 8 (D-02): EXACTLY three keys, nothing else. Never any part
+  // of the probe response body, never a key, never a question.
+  const marker = { at: now().toISOString(), ok: ok, origin_host: originHost || null };
+
+  try {
+    const filePath = markerPath(homeDir);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(marker), 'utf8');
+    debugLog('marker written: ' + JSON.stringify(marker));
+  } catch (e) {
+    debugLog('marker write failed: ' + (e && e.message ? e.message : String(e)));
+  }
+
+  return marker;
+}
+
+// Directly spawnable: `node lib/core/brain-prewarm.cjs`.
+if (require.main === module) {
+  prewarm().catch(() => {});
+}
+
+module.exports = { prewarm, markerPath };

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,
+};