@ctxo/cli 0.10.0 → 0.11.1

package/dist/{cli-router-45W4IRYE.js → cli-router-2JVPBW4S.js}

@@ -19,26 +19,28 @@ import {
   loadConfig,
   makeGlobMatcher,
   watchSnapshotMinFileChanges
-} from "./chunk-I6HLEK4G.js";
+} from "./chunk-HZ4UGA6J.js";
 import {
-  atomicWrite,
-  createLogger
-} from "./chunk-6EKERTJ7.js";
+  atomicWrite
+} from "./chunk-RFEXMBTG.js";
 import {
   JsonIndexReader
-} from "./chunk-2TVHKCCU.js";
+} from "./chunk-CDGQGCVN.js";
+import {
+  createLogger
+} from "./chunk-5DSKZJNN.js";
 import {
   StalenessDetector
 } from "./chunk-PSKDDLSF.js";
 
 // src/cli/cli-router.ts
-import { readFileSync as readFileSync17, existsSync as existsSync25 } from "fs";
-import { dirname as dirname8, join as join29 } from "path";
+import { readFileSync as readFileSync17, existsSync as existsSync27 } from "fs";
+import { dirname as dirname9, join as join31 } from "path";
 
 // src/cli/index-command.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync9, statSync, readdirSync as readdirSync2 } from "fs";
-import { join as join8, relative, extname as extname3 } from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync10, statSync, readdirSync as readdirSync2 } from "fs";
+import { join as join9, relative, extname as extname3 } from "path";
 import { createRequire as createRequire3 } from "module";
 
 // src/core/staleness/content-hasher.ts
@@ -264,9 +266,9 @@ async function loadPlugins(projectRoot, options = {}) {
 }
 
 // src/cli/install-command.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 import { createRequire as createRequire2 } from "module";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/core/detection/detect-languages.ts
 import { execFileSync } from "child_process";
@@ -562,20 +564,60 @@ function buildInstallCommand(manager, packages, options = {}) {
 // src/core/install/run-package-manager.ts
 import { spawn } from "child_process";
 function runPackageManager(command, args, cwd) {
-  const resolved = resolveBinary(command);
   return new Promise((resolve4, reject) => {
-    const child = spawn(resolved, [...args], { cwd, stdio: "inherit", shell: false });
+    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) => resolve4(code ?? 0));
     child.on("error", (err) => reject(err));
   });
 }
-function resolveBinary(command) {
-  if (process.platform !== "win32") return command;
-  if (command === "bun") return "bun.exe";
-  return `${command}.cmd`;
+
+// src/core/detection/detect-java-runtime.ts
+import { spawnSync } from "child_process";
+import { existsSync as existsSync5 } from "fs";
+import { join as join4 } from "path";
+function parseJavaMajor(output) {
+  const m = output.match(/version "([^"]+)"/);
+  if (!m) return void 0;
+  const parts = m[1].split(".");
+  const major = parts[0] === "1" && parts[1] ? parseInt(parts[1], 10) : parseInt(parts[0], 10);
+  return Number.isNaN(major) ? void 0 : major;
+}
+var _javaMajorCache = void 0;
+function detectJavaMajor() {
+  if (_javaMajorCache !== void 0) {
+    return _javaMajorCache === null ? void 0 : _javaMajorCache;
+  }
+  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)) {
+    _javaMajorCache = null;
+    return void 0;
+  }
+  const r = spawnSync(bin, ["-version"], {
+    encoding: "utf-8",
+    timeout: 1e4,
+    windowsHide: true
+  });
+  if (r.error || r.status === null) {
+    _javaMajorCache = null;
+    return void 0;
+  }
+  const major = parseJavaMajor(`${r.stderr ?? ""}${r.stdout ?? ""}`);
+  _javaMajorCache = major ?? null;
+  return major;
+}
+function javaRuntimeAvailable() {
+  return (detectJavaMajor() ?? 0) >= 17;
 }
 
 // src/cli/install-command.ts
+function resolveJavaPackages(opts) {
+  if (opts.fullTier && opts.syntaxOnly) throw new Error("Cannot combine --full-tier with --syntax-only.");
+  const base = ["@ctxo/lang-java"];
+  if (opts.syntaxOnly) return base;
+  if (opts.fullTier || opts.jreAvailable) return [...base, "@ctxo/lang-java-analyzer"];
+  return base;
+}
 var InstallCommand = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
@@ -599,7 +641,7 @@ var InstallCommand = class {
       process.exitCode = 1;
       return;
     }
-    if (!options.global && !existsSync5(join4(this.projectRoot, "package.json"))) {
+    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;
@@ -609,9 +651,28 @@ var InstallCommand = class {
       process.exitCode = 1;
       return;
     }
-    const specifiers = resolvedLangs.map(
-      (lang) => options.version ? `${officialPluginFor(lang)}@${options.version}` : officialPluginFor(lang)
-    );
+    const specifiers = [];
+    for (const lang of resolvedLangs) {
+      if (lang === "java") {
+        const jreAvailable = javaRuntimeAvailable();
+        if (!jreAvailable && !options.fullTier && !options.syntaxOnly) {
+          console.error('[ctxo] JRE 17+ not found; installing Java syntax tier. Install a JRE then run "ctxo install java --full-tier" for resolved call/use edges.');
+        }
+        let javaPkgs;
+        try {
+          javaPkgs = resolveJavaPackages({ jreAvailable, fullTier: options.fullTier, syntaxOnly: options.syntaxOnly });
+        } catch (err) {
+          console.error(`[ctxo] ${err.message}`);
+          process.exitCode = 1;
+          return;
+        }
+        for (const pkg of javaPkgs) {
+          specifiers.push(options.version ? `${pkg}@${options.version}` : pkg);
+        }
+      } else {
+        specifiers.push(options.version ? `${officialPluginFor(lang)}@${options.version}` : officialPluginFor(lang));
+      }
+    }
     const invocation = buildInstallCommand(resolution.manager, specifiers, {
       global: options.global,
       workspaceRoot: !options.global && isWorkspaceRoot(this.projectRoot)
@@ -703,12 +764,12 @@ function isLockedCI(env) {
 }
 
 // src/adapters/storage/json-index-writer.ts
-import { mkdirSync, unlinkSync, existsSync as existsSync6 } from "fs";
-import { dirname as dirname4, join as join5, resolve as resolve2, sep } from "path";
+import { mkdirSync, unlinkSync, existsSync as existsSync7 } from "fs";
+import { dirname as dirname4, join as join6, resolve as resolve2, sep } from "path";
 var JsonIndexWriter = class {
   indexDir;
   constructor(ctxoRoot) {
-    this.indexDir = join5(ctxoRoot, "index");
+    this.indexDir = join6(ctxoRoot, "index");
   }
   write(fileIndex) {
     if (!fileIndex.file) {
@@ -722,7 +783,7 @@ var JsonIndexWriter = class {
   }
   writeCoChanges(matrix) {
     mkdirSync(this.indexDir, { recursive: true });
-    const targetPath = join5(this.indexDir, "co-changes.json");
+    const targetPath = join6(this.indexDir, "co-changes.json");
     this.atomicWrite(targetPath, JSON.stringify(matrix, null, 2));
   }
   atomicWrite(targetPath, content) {
@@ -730,7 +791,7 @@ var JsonIndexWriter = class {
   }
   delete(relativePath) {
     const targetPath = this.resolveIndexPath(relativePath);
-    if (existsSync6(targetPath)) {
+    if (existsSync7(targetPath)) {
       unlinkSync(targetPath);
     }
   }
@@ -758,19 +819,19 @@ var JsonIndexWriter = class {
 };
 
 // src/adapters/storage/schema-manager.ts
-import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
-import { join as join6, dirname as dirname5 } from "path";
+import { readFileSync as readFileSync4, writeFileSync, existsSync as existsSync8, mkdirSync as mkdirSync2 } from "fs";
+import { join as join7, dirname as dirname5 } from "path";
 var CURRENT_SCHEMA_VERSION = "1.0.0";
 var SchemaManager = class {
   versionFilePath;
   constructor(ctxoRoot) {
-    this.versionFilePath = join6(ctxoRoot, "index", "schema-version");
+    this.versionFilePath = join7(ctxoRoot, "index", "schema-version");
   }
   currentVersion() {
     return CURRENT_SCHEMA_VERSION;
   }
   readStoredVersion() {
-    if (!existsSync7(this.versionFilePath)) {
+    if (!existsSync8(this.versionFilePath)) {
       return void 0;
     }
     return readFileSync4(this.versionFilePath, "utf-8").trim();
@@ -787,8 +848,8 @@ var SchemaManager = class {
 };
 
 // src/adapters/storage/architecture-artifacts-writer.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "fs";
-import { join as join7, resolve as resolve3 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join8, resolve as resolve3 } from "path";
 import { tmpdir } from "os";
 var log3 = createLogger("ctxo:architecture-artifacts");
 var DRIFT_FILE_NAME = "drift-events.json";
@@ -796,20 +857,20 @@ var VIOLATIONS_FILE_NAME = "boundary-violations.json";
 var ArchitectureArtifactsWriter = class {
   indexDir;
   constructor(ctxoRoot, options = {}) {
-    this.indexDir = join7(ctxoRoot, "index");
+    this.indexDir = join8(ctxoRoot, "index");
     assertSafeWritePath(ctxoRoot, options.allowProductionPath ?? false);
   }
   writeDriftEvents(artifact) {
     mkdirSync3(this.indexDir, { recursive: true });
-    atomicWrite(join7(this.indexDir, DRIFT_FILE_NAME), JSON.stringify(artifact, null, 2));
+    atomicWrite(join8(this.indexDir, DRIFT_FILE_NAME), JSON.stringify(artifact, null, 2));
   }
   writeBoundaryViolations(artifact) {
     mkdirSync3(this.indexDir, { recursive: true });
-    atomicWrite(join7(this.indexDir, VIOLATIONS_FILE_NAME), JSON.stringify(artifact, null, 2));
+    atomicWrite(join8(this.indexDir, VIOLATIONS_FILE_NAME), JSON.stringify(artifact, null, 2));
   }
   readDriftEvents() {
-    const path = join7(this.indexDir, DRIFT_FILE_NAME);
-    if (!existsSync8(path)) return void 0;
+    const path = join8(this.indexDir, DRIFT_FILE_NAME);
+    if (!existsSync9(path)) return void 0;
     try {
       return JSON.parse(readFileSync5(path, "utf-8"));
     } catch (err) {
@@ -818,8 +879,8 @@ var ArchitectureArtifactsWriter = class {
     }
   }
   readBoundaryViolations() {
-    const path = join7(this.indexDir, VIOLATIONS_FILE_NAME);
-    if (!existsSync8(path)) return void 0;
+    const path = join8(this.indexDir, VIOLATIONS_FILE_NAME);
+    if (!existsSync9(path)) return void 0;
     try {
       return JSON.parse(readFileSync5(path, "utf-8"));
     } catch (err) {
@@ -1128,7 +1189,7 @@ var IndexCommand = class {
   supportedExtensions;
   constructor(projectRoot, ctxoRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = ctxoRoot ?? join8(projectRoot, ".ctxo");
+    this.ctxoRoot = ctxoRoot ?? join9(projectRoot, ".ctxo");
     this.supportedExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".go", ".cs"]);
   }
   loadIgnoreConfig() {
@@ -1156,7 +1217,7 @@ var IndexCommand = class {
     }
     const ignore = this.loadIgnoreConfig();
     const registry = new LanguageAdapterRegistry();
-    const { tsMorphLike, roslynAdapter, csharpTier, goTier } = await this.registerDiscoveredPlugins(registry, ignore.ignoreProjectPatterns);
+    const { tsMorphLike, roslynAdapter, csharpTier, goTier, javaTier } = await this.registerDiscoveredPlugins(registry, ignore.ignoreProjectPatterns);
     this.supportedExtensions = registry.getSupportedExtensions();
     this.printLanguagePreview();
     const writer = new JsonIndexWriter(this.ctxoRoot);
@@ -1166,7 +1227,7 @@ var IndexCommand = class {
     const revertDetector = new RevertDetector();
     let files;
     if (options.file) {
-      const fullPath = join8(this.projectRoot, options.file);
+      const fullPath = join9(this.projectRoot, options.file);
       files = [fullPath];
       console.error(`[ctxo] Incremental re-index: ${options.file}`);
     } else {
@@ -1179,8 +1240,8 @@ var IndexCommand = class {
       console.error(`[ctxo] Building codebase index... Found ${files.length} source files`);
     }
     try {
-      const { sweepStaleTmpFiles } = await import("./atomic-write-AQNYJFAG.js");
-      const swept = sweepStaleTmpFiles(join8(this.ctxoRoot, "index"));
+      const { sweepStaleTmpFiles } = await import("./atomic-write-BAFH464Q.js");
+      const swept = sweepStaleTmpFiles(join9(this.ctxoRoot, "index"));
       if (swept > 0) {
         console.error(`[ctxo] Cleaned ${swept} orphan .tmp file(s) from previous interrupted run`);
       }
@@ -1267,7 +1328,7 @@ var IndexCommand = class {
     }
     let communitySnapshot;
     if (options.skipCommunity && pendingIndices.length > 0) {
-      if (existsSync9(join8(this.ctxoRoot, "index", "communities.json"))) {
+      if (existsSync10(join9(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.`
         );
@@ -1280,6 +1341,7 @@ var IndexCommand = class {
           {
             csharpTier,
             goTier,
+            javaTier,
             tsCount: graphIndices.filter((idx) => /\.(ts|tsx|js|jsx)$/.test(idx.file)).length
           },
           gitAdapter
@@ -1317,10 +1379,12 @@ var IndexCommand = class {
     const csCount = pendingIndices.filter((e) => e.relativePath.endsWith(".cs")).length;
     const tsCount = pendingIndices.filter((e) => /\.(ts|tsx|js|jsx)$/.test(e.relativePath)).length;
     const goCount = pendingIndices.filter((e) => e.relativePath.endsWith(".go")).length;
+    const javaCount = pendingIndices.filter((e) => e.relativePath.endsWith(".java")).length;
     console.error(`[ctxo] Index complete: ${processed} files indexed`);
     if (tsCount > 0) console.error(`[ctxo]   TypeScript/JS: ${tsCount} files (full tier)`);
     if (csCount > 0) console.error(`[ctxo]   C#: ${csCount} files (${csharpTier} tier${csharpTier === "syntax" ? " - .NET SDK 8+ for full analysis" : ""})`);
     if (goCount > 0) console.error(`[ctxo]   Go: ${goCount} files (${goTier} tier${goTier === "syntax" ? " - Go 1.22+ for full analysis" : ""})`);
+    if (javaCount > 0) console.error(`[ctxo]   Java: ${javaCount} files (${javaTier} tier${javaTier === "syntax" ? ' - JRE 17+ & "ctxo install java --full-tier" for full analysis' : ""})`);
     if (roslynAdapter) await roslynAdapter.dispose();
   }
   async autoInstallMissingPlugins() {
@@ -1356,6 +1420,7 @@ var IndexCommand = class {
     let roslynAdapter = null;
     let csharpTier = "unavailable";
     let goTier = "unavailable";
+    let javaTier = "unavailable";
     for (const { plugin, adapter } of loaded) {
       if (typeof adapter.initialize === "function") {
         try {
@@ -1379,11 +1444,15 @@ var IndexCommand = class {
       if (plugin.id === "go" && typeof goCandidate.getTier === "function") {
         goTier = goCandidate.getTier();
       }
-      const activeTier = plugin.id === "csharp" ? csharpTier : plugin.id === "go" ? goTier : plugin.tier;
+      const javaCandidate = adapter;
+      if (plugin.id === "java" && typeof javaCandidate.getTier === "function") {
+        javaTier = javaCandidate.getTier();
+      }
+      const activeTier = plugin.id === "csharp" ? csharpTier : plugin.id === "go" ? goTier : plugin.id === "java" ? javaTier : plugin.tier;
       const tierSuffix = activeTier !== plugin.tier ? ` (active: ${activeTier})` : "";
       console.error(`[ctxo] Plugin ${plugin.id}@${plugin.version} (${plugin.tier} tier${tierSuffix}) \u2014 ${plugin.extensions.join(", ")}`);
     }
-    return { tsMorphLike, roslynAdapter, csharpTier, goTier };
+    return { tsMorphLike, roslynAdapter, csharpTier, goTier, javaTier };
   }
   discoverFilesIn(root, ignoreFile = () => false) {
     try {
@@ -1392,18 +1461,18 @@ var IndexCommand = class {
         encoding: "utf-8",
         maxBuffer: 10 * 1024 * 1024
       });
-      return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => this.isSupportedExtension(line)).map((line) => join8(root, line)).filter((abs) => {
+      return output.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).filter((line) => this.isSupportedExtension(line)).map((line) => join9(root, line)).filter((abs) => {
         const rel = relative(this.projectRoot, abs).replace(/\\/g, "/");
         return !ignoreFile(rel);
-      }).filter((abs) => existsSync9(abs));
+      }).filter((abs) => existsSync10(abs));
     } catch {
       console.error(`[ctxo] git ls-files failed for ${root}`);
       return [];
     }
   }
   discoverWorkspaces(ignoreProject = () => false) {
-    const pkgPath = join8(this.projectRoot, "package.json");
-    if (!existsSync9(pkgPath)) return [this.projectRoot];
+    const pkgPath = join9(this.projectRoot, "package.json");
+    if (!existsSync10(pkgPath)) return [this.projectRoot];
     try {
       const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
       const workspaces = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages;
@@ -1411,17 +1480,17 @@ var IndexCommand = class {
       const resolved = [];
       for (const ws of workspaces) {
         if (ws.endsWith("/*") || ws.endsWith("\\*")) {
-          const parentDir = join8(this.projectRoot, ws.slice(0, -2));
-          if (existsSync9(parentDir)) {
+          const parentDir = join9(this.projectRoot, ws.slice(0, -2));
+          if (existsSync10(parentDir)) {
             for (const entry of readdirSync2(parentDir, { withFileTypes: true })) {
               if (entry.isDirectory()) {
-                resolved.push(join8(parentDir, entry.name));
+                resolved.push(join9(parentDir, entry.name));
               }
             }
           }
         } else {
-          const wsPath = join8(this.projectRoot, ws);
-          if (existsSync9(wsPath)) {
+          const wsPath = join9(this.projectRoot, ws);
+          if (existsSync10(wsPath)) {
             resolved.push(wsPath);
           }
         }
@@ -1454,7 +1523,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-XOEE6VMD.js")).JsonIndexReader(this.ctxoRoot);
+    const reader = new (await import("./json-index-reader-UYS74USB.js")).JsonIndexReader(this.ctxoRoot);
     const indices = reader.readAll();
     const indexedMap = new Map(indices.map((i) => [i.file, i]));
     let staleCount = 0;
@@ -1467,7 +1536,7 @@ var IndexCommand = class {
         staleCount++;
         continue;
       }
-      if (!existsSync9(filePath)) {
+      if (!existsSync10(filePath)) {
         console.error(`[ctxo] DELETED: ${relativePath}`);
         staleCount++;
         continue;
@@ -1493,13 +1562,13 @@ var IndexCommand = class {
     console.error("[ctxo] Index is up to date");
   }
   ensureGitignore() {
-    const gitignorePath = join8(this.projectRoot, ".gitignore");
+    const gitignorePath = join9(this.projectRoot, ".gitignore");
     const cachePattern = ".ctxo/.cache/";
     const suffix = `
 # Ctxo local cache (never committed)
 ${cachePattern}
 `;
-    const existing = existsSync9(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
+    const existing = existsSync10(gitignorePath) ? readFileSync6(gitignorePath, "utf-8") : "";
     if (existing.includes(cachePattern)) return;
     writeFileSync2(gitignorePath, existing + suffix, "utf-8");
     console.error("[ctxo] Added .ctxo/.cache/ to .gitignore");
@@ -1618,8 +1687,8 @@ ${cachePattern}
   }
 };
 function pickEdgeQuality(tiers) {
-  const hasSyntaxOnly = tiers.csharpTier === "syntax" || tiers.goTier === "syntax";
-  const hasFull = tiers.tsCount > 0 || tiers.csharpTier === "full" || tiers.goTier === "full";
+  const hasSyntaxOnly = tiers.csharpTier === "syntax" || tiers.goTier === "syntax" || tiers.javaTier === "syntax";
+  const hasFull = tiers.tsCount > 0 || tiers.csharpTier === "full" || tiers.goTier === "full" || tiers.javaTier === "full";
   if (hasSyntaxOnly && hasFull) return "mixed";
   if (hasSyntaxOnly) return "syntax-only";
   return "full";
@@ -1644,11 +1713,11 @@ function countCommunities(snapshot) {
 }
 
 // src/cli/sync-command.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 var SyncCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join9(projectRoot, ".ctxo");
+    this.ctxoRoot = join10(projectRoot, ".ctxo");
   }
   async run() {
     console.error("[ctxo] Rebuilding SQLite cache from committed JSON index...");
@@ -1663,19 +1732,19 @@ var SyncCommand = class {
 };
 
 // src/cli/status-command.ts
-import { join as join10 } from "path";
-import { existsSync as existsSync10 } from "fs";
+import { join as join11 } from "path";
+import { existsSync as existsSync11 } from "fs";
 import { execFileSync as execFileSync3 } from "child_process";
 var StatusCommand = class {
   projectRoot;
   ctxoRoot;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join10(projectRoot, ".ctxo");
+    this.ctxoRoot = join11(projectRoot, ".ctxo");
   }
   run() {
-    const indexDir = join10(this.ctxoRoot, "index");
-    if (!existsSync10(indexDir)) {
+    const indexDir = join11(this.ctxoRoot, "index");
+    if (!existsSync11(indexDir)) {
       console.error('[ctxo] No index found. Run "ctxo index" first.');
       return;
     }
@@ -1690,7 +1759,7 @@ var StatusCommand = class {
     console.error(`  Indexed files:  ${indices.length}`);
     console.error(`  Total symbols:  ${totalSymbols}`);
     console.error(`  Total edges:    ${totalEdges}`);
-    const cacheExists = existsSync10(join10(this.ctxoRoot, ".cache", "symbols.db"));
+    const cacheExists = existsSync11(join11(this.ctxoRoot, ".cache", "symbols.db"));
     console.error(`  SQLite cache:   ${cacheExists ? "present" : "missing (run ctxo sync)"}`);
     if (indices.length > 0) {
       console.error("");
@@ -1719,7 +1788,7 @@ var StatusCommand = class {
 
 // src/cli/verify-command.ts
 import { mkdtempSync, rmSync } from "fs";
-import { join as join11 } from "path";
+import { join as join12 } from "path";
 import { tmpdir as tmpdir2 } from "os";
 var VerifyCommand = class {
   projectRoot;
@@ -1728,12 +1797,12 @@ var VerifyCommand = class {
   }
   async run() {
     console.error("[ctxo] Verifying index freshness...");
-    const tempDir = mkdtempSync(join11(tmpdir2(), "ctxo-verify-"));
+    const tempDir = mkdtempSync(join12(tmpdir2(), "ctxo-verify-"));
     try {
-      const tempCtxo = join11(tempDir, ".ctxo");
+      const tempCtxo = join12(tempDir, ".ctxo");
       const indexCmd = new IndexCommand(this.projectRoot, tempCtxo);
       await indexCmd.run({ skipSideEffects: true });
-      const committedReader = new JsonIndexReader(join11(this.projectRoot, ".ctxo"));
+      const committedReader = new JsonIndexReader(join12(this.projectRoot, ".ctxo"));
       const freshReader = new JsonIndexReader(tempCtxo);
       const committedIndices = committedReader.readAll();
       const freshIndices = freshReader.readAll();
@@ -1766,20 +1835,20 @@ var VerifyCommand = class {
 };
 
 // src/cli/init-command.ts
-import { join as join13 } from "path";
-import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, chmodSync } from "fs";
+import { join as join14 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync8, writeFileSync as writeFileSync4, mkdirSync as mkdirSync5, chmodSync } from "fs";
 import { createRequire as createRequire4 } from "module";
 
 // src/cli/ai-rules.ts
-import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
-import { join as join12, dirname as dirname6 } from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync7, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4 } from "fs";
+import { join as join13, dirname as dirname6 } from "path";
 var CTXO_HOOK_COMMAND = "ctxo gate-hook";
 function ensureClaudeHook(projectRoot) {
-  const filePath = join12(projectRoot, ".claude", "settings.json");
+  const filePath = join13(projectRoot, ".claude", "settings.json");
   const dir = dirname6(filePath);
-  if (!existsSync11(dir)) mkdirSync4(dir, { recursive: true });
+  if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
   const ctxoEntry = { matcher: "Edit", hooks: [{ type: "command", command: CTXO_HOOK_COMMAND }] };
-  if (!existsSync11(filePath)) {
+  if (!existsSync12(filePath)) {
     writeFileSync3(filePath, JSON.stringify({ hooks: { PreToolUse: [ctxoEntry] } }, null, 2) + "\n", "utf-8");
     return { file: ".claude/settings.json", action: "created" };
   }
@@ -1815,7 +1884,7 @@ var PLATFORMS = [
 function detectPlatforms(projectRoot) {
   const detected = /* @__PURE__ */ new Set();
   for (const p of PLATFORMS) {
-    if (p.detectPaths.some((d) => existsSync11(join12(projectRoot, d)))) {
+    if (p.detectPaths.some((d) => existsSync12(join13(projectRoot, d)))) {
       detected.add(p.id);
     }
   }
@@ -1877,15 +1946,15 @@ function generateRules(platformId) {
 function installRules(projectRoot, platformId) {
   const platform = PLATFORMS.find((p) => p.id === platformId);
   if (!platform) throw new Error(`Unknown platform: ${platformId}`);
-  const filePath = join12(projectRoot, platform.file);
+  const filePath = join13(projectRoot, platform.file);
   const content = generateRules(platformId);
   const dir = dirname6(filePath);
-  if (!existsSync11(dir)) mkdirSync4(dir, { recursive: true });
+  if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
   if (platform.mode === "create") {
     writeFileSync3(filePath, content, "utf-8");
-    return { file: platform.file, action: existsSync11(filePath) ? "updated" : "created" };
+    return { file: platform.file, action: existsSync12(filePath) ? "updated" : "created" };
   }
-  if (!existsSync11(filePath)) {
+  if (!existsSync12(filePath)) {
     writeFileSync3(filePath, content, "utf-8");
     return { file: platform.file, action: "created" };
   }
@@ -1909,15 +1978,15 @@ function escapeRegExp(s) {
 }
 var SKILLS = ["ctxo-understand", "ctxo-safe-edit", "ctxo-review-pr"];
 var SKILL_TARGET_DIR = {
-  "claude-code": (root, skill) => join12(root, ".claude", "skills", skill, "SKILL.md"),
-  cursor: (root, skill) => join12(root, ".cursor", "rules", `${skill}.mdc`)
+  "claude-code": (root, skill) => join13(root, ".claude", "skills", skill, "SKILL.md"),
+  cursor: (root, skill) => join13(root, ".cursor", "rules", `${skill}.mdc`)
 };
 function skillsSourceDir() {
   let dir = import.meta.dirname;
   for (let i = 0; i < 10; i++) {
-    const candidate = join12(dir, "skills");
-    if (existsSync11(join12(candidate, "ctxo-safe-edit", "SKILL.md"))) return candidate;
-    const parent = join12(dir, "..");
+    const candidate = join13(dir, "skills");
+    if (existsSync12(join13(candidate, "ctxo-safe-edit", "SKILL.md"))) return candidate;
+    const parent = join13(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -1929,10 +1998,10 @@ function installSkills(projectRoot, platformId) {
   const src = skillsSourceDir();
   const out = [];
   for (const skill of SKILLS) {
-    const from = join12(src, skill, "SKILL.md");
+    const from = join13(src, skill, "SKILL.md");
     const to = target(projectRoot, skill);
     mkdirSync4(dirname6(to), { recursive: true });
-    const existed = existsSync11(to);
+    const existed = existsSync12(to);
     writeFileSync3(to, readFileSync7(from, "utf-8"), "utf-8");
     out.push({ file: to, action: existed ? "updated" : "created" });
   }
@@ -1940,8 +2009,8 @@ function installSkills(projectRoot, platformId) {
 }
 var GITIGNORE_ENTRY = ".ctxo/.cache/";
 function ensureGitignore(projectRoot) {
-  const filePath = join12(projectRoot, ".gitignore");
-  if (!existsSync11(filePath)) {
+  const filePath = join13(projectRoot, ".gitignore");
+  if (!existsSync12(filePath)) {
     writeFileSync3(filePath, `# Ctxo local cache (auto-rebuilt, never committed)
 ${GITIGNORE_ENTRY}
 `, "utf-8");
@@ -1982,10 +2051,10 @@ gate:
   sensitivity: balanced   # strict | balanced | lenient
 `;
 function ensureConfig(projectRoot) {
-  const filePath = join12(projectRoot, ".ctxo", "config.yaml");
+  const filePath = join13(projectRoot, ".ctxo", "config.yaml");
   const dir = dirname6(filePath);
-  if (!existsSync11(dir)) mkdirSync4(dir, { recursive: true });
-  if (existsSync11(filePath)) {
+  if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
+  if (existsSync12(filePath)) {
     return { file: ".ctxo/config.yaml", action: "skipped" };
   }
   writeFileSync3(filePath, DEFAULT_CONFIG, "utf-8");
@@ -2020,11 +2089,11 @@ function getMcpConfigTargets(selectedPlatformIds) {
   return [...targets.values()];
 }
 function ensureMcpConfig(projectRoot, target) {
-  const filePath = join12(projectRoot, target.file);
+  const filePath = join13(projectRoot, target.file);
   const dir = dirname6(filePath);
-  if (!existsSync11(dir)) mkdirSync4(dir, { recursive: true });
+  if (!existsSync12(dir)) mkdirSync4(dir, { recursive: true });
   const entry = target.extraFields ? { ...target.extraFields, ...CTXO_MCP_ENTRY } : { ...CTXO_MCP_ENTRY };
-  if (!existsSync11(filePath)) {
+  if (!existsSync12(filePath)) {
     const config = { [target.serverKey]: { ctxo: entry } };
     writeFileSync3(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
     return { file: target.file, action: "created" };
@@ -2140,13 +2209,13 @@ var InitCommand = class {
     this.projectRoot = projectRoot;
   }
   installHooks() {
-    const hooksDir = join13(this.projectRoot, ".git", "hooks");
+    const hooksDir = join14(this.projectRoot, ".git", "hooks");
     mkdirSync5(hooksDir, { recursive: true });
     this.installHook(hooksDir, "post-commit", POST_COMMIT_CONTENT);
     this.installHook(hooksDir, "post-merge", POST_MERGE_CONTENT);
   }
   async run(options = {}) {
-    if (!existsSync12(join13(this.projectRoot, ".git"))) {
+    if (!existsSync13(join14(this.projectRoot, ".git"))) {
       console.error('[ctxo] Not a git repository. Run "git init" first.');
       process.exit(1);
     }
@@ -2183,8 +2252,8 @@ var InitCommand = class {
         clack.cancel("Setup cancelled.");
         process.exit(0);
       }
-      const fullPath = join13(this.projectRoot, indexDir);
-      if (!existsSync12(fullPath)) mkdirSync5(fullPath, { recursive: true });
+      const fullPath = join14(this.projectRoot, indexDir);
+      if (!existsSync13(fullPath)) mkdirSync5(fullPath, { recursive: true });
       console.error("");
     }
     stepNum++;
@@ -2360,8 +2429,8 @@ var InitCommand = class {
     const gitignoreResult = ensureGitignore(this.projectRoot);
     const configResult = ensureConfig(this.projectRoot);
     if (!options.rulesOnly) {
-      const indexDir = join13(this.projectRoot, ".ctxo", "index");
-      if (!existsSync12(indexDir)) mkdirSync5(indexDir, { recursive: true });
+      const indexDir = join14(this.projectRoot, ".ctxo", "index");
+      if (!existsSync13(indexDir)) mkdirSync5(indexDir, { recursive: true });
       console.error("[ctxo] \u2713 .ctxo/index/ ready");
     }
     if (configResult.action !== "skipped") {
@@ -2420,7 +2489,7 @@ var InitCommand = class {
     for (const id of toolIds) {
       const platform = PLATFORMS.find((p) => p.id === id);
       if (platform) {
-        const exists = existsSync12(join13(this.projectRoot, platform.file));
+        const exists = existsSync13(join14(this.projectRoot, platform.file));
         const action = platform.mode === "append" && exists ? "append section" : "create";
         console.error(`  ${platform.file.padEnd(42)} (${action})`);
       }
@@ -2439,21 +2508,21 @@ var InitCommand = class {
   /* ---------------------------------------------------------------- */
   async getVersion() {
     try {
-      const pkgPath = join13(this.projectRoot, "node_modules", "@ctxo", "cli", "package.json");
-      if (existsSync12(pkgPath)) {
+      const pkgPath = join14(this.projectRoot, "node_modules", "@ctxo", "cli", "package.json");
+      if (existsSync13(pkgPath)) {
         return JSON.parse(readFileSync8(pkgPath, "utf-8")).version;
       }
-      const { createRequire: createRequire8 } = await import("module");
-      const require4 = createRequire8(import.meta.url);
-      return require4("../../package.json").version;
+      const { createRequire: createRequire9 } = await import("module");
+      const require5 = createRequire9(import.meta.url);
+      return require5("../../package.json").version;
     } catch {
       return void 0;
     }
   }
   installHook(hooksDir, hookName, hookContent) {
-    const hookPath = join13(hooksDir, hookName);
+    const hookPath = join14(hooksDir, hookName);
     let existing = "";
-    if (existsSync12(hookPath)) {
+    if (existsSync13(hookPath)) {
       existing = readFileSync8(hookPath, "utf-8");
       if (existing.includes(CTXO_START)) return;
     } else {
@@ -2466,7 +2535,7 @@ var InitCommand = class {
 };
 
 // src/cli/watch-command.ts
-import { join as join14, extname as extname4, relative as relative2 } from "path";
+import { join as join15, extname as extname4, relative as relative2 } from "path";
 import { readFileSync as readFileSync9 } from "fs";
 
 // src/adapters/watcher/chokidar-watcher-adapter.ts
@@ -2516,12 +2585,12 @@ var WatchCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join14(projectRoot, ".ctxo");
+    this.ctxoRoot = join15(projectRoot, ".ctxo");
   }
   async run() {
     console.error("[ctxo] Starting file watcher...");
     const registry = new LanguageAdapterRegistry();
-    let roslynAdapter = null;
+    const keepAliveByExt = /* @__PURE__ */ new Map();
     for (const { plugin, adapter } of await loadPlugins(this.projectRoot)) {
       if (typeof adapter.initialize === "function") {
         try {
@@ -2532,15 +2601,12 @@ var WatchCommand = class {
         }
       }
       registry.register(plugin.extensions, adapter);
-      const csCandidate = adapter;
-      if (typeof csCandidate.getRoslynDelegate === "function") {
-        const roslyn = csCandidate.getRoslynDelegate();
-        if (roslyn?.isReady()) {
-          const started = await roslyn.startKeepAlive();
-          if (started) {
-            roslynAdapter = roslyn;
-            console.error("[ctxo] C# watch: Roslyn keep-alive active (full tier, <100ms per change)");
-          }
+      const capable = adapter;
+      if (typeof capable.getIncrementalReindex === "function") {
+        const cap = capable.getIncrementalReindex();
+        if (cap?.isReady() && await cap.startKeepAlive()) {
+          for (const ext of plugin.extensions) keepAliveByExt.set(ext.toLowerCase(), cap);
+          console.error(`[ctxo] ${plugin.id} watch: keep-alive active (full tier, fast incremental re-index)`);
         }
       }
       console.error(`[ctxo] Plugin ${plugin.id}@${plugin.version} (${plugin.tier} tier)`);
@@ -2561,8 +2627,9 @@ var WatchCommand = class {
       if (!adapter) return;
       const relativePath = relative2(this.projectRoot, filePath).replace(/\\/g, "/");
       try {
-        if (roslynAdapter?.isReady() && filePath.endsWith(".cs")) {
-          const result = await roslynAdapter.reindexFile(relativePath);
+        const cap = keepAliveByExt.get(extname4(filePath).toLowerCase());
+        if (cap?.isReady()) {
+          const result = await cap.reindexFile(relativePath);
           if (result) {
             const commits2 = await gitAdapter.getCommitHistory(relativePath);
             const intent2 = commits2.map((c) => ({
@@ -2598,7 +2665,7 @@ var WatchCommand = class {
             };
             writer.write(fileIndex2);
             storage.writeSymbolFile(fileIndex2);
-            console.error(`[ctxo] Re-indexed (Roslyn): ${relativePath}`);
+            console.error(`[ctxo] Re-indexed (keep-alive): ${relativePath}`);
             return;
           }
         }
@@ -2686,8 +2753,9 @@ var WatchCommand = class {
         clearTimeout(timeout);
       }
       if (communitySnapshotTimer) clearTimeout(communitySnapshotTimer);
-      const roslynShutdown = roslynAdapter ? roslynAdapter.dispose() : Promise.resolve();
-      roslynShutdown.then(() => {
+      const uniques = new Set(keepAliveByExt.values());
+      const shutdowns = Promise.all([...uniques].map((c) => c.dispose()));
+      shutdowns.then(() => {
         watcher.stop().then(() => {
           storage.close();
           console.error("[ctxo] Watcher stopped");
@@ -2731,21 +2799,21 @@ function readHeadSha() {
 }
 
 // src/cli/stats-command.ts
-import { join as join15 } from "path";
-import { existsSync as existsSync13, readFileSync as readFileSync10 } from "fs";
+import { join as join16 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync10 } from "fs";
 import initSqlJs from "sql.js";
 var StatsCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join15(projectRoot, ".ctxo");
+    this.ctxoRoot = join16(projectRoot, ".ctxo");
   }
   async run(options) {
     if (!this.isStatsEnabled()) {
       console.error("[ctxo] Stats collection is disabled in .ctxo/config.yaml");
       return;
     }
-    const dbPath = join15(this.ctxoRoot, ".cache", "symbols.db");
-    if (!existsSync13(dbPath)) {
+    const dbPath = join16(this.ctxoRoot, ".cache", "symbols.db");
+    if (!existsSync14(dbPath)) {
       if (options.json) {
         process.stdout.write(JSON.stringify(this.emptyReport(options.days)) + "\n");
       } else {
@@ -2792,8 +2860,8 @@ var StatsCommand = class {
     }
   }
   isStatsEnabled() {
-    const configPath = join15(this.ctxoRoot, "config.yaml");
-    if (!existsSync13(configPath)) return true;
+    const configPath = join16(this.ctxoRoot, "config.yaml");
+    if (!existsSync14(configPath)) return true;
     try {
       const raw = readFileSync10(configPath, "utf-8");
       const match = raw.match(/stats:\s*\n\s*enabled:\s*(true|false)/);
@@ -2884,8 +2952,8 @@ var StatsCommand = class {
 };
 
 // src/cli/doctor-command.ts
-import { join as join22 } from "path";
-import { existsSync as existsSync20 } from "fs";
+import { join as join24 } from "path";
+import { existsSync as existsSync22 } from "fs";
 
 // src/adapters/diagnostics/health-checker.ts
 var log4 = createLogger("ctxo:doctor");
@@ -3220,10 +3288,111 @@ function pluginResolves(packageName) {
   }
 }
 
+// src/adapters/diagnostics/checks/java-tier-check.ts
+import { createRequire as createRequire7 } from "module";
+import { existsSync as existsSync15, readdirSync as readdirSync3 } from "fs";
+import { join as join17, dirname as dirname7 } from "path";
+var require4 = createRequire7(import.meta.url);
+function evaluateJavaTier(i) {
+  const id = "java_tier";
+  const title = "Java analysis tier";
+  if (!i.hasJava) {
+    return { id, title, status: "pass", message: "no Java sources detected" };
+  }
+  const jreOk = (i.jreMajor ?? 0) >= 17;
+  if (jreOk && i.analyzerInstalled) {
+    return { id, title, status: "pass", message: `full tier (JRE ${i.jreMajor}, analyzer installed)` };
+  }
+  if (jreOk && !i.analyzerInstalled) {
+    return {
+      id,
+      title,
+      status: "warn",
+      message: `syntax tier (JRE ${i.jreMajor} present, analyzer missing)`,
+      fix: 'Run "ctxo install java --full-tier" for resolved call/use edges'
+    };
+  }
+  if (!jreOk && i.analyzerInstalled) {
+    return {
+      id,
+      title,
+      status: "warn",
+      message: "syntax tier (analyzer installed but no JRE 17+)",
+      fix: "Install a JRE 17+ and ensure it is on PATH (or set JAVA_HOME)"
+    };
+  }
+  return {
+    id,
+    title,
+    status: "pass",
+    message: 'syntax tier (install JRE 17+ and run "ctxo install java --full-tier" for full tier)'
+  };
+}
+function analyzerJarPresent() {
+  try {
+    const pkgJson = require4.resolve("@ctxo/lang-java-analyzer/package.json");
+    const jarPath = join17(dirname7(pkgJson), "jar", "ctxo-jdt-analyzer.jar");
+    return existsSync15(jarPath);
+  } catch {
+    return false;
+  }
+}
+var SKIP_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "target",
+  "build",
+  "out",
+  "bin",
+  ".git",
+  ".ctxo",
+  "dist",
+  "coverage"
+]);
+function findJavaFile(root, maxDepth) {
+  function walk(dir, depth) {
+    let entries;
+    try {
+      entries = readdirSync3(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isFile() && entry.name.endsWith(".java")) return true;
+    }
+    if (depth >= maxDepth) return false;
+    for (const entry of entries) {
+      if (entry.isSymbolicLink()) continue;
+      if (entry.isDirectory() && !SKIP_DIRS.has(entry.name)) {
+        if (walk(join17(dir, entry.name), depth + 1)) return true;
+      }
+    }
+    return false;
+  }
+  return walk(root, 0);
+}
+function projectHasJava(root) {
+  for (const f of ["pom.xml", "build.gradle", "build.gradle.kts"]) {
+    if (existsSync15(join17(root, f))) return true;
+  }
+  return findJavaFile(root, 4);
+}
+var JavaTierCheck = class {
+  id = "java_tier";
+  title = "Java analysis tier";
+  async run(ctx) {
+    return evaluateJavaTier({
+      hasJava: projectHasJava(ctx.projectRoot),
+      jreMajor: detectJavaMajor(),
+      analyzerInstalled: analyzerJarPresent()
+    });
+  }
+};
+
 // src/adapters/diagnostics/checks/git-check.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync14 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join18 } from "path";
 var GitBinaryCheck = class {
   id = "git_binary";
   title = "Git available";
@@ -3240,7 +3409,7 @@ var GitRepoCheck = class {
   id = "git_repo";
   title = "Git repository";
   async run(ctx) {
-    if (existsSync14(join16(ctx.projectRoot, ".git"))) {
+    if (existsSync16(join18(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' };
@@ -3248,9 +3417,9 @@ var GitRepoCheck = class {
 };
 
 // src/adapters/diagnostics/checks/index-check.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync17 } from "fs";
 import { execFileSync as execFileSync6 } from "child_process";
-import { join as join17 } from "path";
+import { join as join19 } from "path";
 function pass2(id, title, message, value) {
   return { id, title, status: "pass", message, value };
 }
@@ -3267,8 +3436,8 @@ var IndexDirectoryCheck = class {
   id = "index_directory";
   title = "Index directory";
   async run(ctx) {
-    const indexDir = join17(ctx.ctxoRoot, "index");
-    if (!existsSync15(indexDir)) {
+    const indexDir = join19(ctx.ctxoRoot, "index");
+    if (!existsSync17(indexDir)) {
       return fail(this.id, this.title, "No index directory", 'Run "ctxo index"');
     }
     const indices = getIndices(ctx);
@@ -3362,8 +3531,8 @@ var CoChangesCacheCheck = class {
   id = "co_changes_cache";
   title = "Co-changes cache";
   async run(ctx) {
-    const coChangesPath = join17(ctx.ctxoRoot, "index", "co-changes.json");
-    if (existsSync15(coChangesPath)) {
+    const coChangesPath = join19(ctx.ctxoRoot, "index", "co-changes.json");
+    if (existsSync17(coChangesPath)) {
       return pass2(this.id, this.title, "present");
     }
     return warn2(this.id, this.title, "missing (co-change analysis disabled)", 'Run "ctxo index" with git history');
@@ -3387,14 +3556,14 @@ var SchemaVersionCheck = class {
 };
 
 // src/adapters/diagnostics/checks/storage-check.ts
-import { existsSync as existsSync16, readFileSync as readFileSync11 } from "fs";
-import { join as join18 } from "path";
+import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
+import { join as join20 } from "path";
 var SqliteCacheCheck = class {
   id = "sqlite_cache";
   title = "SQLite cache";
   async run(ctx) {
-    const dbPath = join18(ctx.ctxoRoot, ".cache", "symbols.db");
-    if (!existsSync16(dbPath)) {
+    const dbPath = join20(ctx.ctxoRoot, ".cache", "symbols.db");
+    if (!existsSync18(dbPath)) {
       return { id: this.id, title: this.title, status: "warn", message: "SQLite cache missing", fix: 'Run "ctxo sync" to rebuild' };
     }
     try {
@@ -3416,14 +3585,14 @@ var SqliteCacheCheck = class {
 };
 
 // src/adapters/diagnostics/checks/config-check.ts
-import { existsSync as existsSync17, readFileSync as readFileSync12 } from "fs";
-import { join as join19 } from "path";
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
+import { join as join21 } from "path";
 var ConfigFileCheck = class {
   id = "config_file";
   title = "Config file";
   async run(ctx) {
-    const configPath = join19(ctx.ctxoRoot, "config.yaml");
-    if (!existsSync17(configPath)) {
+    const configPath = join21(ctx.ctxoRoot, "config.yaml");
+    if (!existsSync19(configPath)) {
       return { id: this.id, title: this.title, status: "warn", message: "No config.yaml (using defaults)" };
     }
     try {
@@ -3461,8 +3630,8 @@ var ConfigFileCheck = class {
 };
 
 // src/adapters/diagnostics/checks/disk-check.ts
-import { existsSync as existsSync18, readdirSync as readdirSync3, statSync as statSync2 } from "fs";
-import { join as join20 } from "path";
+import { existsSync as existsSync20, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join22 } from "path";
 var DEFAULT_THRESHOLDS = { warnMb: 100, failMb: 500 };
 var DiskUsageCheck = class {
   id = "disk_usage";
@@ -3472,7 +3641,7 @@ var DiskUsageCheck = class {
     this.thresholds = thresholds;
   }
   async run(ctx) {
-    if (!existsSync18(ctx.ctxoRoot)) {
+    if (!existsSync20(ctx.ctxoRoot)) {
       return { id: this.id, title: this.title, status: "pass", message: "no .ctxo/ directory", value: "0" };
     }
     const bytes = this.getDirSize(ctx.ctxoRoot);
@@ -3489,12 +3658,12 @@ var DiskUsageCheck = class {
   getDirSize(dirPath) {
     let total = 0;
     try {
-      const entries = readdirSync3(dirPath, { withFileTypes: true, recursive: true });
+      const entries = readdirSync4(dirPath, { withFileTypes: true, recursive: true });
       for (const entry of entries) {
         if (entry.isFile()) {
           try {
             const parent = entry.parentPath ?? entry.path ?? dirPath;
-            total += statSync2(join20(parent, entry.name)).size;
+            total += statSync2(join22(parent, entry.name)).size;
           } catch {
           }
         }
@@ -3507,9 +3676,9 @@ var DiskUsageCheck = class {
 
 // src/cli/doctor-fix.ts
 import { execFileSync as execFileSync7 } from "child_process";
-import { appendFileSync, existsSync as existsSync19, mkdirSync as mkdirSync6, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
-import { createRequire as createRequire7 } from "module";
-import { dirname as dirname7, join as join21 } from "path";
+import { appendFileSync, existsSync as existsSync21, mkdirSync as mkdirSync6, rmSync as rmSync2, unlinkSync as unlinkSync2 } from "fs";
+import { createRequire as createRequire8 } from "module";
+import { dirname as dirname8, join as join23 } from "path";
 async function applyFixes(report, options) {
   if (isCI(process.env) && !options.yes && !options.dryRun) {
     return {
@@ -3644,8 +3813,8 @@ async function fixIndex(projectRoot, dryRun) {
 }
 async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
   if (dryRun) return;
-  const indexDir = join21(ctxoRoot, "index");
-  if (!existsSync19(indexDir)) return;
+  const indexDir = join23(ctxoRoot, "index");
+  if (!existsSync21(indexDir)) return;
   const sourceFiles = listGitFiles2(projectRoot);
   if (sourceFiles.size === 0) return;
   const reader = new JsonIndexReader(ctxoRoot);
@@ -3653,9 +3822,9 @@ async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
   let removed = 0;
   for (const idx of indices) {
     if (sourceFiles.has(idx.file)) continue;
-    const jsonPath = join21(indexDir, `${idx.file}.json`);
+    const jsonPath = join23(indexDir, `${idx.file}.json`);
     try {
-      if (existsSync19(jsonPath)) {
+      if (existsSync21(jsonPath)) {
         unlinkSync2(jsonPath);
         removed += 1;
         pruneEmptyParents(jsonPath, indexDir);
@@ -3666,14 +3835,14 @@ async function pruneOrphans(projectRoot, ctxoRoot, dryRun) {
   if (removed === 0) return;
 }
 function pruneEmptyParents(filePath, stopAt) {
-  let dir = dirname7(filePath);
+  let dir = dirname8(filePath);
   while (dir !== stopAt && dir.startsWith(stopAt)) {
     try {
       rmSync2(dir, { recursive: false });
     } catch {
       return;
     }
-    dir = dirname7(dir);
+    dir = dirname8(dir);
   }
 }
 function listGitFiles2(projectRoot) {
@@ -3689,12 +3858,12 @@ function listGitFiles2(projectRoot) {
   }
 }
 async function fixSqliteCache(projectRoot, ctxoRoot, dryRun) {
-  const cacheDir = join21(ctxoRoot, ".cache");
+  const cacheDir = join23(ctxoRoot, ".cache");
   if (dryRun) return;
-  if (existsSync19(cacheDir)) rmSync2(cacheDir, { recursive: true, force: true });
+  if (existsSync21(cacheDir)) rmSync2(cacheDir, { recursive: true, force: true });
   await new SyncCommand(projectRoot).run();
 }
-var doctorRequire = createRequire7(import.meta.url);
+var doctorRequire = createRequire8(import.meta.url);
 function canResolvePlugin(lang) {
   try {
     doctorRequire.resolve(`${officialPluginFor(lang)}/package.json`);
@@ -3708,8 +3877,8 @@ function isCI(env) {
 }
 function writeLog(ctxoRoot, attempts, halted, reason) {
   try {
-    if (!existsSync19(ctxoRoot)) mkdirSync6(ctxoRoot, { recursive: true });
-    const path = join21(ctxoRoot, "doctor-fix.log");
+    if (!existsSync21(ctxoRoot)) mkdirSync6(ctxoRoot, { recursive: true });
+    const path = join23(ctxoRoot, "doctor-fix.log");
     const ts = (/* @__PURE__ */ new Date()).toISOString();
     const lines = [`# ${ts} doctor --fix${halted ? " (halted: " + reason + ")" : ""}`];
     for (const a of attempts) {
@@ -3742,10 +3911,10 @@ var DoctorCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join22(projectRoot, ".ctxo");
+    this.ctxoRoot = join24(projectRoot, ".ctxo");
   }
   async run(options = {}) {
-    const { getVersion: getVersion2 } = await import("./cli-router-45W4IRYE.js");
+    const { getVersion: getVersion2 } = await import("./cli-router-2JVPBW4S.js");
     console.error(`ctxo v${getVersion2()} \u2014 health check
 `);
     const checks = [
@@ -3760,6 +3929,7 @@ var DoctorCommand = class {
       new TsMorphCheck(),
       new TreeSitterCheck(),
       new LanguageCoverageCheck(),
+      new JavaTierCheck(),
       new DiskUsageCheck(),
       new SymbolCountCheck(),
       new EdgeCountCheck(),
@@ -3767,8 +3937,8 @@ var DoctorCommand = class {
       new CoChangesCacheCheck(),
       new SchemaVersionCheck()
     ];
-    const indexDir = join22(this.ctxoRoot, "index");
-    const indices = existsSync20(indexDir) ? new JsonIndexReader(this.ctxoRoot).readAll() : [];
+    const indexDir = join24(this.ctxoRoot, "index");
+    const indices = existsSync22(indexDir) ? new JsonIndexReader(this.ctxoRoot).readAll() : [];
     const checker = new HealthChecker(checks, { quiet: Boolean(options.quiet) });
     const report = await checker.runAll({
       projectRoot: this.projectRoot,
@@ -3809,8 +3979,8 @@ var DoctorCommand = class {
 };
 
 // src/cli/visualize-command.ts
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync5, existsSync as existsSync21 } from "fs";
-import { join as join23, basename } from "path";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync5, existsSync as existsSync23 } from "fs";
+import { join as join25, basename } from "path";
 import { execFile } from "child_process";
 
 // src/cli/graph-loader.ts
@@ -3826,7 +3996,7 @@ function loadGraph(ctxoRoot) {
 var VisualizeCommand = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join23(projectRoot, ".ctxo");
+    this.ctxoRoot = join25(projectRoot, ".ctxo");
   }
   projectRoot;
   ctxoRoot;
@@ -3969,7 +4139,7 @@ var VisualizeCommand = class {
     const templatePath = this.getTemplatePath();
     const template = readFileSync13(templatePath, "utf-8");
     const html = template.replace("/*__CTXO_DATA__*/null", JSON.stringify(payload));
-    const outputPath = options.output ?? join23(this.ctxoRoot, "visualize.html");
+    const outputPath = options.output ?? join25(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`);
@@ -3980,9 +4150,9 @@ var VisualizeCommand = class {
   getTemplatePath() {
     let dir = import.meta.dirname;
     for (let i = 0; i < 10; i++) {
-      const candidate = join23(dir, "pages", "visualize-template.html");
-      if (existsSync21(candidate)) return candidate;
-      const parent = join23(dir, "..");
+      const candidate = join25(dir, "pages", "visualize-template.html");
+      if (existsSync23(candidate)) return candidate;
+      const parent = join25(dir, "..");
       if (parent === dir) break;
       dir = parent;
     }
@@ -4006,8 +4176,8 @@ var VisualizeCommand = class {
 };
 
 // src/cli/update-command.ts
-import { existsSync as existsSync22, readFileSync as readFileSync14 } from "fs";
-import { join as join24 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync14 } from "fs";
+import { join as join26 } from "path";
 
 // src/core/update/registry-client.ts
 import { request } from "https";
@@ -4325,8 +4495,8 @@ var UpdateCommand = class {
     return this.projectHasCtxoDep() ? "execute" : "print";
   }
   projectHasCtxoDep() {
-    const pkg = join24(this.projectRoot, "package.json");
-    if (!existsSync22(pkg)) return false;
+    const pkg = join26(this.projectRoot, "package.json");
+    if (!existsSync24(pkg)) return false;
     try {
       const json = JSON.parse(readFileSync14(pkg, "utf-8"));
       const merged = { ...json.dependencies ?? {}, ...json.devDependencies ?? {} };
@@ -4363,11 +4533,11 @@ function isLockedCI2(env) {
 }
 
 // src/cli/blast-radius-command.ts
-import { join as join25 } from "path";
+import { join as join27 } from "path";
 var BlastRadiusCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join25(projectRoot, ".ctxo");
+    this.ctxoRoot = join27(projectRoot, ".ctxo");
   }
   run(options) {
     const { graph } = loadGraph(this.ctxoRoot);
@@ -4395,8 +4565,8 @@ var BlastRadiusCommand = class {
 };
 
 // src/cli/gate-hook-command.ts
-import { join as join27, relative as relative3, sep as sep2 } from "path";
-import { existsSync as existsSync24, readFileSync as readFileSync16 } from "fs";
+import { join as join29, relative as relative3, sep as sep2 } from "path";
+import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
 
 // src/core/gate/gate-config.ts
 var DIAL = {
@@ -4463,8 +4633,8 @@ function transcriptHasBlastCheck(lines, symbolId) {
 }
 
 // src/adapters/gate/gate-session-store.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
-import { join as join26 } from "path";
+import { existsSync as existsSync25, mkdirSync as mkdirSync7, readFileSync as readFileSync15, writeFileSync as writeFileSync6 } from "fs";
+import { join as join28 } from "path";
 var log7 = createLogger("ctxo:gate-store");
 var GateSessionStore = class {
   constructor(cacheDir) {
@@ -4473,11 +4643,11 @@ var GateSessionStore = class {
   cacheDir;
   file(sessionId) {
     const safe = sessionId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return join26(this.cacheDir, "gate", `${safe}.json`);
+    return join28(this.cacheDir, "gate", `${safe}.json`);
   }
   read(sessionId) {
     const f = this.file(sessionId);
-    if (!existsSync23(f)) return /* @__PURE__ */ new Set();
+    if (!existsSync25(f)) return /* @__PURE__ */ new Set();
     try {
       return new Set(JSON.parse(readFileSync15(f, "utf-8")));
     } catch (err) {
@@ -4493,7 +4663,7 @@ var GateSessionStore = class {
       const set = this.read(sessionId);
       set.add(symbolId);
       const f = this.file(sessionId);
-      mkdirSync7(join26(this.cacheDir, "gate"), { recursive: true });
+      mkdirSync7(join28(this.cacheDir, "gate"), { recursive: true });
       writeFileSync6(f, JSON.stringify([...set]), "utf-8");
     } catch (err) {
       log7.error(`${err.message}`);
@@ -4532,8 +4702,8 @@ var RANK_ALL = 1e5;
 var GateHookCommand = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.ctxoRoot = join27(projectRoot, ".ctxo");
-    this.cacheDir = join27(this.ctxoRoot, ".cache");
+    this.ctxoRoot = join29(projectRoot, ".ctxo");
+    this.cacheDir = join29(this.ctxoRoot, ".cache");
   }
   projectRoot;
   ctxoRoot;
@@ -4549,11 +4719,11 @@ var GateHookCommand = class {
       const thresholds = resolveGateThresholds(loaded.config.gate);
       if (!thresholds.enabled) return { block: false };
       const relPath = relative3(this.projectRoot, filePath).split(sep2).join("/");
-      const indexFile = join27(this.ctxoRoot, "index", `${relPath}.json`);
-      if (!existsSync24(indexFile)) return { block: false };
+      const indexFile = join29(this.ctxoRoot, "index", `${relPath}.json`);
+      if (!existsSync26(indexFile)) return { block: false };
       const fileIndex = new JsonIndexReader(this.ctxoRoot).readSingle(indexFile);
       if (!fileIndex) return { block: false };
-      if (!existsSync24(filePath)) return { block: false };
+      if (!existsSync26(filePath)) return { block: false };
       const source = readFileSync16(filePath, "utf-8");
       const line = lineOfSnippet(source, oldString);
       if (line === null) return { block: false };
@@ -4561,7 +4731,7 @@ var GateHookCommand = class {
       if (!symbolId) return { block: false };
       const store = new GateSessionStore(this.cacheDir);
       if (store.hasWarned(payload.session_id, symbolId)) return { block: false };
-      if (payload.transcript_path && existsSync24(payload.transcript_path)) {
+      if (payload.transcript_path && existsSync26(payload.transcript_path)) {
         const lines = readFileSync16(payload.transcript_path, "utf-8").split("\n").filter(Boolean);
         if (transcriptHasBlastCheck(lines, symbolId)) return { block: false };
       }
@@ -4627,12 +4797,12 @@ var GateHookCommand = class {
 };
 
 // src/cli/gate-command.ts
-import { join as join28 } from "path";
+import { join as join30 } from "path";
 var RANK_ALL2 = 1e5;
 var GateCommand = class {
   ctxoRoot;
   constructor(projectRoot) {
-    this.ctxoRoot = join28(projectRoot, ".ctxo");
+    this.ctxoRoot = join30(projectRoot, ".ctxo");
   }
   preview(options = {}) {
     const gate = loadConfig(this.ctxoRoot).config.gate;
@@ -4672,8 +4842,8 @@ var GateCommand = class {
 function getVersion() {
   let dir = import.meta.dirname;
   for (let i = 0; i < 10; i++) {
-    const pkg = join29(dir, "package.json");
-    if (existsSync25(pkg)) {
+    const pkg = join31(dir, "package.json");
+    if (existsSync27(pkg)) {
       try {
         const json = JSON.parse(readFileSync17(pkg, "utf-8"));
         return json.version ?? "unknown";
@@ -4681,7 +4851,7 @@ function getVersion() {
         break;
       }
     }
-    const parent = join29(dir, "..");
+    const parent = join31(dir, "..");
     if (parent === dir) break;
     dir = parent;
   }
@@ -4690,8 +4860,8 @@ function getVersion() {
 function locateGitRoot(startDir) {
   let dir = startDir;
   for (let i = 0; i < 12; i++) {
-    if (existsSync25(join29(dir, ".git"))) return dir;
-    const parent = dirname8(dir);
+    if (existsSync27(join31(dir, ".git"))) return dir;
+    const parent = dirname9(dir);
     if (parent === dir) break;
     dir = parent;
   }
@@ -4808,6 +4978,8 @@ var CliRouter = class {
           else if (a === "--global" || a === "-g") flagValues["global"] = true;
           else if (a === "--dry-run") flagValues["dryRun"] = true;
           else if (a === "--force") flagValues["force"] = true;
+          else if (a === "--full-tier") flagValues["fullTier"] = true;
+          else if (a === "--syntax-only") flagValues["syntaxOnly"] = true;
           else if (a === "--pm") {
             const next = args[++i];
             if (!next) {
@@ -4838,6 +5010,8 @@ var CliRouter = class {
           global: flagValues["global"] === true,
           dryRun: flagValues["dryRun"] === true,
           force: flagValues["force"] === true,
+          fullTier: flagValues["fullTier"] === true,
+          syntaxOnly: flagValues["syntaxOnly"] === true,
           pm: typeof flagValues["pm"] === "string" ? flagValues["pm"] : void 0,
           version: typeof flagValues["version"] === "string" ? flagValues["version"] : void 0
         });
@@ -4972,4 +5146,4 @@ export {
   getVersion,
   locateGitRoot
 };
-//# sourceMappingURL=cli-router-45W4IRYE.js.map
+//# sourceMappingURL=cli-router-2JVPBW4S.js.map