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

package/scripts/collect-cold-install-evidence.cjs

@@ -0,0 +1,411 @@
+#!/usr/bin/env node
+'use strict';
+
+/*
+ * scripts/collect-cold-install-evidence.cjs -- Phase 341 Plan 06 (D-13 step 2).
+ *
+ * WHAT: emits one JSON envelope proving a cold install of the npm-source
+ * plugin artifact landed on this machine and that both bundled MCP servers
+ * (mindrian-os, mindrian-brain) load. One command, run identically on
+ * Windows, macOS and Linux, so a human operator on a machine this repo
+ * cannot reach can paste the result back into a tracked proof document.
+ *
+ * WHY: there is no Windows box and no macOS box in this dev environment.
+ * 341-RESEARCH names that as the phase's one hard external dependency with
+ * no fallback (see 341-RESEARCH.md "Loader Ground Truth" F-2/F-3 and
+ * assumption A1). The proof this collector produces is evidence, not a
+ * claim: the fields below are what the D-13 gate actually reads.
+ *
+ * Canon Part 8 (Graph Boundary): local filesystem reads plus local spawns of
+ * this repo's own scripts (node scripts/doctor.cjs). The ONE network touch
+ * in the whole envelope is inherited from `doctor --acceptance`'s full-tier
+ * points (the live `npm view` version-of-record check and the brain-smoke
+ * wire probe) and from `doctor --eureka-smoke`'s optional model-cache read;
+ * this is stated here, not hidden. Nothing in this file opens a socket
+ * itself.
+ *
+ * MCP-server probe note (measured on this Linux dev box, both files read
+ * before writing this probe per the plan's own instruction): neither
+ * bin/mindrian-mcp-server.cjs nor bin/mindrian-brain-mcp-client.cjs exposes
+ * a --version flag or any other CLI probe flag -- both call an unconditional
+ * top-level main() that connects a StdioServerTransport. Measured behavior
+ * differs from the plan's literal "require() + treat a clean exit as
+ * loads:true" fallback: mindrian-brain-mcp-client.cjs happens to exit 0 on
+ * stdin EOF, but mindrian-mcp-server.cjs does NOT -- it stays connected to
+ * stdio by design (a healthy MCP stdio server never exits on its own) and
+ * only stops when killed. A literal "clean exit only" probe would therefore
+ * mis-report a HEALTHY mindrian-os server as not-loading. The narrowest
+ * non-destructive probe each file actually supports is its own startup log
+ * line to stderr (`... MCP server v<version> started ...`), written at the
+ * point server.connect() succeeds. This collector spawns the real entry
+ * file (not require(), since require() previously start it in-process too),
+ * feeds it a closed stdin (input:''), captures stderr up to 2000 characters
+ * bounded by an explicit timeout, and treats either a clean exit(0) OR the
+ * presence of the entry's own "started" marker in stderr as loads:true. A
+ * timeout-kill after a confirmed "started" marker is expected lifecycle for
+ * a server that intentionally never exits on inspection, not a failure --
+ * documented as a note either way for transparency.
+ *
+ * Version note: plugin_version is read via lib/core/repo-version.cjs (the
+ * ONE sanctioned way to read this repo's own version, never a tree search --
+ * see that module's header) when CLAUDE_PLUGIN_ROOT is unset (a dev
+ * checkout), and directly from <CLAUDE_PLUGIN_ROOT>/package.json when it is
+ * set (an installed copy), per the plan's own instruction.
+ *
+ * Every probe below is wrapped so a failure produces a recorded `null` (or
+ * `false` where the field is boolean-shaped) plus a `notes` entry, never a
+ * throw -- an evidence collector that crashes on an unhealthy install is
+ * useless precisely when it is needed most.
+ *
+ * House rule: hyphens only, no em-dashes, no emoji. CJS, process.argv
+ * routing.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { spawnSync } = require('node:child_process');
+
+const SCHEMA = 'mos-cold-install-evidence/1';
+
+function usage() {
+  return 'usage: node scripts/collect-cold-install-evidence.cjs [--json]';
+}
+
+// -- small helpers -----------------------------------------------------
+
+function safe(notes, label, fn, fallback) {
+  try {
+    return fn();
+  } catch (e) {
+    notes.push(label + ': ' + (e && e.message ? e.message : String(e)));
+    return fallback;
+  }
+}
+
+function existsSafe(p) {
+  try {
+    return !!p && fs.existsSync(p);
+  } catch {
+    return false;
+  }
+}
+
+function readJsonSafe(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf8'));
+}
+
+// countInstalledPackages(nodeModulesDir): counts installed packages two
+// levels deep for a scoped entry (@scope/name is ONE package, not two), one
+// level deep otherwise. Skips dotfiles (.bin, .package-lock.json).
+function countInstalledPackages(nodeModulesDir) {
+  let count = 0;
+  const top = fs.readdirSync(nodeModulesDir, { withFileTypes: true });
+  for (const entry of top) {
+    if (!entry.isDirectory()) continue;
+    if (entry.name.startsWith('.')) continue;
+    if (entry.name.startsWith('@')) {
+      const scopeDir = path.join(nodeModulesDir, entry.name);
+      let scoped;
+      try {
+        scoped = fs.readdirSync(scopeDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const s of scoped) {
+        if (s.isDirectory()) count += 1;
+      }
+    } else {
+      count += 1;
+    }
+  }
+  return count;
+}
+
+// longestRelativePath(rootDir): walks rootDir recursively (bounded, symlinks
+// NOT followed to avoid a cycle) and returns { length, path } of the longest
+// path relative to rootDir. Returns null on an unreadable root.
+function longestRelativePath(rootDir) {
+  let best = { length: 0, path: '' };
+  const stack = [rootDir];
+  while (stack.length) {
+    const dir = stack.pop();
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      const abs = path.join(dir, entry.name);
+      const rel = path.relative(rootDir, abs);
+      if (rel.length > best.length) best = { length: rel.length, path: rel };
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory()) stack.push(abs);
+    }
+  }
+  return best;
+}
+
+// probeMcpEntry(entryPath, notes, id): spawns the entry file directly with a
+// closed stdin, capped stderr and a bounded timeout. loads:true when either
+// the process exits cleanly OR its own startup marker appears in stderr
+// before the timeout kills it (see the header comment for why).
+function probeMcpEntry(entryPath, id, notes) {
+  if (!existsSafe(entryPath)) {
+    return { loads: false };
+  }
+  const scratchCwd = safe(notes, 'mcp-probe-' + id + '-scratch-dir', function () {
+    return fs.mkdtempSync(path.join(os.tmpdir(), 'mos-mcp-probe-'));
+  }, os.tmpdir());
+  const result = spawnSync(process.execPath, [entryPath], {
+    cwd: scratchCwd,
+    encoding: 'utf8',
+    timeout: 5000,
+    input: '',
+  });
+  const stderrTail = (result.stderr || '').slice(0, 2000);
+  const startedMarker = /started/i.test(stderrTail);
+  const cleanExit = result.status === 0 && !result.signal;
+  if (result.signal) {
+    notes.push('mcp-probe-' + id + ': killed by signal ' + result.signal + ' after timeout' +
+      (startedMarker ? ' (startup marker seen first -- expected lifecycle for a server that never exits on inspection)' : ' (no startup marker seen -- probe inconclusive)'));
+  }
+  if (result.error) {
+    notes.push('mcp-probe-' + id + ': spawn error: ' + result.error.message);
+  }
+  return { loads: !!(cleanExit || startedMarker) };
+}
+
+// spawnDoctorJson(pluginRoot, args, notes, label): spawns
+// `node <pluginRoot>/scripts/doctor.cjs <args> --json`, and extracts the
+// trailing JSON block from stdout (doctor.cjs's --acceptance path prints
+// human-readable lines before the final JSON.stringify block; --eureka-smoke
+// prints JSON only). Returns the parsed object, or null with a notes entry.
+function spawnDoctorJson(pluginRoot, args, notes, label, timeoutMs) {
+  const doctorPath = path.join(pluginRoot, 'scripts', 'doctor.cjs');
+  if (!existsSafe(doctorPath)) {
+    notes.push(label + ': doctor.cjs not found at ' + doctorPath);
+    return null;
+  }
+  const result = spawnSync(process.execPath, [doctorPath].concat(args).concat(['--json']), {
+    cwd: pluginRoot,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    input: '',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  if (result.error) {
+    notes.push(label + ': spawn error: ' + result.error.message);
+    return null;
+  }
+  if (result.signal) {
+    notes.push(label + ': killed by signal ' + result.signal + ' (timeout ' + timeoutMs + 'ms exceeded)');
+    return null;
+  }
+  const stdout = result.stdout || '';
+  const lines = stdout.split('\n');
+  const startIdx = lines.findIndex(function (l) { return l.trim() === '{'; });
+  if (startIdx === -1) {
+    notes.push(label + ': no JSON block located in stdout (exit code ' + result.status + ')');
+    return null;
+  }
+  const jsonText = lines.slice(startIdx).join('\n');
+  try {
+    return JSON.parse(jsonText);
+  } catch (e) {
+    notes.push(label + ': JSON.parse failed: ' + e.message);
+    return null;
+  }
+}
+
+// -- the collector -------------------------------------------------------
+
+function collectEvidence(opts) {
+  opts = opts || {};
+  const notes = [];
+  const home = os.homedir();
+
+  const pluginRootEnv = process.env.CLAUDE_PLUGIN_ROOT || null;
+  // baseRoot: the root this collector treats as "the plugin" for every
+  // repo-relative read below (doctor.cjs, .mcp.json). Falls back to this
+  // script's own repo when CLAUDE_PLUGIN_ROOT is unset (a dev checkout).
+  const repoRoot = path.resolve(__dirname, '..');
+  const baseRoot = pluginRootEnv && existsSafe(pluginRootEnv) ? pluginRootEnv : repoRoot;
+  if (pluginRootEnv && !existsSafe(pluginRootEnv)) {
+    notes.push('CLAUDE_PLUGIN_ROOT is set to a non-existent path (' + pluginRootEnv + '); falling back to this script\'s own repo root for local reads');
+  }
+
+  // -- claude_code_version --
+  const claudeCodeVersion = safe(notes, 'claude_code_version', function () {
+    const r = spawnSync('claude', ['--version'], { encoding: 'utf8', timeout: 5000, input: '' });
+    if (r.error) throw r.error;
+    if (r.status !== 0) throw new Error('exit ' + r.status);
+    const m = /(\d+\.\d+\.\d+)/.exec((r.stdout || '') + (r.stderr || ''));
+    if (!m) throw new Error('could not parse a version from claude --version output');
+    return m[1];
+  }, null);
+
+  // -- plugin_version (per the plan: repo-version.cjs from a checkout, the
+  // installed package.json from an install; never a tree search) --
+  let pluginVersion = null;
+  if (pluginRootEnv) {
+    pluginVersion = safe(notes, 'plugin_version', function () {
+      const pkg = readJsonSafe(path.join(pluginRootEnv, 'package.json'));
+      if (!pkg.version) throw new Error('package.json at CLAUDE_PLUGIN_ROOT has no version field');
+      return pkg.version;
+    }, null);
+  } else {
+    pluginVersion = safe(notes, 'plugin_version', function () {
+      const { readRepoVersion } = require(path.join(repoRoot, 'lib', 'core', 'repo-version.cjs'));
+      return readRepoVersion().version;
+    }, null);
+  }
+
+  // -- marketplace_source: the plugins[].source object for "mos" from the
+  // cached marketplace catalog Claude Code itself reads from. --
+  const marketplaceCatalogPath = path.join(home, '.claude', 'plugins', 'marketplaces', 'mindrian-marketplace', '.claude-plugin', 'marketplace.json');
+  const marketplaceSource = safe(notes, 'marketplace_source', function () {
+    const catalog = readJsonSafe(marketplaceCatalogPath);
+    const entry = Array.isArray(catalog.plugins) ? catalog.plugins.find(function (p) { return p.name === 'mos'; }) : null;
+    if (!entry) throw new Error('no "mos" entry in ' + marketplaceCatalogPath);
+    if (!entry.source) throw new Error('"mos" entry has no source field');
+    return entry.source;
+  }, null);
+
+  // -- npm_cache_present --
+  const npmCachePath = path.join(home, '.claude', 'plugins', 'npm-cache');
+  const npmCachePresent = existsSafe(npmCachePath);
+
+  // -- cache_dir / node_modules_present / completion_record_present /
+  // installed_package_count / longest_relative_path --
+  let cacheDir = null;
+  let nodeModulesPresent = false;
+  let completionRecordPresent = false;
+  let installedPackageCount = 0;
+  let longestPath = { length: 0, path: '' };
+  if (pluginVersion) {
+    cacheDir = path.join(home, '.claude', 'plugins', 'cache', 'mindrian-marketplace', 'mos', pluginVersion);
+    if (existsSafe(cacheDir)) {
+      const nodeModulesDir = path.join(cacheDir, 'node_modules');
+      nodeModulesPresent = existsSafe(nodeModulesDir);
+      completionRecordPresent = existsSafe(path.join(nodeModulesDir, '.package-lock.json'));
+      if (nodeModulesPresent) {
+        installedPackageCount = safe(notes, 'installed_package_count', function () {
+          return countInstalledPackages(nodeModulesDir);
+        }, 0);
+      }
+      longestPath = safe(notes, 'longest_relative_path', function () {
+        return longestRelativePath(cacheDir);
+      }, { length: 0, path: '' });
+    } else {
+      notes.push('cache_dir does not exist yet: ' + cacheDir);
+    }
+  } else {
+    notes.push('cache_dir could not be computed: plugin_version is unknown');
+  }
+
+  // -- mcp_servers: probe both .mcp.json entries --
+  const mcpJsonPath = path.join(baseRoot, '.mcp.json');
+  let mcpServers = [];
+  const mcpConfig = safe(notes, 'mcp_servers', function () { return readJsonSafe(mcpJsonPath); }, null);
+  if (mcpConfig && mcpConfig.mcpServers) {
+    mcpServers = Object.keys(mcpConfig.mcpServers).map(function (id) {
+      const def = mcpConfig.mcpServers[id];
+      const rawArg = Array.isArray(def.args) && def.args.length ? def.args[0] : '';
+      const entryPath = rawArg.replace('${CLAUDE_PLUGIN_ROOT}', baseRoot);
+      const entryExists = existsSafe(entryPath);
+      const probe = probeMcpEntry(entryPath, id, notes);
+      return { id: id, entry_path: entryPath, entry_exists: entryExists, loads: entryExists && probe.loads };
+    });
+  } else {
+    notes.push('mcp_servers: could not read ' + mcpJsonPath + ' (or it has no mcpServers block)');
+  }
+
+  // -- doctor_acceptance (full tier: the one network touch this envelope
+  // documents, per the header comment) --
+  const doctorAcceptanceRaw = spawnDoctorJson(baseRoot, ['--acceptance'], notes, 'doctor_acceptance', 180000);
+  const doctorAcceptance = doctorAcceptanceRaw
+    ? { ok: Array.isArray(doctorAcceptanceRaw.failed_points) && doctorAcceptanceRaw.failed_points.length === 0, failed_point_ids: doctorAcceptanceRaw.failed_points || [] }
+    : { ok: false, failed_point_ids: [] };
+
+  // -- eureka_smoke --
+  const eurekaSmokeRaw = spawnDoctorJson(baseRoot, ['--eureka-smoke'], notes, 'eureka_smoke', 60000);
+  const eurekaSmoke = eurekaSmokeRaw
+    ? {
+        ok: !!eurekaSmokeRaw.ok,
+        layers: Array.isArray(eurekaSmokeRaw.layers)
+          ? eurekaSmokeRaw.layers.map(function (l) { return { id: l.id, ok: !!l.ok, advisory: !!l.advisory }; })
+          : [],
+      }
+    : { ok: false, layers: [] };
+
+  const envelope = {
+    schema: SCHEMA,
+    collected_at: new Date().toISOString(),
+    platform: process.platform,
+    arch: process.arch,
+    node: process.version,
+    os_release: os.release(),
+    claude_code_version: claudeCodeVersion,
+    plugin_root: pluginRootEnv,
+    plugin_version: pluginVersion,
+    marketplace_source: marketplaceSource,
+    npm_cache_present: npmCachePresent,
+    cache_dir: cacheDir,
+    node_modules_present: nodeModulesPresent,
+    completion_record_present: completionRecordPresent,
+    installed_package_count: installedPackageCount,
+    mcp_servers: mcpServers,
+    doctor_acceptance: doctorAcceptance,
+    eureka_smoke: eurekaSmoke,
+    longest_relative_path: longestPath,
+    first_install_seconds: opts.firstInstallSeconds != null ? opts.firstInstallSeconds : null,
+    notes: opts.firstInstallSeconds == null
+      ? notes.concat(['first_install_seconds is null by default -- the human operator records the wall-clock seconds the "claude plugin update mos@mindrian-marketplace" command took, per 341-RESEARCH Open Question 1'])
+      : notes,
+  };
+
+  return envelope;
+}
+
+// -- CLI -------------------------------------------------------------
+
+function main() {
+  const args = process.argv.slice(2);
+  let json = false;
+  for (const arg of args) {
+    if (arg === '--json') { json = true; continue; }
+    process.stderr.write(usage() + '\n');
+    process.exit(2);
+    return;
+  }
+
+  const envelope = collectEvidence({});
+
+  if (json) {
+    process.stdout.write(JSON.stringify(envelope) + '\n');
+    process.exit(0);
+    return;
+  }
+
+  console.log('Cold-install evidence (' + envelope.schema + ')');
+  console.log('  platform: ' + envelope.platform + ' / ' + envelope.arch + ' / node ' + envelope.node);
+  console.log('  plugin_version: ' + envelope.plugin_version);
+  console.log('  marketplace_source: ' + JSON.stringify(envelope.marketplace_source));
+  console.log('  node_modules_present: ' + envelope.node_modules_present + '  completion_record_present: ' + envelope.completion_record_present);
+  console.log('  installed_package_count: ' + envelope.installed_package_count);
+  console.log('  mcp_servers: ' + envelope.mcp_servers.map(function (s) { return s.id + '=' + (s.loads ? 'loads' : 'no-load'); }).join(', '));
+  console.log('  doctor_acceptance.ok: ' + envelope.doctor_acceptance.ok);
+  console.log('  eureka_smoke.ok: ' + envelope.eureka_smoke.ok);
+  console.log('  longest_relative_path: ' + envelope.longest_relative_path.length + ' chars');
+  console.log('');
+  console.log(JSON.stringify(envelope, null, 2));
+  process.exit(0);
+}
+
+module.exports = { collectEvidence };
+
+if (require.main === module) {
+  main();
+}

package/scripts/doctor.cjs

@@ -371,9 +371,10 @@ Class flags (combine freely; --all activates them all):
                            transcripts at ~/.claude/projects/.../*.jsonl for /mos:<deprecated>
                            patterns; surfaces a per-command "use /mos:<new> instead" hint.
                            Phase 121.5-08 Sub-plan J. LOCAL-only, zero network.)
-  --brain-smoke            class M (Brain end-to-end smoke: 6-layer probe -- plugin root,
-                           key resolver, HTTPS schema, MCP stdio handshake, e2e brain_schema,
-                           store identity (stale-replica detection, quick 260819-c9b).
+  --brain-smoke            class M (Brain end-to-end smoke: 7-layer probe -- origin and
+                           shadow connector (quick 260911-axz), plugin root, key resolver,
+                           HTTPS schema, MCP stdio handshake, e2e brain_schema, store identity
+                           (stale-replica detection, quick 260819-c9b).
                            Diagnostic-only; reports the exact failing layer. Phase 127-02.)
   --eureka-smoke           class S (Eureka local-embedding-stack smoke: 4-layer probe --
                            deps present, vec backend, model cache, graceful degrade.
@@ -4198,15 +4199,17 @@ async function classMBrainSmoke(flags) {
   if (flags.json) {
     console.log(JSON.stringify(Object.assign({ class: 'M' }, result), null, 2));
   } else {
-    console.log('Class M -- Brain end-to-end smoke (6-layer probe)');
+    console.log('Class M -- Brain end-to-end smoke (7-layer probe)');
     console.log('  Overall: ' + (result.ok ? 'PASS' : 'FAIL') + '  (' + result.overall_ms + 'ms)');
     for (const layer of result.layers) {
       const marker = layer.ok ? 'PASS' : 'FAIL';
       console.log('    [' + marker + '] ' + layer.name + ' -- ' + layer.reason + ' (' + layer.ms + 'ms)');
       // Handoff section 7 item g: report which endpoint the wire resolved
-      // to and whether it is canon. Guarded on payload being present so
-      // layers 1-5 (which never carry one) print exactly as before.
-      if (layer.payload) {
+      // to and whether it is canon. Branches on layer.id so the pre-existing
+      // store_identity shape stays byte-identical and the new origin_shadow
+      // shape (quick task 260911-axz) gets its own rendering instead of
+      // printing "endpoint=undefined node_count=undefined canon=undefined".
+      if (layer.payload && layer.id === 'store_identity') {
         const p = layer.payload;
         console.log('        endpoint=' + p.endpoint + ' node_count=' + p.node_count
           + ' canon=' + p.canon + (p.override ? ' override=true' : ''));
@@ -4217,6 +4220,18 @@ async function classMBrainSmoke(flags) {
           if (p.stamp.refreshed_at != null) stampParts.push('refreshed_at=' + p.stamp.refreshed_at);
           console.log('        GraphRagMeta stamp: ' + stampParts.join(' '));
         }
+      } else if (layer.payload && layer.id === 'origin_shadow') {
+        const p = layer.payload;
+        console.log('        origin=' + p.resolved_origin + ' theo=' + p.is_theo
+          + (p.override ? ' override=true' : ''));
+        if (p.theo_health) {
+          console.log('        theo_health mode=' + p.theo_health.mode
+            + (p.theo_health.build_sha != null ? ' sha=' + p.theo_health.build_sha : ''));
+        }
+        for (const s of (p.shadows || [])) {
+          console.log('        shadow: scope=' + s.scope + ' host=' + s.url_host
+            + ' fix=`claude mcp remove mindrian-brain -s ' + s.scope + '`');
+        }
       }
     }
   }

package/scripts/room-registry

@@ -332,9 +332,9 @@ print(json.dumps(reg['rooms'][name], indent=2))
       *)  REAL_ROOMDIR="${ROOMS_HOME}/${RPATH}" ;;
     esac
     _write_current_room "${REAL_ROOMDIR}" "${NAME}"
-    # Fire-and-forget graph sync (D-16: never blocks)
+    # Fire-and-forget local SQLite graph sync (D-16: never blocks). The Brain half
+    # was removed 2026-09-10 as a Canon Part 8 breach (quick task 260910-h32).
     node "${SCRIPT_DIR}/sync-rooms-graph" "$ROOMS_HOME" >/dev/null 2>&1 &
-    node "${SCRIPT_DIR}/sync-rooms-brain" "$ROOMS_HOME" >/dev/null 2>&1 &
     ;;
 
   read)
@@ -597,9 +597,9 @@ with open(tmp, 'w') as f:
 os.replace(tmp, reg_file)
 print('archived')
 " "$REGISTRY_FILE" "$NAME"
-    # Fire-and-forget graph sync (D-16: never blocks)
+    # Fire-and-forget local SQLite graph sync (D-16: never blocks). The Brain half
+    # was removed 2026-09-10 as a Canon Part 8 breach (quick task 260910-h32).
     node "${SCRIPT_DIR}/sync-rooms-graph" "$ROOMS_HOME" >/dev/null 2>&1 &
-    node "${SCRIPT_DIR}/sync-rooms-brain" "$ROOMS_HOME" >/dev/null 2>&1 &
     ;;
 
   get-active)

package/scripts/session-start

@@ -369,10 +369,11 @@ Per Canon Part 10 sub-claim 1, conversation IS the surface; commands are interna
 context=""
 
 if [ -d "$ROOM_DIR" ]; then
-  # Fire-and-forget room hierarchy graph sync (Phase 59.2, D-16: never blocks)
+  # Fire-and-forget local SQLite room hierarchy graph sync (Phase 59.2, D-16: never
+  # blocks). The Brain half was removed 2026-09-10 as a Canon Part 8 breach (quick
+  # task 260910-h32).
   ROOMS_HOME="${MINDRIAN_ROOMS_HOME:-$HOME/MindrianRooms}"
   node "${SCRIPT_DIR}/sync-rooms-graph" "$ROOMS_HOME" >/dev/null 2>&1 &
-  node "${SCRIPT_DIR}/sync-rooms-brain" "$ROOMS_HOME" >/dev/null 2>&1 &
 
   # =============================================================================
   # CONTEXT INTELLIGENCE: Archetype detection + tiered loading (CTX-01, CTX-02, CTX-05)
@@ -1909,6 +1910,28 @@ fi
 unset _BRAIN_KEY_JSON _BRAIN_AVAILABLE _BRAIN_REASON
 # --- END Brain status ---
 
+# ---------------------------------------------------------------------------
+# Quick 260911-ddd (DDD-02): CLI-only pre-warm extra, never the only path.
+#
+# The MCP shim (bin/mindrian-brain-mcp-client.cjs) already fires this same
+# probe at startup on all three surfaces (CLI, Desktop, Cowork) because
+# .mcp.json registers it with alwaysLoad: true -- that is the one
+# surface-neutral pre-warm point. This spawn is a CLI-only belt-and-braces
+# extra: session-start fires earlier in the CLI turn than the shim
+# necessarily connects, so firing it here too shortens the CLI cold window
+# further without duplicating any state (both calls write the same marker
+# idempotently).
+#
+# This is NOT the egress quick 260910-h32 removed: that was a brain_write of
+# room data. This is a content-free theo_health READ with no arguments and
+# no room bytes -- it reintroduces no Brain write. Detached, guarded idiom
+# (matches the existing `( node ... >/dev/null 2>&1 || true ) &` pattern
+# used elsewhere in this file, e.g. the feynman-minto-guardian spawn below).
+# Deliberately NOT inside the `if [ -d "$ROOM_DIR" ]` guard: pre-warm has
+# nothing to do with a room.
+# ---------------------------------------------------------------------------
+( node "${PLUGIN_ROOT}/lib/core/brain-prewarm.cjs" >/dev/null 2>&1 || true ) &
+
 # ---------------------------------------------------------------------------
 # 260517-dcw dogfood-bridge drain (Canon Part 6 Product-as-Venture)
 # ---------------------------------------------------------------------------

package/scripts/whitespace-to-brain.cjs

@@ -37,7 +37,8 @@ const path = require('path');
 const crypto = require('crypto');
 
 // ---------------------------------------------------------------------------
-// Brain client (lazy-loaded, fire-and-forget pattern from sync-rooms-brain)
+// Brain client (lazy-loaded, fire-and-forget pattern, same style as the
+// retired room-hierarchy sync writer removed 2026-09-10, quick task 260910-h32)
 // ---------------------------------------------------------------------------
 
 const PLUGIN_ROOT = path.resolve(__dirname, '..');

package/skills/doctor/SKILL.md

@@ -76,7 +76,7 @@ Every check has a stable class letter (or a registry id). The class flag that ac
 - **class J -- deployment-surfaces** (shares `--install-state`; `--fix` supported) -- reconciles every owned surface in `data/deployment-surfaces.json` against disk. Reads topology / active-root / active-version from class I's same-invocation result (self-derives via `shared.cjs` when absent). `--fix` re-stamps `ok:false` session-start-owned surfaces and prunes the marketplace cache.
 - **class K -- stale-first-touch-copy** (`--stale-first-touch`; check-only) -- greeting surfaces declared by `data/first-touch-surfaces.json` (banner, splash, onboard, sessionstart, operator-update, larry-extended) scanned for stale version literals and U+2014 em-dash violations. SEED-007 absorption. Also activated by `--all`.
 - **class L -- deprecated-usage** (`--deprecated-usage`; check-only) -- scans the last 7 days of `~/.claude/projects/.../*.jsonl` session transcripts for `/mos:<deprecated>` patterns and surfaces a per-command "use `/mos:<new>` instead" hint. Pure LOCAL scan; zero network, zero Brain. Also activated by `--all`.
-- **class M -- brain-smoke** (`--brain-smoke`; check-only) -- 5-layer Brain end-to-end probe (plugin root resolver, key resolver, HTTPS schema, MCP stdio handshake, e2e brain_schema via the bundled shim). Diagnostic-only; reports the exact failing layer. This is an async runner and stays special-cased (carve-out, below). Activated by `--all`.
+- **class M -- brain-smoke** (`--brain-smoke`; check-only) -- 7-layer Brain end-to-end probe: layer 0 origin and shadow connector (quick task 260911-axz -- resolved Brain origin, Theo status, `MINDRIAN_BRAIN_URL` override, Theo's live mode/build sha, and any Claude Code `~/.claude.json` entry shadowing the plugin's own `mindrian-brain` shim), then plugin root resolver, key resolver, HTTPS schema, MCP stdio handshake, e2e brain_schema via the bundled shim, and store identity (stale-replica detection). Diagnostic-only; reports the exact failing layer. This is an async runner and stays special-cased (carve-out, below). Activated by `--all`.
 - **class N -- plugin-enabled-state** (no flag; bare run + `--all`; check-only) -- the silent-disable watchdog (DRIFT-12). Reads `~/.claude/settings.json` enabledPlugins + installed_plugins.json; installed && enabled===false is CRITICAL with a re-enable hint. It runs on a bare run and under `--all` precisely because a DISABLED plugin cannot fire its own SessionStart hooks to report itself. LOCAL read only; never writes settings.json.
 - **class P / Q / R -- drift** (`--drift`; opt-in, NOT in `--all`) -- class P is prose-vs-code drift (skill-vs-code + first-touch, report-only even under `--fix`), class Q is gsd-record drift (shells out to `gsd-tools validate health`, parses W007 ROADMAP gaps + I001 missing SUMMARYs; `--fix` writes the DRIFT.md baseline and stubs missing SUMMARYs), class R is runtime-reachability drift (FAILS NON-ZERO when a capability is WIRED in the connector registry but UNREACHABLE by `decide()` at runtime). LOCAL-only, zero network.
 - **class S -- eureka-smoke** (`--eureka-smoke`; check-only) -- 4-layer Eureka local-embedding-stack probe (deps present, vec backend, model cache, graceful degrade). Non-cascading; never downloads a model unless `MINDRIAN_EUREKA_SMOKE_ALLOW_DOWNLOAD=1`; rolls into `--acceptance`. Another async carve-out (below). `--fix eureka` installs the local embedding stack into `~/.mindrian/eureka-deps/` (one-time, about 380 MB), the same action as `/mos:eureka enable`.
@@ -102,7 +102,7 @@ Look at the user's invocation:
 - `/mos:doctor --install-state` -> class I (install-state + topology + 6-way version-of-record) + class J (deployment-surface reconciliation)
 - `/mos:doctor --stale-first-touch` -> class K
 - `/mos:doctor --deprecated-usage` -> class L
-- `/mos:doctor --brain-smoke` -> class M (5-layer Brain probe)
+- `/mos:doctor --brain-smoke` -> class M (7-layer Brain probe)
 - `/mos:doctor --eureka-smoke` -> class S (4-layer Eureka probe; opt-in)
 - `/mos:doctor --drift` -> class P + class Q + class R (opt-in; NOT in `--all`)
 - `/mos:doctor --report-registration-bug` -> READ-ONLY escalation reporter (below). NOT a class flag, NOT part of `--all`, NOT a `--fix`.

package/skills/larry-personality/SKILL.md

@@ -395,9 +395,10 @@ into Larry's voice for the thin-coverage case. Decision #8 already settled the d
 subsection is the missing wiring, not a new rule.
 
 The trigger is a SIGNAL, never a fixed roster of command names. Any brain_* result carrying one
-of these shapes fires the clause: an empty `signals` set in the DirectiveEnvelope `brain_ask`
-returns (the tool's own description says the envelope "degrades harmlessly to an empty signals
-set when the upstream response carries none"); a `normalize_framework_name` result with zero
+of these shapes fires the clause: the `brain_ask` tool's own description now says its
+DirectiveEnvelope's `directive` and `next_gate` are composed from the graph-grounded rows behind
+the answer, and that an empty `grounding.rows` means thin footing, not a clean answer -- an empty
+`grounding.rows` is exactly that signal; a `normalize_framework_name` result with zero
 canonical matches or with multiple ambiguous ones (the healthy floor is exactly one match); a low
 `orchestration_readiness` `readiness_score` (the floor is 3). Any low-confidence signal counts,
 including ones from tools not named here -- this is signal-driven, not a hardcoded list.