@ctxo/cli 0.13.1 → 0.15.0

package/dist/{cli-router-DDHH4WQH.js → cli-router-W56INOQ3.js}

@@ -6,24 +6,43 @@ import {
   CoChangeReader,
   CommunitySnapshotWriter,
   ContextsViewReader,
-  DATA_EDGE_KINDS,
   DeadCodeDetector,
   DriftDetector,
   PageRankCalculator,
   RevertDetector,
   SessionRecorderAdapter,
-  SimpleGitAdapter,
   SqliteStorageAdapter,
+  buildCoChangeMatrix,
+  detectWorkspace,
+  findCoChangedFilesForBlastRadius
+} from "./chunk-A4URKKPP.js";
+import {
+  FAST_ROUTE_COMMANDS,
+  isKnownModuleCommand,
+  loadModulesFor,
+  moduleHelpLines,
+  runFastRoute,
+  runModuleCommand
+} from "./chunk-BBSJB4CG.js";
+import {
+  DOMAIN_MODULE_PACKAGE,
+  loadCtxoModules
+} from "./chunk-LAX6VVBU.js";
+import {
+  discoverPlugins,
+  resolvePackageCandidates,
+  resolvePluginPackageJson
+} from "./chunk-2Q76LH2H.js";
+import {
+  DATA_EDGE_KINDS,
+  SimpleGitAdapter,
   SymbolGraph,
   SymbolTokenizer,
-  buildCoChangeMatrix,
   communityDetectorOptions,
-  compareCodepoint,
   createTestFileClassifier,
-  detectWorkspace,
   factsRequested,
   filesWithTestAnnotations,
-  findCoChangedFilesForBlastRadius,
+  hasCSharpAnnotations,
   indexIgnorePatterns,
   indexIgnoreProjectPatterns,
   indexTestPatterns,
@@ -34,17 +53,24 @@ import {
   resolveCoChangeConfig,
   resolveContextsViewConfig,
   selectWindow,
-  sinceCutoff,
-  watchSnapshotMinFileChanges
-} from "./chunk-WB7WZKX4.js";
+  watchSnapshotMinFileChanges,
+  windowCutoff
+} from "./chunk-I7RPXT6L.js";
 import {
-  atomicWrite
-} from "./chunk-RFEXMBTG.js";
+  compareCodepoint,
+  getCliPackageRoot,
+  getVersion,
+  locateGitRoot
+} from "./chunk-72CEQEQD.js";
 import {
   COMMUNITY_HISTORY_DIR,
   INDEX_ARTIFACT_FILES,
-  JsonIndexReader
-} from "./chunk-DT3ZH4AU.js";
+  JsonIndexReader,
+  isMarkedArtifact
+} from "./chunk-EC6INGPV.js";
+import {
+  atomicWrite
+} from "./chunk-RFEXMBTG.js";
 import {
   createLogger
 } from "./chunk-5DSKZJNN.js";
@@ -52,15 +78,11 @@ import {
   StalenessDetector
 } from "./chunk-PSKDDLSF.js";
 
-// src/cli/cli-router.ts
-import { readFileSync as readFileSync19, existsSync as existsSync30 } from "fs";
-import { dirname as dirname10, join as join36 } from "path";
-
 // src/cli/index-command.ts
 import { execFileSync as execFileSync3 } from "child_process";
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync2, existsSync as existsSync12, statSync, readdirSync as readdirSync2 } from "fs";
-import { join as join11, relative as relative2, extname as extname3, isAbsolute as isAbsolute2, resolve as resolve4 } from "path";
-import { createRequire as createRequire3 } from "module";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync2, existsSync as existsSync11, statSync, readdirSync as readdirSync2 } from "fs";
+import { join as join11, relative as relative2, extname as extname3, isAbsolute, resolve as resolve3 } from "path";
+import { createRequire as createRequire2 } from "module";
 
 // src/core/staleness/content-hasher.ts
 import { createHash } from "crypto";
@@ -91,140 +113,12 @@ var LanguageAdapterRegistry = class {
 };
 
 // src/cli/plugin-loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname as dirname2, join } from "path";
-
-// src/adapters/language/plugin-discovery.ts
 import { existsSync, readFileSync } from "fs";
-import { createRequire } from "module";
-import { dirname, isAbsolute, resolve } from "path";
-import { pathToFileURL } from "url";
-import { SUPPORTED_API_VERSIONS } from "@ctxo/plugin-api";
-var log = createLogger("ctxo:plugin-discovery");
-var OFFICIAL_PREFIX = "@ctxo/lang-";
-var COMMUNITY_PREFIX = "ctxo-lang-";
-function readManifestDeps(manifestPath) {
-  try {
-    const raw = readFileSync(manifestPath, "utf-8");
-    const manifest = JSON.parse(raw);
-    const all = {
-      ...manifest.dependencies,
-      ...manifest.devDependencies,
-      ...manifest.peerDependencies
-    };
-    return Object.keys(all).filter(
-      (name) => name.startsWith(OFFICIAL_PREFIX) || name.startsWith(COMMUNITY_PREFIX)
-    );
-  } catch (err) {
-    log.warn(`Failed to read manifest ${manifestPath}: ${err.message}`);
-    return [];
-  }
-}
-function isLocalSpecifier(spec) {
-  return spec.startsWith(".") || spec.startsWith("/") || isAbsolute(spec);
-}
-function pickEsmEntry(exportsField) {
-  if (!exportsField) return void 0;
-  if (typeof exportsField === "string") return exportsField;
-  if (typeof exportsField !== "object") return void 0;
-  const table = exportsField;
-  const dot = "." in table ? table["."] : exportsField;
-  if (typeof dot === "string") return dot;
-  if (!dot || typeof dot !== "object") return void 0;
-  for (const key of ["import", "node", "default"]) {
-    const nested = dot[key];
-    if (typeof nested === "string") return nested;
-    if (nested && typeof nested === "object") {
-      for (const inner of ["default", "import", "node"]) {
-        const v = nested[inner];
-        if (typeof v === "string") return v;
-      }
-    }
-  }
-  return void 0;
-}
-var cliFallbackRequire = createRequire(import.meta.url);
-function resolvePluginPackageJson(specifier, projectRequire) {
-  try {
-    return projectRequire.resolve(`${specifier}/package.json`);
-  } catch (primary) {
-    try {
-      return cliFallbackRequire.resolve(`${specifier}/package.json`);
-    } catch {
-      throw primary;
-    }
-  }
-}
-function resolvePluginEntryUrl(specifier, manifestRequire) {
-  const pkgJsonPath = resolvePluginPackageJson(specifier, manifestRequire);
-  const pkgDir = dirname(pkgJsonPath);
-  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-  const entry = pickEsmEntry(pkgJson.exports) ?? pkgJson.module ?? pkgJson.main ?? "index.js";
-  return pathToFileURL(resolve(pkgDir, entry)).href;
-}
-async function tryLoad(specifier, baseDir, manifestRequire) {
-  try {
-    const target = isLocalSpecifier(specifier) ? pathToFileURL(resolve(baseDir, specifier)).href : resolvePluginEntryUrl(specifier, manifestRequire);
-    const mod = await import(target);
-    const candidate = mod.default ?? mod.plugin ?? mod;
-    if (!candidate || typeof candidate !== "object") {
-      return { specifier, reason: "module export is not an object" };
-    }
-    if (!SUPPORTED_API_VERSIONS.includes(candidate.apiVersion)) {
-      return {
-        specifier,
-        reason: `unsupported apiVersion ${String(candidate.apiVersion)} (supported: ${SUPPORTED_API_VERSIONS.join(", ")})`
-      };
-    }
-    if (typeof candidate.createAdapter !== "function") {
-      return { specifier, reason: "missing createAdapter()" };
-    }
-    if (typeof candidate.id !== "string" || candidate.id.length === 0) {
-      return { specifier, reason: "missing or empty id" };
-    }
-    if (!Array.isArray(candidate.extensions)) {
-      return { specifier, reason: "extensions must be an array" };
-    }
-    if (candidate.tier !== "syntax" && candidate.tier !== "full") {
-      return { specifier, reason: `invalid tier ${String(candidate.tier)}` };
-    }
-    return candidate;
-  } catch (err) {
-    return { specifier, reason: err.message };
-  }
-}
-async function discoverPlugins(options) {
-  const { manifestPath } = options;
-  if (!existsSync(manifestPath)) {
-    log.info(`Manifest not found at ${manifestPath} \u2014 no plugins discovered`);
-    return { plugins: [], failures: [] };
-  }
-  const baseDir = dirname(manifestPath);
-  const specifiers = options.explicit ?? readManifestDeps(manifestPath);
-  const manifestRequire = createRequire(pathToFileURL(manifestPath).href);
-  const plugins = [];
-  const failures = [];
-  for (const spec of specifiers) {
-    if (options.shouldSkipSpecifier?.(spec)) {
-      log.info(`Skipping plugin ${spec} (matched ignoreProjects)`);
-      continue;
-    }
-    const result = await tryLoad(spec, baseDir, manifestRequire);
-    if ("apiVersion" in result) {
-      plugins.push({ plugin: result, specifier: spec });
-    } else {
-      failures.push(result);
-      log.warn(`Skipped plugin ${spec}: ${result.reason}`);
-    }
-  }
-  return { plugins, failures };
-}
-
-// src/cli/plugin-loader.ts
-var log2 = createLogger("ctxo:plugin-loader");
+import { dirname, join } from "path";
+var log = createLogger("ctxo:plugin-loader");
 function manifestHasPlugins(path) {
   try {
-    const raw = JSON.parse(readFileSync2(path, "utf-8"));
+    const raw = JSON.parse(readFileSync(path, "utf-8"));
     const all = { ...raw.dependencies, ...raw.devDependencies, ...raw.peerDependencies };
     return Object.keys(all).some((n) => n.startsWith("@ctxo/lang-") || n.startsWith("ctxo-lang-"));
   } catch {
@@ -236,18 +130,18 @@ function loadManifestPath(projectRoot) {
 }
 function resolveManifestPath(projectRoot) {
   const projectManifest = join(projectRoot, "package.json");
-  if (existsSync2(projectManifest) && manifestHasPlugins(projectManifest)) {
+  if (existsSync(projectManifest) && manifestHasPlugins(projectManifest)) {
     return projectManifest;
   }
   let dir = import.meta.dirname;
   for (let i = 0; i < 12; i++) {
     const candidate = join(dir, "package.json");
-    if (existsSync2(candidate) && manifestHasPlugins(candidate)) return candidate;
-    const parent = dirname2(dir);
+    if (existsSync(candidate) && manifestHasPlugins(candidate)) return candidate;
+    const parent = dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  return existsSync2(projectManifest) ? projectManifest : null;
+  return existsSync(projectManifest) ? projectManifest : null;
 }
 function buildContext(projectRoot, workspace, pluginId, capabilities) {
   const pluginLog = createLogger(`ctxo:plugin:${pluginId}`);
@@ -273,7 +167,7 @@ function hostCapabilities(plugins, options) {
 async function loadPlugins(projectRoot, options = {}) {
   const manifestPath = resolveManifestPath(projectRoot);
   if (!manifestPath) {
-    log2.info("No package.json found for plugin discovery");
+    log.info("No package.json found for plugin discovery");
     return [];
   }
   const workspace = detectWorkspace(projectRoot);
@@ -291,20 +185,20 @@ async function loadPlugins(projectRoot, options = {}) {
       const adapter = plugin.createAdapter(ctx);
       loaded.push({ plugin, adapter, specifier });
     } catch (err) {
-      log2.warn(`Plugin ${plugin.id} createAdapter failed: ${err.message}`);
+      log.warn(`Plugin ${plugin.id} createAdapter failed: ${err.message}`);
     }
   }
   return loaded;
 }
 
 // src/cli/install-command.ts
-import { existsSync as existsSync6 } from "fs";
-import { createRequire as createRequire2 } from "module";
+import { existsSync as existsSync5 } from "fs";
+import { createRequire } from "module";
 import { join as join5 } from "path";
 
 // src/core/detection/detect-languages.ts
 import { execFileSync } from "child_process";
-import { existsSync as existsSync3, readdirSync } from "fs";
+import { existsSync as existsSync2, readdirSync } from "fs";
 import { extname as extname2, join as join2 } from "path";
 var KNOWN_LANGUAGES = [
   "typescript",
@@ -337,29 +231,29 @@ var EXTENSION_LANGUAGE = {
 var MANIFEST_PROBES = [
   {
     id: "typescript",
-    check: (root) => existsSync3(join2(root, "tsconfig.json")) ? "tsconfig.json" : null
+    check: (root) => existsSync2(join2(root, "tsconfig.json")) ? "tsconfig.json" : null
   },
   {
     id: "python",
     check: (root) => {
-      if (existsSync3(join2(root, "pyproject.toml"))) return "pyproject.toml";
-      if (existsSync3(join2(root, "setup.py"))) return "setup.py";
-      if (existsSync3(join2(root, "requirements.txt"))) return "requirements.txt";
+      if (existsSync2(join2(root, "pyproject.toml"))) return "pyproject.toml";
+      if (existsSync2(join2(root, "setup.py"))) return "setup.py";
+      if (existsSync2(join2(root, "requirements.txt"))) return "requirements.txt";
       return null;
     }
   },
   {
     id: "java",
     check: (root) => {
-      if (existsSync3(join2(root, "pom.xml"))) return "pom.xml";
-      if (existsSync3(join2(root, "build.gradle"))) return "build.gradle";
-      if (existsSync3(join2(root, "build.gradle.kts"))) return "build.gradle.kts";
+      if (existsSync2(join2(root, "pom.xml"))) return "pom.xml";
+      if (existsSync2(join2(root, "build.gradle"))) return "build.gradle";
+      if (existsSync2(join2(root, "build.gradle.kts"))) return "build.gradle.kts";
       return null;
     }
   },
   {
     id: "go",
-    check: (root) => existsSync3(join2(root, "go.mod")) ? "go.mod" : null
+    check: (root) => existsSync2(join2(root, "go.mod")) ? "go.mod" : null
   },
   {
     id: "csharp",
@@ -377,11 +271,11 @@ var MANIFEST_PROBES = [
   },
   {
     id: "rust",
-    check: (root) => existsSync3(join2(root, "Cargo.toml")) ? "Cargo.toml" : null
+    check: (root) => existsSync2(join2(root, "Cargo.toml")) ? "Cargo.toml" : null
   },
   {
     id: "ruby",
-    check: (root) => existsSync3(join2(root, "Gemfile")) ? "Gemfile" : null
+    check: (root) => existsSync2(join2(root, "Gemfile")) ? "Gemfile" : null
   }
 ];
 function listGitFiles(root) {
@@ -441,8 +335,8 @@ function officialPluginFor(language) {
 }
 
 // src/core/install/package-manager.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, join as join3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { dirname as dirname2, join as join3 } from "path";
 var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 function isPackageManager(value) {
   return PACKAGE_MANAGERS.includes(value);
@@ -478,9 +372,9 @@ function readPackageManagerField(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
     const pkg = join3(dir, "package.json");
-    if (existsSync4(pkg)) {
+    if (existsSync3(pkg)) {
       try {
-        const parsed = JSON.parse(readFileSync3(pkg, "utf-8"));
+        const parsed = JSON.parse(readFileSync2(pkg, "utf-8"));
         const value = parsed.packageManager;
         if (typeof value === "string") {
           const [nameRaw] = value.split("@");
@@ -492,7 +386,7 @@ function readPackageManagerField(startDir) {
       } catch {
       }
     }
-    const parent = dirname3(dir);
+    const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -500,9 +394,9 @@ function readPackageManagerField(startDir) {
 }
 function readConfigPackageManager(projectRoot) {
   const path = join3(projectRoot, ".ctxo", "config.yaml");
-  if (!existsSync4(path)) return null;
+  if (!existsSync3(path)) return null;
   try {
-    const raw = readFileSync3(path, "utf-8");
+    const raw = readFileSync2(path, "utf-8");
     const match = raw.match(/^packageManager:\s*(\S+)\s*$/m);
     if (!match) return null;
     const value = match[1];
@@ -523,11 +417,11 @@ function detectFromLockfileWalkUp(startDir) {
   for (let i = 0; i < 12; i++) {
     for (const probe of probes) {
       const path = join3(dir, probe.file);
-      if (existsSync4(path)) {
+      if (existsSync3(path)) {
         return { manager: probe.manager, detail: probe.file };
       }
     }
-    const parent = dirname3(dir);
+    const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -536,9 +430,9 @@ function detectFromLockfileWalkUp(startDir) {
 function readWorkspaceLinks(projectRoot) {
   const links = /* @__PURE__ */ new Set();
   const pkgPath = join3(projectRoot, "package.json");
-  if (!existsSync4(pkgPath)) return links;
+  if (!existsSync3(pkgPath)) return links;
   try {
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     for (const group of [pkg.dependencies, pkg.devDependencies, pkg.peerDependencies, pkg.optionalDependencies]) {
       if (!group) continue;
       for (const [name, spec] of Object.entries(group)) {
@@ -553,11 +447,11 @@ function readWorkspaceLinks(projectRoot) {
   }
 }
 function isWorkspaceRoot(projectRoot) {
-  if (existsSync4(join3(projectRoot, "pnpm-workspace.yaml"))) return true;
+  if (existsSync3(join3(projectRoot, "pnpm-workspace.yaml"))) return true;
   const pkgPath = join3(projectRoot, "package.json");
-  if (!existsSync4(pkgPath)) return false;
+  if (!existsSync3(pkgPath)) return false;
   try {
-    const pkg = JSON.parse(readFileSync3(pkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
     const ws = pkg.workspaces;
     if (Array.isArray(ws) && ws.length > 0) return true;
     if (ws && typeof ws === "object" && Array.isArray(ws.packages)) return true;
@@ -600,16 +494,16 @@ function buildInstallCommand(manager, packages, options = {}) {
 // src/core/install/run-package-manager.ts
 import { spawn } from "child_process";
 function runPackageManager(command, args, cwd) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     const child = process.platform === "win32" ? spawn([command, ...args].join(" "), { cwd, stdio: "inherit", shell: true }) : spawn(command, [...args], { cwd, stdio: "inherit", shell: false });
-    child.on("exit", (code) => resolve6(code ?? 0));
+    child.on("exit", (code) => resolve5(code ?? 0));
     child.on("error", (err) => reject(err));
   });
 }
 
 // src/core/detection/detect-java-runtime.ts
 import { spawnSync } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { join as join4 } from "path";
 function parseJavaMajor(output) {
   const m = output.match(/version "([^"]+)"/);
@@ -625,7 +519,7 @@ function detectJavaMajor() {
   }
   const home = process.env["CTXO_JAVA_HOME"] || process.env["JAVA_HOME"];
   const bin = home ? join4(home, "bin", process.platform === "win32" ? "java.exe" : "java") : "java";
-  if (home && !existsSync5(bin)) {
+  if (home && !existsSync4(bin)) {
     _javaMajorCache = null;
     return void 0;
   }
@@ -647,6 +541,23 @@ function javaRuntimeAvailable() {
 }
 
 // src/cli/install-command.ts
+var INSTALL_EXTRAS = { domain: DOMAIN_MODULE_PACKAGE };
+function resolveInstallTargets(raw) {
+  const languages = [];
+  const extras = [];
+  const unknown = [];
+  for (const name of raw) {
+    const extra = Object.hasOwn(INSTALL_EXTRAS, name.toLowerCase()) ? INSTALL_EXTRAS[name.toLowerCase()] : void 0;
+    if (extra !== void 0) {
+      if (!extras.includes(extra)) extras.push(extra);
+      continue;
+    }
+    const lang = normalizeLanguage(name);
+    if (lang === null) unknown.push(name);
+    else if (!languages.includes(lang)) languages.push(lang);
+  }
+  return { languages, extras, unknown };
+}
 function resolveJavaPackages(opts) {
   if (opts.fullTier && opts.syntaxOnly) throw new Error("Cannot combine --full-tier with --syntax-only.");
   const base = ["@ctxo/lang-java"];
@@ -657,8 +568,8 @@ function resolveJavaPackages(opts) {
 function buildPluginSpecifiers(languages, opts) {
   const out = [];
   const seen = /* @__PURE__ */ new Set();
-  const add = (pkg) => {
-    const spec = opts.version ? `${pkg}@${opts.version}` : pkg;
+  const add = (pkg, version = opts.version) => {
+    const spec = version ? `${pkg}@${version}` : pkg;
     if (seen.has(spec)) return;
     seen.add(spec);
     out.push(spec);
@@ -670,6 +581,7 @@ function buildPluginSpecifiers(languages, opts) {
       add(officialPluginFor(lang));
     }
   }
+  for (const pkg of opts.extras ?? []) add(pkg, opts.version ?? opts.cliVersion);
   return out;
 }
 var InstallCommand = class {
@@ -678,8 +590,9 @@ var InstallCommand = class {
   }
   projectRoot;
   async run(options = {}) {
-    const resolvedLangs = this.resolveLanguages(options);
-    if (resolvedLangs.length === 0) {
+    const { languages: resolvedLangs, extras } = this.resolveLanguages(options);
+    if (resolvedLangs.length === 0 && extras.length === 0) {
+      if (process.exitCode === 1) return;
       console.error('[ctxo] Nothing to install. Specify a language (e.g. "ctxo install python") or add one to your project.');
       process.exitCode = 0;
       return;
@@ -695,10 +608,10 @@ var InstallCommand = class {
       process.exitCode = 1;
       return;
     }
-    if (!options.global && !existsSync6(join5(this.projectRoot, "package.json"))) {
-      console.error("[ctxo] No package.json in the current project. Re-run with --global or create a package.json first.");
-      process.exitCode = 1;
-      return;
+    const noManifest = !options.global && !existsSync5(join5(this.projectRoot, "package.json"));
+    const installGlobal = (options.global ?? false) || noManifest;
+    if (noManifest) {
+      console.error("[ctxo] No package.json here: installing globally, so the MCP server, hooks and CLI share one copy.");
     }
     if (!options.force && !options.global && isLockedCI(process.env)) {
       console.error("[ctxo] CI environment detected with a frozen lockfile. Refusing to mutate dependencies. Use --force or switch to --global.");
@@ -715,7 +628,9 @@ var InstallCommand = class {
         jreAvailable,
         fullTier: options.fullTier,
         syntaxOnly: options.syntaxOnly,
-        version: options.version
+        version: options.version,
+        extras,
+        cliVersion: getVersion()
       });
     } catch (err) {
       console.error(`[ctxo] ${err.message}`);
@@ -723,15 +638,15 @@ var InstallCommand = class {
       return;
     }
     const invocation = buildInstallCommand(resolution.manager, specifiers, {
-      global: options.global,
-      workspaceRoot: !options.global && isWorkspaceRoot(this.projectRoot)
+      global: installGlobal,
+      workspaceRoot: !installGlobal && isWorkspaceRoot(this.projectRoot)
     });
     const plan = {
       languages: resolvedLangs,
       packages: specifiers,
       manager: resolution.manager,
       managerSource: resolution.source,
-      global: options.global ?? false,
+      global: installGlobal,
       command: invocation.command,
       args: [...invocation.args]
     };
@@ -753,30 +668,26 @@ var InstallCommand = class {
   resolveLanguages(options) {
     const requested = options.languages ?? [];
     if (requested.length > 0) {
-      const out = [];
-      for (const raw of requested) {
-        const lang = normalizeLanguage(raw);
-        if (!lang) {
-          console.error(
-            `[ctxo] Unknown language "${raw}". Known: ${KNOWN_LANGUAGES.join(", ")}. Community plugins: see the ctxo-lang-template scaffolding guide.`
-          );
-          process.exitCode = 1;
-          return [];
-        }
-        if (!out.includes(lang)) out.push(lang);
+      const { languages, extras, unknown } = resolveInstallTargets(requested);
+      if (unknown.length > 0) {
+        console.error(
+          `[ctxo] Unknown language "${unknown[0]}". Known: ${[...KNOWN_LANGUAGES, ...Object.keys(INSTALL_EXTRAS)].join(", ")}. Community plugins: see the ctxo-lang-template scaffolding guide.`
+        );
+        process.exitCode = 1;
+        return { languages: [], extras: [] };
       }
-      return out;
+      return { languages, extras };
     }
     const detection = detectLanguages(this.projectRoot);
     const needed = decideNeededLanguages(detection);
-    if (needed.length === 0) return [];
+    if (needed.length === 0) return { languages: [], extras: [] };
     const missing = needed.filter((lang) => !isPluginInstalled(lang));
     if (missing.length === 0) {
       console.error("[ctxo] All detected languages already have plugins installed.");
-      return [];
+      return { languages: [], extras: [] };
     }
     console.error(`[ctxo] Detected missing plugins for: ${missing.join(", ")}`);
-    return missing;
+    return { languages: missing, extras: [] };
   }
 };
 function normalizeLanguage(input) {
@@ -799,7 +710,7 @@ function normalizeLanguage(input) {
   };
   return aliases[lowered] ?? null;
 }
-var installRequire = createRequire2(import.meta.url);
+var installRequire = createRequire(import.meta.url);
 function isPluginInstalled(lang) {
   try {
     installRequire.resolve(`${officialPluginFor(lang)}/package.json`);
@@ -814,9 +725,9 @@ function isLockedCI(env) {
 }
 
 // src/cli/read-source.ts
-import { readFileSync as readFileSync4 } from "fs";
+import { readFileSync as readFileSync3 } from "fs";
 function readSourceText(absolutePath) {
-  const bytes = readFileSync4(absolutePath);
+  const bytes = readFileSync3(absolutePath);
   if (bytes.length >= 2) {
     const first = bytes[0];
     const second = bytes[1];
@@ -835,7 +746,7 @@ function decodeUtf16(bytes, bigEndian) {
 
 // src/cli/index-cochange.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { join as join6 } from "path";
 function changeLogSize(windowCommits, maxHistory) {
   return windowCommits === "all" ? "all" : Math.max(windowCommits, maxHistory * 50);
@@ -844,9 +755,7 @@ function writeCoChangeMatrix(options) {
   const { writer, projectRoot, commits, head, headCommittedAt, coChange, indexedFiles } = options;
   const isIncluded = coChangeFileFilter(projectRoot, indexedFiles, coChange);
   if (isIncluded === void 0) return;
-  const since = coChange.since !== void 0 ? parseCoChangeSince(coChange.since) : void 0;
-  const cutoff = since !== void 0 ? sinceCutoff(headCommittedAt, since) : void 0;
-  const windowed = selectWindow(commits, coChange.maxCommits, cutoff);
+  const windowed = selectWindow(commits, coChange.maxCommits, windowCutoff(coChange, headCommittedAt));
   const matrix = buildCoChangeMatrix(windowed, {
     isIncluded,
     maxCommits: coChange.maxCommits,
@@ -876,7 +785,7 @@ function coChangeFileFilter(projectRoot, indexedFiles, coChange) {
   const isExcluded = makeGlobMatcher([...coChange.exclude]);
   const present = /* @__PURE__ */ new Set();
   for (const path of candidates) {
-    if (!isExcluded(path) && existsSync7(join6(projectRoot, path))) present.add(path);
+    if (!isExcluded(path) && existsSync6(join6(projectRoot, path))) present.add(path);
   }
   return (path) => present.has(path);
 }
@@ -903,14 +812,14 @@ function describeCoChangeWindow(coChange, commitsScanned) {
 }
 
 // src/cli/index-contexts-view.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 import { join as join8 } from "path";
 
 // src/adapters/storage/architecture-artifacts-writer.ts
-import { existsSync as existsSync8, mkdirSync, readFileSync as readFileSync5 } from "fs";
-import { join as join7, resolve as resolve2 } from "path";
+import { existsSync as existsSync7, mkdirSync, readFileSync as readFileSync4 } from "fs";
+import { join as join7, resolve } from "path";
 import { tmpdir } from "os";
-var log3 = createLogger("ctxo:architecture-artifacts");
+var log2 = createLogger("ctxo:architecture-artifacts");
 var DRIFT_FILE_NAME = "drift-events.json";
 var VIOLATIONS_FILE_NAME = "boundary-violations.json";
 var CONTEXTS_VIEW_FILE_NAME = "contexts-view.json";
@@ -937,7 +846,7 @@ var ArchitectureArtifactsWriter = class {
     const path = join7(this.indexDir, CONTEXTS_VIEW_FILE_NAME);
     const content = JSON.stringify(view, null, 2);
     try {
-      if (readFileSync5(path, "utf-8") === content) return false;
+      if (readFileSync4(path, "utf-8") === content) return false;
     } catch {
     }
     mkdirSync(this.indexDir, { recursive: true });
@@ -946,28 +855,28 @@ var ArchitectureArtifactsWriter = class {
   }
   readDriftEvents() {
     const path = join7(this.indexDir, DRIFT_FILE_NAME);
-    if (!existsSync8(path)) return void 0;
+    if (!existsSync7(path)) return void 0;
     try {
-      return JSON.parse(readFileSync5(path, "utf-8"));
+      return JSON.parse(readFileSync4(path, "utf-8"));
     } catch (err) {
-      log3.warn(`failed to parse ${DRIFT_FILE_NAME}: ${err.message}`);
+      log2.warn(`failed to parse ${DRIFT_FILE_NAME}: ${err.message}`);
       return void 0;
     }
   }
   readBoundaryViolations() {
     const path = join7(this.indexDir, VIOLATIONS_FILE_NAME);
-    if (!existsSync8(path)) return void 0;
+    if (!existsSync7(path)) return void 0;
     try {
-      return JSON.parse(readFileSync5(path, "utf-8"));
+      return JSON.parse(readFileSync4(path, "utf-8"));
     } catch (err) {
-      log3.warn(`failed to parse ${VIOLATIONS_FILE_NAME}: ${err.message}`);
+      log2.warn(`failed to parse ${VIOLATIONS_FILE_NAME}: ${err.message}`);
       return void 0;
     }
   }
 };
 function assertSafeWritePath(ctxoRoot, allowProductionPath) {
-  const resolvedRoot = resolve2(ctxoRoot);
-  const resolvedTmp = resolve2(tmpdir());
+  const resolvedRoot = resolve(ctxoRoot);
+  const resolvedTmp = resolve(tmpdir());
   if (resolvedRoot.startsWith(resolvedTmp)) return;
   if (allowProductionPath) return;
   throw new Error(
@@ -1851,14 +1760,9 @@ function fileOfSymbol(symbolId) {
   const cut = symbolId.indexOf("::");
   return cut === -1 ? symbolId : symbolId.slice(0, cut);
 }
-function hasCSharpAnnotations(indices) {
-  return indices.some(
-    (index) => index.file.endsWith(".cs") && index.symbols.some((symbol) => symbol.annotations && symbol.annotations.length > 0)
-  );
-}
 function computeAndWriteContextsView(options) {
   const { projectRoot, ctxoRoot, config, indices, snapshot, symbolPageRank } = options;
-  const exists = options.exists ?? existsSync9;
+  const exists = options.exists ?? existsSync8;
   const settings = resolveContextsViewConfig(config);
   const isTest = createTestFileClassifier(indexTestPatterns(config), filesWithTestAnnotations(indices), {
     annotationAware: hasCSharpAnnotations(indices)
@@ -1913,8 +1817,8 @@ async function extractFileFacts(adapter, relativePath, source) {
 }
 
 // src/adapters/storage/json-index-writer.ts
-import { mkdirSync as mkdirSync2, unlinkSync, existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname4, join as join9, relative, resolve as resolve3, sep } from "path";
+import { mkdirSync as mkdirSync2, unlinkSync, existsSync as existsSync9, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname3, join as join9, relative, resolve as resolve2, sep } from "path";
 import { isDeepStrictEqual } from "util";
 var JsonIndexWriter = class {
   indexDir;
@@ -1926,7 +1830,7 @@ var JsonIndexWriter = class {
       throw new Error("FileIndex.file must not be empty");
     }
     const targetPath = this.resolveIndexPath(fileIndex.file);
-    mkdirSync2(dirname4(targetPath), { recursive: true });
+    mkdirSync2(dirname3(targetPath), { recursive: true });
     const sorted = this.sortKeys(fileIndex);
     const json = JSON.stringify(sorted, null, 2);
     this.atomicWrite(targetPath, json);
@@ -1945,9 +1849,9 @@ var JsonIndexWriter = class {
   }
   /** True when the file at `targetPath` parses and has the same `window` and `entries` as `matrix`. */
   holdsSameCoChanges(targetPath, matrix) {
-    if (!existsSync10(targetPath)) return false;
+    if (!existsSync9(targetPath)) return false;
     try {
-      const existing = JSON.parse(readFileSync6(targetPath, "utf-8"));
+      const existing = JSON.parse(readFileSync5(targetPath, "utf-8"));
       if (existing === null || typeof existing !== "object") return false;
       const { window, entries } = existing;
       return isDeepStrictEqual(window, matrix.window) && isDeepStrictEqual(entries, matrix.entries);
@@ -1960,7 +1864,7 @@ var JsonIndexWriter = class {
   }
   delete(relativePath) {
     const targetPath = this.resolveIndexPath(relativePath);
-    if (existsSync10(targetPath)) {
+    if (existsSync9(targetPath)) {
       unlinkSync(targetPath);
     }
   }
@@ -1970,11 +1874,12 @@ var JsonIndexWriter = class {
    * an artifact's included. Returns true when a file was deleted and false when there was none.
    *
    * Throws for a path outside the index folder, and for the artifacts that live there but are not entries
-   * (the co-change matrix, the community snapshot and its history, the architecture artifacts).
+   * (the co-change matrix, the community snapshot and its history, the architecture artifacts, and any JSON
+   * carrying the `ctxoArtifact` marker of a module artifact).
    */
   deleteEntryFile(jsonPath) {
-    const resolved = resolve3(jsonPath);
-    const indexDir = resolve3(this.indexDir);
+    const resolved = resolve2(jsonPath);
+    const indexDir = resolve2(this.indexDir);
     if (!resolved.startsWith(indexDir + sep)) {
       throw new Error(`Not inside the index folder: ${jsonPath}`);
     }
@@ -1982,13 +1887,33 @@ var JsonIndexWriter = class {
     if (INDEX_ARTIFACT_FILES.includes(inIndex) || inIndex.startsWith(`${COMMUNITY_HISTORY_DIR}/`)) {
       throw new Error(`Refusing to delete the index artifact ${inIndex}`);
     }
-    if (!existsSync10(resolved)) return false;
-    unlinkSync(resolved);
+    let text;
+    try {
+      text = readFileSync5(resolved, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") return false;
+      throw err;
+    }
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = void 0;
+    }
+    if (isMarkedArtifact(data)) {
+      throw new Error(`Refusing to delete the index artifact ${inIndex}`);
+    }
+    try {
+      unlinkSync(resolved);
+    } catch (err) {
+      if (err.code === "ENOENT") return false;
+      throw err;
+    }
     return true;
   }
   resolveIndexPath(relativePath) {
-    const resolved = resolve3(this.indexDir, `${relativePath}.json`);
-    const normalizedDir = resolve3(this.indexDir) + sep;
+    const resolved = resolve2(this.indexDir, `${relativePath}.json`);
+    const normalizedDir = resolve2(this.indexDir) + sep;
     if (!resolved.startsWith(normalizedDir)) {
       throw new Error(`Path traversal detected: ${relativePath}`);
     }
@@ -2010,8 +1935,8 @@ var JsonIndexWriter = class {
 };
 
 // src/adapters/storage/schema-manager.ts
-import { readFileSync as readFileSync7, writeFileSync, existsSync as existsSync11, mkdirSync as mkdirSync3 } from "fs";
-import { join as join10, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync6, writeFileSync, existsSync as existsSync10, mkdirSync as mkdirSync3 } from "fs";
+import { join as join10, dirname as dirname4 } from "path";
 var CURRENT_SCHEMA_VERSION = "1.0.0";
 var SchemaManager = class {
   versionFilePath;
@@ -2022,13 +1947,13 @@ var SchemaManager = class {
     return CURRENT_SCHEMA_VERSION;
   }
   readStoredVersion() {
-    if (!existsSync11(this.versionFilePath)) {
+    if (!existsSync10(this.versionFilePath)) {
       return void 0;
     }
-    return readFileSync7(this.versionFilePath, "utf-8").trim();
+    return readFileSync6(this.versionFilePath, "utf-8").trim();
   }
   writeVersion() {
-    mkdirSync3(dirname5(this.versionFilePath), { recursive: true });
+    mkdirSync3(dirname4(this.versionFilePath), { recursive: true });
     writeFileSync(this.versionFilePath, CURRENT_SCHEMA_VERSION, "utf-8");
   }
   isCompatible() {
@@ -2332,7 +2257,7 @@ var CommunityDetector = class {
 };
 
 // src/cli/index-command.ts
-var requireCjs = createRequire3(import.meta.url);
+var requireCjs = createRequire2(import.meta.url);
 var IndexCommand = class {
   projectRoot;
   ctxoRoot;
@@ -2370,8 +2295,10 @@ var IndexCommand = class {
     const gitAdapter = new SimpleGitAdapter(this.projectRoot);
     const incremental = options.files !== void 0 || options.commit !== void 0 || Boolean(options.file);
     const commitChanges = options.commit !== void 0 ? await readCommitChanges(gitAdapter, options.commit) : [];
+    const modules = options.modules ?? [];
+    const requestFacts = factsRequested(ignore.config) || modules.some((module) => module.registration.indexCapabilities?.facts === true);
     const registry = new LanguageAdapterRegistry();
-    const plugins = await this.registerDiscoveredPlugins(registry, ignore.ignoreProjectPatterns, factsRequested(ignore.config));
+    const plugins = await this.registerDiscoveredPlugins(registry, ignore.ignoreProjectPatterns, requestFacts);
     const { tsMorphLike, roslynAdapter, csharpComposite, goTier, javaTier } = plugins;
     const csharpTierAtLoad = plugins.csharpTier;
     let csharpTier = plugins.csharpTier;
@@ -2494,7 +2421,7 @@ var IndexCommand = class {
         console.error(`[ctxo] Edge extraction failed for ${entry.relativePath}: ${err.message}`);
       }
     }
-    if (factsRequested(ignore.config)) {
+    if (requestFacts) {
       for (const entry of pendingIndices) {
         const adapter = registry.getAdapter(entry.relativePath);
         if (!adapter) continue;
@@ -2529,6 +2456,7 @@ var IndexCommand = class {
         registry.getSupportedExtensions().size === 0 ? "[ctxo] No language plugin is loaded, so no file was indexed. Run `ctxo install` (or `ctxo index --install-missing`). communities.json, its history and the architecture artifacts were left as they are" : "[ctxo] No source file was indexed. communities.json, its history and the architecture artifacts were left as they are"
       );
     }
+    let phase2ChangeLog;
     if (!options.skipHistory && refreshCoChange) {
       try {
         const coChange = resolveCoChangeConfig(ignore.config, {
@@ -2537,6 +2465,7 @@ var IndexCommand = class {
         });
         const maxHistory = options.maxHistory ?? 20;
         const changeLog = await gitAdapter.getChangeLog(changeLogSize(coChange.maxCommits, maxHistory));
+        if (changeLog !== void 0) phase2ChangeLog = { changeLog, coChange };
         if (changeLog === void 0) {
           console.error("[ctxo] Git history unavailable: intent[] left empty and co-changes.json not updated");
         } else {
@@ -2569,7 +2498,7 @@ var IndexCommand = class {
     let communitySnapshot;
     let symbolPageRank;
     if (options.skipCommunity && refreshProducts) {
-      if (existsSync12(join11(this.ctxoRoot, "index", "communities.json"))) {
+      if (existsSync11(join11(this.ctxoRoot, "index", "communities.json"))) {
         console.error(
           `[ctxo] WARN stale communities.json present \u2014 --skip-community preserved existing snapshot. Run \`ctxo index\` (full) to refresh.`
         );
@@ -2646,6 +2575,9 @@ var IndexCommand = class {
         }
       }
     }
+    if (refreshProducts) {
+      await this.runModuleIndexPasses(modules, ignore.config, indexed, phase2ChangeLog);
+    }
     if (!options.skipSideEffects) {
       this.ensureGitignore();
     }
@@ -2664,6 +2596,49 @@ var IndexCommand = class {
     if (sqlCount > 0) console.error(`[ctxo]   SQL: ${sqlCount} files (syntax tier)`);
     if (roslynAdapter) await roslynAdapter.dispose();
   }
+  /**
+   * Phase 2e. Runs each module's `indexPass` on the merged index (the one the snapshot, the artifacts and
+   * the contexts view were built from), with a graph built on first use, the host's test-file check and,
+   * when Phase 2 read the change log, the raw commits of the co-change window (renames intact). Each pass
+   * is awaited in turn; one that throws is reported and the next one still runs.
+   */
+  async runModuleIndexPasses(modules, config, indices, phase2) {
+    const passes = modules.filter((module) => typeof module.registration.indexPass === "function");
+    if (passes.length === 0) return;
+    let ctx;
+    try {
+      const { createModuleHost } = await import("./module-host-KTGDODES.js");
+      const { services } = createModuleHost({ projectRoot: this.projectRoot, mode: "cli" });
+      let graph;
+      ctx = {
+        projectRoot: this.projectRoot,
+        ctxoRoot: this.ctxoRoot,
+        config,
+        indices,
+        graph: () => graph ??= services.buildGraph(indices),
+        isTestFile: services.createTestFileCheck(config, indices),
+        history: phase2 === void 0 ? void 0 : {
+          head: phase2.changeLog.head,
+          headCommittedAt: phase2.changeLog.headCommittedAt,
+          commits: selectWindow(
+            phase2.changeLog.commits,
+            phase2.coChange.maxCommits,
+            windowCutoff(phase2.coChange, phase2.changeLog.headCommittedAt)
+          )
+        }
+      };
+    } catch (err) {
+      console.error(`[ctxo] Module index passes skipped: ${err.message}`);
+      return;
+    }
+    for (const module of passes) {
+      try {
+        await module.registration.indexPass(ctx);
+      } catch (err) {
+        console.error(`[ctxo] ${module.name} index pass failed: ${err.message}`);
+      }
+    }
+  }
   async autoInstallMissingPlugins() {
     const detection = detectLanguages(this.projectRoot);
     const needed = decideNeededLanguages(detection);
@@ -2743,7 +2718,7 @@ var IndexCommand = class {
       return output.split("\0").filter((line) => line.length > 0).filter((line) => this.isSupportedExtension(line)).map((line) => join11(root, line)).filter((abs) => {
         const rel = relative2(this.projectRoot, abs).replace(/\\/g, "/");
         return !ignoreFile(rel);
-      }).filter((abs) => existsSync12(abs));
+      }).filter((abs) => existsSync11(abs));
     } catch {
       console.error(`[ctxo] git ls-files failed for ${root}`);
       return [];
@@ -2755,16 +2730,16 @@ var IndexCommand = class {
    */
   discoverWorkspaces(ignoreProject = () => false) {
     const pkgPath = join11(this.projectRoot, "package.json");
-    if (!existsSync12(pkgPath)) return { kept: [this.projectRoot], ignored: [] };
+    if (!existsSync11(pkgPath)) return { kept: [this.projectRoot], ignored: [] };
     try {
-      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
       const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
       if (!workspaces || workspaces.length === 0) return { kept: [this.projectRoot], ignored: [] };
       const resolved = [];
       for (const ws of workspaces) {
         if (ws.endsWith("/*") || ws.endsWith("\\*")) {
           const parentDir = join11(this.projectRoot, ws.slice(0, -2));
-          if (existsSync12(parentDir)) {
+          if (existsSync11(parentDir)) {
             for (const entry of readdirSync2(parentDir, { withFileTypes: true })) {
               if (entry.isDirectory()) {
                 resolved.push(join11(parentDir, entry.name));
@@ -2773,7 +2748,7 @@ var IndexCommand = class {
           }
         } else {
           const wsPath = join11(this.projectRoot, ws);
-          if (existsSync12(wsPath)) {
+          if (existsSync11(wsPath)) {
             resolved.push(wsPath);
           }
         }
@@ -2808,7 +2783,7 @@ var IndexCommand = class {
     if (_roslyn) await _roslyn.dispose();
     const hasher = new ContentHasher();
     const files = this.discoverFilesIn(this.projectRoot);
-    const reader = new (await import("./json-index-reader-OXTRTGE6.js")).JsonIndexReader(this.ctxoRoot);
+    const reader = new (await import("./json-index-reader-DKEIP2QR.js")).JsonIndexReader(this.ctxoRoot);
     const indices = reader.readAll();
     const indexedMap = new Map(indices.map((i) => [i.file, i]));
     let staleCount = 0;
@@ -2821,7 +2796,7 @@ var IndexCommand = class {
         staleCount++;
         continue;
       }
-      if (!existsSync12(filePath)) {
+      if (!existsSync11(filePath)) {
         console.error(`[ctxo] DELETED: ${relativePath}`);
         staleCount++;
         continue;
@@ -2853,7 +2828,7 @@ var IndexCommand = class {
 # Ctxo local cache (never committed)
 ${cachePattern}
 `;
-    const existing = existsSync12(gitignorePath) ? readFileSync8(gitignorePath, "utf-8") : "";
+    const existing = existsSync11(gitignorePath) ? readFileSync7(gitignorePath, "utf-8") : "";
     if (existing.includes(cachePattern)) return;
     writeFileSync2(gitignorePath, existing + suffix, "utf-8");
     console.error("[ctxo] Added .ctxo/.cache/ to .gitignore");
@@ -2900,7 +2875,7 @@ ${cachePattern}
     for (const path of [...candidates].sort(compareCodepoint)) {
       if (!isIndexable(path)) {
         if (listed.has(path)) skippedListed += 1;
-      } else if (existsSync12(join11(this.projectRoot, path))) {
+      } else if (existsSync11(join11(this.projectRoot, path))) {
         changed.push(path);
       } else {
         missing.push(path);
@@ -2953,7 +2928,7 @@ ${cachePattern}
    * have been committed by a machine that has the plugin, and the file is still there.
    */
   findStaleEntries(committed, reindexed, isIgnored) {
-    return committed.map((idx) => idx.file).filter((file) => !reindexed.has(file) && (!existsSync12(join11(this.projectRoot, file)) || isIgnored(file))).sort(compareCodepoint);
+    return committed.map((idx) => idx.file).filter((file) => !reindexed.has(file) && (!existsSync11(join11(this.projectRoot, file)) || isIgnored(file))).sort(compareCodepoint);
   }
   /**
    * Produce the FileIndex list used as input to community detection, the architecture artifacts and the
@@ -3127,13 +3102,13 @@ async function readCommitChanges(gitAdapter, rev) {
 function toRepoPath(projectRoot, input) {
   const trimmed = input.trim().replace(/\\/g, "/");
   if (trimmed === "") return void 0;
-  const relativePath = relative2(projectRoot, resolve4(projectRoot, trimmed));
-  if (relativePath === "" || isAbsolute2(relativePath) || relativePath.split(/[\\/]/)[0] === "..") return void 0;
+  const relativePath = relative2(projectRoot, resolve3(projectRoot, trimmed));
+  if (relativePath === "" || isAbsolute(relativePath) || relativePath.split(/[\\/]/)[0] === "..") return void 0;
   return relativePath.replace(/\\/g, "/");
 }
 function isInsideDirectory(directory, absolute) {
   const relativePath = relative2(directory, absolute);
-  return relativePath !== "" && !isAbsolute2(relativePath) && relativePath.split(/[\\/]/)[0] !== "..";
+  return relativePath !== "" && !isAbsolute(relativePath) && relativePath.split(/[\\/]/)[0] !== "..";
 }
 function countCommunities(snapshot) {
   const ids = /* @__PURE__ */ new Set();
@@ -3162,7 +3137,7 @@ var SyncCommand = class {
 
 // src/cli/status-command.ts
 import { join as join13 } from "path";
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { execFileSync as execFileSync4 } from "child_process";
 var StatusCommand = class {
   projectRoot;
@@ -3173,7 +3148,7 @@ var StatusCommand = class {
   }
   run() {
     const indexDir = join13(this.ctxoRoot, "index");
-    if (!existsSync13(indexDir)) {
+    if (!existsSync12(indexDir)) {
       console.error('[ctxo] No index found. Run "ctxo index" first.');
       return;
     }
@@ -3188,7 +3163,7 @@ var StatusCommand = class {
     console.error(`  Indexed files:  ${indices.length}`);
     console.error(`  Total symbols:  ${totalSymbols}`);
     console.error(`  Total edges:    ${totalEdges}`);
-    const cacheExists = existsSync13(join13(this.ctxoRoot, ".cache", "symbols.db"));
+    const cacheExists = existsSync12(join13(this.ctxoRoot, ".cache", "symbols.db"));
     console.error(`  SQLite cache:   ${cacheExists ? "present" : "missing (run ctxo sync)"}`);
     if (indices.length > 0) {
       console.error("");
@@ -3264,13 +3239,13 @@ var VerifyCommand = class {
 };
 
 // src/cli/init-command.ts
-import { isAbsolute as isAbsolute3, join as join17, relative as relative4 } from "path";
-import { existsSync as existsSync15, readFileSync as readFileSync10, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, chmodSync } from "fs";
-import { createRequire as createRequire4 } from "module";
+import { isAbsolute as isAbsolute2, join as join17, relative as relative4 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync9, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, chmodSync } from "fs";
+import { createRequire as createRequire3 } from "module";
 
 // src/cli/ai-rules.ts
-import { existsSync as existsSync14, readFileSync as readFileSync9, realpathSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, statSync as statSync2 } from "fs";
-import { join as join15, dirname as dirname6, relative as relative3, sep as sep2 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync8, realpathSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, statSync as statSync2 } from "fs";
+import { join as join15, dirname as dirname5, relative as relative3, sep as sep2 } from "path";
 
 // src/core/agent-rules/rules-block.ts
 var RULES_TEMPLATE_VERSION = "0.13";
@@ -3564,16 +3539,20 @@ function guardAndSkillsExpected(block) {
 // src/cli/ai-rules.ts
 var CTXO_HOOK_COMMAND = "ctxo gate-hook";
 var CLAUDE_SETTINGS_FILE = ".claude/settings.json";
-var UNREADABLE_SETTINGS_WARNING = `${CLAUDE_SETTINGS_FILE} is not valid JSON or not a settings object; left unchanged. Fix it, then run "ctxo init --only rules,skills,guard".`;
+var GUARD_RERUN_PARTS = "rules,skills,guard";
+function unreadableSettingsWarning(rerun) {
+  return `${CLAUDE_SETTINGS_FILE} is not valid JSON or not a settings object; left unchanged. Fix it, then run "ctxo init --only ${rerun}".`;
+}
 function isPlainObject(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function readSettings(path) {
-  if (!existsSync14(path)) return { kind: "missing" };
+var GUARD_PROBE = { event: "PreToolUse", command: CTXO_HOOK_COMMAND };
+function readSettings(path, probe = GUARD_PROBE) {
+  if (!existsSync13(path)) return { kind: "missing" };
   let json;
   let shape;
   try {
-    shape = textShape(readFileSync9(path, "utf-8"));
+    shape = textShape(readFileSync8(path, "utf-8"));
     json = JSON.parse(shape.text);
   } catch {
     return { kind: "unreadable" };
@@ -3581,19 +3560,19 @@ function readSettings(path) {
   if (!isPlainObject(json)) return { kind: "unreadable" };
   if (json.hooks === void 0) return { kind: "ok", json, hasHook: false, shape };
   if (!isPlainObject(json.hooks)) return { kind: "unreadable" };
-  const pre = json.hooks.PreToolUse;
-  if (pre === void 0) return { kind: "ok", json, hasHook: false, shape };
-  if (!Array.isArray(pre)) return { kind: "unreadable" };
-  const wellFormed = pre.filter(
+  const list = json.hooks[probe.event];
+  if (list === void 0) return { kind: "ok", json, hasHook: false, shape };
+  if (!Array.isArray(list)) return { kind: "unreadable" };
+  const wellFormed = list.filter(
     (entry) => isPlainObject(entry) && Array.isArray(entry.hooks)
   );
-  const hasHook = wellFormed.some((entry) => entry.hooks.some((h) => isPlainObject(h) && h.command === CTXO_HOOK_COMMAND));
-  if (!hasHook && wellFormed.length !== pre.length) return { kind: "unreadable" };
+  const hasHook = wellFormed.some((entry) => entry.hooks.some((h) => isPlainObject(h) && h.command === probe.command));
+  if (!hasHook && wellFormed.length !== list.length) return { kind: "unreadable" };
   return { kind: "ok", json, hasHook, shape };
 }
-function guardRegistration(projectRoot) {
-  const shared = readSettings(join15(projectRoot, ".claude", "settings.json"));
-  const local = readSettings(join15(projectRoot, ".claude", "settings.local.json"));
+function guardRegistration(projectRoot, probe = GUARD_PROBE) {
+  const shared = readSettings(join15(projectRoot, ".claude", "settings.json"), probe);
+  const local = readSettings(join15(projectRoot, ".claude", "settings.local.json"), probe);
   if (shared.kind === "ok" && shared.hasHook || local.kind === "ok" && local.hasHook) {
     return { shared, state: "present" };
   }
@@ -3606,7 +3585,7 @@ function platformRulesState(projectRoot, platform) {
   const path = join15(projectRoot, platform.file);
   let text;
   try {
-    text = readFileSync9(path, "utf-8");
+    text = readFileSync8(path, "utf-8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT" || code === "EISDIR") return void 0;
@@ -3639,11 +3618,11 @@ function sameFileOnDisk(a, b) {
 function linkedRulesPlatforms(projectRoot, platformId) {
   const platform = PLATFORMS.find((p) => p.id === platformId);
   const path = platform ? join15(projectRoot, platform.file) : void 0;
-  if (!path || !existsSync14(path)) return [];
+  if (!path || !existsSync13(path)) return [];
   return PLATFORMS.filter((other) => {
     if (other.id === platformId) return false;
     const otherPath = join15(projectRoot, other.file);
-    return existsSync14(otherPath) && sameFileOnDisk(path, otherPath);
+    return existsSync13(otherPath) && sameFileOnDisk(path, otherPath);
   }).map((other) => other.id);
 }
 function firstRulesBlock(projectRoot, platformId) {
@@ -3706,23 +3685,29 @@ function rulesFileHoldReasons(projectRoot, platformId, optionsFor = () => ({}))
   return void 0;
 }
 function ensureClaudeHook(projectRoot, options = {}) {
+  return ensureClaudeHookEntry(projectRoot, { event: "PreToolUse", matcher: "Edit", command: CTXO_HOOK_COMMAND }, options);
+}
+function ensureClaudeHookEntry(projectRoot, entry, options = {}) {
   const filePath = join15(projectRoot, ".claude", "settings.json");
-  const ctxoEntry = { matcher: "Edit", hooks: [{ type: "command", command: CTXO_HOOK_COMMAND }] };
-  const { shared, state } = guardRegistration(projectRoot);
+  const hookEntry = {
+    ...entry.matcher !== void 0 ? { matcher: entry.matcher } : {},
+    hooks: [{ type: "command", command: entry.command }]
+  };
+  const { shared, state } = guardRegistration(projectRoot, { event: entry.event, command: entry.command });
   if (state === "present") return { file: CLAUDE_SETTINGS_FILE, action: "skipped" };
   if (shared.kind === "unreadable") {
-    return { file: CLAUDE_SETTINGS_FILE, action: "skipped", warning: UNREADABLE_SETTINGS_WARNING };
+    return { file: CLAUDE_SETTINGS_FILE, action: "skipped", warning: unreadableSettingsWarning(options.rerun ?? GUARD_RERUN_PARTS) };
   }
   if (shared.kind === "missing") {
     if (!options.dryRun) {
-      mkdirSync4(dirname6(filePath), { recursive: true });
-      writeFileSync3(filePath, JSON.stringify({ hooks: { PreToolUse: [ctxoEntry] } }, null, 2) + "\n", "utf-8");
+      mkdirSync4(dirname5(filePath), { recursive: true });
+      writeFileSync3(filePath, JSON.stringify({ hooks: { [entry.event]: [hookEntry] } }, null, 2) + "\n", "utf-8");
     }
     return { file: CLAUDE_SETTINGS_FILE, action: "created" };
   }
   const hooks = isPlainObject(shared.json.hooks) ? shared.json.hooks : {};
-  const pre = Array.isArray(hooks.PreToolUse) ? hooks.PreToolUse : [];
-  const updated = { ...shared.json, hooks: { ...hooks, PreToolUse: [...pre, ctxoEntry] } };
+  const list = Array.isArray(hooks[entry.event]) ? hooks[entry.event] : [];
+  const updated = { ...shared.json, hooks: { ...hooks, [entry.event]: [...list, hookEntry] } };
   const body = JSON.stringify(updated, null, 2) + "\n";
   if (!options.dryRun) writeFileSync3(filePath, shared.shape.restore(body), "utf-8");
   return { file: CLAUDE_SETTINGS_FILE, action: "updated" };
@@ -3752,7 +3737,7 @@ var PLATFORMS = [
 function detectPlatforms(projectRoot) {
   const detected = /* @__PURE__ */ new Set();
   for (const p of PLATFORMS) {
-    if (p.detectPaths.some((d) => existsSync14(join15(projectRoot, d)))) {
+    if (p.detectPaths.some((d) => existsSync13(join15(projectRoot, d)))) {
       detected.add(p.id);
     }
   }
@@ -3785,7 +3770,7 @@ function installRules(projectRoot, platformId, options = {}) {
   const { result, content } = planRules(projectRoot, platformId, { tier: options.tier });
   if (!options.dryRun && result.action !== "skipped" && content !== void 0) {
     const filePath = join15(projectRoot, result.file);
-    if (result.action === "created") mkdirSync4(dirname6(filePath), { recursive: true });
+    if (result.action === "created") mkdirSync4(dirname5(filePath), { recursive: true });
     writeFileSync3(filePath, content, "utf-8");
   }
   return result;
@@ -3798,9 +3783,9 @@ function planRules(projectRoot, platformId, options = {}) {
   const filePath = join15(projectRoot, file);
   let existing = options.existing;
   if (existing === void 0) {
-    if (!existsSync14(filePath)) return { result: { file, action: "created" }, content: generateRules(platformId, tier) };
+    if (!existsSync13(filePath)) return { result: { file, action: "created" }, content: generateRules(platformId, tier) };
     try {
-      existing = readFileSync9(filePath, "utf-8");
+      existing = readFileSync8(filePath, "utf-8");
     } catch (err) {
       return { result: { file, action: "skipped", warning: unreadableWarning(file, err) } };
     }
@@ -3844,7 +3829,7 @@ function skillsSourceDir() {
   let dir = import.meta.dirname;
   for (let i = 0; i < 10; i++) {
     const candidate = join15(dir, "skills");
-    if (existsSync14(join15(candidate, "ctxo-safe-edit", "SKILL.md"))) return candidate;
+    if (existsSync13(join15(candidate, "ctxo-safe-edit", "SKILL.md"))) return candidate;
     const parent = join15(dir, "..");
     if (parent === dir) break;
     dir = parent;
@@ -3856,13 +3841,13 @@ function skillPlan(projectRoot, platformId) {
   if (!target) return [];
   const src = skillsSourceDir();
   return SKILLS.map((skill) => {
-    const bundled = readFileSync9(join15(src, skill, "SKILL.md"), "utf-8");
+    const bundled = readFileSync8(join15(src, skill, "SKILL.md"), "utf-8");
     const to = target(projectRoot, skill);
     const file = relative3(projectRoot, to).split(sep2).join("/");
-    if (!existsSync14(to)) return { skill, file, state: "missing", bundled, to };
+    if (!existsSync13(to)) return { skill, file, state: "missing", bundled, to };
     let installed;
     try {
-      installed = readFileSync9(to, "utf-8");
+      installed = readFileSync8(to, "utf-8");
     } catch (err) {
       return { skill, file, state: "missing", bundled, to, blocked: unreadableWarning(file, err) };
     }
@@ -3878,18 +3863,37 @@ function skillStates(projectRoot, platformId) {
   return skillPlan(projectRoot, platformId).map(({ skill, file, state }) => ({ skill, file, state }));
 }
 function installSkills(projectRoot, platformId, options = {}) {
-  return skillPlan(projectRoot, platformId).map(({ file, state, bundled, to, version, blocked }) => {
-    if (blocked !== void 0) return { file, action: "skipped", warning: blocked };
-    if (state === "current") return { file, action: "skipped" };
-    if (state === "newer") {
-      return { file, action: "skipped", warning: `${file}: skill v${version ?? ""} comes from a newer ctxo; left unchanged` };
+  if (!skillTarget(platformId)) return [];
+  const src = skillsSourceDir();
+  const bundled = SKILLS.map((skill) => ({ skill, content: readFileSync8(join15(src, skill, "SKILL.md"), "utf-8") }));
+  return bundled.map(({ skill, content }) => installSkillContent(projectRoot, platformId, skill, content, options));
+}
+function installSkillContent(projectRoot, platformId, name, content, options = {}) {
+  const target = skillTarget(platformId);
+  if (!target) return void 0;
+  const to = target(projectRoot, name);
+  const file = relative3(projectRoot, to).split(sep2).join("/");
+  let installed;
+  try {
+    installed = readFileSync8(to, "utf-8");
+  } catch (err) {
+    if (err.code !== "ENOENT") {
+      return { file, action: "skipped", warning: unreadableWarning(file, err) };
     }
-    if (!options.dryRun) {
-      mkdirSync4(dirname6(to), { recursive: true });
-      writeFileSync3(to, bundled, "utf-8");
+  }
+  if (installed !== void 0) {
+    const version = skillTemplateVersion(installed);
+    const ours = skillTemplateVersion(content);
+    if (version !== void 0 && ours !== void 0 && compareTemplateVersions(version, ours) > 0) {
+      return { file, action: "skipped", warning: `${file}: skill v${version} comes from a newer ctxo; left unchanged` };
     }
-    return { file, action: state === "missing" ? "created" : "updated" };
-  });
+    if (comparableMarkdown(installed) === comparableMarkdown(content)) return { file, action: "skipped" };
+  }
+  if (!options.dryRun) {
+    mkdirSync4(dirname5(to), { recursive: true });
+    writeFileSync3(to, content, "utf-8");
+  }
+  return { file, action: installed === void 0 ? "created" : "updated" };
 }
 function skillInstallWarnings(projectRoot, platformId, results) {
   const newer = new Set(skillStates(projectRoot, platformId).filter((s) => s.state === "newer").map((s) => s.file));
@@ -3905,7 +3909,7 @@ function skillInstallWarnings(projectRoot, platformId, results) {
 var GITIGNORE_ENTRY = ".ctxo/.cache/";
 function ensureIndexDir(projectRoot, options = {}) {
   const dir = join15(projectRoot, ".ctxo", "index");
-  if (existsSync14(dir)) return { file: ".ctxo/index/", action: "skipped" };
+  if (existsSync13(dir)) return { file: ".ctxo/index/", action: "skipped" };
   if (!options.dryRun) mkdirSync4(dir, { recursive: true });
   return { file: ".ctxo/index/", action: "created" };
 }
@@ -3913,7 +3917,7 @@ function ensureGitignore(projectRoot, options = {}) {
   const filePath = join15(projectRoot, ".gitignore");
   let existing;
   try {
-    existing = readFileSync9(filePath, "utf-8");
+    existing = readFileSync8(filePath, "utf-8");
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
     if (!options.dryRun) {
@@ -3970,9 +3974,9 @@ function ensureConfig(projectRoot, options = {}) {
   const filePath = join15(projectRoot, ".ctxo", "config.yaml");
   const file = ".ctxo/config.yaml";
   if (options.dryRun) {
-    return { file, action: existsSync14(filePath) ? "skipped" : "created" };
+    return { file, action: existsSync13(filePath) ? "skipped" : "created" };
   }
-  mkdirSync4(dirname6(filePath), { recursive: true });
+  mkdirSync4(dirname5(filePath), { recursive: true });
   try {
     writeFileSync3(filePath, DEFAULT_CONFIG, { encoding: "utf-8", flag: "wx" });
   } catch (err) {
@@ -3981,7 +3985,15 @@ function ensureConfig(projectRoot, options = {}) {
   }
   return { file, action: "created" };
 }
-var CTXO_MCP_ENTRY = { command: "npx", args: ["-y", "@ctxo/cli"] };
+var NPX_MCP_ENTRY = { command: "npx", args: ["-y", "@ctxo/cli"] };
+function ctxoMcpEntry(kind) {
+  return kind === "global" ? { command: "ctxo", args: [] } : { command: NPX_MCP_ENTRY.command, args: [...NPX_MCP_ENTRY.args] };
+}
+function isNpxDefaultEntry(entry) {
+  if (!isPlainObject(entry) || entry["command"] !== NPX_MCP_ENTRY.command) return false;
+  const args = entry["args"];
+  return Array.isArray(args) && args.length === NPX_MCP_ENTRY.args.length && args.every((a, i) => a === NPX_MCP_ENTRY.args[i]);
+}
 function getMcpConfigTargets(selectedPlatformIds) {
   const targets = /* @__PURE__ */ new Map();
   for (const id of selectedPlatformIds) {
@@ -4013,18 +4025,20 @@ function ensureMcpConfig(projectRoot, target, options = {}) {
   const filePath = join15(projectRoot, target.file);
   const write = (config) => {
     if (options.dryRun) return;
-    mkdirSync4(dirname6(filePath), { recursive: true });
+    mkdirSync4(dirname5(filePath), { recursive: true });
     writeFileSync3(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
   };
-  const entry = target.extraFields ? { ...target.extraFields, ...CTXO_MCP_ENTRY } : { ...CTXO_MCP_ENTRY };
+  const kind = options.installKind ?? "project";
+  const base = ctxoMcpEntry(kind);
+  const entry = target.extraFields ? { ...target.extraFields, ...base } : { ...base };
   const fresh = () => ({ [target.serverKey]: { ctxo: entry } });
-  if (!existsSync14(filePath)) {
+  if (!existsSync13(filePath)) {
     write(fresh());
     return { file: target.file, action: "created" };
   }
   let text;
   try {
-    text = readFileSync9(filePath, "utf-8");
+    text = readFileSync8(filePath, "utf-8");
   } catch (err) {
     return { file: target.file, action: "skipped", warning: unreadableWarning(target.file, err) };
   }
@@ -4040,15 +4054,103 @@ function ensureMcpConfig(projectRoot, target, options = {}) {
     return { file: target.file, action: "updated" };
   }
   if (servers["ctxo"]) {
+    if (kind === "global" && isNpxDefaultEntry(servers["ctxo"])) {
+      write({ ...parsed, [target.serverKey]: { ...servers, ctxo: { ...servers["ctxo"], ...entry } } });
+      return { file: target.file, action: "updated" };
+    }
     return { file: target.file, action: "skipped" };
   }
   write({ ...parsed, [target.serverKey]: { ...servers, ctxo: entry } });
   return { file: target.file, action: "updated" };
 }
 
+// src/core/install/install-kind.ts
+function normalizePath(path, platform) {
+  const slashed = path.replace(/\\/g, "/").replace(/\/+$/, "");
+  return platform === "win32" ? slashed.toLowerCase() : slashed;
+}
+var RUNNER_CACHE = /\/(_npx|dlx)\/|\/bunx-[^/]*\/|\/\.bun\/install\/cache\//;
+function cliInstallKind(cliPackageRoot, projectRoot, platform = process.platform) {
+  const cli = normalizePath(cliPackageRoot, platform);
+  if (RUNNER_CACHE.test(`${cli}/`)) return "npx";
+  const marker = "/node_modules/";
+  const at = cli.indexOf(marker);
+  if (at >= 0) {
+    const owner = cli.slice(0, at);
+    const project = normalizePath(projectRoot, platform);
+    if (project === owner || project.startsWith(`${owner}/`)) return "project";
+  }
+  return "global";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function commandName(command) {
+  const base = command.replace(/\\/g, "/").split("/").pop() ?? command;
+  return base.toLowerCase().replace(/\.(cmd|exe|bat)$/, "");
+}
+var CTXO_SPEC = /^@ctxo\/cli(@|$)/;
+function launcherOfCommand(command, args) {
+  const name = commandName(command);
+  if (name === "npx") return args.some((a) => CTXO_SPEC.test(a)) ? "npx" : "other";
+  if (name === "ctxo") return "path-binary";
+  return "other";
+}
+function innerCommand(entry) {
+  if (!isRecord(entry) || typeof entry["command"] !== "string") return void 0;
+  const args = Array.isArray(entry["args"]) ? entry["args"].filter((a) => typeof a === "string") : [];
+  if (commandName(entry["command"]) === "cmd") {
+    const run2 = args.findIndex((a) => a.toLowerCase() === "/c");
+    const inner = run2 >= 0 ? args[run2 + 1] : void 0;
+    return inner === void 0 ? { command: "cmd", args: [] } : { command: inner, args: args.slice(run2 + 2) };
+  }
+  return { command: entry["command"], args };
+}
+function mcpLauncherOf(entry) {
+  const inner = innerCommand(entry);
+  return inner === void 0 ? void 0 : launcherOfCommand(inner.command, inner.args);
+}
+function mcpNpxPin(entry) {
+  const inner = innerCommand(entry);
+  if (inner === void 0 || launcherOfCommand(inner.command, inner.args) !== "npx") return void 0;
+  const spec = inner.args.find((a) => CTXO_SPEC.test(a));
+  const version = spec?.startsWith("@ctxo/cli@") ? spec.slice("@ctxo/cli@".length) : "";
+  return version !== "" && version !== "latest" ? version : void 0;
+}
+function assessInstallCopies(facts) {
+  if (facts.hooksCallCtxo && !facts.ctxoOnPath) {
+    return {
+      status: "warn",
+      message: 'hooks call "ctxo" but no ctxo is on PATH, so they never run',
+      fix: 'Install @ctxo/cli globally ("npm i -g @ctxo/cli")'
+    };
+  }
+  if (facts.hooksCallCtxo && facts.launchers.includes("npx")) {
+    const global = facts.globalCliVersion;
+    const differing = global === void 0 ? void 0 : (facts.npxPins ?? []).find((pin) => pin !== global);
+    if (differing !== void 0) {
+      const start = `MCP starts "npx -y @ctxo/cli@${differing}" while hooks run "ctxo" ${global} from PATH: two copies`;
+      return facts.domainInstalled === true ? {
+        status: "warn",
+        message: `${start}, and @ctxo/domain installed in one is missing from the other`,
+        fix: 'Install once globally ("npm i -g @ctxo/cli @ctxo/domain"), then run "ctxo init --only mcp" from that install'
+      } : {
+        status: "warn",
+        message: `${start}, so a package installed next to one is not seen by the other`,
+        fix: 'Install once globally ("npm i -g @ctxo/cli"), then run "ctxo init --only mcp" from that install'
+      };
+    }
+    return { status: "pass", message: "one copy: MCP and hooks run ctxo from PATH" };
+  }
+  if (facts.hooksCallCtxo && facts.launchers.includes("path-binary")) {
+    return { status: "pass", message: "one copy: MCP and hooks run ctxo from PATH" };
+  }
+  return { status: "pass", message: "nothing to compare (no ctxo hooks or no MCP entry)" };
+}
+
 // src/cli/git-hooks.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { join as join16, resolve as resolve5 } from "path";
+import { join as join16, resolve as resolve4 } from "path";
 var CTXO_START = "# ctxo-start";
 var CTXO_END = "# ctxo-end";
 var POST_COMMIT_HOOK_VERSION = 2;
@@ -4107,7 +4209,7 @@ function resolveHooksDir(projectRoot) {
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"]
     }).trim();
-    return answer ? resolve5(projectRoot, answer) : fallback;
+    return answer ? resolve4(projectRoot, answer) : fallback;
   } catch {
     return fallback;
   }
@@ -4147,7 +4249,8 @@ function sharedHooksWarning(hooksDir, scope) {
 }
 
 // src/cli/init-parts.ts
-var INIT_PARTS = ["rules", "skills", "guard", "mcp", "git-hooks", "config"];
+var INIT_PARTS = ["rules", "skills", "guard", "mcp", "git-hooks", "config", "domain"];
+var OPT_IN_PARTS = /* @__PURE__ */ new Set(["domain"]);
 function isInitPart(value) {
   return INIT_PARTS.includes(value);
 }
@@ -4172,7 +4275,9 @@ function resolveInitParts(flags) {
   return new Set(
     INIT_PARTS.filter((part) => {
       if (flags.noGuard && part === "guard") return false;
-      return flags.only !== void 0 ? flags.only.includes(part) : !removed.has(part);
+      if (part === "domain" && flags.domain && !removed.has(part)) return true;
+      if (flags.only !== void 0) return flags.only.includes(part);
+      return !OPT_IN_PARTS.has(part) && !removed.has(part);
     })
   );
 }
@@ -4181,7 +4286,19 @@ function pluginStepEnabled(flags) {
 }
 
 // src/cli/init-command.ts
-var requireCjs2 = createRequire4(import.meta.url);
+var requireCjs2 = createRequire3(import.meta.url);
+function projectDeclaresCtxoCli(root) {
+  try {
+    const pkg = JSON.parse(readFileSync9(join17(root, "package.json"), "utf-8"));
+    if (typeof pkg !== "object" || pkg === null) return false;
+    return ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some((field) => {
+      const deps = pkg[field];
+      return typeof deps === "object" && deps !== null && "@ctxo/cli" in deps;
+    });
+  } catch {
+    return false;
+  }
+}
 function resolveInstalledPlugins(needed) {
   const installed = [];
   const missing = [];
@@ -4250,6 +4367,54 @@ function renderBanner(_version, pc) {
 var RULES_DEPRECATION_NOTICE = "[ctxo] --rules is deprecated and now means --skip git-hooks,guard. Use --only or --skip instead.";
 var NOTHING_TO_INSTALL_NOTICE = "[ctxo] Nothing to install: every part is excluded.";
 var SHARED_HOOKS_SKIPPED = "git hooks skipped - shared hooks directory (see warning above)";
+var DOMAIN_PACKAGE_ROW = "@ctxo/domain (package)";
+var DOMAIN_MISSING_WARNING = '@ctxo/domain is not installed; run "ctxo install domain", then "ctxo init --only domain"';
+var BOUNDARY_QUESTION = "Boundary violations between named contexts";
+var BOUNDARY_CHOICES = [
+  { value: "by-rung", label: "by-rung: fail verify-domain for bounded and boring contexts, warn for the others" },
+  { value: "report", label: "report: warnings only" }
+];
+var INITIAL_ANSWERS = {
+  confirm: async (_message, initial) => initial,
+  select: async (_message, _options, initial) => initial
+};
+function nonInteractiveDomainRun(options, toolIds) {
+  return {
+    interactive: false,
+    yes: options.yes === true,
+    noInstall: options.noInstall === true,
+    ...options.boundaries !== void 0 ? { boundaries: options.boundaries } : {},
+    prompter: INITIAL_ANSWERS,
+    toolIds
+  };
+}
+function clackPrompter(clack, pc) {
+  const answered = (value) => {
+    if (clack.isCancel(value)) {
+      clack.cancel("Setup cancelled.");
+      process.exit(0);
+    }
+    return value;
+  };
+  return {
+    async confirm(message, initial) {
+      return answered(await clack.confirm({ message: pc.cyan(message), initialValue: initial })) === true;
+    },
+    async select(message, options, initial) {
+      const choices = options.map((option) => ({ value: option.value, label: option.label }));
+      const picked = await clack.select({ message: pc.cyan(message), options: choices, initialValue: initial });
+      return answered(picked);
+    }
+  };
+}
+function configuredBoundaryMode(projectRoot) {
+  const domain = loadConfig(join17(projectRoot, ".ctxo")).config["domain"];
+  if (typeof domain !== "object" || domain === null) return void 0;
+  const boundaries = domain["boundaries"];
+  if (typeof boundaries !== "object" || boundaries === null) return void 0;
+  const enforce = boundaries["enforce"];
+  return enforce === "by-rung" || enforce === "report" ? enforce : void 0;
+}
 var TOOL_PARTS = ["rules", "skills", "guard", "mcp"];
 function selectedTools(options) {
   return options.tools ? [...new Set(options.tools)] : PLATFORMS.map((p) => p.id);
@@ -4295,12 +4460,16 @@ var GIT_HOOKS = [
 ];
 function displayPath(projectRoot, path) {
   const rel = forwardSlashes(relative4(projectRoot, path));
-  return rel === "" || rel.startsWith("..") || isAbsolute3(rel) ? forwardSlashes(path) : rel;
+  return rel === "" || rel.startsWith("..") || isAbsolute2(rel) ? forwardSlashes(path) : rel;
 }
 var InitCommand = class {
   projectRoot;
-  constructor(projectRoot) {
+  cliAnchor;
+  /** Set when the domain part could not run (missing package, failed init); `run` then ends with exit code 1. */
+  domainFailed = false;
+  constructor(projectRoot, options = {}) {
     this.projectRoot = projectRoot;
+    this.cliAnchor = options.cliAnchor;
   }
   /**
    * Installs (or upgrades in place) the post-commit and post-merge blocks in the hooks directory
@@ -4324,13 +4493,15 @@ var InitCommand = class {
   }
   /**
    * What init would do with these options, one row per file, writing nothing: the same pipeline as a
-   * real run over the parts the flags select. Without `tools` it previews every platform (D16).
+   * real run over the parts the flags select. Without `tools` it previews every platform (D16), the
+   * domain part included (PF11). Without @ctxo/domain the domain part is the row `@ctxo/domain (package)`.
    */
-  plan(options = {}) {
-    return this.applyParts(resolveInitParts(options), selectedTools(options), true, declinedBy(options));
+  async plan(options = {}) {
+    const toolIds = selectedTools(options);
+    return this.applyParts(resolveInitParts(options), toolIds, true, declinedBy(options), nonInteractiveDomainRun(options, toolIds));
   }
   async run(options = {}) {
-    if (!existsSync15(join17(this.projectRoot, ".git"))) {
+    if (!existsSync14(join17(this.projectRoot, ".git"))) {
       console.error('[ctxo] Not a git repository. Run "git init" first.');
       process.exit(1);
     }
@@ -4340,23 +4511,25 @@ var InitCommand = class {
       console.error(NOTHING_TO_INSTALL_NOTICE);
       return;
     }
-    if (options.dryRun) return this.dryRun(options);
-    if (options.yes || options.tools) return await this.runNonInteractive(options, parts);
-    return this.runInteractive(options, parts);
+    if (options.dryRun) await this.dryRun(options);
+    else if (options.yes || options.tools) await this.runNonInteractive(options, parts);
+    else await this.runInteractive(options, parts);
+    if (this.domainFailed) process.exitCode = 1;
   }
   /* ---------------------------------------------------------------- */
   /*  The parts pipeline                                               */
   /* ---------------------------------------------------------------- */
   /**
-   * Installs the selected parts in one fixed order: config, skills, guard, rules, MCP, git hooks.
+   * Installs the selected parts in one fixed order: config, skills, guard, rules, MCP, git hooks, domain.
    * Skills and the guard go first so each platform's rules tier is resolved from what is on disk after
    * them, and so `rulesHold` can see whether a block that expects them must wait (for a file under
    * any of its linked names, `rulesFileHoldReasons`). A part not in the
    * set adds no row. Bundled skills that cannot be read become a warning row, and the other parts
    * still run. `dryRun` gives the same rows and writes nothing; the rules tier and the hold then count
    * the skills and guard it would install as present. `declined` is what the user declined in this run.
+   * `domain` says how the domain part (step 7, `applyDomain`) installs @ctxo/domain and asks its questions.
    */
-  applyParts(parts, toolIds, dryRun, declined) {
+  async applyParts(parts, toolIds, dryRun, declined, domain) {
     const root = this.projectRoot;
     const write = { dryRun };
     const results = [];
@@ -4408,7 +4581,9 @@ var InitCommand = class {
       }
     }
     if (parts.has("mcp")) {
-      for (const target of getMcpConfigTargets([...toolIds])) results.push(ensureMcpConfig(root, target, write));
+      const detected = cliInstallKind(getCliPackageRoot(), root);
+      const installKind = detected === "global" && projectDeclaresCtxoCli(root) ? "project" : detected;
+      for (const target of getMcpConfigTargets([...toolIds])) results.push(ensureMcpConfig(root, target, { ...write, installKind }));
     }
     if (parts.has("git-hooks")) {
       const hooks = this.installHooks(write);
@@ -4417,8 +4592,81 @@ var InitCommand = class {
         results.push({ file: displayPath(root, hooks.hooksDir), action: "skipped", warning: SHARED_HOOKS_SKIPPED });
       }
     }
+    if (parts.has("domain")) {
+      domain.pause?.();
+      try {
+        results.push(...await this.applyDomain(dryRun, domain));
+      } finally {
+        domain.resume?.();
+      }
+    }
     return results;
   }
+  /**
+   * Step 7, the domain part. Without @ctxo/domain's init contribution: a dry run gives the row
+   * `@ctxo/domain (package)`; `--no-install`, a non-interactive run without `--yes` or a declined install
+   * question give the missing-package warning (all but the declined question fail the run); otherwise
+   * @ctxo/domain is installed (`ctxo install domain`) and loaded again. Then the contribution's `apply` runs
+   * with the domain tools, the run's prompter, `ensureConfig` and the two writers of `ai-rules.ts`.
+   */
+  async applyDomain(dryRun, run2) {
+    const missing = { file: "@ctxo/domain", action: "skipped", warning: DOMAIN_MISSING_WARNING };
+    let init = await this.loadDomainInit(false);
+    if (init === void 0) {
+      if (dryRun) return [{ file: DOMAIN_PACKAGE_ROW, action: "created" }];
+      const declined = run2.interactive && run2.installApproved === false;
+      const allowed = !run2.noInstall && (run2.interactive ? run2.installApproved === true : run2.yes);
+      if (!allowed) {
+        if (!declined) this.domainFailed = true;
+        return [missing];
+      }
+      await new InstallCommand(this.projectRoot).run({ languages: ["domain"], yes: true });
+      init = await this.loadDomainInit(true);
+      if (init === void 0) {
+        this.domainFailed = true;
+        return [missing];
+      }
+    }
+    const root = this.projectRoot;
+    const write = { dryRun };
+    const ctx = {
+      projectRoot: root,
+      toolIds: run2.toolIds,
+      dryRun,
+      yes: run2.yes,
+      ...run2.boundaries !== void 0 ? { boundaries: run2.boundaries } : {},
+      prompt: run2.prompter,
+      ensureConfigFile: () => ensureConfig(root, write),
+      ensureClaudeHookEntry: (entry) => ensureClaudeHookEntry(root, entry, { ...write, rerun: "domain" }),
+      installSkill: (platformId, name, content) => installSkillContent(root, platformId, name, content, write)
+    };
+    try {
+      return [...await init.apply(ctx)];
+    } catch (err) {
+      this.domainFailed = true;
+      return [{ file: "@ctxo/domain", action: "skipped", warning: `@ctxo/domain init failed: ${err.message}` }];
+    }
+  }
+  /**
+   * @ctxo/domain's init contribution, or undefined when the package is not installed, does not load
+   * (version mismatch, load failure: the loader warns) or has no `init`. `refresh` looks again after an install.
+   */
+  async loadDomainInit(refresh) {
+    try {
+      const [{ DOMAIN_MODULE_PACKAGE: DOMAIN_MODULE_PACKAGE2, loadCtxoModules: loadCtxoModules2 }, { resolvePackageCandidates: resolvePackageCandidates2 }, { createModuleHost }] = await Promise.all([
+        import("./module-loader-B3LYF3W7.js"),
+        import("./plugin-discovery-XRXI3IJF.js"),
+        import("./module-host-KTGDODES.js")
+      ]);
+      if (resolvePackageCandidates2(DOMAIN_MODULE_PACKAGE2, this.projectRoot, this.cliAnchor).length === 0) return void 0;
+      const host = createModuleHost({ projectRoot: this.projectRoot, mode: "cli" });
+      const { modules } = await loadCtxoModules2(host, { refresh, cliAnchor: this.cliAnchor });
+      const init = modules[0]?.registration.init;
+      return init !== void 0 && typeof init.apply === "function" ? init : void 0;
+    } catch {
+      return void 0;
+    }
+  }
   /**
    * The rows for a rules file that `rulesHold` keeps back: the held row, then the warning a write
    * would have given (a damaged block or one from a newer ctxo, read by a dry run that writes nothing).
@@ -4454,7 +4702,8 @@ var InitCommand = class {
     const showTools = TOOL_PARTS.some((part) => parts.has(part));
     const showPlugins = missingPlugins.length > 0;
     const showHooks = parts.has("git-hooks");
-    const totalSteps = [showIndex, showTools, showPlugins, showHooks].filter(Boolean).length;
+    const showDomain = parts.has("domain");
+    const totalSteps = [showIndex, showTools, showPlugins, showHooks, showDomain].filter(Boolean).length;
     let stepNum = 0;
     console.error("");
     console.error(renderBanner(version, pc));
@@ -4548,6 +4797,31 @@ var InitCommand = class {
       }
       console.error("");
     }
+    const prompter = clackPrompter(clack, pc);
+    let installApproved;
+    let boundaries = options.boundaries;
+    if (showDomain) {
+      stepNum++;
+      console.error(stepHeader(
+        stepNum,
+        totalSteps,
+        "Domain Knowledge",
+        "Registry, fold guard and the ctxo-domain-fold skill (@ctxo/domain).",
+        pc
+      ));
+      console.error("");
+      const installed = await this.loadDomainInit(false) !== void 0;
+      if (!installed && !options.noInstall) {
+        installApproved = await prompter.confirm(
+          `Install @ctxo/domain@${getVersion()}? It adds the registry, contexts-touched and the fold guard.`,
+          true
+        );
+      }
+      if ((installed || installApproved === true) && boundaries === void 0 && configuredBoundaryMode(this.projectRoot) === void 0) {
+        boundaries = await prompter.select(BOUNDARY_QUESTION, BOUNDARY_CHOICES, "by-rung");
+      }
+      console.error("");
+    }
     const declined = declinedBy(options);
     if (parts.has("guard") && toolIds.includes("claude-code") && !options.noGuard) {
       const guard = await clack.confirm({
@@ -4565,7 +4839,19 @@ var InitCommand = class {
     }
     const s = clack.spinner();
     s.start(pc.dim("Configuring..."));
-    const rows = this.applyParts(parts, toolIds, false, declined).map((result) => summaryRow(result, pc));
+    const domainRun = {
+      interactive: true,
+      yes: false,
+      noInstall: options.noInstall === true,
+      ...boundaries !== void 0 ? { boundaries } : {},
+      ...installApproved !== void 0 ? { installApproved } : {},
+      prompter,
+      toolIds: showTools ? toolIds : [...detectPlatforms(this.projectRoot)],
+      // The domain step may install a package and ask the module's own questions: never under a live spinner.
+      pause: () => s.stop(pc.dim("Setting up the domain layer...")),
+      resume: () => s.start(pc.dim("Finalizing..."))
+    };
+    const rows = (await this.applyParts(parts, toolIds, false, declined, domainRun)).map((result) => summaryRow(result, pc));
     if (pluginsToInstall.length > 0) {
       s.stop(pc.dim("Installing language plugins..."));
       const installer = new InstallCommand(this.projectRoot);
@@ -4578,7 +4864,7 @@ var InitCommand = class {
       console.error("");
       console.error(box(rows, { title: pc.green("\u2713 Summary"), border: pc.green }, pc));
     }
-    const hasWork = toolIds.length > 0 || parts.has("git-hooks");
+    const hasWork = toolIds.length > 0 || parts.has("git-hooks") || parts.has("domain");
     if (hasWork) {
       const steps = [
         `${pc.cyan("\u25B6")} ctxo index     ${pc.dim("\u2500 build codebase index")}`,
@@ -4597,7 +4883,8 @@ var InitCommand = class {
   async runNonInteractive(options, parts) {
     const toolIds = selectedTools(options);
     exitOnUnknownTools(toolIds);
-    for (const result of this.applyParts(parts, toolIds, false, declinedBy(options))) console.error(formatResultLine(result));
+    const rows = await this.applyParts(parts, toolIds, false, declinedBy(options), nonInteractiveDomainRun(options, toolIds));
+    for (const result of rows) console.error(formatResultLine(result));
     if (pluginStepEnabled(options)) {
       const missing = this.missingPlugins();
       if (missing.length > 0) {
@@ -4620,10 +4907,11 @@ var InitCommand = class {
    * hooks directory prints installHooks' warning and no hook rows, as a real run does. The hook rows
    * come marked from the pipeline, so the hooks directory is looked up only when git-hooks is selected.
    */
-  dryRun(options) {
+  async dryRun(options) {
     exitOnUnknownTools(selectedTools(options));
     console.error(DRY_RUN_HEADER);
-    for (const result of this.plan(options)) console.error(formatPlanLine(result));
+    const rows = await this.plan(options);
+    for (const result of rows) console.error(formatPlanLine(result));
   }
   /* ---------------------------------------------------------------- */
   /*  Helpers                                                          */
@@ -4631,11 +4919,11 @@ var InitCommand = class {
   async getVersion() {
     try {
       const pkgPath = join17(this.projectRoot, "node_modules", "@ctxo", "cli", "package.json");
-      if (existsSync15(pkgPath)) {
-        return JSON.parse(readFileSync10(pkgPath, "utf-8")).version;
+      if (existsSync14(pkgPath)) {
+        return JSON.parse(readFileSync9(pkgPath, "utf-8")).version;
       }
-      const { createRequire: createRequire10 } = await import("module");
-      const require5 = createRequire10(import.meta.url);
+      const { createRequire: createRequire9 } = await import("module");
+      const require5 = createRequire9(import.meta.url);
       return require5("../../package.json").version;
     } catch {
       return void 0;
@@ -4656,7 +4944,7 @@ var InitCommand = class {
     let existing = "#!/bin/sh\n";
     let hookExists = true;
     try {
-      existing = readFileSync10(hookPath, "utf-8");
+      existing = readFileSync9(hookPath, "utf-8");
     } catch (err) {
       if (err.code !== "ENOENT") throw err;
       hookExists = false;
@@ -4948,7 +5236,7 @@ function readHeadSha() {
 
 // src/cli/stats-command.ts
 import { join as join19 } from "path";
-import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync10 } from "fs";
 import initSqlJs from "sql.js";
 var StatsCommand = class {
   ctxoRoot;
@@ -4961,7 +5249,7 @@ var StatsCommand = class {
       return;
     }
     const dbPath = join19(this.ctxoRoot, ".cache", "symbols.db");
-    if (!existsSync16(dbPath)) {
+    if (!existsSync15(dbPath)) {
       if (options.json) {
         process.stdout.write(JSON.stringify(this.emptyReport(options.days)) + "\n");
       } else {
@@ -4970,7 +5258,7 @@ var StatsCommand = class {
       return;
     }
     const SQL = await initSqlJs();
-    const buffer = readFileSync11(dbPath);
+    const buffer = readFileSync10(dbPath);
     const db = new SQL.Database(buffer);
     const recorder = new SessionRecorderAdapter(db);
     try {
@@ -5009,9 +5297,9 @@ var StatsCommand = class {
   }
   isStatsEnabled() {
     const configPath = join19(this.ctxoRoot, "config.yaml");
-    if (!existsSync16(configPath)) return true;
+    if (!existsSync15(configPath)) return true;
     try {
-      const raw = readFileSync11(configPath, "utf-8");
+      const raw = readFileSync10(configPath, "utf-8");
       const match = raw.match(/stats:\s*\n\s*enabled:\s*(true|false)/);
       if (match) return match[1] !== "false";
       return true;
@@ -5100,11 +5388,11 @@ var StatsCommand = class {
 };
 
 // src/cli/doctor-command.ts
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 import { existsSync as existsSync25 } from "fs";
 
 // src/adapters/diagnostics/health-checker.ts
-var log4 = createLogger("ctxo:doctor");
+var log3 = createLogger("ctxo:doctor");
 var HealthChecker = class {
   checks;
   quiet;
@@ -5121,12 +5409,12 @@ var HealthChecker = class {
       if (outcome.status === "fulfilled") {
         const r = outcome.value;
         if (!this.quiet) {
-          log4.info(`${r.id}: ${r.status.toUpperCase()} (${r.message})`);
+          log3.info(`${r.id}: ${r.status.toUpperCase()} (${r.message})`);
         }
         return r;
       }
       const message = outcome.reason?.message ?? "Unknown error";
-      if (!this.quiet) log4.error(`${check.id}: FAIL (${message})`);
+      if (!this.quiet) log3.error(`${check.id}: FAIL (${message})`);
       return {
         id: check.id,
         title: check.title,
@@ -5193,8 +5481,8 @@ var DoctorReporter = class {
 };
 
 // src/adapters/diagnostics/checks/runtime-check.ts
-import { createRequire as createRequire5 } from "module";
-var require2 = createRequire5(import.meta.url);
+import { createRequire as createRequire4 } from "module";
+var require2 = createRequire4(import.meta.url);
 function pass(id, title, message) {
   return { id, title, status: "pass", message };
 }
@@ -5265,21 +5553,22 @@ function tryResolve(packageName) {
 }
 
 // src/cli/version-command.ts
-import { SUPPORTED_API_VERSIONS as SUPPORTED_API_VERSIONS2 } from "@ctxo/plugin-api";
-var NEWEST_API_VERSION = SUPPORTED_API_VERSIONS2[SUPPORTED_API_VERSIONS2.length - 1];
-function gatherVersionInfo(discovered) {
+import { SUPPORTED_API_VERSIONS } from "@ctxo/plugin-api";
+var NEWEST_API_VERSION = SUPPORTED_API_VERSIONS[SUPPORTED_API_VERSIONS.length - 1];
+function gatherVersionInfo(discovered, modules = []) {
   const plugins = discovered.map(({ plugin, specifier }) => ({
     name: specifier,
     id: plugin.id,
     version: plugin.version,
     apiVersion: plugin.apiVersion,
-    compatible: SUPPORTED_API_VERSIONS2.includes(plugin.apiVersion)
+    compatible: SUPPORTED_API_VERSIONS.includes(plugin.apiVersion)
   }));
   return {
     ctxo: getVersion(),
     pluginApiVersion: NEWEST_API_VERSION,
-    pluginApiVersions: SUPPORTED_API_VERSIONS2,
+    pluginApiVersions: SUPPORTED_API_VERSIONS,
     plugins,
+    modules,
     runtime: {
       node: process.version,
       platform: process.platform,
@@ -5296,6 +5585,11 @@ function formatVerbose(info) {
   lines.push(`Plugin API: ${info.pluginApiVersions.join(", ")}`);
   lines.push(`Runtime:    Node ${info.runtime.node} on ${info.runtime.platform}/${info.runtime.arch}`);
   lines.push("");
+  for (const m of info.modules.filter((x) => x.status !== "not-installed")) {
+    const label = m.version === void 0 ? m.name : `${m.name} ${m.version}`;
+    lines.push(`Modules:    ${label} (${m.status})`);
+  }
+  if (info.modules.some((x) => x.status !== "not-installed")) lines.push("");
   if (info.plugins.length === 0) {
     lines.push("Plugins:    (none installed)");
     lines.push("");
@@ -5320,6 +5614,18 @@ function formatVerbose(info) {
 function formatJson(info) {
   return JSON.stringify(info, null, 2);
 }
+async function collectModuleReports(projectRoot, options = {}) {
+  try {
+    if (resolvePackageCandidates(DOMAIN_MODULE_PACKAGE, projectRoot, options.cliAnchor).length === 0) {
+      return [{ name: DOMAIN_MODULE_PACKAGE, status: "not-installed" }];
+    }
+    const { createModuleHost } = await import("./module-host-KTGDODES.js");
+    const { reports } = await loadCtxoModules(createModuleHost({ projectRoot, mode: "cli" }), { cliAnchor: options.cliAnchor });
+    return reports;
+  } catch (err) {
+    return [{ name: DOMAIN_MODULE_PACKAGE, status: "load-failed", reason: err.message }];
+  }
+}
 var VersionCommand = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
@@ -5338,12 +5644,13 @@ var VersionCommand = class {
     process.stdout.write(formatShort(info) + "\n");
   }
   async collect() {
+    const modules = await collectModuleReports(this.projectRoot);
     const manifestPath = loadManifestPath(this.projectRoot);
     if (!manifestPath) {
-      return gatherVersionInfo([]);
+      return gatherVersionInfo([], modules);
     }
     const { plugins } = await discoverPlugins({ manifestPath });
-    return gatherVersionInfo(plugins);
+    return gatherVersionInfo(plugins, modules);
   }
 };
 
@@ -5375,10 +5682,11 @@ var VersionsCheck = class {
   }
 };
 async function collectInfo(ctx) {
+  const modules = await collectModuleReports(ctx.projectRoot);
   const manifestPath = loadManifestPath(ctx.projectRoot);
-  if (!manifestPath) return gatherVersionInfo([]);
+  if (!manifestPath) return gatherVersionInfo([], modules);
   const { plugins } = await discoverPlugins({ manifestPath });
-  return gatherVersionInfo(plugins);
+  return gatherVersionInfo(plugins, modules);
 }
 function buildSummary(info) {
   const pluginCount = info.plugins.length;
@@ -5387,8 +5695,8 @@ function buildSummary(info) {
 }
 
 // src/adapters/diagnostics/checks/language-coverage-check.ts
-import { createRequire as createRequire6 } from "module";
-var require3 = createRequire6(import.meta.url);
+import { createRequire as createRequire5 } from "module";
+var require3 = createRequire5(import.meta.url);
 var LanguageCoverageCheck = class {
   id = "language_coverage";
   title = "Language coverage";
@@ -5439,10 +5747,10 @@ function pluginResolves(packageName) {
 }
 
 // src/adapters/diagnostics/checks/java-tier-check.ts
-import { createRequire as createRequire7 } from "module";
-import { existsSync as existsSync17, readdirSync as readdirSync3 } from "fs";
-import { join as join20, dirname as dirname7 } from "path";
-var require4 = createRequire7(import.meta.url);
+import { createRequire as createRequire6 } from "module";
+import { existsSync as existsSync16, readdirSync as readdirSync3 } from "fs";
+import { join as join20, dirname as dirname6 } from "path";
+var require4 = createRequire6(import.meta.url);
 function evaluateJavaTier(i) {
   const id = "java_tier";
   const title = "Java analysis tier";
@@ -5482,8 +5790,8 @@ function evaluateJavaTier(i) {
 function analyzerJarPresent() {
   try {
     const pkgJson = require4.resolve("@ctxo/lang-java-analyzer/package.json");
-    const jarDir = join20(dirname7(pkgJson), "jar");
-    return existsSync17(join20(jarDir, "ctxo-jdt-analyzer-11.jar")) || existsSync17(join20(jarDir, "ctxo-jdt-analyzer-17.jar"));
+    const jarDir = join20(dirname6(pkgJson), "jar");
+    return existsSync16(join20(jarDir, "ctxo-jdt-analyzer-11.jar")) || existsSync16(join20(jarDir, "ctxo-jdt-analyzer-17.jar"));
   } catch {
     return false;
   }
@@ -5528,7 +5836,7 @@ function findSourceFile(root, extension, maxDepth) {
 }
 function projectHasJava(root) {
   for (const f of ["pom.xml", "build.gradle", "build.gradle.kts"]) {
-    if (existsSync17(join20(root, f))) return true;
+    if (existsSync16(join20(root, f))) return true;
   }
   return findJavaFile(root, 4);
 }
@@ -5545,10 +5853,10 @@ var JavaTierCheck = class {
 };
 
 // src/adapters/diagnostics/checks/csharp-tier-check.ts
-import { createRequire as createRequire8 } from "module";
+import { createRequire as createRequire7 } from "module";
 import { spawnSync as spawnSync3 } from "child_process";
-import { existsSync as existsSync18, readdirSync as readdirSync4 } from "fs";
-import { join as join21, dirname as dirname8 } from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync4 } from "fs";
+import { join as join21, dirname as dirname7 } from "path";
 
 // src/core/detection/detect-dotnet-sdk.ts
 import { spawnSync as spawnSync2 } from "child_process";
@@ -5635,10 +5943,10 @@ function restoreFailureMessage(r) {
 }
 function resolveHelperProject(projectRoot) {
   try {
-    const requireFromProject = createRequire8(join21(projectRoot, "package.json"));
+    const requireFromProject = createRequire7(join21(projectRoot, "package.json"));
     const pkgJson = resolvePluginPackageJson("@ctxo/lang-csharp", requireFromProject);
-    const csproj = join21(dirname8(pkgJson), "tools", "ctxo-roslyn", "ctxo-roslyn.csproj");
-    return existsSync18(csproj) ? csproj : null;
+    const csproj = join21(dirname7(pkgJson), "tools", "ctxo-roslyn", "ctxo-roslyn.csproj");
+    return existsSync17(csproj) ? csproj : null;
   } catch {
     return null;
   }
@@ -5686,7 +5994,7 @@ var CSharpTierCheck = class {
 
 // src/adapters/diagnostics/checks/git-check.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
 import { join as join22 } from "path";
 var GitBinaryCheck = class {
   id = "git_binary";
@@ -5704,7 +6012,7 @@ var GitRepoCheck = class {
   id = "git_repo";
   title = "Git repository";
   async run(ctx) {
-    if (existsSync19(join22(ctx.projectRoot, ".git"))) {
+    if (existsSync18(join22(ctx.projectRoot, ".git"))) {
       return { id: this.id, title: this.title, status: "pass", message: ctx.projectRoot, value: ctx.projectRoot };
     }
     return { id: this.id, title: this.title, status: "fail", message: "Not a git repository", fix: 'Run "git init" or clone a repository' };
@@ -5714,14 +6022,14 @@ var GitHooksCheck = class {
   id = "git_hooks";
   title = "Git hooks";
   async run(ctx) {
-    if (!existsSync19(join22(ctx.projectRoot, ".git"))) {
+    if (!existsSync18(join22(ctx.projectRoot, ".git"))) {
       return { id: this.id, title: this.title, status: "pass", message: "Not a git repository (hooks not applicable)" };
     }
     const hooksDir = resolveHooksDir(ctx.projectRoot);
     const hookPath = join22(hooksDir, "post-commit");
     let versions;
     try {
-      versions = readCtxoBlockVersions(readFileSync12(hookPath, "utf-8"));
+      versions = readCtxoBlockVersions(readFileSync11(hookPath, "utf-8"));
     } catch {
       versions = [];
     }
@@ -5924,10 +6232,119 @@ var ClaudeGuardHookCheck = class {
   }
 };
 
+// src/adapters/diagnostics/checks/install-copies-check.ts
+import { existsSync as existsSync19, readFileSync as readFileSync12, realpathSync as realpathSync2 } from "fs";
+import { delimiter, join as join23 } from "path";
+var MCP_FILES = [
+  { file: ".mcp.json", keys: ["mcpServers"] },
+  { file: ".vscode/mcp.json", keys: ["servers"] },
+  { file: ".gemini/settings.json", keys: ["mcpServers"] },
+  { file: ".amazonq/mcp.json", keys: ["mcpServers"] },
+  { file: ".continue/mcpServers/ctxo.json", keys: ["mcpServers"] }
+];
+var SETTINGS_FILES = [".claude/settings.json", ".claude/settings.local.json"];
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync12(path, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function mcpLaunchers(projectRoot) {
+  const out = [];
+  const npxPins = [];
+  for (const { file, keys } of MCP_FILES) {
+    const json = readJson(join23(projectRoot, file));
+    if (!isRecord2(json)) continue;
+    for (const key of keys) {
+      const servers = json[key];
+      const launcher = isRecord2(servers) ? mcpLauncherOf(servers["ctxo"]) : void 0;
+      if (launcher !== void 0) out.push(launcher);
+      const pin = isRecord2(servers) ? mcpNpxPin(servers["ctxo"]) : void 0;
+      if (pin !== void 0) npxPins.push(pin);
+    }
+  }
+  return { launchers: out, npxPins };
+}
+function hookCallsCtxo(node, depth = 0) {
+  if (depth > 8) return false;
+  if (Array.isArray(node)) return node.some((child) => hookCallsCtxo(child, depth + 1));
+  if (!isRecord2(node)) return false;
+  const command = node["command"];
+  if (typeof command === "string" && command.trimStart().startsWith("ctxo ")) return true;
+  return Object.values(node).some((child) => hookCallsCtxo(child, depth + 1));
+}
+function anyHookCallsCtxo(projectRoot) {
+  return SETTINGS_FILES.some((file) => {
+    const json = readJson(join23(projectRoot, file));
+    return isRecord2(json) && hookCallsCtxo(json["hooks"]);
+  });
+}
+function binaryOnPath(dirs) {
+  const names = process.platform === "win32" ? ["ctxo.cmd", "ctxo.exe"] : ["ctxo"];
+  return dirs.some((dir) => dir !== "" && names.some((name) => existsSync19(join23(dir, name))));
+}
+function globalCliVersion(dirs) {
+  const names = process.platform === "win32" ? ["ctxo.cmd", "ctxo.exe"] : ["ctxo"];
+  for (const dir of dirs) {
+    const found = dir === "" ? void 0 : names.find((name) => existsSync19(join23(dir, name)));
+    if (found === void 0) continue;
+    const candidates = [
+      join23(dir, "node_modules", "@ctxo", "cli", "package.json"),
+      // Windows npm prefix, a global bin dir with its own node_modules
+      join23(dir, "..", "lib", "node_modules", "@ctxo", "cli", "package.json")
+      // unix npm prefix/bin
+    ];
+    try {
+      candidates.push(join23(realpathSync2(join23(dir, found)), "..", "..", "package.json"));
+    } catch {
+    }
+    for (const file of candidates) {
+      const json = readJson(file);
+      if (isRecord2(json) && json["name"] === "@ctxo/cli" && typeof json["version"] === "string") return json["version"];
+    }
+  }
+  return void 0;
+}
+var InstallCopiesCheck = class {
+  constructor(options = {}) {
+    this.options = options;
+  }
+  options;
+  id = "install_copies";
+  title = "Install copies";
+  async run(ctx) {
+    try {
+      const pathDirs = this.options.pathDirs ?? (process.env["PATH"] ?? "").split(delimiter);
+      const { launchers, npxPins } = mcpLaunchers(ctx.projectRoot);
+      const globalVersion = globalCliVersion(pathDirs);
+      const verdict = assessInstallCopies({
+        launchers,
+        npxPins,
+        ...globalVersion !== void 0 ? { globalCliVersion: globalVersion } : {},
+        hooksCallCtxo: anyHookCallsCtxo(ctx.projectRoot),
+        ctxoOnPath: binaryOnPath(pathDirs),
+        domainInstalled: resolvePackageCandidates(DOMAIN_MODULE_PACKAGE, ctx.projectRoot).length > 0
+      });
+      return { id: this.id, title: this.title, ...verdict };
+    } catch (err) {
+      return {
+        id: this.id,
+        title: this.title,
+        status: "pass",
+        message: `could not be checked: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+};
+
 // src/adapters/diagnostics/checks/index-check.ts
 import { existsSync as existsSync20 } from "fs";
 import { execFileSync as execFileSync8 } from "child_process";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 function pass2(id, title, message, value) {
   return { id, title, status: "pass", message, value };
 }
@@ -5944,7 +6361,7 @@ var IndexDirectoryCheck = class {
   id = "index_directory";
   title = "Index directory";
   async run(ctx) {
-    const indexDir = join23(ctx.ctxoRoot, "index");
+    const indexDir = join24(ctx.ctxoRoot, "index");
     if (!existsSync20(indexDir)) {
       return fail(this.id, this.title, "No index directory", 'Run "ctxo index"');
     }
@@ -6039,7 +6456,7 @@ var CoChangesCacheCheck = class {
   id = "co_changes_cache";
   title = "Co-changes cache";
   async run(ctx) {
-    const coChangesPath = join23(ctx.ctxoRoot, "index", "co-changes.json");
+    const coChangesPath = join24(ctx.ctxoRoot, "index", "co-changes.json");
     if (existsSync20(coChangesPath)) {
       return pass2(this.id, this.title, "present");
     }
@@ -6065,12 +6482,12 @@ var SchemaVersionCheck = class {
 
 // src/adapters/diagnostics/checks/storage-check.ts
 import { existsSync as existsSync21, readFileSync as readFileSync13 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var SqliteCacheCheck = class {
   id = "sqlite_cache";
   title = "SQLite cache";
   async run(ctx) {
-    const dbPath = join24(ctx.ctxoRoot, ".cache", "symbols.db");
+    const dbPath = join25(ctx.ctxoRoot, ".cache", "symbols.db");
     if (!existsSync21(dbPath)) {
       return { id: this.id, title: this.title, status: "warn", message: "SQLite cache missing", fix: 'Run "ctxo sync" to rebuild' };
     }
@@ -6094,12 +6511,12 @@ var SqliteCacheCheck = class {
 
 // src/adapters/diagnostics/checks/config-check.ts
 import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var ConfigFileCheck = class {
   id = "config_file";
   title = "Config file";
   async run(ctx) {
-    const configPath = join25(ctx.ctxoRoot, "config.yaml");
+    const configPath = join26(ctx.ctxoRoot, "config.yaml");
     if (!existsSync22(configPath)) {
       return { id: this.id, title: this.title, status: "warn", message: "No config.yaml (using defaults)" };
     }
@@ -6139,7 +6556,7 @@ var ConfigFileCheck = class {
 
 // src/adapters/diagnostics/checks/disk-check.ts
 import { existsSync as existsSync23, readdirSync as readdirSync5, statSync as statSync3 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var DEFAULT_THRESHOLDS = { warnMb: 100, failMb: 500 };
 var DiskUsageCheck = class {
   id = "disk_usage";
@@ -6171,7 +6588,7 @@ var DiskUsageCheck = class {
         if (entry.isFile()) {
           try {
             const parent = entry.parentPath ?? entry.path ?? dirPath;
-            total += statSync3(join26(parent, entry.name)).size;
+            total += statSync3(join27(parent, entry.name)).size;
           } catch {
           }
         }
@@ -6185,8 +6602,8 @@ var DiskUsageCheck = class {
 // src/cli/doctor-fix.ts
 import { execFileSync as execFileSync9 } from "child_process";
 import { appendFileSync, existsSync as existsSync24, mkdirSync as mkdirSync6, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
-import { createRequire as createRequire9 } from "module";
-import { dirname as dirname9, join as join27 } from "path";
+import { createRequire as createRequire8 } from "module";
+import { dirname as dirname8, join as join28 } from "path";
 async function applyFixes(report, options) {
   if (isCI(process.env) && !options.yes && !options.dryRun) {
     return {
@@ -6421,7 +6838,7 @@ async function fixIndex(projectRoot, dryRun) {
 }
 async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
   if (dryRun) return;
-  const indexDir = join27(ctxoRoot, "index");
+  const indexDir = join28(ctxoRoot, "index");
   if (!existsSync24(indexDir)) return;
   const sourceFiles = listGitFiles2(projectRoot);
   if (sourceFiles.size === 0) return;
@@ -6430,7 +6847,7 @@ async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
   let removed = 0;
   for (const idx of indices) {
     if (sourceFiles.has(idx.file)) continue;
-    const jsonPath = join27(indexDir, `${idx.file}.json`);
+    const jsonPath = join28(indexDir, `${idx.file}.json`);
     try {
       if (existsSync24(jsonPath)) {
         unlinkSync2(jsonPath);
@@ -6443,14 +6860,14 @@ async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
   if (removed === 0) return;
 }
 function pruneEmptyParents(filePath, stopAt) {
-  let dir = dirname9(filePath);
+  let dir = dirname8(filePath);
   while (dir !== stopAt && dir.startsWith(stopAt)) {
     try {
       rmSync2(dir, { recursive: false });
     } catch {
       return;
     }
-    dir = dirname9(dir);
+    dir = dirname8(dir);
   }
 }
 function listGitFiles2(projectRoot) {
@@ -6468,12 +6885,12 @@ function listGitFiles2(projectRoot) {
   }
 }
 async function fixSqliteCache(projectRoot, ctxoRoot, dryRun) {
-  const cacheDir = join27(ctxoRoot, ".cache");
+  const cacheDir = join28(ctxoRoot, ".cache");
   if (dryRun) return;
   if (existsSync24(cacheDir)) rmSync2(cacheDir, { recursive: true, force: true });
   await new SyncCommand(projectRoot).run();
 }
-var doctorRequire = createRequire9(import.meta.url);
+var doctorRequire = createRequire8(import.meta.url);
 function canResolvePlugin(lang) {
   try {
     doctorRequire.resolve(`${officialPluginFor(lang)}/package.json`);
@@ -6488,7 +6905,7 @@ function isCI(env) {
 function writeLog(ctxoRoot, attempts, halted, reason) {
   try {
     if (!existsSync24(ctxoRoot)) mkdirSync6(ctxoRoot, { recursive: true });
-    const path = join27(ctxoRoot, "doctor-fix.log");
+    const path = join28(ctxoRoot, "doctor-fix.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     const lines = [`# ${ts} doctor --fix${halted ? " (halted: " + reason + ")" : ""}`];
     for (const a of attempts) {
@@ -6523,11 +6940,10 @@ var DoctorCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join28(projectRoot, ".ctxo");
+    this.ctxoRoot = join29(projectRoot, ".ctxo");
   }
   async run(options = {}) {
-    const { getVersion: getVersion2 } = await import("./cli-router-DDHH4WQH.js");
-    console.error(`ctxo v${getVersion2()} \u2014 health check
+    console.error(`ctxo v${getVersion()} \u2014 health check
 `);
     const checks = [
       new VersionsCheck(),
@@ -6538,6 +6954,7 @@ var DoctorCommand = class {
       new AiRulesCheck(),
       new SkillsCheck(),
       new ClaudeGuardHookCheck(),
+      new InstallCopiesCheck(),
       new IndexDirectoryCheck(),
       new IndexFreshnessCheck(),
       new SqliteCacheCheck(),
@@ -6552,9 +6969,11 @@ var DoctorCommand = class {
       new EdgeCountCheck(),
       new OrphanedFilesCheck(),
       new CoChangesCacheCheck(),
-      new SchemaVersionCheck()
+      new SchemaVersionCheck(),
+      // Module checks last, so the core report reads the same with or without a module.
+      ...(options.modules ?? []).flatMap((module) => module.registration.doctorChecks ?? [])
     ];
-    const indexDir = join28(this.ctxoRoot, "index");
+    const indexDir = join29(this.ctxoRoot, "index");
     const indices = existsSync25(indexDir) ? new JsonIndexReader(this.ctxoRoot).readAll() : [];
     const checker = new HealthChecker(checks, { quiet: Boolean(options.quiet) });
     const report = await checker.runAll({
@@ -6597,7 +7016,7 @@ var DoctorCommand = class {
 
 // src/cli/visualize-command.ts
 import { readFileSync as readFileSync15, writeFileSync as writeFileSync5, existsSync as existsSync26 } from "fs";
-import { join as join29, basename } from "path";
+import { join as join30, basename } from "path";
 import { execFile } from "child_process";
 
 // src/cli/graph-loader.ts
@@ -6613,7 +7032,7 @@ function loadGraph(ctxoRoot) {
 var VisualizeCommand = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join29(projectRoot, ".ctxo");
+    this.ctxoRoot = join30(projectRoot, ".ctxo");
   }
   projectRoot;
   ctxoRoot;
@@ -6756,7 +7175,7 @@ var VisualizeCommand = class {
     const templatePath = this.getTemplatePath();
     const template = readFileSync15(templatePath, "utf-8");
     const html = template.replace("/*__CTXO_DATA__*/null", () => JSON.stringify(payload).replace(/</g, "\\u003c"));
-    const outputPath = options.output ?? join29(this.ctxoRoot, "visualize.html");
+    const outputPath = options.output ?? join30(this.ctxoRoot, "visualize.html");
     writeFileSync5(outputPath, html, "utf-8");
     console.error(`[ctxo] Wrote visualization to ${outputPath}`);
     console.error(`[ctxo] ${nodes.length} symbols, ${edges.length} edges, ${deadResult.deadSymbols.length} dead`);
@@ -6767,9 +7186,9 @@ var VisualizeCommand = class {
   getTemplatePath() {
     let dir = import.meta.dirname;
     for (let i = 0; i < 10; i++) {
-      const candidate = join29(dir, "pages", "visualize-template.html");
+      const candidate = join30(dir, "pages", "visualize-template.html");
       if (existsSync26(candidate)) return candidate;
-      const parent = join29(dir, "..");
+      const parent = join30(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
@@ -6794,11 +7213,11 @@ var VisualizeCommand = class {
 
 // src/cli/update-command.ts
 import { existsSync as existsSync27, readFileSync as readFileSync16 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 
 // src/core/update/registry-client.ts
 import { request } from "https";
-var log5 = createLogger("ctxo:update:registry");
+var log4 = createLogger("ctxo:update:registry");
 var DEFAULT_TIMEOUT_MS = 5e3;
 async function fetchDistTags(packageName, options = {}) {
   const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
@@ -6840,14 +7259,14 @@ function classifyFetchError(name, err) {
   if (code === "ECONNREFUSED" || code === "ECONNRESET" || code === "ENOTFOUND" || code === "EAI_AGAIN") {
     return { name, reason: "network", message };
   }
-  log5.error(`unexpected fetch error for ${name}: ${message}`);
+  log4.error(`unexpected fetch error for ${name}: ${message}`);
   return { name, reason: "network", message };
 }
-var defaultHttpsFetcher = (url, timeoutMs) => new Promise((resolve6, reject) => {
+var defaultHttpsFetcher = (url, timeoutMs) => new Promise((resolve5, reject) => {
   const req = request(url, { method: "GET", headers: { "user-agent": "ctxo-update", accept: "application/json" } }, (res) => {
     const chunks = [];
     res.on("data", (chunk) => chunks.push(chunk));
-    res.on("end", () => resolve6({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf-8") }));
+    res.on("end", () => resolve5({ status: res.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf-8") }));
     res.on("error", reject);
   });
   req.setTimeout(timeoutMs, () => {
@@ -6948,7 +7367,7 @@ function isSafeVersionSpecifier(version) {
 }
 
 // src/cli/update-command.ts
-var log6 = createLogger("ctxo:update");
+var log5 = createLogger("ctxo:update");
 var CTXO_CLI_PACKAGE = "@ctxo/cli";
 function formatText(report) {
   const lines = [];
@@ -7112,16 +7531,16 @@ var UpdateCommand = class {
     return this.projectHasCtxoDep() ? "execute" : "print";
   }
   projectHasCtxoDep() {
-    const pkg = join30(this.projectRoot, "package.json");
+    const pkg = join31(this.projectRoot, "package.json");
     if (!existsSync27(pkg)) return false;
     try {
       const json = JSON.parse(readFileSync16(pkg, "utf-8"));
       const merged = { ...json.dependencies ?? {}, ...json.devDependencies ?? {} };
       return Object.keys(merged).some(
-        (name) => name === CTXO_CLI_PACKAGE || name.startsWith("@ctxo/lang-") || name.startsWith("ctxo-lang-")
+        (name) => name === CTXO_CLI_PACKAGE || name === DOMAIN_MODULE_PACKAGE || name.startsWith("@ctxo/lang-") || name.startsWith("ctxo-lang-")
       );
     } catch (err) {
-      log6.error(`failed to read project package.json: ${err.message}`);
+      log5.error(`failed to read project package.json: ${err.message}`);
       return false;
     }
   }
@@ -7140,9 +7559,12 @@ var UpdateCommand = class {
 async function defaultDiscoverInstalled(projectRoot) {
   const out = [{ name: CTXO_CLI_PACKAGE, version: getVersion() }];
   const manifestPath = loadManifestPath(projectRoot);
-  if (!manifestPath) return out;
-  const { plugins } = await discoverPlugins({ manifestPath });
-  for (const p of plugins) out.push({ name: p.specifier, version: p.plugin.version });
+  if (manifestPath) {
+    const { plugins } = await discoverPlugins({ manifestPath });
+    for (const p of plugins) out.push({ name: p.specifier, version: p.plugin.version });
+  }
+  const domain = resolvePackageCandidates(DOMAIN_MODULE_PACKAGE, projectRoot)[0];
+  if (domain !== void 0) out.push({ name: DOMAIN_MODULE_PACKAGE, version: domain.version });
   return out;
 }
 function isLockedCI2(env) {
@@ -7150,11 +7572,11 @@ function isLockedCI2(env) {
 }
 
 // src/cli/blast-radius-command.ts
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var BlastRadiusCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join31(projectRoot, ".ctxo");
+    this.ctxoRoot = join32(projectRoot, ".ctxo");
   }
   run(options) {
     const { graph } = loadGraph(this.ctxoRoot);
@@ -7187,12 +7609,12 @@ var BlastRadiusCommand = class {
 };
 
 // src/cli/contexts-command.ts
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var NO_VIEW_HINT = "No contexts view. Run ctxo index (without --skip-community).";
 var ContextsCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join32(projectRoot, ".ctxo");
+    this.ctxoRoot = join33(projectRoot, ".ctxo");
   }
   run(options) {
     const view = new ContextsViewReader(this.ctxoRoot).readContextsView();
@@ -7232,7 +7654,7 @@ var ContextsCommand = class {
 };
 
 // src/cli/gate-hook-command.ts
-import { join as join34, relative as relative6, sep as sep3 } from "path";
+import { join as join35, relative as relative6, sep as sep3 } from "path";
 import { existsSync as existsSync29, readFileSync as readFileSync18 } from "fs";
 
 // src/core/gate/gate-config.ts
@@ -7301,8 +7723,8 @@ function transcriptHasBlastCheck(lines, symbolId) {
 
 // src/adapters/gate/gate-session-store.ts
 import { existsSync as existsSync28, mkdirSync as mkdirSync7, readFileSync as readFileSync17, writeFileSync as writeFileSync6 } from "fs";
-import { join as join33 } from "path";
-var log7 = createLogger("ctxo:gate-store");
+import { join as join34 } from "path";
+var log6 = createLogger("ctxo:gate-store");
 var GateSessionStore = class {
   constructor(cacheDir) {
     this.cacheDir = cacheDir;
@@ -7310,7 +7732,7 @@ var GateSessionStore = class {
   cacheDir;
   file(sessionId) {
     const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return join33(this.cacheDir, "gate", `${safe}.json`);
+    return join34(this.cacheDir, "gate", `${safe}.json`);
   }
   read(sessionId) {
     const f = this.file(sessionId);
@@ -7318,7 +7740,7 @@ var GateSessionStore = class {
     try {
       return new Set(JSON.parse(readFileSync17(f, "utf-8")));
     } catch (err) {
-      log7.error(`${err.message}`);
+      log6.error(`${err.message}`);
       return /* @__PURE__ */ new Set();
     }
   }
@@ -7330,10 +7752,10 @@ var GateSessionStore = class {
       const set = this.read(sessionId);
       set.add(symbolId);
       const f = this.file(sessionId);
-      mkdirSync7(join33(this.cacheDir, "gate"), { recursive: true });
+      mkdirSync7(join34(this.cacheDir, "gate"), { recursive: true });
       writeFileSync6(f, JSON.stringify([...set]), "utf-8");
     } catch (err) {
-      log7.error(`${err.message}`);
+      log6.error(`${err.message}`);
     }
   }
 };
@@ -7364,13 +7786,13 @@ ${list}` : "",
 }
 
 // src/cli/gate-hook-command.ts
-var log8 = createLogger("ctxo:gate-hook");
+var log7 = createLogger("ctxo:gate-hook");
 var RANK_ALL = 1e5;
 var GateHookCommand = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join34(projectRoot, ".ctxo");
-    this.cacheDir = join34(this.ctxoRoot, ".cache");
+    this.ctxoRoot = join35(projectRoot, ".ctxo");
+    this.cacheDir = join35(this.ctxoRoot, ".cache");
   }
   projectRoot;
   ctxoRoot;
@@ -7386,7 +7808,7 @@ var GateHookCommand = class {
       const thresholds = resolveGateThresholds(loaded.config.gate);
       if (!thresholds.enabled) return { block: false };
       const relPath = relative6(this.projectRoot, filePath).split(sep3).join("/");
-      const indexFile = join34(this.ctxoRoot, "index", `${relPath}.json`);
+      const indexFile = join35(this.ctxoRoot, "index", `${relPath}.json`);
       if (!existsSync29(indexFile)) return { block: false };
       const fileIndex = new JsonIndexReader(this.ctxoRoot).readSingle(indexFile);
       if (!fileIndex) return { block: false };
@@ -7420,7 +7842,7 @@ var GateHookCommand = class {
       const top = blast.impactedSymbols.filter((s) => s.confidence !== "potential").map((s) => s.symbolId);
       return { block: true, reason: formatBlockReason(name, riskCount, top) };
     } catch (err) {
-      log8.error(`${err.message}`);
+      log7.error(`${err.message}`);
       return { block: false };
     }
   }
@@ -7432,7 +7854,7 @@ var GateHookCommand = class {
         if (decision.block) this.emitBlock(decision.reason ?? "ctxo guard");
       }
     } catch (err) {
-      log8.error(`${err.message}`);
+      log7.error(`${err.message}`);
     }
     process.exit(0);
   }
@@ -7448,7 +7870,7 @@ var GateHookCommand = class {
     process.exit(0);
   }
   readStdin() {
-    return new Promise((resolve6) => {
+    return new Promise((resolve5) => {
       let data = "";
       process.stdin.setEncoding("utf-8");
       process.stdin.on("data", (c) => {
@@ -7456,23 +7878,23 @@ var GateHookCommand = class {
       });
       process.stdin.on("end", () => {
         try {
-          resolve6(JSON.parse(data));
+          resolve5(JSON.parse(data));
         } catch {
-          resolve6(null);
+          resolve5(null);
         }
       });
-      process.stdin.on("error", () => resolve6(null));
+      process.stdin.on("error", () => resolve5(null));
     });
   }
 };
 
 // src/cli/gate-command.ts
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var RANK_ALL2 = 1e5;
 var GateCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join35(projectRoot, ".ctxo");
+    this.ctxoRoot = join36(projectRoot, ".ctxo");
   }
   preview(options = {}) {
     const gate = loadConfig(this.ctxoRoot).config.gate;
@@ -7545,43 +7967,50 @@ function readInitPartsFlag(args, flag) {
   }
   return { present, parts };
 }
-function getVersion() {
-  let dir = import.meta.dirname;
-  for (let i = 0; i < 10; i++) {
-    const pkg = join36(dir, "package.json");
-    if (existsSync30(pkg)) {
-      try {
-        const json = JSON.parse(readFileSync19(pkg, "utf-8"));
-        return json.version ?? "unknown";
-      } catch {
-        break;
-      }
+var BOUNDARIES_ERROR = "[ctxo] --boundaries requires by-rung or report";
+function readBoundariesFlag(args) {
+  let mode;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    let value;
+    if (arg === "--boundaries") {
+      value = args[i + 1];
+      i += 1;
+    } else if (arg.startsWith("--boundaries=")) {
+      value = arg.slice("--boundaries=".length);
+    } else {
+      continue;
     }
-    const parent = join36(dir, "..");
-    if (parent === dir) break;
-    dir = parent;
+    if (value !== "by-rung" && value !== "report") return { error: BOUNDARIES_ERROR };
+    mode = value;
   }
-  return "unknown";
-}
-function locateGitRoot(startDir) {
-  let dir = startDir;
-  for (let i = 0; i < 12; i++) {
-    if (existsSync30(join36(dir, ".git"))) return dir;
-    const parent = dirname10(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return null;
+  return mode !== void 0 ? { mode } : {};
 }
 var CliRouter = class {
   projectRoot;
-  constructor(projectRoot) {
+  cliAnchor;
+  modules;
+  constructor(projectRoot, options = {}) {
     this.projectRoot = locateGitRoot(projectRoot) ?? projectRoot;
+    this.cliAnchor = options.cliAnchor;
+  }
+  /**
+   * The opt-in modules (@ctxo/domain), loaded on first use and only by the routes that need them: the
+   * help, module and unknown commands, `index` and `doctor` (`version` reports them through its own
+   * loader call, which shares this load). Never rejects; a failed load means no module.
+   */
+  loadModules() {
+    this.modules ??= loadModulesFor(this.projectRoot, "cli", { cliAnchor: this.cliAnchor });
+    return this.modules;
   }
   async route(args) {
     const command = args[0];
+    if (command !== void 0 && isKnownModuleCommand(command)) {
+      await this.dispatchModuleCommand(command, args);
+      return;
+    }
     if (!command || args.some((arg) => arg === "--help" || arg === "-h")) {
-      this.printHelp();
+      await this.printHelp();
       return;
     }
     if (command === "--version" || command === "-v" || command === "-V") {
@@ -7662,6 +8091,7 @@ var CliRouter = class {
           process.exit(1);
           return;
         }
+        const modules = await this.loadModules();
         await new IndexCommand(this.projectRoot).run({
           files: filesArg.length > 0 ? filesArg : void 0,
           commit: commitArg,
@@ -7671,7 +8101,8 @@ var CliRouter = class {
           maxHistory: maxHistoryArg,
           cochangeCommits: cochangeCommitsArg,
           cochangeSince: cochangeSinceArg,
-          installMissing
+          installMissing,
+          modules
         });
         break;
       }
@@ -7695,16 +8126,18 @@ var CliRouter = class {
         const dryRun = args.includes("--dry-run");
         const noInstall = args.includes("--no-install");
         const noGuard = args.includes("--no-guard");
+        const domain = args.includes("--domain");
         const tools = toolsArg ? toolsArg.split(",").map((t) => t.trim()) : void 0;
         const only = readInitPartsFlag(args, "--only");
         const skip = readInitPartsFlag(args, "--skip");
-        const partsError = only.error ?? skip.error ?? (only.present && (skip.present || rulesOnly) ? "[ctxo] --only cannot be combined with --skip or --rules" : void 0);
+        const boundaries = readBoundariesFlag(args);
+        const partsError = only.error ?? skip.error ?? (only.present && (skip.present || rulesOnly) ? "[ctxo] --only cannot be combined with --skip or --rules" : void 0) ?? boundaries.error;
         if (partsError) {
           console.error(partsError);
           process.exit(1);
           return;
         }
-        await new InitCommand(this.projectRoot).run({
+        await new InitCommand(this.projectRoot, { cliAnchor: this.cliAnchor }).run({
           tools,
           yes: yesArg,
           rulesOnly,
@@ -7712,7 +8145,9 @@ var CliRouter = class {
           noInstall,
           only: only.present ? only.parts : void 0,
           skip: skip.present ? skip.parts : void 0,
-          noGuard
+          noGuard,
+          domain,
+          ...boundaries.mode !== void 0 ? { boundaries: boundaries.mode } : {}
         });
         break;
       }
@@ -7730,12 +8165,14 @@ var CliRouter = class {
         const fixArg = args.includes("--fix");
         const dryRunArg = args.includes("--dry-run");
         const yesArg = args.includes("--yes") || args.includes("-y");
+        const modules = await this.loadModules();
         await new DoctorCommand(this.projectRoot).run({
           json: jsonArg,
           quiet: quietArg,
           fix: fixArg,
           dryRun: dryRunArg,
-          yes: yesArg
+          yes: yesArg,
+          modules
         });
         break;
       }
@@ -7864,13 +8301,51 @@ var CliRouter = class {
         break;
       }
       default:
+        if (await this.dispatchModuleCommand(command, args)) return;
         console.error(`[ctxo] Unknown command: "${command}". Run "ctxo --help" for usage.`);
         process.exit(1);
         return;
     }
   }
-  printHelp() {
+  /**
+   * Runs a module command and sets `process.exitCode` from it. A known module command name without its
+   * module prints the install hint and exits 1 (the hook command exits 0 silently, as on the fast route).
+   * Resolves to false when no module registers `command` and the CLI does not know the name, so the caller
+   * reports an unknown command.
+   */
+  async dispatchModuleCommand(command, args) {
+    if (FAST_ROUTE_COMMANDS.has(command)) {
+      process.exitCode = await runFastRoute(args, this.projectRoot, { cliAnchor: this.cliAnchor });
+      return true;
+    }
+    let code;
+    try {
+      code = await runModuleCommand(command, args.slice(1), {
+        projectRoot: this.projectRoot,
+        modules: await this.loadModules()
+      });
+    } catch (err) {
+      console.error(`[ctxo] "ctxo ${command}" failed: ${err.message}`);
+      process.exitCode = 1;
+      return true;
+    }
+    if (code !== void 0) {
+      process.exitCode = typeof code === "number" && Number.isInteger(code) ? code : 1;
+      return true;
+    }
+    if (isKnownModuleCommand(command)) {
+      console.error(`[ctxo] "ctxo ${command}" needs @ctxo/domain. Install it with "ctxo install domain".`);
+      process.exitCode = 1;
+      return true;
+    }
+    return false;
+  }
+  async printHelp() {
     const v = getVersion();
+    const moduleLines = moduleHelpLines(await this.loadModules());
+    const moduleBlock = moduleLines.length > 0 ? `
+
+${moduleLines.join("\n")}` : "";
     console.error(`
 ctxo v${v} \u2014 MCP server for dependency-aware codebase context
 
@@ -7891,11 +8366,13 @@ Usage:
   ctxo status               Show index manifest
   ctxo init                 Interactive setup (rules, skills, guard, MCP, git hooks, config); the post-commit hook runs ctxo index --commit HEAD
   ctxo init --tools a,b -y  Non-interactive (claude-code,cursor,...); -y without --tools selects every tool
-  ctxo init --only <parts>  Install only these parts: rules,skills,guard,mcp,git-hooks,config
+  ctxo init --only <parts>  Install only these parts: rules,skills,guard,mcp,git-hooks,config,domain
   ctxo init --skip <parts>  Install everything except these parts
   ctxo init --no-guard      Does not install the Claude Code safe-edit guard
   ctxo init --rules         Deprecated: same as --skip git-hooks,guard
   ctxo init --dry-run       List every file init would create or change
+  ctxo init --domain        Also set up the domain layer: registry, fold guard, skill (@ctxo/domain)
+  ctxo init --boundaries <by-rung|report>   Boundary mode for --domain, without the prompt
   ctxo stats                Show usage statistics (--json, --days N, --clear)
   ctxo doctor               Health check all subsystems (--json, --quiet)
   ctxo doctor --fix         Apply fixes in dependency order: config, git hooks, skills, the safe-edit guard, rules blocks, plugins, index (--dry-run, --yes)
@@ -7908,6 +8385,7 @@ Usage:
   ctxo install ts --global  Install globally
   ctxo install py --dry-run Show command without running
   ctxo install sql          SQL plugin: .sql definitions, data edges from C#, TypeScript, Java and Go call sites
+  ctxo install domain       Install @ctxo/domain at this CLI's version (globally without package.json)
   ctxo update              Check + apply updates for ctxo + plugins
   ctxo update --check      Check only, no install
   ctxo update --print      Print install command, never execute
@@ -7925,12 +8403,10 @@ Usage:
   ctxo --version --json          Machine-readable version payload
   ctxo version                   Subcommand \u2014 verbose by default
   ctxo --help               Show this help message (also ctxo <command> --help; nothing is run)
-`.trim());
+`.trim() + moduleBlock);
   }
 };
 export {
-  CliRouter,
-  getVersion,
-  locateGitRoot
+  CliRouter
 };
-//# sourceMappingURL=cli-router-DDHH4WQH.js.map
+//# sourceMappingURL=cli-router-W56INOQ3.js.map