@mindrian_os/cli 1.13.0-beta.10 → 1.13.0-beta.43

package/bin/cli.js

@@ -1,88 +1,214 @@
 #!/usr/bin/env node
 'use strict';
 /*
- * Phase 95.6 D-05c -- MindrianOS CLI (Path B setup-wizard + Path C doctor parity).
+ * MindrianOS installer + diagnostics CLI.
  *
- * Usage: mindrian-os <install|doctor|update> [args]
+ * npm package:        @mindrian_os/cli   ->   `npx @mindrian_os/cli` installs MindrianOS
+ * installed command:  mindrian-os <install|doctor|update> [args]   (no subcommand = install)
  *
- *   install   Path B. Print the marketplace install instructions plus the
- *             optional Brain-key setup. A thin wrapper around the canonical
- *             marketplace flow -- no side effects, just guidance.
- *   doctor    Path C. Run /mos:doctor's diagnostic logic from OUTSIDE Claude
- *             Code so users catch install/drift problems before a session.
- *             Spawns `node <pluginRoot>/scripts/doctor.cjs` with any extra
- *             args passed through (e.g. `mindrian-os doctor --all --fix`).
- *             Exits with doctor.cjs's exit code.
- *   update    Mirror /mos:update. `git -C <pluginRoot> pull --ff-only`, then
- *             re-run `bash <pluginRoot>/install.sh` to re-register agents,
- *             hooks, settings.json, and the statusLine block.
+ * The package name is the verb: running it with no subcommand (or with only
+ * flags, e.g. `npx @mindrian_os/cli --version 1.13.0-beta.9`) does the
+ * install. `doctor` and `update` are still explicit subcommands.
+ *
+ *   install   Install (or bring current) MindrianOS by driving Claude Code's
+ *             own plugin CLI: registers the Mindrian marketplace, refreshes the
+ *             catalog, then `claude plugin install` + `claude plugin update` on
+ *             mos@mindrian-marketplace. Requires the `claude` CLI on PATH (prints
+ *             how to get it if missing). Flags pass through to `claude plugin
+ *             install` (e.g. `--version 1.13.0-beta.9`); when a version is pinned
+ *             the update step is skipped. The Brain key stays a printed hint --
+ *             writing it to the environment is the one side effect left to you.
+ *   doctor    Run /mos:doctor's diagnostic from OUTSIDE Claude Code so you catch
+ *             install/drift problems before a session. Resolves the installed
+ *             plugin (marketplace cache, dev clone, or MINDRIAN_OS_ROOT), then
+ *             `node <pluginRoot>/scripts/doctor.cjs <args...>`. If the plugin is
+ *             not installed, says so plainly instead of throwing a node stack.
+ *   update    Bring MindrianOS current. For a marketplace install: `claude plugin
+ *             marketplace update` + `claude plugin update mos@mindrian-marketplace`.
+ *             For a dev clone (MINDRIAN_OS_ROOT set): `git -C <root> pull --ff-only`
+ *             + `bash <root>/install.sh`.
  *
  * GSD pattern: pure CJS, node built-ins only, zero npm deps. No CLI framework
  * (no commander/yargs/meow). process.argv switch-case routing, mirroring
  * bin/mindrian-tools.cjs and ~/.claude/get-shit-done/bin/gsd-tools.cjs.
  *
- * PLUGIN_ROOT resolution: MINDRIAN_OS_ROOT env var if set (tests, dev boxes),
- * else the canonical install cache at ~/.claude/plugins/mindrian-os.
+ * Plugin-root resolution is delegated to lib/core/active-plugin-root.cjs (the
+ * single source of truth: MINDRIAN_OS_ROOT -> installed_plugins.json -> newest
+ * marketplace-cache mos/<version>/ -> legacy clone -> not-found). doctor and
+ * update both read from it; scripts/statusline-mos shells out to its CLI form.
  */
 
 const { spawnSync } = require('node:child_process');
 const path = require('node:path');
 const os = require('node:os');
+const fs = require('node:fs');
+// The ONE plugin-root resolver: installed_plugins.json (temporal truth) first,
+// then the pre-release-tolerant marketplace-cache scan, then a legacy clone.
+const { resolveActivePluginRoot } = require('../lib/core/active-plugin-root.cjs');
+
+const MARKETPLACE = 'jsagir/mindrian-marketplace';
+const PLUGIN_SPEC = 'mos@mindrian-marketplace';
 
-const PLUGIN_ROOT = process.env.MINDRIAN_OS_ROOT
-  || path.join(os.homedir(), '.claude', 'plugins', 'mindrian-os');
+// On Windows, npm-global CLIs are installed as `.cmd` shims (e.g. `claude.cmd`),
+// not bare executables. Node's spawnSync does NOT consult PATHEXT, so spawning
+// 'claude' directly fails with ENOENT even when `claude --version` works in the
+// user's interactive shell. Routing through the shell (cmd.exe) on win32 lets
+// PATHEXT resolve the `.cmd` shim. POSIX is unaffected -- shell stays false there.
+//
+// IMPORTANT: shell is scoped to `claude` spawns ONLY (via runClaude below), NOT
+// applied to the generic run() helper. run() is also called as
+// run(process.execPath, ...) in the doctor subcommand, and on Windows
+// process.execPath is `C:\Program Files\nodejs\node.exe` (contains a space).
+// With shell:true Node passes the command unquoted to cmd.exe, which would parse
+// `C:\Program` as the command and break. node/git resolve fine WITHOUT shell.
+const isWindows = process.platform === 'win32';
 
 function run(cmd, args, opts) {
   return spawnSync(cmd, args, { stdio: 'inherit', ...opts });
 }
 
+// Spawn the `claude` CLI, shelling out on Windows so the `claude.cmd` shim
+// resolves via PATHEXT. All `claude` invocations MUST go through this wrapper.
+function runClaude(args, opts) {
+  return run('claude', args, { shell: isWindows, ...opts });
+}
+
+function ok(result) {
+  return result && typeof result.status === 'number' && result.status === 0;
+}
+
 function exitFrom(result) {
   // spawnSync sets status=null when the process was killed by a signal or
   // failed to launch; treat that as a generic failure.
   process.exit(result && typeof result.status === 'number' ? result.status : 1);
 }
 
+function hasDoctor(dir) {
+  try {
+    return !!dir && fs.existsSync(path.join(dir, 'scripts', 'doctor.cjs'));
+  } catch {
+    return false;
+  }
+}
+
 function printUsage() {
-  console.log('mindrian-os <install|doctor|update>');
-  console.log('  install   show install instructions + Brain-key setup (Path B)');
-  console.log('  doctor    run the MindrianOS install/drift diagnostic (Path C; passes flags through to /mos:doctor)');
-  console.log('  update    pull the latest plugin and re-run install registration');
+  console.log('mindrian-os <install|doctor|update>   (no subcommand = install)');
+  console.log('  install   install / bring current via Claude Code (marketplace add + plugin install/update)');
+  console.log('  doctor    run the MindrianOS install/drift diagnostic (passes flags through to /mos:doctor)');
+  console.log('  update    bring MindrianOS current (marketplace update + plugin update; or git pull for a dev clone)');
+}
+
+function requireClaudeCli() {
+  const check = spawnSync('claude', ['--version'], { stdio: 'ignore', shell: isWindows });
+  if (ok(check)) return true;
+  console.error('Claude Code is not installed (no `claude` command on your PATH).');
+  console.error('Install it first:');
+  console.error('  npm install -g @anthropic-ai/claude-code');
+  console.error('Then re-run:');
+  console.error('  npx @mindrian_os/cli');
+  return false;
 }
 
-const sub = process.argv[2];
+// No subcommand, or flags only (e.g. `npx @mindrian_os/cli --version 1.13.0-beta.9`),
+// means "install" -- the package name is the verb. Pass any leading flags through.
+let sub = process.argv[2];
+let argOffset = 3;
+if (!sub || sub.startsWith('-')) {
+  sub = 'install';
+  argOffset = 2;
+}
 
 switch (sub) {
   case 'doctor': {
-    // Path C: run /mos:doctor's logic from outside Claude Code.
-    const doctorPath = path.join(PLUGIN_ROOT, 'scripts', 'doctor.cjs');
-    const r = run(process.execPath, [doctorPath, ...process.argv.slice(3)]);
+    const { root } = resolveActivePluginRoot();
+    if (!root || !hasDoctor(root)) {
+      console.error('MindrianOS does not appear to be installed (could not find scripts/doctor.cjs).');
+      console.error('Looked under: ' + path.join(os.homedir(), '.claude', 'plugins') + (process.env.MINDRIAN_OS_ROOT ? ' and $MINDRIAN_OS_ROOT' : ''));
+      console.error('Install it first:');
+      console.error('  npx @mindrian_os/cli');
+      process.exit(1);
+    }
+    const r = run(process.execPath, [path.join(root, 'scripts', 'doctor.cjs'), ...process.argv.slice(argOffset)]);
     exitFrom(r);
     break;
   }
 
   case 'update': {
-    // Mirror /mos:update: fast-forward the plugin clone, then re-run install.sh
-    // so agents, hooks, settings.json, and the statusLine block get re-stamped.
-    run('git', ['-C', PLUGIN_ROOT, 'pull', '--ff-only']);
-    const r = run('bash', [path.join(PLUGIN_ROOT, 'install.sh')]);
-    exitFrom(r);
+    // Dev clone (MINDRIAN_OS_ROOT or a legacy hand-clone): git pull + re-run install.sh.
+    const { root } = resolveActivePluginRoot();
+    const isDevClone = !!process.env.MINDRIAN_OS_ROOT
+      || (root && fs.existsSync(path.join(root, '.git')) && fs.existsSync(path.join(root, 'install.sh')));
+    if (isDevClone && root) {
+      run('git', ['-C', root, 'pull', '--ff-only']);
+      const r = run('bash', [path.join(root, 'install.sh')]);
+      exitFrom(r);
+      break;
+    }
+    // Marketplace install: use Claude Code's own update path.
+    if (!requireClaudeCli()) process.exit(1);
+    console.log('Refreshing the marketplace catalog...');
+    runClaude(['plugin', 'marketplace', 'update']);
+    console.log('Updating the MindrianOS plugin...');
+    const r = runClaude(['plugin', 'update', PLUGIN_SPEC]);
+    if (!ok(r)) {
+      console.error('');
+      console.error('`claude plugin update ' + PLUGIN_SPEC + '` did not complete.');
+      console.error('Try inside Claude Code:  /plugin marketplace update   then   /plugin update ' + PLUGIN_SPEC);
+      exitFrom(r);
+    }
+    console.log('');
+    console.log('MindrianOS is up to date. Run `claude plugin list` to confirm the version.');
+    console.log('Verify:  mindrian-os doctor   (or /mos:doctor inside Claude Code)');
+    process.exit(0);
     break;
   }
 
   case 'install': {
-    // Path B: wrap the marketplace install + a Brain-key prompt. No side
-    // effects -- the user runs the printed commands inside Claude Code.
-    console.log('To install MindrianOS in Claude Code:');
-    console.log('  /plugin marketplace add jsagir/mindrian-marketplace');
-    console.log('  /plugin install mos@mindrian-marketplace');
+    // Flags after `install` (or leading flags when `install` is implied) pass
+    // through to `claude plugin install` (e.g. `... --version 1.13.0-beta.9`).
+    const passthrough = process.argv.slice(argOffset);
+    const pinned = passthrough.some((a) => a === '--version' || a.startsWith('--version='));
+
+    if (!requireClaudeCli()) process.exit(1);
+
+    // Register the Mindrian marketplace (idempotent) and refresh its catalog so
+    // we resolve the current ref. Both are best-effort -- "already added" /
+    // "already up to date" exit non-zero on some Claude Code versions; fine.
+    console.log('Adding the Mindrian marketplace...');
+    runClaude(['plugin', 'marketplace', 'add', MARKETPLACE]);
+    console.log('Refreshing the marketplace catalog...');
+    runClaude(['plugin', 'marketplace', 'update']);
+
+    // Install. On an already-installed plugin Claude Code reports "already
+    // installed" and still exits 0 -- the update step below then moves it
+    // forward to the current ref (unless the caller pinned a version).
+    console.log('Installing the MindrianOS plugin...');
+    const inst = runClaude(['plugin', 'install', PLUGIN_SPEC, ...passthrough]);
+    let updated = false;
+    if (!pinned) {
+      console.log('Bringing the plugin to the current build...');
+      const upd = runClaude(['plugin', 'update', PLUGIN_SPEC]);
+      updated = ok(upd);
+    }
+
+    if (!ok(inst) && !updated) {
+      console.error('');
+      console.error('Installing ' + PLUGIN_SPEC + ' did not complete.');
+      console.error('Finish it by hand inside Claude Code:');
+      console.error('  /plugin marketplace add ' + MARKETPLACE);
+      console.error('  /plugin install ' + PLUGIN_SPEC);
+      exitFrom(inst);
+    }
+
     console.log('');
-    console.log('Or run the universal installer from a shell:');
-    console.log('  curl -fsSL https://raw.githubusercontent.com/jsagir/mindrian-os-plugin/main/install.sh | bash');
+    console.log('MindrianOS is installed and current. Run `claude plugin list` to see the version.');
     console.log('');
-    console.log('Optional: set your Brain key for enriched intelligence:');
-    console.log('  export MINDRIAN_BRAIN_KEY=<your-key>   (or add it to ~/.claude/.env)');
+    console.log('Optional -- connect the Brain for enriched intelligence:');
+    console.log('  inside Claude Code:  /mos:setup   (choose "Configure Brain", paste your key)');
+    console.log('  or set it directly:  export MINDRIAN_BRAIN_KEY="<your-key>"   (or add it to ~/.claude/.env)');
     console.log('');
-    console.log('Then verify: mindrian-os doctor   (or /mos:doctor inside Claude Code)');
+    console.log('Verify:  mindrian-os doctor   (or /mos:doctor inside Claude Code)');
+    console.log('Start:   open a fresh Claude Code session, then  /mos:onboard');
     process.exit(0);
     break;
   }

package/lib/core/active-plugin-root.cjs

@@ -0,0 +1,207 @@
+'use strict';
+/*
+ * lib/core/active-plugin-root.cjs -- the ONE resolver for "where is the active
+ * MindrianOS plugin install on this machine?"
+ *
+ * Background: before this module, three different places guessed independently
+ * (bin/cli.js hardcoded a legacy path; scripts/statusline-mos did `ls cache |
+ * sort -V` with a pure-semver regex that rejected `-beta.N`; context-monitor
+ * inherited whatever those picked). Three guessers, three failure modes -- a box
+ * with 1.12.0 + 1.13.0-beta.9 in the cache ended up rendering the statusline,
+ * the version banner, and MINDRIAN_OS_ROOT from the wrong (older) version. This
+ * collapses them into one source of truth.
+ *
+ * Precedence (first hit wins):
+ *   1. MINDRIAN_OS_ROOT env var          -- tests, dev boxes, hand clones.
+ *   2. ~/.claude/plugins/installed_plugins.json
+ *                                        -- Claude Code's own registry of the
+ *                                           ACTIVE install of mos@mindrian-marketplace.
+ *                                           Temporal truth: it knows which one is
+ *                                           current even when "highest semver" is not
+ *                                           the active one (e.g. a pinned older version).
+ *   3. ~/.claude/plugins/cache/<marketplace>/mos/<version>/
+ *                                        -- newest valid version dir; pre-release
+ *                                           tolerant (`sort -V` ordering). Fallback
+ *                                           for when installed_plugins.json is missing
+ *                                           or unparseable.
+ *   4. ~/.claude/plugins/mindrian-os/    -- legacy hand-clone layout.
+ *   5. null                              -- not installed.
+ *
+ * Use as a module:
+ *   const { resolveActivePluginRoot } = require('<...>/lib/core/active-plugin-root.cjs');
+ *   const { root, source } = resolveActivePluginRoot();   // root may be null
+ *
+ * Use as a CLI (so a bash wrapper -- e.g. scripts/statusline-mos -- can shell out):
+ *   node active-plugin-root.cjs          -> prints the resolved path, or nothing; exit 0 if found, 1 if not
+ *   node active-plugin-root.cjs --json   -> prints {"root": "<path|null>", "source": "<...>"}
+ *
+ * Canon Part 8: this reads LOCAL files only (~/.claude/plugins/). Zero network.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const PLUGIN_KEYS = ['mos', 'mindrian-os']; // accept either marketplace plugin name
+
+// A valid plugin install dir has a .claude-plugin/plugin.json.
+function isPluginDir(dir) {
+  try {
+    return !!dir && fs.statSync(dir).isDirectory() && fs.existsSync(path.join(dir, '.claude-plugin', 'plugin.json'));
+  } catch {
+    return false;
+  }
+}
+
+function fromInstalledPlugins(home) {
+  // Shape (Claude Code 2.x):
+  //   { "version": N, "plugins": { "mos@mindrian-marketplace": [ { "installPath": "...", ... } ], ... } }
+  // Defensive: the key might be just "mos"; the value might be an object not a
+  // 1-element array; the path field might be installPath / path / dir.
+  const file = path.join(home, '.claude', 'plugins', 'installed_plugins.json');
+  let data;
+  try {
+    data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+  const plugins = (data && (data.plugins || data)) || {};
+  for (const key of Object.keys(plugins)) {
+    const name = String(key).split('@')[0];
+    if (!PLUGIN_KEYS.includes(name)) continue;
+    let entry = plugins[key];
+    if (Array.isArray(entry)) entry = entry[0];
+    if (!entry || typeof entry !== 'object') continue;
+    const p = entry.installPath || entry.path || entry.dir;
+    if (p && isPluginDir(p)) return p;
+  }
+  return null;
+}
+
+function fromMarketplaceCache(home) {
+  const cacheBase = path.join(home, '.claude', 'plugins', 'cache');
+  let marketplaces;
+  try {
+    marketplaces = fs.readdirSync(cacheBase, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const found = [];
+  for (const mk of marketplaces) {
+    if (!mk.isDirectory()) continue;
+    for (const pluginName of PLUGIN_KEYS) {
+      const pluginDir = path.join(cacheBase, mk.name, pluginName);
+      let versions;
+      try {
+        versions = fs.readdirSync(pluginDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const v of versions) {
+        if (!v.isDirectory()) continue;
+        const candidate = path.join(pluginDir, v.name);
+        if (isPluginDir(candidate)) found.push({ dir: candidate, ver: v.name });
+      }
+    }
+  }
+  if (!found.length) return null;
+  // `localeCompare` numeric ordering matches `sort -V` for the cases we care
+  // about: 1.12.0 < 1.12.5.1 < 1.13.0-beta.9 < 1.13.0-beta.11 < 1.13.0.
+  found.sort((a, b) => String(a.ver).localeCompare(String(b.ver), undefined, { numeric: true }));
+  return found[found.length - 1].dir;
+}
+
+function fromLegacyClone(home) {
+  const legacy = path.join(home, '.claude', 'plugins', 'mindrian-os');
+  return isPluginDir(legacy) ? legacy : null;
+}
+
+// Phase 123 Plan-02 (HARNESS-123-05): classify the resolved plugin root into one
+// of the 4 known topologies. RESEARCH Pitfall 4: a legacy-clone dir can carry an
+// unrelated origin remote (the dogfood box's ~/.claude/plugins/mindrian-os/ has
+// its origin pointed at mindrian-agno-backend.git) so a naive "has origin ->
+// dev-clone" heuristic mis-classifies it. The order below is precedence-locked:
+// env override and explicit legacy path win before the structural git probe.
+//
+// Returns one of: 'marketplace-cache' | 'dev-clone' | 'legacy' | 'not-found'.
+function classifyTopology(root, source) {
+  if (!root) return 'not-found';
+  // env override -> always treated as a dev clone (tests, dev boxes, hand clones).
+  if (source === 'MINDRIAN_OS_ROOT') return 'dev-clone';
+
+  const home = os.homedir();
+  // Explicit legacy path wins before the structural check -- some legacy clones
+  // carry an unrelated origin remote (Pitfall 4).
+  try {
+    if (path.resolve(root) === path.resolve(home, '.claude', 'plugins', 'mindrian-os')) {
+      return 'legacy';
+    }
+  } catch { /* ignore */ }
+
+  // Marketplace cache: under ~/.claude/plugins/cache/<mp>/{mos|mindrian-os}/<version>/.
+  try {
+    const cacheBase = path.resolve(home, '.claude', 'plugins', 'cache');
+    const resolved = path.resolve(root);
+    if (resolved.startsWith(cacheBase + path.sep)) {
+      return 'marketplace-cache';
+    }
+  } catch { /* ignore */ }
+
+  // Dev clone structural probe: a .git + install.sh + an origin remote URL that
+  // mentions the plugin repo name. execSync is wrapped in try/catch so a missing
+  // git binary or a non-git dir falls through cleanly.
+  try {
+    if (fs.existsSync(path.join(root, '.git')) && fs.existsSync(path.join(root, 'install.sh'))) {
+      const cp = require('node:child_process');
+      let originUrl = '';
+      try {
+        originUrl = cp.execSync('git -C ' + JSON.stringify(root) + ' remote get-url origin', {
+          stdio: ['ignore', 'pipe', 'ignore'],
+          encoding: 'utf8',
+          timeout: 1500,
+        }).trim();
+      } catch { /* no origin remote, swallow */ }
+      if (/mindrian-os-plugin/i.test(originUrl)) return 'dev-clone';
+    }
+  } catch { /* ignore */ }
+
+  // Defensive defaults: respect the resolver's source classification.
+  if (source === 'legacy-clone') return 'legacy';
+  // A resolved plugin dir that is not under a recognized cache path and not the
+  // legacy fixed path and does not pass the dev-clone probe -- treat as
+  // marketplace-cache (the bin/cli.js + installed_plugins.json path).
+  return 'marketplace-cache';
+}
+
+function resolveActivePluginRoot() {
+  const envRoot = process.env.MINDRIAN_OS_ROOT;
+  if (envRoot) {
+    return { root: envRoot, source: 'MINDRIAN_OS_ROOT', topology: classifyTopology(envRoot, 'MINDRIAN_OS_ROOT') };
+  }
+
+  const home = os.homedir();
+  let r;
+  if ((r = fromInstalledPlugins(home))) {
+    return { root: r, source: 'installed_plugins.json', topology: classifyTopology(r, 'installed_plugins.json') };
+  }
+  if ((r = fromMarketplaceCache(home))) {
+    return { root: r, source: 'marketplace-cache', topology: classifyTopology(r, 'marketplace-cache') };
+  }
+  if ((r = fromLegacyClone(home))) {
+    return { root: r, source: 'legacy-clone', topology: classifyTopology(r, 'legacy-clone') };
+  }
+  return { root: null, source: 'not-found', topology: 'not-found' };
+}
+
+module.exports = { resolveActivePluginRoot, classifyTopology };
+
+// CLI entry point.
+if (require.main === module) {
+  const out = resolveActivePluginRoot();
+  if (process.argv.includes('--json')) {
+    process.stdout.write(JSON.stringify(out) + '\n');
+  } else if (out.root) {
+    process.stdout.write(out.root + '\n');
+  }
+  process.exit(out.root ? 0 : 1);
+}

package/package.json

@@ -1,26 +1,19 @@
 {
   "name": "@mindrian_os/cli",
-  "version": "1.13.0-beta.10",
-  "description": "MindrianOS MCP server - Larry thinks with you through PWS methodology via Claude Desktop and Cowork",
+  "version": "1.13.0-beta.43",
+  "description": "Install MindrianOS into Claude Code with one command -- `npx @mindrian_os/install`. 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",
     "parity": "node lib/parity/check-parity.cjs",
     "migrate-minto-v88": "node scripts/migrate-minto-schema-v88.cjs"
   },
   "bin": {
-    "mindrian-os": "bin/cli.js"
+    "mindrian-os": "bin/cli.js",
+    "cli": "bin/cli.js"
   },
   "files": [
-    "bin/",
-    "lib/",
-    "pipelines/",
-    "references/",
-    "skills/",
-    "commands/",
-    "agents/",
-    "hooks/",
-    ".claude-plugin/",
-    ".mcp.json",
+    "bin/cli.js",
+    "lib/core/active-plugin-root.cjs",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"
@@ -35,6 +28,7 @@
     "flexsearch": "^0.7.43",
     "gray-matter": "^4.0.3",
     "markdown-it": "^14.1.0",
+    "semver": "^7.7.4",
     "zod": "^3.25.76"
   },
   "engines": {

package/.claude-plugin/plugin.json

@@ -1,21 +0,0 @@
-{
-  "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": "1.13.0-beta.10",
-  "author": {
-    "name": "Jonathan Sagir",
-    "url": "https://mindrian.ai"
-  },
-  "homepage": "https://mindrian.ai",
-  "repository": "https://github.com/jsagir/mindrian-os-plugin",
-  "license": "BSL-1.1",
-  "keywords": [
-    "innovation",
-    "pws",
-    "venture",
-    "methodology",
-    "data-room",
-    "thinking-partner",
-    "larry"
-  ]
-}

package/.mcp.json

@@ -1,9 +0,0 @@
-{
-  "mcpServers": {
-    "mindrian-os": {
-      "command": "node",
-      "args": ["bin/mindrian-mcp-server.cjs"],
-      "alwaysLoad": true
-    }
-  }
-}

package/agents/brain-query.md

@@ -1,80 +0,0 @@
----
-name: brain-query
-description: Query the Brain teaching graph with natural language. Translates to Cypher, synthesizes insights, never exposes raw data.
-model: inherit
-color: blue
-allowed-tools:
-  - mcp__mindrian-brain__brain_query
-  - mcp__neo4j-brain__read_neo4j_cypher
-  - mcp__neo4j-brain__get_neo4j_schema
-  - mcp__mindrian-brain__brain_search
-  - mcp__pinecone-brain__search-records
-  - Read
----
-
-<!-- Phase 95.6 D-10: Brain access declared explicitly via allowed-tools (mcp__mindrian-brain__* / mcp__neo4j-brain__* / mcp__pinecone-brain__*); no implicit MCP inheritance. -->
-
-You are the Brain Agent -- a schema-aware GraphRAG retriever. You translate questions into precise Cypher queries and return insights.
-
-## Your Role
-
-Translate natural language questions into precise Cypher queries against the Brain graph. Return INSIGHTS, not raw query results. You are the bridge between human questions and graph intelligence.
-
-## Voice
-
-Neutral, analytical, precise. You are NOT Larry. No warmth, no reframes, no teaching metaphors. No "Very simply..." or "Think about it like this..." State findings clearly. Use structured language: "The graph shows...", "Three connections emerge...", "The strongest path is..."
-
-## Setup
-
-Before answering any question:
-
-1. Read `references/brain/schema.md` for the node/relationship taxonomy (8 node types, 8 relationships)
-2. Read `references/brain/query-patterns.md` for the 8 standard query templates
-
-These are your only query source. Never invent Cypher from scratch -- adapt named patterns.
-
-## Query Protocol
-
-For every question:
-
-1. **Pattern Match** -- Determine which named pattern(s) from query-patterns.md match the question
-2. **Adapt** -- Replace `$parameters` with specific values from the current context
-3. **Execute** -- Call `mcp__mindrian-brain__brain_query` (fallback: `mcp__neo4j-brain__read_neo4j_cypher`) with the adapted Cypher
-4. **Enrich** -- If results need semantic context, use `mcp__mindrian-brain__brain_search` (fallback: `mcp__pinecone-brain__search-records`; if Pinecone returns RESOURCE_EXHAUSTED, skip semantic search and use Neo4j Cypher queries instead) for fuzzy matching
-5. **Synthesize** -- Convert raw results into natural language insight with specific evidence
-6. **Return** -- Deliver insight to the calling agent or skill
-
-## Multi-Hop Protocol
-
-For complex questions requiring graph traversal across multiple relationships:
-
-1. **Start constrained** -- Begin with the most specific query (fewest possible results)
-2. **Chain results** -- Use hop N results as parameters for hop N+1
-3. **Build narrative** -- Each hop adds a layer to the insight. Connect the dots explicitly
-4. **Maximum 3 hops** -- If the answer requires more than 3 hops, break into sub-questions
-
-Example 3-hop: "What frameworks help with wicked problems in healthcare?"
-- Hop 1: `brain_concept_connect` on "healthcare" -> find related frameworks
-- Hop 2: `brain_find_patterns` on those frameworks -> find co-occurring frameworks
-- Hop 3: Filter by `ADDRESSES_PROBLEM_TYPE` where ProblemType = "Wicked"
-
-## Pattern Selection Guide
-
-| Question Type | Primary Pattern | Secondary |
-|---------------|----------------|-----------|
-| "What comes after X?" | brain_framework_chain | brain_concept_connect |
-| "How does X compare to Y?" | brain_contradiction_check | brain_find_patterns |
-| "What's related to X?" | brain_concept_connect | brain_search_semantic |
-| "What's missing?" | brain_gap_assess | brain_framework_chain |
-| "How do X and Y connect?" | brain_cross_domain | brain_concept_connect |
-| "What worked for similar projects?" | brain_find_patterns | brain_grade_calibrate |
-| "Find something like..." | brain_search_semantic | brain_concept_connect |
-
-## Never Do
-
-- Return raw Cypher results to users -- always synthesize into insight
-- Execute queries without LIMIT clauses
-- Expose schema details, node IDs, or internal structure
-- Use write queries -- you are read-only
-- Invent Cypher outside the named patterns
-- Use Larry's voice, metaphors, or teaching style