repowisestage 0.0.68 → 0.0.70

package/dist/bin/repowise.js

@@ -620,388 +620,69 @@ var init_process_manager = __esm({
   }
 });
 
-// ../listener/dist/service-installer.js
-var service_installer_exports = {};
-__export(service_installer_exports, {
-  install: () => install,
-  isInstalled: () => isInstalled,
-  isServiceRunning: () => isServiceRunning,
-  stopService: () => stopService,
-  uninstall: () => uninstall
-});
-import { execFile as execFile4 } from "child_process";
-import { writeFile as writeFile8, mkdir as mkdir8, unlink as unlink6 } from "fs/promises";
-import { homedir as homedir3 } from "os";
-import { join as join13 } from "path";
-function exec(cmd, args) {
-  return new Promise((resolve5, reject) => {
-    execFile4(cmd, args, (err, stdout) => {
-      if (err) {
-        reject(err);
-        return;
-      }
-      resolve5(String(stdout ?? ""));
-    });
-  });
-}
-function plistPath() {
-  return join13(homedir3(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
-}
-function logDir() {
-  return join13(getConfigDir(), "logs");
-}
-function buildPlist() {
-  const cmd = resolveListenerCommand();
-  const logs = logDir();
-  const programArgs = [process.execPath, cmd.script, ...cmd.args].map((a) => `        <string>${a}</string>`).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
-<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
-  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
-<plist version="1.0">
-<dict>
-    <key>Label</key>
-    <string>${PLIST_LABEL}</string>
-    <key>ProgramArguments</key>
-    <array>
-${programArgs}
-    </array>
-    <key>RunAtLoad</key>
-    <true/>
-    <key>KeepAlive</key>
-    <true/>
-    <key>StandardOutPath</key>
-    <string>${join13(logs, "listener-stdout.log")}</string>
-    <key>StandardErrorPath</key>
-    <string>${join13(logs, "listener-stderr.log")}</string>
-    <key>ProcessType</key>
-    <string>Background</string>
-    <!--
-      SoftResourceLimits: raise the open-file descriptor limit from the macOS
-      default of 256 to 4096. When multiple LSP child processes (rust-analyzer,
-      jdtls, etc.) share the listener's fd budget they can exhaust the default
-      very quickly, causing EMFILE errors. 4096 matches the system-wide default
-      set by /etc/launchd.conf on modern macOS and gives enough headroom for
-      ~10 concurrent LSP servers each opening ~300 fds.
-
-      MemoryLimit: intentionally NOT set here. The launchd MemoryLimit key
-      (available since macOS 12.3) terminates the entire LaunchAgent when RSS
-      exceeds the threshold \u2014 it cannot be scoped to individual child processes.
-      Killing the listener to evict a memory-hungry rust-analyzer instance is
-      undesirable. Per-child memory pressure is better handled by the LSP
-      process manager (process-manager.ts) or by OS-level memory pressure
-      signals (SIGTERM on macOS, OOM killer on Linux).
-    -->
-    <key>SoftResourceLimits</key>
-    <dict>
-        <key>NumberOfFiles</key>
-        <integer>4096</integer>
-    </dict>
-</dict>
-</plist>`;
-}
-async function darwinInstall() {
-  await mkdir8(logDir(), { recursive: true });
-  await mkdir8(join13(homedir3(), "Library", "LaunchAgents"), { recursive: true });
-  try {
-    await exec("launchctl", ["unload", plistPath()]);
-  } catch {
-  }
-  await writeFile8(plistPath(), buildPlist());
-  await exec("launchctl", ["load", plistPath()]);
-}
-async function darwinUninstall() {
-  try {
-    await exec("launchctl", ["unload", plistPath()]);
-  } catch {
-  }
-  try {
-    await unlink6(plistPath());
-  } catch {
-  }
-}
-async function darwinIsInstalled() {
-  try {
-    const stdout = await exec("launchctl", ["list"]);
-    return stdout.includes(PLIST_LABEL);
-  } catch {
-    return false;
-  }
-}
-function unitPath() {
-  return join13(homedir3(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
-}
-function buildUnit() {
-  const cmd = resolveListenerCommand();
-  const execStart = [process.execPath, cmd.script, ...cmd.args].join(" ");
-  const logs = logDir();
-  return `[Unit]
-Description=RepoWise Listener
-After=network-online.target
-Wants=network-online.target
-
-[Service]
-Type=simple
-ExecStart=${execStart}
-Restart=always
-RestartSec=10
-StandardOutput=append:${join13(logs, "listener-stdout.log")}
-StandardError=append:${join13(logs, "listener-stderr.log")}
-
-[Install]
-WantedBy=default.target`;
-}
-async function linuxInstall() {
-  await mkdir8(logDir(), { recursive: true });
-  await mkdir8(join13(homedir3(), ".config", "systemd", "user"), { recursive: true });
-  await writeFile8(unitPath(), buildUnit());
-  await exec("systemctl", ["--user", "daemon-reload"]);
-  await exec("systemctl", ["--user", "enable", SYSTEMD_SERVICE]);
-  await exec("systemctl", ["--user", "start", SYSTEMD_SERVICE]);
-}
-async function linuxUninstall() {
-  try {
-    await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
-  } catch {
-  }
-  try {
-    await exec("systemctl", ["--user", "disable", SYSTEMD_SERVICE]);
-  } catch {
-  }
-  try {
-    await unlink6(unitPath());
-  } catch {
-  }
-  try {
-    await exec("systemctl", ["--user", "daemon-reload"]);
-  } catch {
-  }
+// ../listener/dist/lsp/registry.js
+function resolvePhpLspOverride(env = process.env, configOverrides) {
+  const envChoice = env["PHP_LSP"];
+  const configChoice = configOverrides?.["php"];
+  const choice = envChoice ?? configChoice;
+  if (choice !== "intelephense")
+    return null;
+  return {
+    id: "intelephense",
+    displayName: "intelephense (user-provided)",
+    command: "intelephense",
+    args: ["--stdio"],
+    extensions: [".php"],
+    lspLanguageId: "php",
+    installHint: "Intelephense override is enabled \u2014 install it yourself: `npm i -g intelephense` (commercial licence required for premium features)."
+  };
 }
-async function linuxIsInstalled() {
-  try {
-    const stdout = await exec("systemctl", ["--user", "is-enabled", SYSTEMD_SERVICE]);
-    return stdout.trim() === "enabled";
-  } catch {
-    return false;
+function getEffectiveConfig(lang, env = process.env, configOverrides) {
+  if (lang === "php") {
+    const override = resolvePhpLspOverride(env, configOverrides);
+    if (override)
+      return override;
   }
+  return LSP_REGISTRY[lang]?.[0];
 }
-async function win32Install() {
-  await mkdir8(logDir(), { recursive: true });
-  const cmd = resolveListenerCommand();
-  const taskCmd = [process.execPath, cmd.script, ...cmd.args].map((a) => `"${a}"`).join(" ");
-  await exec("schtasks", [
-    "/create",
-    "/tn",
-    TASK_NAME,
-    "/tr",
-    taskCmd,
-    "/sc",
-    "onlogon",
-    "/ru",
-    process.env.USERNAME ?? "",
-    "/f"
-  ]);
-  await exec("schtasks", ["/run", "/tn", TASK_NAME]);
-}
-async function win32Uninstall() {
-  try {
-    await exec("schtasks", ["/end", "/tn", TASK_NAME]);
-  } catch {
-  }
-  try {
-    await exec("schtasks", ["/delete", "/tn", TASK_NAME, "/f"]);
-  } catch {
+function getEffectiveConfigList(lang, env = process.env, configOverrides) {
+  if (lang === "php") {
+    const override = resolvePhpLspOverride(env, configOverrides);
+    if (override)
+      return [override];
   }
+  return LSP_REGISTRY[lang] ?? [];
 }
-async function win32IsInstalled() {
-  try {
-    await exec("schtasks", ["/query", "/tn", TASK_NAME]);
-    return true;
-  } catch {
-    return false;
+function detectLanguage(path) {
+  const dot = path.lastIndexOf(".");
+  if (dot < 0)
+    return null;
+  const ext = path.slice(dot).toLowerCase();
+  for (const [lang, configs] of Object.entries(LSP_REGISTRY)) {
+    if (configs.some((c) => c.extensions.includes(ext))) {
+      return lang;
+    }
   }
+  return null;
 }
-async function darwinStop() {
-  try {
-    await exec("launchctl", ["unload", plistPath()]);
-  } catch {
+async function probeServers(isAvailable, env = process.env, configOverrides) {
+  const out = [];
+  for (const lang of Object.keys(LSP_REGISTRY)) {
+    const configs = getEffectiveConfigList(lang, env, configOverrides);
+    const checkedCommands = configs.map((c) => c.command);
+    let found = null;
+    for (const config2 of configs) {
+      if (await isAvailable(config2.command)) {
+        found = config2;
+        break;
+      }
+    }
+    out.push({ language: lang, config: found, checkedCommands });
   }
+  return out;
 }
-async function linuxStop() {
-  await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
-}
-async function win32Stop() {
-  await exec("schtasks", ["/end", "/tn", TASK_NAME]);
-}
-async function darwinIsServiceRunning() {
-  try {
-    const stdout = await exec("launchctl", ["list", PLIST_LABEL]);
-    const pidMatch = stdout.match(/"PID"\s*=\s*(\d+)/);
-    return pidMatch !== null && parseInt(pidMatch[1], 10) > 0;
-  } catch {
-    return false;
-  }
-}
-async function linuxIsServiceRunning() {
-  try {
-    const stdout = await exec("systemctl", ["--user", "is-active", SYSTEMD_SERVICE]);
-    return stdout.trim() === "active";
-  } catch {
-    return false;
-  }
-}
-async function win32IsServiceRunning() {
-  try {
-    const stdout = await exec("schtasks", ["/query", "/tn", TASK_NAME, "/fo", "CSV"]);
-    return stdout.includes("Running");
-  } catch {
-    return false;
-  }
-}
-async function stopService() {
-  switch (process.platform) {
-    case "darwin":
-      await darwinStop();
-      break;
-    case "linux":
-      await linuxStop();
-      break;
-    case "win32":
-      await win32Stop();
-      break;
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
-  }
-}
-async function install() {
-  switch (process.platform) {
-    case "darwin":
-      await darwinInstall();
-      break;
-    case "linux":
-      await linuxInstall();
-      break;
-    case "win32":
-      await win32Install();
-      break;
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
-  }
-}
-async function uninstall() {
-  switch (process.platform) {
-    case "darwin":
-      await darwinUninstall();
-      break;
-    case "linux":
-      await linuxUninstall();
-      break;
-    case "win32":
-      await win32Uninstall();
-      break;
-    default:
-      throw new Error(`Unsupported platform: ${process.platform}`);
-  }
-}
-async function isInstalled() {
-  switch (process.platform) {
-    case "darwin":
-      return darwinIsInstalled();
-    case "linux":
-      return linuxIsInstalled();
-    case "win32":
-      return win32IsInstalled();
-    default:
-      return false;
-  }
-}
-async function isServiceRunning() {
-  switch (process.platform) {
-    case "darwin":
-      return darwinIsServiceRunning();
-    case "linux":
-      return linuxIsServiceRunning();
-    case "win32":
-      return win32IsServiceRunning();
-    default:
-      return false;
-  }
-}
-var IS_STAGING, PLIST_LABEL, SYSTEMD_SERVICE, TASK_NAME;
-var init_service_installer = __esm({
-  "../listener/dist/service-installer.js"() {
-    "use strict";
-    init_config_dir();
-    init_process_manager();
-    IS_STAGING = true ? true : false;
-    PLIST_LABEL = IS_STAGING ? "com.repowise-staging.listener" : "com.repowise.listener";
-    SYSTEMD_SERVICE = IS_STAGING ? "repowise-staging-listener" : "repowise-listener";
-    TASK_NAME = IS_STAGING ? "RepoWise Staging Listener" : "RepoWise Listener";
-  }
-});
-
-// ../listener/dist/lsp/registry.js
-function resolvePhpLspOverride(env = process.env, configOverrides) {
-  const envChoice = env["PHP_LSP"];
-  const configChoice = configOverrides?.["php"];
-  const choice = envChoice ?? configChoice;
-  if (choice !== "intelephense")
-    return null;
-  return {
-    id: "intelephense",
-    displayName: "intelephense (user-provided)",
-    command: "intelephense",
-    args: ["--stdio"],
-    extensions: [".php"],
-    lspLanguageId: "php",
-    installHint: "Intelephense override is enabled \u2014 install it yourself: `npm i -g intelephense` (commercial licence required for premium features)."
-  };
-}
-function getEffectiveConfig(lang, env = process.env, configOverrides) {
-  if (lang === "php") {
-    const override = resolvePhpLspOverride(env, configOverrides);
-    if (override)
-      return override;
-  }
-  return LSP_REGISTRY[lang]?.[0];
-}
-function getEffectiveConfigList(lang, env = process.env, configOverrides) {
-  if (lang === "php") {
-    const override = resolvePhpLspOverride(env, configOverrides);
-    if (override)
-      return [override];
-  }
-  return LSP_REGISTRY[lang] ?? [];
-}
-function detectLanguage(path) {
-  const dot = path.lastIndexOf(".");
-  if (dot < 0)
-    return null;
-  const ext = path.slice(dot).toLowerCase();
-  for (const [lang, configs] of Object.entries(LSP_REGISTRY)) {
-    if (configs.some((c) => c.extensions.includes(ext))) {
-      return lang;
-    }
-  }
-  return null;
-}
-async function probeServers(isAvailable, env = process.env, configOverrides) {
-  const out = [];
-  for (const lang of Object.keys(LSP_REGISTRY)) {
-    const configs = getEffectiveConfigList(lang, env, configOverrides);
-    const checkedCommands = configs.map((c) => c.command);
-    let found = null;
-    for (const config2 of configs) {
-      if (await isAvailable(config2.command)) {
-        found = config2;
-        break;
-      }
-    }
-    out.push({ language: lang, config: found, checkedCommands });
-  }
-  return out;
-}
-function getBuildSpec(language) {
-  return BUILD_SPECS[language] ?? null;
+function getBuildSpec(language) {
+  return BUILD_SPECS[language] ?? null;
 }
 var LSP_REGISTRY, BUILD_SPECS;
 var init_registry = __esm({
@@ -1415,7 +1096,7 @@ var init_registry = __esm({
 });
 
 // ../listener/dist/lsp/jdk-probe.js
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 function parseJavaMajorVersion(stderr) {
   const modernMatch = /\b(?:openjdk|java) version "(\d+)(?:\.\d+)*(?:[._]\w+)?"/.exec(stderr);
   if (!modernMatch?.[1])
@@ -1430,166 +1111,503 @@ function parseJavaMajorVersion(stderr) {
       return Number.isFinite(legacy) ? legacy : void 0;
     }
   }
-  return first;
+  return first;
+}
+async function probeJdk(options = {}) {
+  const timeoutMs = options.timeoutMs ?? 5e3;
+  return new Promise((resolve5) => {
+    let stderr = "";
+    let settled = false;
+    const child = spawn2("java", ["-version"], { stdio: ["ignore", "pipe", "pipe"] });
+    const timer = setTimeout(() => {
+      if (settled)
+        return;
+      settled = true;
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      resolve5({ present: false });
+    }, timeoutMs);
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", () => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve5({ present: false });
+    });
+    child.on("close", (code) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      if (code !== 0) {
+        resolve5({ present: false, rawOutput: stderr.trim() });
+        return;
+      }
+      const major = parseJavaMajorVersion(stderr);
+      if (major === void 0) {
+        resolve5({ present: true, rawOutput: stderr.trim() });
+        return;
+      }
+      resolve5({ present: true, majorVersion: major, rawOutput: stderr.trim() });
+    });
+  });
+}
+var init_jdk_probe = __esm({
+  "../listener/dist/lsp/jdk-probe.js"() {
+    "use strict";
+  }
+});
+
+// ../listener/dist/lsp/native-installer.js
+import { createWriteStream } from "fs";
+import { promises as fs } from "fs";
+import { createGunzip } from "zlib";
+import { spawn as spawn3 } from "child_process";
+import { pipeline } from "stream/promises";
+import { createHash as createHash3 } from "crypto";
+import { join as join13, dirname as dirname5 } from "path";
+function getNativeLspDir() {
+  return join13(getLspInstallDir(), "native");
+}
+function getNativeLspBinDir() {
+  return join13(getNativeLspDir(), "bin");
+}
+async function ensureNativeLspInstalled(lspKey) {
+  const entry = NATIVE_LSP_VERSIONS[lspKey];
+  if (!entry)
+    return { installed: false, alreadyPresent: false, skipped: "no-native-version" };
+  const platformKey = getCurrentPlatformKey();
+  if (!platformKey) {
+    return { installed: false, alreadyPresent: false, skipped: "unsupported-platform" };
+  }
+  const asset = entry.assets[platformKey];
+  if (!asset) {
+    return { installed: false, alreadyPresent: false, skipped: "unsupported-platform" };
+  }
+  if (entry.requiresJdk !== void 0) {
+    const jdk = await probeJdk();
+    if (!jdk.present || jdk.majorVersion === void 0 || jdk.majorVersion < entry.requiresJdk) {
+      return {
+        installed: false,
+        alreadyPresent: false,
+        skipped: "jvm-missing",
+        error: `${lspKey} requires JDK ${entry.requiresJdk.toString()}+ (found: ${jdk.present ? `Java ${jdk.majorVersion?.toString() ?? "?"}` : "no java on PATH"}). Install with: brew install openjdk@21 (macOS) or apt install openjdk-21-jdk (Linux)`
+      };
+    }
+  }
+  const usesWrapper = Boolean(asset.launcherJarGlob && asset.wrapperBinaryName);
+  const versionDir = join13(getNativeLspDir(), lspKey, entry.version);
+  if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
+    const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
+    const shimPath = join13(getNativeLspBinDir(), asset.wrapperBinaryName);
+    if (jarPath && await pathExists(shimPath)) {
+      return { installed: false, alreadyPresent: true, binaryPath: shimPath };
+    }
+  } else {
+    const installedBinary = join13(versionDir, asset.binaryPath);
+    if (await pathExists(installedBinary)) {
+      await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
+      return { installed: false, alreadyPresent: true, binaryPath: installedBinary };
+    }
+  }
+  try {
+    await fs.mkdir(versionDir, { recursive: true });
+    const tmpDownload = join13(versionDir, `.${asset.filename}.download`);
+    const downloadUrl = entry.source.kind === "github-release" ? `https://github.com/${entry.source.repo}/releases/download/${entry.version}/${asset.filename}` : asset.url ?? "";
+    if (!downloadUrl) {
+      return {
+        installed: false,
+        alreadyPresent: false,
+        error: `direct-url asset for ${lspKey} missing required \`url\` field`
+      };
+    }
+    await downloadFile(downloadUrl, tmpDownload);
+    if (asset.sha256) {
+      const actual = await sha256File(tmpDownload);
+      if (actual !== asset.sha256) {
+        await fs.unlink(tmpDownload).catch(() => void 0);
+        return {
+          installed: false,
+          alreadyPresent: false,
+          error: `SHA256 mismatch for ${lspKey}: expected ${asset.sha256}, got ${actual}`
+        };
+      }
+    } else {
+      console.warn(`[lsp-install] WARN: SHA256 verification skipped for ${lspKey} (no pin in NATIVE_LSP_VERSIONS) \u2014 run apps/listener/scripts/pin-native-shas.ts to record one`);
+    }
+    await extractAsset(tmpDownload, versionDir, asset);
+    await fs.unlink(tmpDownload).catch(() => void 0);
+    if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
+      const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
+      if (!jarPath) {
+        return {
+          installed: false,
+          alreadyPresent: false,
+          error: `extract completed but no JAR matched ${asset.launcherJarGlob} in ${versionDir}`
+        };
+      }
+      const shimPath = await writeJdtlsWrapper({
+        binaryName: asset.wrapperBinaryName,
+        versionDir,
+        launcherJarPath: jarPath
+      });
+      await pruneStaleVersions(lspKey, entry.version);
+      return { installed: true, alreadyPresent: false, binaryPath: shimPath };
+    }
+    const installedBinary = join13(versionDir, asset.binaryPath);
+    if (!await pathExists(installedBinary)) {
+      return {
+        installed: false,
+        alreadyPresent: false,
+        error: `extract completed but binary missing at ${installedBinary}`
+      };
+    }
+    await fs.chmod(installedBinary, 493).catch(() => void 0);
+    await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
+    await pruneStaleVersions(lspKey, entry.version);
+    return { installed: true, alreadyPresent: false, binaryPath: installedBinary };
+  } catch (err) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function resolveGlobInsideDir(versionDir, glob) {
+  const parts = glob.split("/");
+  let dir = versionDir;
+  for (let i = 0; i < parts.length - 1; i += 1) {
+    dir = join13(dir, parts[i]);
+  }
+  const pattern = parts[parts.length - 1];
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const re = new RegExp(`^${escaped}$`);
+  let entries;
+  try {
+    entries = await fs.readdir(dir);
+  } catch {
+    return null;
+  }
+  const matches = entries.filter((e) => re.test(e)).sort();
+  const last = matches[matches.length - 1];
+  return last ? join13(dir, last) : null;
+}
+async function pruneStaleVersions(lspKey, currentVersion) {
+  const lspDir = join13(getNativeLspDir(), lspKey);
+  let entries;
+  try {
+    entries = await fs.readdir(lspDir);
+  } catch {
+    return;
+  }
+  await Promise.all(entries.filter((name) => name !== currentVersion).map(async (name) => {
+    try {
+      await fs.rm(join13(lspDir, name), { recursive: true, force: true });
+    } catch {
+    }
+  }));
+}
+function shQuote(value) {
+  return value.replace(/[\\"$`]/g, (ch) => `\\${ch}`);
+}
+function cmdQuote(value) {
+  return value.replace(/"/g, '""').replace(/%/g, "%%");
+}
+async function writeJdtlsWrapper(input) {
+  const binDir = getNativeLspBinDir();
+  await fs.mkdir(binDir, { recursive: true });
+  const shimPath = join13(binDir, input.binaryName);
+  const platformCfgDir = process.platform === "darwin" ? "config_mac" : process.platform === "win32" ? "config_win" : "config_linux";
+  const workspaceBase = join13(input.versionDir, "workspaces");
+  const qLauncher = shQuote(input.launcherJarPath);
+  const qConfig = shQuote(`${input.versionDir}/${platformCfgDir}`);
+  const qWorkspaceBase = shQuote(workspaceBase);
+  const unixScript = `#!/usr/bin/env bash
+# Generated by repowise listener \u2014 do not edit by hand.
+# Invokes Eclipse JDT.LS via the equinox launcher.
+set -euo pipefail
+WS_NAME="\${REPOWISE_JDTLS_WS_NAME:-default}"
+WS_DIR="${qWorkspaceBase}/\${WS_NAME}"
+mkdir -p "$WS_DIR"
+exec java \\
+  -Declipse.application=org.eclipse.jdt.ls.core.id1 \\
+  -Dosgi.bundles.defaultStartLevel=4 \\
+  -Declipse.product=org.eclipse.jdt.ls.core.product \\
+  -Dlog.level=ALL \\
+  -Xms1g \\
+  --add-modules=ALL-SYSTEM \\
+  --add-opens java.base/java.util=ALL-UNNAMED \\
+  --add-opens java.base/java.lang=ALL-UNNAMED \\
+  -jar "${qLauncher}" \\
+  -configuration "${qConfig}" \\
+  -data "$WS_DIR" \\
+  "$@"
+`;
+  await fs.writeFile(shimPath, unixScript);
+  await fs.chmod(shimPath, 493);
+  if (process.platform === "win32") {
+    const winShim = `${shimPath}.cmd`;
+    const cqLauncher = cmdQuote(input.launcherJarPath);
+    const cqConfig = cmdQuote(`${input.versionDir}\\${platformCfgDir}`);
+    const cqWorkspaceBase = cmdQuote(workspaceBase);
+    const winScript = `@echo off\r
+rem Generated by repowise listener\r
+if "%REPOWISE_JDTLS_WS_NAME%"=="" set REPOWISE_JDTLS_WS_NAME=default\r
+set WS_DIR=${cqWorkspaceBase}\\%REPOWISE_JDTLS_WS_NAME%\r
+if not exist "%WS_DIR%" mkdir "%WS_DIR%"\r
+java ^\r
+  -Declipse.application=org.eclipse.jdt.ls.core.id1 ^\r
+  -Dosgi.bundles.defaultStartLevel=4 ^\r
+  -Declipse.product=org.eclipse.jdt.ls.core.product ^\r
+  -Dlog.level=ALL ^\r
+  -Xms1g ^\r
+  --add-modules=ALL-SYSTEM ^\r
+  --add-opens java.base/java.util=ALL-UNNAMED ^\r
+  --add-opens java.base/java.lang=ALL-UNNAMED ^\r
+  -jar "${cqLauncher}" ^\r
+  -configuration "${cqConfig}" ^\r
+  -data "%WS_DIR%" ^\r
+  %*\r
+`;
+    await fs.writeFile(winShim, winScript);
+  }
+  return shimPath;
+}
+async function ensureSymlinkInBin(lspKey, target, sourceAssetPath) {
+  const binDir = getNativeLspBinDir();
+  await fs.mkdir(binDir, { recursive: true });
+  const winExtMatch = process.platform === "win32" && sourceAssetPath ? /\.(exe|bat|cmd|ps1)$/i.exec(sourceAssetPath) : null;
+  const linkName = winExtMatch ? `${lspKey}${winExtMatch[0].toLowerCase()}` : lspKey;
+  const linkPath = join13(binDir, linkName);
+  try {
+    await fs.unlink(linkPath);
+  } catch {
+  }
+  try {
+    await fs.symlink(target, linkPath);
+  } catch (err) {
+    if (err.code === "EPERM" || process.platform === "win32") {
+      await fs.copyFile(target, linkPath);
+    } else {
+      throw err;
+    }
+  }
+}
+async function downloadFile(url, dest) {
+  const res = await fetch(url);
+  if (!res.ok || !res.body) {
+    throw new Error(`download ${url} failed: HTTP ${res.status.toString()}`);
+  }
+  await fs.mkdir(dirname5(dest), { recursive: true });
+  const sink = createWriteStream(dest);
+  await pipeline(res.body, sink);
+}
+async function sha256File(path) {
+  const hash = createHash3("sha256");
+  const data = await fs.readFile(path);
+  hash.update(data);
+  return hash.digest("hex");
+}
+async function extractAsset(source, destDir, asset) {
+  const filename = asset.filename.toLowerCase();
+  if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
+    await runExternal("tar", ["-xzf", source, "-C", destDir]);
+    return;
+  }
+  if (filename.endsWith(".zip")) {
+    if (process.platform === "win32") {
+      await runExternal("powershell.exe", [
+        "-NoProfile",
+        "-Command",
+        `Expand-Archive -Path '${source}' -DestinationPath '${destDir}' -Force`
+      ]);
+    } else {
+      await runExternal("unzip", ["-o", "-q", source, "-d", destDir]);
+    }
+    return;
+  }
+  if (filename.endsWith(".gz")) {
+    const outPath = join13(destDir, asset.binaryPath);
+    await fs.mkdir(dirname5(outPath), { recursive: true });
+    await pipeline((await fs.open(source)).createReadStream(), createGunzip(), createWriteStream(outPath));
+    return;
+  }
+  await fs.copyFile(source, join13(destDir, asset.binaryPath));
 }
-async function probeJdk(options = {}) {
-  const timeoutMs = options.timeoutMs ?? 5e3;
-  return new Promise((resolve5) => {
+async function runExternal(cmd, args) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn3(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
     let stderr = "";
-    let settled = false;
-    const child = spawn3("java", ["-version"], { stdio: ["ignore", "pipe", "pipe"] });
-    const timer = setTimeout(() => {
-      if (settled)
-        return;
-      settled = true;
-      try {
-        child.kill("SIGKILL");
-      } catch {
-      }
-      resolve5({ present: false });
-    }, timeoutMs);
     child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString("utf8");
-    });
-    child.on("error", () => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      resolve5({ present: false });
+      stderr += chunk.toString();
     });
+    child.on("error", reject);
     child.on("close", (code) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      if (code !== 0) {
-        resolve5({ present: false, rawOutput: stderr.trim() });
-        return;
-      }
-      const major = parseJavaMajorVersion(stderr);
-      if (major === void 0) {
-        resolve5({ present: true, rawOutput: stderr.trim() });
-        return;
-      }
-      resolve5({ present: true, majorVersion: major, rawOutput: stderr.trim() });
+      if (code === 0)
+        resolve5();
+      else
+        reject(new Error(`${cmd} ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr.split("\n").slice(0, 3).join(" ")}`));
     });
   });
 }
-var init_jdk_probe = __esm({
-  "../listener/dist/lsp/jdk-probe.js"() {
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_native_installer = __esm({
+  "../listener/dist/lsp/native-installer.js"() {
     "use strict";
+    init_src();
+    init_installer();
+    init_jdk_probe();
   }
 });
 
-// ../listener/dist/lsp/native-installer.js
-import { createWriteStream } from "fs";
-import { promises as fs } from "fs";
-import { createGunzip } from "zlib";
+// ../listener/dist/lsp/coursier-installer.js
+import { promises as fs2 } from "fs";
 import { spawn as spawn4 } from "child_process";
-import { pipeline } from "stream/promises";
-import { createHash as createHash3 } from "crypto";
-import { join as join15, dirname as dirname5 } from "path";
-function getNativeLspDir() {
-  return join15(getLspInstallDir(), "native");
-}
-function getNativeLspBinDir() {
-  return join15(getNativeLspDir(), "bin");
+import { join as join14 } from "path";
+function getCoursierBinDir() {
+  return join14(getLspInstallDir(), "coursier-bin");
 }
-async function ensureNativeLspInstalled(lspKey) {
-  const entry = NATIVE_LSP_VERSIONS[lspKey];
-  if (!entry)
-    return { installed: false, alreadyPresent: false, skipped: "no-native-version" };
-  const platformKey = getCurrentPlatformKey();
-  if (!platformKey) {
-    return { installed: false, alreadyPresent: false, skipped: "unsupported-platform" };
+async function ensureCoursierLspInstalled(key) {
+  const entry = COURSIER_LSPS[key];
+  if (!entry) {
+    return { installed: false, alreadyPresent: false, skipped: "no-coursier-entry" };
   }
-  const asset = entry.assets[platformKey];
-  if (!asset) {
-    return { installed: false, alreadyPresent: false, skipped: "unsupported-platform" };
+  const binDir = getCoursierBinDir();
+  const binaryPath = join14(binDir, entry.appName);
+  const binaryPathExe = join14(binDir, `${entry.appName}.bat`);
+  if (await pathExists2(binaryPath) || await pathExists2(binaryPathExe)) {
+    return { installed: false, alreadyPresent: true, binaryPath };
   }
-  if (entry.requiresJdk !== void 0) {
-    const jdk = await probeJdk();
-    if (!jdk.present || jdk.majorVersion === void 0 || jdk.majorVersion < entry.requiresJdk) {
-      return {
-        installed: false,
-        alreadyPresent: false,
-        skipped: "jvm-missing",
-        error: `${lspKey} requires JDK ${entry.requiresJdk.toString()}+ (found: ${jdk.present ? `Java ${jdk.majorVersion?.toString() ?? "?"}` : "no java on PATH"}). Install with: brew install openjdk@21 (macOS) or apt install openjdk-21-jdk (Linux)`
-      };
-    }
+  const csBootstrap = await ensureNativeLspInstalled("coursier");
+  if (csBootstrap.skipped || !csBootstrap.installed && !csBootstrap.alreadyPresent) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      skipped: "coursier-bootstrap-failed",
+      error: csBootstrap.error ?? csBootstrap.skipped
+    };
   }
-  const usesWrapper = Boolean(asset.launcherJarGlob && asset.wrapperBinaryName);
-  const versionDir = join15(getNativeLspDir(), lspKey, entry.version);
-  if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
-    const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
-    const shimPath = join15(getNativeLspBinDir(), asset.wrapperBinaryName);
-    if (jarPath && await pathExists(shimPath)) {
-      return { installed: false, alreadyPresent: true, binaryPath: shimPath };
-    }
-  } else {
-    const installedBinary = join15(versionDir, asset.binaryPath);
-    if (await pathExists(installedBinary)) {
-      await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
-      return { installed: false, alreadyPresent: true, binaryPath: installedBinary };
-    }
+  const csPath = join14(getNativeLspBinDir(), "coursier");
+  const csPathExe = join14(getNativeLspBinDir(), "coursier.exe");
+  const cs = await pathExists2(csPath) ? csPath : await pathExists2(csPathExe) ? csPathExe : null;
+  if (!cs) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      skipped: "coursier-bootstrap-failed",
+      error: `coursier launcher not found at ${csPath} after bootstrap`
+    };
   }
   try {
-    await fs.mkdir(versionDir, { recursive: true });
-    const tmpDownload = join15(versionDir, `.${asset.filename}.download`);
-    const downloadUrl = entry.source.kind === "github-release" ? `https://github.com/${entry.source.repo}/releases/download/${entry.version}/${asset.filename}` : asset.url ?? "";
-    if (!downloadUrl) {
+    await fs2.mkdir(binDir, { recursive: true });
+    await runCs(cs, ["install", "--install-dir", binDir, entry.appName]);
+    if (!await pathExists2(binaryPath) && !await pathExists2(binaryPathExe)) {
       return {
         installed: false,
         alreadyPresent: false,
-        error: `direct-url asset for ${lspKey} missing required \`url\` field`
+        error: `cs install ${entry.appName} completed but launcher missing at ${binaryPath}`
       };
     }
-    await downloadFile(downloadUrl, tmpDownload);
-    if (asset.sha256) {
-      const actual = await sha256File(tmpDownload);
-      if (actual !== asset.sha256) {
-        await fs.unlink(tmpDownload).catch(() => void 0);
-        return {
-          installed: false,
-          alreadyPresent: false,
-          error: `SHA256 mismatch for ${lspKey}: expected ${asset.sha256}, got ${actual}`
-        };
-      }
-    } else {
-      console.warn(`[lsp-install] WARN: SHA256 verification skipped for ${lspKey} (no pin in NATIVE_LSP_VERSIONS) \u2014 run apps/listener/scripts/pin-native-shas.ts to record one`);
-    }
-    await extractAsset(tmpDownload, versionDir, asset);
-    await fs.unlink(tmpDownload).catch(() => void 0);
-    if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
-      const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
-      if (!jarPath) {
-        return {
-          installed: false,
-          alreadyPresent: false,
-          error: `extract completed but no JAR matched ${asset.launcherJarGlob} in ${versionDir}`
-        };
-      }
-      const shimPath = await writeJdtlsWrapper({
-        binaryName: asset.wrapperBinaryName,
-        versionDir,
-        launcherJarPath: jarPath
-      });
-      await pruneStaleVersions(lspKey, entry.version);
-      return { installed: true, alreadyPresent: false, binaryPath: shimPath };
-    }
-    const installedBinary = join15(versionDir, asset.binaryPath);
-    if (!await pathExists(installedBinary)) {
-      return {
-        installed: false,
-        alreadyPresent: false,
-        error: `extract completed but binary missing at ${installedBinary}`
-      };
+    return { installed: true, alreadyPresent: false, binaryPath };
+  } catch (err) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+async function runCs(cs, args) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn4(cs, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0)
+        resolve5();
+      else
+        reject(new Error(`cs ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr.split("\n").slice(0, 3).join(" ")}`));
+    });
+  });
+}
+async function pathExists2(p) {
+  try {
+    await fs2.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var init_coursier_installer = __esm({
+  "../listener/dist/lsp/coursier-installer.js"() {
+    "use strict";
+    init_src();
+    init_installer();
+    init_native_installer();
+  }
+});
+
+// ../listener/dist/lsp/toolchain-installer.js
+import { spawn as spawn5 } from "child_process";
+import { promises as fs3 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join15 } from "path";
+async function ensureToolchainLspInstalled(key) {
+  const entry = TOOLCHAIN_LSPS[key];
+  if (!entry) {
+    return { installed: false, alreadyPresent: false, skipped: "no-toolchain-entry" };
+  }
+  if (entry.bundled) {
+    const found = await isCommandOnPath(entry.binaryName);
+    if (found)
+      return { installed: false, alreadyPresent: true };
+    return { installed: false, alreadyPresent: false, skipped: "bundled-not-installable" };
+  }
+  if (await isCommandOnPath(entry.binaryName)) {
+    return { installed: false, alreadyPresent: true, skipped: "already-on-path" };
+  }
+  if (!entry.toolchain) {
+    return { installed: false, alreadyPresent: false, skipped: "toolchain-missing" };
+  }
+  if (!await isCommandOnPath(entry.toolchain)) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      skipped: "toolchain-missing",
+      error: `${entry.toolchain} toolchain not on PATH`
+    };
+  }
+  let binDir;
+  try {
+    binDir = await resolveToolchainBinDir(entry);
+  } catch (err) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  try {
+    if (!entry.installArgs) {
+      return { installed: false, alreadyPresent: false, skipped: "toolchain-missing" };
     }
-    await fs.chmod(installedBinary, 493).catch(() => void 0);
-    await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
-    await pruneStaleVersions(lspKey, entry.version);
-    return { installed: true, alreadyPresent: false, binaryPath: installedBinary };
+    await runToolchain(entry.toolchain, entry.installArgs);
   } catch (err) {
     return {
       installed: false,
@@ -1597,714 +1615,766 @@ async function ensureNativeLspInstalled(lspKey) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
+  const binaryPath = join15(binDir, entry.binaryName);
+  if (!await pathExists3(binaryPath)) {
+    return {
+      installed: false,
+      alreadyPresent: false,
+      error: `${entry.toolchain} install of ${entry.binaryName} completed but binary missing at ${binaryPath}`,
+      binDir
+    };
+  }
+  return { installed: true, alreadyPresent: false, binaryPath, binDir };
 }
-async function resolveGlobInsideDir(versionDir, glob) {
-  const parts = glob.split("/");
-  let dir = versionDir;
-  for (let i = 0; i < parts.length - 1; i += 1) {
-    dir = join15(dir, parts[i]);
+async function resolveToolchainBinDir(entry) {
+  if (!entry.toolchain) {
+    throw new Error("cannot resolve bin dir for entry without toolchain");
   }
-  const pattern = parts[parts.length - 1];
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
-  const re = new RegExp(`^${escaped}$`);
-  let entries;
-  try {
-    entries = await fs.readdir(dir);
-  } catch {
-    return null;
+  if (entry.toolchainBinDir) {
+    if (entry.toolchain === "go") {
+      const gopath = process.env["GOPATH"] ?? join15(homedir3(), "go");
+      return join15(gopath, "bin");
+    }
+    return join15(homedir3(), entry.toolchainBinDir);
   }
-  const matches = entries.filter((e) => re.test(e)).sort();
-  const last = matches[matches.length - 1];
-  return last ? join15(dir, last) : null;
-}
-async function pruneStaleVersions(lspKey, currentVersion) {
-  const lspDir = join15(getNativeLspDir(), lspKey);
-  let entries;
-  try {
-    entries = await fs.readdir(lspDir);
-  } catch {
-    return;
+  if (entry.toolchain === "gem") {
+    const userdir = await captureStdout("gem", ["env", "userdir"]);
+    return join15(userdir.trim(), "bin");
   }
-  await Promise.all(entries.filter((name) => name !== currentVersion).map(async (name) => {
-    try {
-      await fs.rm(join15(lspDir, name), { recursive: true, force: true });
-    } catch {
+  throw new Error(`no bin-dir resolution for toolchain ${entry.toolchain}`);
+}
+function getToolchainBinDirs() {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(TOOLCHAIN_LSPS)) {
+    if (entry.bundled || !entry.toolchain || !entry.toolchainBinDir)
+      continue;
+    if (entry.toolchain === "go") {
+      const gopath = process.env["GOPATH"] ?? join15(homedir3(), "go");
+      dirs.add(join15(gopath, "bin"));
+    } else {
+      dirs.add(join15(homedir3(), entry.toolchainBinDir));
     }
-  }));
+  }
+  return [...dirs];
 }
-function shQuote(value) {
-  return value.replace(/[\\"$`]/g, (ch) => `\\${ch}`);
+function runToolchain(cmd, args) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn5(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0)
+        resolve5();
+      else
+        reject(new Error(`${cmd} ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr.split("\n").slice(0, 3).join(" ")}`));
+    });
+  });
 }
-function cmdQuote(value) {
-  return value.replace(/"/g, '""').replace(/%/g, "%%");
+function captureStdout(cmd, args) {
+  return new Promise((resolve5, reject) => {
+    const child = spawn5(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0)
+        resolve5(stdout);
+      else
+        reject(new Error(`${cmd} ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr}`));
+    });
+  });
 }
-async function writeJdtlsWrapper(input) {
-  const binDir = getNativeLspBinDir();
-  await fs.mkdir(binDir, { recursive: true });
-  const shimPath = join15(binDir, input.binaryName);
-  const platformCfgDir = process.platform === "darwin" ? "config_mac" : process.platform === "win32" ? "config_win" : "config_linux";
-  const workspaceBase = join15(input.versionDir, "workspaces");
-  const qLauncher = shQuote(input.launcherJarPath);
-  const qConfig = shQuote(`${input.versionDir}/${platformCfgDir}`);
-  const qWorkspaceBase = shQuote(workspaceBase);
-  const unixScript = `#!/usr/bin/env bash
-# Generated by repowise listener \u2014 do not edit by hand.
-# Invokes Eclipse JDT.LS via the equinox launcher.
-set -euo pipefail
-WS_NAME="\${REPOWISE_JDTLS_WS_NAME:-default}"
-WS_DIR="${qWorkspaceBase}/\${WS_NAME}"
-mkdir -p "$WS_DIR"
-exec java \\
-  -Declipse.application=org.eclipse.jdt.ls.core.id1 \\
-  -Dosgi.bundles.defaultStartLevel=4 \\
-  -Declipse.product=org.eclipse.jdt.ls.core.product \\
-  -Dlog.level=ALL \\
-  -Xms1g \\
-  --add-modules=ALL-SYSTEM \\
-  --add-opens java.base/java.util=ALL-UNNAMED \\
-  --add-opens java.base/java.lang=ALL-UNNAMED \\
-  -jar "${qLauncher}" \\
-  -configuration "${qConfig}" \\
-  -data "$WS_DIR" \\
-  "$@"
-`;
-  await fs.writeFile(shimPath, unixScript);
-  await fs.chmod(shimPath, 493);
-  if (process.platform === "win32") {
-    const winShim = `${shimPath}.cmd`;
-    const cqLauncher = cmdQuote(input.launcherJarPath);
-    const cqConfig = cmdQuote(`${input.versionDir}\\${platformCfgDir}`);
-    const cqWorkspaceBase = cmdQuote(workspaceBase);
-    const winScript = `@echo off\r
-rem Generated by repowise listener\r
-if "%REPOWISE_JDTLS_WS_NAME%"=="" set REPOWISE_JDTLS_WS_NAME=default\r
-set WS_DIR=${cqWorkspaceBase}\\%REPOWISE_JDTLS_WS_NAME%\r
-if not exist "%WS_DIR%" mkdir "%WS_DIR%"\r
-java ^\r
-  -Declipse.application=org.eclipse.jdt.ls.core.id1 ^\r
-  -Dosgi.bundles.defaultStartLevel=4 ^\r
-  -Declipse.product=org.eclipse.jdt.ls.core.product ^\r
-  -Dlog.level=ALL ^\r
-  -Xms1g ^\r
-  --add-modules=ALL-SYSTEM ^\r
-  --add-opens java.base/java.util=ALL-UNNAMED ^\r
-  --add-opens java.base/java.lang=ALL-UNNAMED ^\r
-  -jar "${cqLauncher}" ^\r
-  -configuration "${cqConfig}" ^\r
-  -data "%WS_DIR%" ^\r
-  %*\r
-`;
-    await fs.writeFile(winShim, winScript);
-  }
-  return shimPath;
+async function isCommandOnPath(command) {
+  if (/[^\w./+-]/.test(command))
+    return false;
+  const probeCmd = process.platform === "win32" ? "where" : "which";
+  return new Promise((resolve5) => {
+    const child = spawn5(probeCmd, [command], { stdio: "ignore", timeout: 5e3 });
+    child.on("error", () => resolve5(false));
+    child.on("close", (code) => resolve5(code === 0));
+  });
 }
-async function ensureSymlinkInBin(lspKey, target, sourceAssetPath) {
-  const binDir = getNativeLspBinDir();
-  await fs.mkdir(binDir, { recursive: true });
-  const winExtMatch = process.platform === "win32" && sourceAssetPath ? /\.(exe|bat|cmd|ps1)$/i.exec(sourceAssetPath) : null;
-  const linkName = winExtMatch ? `${lspKey}${winExtMatch[0].toLowerCase()}` : lspKey;
-  const linkPath = join15(binDir, linkName);
+async function pathExists3(p) {
   try {
-    await fs.unlink(linkPath);
+    await fs3.access(p);
+    return true;
   } catch {
-  }
-  try {
-    await fs.symlink(target, linkPath);
-  } catch (err) {
-    if (err.code === "EPERM" || process.platform === "win32") {
-      await fs.copyFile(target, linkPath);
-    } else {
-      throw err;
-    }
+    return false;
   }
 }
-async function downloadFile(url, dest) {
-  const res = await fetch(url);
-  if (!res.ok || !res.body) {
-    throw new Error(`download ${url} failed: HTTP ${res.status.toString()}`);
+var init_toolchain_installer = __esm({
+  "../listener/dist/lsp/toolchain-installer.js"() {
+    "use strict";
+    init_src();
   }
-  await fs.mkdir(dirname5(dest), { recursive: true });
-  const sink = createWriteStream(dest);
-  await pipeline(res.body, sink);
+});
+
+// ../listener/dist/lsp/installer.js
+import { promises as fs4 } from "fs";
+import { join as join16, dirname as dirname6 } from "path";
+import { spawn as spawn6 } from "child_process";
+import lockfile3 from "proper-lockfile";
+function getLspInstallDir() {
+  return join16(getConfigDir(), "lsp-servers");
 }
-async function sha256File(path) {
-  const hash = createHash3("sha256");
-  const data = await fs.readFile(path);
-  hash.update(data);
-  return hash.digest("hex");
+function getLspBinDir() {
+  return join16(getLspInstallDir(), "node_modules", ".bin");
 }
-async function extractAsset(source, destDir, asset) {
-  const filename = asset.filename.toLowerCase();
-  if (filename.endsWith(".tar.gz") || filename.endsWith(".tgz")) {
-    await runExternal("tar", ["-xzf", source, "-C", destDir]);
-    return;
+async function ensureNpmLspInstalled(config2) {
+  if (!config2.npmPackage)
+    return { installed: false, skipped: "no-npm-package" };
+  const installDir = getLspInstallDir();
+  const binPath = join16(installDir, "node_modules", ".bin", config2.command);
+  if (await pathExists4(binPath)) {
+    return { installed: false, skipped: "already-present" };
+  }
+  try {
+    await fs4.mkdir(installDir, { recursive: true });
+    let release = null;
+    try {
+      release = await lockfile3.lock(installDir, {
+        stale: 18e4,
+        retries: { retries: 20, factor: 1.5, minTimeout: 500, maxTimeout: 5e3 },
+        realpath: false
+      });
+    } catch {
+      if (await pathExists4(binPath)) {
+        return { installed: false, skipped: "already-present" };
+      }
+    }
+    try {
+      if (await pathExists4(binPath)) {
+        return { installed: false, skipped: "already-present" };
+      }
+      const pkgJsonPath = join16(installDir, "package.json");
+      if (!await pathExists4(pkgJsonPath)) {
+        await fs4.writeFile(pkgJsonPath, JSON.stringify({ name: "repowise-lsp-servers", private: true, version: "0.0.0" }, null, 2), "utf-8");
+      }
+      await runNpmInstall(installDir, config2.npmPackage);
+      if (!await pathExists4(binPath)) {
+        return {
+          installed: false,
+          error: `npm install completed but ${config2.command} still not at ${binPath}`
+        };
+      }
+      return { installed: true };
+    } finally {
+      if (release) {
+        try {
+          await release();
+        } catch {
+        }
+      }
+    }
+  } catch (err) {
+    return {
+      installed: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
-  if (filename.endsWith(".zip")) {
-    if (process.platform === "win32") {
-      await runExternal("powershell.exe", [
-        "-NoProfile",
-        "-Command",
-        `Expand-Archive -Path '${source}' -DestinationPath '${destDir}' -Force`
-      ]);
-    } else {
-      await runExternal("unzip", ["-o", "-q", source, "-d", destDir]);
+}
+async function resolveNpmCommand() {
+  const nodeDir = dirname6(process.execPath);
+  for (const candidate of [join16(nodeDir, "npm"), join16(nodeDir, "npm.cmd")]) {
+    try {
+      await fs4.access(candidate);
+      return candidate;
+    } catch {
     }
-    return;
   }
-  if (filename.endsWith(".gz")) {
-    const outPath = join15(destDir, asset.binaryPath);
-    await fs.mkdir(dirname5(outPath), { recursive: true });
-    await pipeline((await fs.open(source)).createReadStream(), createGunzip(), createWriteStream(outPath));
-    return;
+  for (const candidate of ["/opt/homebrew/bin/npm", "/usr/local/bin/npm", "/usr/bin/npm"]) {
+    try {
+      await fs4.access(candidate);
+      return candidate;
+    } catch {
+    }
   }
-  await fs.copyFile(source, join15(destDir, asset.binaryPath));
+  return "npm";
 }
-async function runExternal(cmd, args) {
+async function runNpmInstall(cwd, pkg2) {
+  const npmCmd = await resolveNpmCommand();
+  const nodeDir = dirname6(process.execPath);
+  const augmentedPath = process.env.PATH ? `${nodeDir}:${process.env.PATH}` : nodeDir;
   return new Promise((resolve5, reject) => {
-    const child = spawn4(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+    const child = spawn6(npmCmd, ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, PATH: augmentedPath }
+    });
     let stderr = "";
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString();
     });
-    child.on("error", reject);
+    child.on("error", (err) => reject(err));
     child.on("close", (code) => {
-      if (code === 0)
+      if (code === 0) {
         resolve5();
-      else
-        reject(new Error(`${cmd} ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr.split("\n").slice(0, 3).join(" ")}`));
+      } else {
+        reject(new Error(`npm install ${pkg2} exited ${(code ?? -1).toString()}: ${sanitizeNpmStderr(stderr)}`));
+      }
     });
   });
 }
-async function pathExists(p) {
+function sanitizeNpmStderr(raw) {
+  const truncated = raw.split("\n").slice(0, 3).join(" ").trim();
+  return truncated.replace(/(https?:\/\/)[^@\s/]*@/g, (_match, scheme) => `${scheme}<redacted>@`);
+}
+async function pathExists4(p) {
   try {
-    await fs.access(p);
+    await fs4.access(p);
     return true;
   } catch {
     return false;
   }
 }
-var init_native_installer = __esm({
-  "../listener/dist/lsp/native-installer.js"() {
-    "use strict";
-    init_src();
-    init_installer();
-    init_jdk_probe();
-  }
-});
-
-// ../listener/dist/lsp/coursier-installer.js
-import { promises as fs2 } from "fs";
-import { spawn as spawn5 } from "child_process";
-import { join as join16 } from "path";
-function getCoursierBinDir() {
-  return join16(getLspInstallDir(), "coursier-bin");
-}
-async function ensureCoursierLspInstalled(key) {
-  const entry = COURSIER_LSPS[key];
-  if (!entry) {
-    return { installed: false, alreadyPresent: false, skipped: "no-coursier-entry" };
-  }
-  const binDir = getCoursierBinDir();
-  const binaryPath = join16(binDir, entry.appName);
-  const binaryPathExe = join16(binDir, `${entry.appName}.bat`);
-  if (await pathExists2(binaryPath) || await pathExists2(binaryPathExe)) {
-    return { installed: false, alreadyPresent: true, binaryPath };
-  }
-  const csBootstrap = await ensureNativeLspInstalled("coursier");
-  if (csBootstrap.skipped || !csBootstrap.installed && !csBootstrap.alreadyPresent) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      skipped: "coursier-bootstrap-failed",
-      error: csBootstrap.error ?? csBootstrap.skipped
-    };
-  }
-  const csPath = join16(getNativeLspBinDir(), "coursier");
-  const csPathExe = join16(getNativeLspBinDir(), "coursier.exe");
-  const cs = await pathExists2(csPath) ? csPath : await pathExists2(csPathExe) ? csPathExe : null;
-  if (!cs) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      skipped: "coursier-bootstrap-failed",
-      error: `coursier launcher not found at ${csPath} after bootstrap`
-    };
+async function detectRepoLanguages(repoRoot) {
+  const found = /* @__PURE__ */ new Set();
+  let inspected = 0;
+  const MAX_INSPECT = 200;
+  async function inspect(dir) {
+    if (inspected >= MAX_INSPECT)
+      return;
+    let entries;
+    try {
+      entries = await fs4.readdir(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (inspected >= MAX_INSPECT)
+        return;
+      if (name.startsWith("."))
+        continue;
+      if (name === "node_modules" || name === "dist" || name === "build")
+        continue;
+      const lang = detectLanguage(name);
+      if (lang) {
+        found.add(lang);
+        inspected += 1;
+      }
+    }
   }
+  await inspect(repoRoot);
+  let topEntries = [];
   try {
-    await fs2.mkdir(binDir, { recursive: true });
-    await runCs(cs, ["install", "--install-dir", binDir, entry.appName]);
-    if (!await pathExists2(binaryPath) && !await pathExists2(binaryPathExe)) {
-      return {
-        installed: false,
-        alreadyPresent: false,
-        error: `cs install ${entry.appName} completed but launcher missing at ${binaryPath}`
-      };
+    topEntries = await fs4.readdir(repoRoot);
+  } catch {
+    return found;
+  }
+  for (const name of topEntries) {
+    if (name.startsWith("."))
+      continue;
+    if (name === "node_modules" || name === "dist" || name === "build")
+      continue;
+    const sub = join16(repoRoot, name);
+    try {
+      const stat8 = await fs4.stat(sub);
+      if (stat8.isDirectory())
+        await inspect(sub);
+    } catch {
     }
-    return { installed: true, alreadyPresent: false, binaryPath };
-  } catch (err) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
   }
+  return found;
 }
-async function runCs(cs, args) {
-  return new Promise((resolve5, reject) => {
-    const child = spawn5(cs, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0)
-        resolve5();
-      else
-        reject(new Error(`cs ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr.split("\n").slice(0, 3).join(" ")}`));
+async function prepareLspServersForRepos(repos, options = {}) {
+  const detected = /* @__PURE__ */ new Set();
+  for (const r of repos) {
+    if (!r.localPath)
+      continue;
+    try {
+      const stat8 = await fs4.stat(r.localPath);
+      if (!stat8.isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    try {
+      const langs = await detectRepoLanguages(r.localPath);
+      for (const l of langs)
+        detected.add(l);
+    } catch {
+    }
+  }
+  const results = [];
+  for (const language of detected) {
+    const configs = getEffectiveConfigList(language, process.env, options.lspOverrides);
+    const npmConfig = configs.find((c) => c.npmPackage);
+    if (npmConfig) {
+      const outcome = await ensureNpmLspInstalled(npmConfig);
+      results.push({
+        language,
+        installed: outcome.installed,
+        alreadyPresent: outcome.skipped === "already-present",
+        skippedNoNpmPackage: false,
+        installMethod: "npm",
+        error: outcome.error
+      });
+      continue;
+    }
+    const nativeConfig = configs.find((c) => c.nativeInstallKey);
+    if (nativeConfig?.nativeInstallKey) {
+      const outcome = await ensureNativeLspInstalled(nativeConfig.nativeInstallKey);
+      results.push({
+        language,
+        installed: outcome.installed,
+        alreadyPresent: outcome.alreadyPresent,
+        skippedNoNpmPackage: false,
+        installMethod: "native",
+        skipped: outcome.skipped,
+        hint: outcome.skipped ? nativeConfig.installHint : void 0,
+        error: outcome.error
+      });
+      continue;
+    }
+    const coursierConfig = configs.find((c) => c.coursierInstallKey);
+    if (coursierConfig?.coursierInstallKey) {
+      const outcome = await ensureCoursierLspInstalled(coursierConfig.coursierInstallKey);
+      results.push({
+        language,
+        installed: outcome.installed,
+        alreadyPresent: outcome.alreadyPresent,
+        skippedNoNpmPackage: false,
+        installMethod: "coursier",
+        skipped: outcome.skipped,
+        hint: outcome.skipped ? coursierConfig.installHint : void 0,
+        error: outcome.error
+      });
+      continue;
+    }
+    const toolchainConfig = configs.find((c) => c.toolchainInstallKey);
+    if (toolchainConfig?.toolchainInstallKey) {
+      const outcome = await ensureToolchainLspInstalled(toolchainConfig.toolchainInstallKey);
+      results.push({
+        language,
+        installed: outcome.installed,
+        alreadyPresent: outcome.alreadyPresent,
+        skippedNoNpmPackage: false,
+        installMethod: "toolchain",
+        skipped: outcome.skipped,
+        // Surface the install hint for any skip reason — toolchain
+        // missing means user needs to install it; bundled SDK means
+        // user needs the SDK.
+        hint: outcome.skipped ? toolchainConfig.installHint : void 0,
+        error: outcome.error
+      });
+      continue;
+    }
+    results.push({
+      language,
+      installed: false,
+      alreadyPresent: false,
+      skippedNoNpmPackage: true,
+      hint: configs[0]?.installHint
     });
-  });
-}
-async function pathExists2(p) {
-  try {
-    await fs2.access(p);
-    return true;
-  } catch {
-    return false;
   }
+  return results;
 }
-var init_coursier_installer = __esm({
-  "../listener/dist/lsp/coursier-installer.js"() {
+var init_installer = __esm({
+  "../listener/dist/lsp/installer.js"() {
     "use strict";
-    init_src();
-    init_installer();
+    init_config_dir();
+    init_registry();
     init_native_installer();
+    init_coursier_installer();
+    init_toolchain_installer();
   }
 });
 
-// ../listener/dist/lsp/toolchain-installer.js
-import { spawn as spawn6 } from "child_process";
-import { promises as fs3 } from "fs";
+// ../listener/dist/lsp/daemon-path.js
 import { homedir as homedir4 } from "os";
-import { join as join17 } from "path";
-async function ensureToolchainLspInstalled(key) {
-  const entry = TOOLCHAIN_LSPS[key];
-  if (!entry) {
-    return { installed: false, alreadyPresent: false, skipped: "no-toolchain-entry" };
-  }
-  if (entry.bundled) {
-    const found = await isCommandOnPath(entry.binaryName);
-    if (found)
-      return { installed: false, alreadyPresent: true };
-    return { installed: false, alreadyPresent: false, skipped: "bundled-not-installable" };
-  }
-  if (await isCommandOnPath(entry.binaryName)) {
-    return { installed: false, alreadyPresent: true, skipped: "already-on-path" };
-  }
-  if (!entry.toolchain) {
-    return { installed: false, alreadyPresent: false, skipped: "toolchain-missing" };
-  }
-  if (!await isCommandOnPath(entry.toolchain)) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      skipped: "toolchain-missing",
-      error: `${entry.toolchain} toolchain not on PATH`
-    };
-  }
-  let binDir;
-  try {
-    binDir = await resolveToolchainBinDir(entry);
-  } catch (err) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
+import { delimiter, dirname as dirname7, join as join17 } from "path";
+function commonBinDirs() {
+  const home = homedir4();
+  return [
+    "/opt/homebrew/bin",
+    // Apple Silicon Homebrew
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    // Intel Homebrew / common installs
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin",
+    join17(home, ".local", "bin"),
+    // pipx / pip --user / uv
+    join17(home, ".npm-global", "bin"),
+    // common npm global prefix
+    join17(home, "go", "bin"),
+    // gopls
+    join17(home, ".cargo", "bin")
+    // rust-analyzer via cargo
+  ];
+}
+function managedBinDirs() {
+  return [getLspBinDir(), getNativeLspBinDir(), getCoursierBinDir(), ...getToolchainBinDirs()];
+}
+function dedup(dirs) {
+  return [...new Set(dirs.filter((d) => d.length > 0))];
+}
+function daemonPathDirs() {
+  return dedup([dirname7(process.execPath), ...commonBinDirs(), ...managedBinDirs()]);
+}
+function buildDaemonPath() {
+  return daemonPathDirs().join(delimiter);
+}
+var init_daemon_path = __esm({
+  "../listener/dist/lsp/daemon-path.js"() {
+    "use strict";
+    init_installer();
+    init_native_installer();
+    init_coursier_installer();
+    init_toolchain_installer();
   }
+});
+
+// ../listener/dist/service-installer.js
+var service_installer_exports = {};
+__export(service_installer_exports, {
+  install: () => install,
+  isInstalled: () => isInstalled,
+  isServiceRunning: () => isServiceRunning,
+  stopService: () => stopService,
+  uninstall: () => uninstall
+});
+import { execFile as execFile4 } from "child_process";
+import { writeFile as writeFile8, mkdir as mkdir8, unlink as unlink6 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import { join as join18 } from "path";
+function exec(cmd, args) {
+  return new Promise((resolve5, reject) => {
+    execFile4(cmd, args, (err, stdout) => {
+      if (err) {
+        reject(err);
+        return;
+      }
+      resolve5(String(stdout ?? ""));
+    });
+  });
+}
+function xmlEscape(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function sanitizeEnvValue(value) {
+  return Array.from(value).filter((ch) => ch.charCodeAt(0) >= 32).join("");
+}
+function plistPath() {
+  return join18(homedir5(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+}
+function logDir() {
+  return join18(getConfigDir(), "logs");
+}
+function buildPlist() {
+  const cmd = resolveListenerCommand();
+  const logs = logDir();
+  const programArgs = [process.execPath, cmd.script, ...cmd.args].map((a) => `        <string>${xmlEscape(a)}</string>`).join("\n");
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${xmlEscape(PLIST_LABEL)}</string>
+    <key>ProgramArguments</key>
+    <array>
+${programArgs}
+    </array>
+    <key>RunAtLoad</key>
+    <true/>
+    <key>KeepAlive</key>
+    <true/>
+    <!--
+      FIX-8: launchd inherits a minimal PATH (/usr/bin:/bin:\u2026) that excludes
+      /opt/homebrew/bin + the npm-global bin, so user-installed LSP servers
+      (pyright, rust-analyzer, \u2026) cannot be spawned and the typed-resolution
+      which-probe fails. Inject a rich PATH (single source of truth:
+      buildDaemonPath in lsp/daemon-path.ts) so the daemon resolves them.
+    -->
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>${xmlEscape(buildDaemonPath())}</string>
+    </dict>
+    <key>StandardOutPath</key>
+    <string>${xmlEscape(join18(logs, "listener-stdout.log"))}</string>
+    <key>StandardErrorPath</key>
+    <string>${xmlEscape(join18(logs, "listener-stderr.log"))}</string>
+    <key>ProcessType</key>
+    <string>Background</string>
+    <!--
+      SoftResourceLimits: raise the open-file descriptor limit from the macOS
+      default of 256 to 4096. When multiple LSP child processes (rust-analyzer,
+      jdtls, etc.) share the listener's fd budget they can exhaust the default
+      very quickly, causing EMFILE errors. 4096 matches the system-wide default
+      set by /etc/launchd.conf on modern macOS and gives enough headroom for
+      ~10 concurrent LSP servers each opening ~300 fds.
+
+      MemoryLimit: intentionally NOT set here. The launchd MemoryLimit key
+      (available since macOS 12.3) terminates the entire LaunchAgent when RSS
+      exceeds the threshold \u2014 it cannot be scoped to individual child processes.
+      Killing the listener to evict a memory-hungry rust-analyzer instance is
+      undesirable. Per-child memory pressure is better handled by the LSP
+      process manager (process-manager.ts) or by OS-level memory pressure
+      signals (SIGTERM on macOS, OOM killer on Linux).
+    -->
+    <key>SoftResourceLimits</key>
+    <dict>
+        <key>NumberOfFiles</key>
+        <integer>4096</integer>
+    </dict>
+</dict>
+</plist>`;
+}
+async function darwinInstall() {
+  await mkdir8(logDir(), { recursive: true });
+  await mkdir8(join18(homedir5(), "Library", "LaunchAgents"), { recursive: true });
   try {
-    if (!entry.installArgs) {
-      return { installed: false, alreadyPresent: false, skipped: "toolchain-missing" };
-    }
-    await runToolchain(entry.toolchain, entry.installArgs);
-  } catch (err) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
-  }
-  const binaryPath = join17(binDir, entry.binaryName);
-  if (!await pathExists3(binaryPath)) {
-    return {
-      installed: false,
-      alreadyPresent: false,
-      error: `${entry.toolchain} install of ${entry.binaryName} completed but binary missing at ${binaryPath}`,
-      binDir
-    };
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
   }
-  return { installed: true, alreadyPresent: false, binaryPath, binDir };
+  await writeFile8(plistPath(), buildPlist());
+  await exec("launchctl", ["load", plistPath()]);
 }
-async function resolveToolchainBinDir(entry) {
-  if (!entry.toolchain) {
-    throw new Error("cannot resolve bin dir for entry without toolchain");
-  }
-  if (entry.toolchainBinDir) {
-    if (entry.toolchain === "go") {
-      const gopath = process.env["GOPATH"] ?? join17(homedir4(), "go");
-      return join17(gopath, "bin");
-    }
-    return join17(homedir4(), entry.toolchainBinDir);
+async function darwinUninstall() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
   }
-  if (entry.toolchain === "gem") {
-    const userdir = await captureStdout("gem", ["env", "userdir"]);
-    return join17(userdir.trim(), "bin");
+  try {
+    await unlink6(plistPath());
+  } catch {
   }
-  throw new Error(`no bin-dir resolution for toolchain ${entry.toolchain}`);
 }
-function getToolchainBinDirs() {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const entry of Object.values(TOOLCHAIN_LSPS)) {
-    if (entry.bundled || !entry.toolchain || !entry.toolchainBinDir)
-      continue;
-    if (entry.toolchain === "go") {
-      const gopath = process.env["GOPATH"] ?? join17(homedir4(), "go");
-      dirs.add(join17(gopath, "bin"));
-    } else {
-      dirs.add(join17(homedir4(), entry.toolchainBinDir));
-    }
+async function darwinIsInstalled() {
+  try {
+    const stdout = await exec("launchctl", ["list"]);
+    return stdout.includes(PLIST_LABEL);
+  } catch {
+    return false;
   }
-  return [...dirs];
 }
-function runToolchain(cmd, args) {
-  return new Promise((resolve5, reject) => {
-    const child = spawn6(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0)
-        resolve5();
-      else
-        reject(new Error(`${cmd} ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr.split("\n").slice(0, 3).join(" ")}`));
-    });
-  });
+function unitPath() {
+  return join18(homedir5(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
 }
-function captureStdout(cmd, args) {
-  return new Promise((resolve5, reject) => {
-    const child = spawn6(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", reject);
-    child.on("close", (code) => {
-      if (code === 0)
-        resolve5(stdout);
-      else
-        reject(new Error(`${cmd} ${args.join(" ")} exited ${(code ?? -1).toString()}: ${stderr}`));
-    });
-  });
+function buildUnit() {
+  const cmd = resolveListenerCommand();
+  const execStart = [process.execPath, cmd.script, ...cmd.args].join(" ");
+  const logs = logDir();
+  return `[Unit]
+Description=RepoWise Listener
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+# FIX-8: systemd user services run with a minimal PATH and don't load shell
+# profiles. Inject a rich PATH so LSP servers + the typed-resolution probe
+# resolve (single source of truth: buildDaemonPath() in lsp/daemon-path.ts).
+Environment=PATH=${sanitizeEnvValue(buildDaemonPath())}
+ExecStart=${execStart}
+Restart=always
+RestartSec=10
+StandardOutput=append:${join18(logs, "listener-stdout.log")}
+StandardError=append:${join18(logs, "listener-stderr.log")}
+
+[Install]
+WantedBy=default.target`;
 }
-async function isCommandOnPath(command) {
-  if (/[^\w./+-]/.test(command))
-    return false;
-  const probeCmd = process.platform === "win32" ? "where" : "which";
-  return new Promise((resolve5) => {
-    const child = spawn6(probeCmd, [command], { stdio: "ignore", timeout: 5e3 });
-    child.on("error", () => resolve5(false));
-    child.on("close", (code) => resolve5(code === 0));
-  });
+async function linuxInstall() {
+  await mkdir8(logDir(), { recursive: true });
+  await mkdir8(join18(homedir5(), ".config", "systemd", "user"), { recursive: true });
+  await writeFile8(unitPath(), buildUnit());
+  await exec("systemctl", ["--user", "daemon-reload"]);
+  await exec("systemctl", ["--user", "enable", SYSTEMD_SERVICE]);
+  await exec("systemctl", ["--user", "start", SYSTEMD_SERVICE]);
 }
-async function pathExists3(p) {
+async function linuxUninstall() {
   try {
-    await fs3.access(p);
-    return true;
+    await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "disable", SYSTEMD_SERVICE]);
+  } catch {
+  }
+  try {
+    await unlink6(unitPath());
+  } catch {
+  }
+  try {
+    await exec("systemctl", ["--user", "daemon-reload"]);
   } catch {
-    return false;
   }
 }
-var init_toolchain_installer = __esm({
-  "../listener/dist/lsp/toolchain-installer.js"() {
-    "use strict";
-    init_src();
+async function linuxIsInstalled() {
+  try {
+    const stdout = await exec("systemctl", ["--user", "is-enabled", SYSTEMD_SERVICE]);
+    return stdout.trim() === "enabled";
+  } catch {
+    return false;
   }
-});
-
-// ../listener/dist/lsp/installer.js
-import { promises as fs4 } from "fs";
-import { join as join18, dirname as dirname6 } from "path";
-import { spawn as spawn7 } from "child_process";
-import lockfile3 from "proper-lockfile";
-function getLspInstallDir() {
-  return join18(getConfigDir(), "lsp-servers");
 }
-function getLspBinDir() {
-  return join18(getLspInstallDir(), "node_modules", ".bin");
+async function win32Install() {
+  await mkdir8(logDir(), { recursive: true });
+  const cmd = resolveListenerCommand();
+  const taskCmd = [process.execPath, cmd.script, ...cmd.args].map((a) => `"${a}"`).join(" ");
+  await exec("schtasks", [
+    "/create",
+    "/tn",
+    TASK_NAME,
+    "/tr",
+    taskCmd,
+    "/sc",
+    "onlogon",
+    "/ru",
+    process.env.USERNAME ?? "",
+    "/f"
+  ]);
+  await exec("schtasks", ["/run", "/tn", TASK_NAME]);
 }
-async function ensureNpmLspInstalled(config2) {
-  if (!config2.npmPackage)
-    return { installed: false, skipped: "no-npm-package" };
-  const installDir = getLspInstallDir();
-  const binPath = join18(installDir, "node_modules", ".bin", config2.command);
-  if (await pathExists4(binPath)) {
-    return { installed: false, skipped: "already-present" };
+async function win32Uninstall() {
+  try {
+    await exec("schtasks", ["/end", "/tn", TASK_NAME]);
+  } catch {
   }
   try {
-    await fs4.mkdir(installDir, { recursive: true });
-    let release = null;
-    try {
-      release = await lockfile3.lock(installDir, {
-        stale: 18e4,
-        retries: { retries: 20, factor: 1.5, minTimeout: 500, maxTimeout: 5e3 },
-        realpath: false
-      });
-    } catch {
-      if (await pathExists4(binPath)) {
-        return { installed: false, skipped: "already-present" };
-      }
-    }
-    try {
-      if (await pathExists4(binPath)) {
-        return { installed: false, skipped: "already-present" };
-      }
-      const pkgJsonPath = join18(installDir, "package.json");
-      if (!await pathExists4(pkgJsonPath)) {
-        await fs4.writeFile(pkgJsonPath, JSON.stringify({ name: "repowise-lsp-servers", private: true, version: "0.0.0" }, null, 2), "utf-8");
-      }
-      await runNpmInstall(installDir, config2.npmPackage);
-      if (!await pathExists4(binPath)) {
-        return {
-          installed: false,
-          error: `npm install completed but ${config2.command} still not at ${binPath}`
-        };
-      }
-      return { installed: true };
-    } finally {
-      if (release) {
-        try {
-          await release();
-        } catch {
-        }
-      }
-    }
-  } catch (err) {
-    return {
-      installed: false,
-      error: err instanceof Error ? err.message : String(err)
-    };
+    await exec("schtasks", ["/delete", "/tn", TASK_NAME, "/f"]);
+  } catch {
   }
 }
-async function resolveNpmCommand() {
-  const nodeDir = dirname6(process.execPath);
-  for (const candidate of [join18(nodeDir, "npm"), join18(nodeDir, "npm.cmd")]) {
-    try {
-      await fs4.access(candidate);
-      return candidate;
-    } catch {
-    }
+async function win32IsInstalled() {
+  try {
+    await exec("schtasks", ["/query", "/tn", TASK_NAME]);
+    return true;
+  } catch {
+    return false;
   }
-  for (const candidate of ["/opt/homebrew/bin/npm", "/usr/local/bin/npm", "/usr/bin/npm"]) {
-    try {
-      await fs4.access(candidate);
-      return candidate;
-    } catch {
-    }
+}
+async function darwinStop() {
+  try {
+    await exec("launchctl", ["unload", plistPath()]);
+  } catch {
   }
-  return "npm";
 }
-async function runNpmInstall(cwd, pkg2) {
-  const npmCmd = await resolveNpmCommand();
-  const nodeDir = dirname6(process.execPath);
-  const augmentedPath = process.env.PATH ? `${nodeDir}:${process.env.PATH}` : nodeDir;
-  return new Promise((resolve5, reject) => {
-    const child = spawn7(npmCmd, ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, PATH: augmentedPath }
-    });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (err) => reject(err));
-    child.on("close", (code) => {
-      if (code === 0) {
-        resolve5();
-      } else {
-        reject(new Error(`npm install ${pkg2} exited ${(code ?? -1).toString()}: ${sanitizeNpmStderr(stderr)}`));
-      }
-    });
-  });
+async function linuxStop() {
+  await exec("systemctl", ["--user", "stop", SYSTEMD_SERVICE]);
 }
-function sanitizeNpmStderr(raw) {
-  const truncated = raw.split("\n").slice(0, 3).join(" ").trim();
-  return truncated.replace(/(https?:\/\/)[^@\s/]*@/g, (_match, scheme) => `${scheme}<redacted>@`);
+async function win32Stop() {
+  await exec("schtasks", ["/end", "/tn", TASK_NAME]);
 }
-async function pathExists4(p) {
+async function darwinIsServiceRunning() {
   try {
-    await fs4.access(p);
-    return true;
+    const stdout = await exec("launchctl", ["list", PLIST_LABEL]);
+    const pidMatch = stdout.match(/"PID"\s*=\s*(\d+)/);
+    return pidMatch !== null && parseInt(pidMatch[1], 10) > 0;
   } catch {
     return false;
   }
 }
-async function detectRepoLanguages(repoRoot) {
-  const found = /* @__PURE__ */ new Set();
-  let inspected = 0;
-  const MAX_INSPECT = 200;
-  async function inspect(dir) {
-    if (inspected >= MAX_INSPECT)
-      return;
-    let entries;
-    try {
-      entries = await fs4.readdir(dir);
-    } catch {
-      return;
-    }
-    for (const name of entries) {
-      if (inspected >= MAX_INSPECT)
-        return;
-      if (name.startsWith("."))
-        continue;
-      if (name === "node_modules" || name === "dist" || name === "build")
-        continue;
-      const lang = detectLanguage(name);
-      if (lang) {
-        found.add(lang);
-        inspected += 1;
-      }
-    }
+async function linuxIsServiceRunning() {
+  try {
+    const stdout = await exec("systemctl", ["--user", "is-active", SYSTEMD_SERVICE]);
+    return stdout.trim() === "active";
+  } catch {
+    return false;
   }
-  await inspect(repoRoot);
-  let topEntries = [];
+}
+async function win32IsServiceRunning() {
   try {
-    topEntries = await fs4.readdir(repoRoot);
+    const stdout = await exec("schtasks", ["/query", "/tn", TASK_NAME, "/fo", "CSV"]);
+    return stdout.includes("Running");
   } catch {
-    return found;
+    return false;
+  }
+}
+async function stopService() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinStop();
+      break;
+    case "linux":
+      await linuxStop();
+      break;
+    case "win32":
+      await win32Stop();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+}
+async function install() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinInstall();
+      break;
+    case "linux":
+      await linuxInstall();
+      break;
+    case "win32":
+      await win32Install();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
   }
-  for (const name of topEntries) {
-    if (name.startsWith("."))
-      continue;
-    if (name === "node_modules" || name === "dist" || name === "build")
-      continue;
-    const sub = join18(repoRoot, name);
-    try {
-      const stat8 = await fs4.stat(sub);
-      if (stat8.isDirectory())
-        await inspect(sub);
-    } catch {
-    }
+}
+async function uninstall() {
+  switch (process.platform) {
+    case "darwin":
+      await darwinUninstall();
+      break;
+    case "linux":
+      await linuxUninstall();
+      break;
+    case "win32":
+      await win32Uninstall();
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
   }
-  return found;
 }
-async function prepareLspServersForRepos(repos, options = {}) {
-  const detected = /* @__PURE__ */ new Set();
-  for (const r of repos) {
-    if (!r.localPath)
-      continue;
-    try {
-      const stat8 = await fs4.stat(r.localPath);
-      if (!stat8.isDirectory())
-        continue;
-    } catch {
-      continue;
-    }
-    try {
-      const langs = await detectRepoLanguages(r.localPath);
-      for (const l of langs)
-        detected.add(l);
-    } catch {
-    }
+async function isInstalled() {
+  switch (process.platform) {
+    case "darwin":
+      return darwinIsInstalled();
+    case "linux":
+      return linuxIsInstalled();
+    case "win32":
+      return win32IsInstalled();
+    default:
+      return false;
   }
-  const results = [];
-  for (const language of detected) {
-    const configs = getEffectiveConfigList(language, process.env, options.lspOverrides);
-    const npmConfig = configs.find((c) => c.npmPackage);
-    if (npmConfig) {
-      const outcome = await ensureNpmLspInstalled(npmConfig);
-      results.push({
-        language,
-        installed: outcome.installed,
-        alreadyPresent: outcome.skipped === "already-present",
-        skippedNoNpmPackage: false,
-        installMethod: "npm",
-        error: outcome.error
-      });
-      continue;
-    }
-    const nativeConfig = configs.find((c) => c.nativeInstallKey);
-    if (nativeConfig?.nativeInstallKey) {
-      const outcome = await ensureNativeLspInstalled(nativeConfig.nativeInstallKey);
-      results.push({
-        language,
-        installed: outcome.installed,
-        alreadyPresent: outcome.alreadyPresent,
-        skippedNoNpmPackage: false,
-        installMethod: "native",
-        skipped: outcome.skipped,
-        hint: outcome.skipped ? nativeConfig.installHint : void 0,
-        error: outcome.error
-      });
-      continue;
-    }
-    const coursierConfig = configs.find((c) => c.coursierInstallKey);
-    if (coursierConfig?.coursierInstallKey) {
-      const outcome = await ensureCoursierLspInstalled(coursierConfig.coursierInstallKey);
-      results.push({
-        language,
-        installed: outcome.installed,
-        alreadyPresent: outcome.alreadyPresent,
-        skippedNoNpmPackage: false,
-        installMethod: "coursier",
-        skipped: outcome.skipped,
-        hint: outcome.skipped ? coursierConfig.installHint : void 0,
-        error: outcome.error
-      });
-      continue;
-    }
-    const toolchainConfig = configs.find((c) => c.toolchainInstallKey);
-    if (toolchainConfig?.toolchainInstallKey) {
-      const outcome = await ensureToolchainLspInstalled(toolchainConfig.toolchainInstallKey);
-      results.push({
-        language,
-        installed: outcome.installed,
-        alreadyPresent: outcome.alreadyPresent,
-        skippedNoNpmPackage: false,
-        installMethod: "toolchain",
-        skipped: outcome.skipped,
-        // Surface the install hint for any skip reason — toolchain
-        // missing means user needs to install it; bundled SDK means
-        // user needs the SDK.
-        hint: outcome.skipped ? toolchainConfig.installHint : void 0,
-        error: outcome.error
-      });
-      continue;
-    }
-    results.push({
-      language,
-      installed: false,
-      alreadyPresent: false,
-      skippedNoNpmPackage: true,
-      hint: configs[0]?.installHint
-    });
+}
+async function isServiceRunning() {
+  switch (process.platform) {
+    case "darwin":
+      return darwinIsServiceRunning();
+    case "linux":
+      return linuxIsServiceRunning();
+    case "win32":
+      return win32IsServiceRunning();
+    default:
+      return false;
   }
-  return results;
 }
-var init_installer = __esm({
-  "../listener/dist/lsp/installer.js"() {
+var IS_STAGING, PLIST_LABEL, SYSTEMD_SERVICE, TASK_NAME;
+var init_service_installer = __esm({
+  "../listener/dist/service-installer.js"() {
     "use strict";
     init_config_dir();
-    init_registry();
-    init_native_installer();
-    init_coursier_installer();
-    init_toolchain_installer();
+    init_process_manager();
+    init_daemon_path();
+    IS_STAGING = true ? true : false;
+    PLIST_LABEL = IS_STAGING ? "com.repowise-staging.listener" : "com.repowise.listener";
+    SYSTEMD_SERVICE = IS_STAGING ? "repowise-staging-listener" : "repowise-listener";
+    TASK_NAME = IS_STAGING ? "RepoWise Staging Listener" : "RepoWise Listener";
   }
 });
 
@@ -2316,7 +2386,7 @@ __export(sidecar_cache_exports, {
   sidecarCachePaths: () => sidecarCachePaths
 });
 import { mkdir as mkdir9, readFile as readFile8, readdir as readdir3, stat as stat2, unlink as unlink8, writeFile as writeFile9 } from "fs/promises";
-import { dirname as dirname8, join as join19 } from "path";
+import { dirname as dirname9, join as join20 } from "path";
 function repoIdSafe(repoId) {
   return /^[A-Za-z0-9_.-]{1,128}$/.test(repoId) && !repoId.startsWith(".");
 }
@@ -2330,8 +2400,8 @@ function sidecarCachePaths(repoId, commitSha) {
   if (!commitShaSafe(commitSha)) {
     throw new Error(`unsafe commitSha: ${commitSha}`);
   }
-  const repoDir = join19(getConfigDir(), "typed-resolution", repoId);
-  const fullPath = join19(repoDir, `${commitSha}.jsonl`);
+  const repoDir = join20(getConfigDir(), "typed-resolution", repoId);
+  const fullPath = join20(repoDir, `${commitSha}.jsonl`);
   return { fullPath, repoDir };
 }
 async function persistMergedSidecar(repoId, commitSha, sidecar) {
@@ -2354,7 +2424,7 @@ async function sweepSidecarDir(repoDir) {
   const withMtime = [];
   for (const name of jsonlFiles) {
     try {
-      const s = await stat2(join19(repoDir, name));
+      const s = await stat2(join20(repoDir, name));
       withMtime.push({ name, mtimeMs: s.mtimeMs });
     } catch {
     }
@@ -2365,7 +2435,7 @@ async function sweepSidecarDir(repoDir) {
   for (const { name, mtimeMs } of candidates) {
     if (now - mtimeMs >= SWEEP_MAX_AGE_MS) {
       try {
-        await unlink8(join19(repoDir, name));
+        await unlink8(join20(repoDir, name));
       } catch {
       }
     }
@@ -2469,7 +2539,10 @@ async function uploadSidecar(req, fetchImpl = fetch) {
     throw new Error("upload-url response missing `data.url`");
   const putRes = await fetchImpl(presignedUrl, {
     method: "PUT",
-    headers: { "content-type": "application/json" },
+    headers: {
+      "content-type": "application/json",
+      "x-amz-server-side-encryption": "aws:kms"
+    },
     body
   });
   if (!putRes.ok) {
@@ -3060,13 +3133,13 @@ var init_telemetry = __esm({
 // bin/repowise.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname21, join as join60 } from "path";
+import { dirname as dirname23, join as join61 } from "path";
 import { Command } from "commander";
 
 // ../listener/dist/main.js
 init_config_dir();
 import { readFile as readFile13, writeFile as writeFile15, mkdir as mkdir16, stat as fsStat } from "fs/promises";
-import { join as join40, dirname as dirname15 } from "path";
+import { join as join41, dirname as dirname17 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import lockfile4 from "proper-lockfile";
 
@@ -4877,7 +4950,7 @@ init_config_dir();
 init_process_manager();
 init_service_installer();
 import { unlink as unlink7 } from "fs/promises";
-import { join as join14 } from "path";
+import { join as join19 } from "path";
 async function getListenerStatus() {
   const pid = await readPid();
   if (pid !== null) {
@@ -4886,7 +4959,7 @@ async function getListenerStatus() {
       return { running: true, method: "pid", pid, serviceInstalled: serviceInstalled2 };
     }
     try {
-      await unlink7(join14(getConfigDir(), "listener.pid"));
+      await unlink7(join19(getConfigDir(), "listener.pid"));
     } catch {
     }
   }
@@ -4931,15 +5004,15 @@ async function stopListener() {
 
 // ../listener/dist/mcp/bootstrap.js
 init_config_dir();
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // ../listener/dist/lsp/workspace-session.js
 import { pathToFileURL } from "url";
 import { readFile as readFile7 } from "fs/promises";
-import { resolve as pathResolve2, sep as pathSep, dirname as dirname7 } from "path";
+import { resolve as pathResolve2, sep as pathSep, dirname as dirname8, delimiter as delimiter2 } from "path";
 
 // ../listener/dist/lsp/lsp-client.js
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 import { EventEmitter, once } from "events";
 import { Buffer as Buffer2 } from "buffer";
 var LspTimeoutError = class extends Error {
@@ -4984,7 +5057,7 @@ var LspClient = class extends EventEmitter {
   closed = false;
   constructor(options) {
     super();
-    this.child = options.spawn ? options.spawn() : spawn2(options.command, [...options.args ?? []], {
+    this.child = options.spawn ? options.spawn() : spawn7(options.command, [...options.args ?? []], {
       cwd: options.cwd,
       env: options.env ?? process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -5207,10 +5280,7 @@ var LspClient = class extends EventEmitter {
 };
 
 // ../listener/dist/lsp/workspace-session.js
-init_installer();
-init_native_installer();
-init_coursier_installer();
-init_toolchain_installer();
+init_daemon_path();
 
 // ../listener/dist/lsp/bloop-lifecycle.js
 import { spawn as spawn8 } from "child_process";
@@ -5270,13 +5340,7 @@ var WorkspaceManager = class {
     this.rssSampler = opts.rssSampler ?? (() => process.memoryUsage().rss);
     this.clientFactory = opts.clientFactory ?? ((config2, cwd) => {
       const env = { ...process.env };
-      const lspBinDirs = [
-        getLspBinDir(),
-        getNativeLspBinDir(),
-        getCoursierBinDir(),
-        ...getToolchainBinDirs()
-      ];
-      env.PATH = buildLspSpawnPath(env.PATH, dirname7(process.execPath), lspBinDirs);
+      env.PATH = buildLspSpawnPath(env.PATH, dirname8(process.execPath), managedBinDirs());
       const client = new LspClient({
         command: config2.command,
         args: config2.args,
@@ -5645,14 +5709,19 @@ var PathEscapeError = class extends Error {
   }
 };
 function buildLspSpawnPath(basePath, nodeDir, lspBinDirs) {
-  const extra = lspBinDirs.join(":");
-  return basePath ? `${nodeDir}:${basePath}:${extra}` : `${nodeDir}:${extra}`;
+  const parts = [
+    nodeDir,
+    ...basePath ? basePath.split(delimiter2) : [],
+    ...commonBinDirs(),
+    ...lspBinDirs
+  ];
+  return [...new Set(parts.filter((d) => d.length > 0))].join(delimiter2);
 }
 
 // ../listener/dist/mcp/graph-cache.js
 init_config_dir();
 import { readFile as readFile9, stat as stat3 } from "fs/promises";
-import { join as join20 } from "path";
+import { join as join21 } from "path";
 var EVICT_DEBOUNCE_MS = 6e4;
 function assertSafeRepoId(repoId) {
   if (!repoId || typeof repoId !== "string") {
@@ -5667,7 +5736,7 @@ function assertSafeRepoId(repoId) {
 }
 function createGraphCache(options = {}) {
   const evictMs = options.evictDebounceMs ?? EVICT_DEBOUNCE_MS;
-  const resolvePath = options.resolveGraphPath ?? ((repoId) => join20(defaultRepoWiseHome(), "graphs", `${repoId}.json`));
+  const resolvePath = options.resolveGraphPath ?? ((repoId) => join21(defaultRepoWiseHome(), "graphs", `${repoId}.json`));
   const entries = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
   async function loadFromDisk(repoId) {
@@ -5761,7 +5830,7 @@ function defaultRepoWiseHome() {
 
 // ../listener/dist/mcp/graph-downloader.js
 import { mkdir as mkdir10, rename as rename3, writeFile as writeFile10 } from "fs/promises";
-import { dirname as dirname9 } from "path";
+import { dirname as dirname10 } from "path";
 function createGraphDownloader(options) {
   const fetchFn = options.fetchImpl ?? fetch;
   let lastSha = null;
@@ -5812,7 +5881,7 @@ function createGraphDownloader(options) {
         message: `graph parse: ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    await mkdir10(dirname9(options.targetPath), { recursive: true });
+    await mkdir10(dirname10(options.targetPath), { recursive: true });
     const tmpPath = `${options.targetPath}.${Date.now()}.tmp`;
     await writeFile10(tmpPath, body, { encoding: "utf-8", mode: 384 });
     await rename3(tmpPath, options.targetPath);
@@ -5838,7 +5907,7 @@ function createGraphDownloader(options) {
 // ../listener/dist/mcp/log-encryption.js
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
 import { mkdir as mkdir11, readFile as readFile10, stat as stat4, writeFile as writeFile11 } from "fs/promises";
-import { dirname as dirname10 } from "path";
+import { dirname as dirname11 } from "path";
 var KEY_BYTES = 32;
 var IV_BYTES = 12;
 var TAG_BYTES = 16;
@@ -5885,7 +5954,7 @@ function createFileKeyStore(keyPath) {
         return parsed;
       }
       const fresh = randomBytes(KEY_BYTES);
-      await mkdir11(dirname10(keyPath), { recursive: true });
+      await mkdir11(dirname11(keyPath), { recursive: true });
       const tmp = `${keyPath}.tmp`;
       await writeFile11(tmp, fresh.toString("base64") + "\n", {
         encoding: "utf-8",
@@ -5927,7 +5996,7 @@ function decryptLine(encoded, key) {
 
 // ../listener/dist/mcp/mcp-logger.js
 import { appendFile, mkdir as mkdir12, stat as stat5, unlink as unlink9, writeFile as writeFile12, readFile as readFile11 } from "fs/promises";
-import { dirname as dirname11 } from "path";
+import { dirname as dirname12 } from "path";
 var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
 function createMcpLogger(options) {
   const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
@@ -5950,7 +6019,7 @@ function createMcpLogger(options) {
     await migrateLegacyPlaintext();
     const key = await options.keyStore.getKey();
     const encoded = encryptLine(JSON.stringify(entry), key) + "\n";
-    await mkdir12(dirname11(options.filePath), { recursive: true });
+    await mkdir12(dirname12(options.filePath), { recursive: true });
     await appendFile(options.filePath, encoded, { encoding: "utf-8", mode: 384 });
     try {
       const s = await stat5(options.filePath);
@@ -5984,7 +6053,7 @@ async function rotate(path, size) {
 // ../listener/dist/mcp/mcp-log-uploader.js
 import { randomUUID } from "crypto";
 import { readFile as readFile12, writeFile as writeFile13, mkdir as mkdir13 } from "fs/promises";
-import { dirname as dirname12 } from "path";
+import { dirname as dirname13 } from "path";
 var DEFAULT_MAX_ENTRIES = 5e3;
 var DEFAULT_MAX_BYTES2 = 1 * 1024 * 1024;
 function createMcpLogUploader(options) {
@@ -6134,7 +6203,7 @@ async function readPendingBatch(watermarkPath) {
   }
 }
 async function writePendingBatch(watermarkPath, batchId) {
-  await mkdir13(dirname12(watermarkPath), { recursive: true });
+  await mkdir13(dirname13(watermarkPath), { recursive: true });
   await writeFile13(pendingPath(watermarkPath), batchId, { encoding: "utf-8", mode: 384 });
 }
 async function clearPendingBatch(watermarkPath) {
@@ -6156,7 +6225,7 @@ async function readWatermark(path) {
   }
 }
 async function writeWatermark(path, offset) {
-  await mkdir13(dirname12(path), { recursive: true });
+  await mkdir13(dirname13(path), { recursive: true });
   const tmp = `${path}.tmp`;
   await writeFile13(tmp, offset.toString() + "\n", { encoding: "utf-8", mode: 384 });
   const { rename: rename5 } = await import("fs/promises");
@@ -6176,7 +6245,7 @@ async function isLocallyConsented(flagPath2) {
 init_config_dir();
 import { createServer } from "http";
 import { mkdir as mkdir14, writeFile as writeFile14 } from "fs/promises";
-import { dirname as dirname13, join as join21 } from "path";
+import { dirname as dirname14, join as join22 } from "path";
 import { createHash as createHash4, randomUUID as randomUUID2 } from "crypto";
 
 // ../listener/dist/mcp/sanitize.js
@@ -7694,7 +7763,7 @@ async function readJson(req) {
   }
 }
 async function writeEndpointFile(path, endpoint, secret) {
-  await mkdir14(dirname13(path), { recursive: true });
+  await mkdir14(dirname14(path), { recursive: true });
   await writeFile14(path, formatEndpointFile({ endpoint, secret }), {
     encoding: "utf-8",
     mode: 384
@@ -7708,7 +7777,7 @@ function extractBearer(header) {
   return m ? m[1] : null;
 }
 function defaultEndpointFile() {
-  return join21(getConfigDir(), "listener.endpoint");
+  return join22(getConfigDir(), "listener.endpoint");
 }
 
 // ../listener/dist/mcp/bootstrap.js
@@ -7716,7 +7785,7 @@ async function startMcp(options) {
   const disabled = process.env.REPOWISE_MCP_DISABLED === "true";
   const graphsDir = options.graphsDir ?? defaultGraphsDir();
   const graphCache = createGraphCache({
-    resolveGraphPath: (repoId) => join22(graphsDir, `${repoId}.json`)
+    resolveGraphPath: (repoId) => join23(graphsDir, `${repoId}.json`)
   });
   if (disabled) {
     return {
@@ -7739,12 +7808,12 @@ async function startMcp(options) {
   }
   const firstRepoLocal = options.repos.find((r) => r.localPath)?.localPath;
   const mcpHome = defaultMcpHome();
-  const logFilePath = join22(mcpHome, "mcp-log.jsonl.enc");
-  const keyStore = createFileKeyStore(join22(mcpHome, "mcp-log.key"));
+  const logFilePath = join23(mcpHome, "mcp-log.jsonl.enc");
+  const keyStore = createFileKeyStore(join23(mcpHome, "mcp-log.key"));
   const mcpLogger = createMcpLogger({ filePath: logFilePath, keyStore });
-  const flagFilePath = join22(mcpHome, "mcp-log.flag");
-  const watermarkFilePath = join22(mcpHome, "mcp-log.watermark");
-  const consentSentMarkerPath = join22(mcpHome, "mcp-log.consent-sent");
+  const flagFilePath = join23(mcpHome, "mcp-log.flag");
+  const watermarkFilePath = join23(mcpHome, "mcp-log.watermark");
+  const consentSentMarkerPath = join23(mcpHome, "mcp-log.consent-sent");
   let uploader = null;
   let lastConsentState = false;
   let serverConsentEnsuredThisProcess = false;
@@ -7791,7 +7860,7 @@ async function startMcp(options) {
       apiBaseUrl: repo.apiUrl,
       getAuthToken: options.getAuthToken,
       repoId: repo.repoId,
-      targetPath: join22(graphsDir, `${repo.repoId}.json`),
+      targetPath: join23(graphsDir, `${repo.repoId}.json`),
       graphCache,
       ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
     }));
@@ -7876,7 +7945,7 @@ async function startMcp(options) {
           apiBaseUrl: repo.apiUrl,
           getAuthToken: options.getAuthToken,
           repoId: repo.repoId,
-          targetPath: join22(graphsDir, `${repo.repoId}.json`),
+          targetPath: join23(graphsDir, `${repo.repoId}.json`),
           graphCache,
           ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
         }));
@@ -7897,7 +7966,7 @@ async function startMcp(options) {
   };
 }
 function defaultGraphsDir() {
-  return join22(getConfigDir(), "graphs");
+  return join23(getConfigDir(), "graphs");
 }
 function defaultMcpHome() {
   return getConfigDir();
@@ -7950,16 +8019,16 @@ async function ensureServerConsent(opts) {
 }
 
 // ../listener/dist/mcp/auto-config/index.js
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { basename as basename3 } from "path";
 
 // ../listener/dist/mcp/auto-config/writers/claude-code.js
 import { promises as fs6 } from "fs";
-import { join as join23 } from "path";
+import { join as join24 } from "path";
 
 // ../listener/dist/mcp/auto-config/markers.js
 import { promises as fs5 } from "fs";
-import { dirname as dirname14 } from "path";
+import { dirname as dirname15 } from "path";
 async function writeMergedConfig(params) {
   const current = await readConfig(params.path);
   const servers = { ...current.mcpServers ?? {} };
@@ -7969,7 +8038,7 @@ async function writeMergedConfig(params) {
   const existing = safeExistingContent(params.path, current);
   if (existing === canonical)
     return "unchanged";
-  await fs5.mkdir(dirname14(params.path), { recursive: true });
+  await fs5.mkdir(dirname15(params.path), { recursive: true });
   await fs5.writeFile(params.path, canonical, "utf-8");
   return "written";
 }
@@ -8035,10 +8104,10 @@ function safeExistingContent(path, current) {
 var claudeCodeWriter = {
   tool: "claude-code",
   async detect(repoRoot, home) {
-    return await fileExists2(join23(repoRoot, "CLAUDE.md")) || await hasClaudeBinary(home);
+    return await fileExists2(join24(repoRoot, "CLAUDE.md")) || await hasClaudeBinary(home);
   },
   async write(ctx) {
-    const path = join23(ctx.repoRoot, ".mcp.json");
+    const path = join24(ctx.repoRoot, ".mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8048,7 +8117,7 @@ var claudeCodeWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join23(ctx.repoRoot, ".mcp.json");
+    const path = join24(ctx.repoRoot, ".mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8062,20 +8131,20 @@ async function fileExists2(path) {
   }
 }
 async function hasClaudeBinary(home) {
-  return fileExists2(join23(home, ".claude", "claude.json"));
+  return fileExists2(join24(home, ".claude", "claude.json"));
 }
 
 // ../listener/dist/mcp/auto-config/writers/claude-code-hooks.js
 import { promises as fs7 } from "fs";
-import { join as join24 } from "path";
+import { join as join25 } from "path";
 var claudeCodeHooksWriter = {
   tool: "claude-code-hooks",
   async detect(repoRoot, home) {
-    return await fileExists3(join24(repoRoot, "CLAUDE.md")) || await fileExists3(join24(home, ".claude.json"));
+    return await fileExists3(join25(repoRoot, "CLAUDE.md")) || await fileExists3(join25(home, ".claude.json"));
   },
   async write(ctx) {
     const result = await writeClaudeHooksToRepo(ctx.repoRoot, ctx.contextFolder ?? "repowise-context", ctx.variant);
-    return { status: result.status, path: join24(ctx.repoRoot, result.relPath) };
+    return { status: result.status, path: join25(ctx.repoRoot, result.relPath) };
   },
   async remove(ctx) {
     await removeClaudeHooksFromRepo(ctx.repoRoot);
@@ -8092,14 +8161,14 @@ async function fileExists3(path) {
 
 // ../listener/dist/mcp/auto-config/writers/cline.js
 import { promises as fs8 } from "fs";
-import { join as join25 } from "path";
+import { join as join26 } from "path";
 var clineWriter = {
   tool: "cline",
   async detect(repoRoot, home) {
-    return await fileExists4(join25(repoRoot, ".clinerules")) || await fileExists4(join25(home, ".cline"));
+    return await fileExists4(join26(repoRoot, ".clinerules")) || await fileExists4(join26(home, ".cline"));
   },
   async write(ctx) {
-    const path = join25(ctx.home, ".cline", "mcp.json");
+    const path = join26(ctx.home, ".cline", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8109,7 +8178,7 @@ var clineWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join25(ctx.home, ".cline", "mcp.json");
+    const path = join26(ctx.home, ".cline", "mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8125,13 +8194,13 @@ async function fileExists4(path) {
 
 // ../listener/dist/mcp/auto-config/writers/cline-hooks.js
 import { promises as fs9 } from "fs";
-import { join as join26 } from "path";
+import { join as join27 } from "path";
 var SCRIPT_REL = ".clinerules/hooks/UserPromptSubmit";
 var OWNERSHIP_MARKER = "managed by RepoWise";
 var clineHooksWriter = {
   tool: "cline-hooks",
   async detect(repoRoot) {
-    return fileExists5(join26(repoRoot, ".clinerules"));
+    return fileExists5(join27(repoRoot, ".clinerules"));
   },
   async write(ctx) {
     if (await isGitTracked(ctx.repoRoot, SCRIPT_REL)) {
@@ -8141,7 +8210,7 @@ var clineHooksWriter = {
         reason: `${SCRIPT_REL} is git-tracked; update it manually to opt in`
       };
     }
-    const path = join26(ctx.repoRoot, SCRIPT_REL);
+    const path = join27(ctx.repoRoot, SCRIPT_REL);
     const next = buildClineHookScript({
       repoName: ctx.repoName,
       contextFolder: ctx.contextFolder ?? "repowise-context",
@@ -8158,14 +8227,14 @@ var clineHooksWriter = {
       await ensureExecutable(path);
       return { status: "unchanged", path };
     }
-    await fs9.mkdir(join26(ctx.repoRoot, ".clinerules", "hooks"), { recursive: true });
+    await fs9.mkdir(join27(ctx.repoRoot, ".clinerules", "hooks"), { recursive: true });
     await fs9.writeFile(path, next, { encoding: "utf-8", mode: 493 });
     await ensureExecutable(path);
     await applyGitignoreChanges(ctx.repoRoot, { add: [SCRIPT_REL] });
     return { status: "written", path };
   },
   async remove(ctx) {
-    const path = join26(ctx.repoRoot, SCRIPT_REL);
+    const path = join27(ctx.repoRoot, SCRIPT_REL);
     const existing = await readOrNull(path);
     if (existing !== null && existing.includes(OWNERSHIP_MARKER)) {
       await fs9.unlink(path);
@@ -8200,14 +8269,14 @@ async function readOrNull(path) {
 
 // ../listener/dist/mcp/auto-config/writers/codex.js
 import { promises as fs10 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var codexWriter = {
   tool: "codex",
   async detect(_repoRoot, home) {
-    return fileExists6(join27(home, ".codex"));
+    return fileExists6(join28(home, ".codex"));
   },
   async write(ctx) {
-    const path = join27(ctx.home, ".codex", "mcp.json");
+    const path = join28(ctx.home, ".codex", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8217,7 +8286,7 @@ var codexWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join27(ctx.home, ".codex", "mcp.json");
+    const path = join28(ctx.home, ".codex", "mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8233,15 +8302,15 @@ async function fileExists6(path) {
 
 // ../listener/dist/mcp/auto-config/writers/codex-hooks.js
 import { promises as fs11 } from "fs";
-import { join as join28 } from "path";
+import { join as join29 } from "path";
 var HOOKS_REL = ".codex/hooks.json";
 var codexHooksWriter = {
   tool: "codex-hooks",
   async detect(repoRoot, home) {
-    return await fileExists7(join28(home, ".codex")) || await fileExists7(join28(repoRoot, ".codex"));
+    return await fileExists7(join29(home, ".codex")) || await fileExists7(join29(repoRoot, ".codex"));
   },
   async write(ctx) {
-    const repoSignal = await fileExists7(join28(ctx.repoRoot, ".codex"));
+    const repoSignal = await fileExists7(join29(ctx.repoRoot, ".codex"));
     const selected = ctx.selectedTools?.includes("codex") ?? false;
     if (!repoSignal && !selected) {
       return { status: "skipped", reason: "no repo-scoped Codex signal and not selected" };
@@ -8253,7 +8322,7 @@ var codexHooksWriter = {
         reason: `${HOOKS_REL} is git-tracked; add the RepoWise UserPromptSubmit hook manually to opt in`
       };
     }
-    const path = join28(ctx.repoRoot, HOOKS_REL);
+    const path = join29(ctx.repoRoot, HOOKS_REL);
     const existing = await readOrNull2(path);
     const merged = mergeCodexHookSettings(existing, {
       repoName: ctx.repoName,
@@ -8263,13 +8332,13 @@ var codexHooksWriter = {
     if (merged === existing) {
       return { status: "unchanged", path };
     }
-    await fs11.mkdir(join28(ctx.repoRoot, ".codex"), { recursive: true });
+    await fs11.mkdir(join29(ctx.repoRoot, ".codex"), { recursive: true });
     await fs11.writeFile(path, merged, "utf-8");
     await applyGitignoreChanges(ctx.repoRoot, { add: [HOOKS_REL] });
     return { status: "written", path };
   },
   async remove(ctx) {
-    const path = join28(ctx.repoRoot, HOOKS_REL);
+    const path = join29(ctx.repoRoot, HOOKS_REL);
     const existing = await readOrNull2(path);
     if (existing !== null) {
       const next = removeCodexHookSettings(existing);
@@ -8300,14 +8369,14 @@ async function readOrNull2(path) {
 
 // ../listener/dist/mcp/auto-config/writers/copilot.js
 import { promises as fs12 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } from "path";
 var copilotWriter = {
   tool: "copilot",
   async detect(repoRoot) {
-    return fileExists8(join29(repoRoot, ".vscode"));
+    return fileExists8(join30(repoRoot, ".vscode"));
   },
   async write(ctx) {
-    const path = join29(ctx.repoRoot, ".vscode", "mcp.json");
+    const path = join30(ctx.repoRoot, ".vscode", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8317,7 +8386,7 @@ var copilotWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join29(ctx.repoRoot, ".vscode", "mcp.json");
+    const path = join30(ctx.repoRoot, ".vscode", "mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8333,15 +8402,15 @@ async function fileExists8(path) {
 
 // ../listener/dist/mcp/auto-config/writers/copilot-hooks.js
 import { promises as fs13 } from "fs";
-import { join as join30 } from "path";
+import { join as join31 } from "path";
 var HOOKS_REL2 = ".github/hooks/repowise.json";
 var copilotHooksWriter = {
   tool: "copilot-hooks",
   async detect(repoRoot) {
-    return fileExists9(join30(repoRoot, ".github", "copilot-instructions.md"));
+    return fileExists9(join31(repoRoot, ".github", "copilot-instructions.md"));
   },
   async write(ctx) {
-    const path = join30(ctx.repoRoot, HOOKS_REL2);
+    const path = join31(ctx.repoRoot, HOOKS_REL2);
     const next = buildCopilotHooksFile({
       repoName: ctx.repoName,
       contextFolder: ctx.contextFolder ?? "repowise-context",
@@ -8361,14 +8430,14 @@ var copilotHooksWriter = {
     if (existing === next) {
       return { status: "unchanged", path };
     }
-    await fs13.mkdir(join30(ctx.repoRoot, ".github", "hooks"), { recursive: true });
+    await fs13.mkdir(join31(ctx.repoRoot, ".github", "hooks"), { recursive: true });
     await fs13.writeFile(path, next, "utf-8");
     const userSelected = ctx.selectedTools?.includes("copilot") ?? false;
     await applyGitignoreChanges(ctx.repoRoot, userSelected ? { remove: [HOOKS_REL2] } : { add: [HOOKS_REL2] });
     return { status: "written", path };
   },
   async remove(ctx) {
-    const path = join30(ctx.repoRoot, HOOKS_REL2);
+    const path = join31(ctx.repoRoot, HOOKS_REL2);
     if (!await isGitTracked(ctx.repoRoot, HOOKS_REL2)) {
       await fs13.unlink(path).catch(() => {
       });
@@ -8394,14 +8463,14 @@ async function readOrNull3(path) {
 
 // ../listener/dist/mcp/auto-config/writers/cursor.js
 import { promises as fs14 } from "fs";
-import { join as join31 } from "path";
+import { join as join32 } from "path";
 var cursorWriter = {
   tool: "cursor",
   async detect(repoRoot) {
-    return await fileExists10(join31(repoRoot, ".cursor")) || await fileExists10(join31(repoRoot, ".cursorrules"));
+    return await fileExists10(join32(repoRoot, ".cursor")) || await fileExists10(join32(repoRoot, ".cursorrules"));
   },
   async write(ctx) {
-    const path = join31(ctx.repoRoot, ".cursor", "mcp.json");
+    const path = join32(ctx.repoRoot, ".cursor", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8411,7 +8480,7 @@ var cursorWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join31(ctx.repoRoot, ".cursor", "mcp.json");
+    const path = join32(ctx.repoRoot, ".cursor", "mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8427,14 +8496,14 @@ async function fileExists10(path) {
 
 // ../listener/dist/mcp/auto-config/writers/gemini-cli.js
 import { promises as fs15 } from "fs";
-import { join as join32 } from "path";
+import { join as join33 } from "path";
 var geminiCliWriter = {
   tool: "gemini-cli",
   async detect(_repoRoot, home) {
-    return fileExists11(join32(home, ".gemini"));
+    return fileExists11(join33(home, ".gemini"));
   },
   async write(ctx) {
-    const path = join32(ctx.home, ".gemini", "settings.json");
+    const path = join33(ctx.home, ".gemini", "settings.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8444,7 +8513,7 @@ var geminiCliWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join32(ctx.home, ".gemini", "settings.json");
+    const path = join33(ctx.home, ".gemini", "settings.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8460,15 +8529,15 @@ async function fileExists11(path) {
 
 // ../listener/dist/mcp/auto-config/writers/gemini-hooks.js
 import { promises as fs16 } from "fs";
-import { join as join33 } from "path";
+import { join as join34 } from "path";
 var SETTINGS_REL = ".gemini/settings.json";
 var geminiHooksWriter = {
   tool: "gemini-hooks",
   async detect(repoRoot, home) {
-    return await fileExists12(join33(home, ".gemini")) || await fileExists12(join33(repoRoot, ".gemini"));
+    return await fileExists12(join34(home, ".gemini")) || await fileExists12(join34(repoRoot, ".gemini"));
   },
   async write(ctx) {
-    const repoSignal = await fileExists12(join33(ctx.repoRoot, ".gemini")) || await fileExists12(join33(ctx.repoRoot, "GEMINI.md"));
+    const repoSignal = await fileExists12(join34(ctx.repoRoot, ".gemini")) || await fileExists12(join34(ctx.repoRoot, "GEMINI.md"));
     const selected = ctx.selectedTools?.includes("gemini") ?? false;
     if (!repoSignal && !selected) {
       return { status: "skipped", reason: "no repo-scoped Gemini signal and not selected" };
@@ -8480,7 +8549,7 @@ var geminiHooksWriter = {
         reason: `${SETTINGS_REL} is git-tracked; add the RepoWise BeforeAgent hook manually to opt in`
       };
     }
-    const path = join33(ctx.repoRoot, SETTINGS_REL);
+    const path = join34(ctx.repoRoot, SETTINGS_REL);
     const existing = await readOrNull4(path);
     const merged = mergeGeminiHookSettings(existing, {
       repoName: ctx.repoName,
@@ -8490,13 +8559,13 @@ var geminiHooksWriter = {
     if (merged === existing) {
       return { status: "unchanged", path };
     }
-    await fs16.mkdir(join33(ctx.repoRoot, ".gemini"), { recursive: true });
+    await fs16.mkdir(join34(ctx.repoRoot, ".gemini"), { recursive: true });
     await fs16.writeFile(path, merged, "utf-8");
     await applyGitignoreChanges(ctx.repoRoot, { add: [SETTINGS_REL] });
     return { status: "written", path };
   },
   async remove(ctx) {
-    const path = join33(ctx.repoRoot, SETTINGS_REL);
+    const path = join34(ctx.repoRoot, SETTINGS_REL);
     const existing = await readOrNull4(path);
     if (existing !== null) {
       const next = removeGeminiHookSettings(existing);
@@ -8527,14 +8596,14 @@ async function readOrNull4(path) {
 
 // ../listener/dist/mcp/auto-config/writers/roo.js
 import { promises as fs17 } from "fs";
-import { join as join34 } from "path";
+import { join as join35 } from "path";
 var rooWriter = {
   tool: "roo",
   async detect(repoRoot, home) {
-    return await fileExists13(join34(repoRoot, ".roo")) || await fileExists13(join34(home, ".roo"));
+    return await fileExists13(join35(repoRoot, ".roo")) || await fileExists13(join35(home, ".roo"));
   },
   async write(ctx) {
-    const repoConfig = join34(ctx.repoRoot, ".roo", "mcp.json");
+    const repoConfig = join35(ctx.repoRoot, ".roo", "mcp.json");
     const before = await readOrNull5(repoConfig);
     await this.remove(ctx);
     const after = await readOrNull5(repoConfig);
@@ -8544,9 +8613,9 @@ var rooWriter = {
     };
   },
   async remove(ctx) {
-    const repoConfig = join34(ctx.repoRoot, ".roo", "mcp.json");
-    const homeConfig = join34(ctx.home, ".roo", "mcp.json");
-    const homeSettings = join34(ctx.home, ".roo", "settings.json");
+    const repoConfig = join35(ctx.repoRoot, ".roo", "mcp.json");
+    const homeConfig = join35(ctx.home, ".roo", "mcp.json");
+    const homeSettings = join35(ctx.home, ".roo", "settings.json");
     for (const path of [repoConfig, homeConfig, homeSettings]) {
       await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`).catch(() => {
       });
@@ -8573,14 +8642,14 @@ async function readOrNull5(path) {
 
 // ../listener/dist/mcp/auto-config/writers/windsurf.js
 import { promises as fs18 } from "fs";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 var windsurfWriter = {
   tool: "windsurf",
   async detect(_repoRoot, home) {
-    return fileExists14(join35(home, ".codeium", "windsurf"));
+    return fileExists14(join36(home, ".codeium", "windsurf"));
   },
   async write(ctx) {
-    const path = join35(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+    const path = join36(ctx.home, ".codeium", "windsurf", "mcp_config.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -8590,7 +8659,7 @@ var windsurfWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join35(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+    const path = join36(ctx.home, ".codeium", "windsurf", "mcp_config.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -8623,7 +8692,7 @@ var WRITERS = [
 
 // ../listener/dist/mcp/auto-config/index.js
 async function runAutoConfig(opts) {
-  const home = opts.home ?? homedir5();
+  const home = opts.home ?? homedir6();
   const writers = opts.writers ?? WRITERS;
   const results = [];
   for (const writer of writers) {
@@ -8672,7 +8741,7 @@ init_installer();
 init_registry();
 init_lsp_tools();
 import { promises as fs19 } from "fs";
-import { join as join36 } from "path";
+import { join as join37 } from "path";
 async function collectRepresentativeFiles(repoRoot) {
   const reps = /* @__PURE__ */ new Map();
   let inspected = 0;
@@ -8713,7 +8782,7 @@ async function collectRepresentativeFiles(repoRoot) {
       continue;
     if (name === "node_modules" || name === "dist" || name === "build")
       continue;
-    const sub = join36(repoRoot, name);
+    const sub = join37(repoRoot, name);
     try {
       const stat8 = await fs19.stat(sub);
       if (stat8.isDirectory())
@@ -8761,7 +8830,7 @@ init_config_dir();
 import { promises as fs20 } from "fs";
 import { spawn as spawn9, execFile as execFile5 } from "child_process";
 import { createWriteStream as createWriteStream2 } from "fs";
-import { join as join37 } from "path";
+import { join as join38 } from "path";
 import { promisify as promisify3 } from "util";
 var execFileAsync3 = promisify3(execFile5);
 async function isCommandOnPath2(cmd) {
@@ -8825,7 +8894,7 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
       if (e.isDirectory()) {
         if (skip.has(e.name) || e.name.startsWith("."))
           continue;
-        await rec(join37(dir, e.name));
+        await rec(join38(dir, e.name));
         continue;
       }
       const dot = e.name.lastIndexOf(".");
@@ -8834,7 +8903,7 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
       const ext = e.name.slice(dot);
       if (!C_EXTS.has(ext) && !CPP_EXTS.has(ext))
         continue;
-      sources.push({ path: join37(dir, e.name), ext });
+      sources.push({ path: join38(dir, e.name), ext });
     }
   }
   await rec(repoRoot);
@@ -8850,9 +8919,9 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
       command: `${driver} ${std} -I. -I./include -c "${src}"`
     };
   });
-  const outDir = join37(repoRoot, ".repowise");
+  const outDir = join38(repoRoot, ".repowise");
   await fs20.mkdir(outDir, { recursive: true });
-  const outPath = join37(outDir, "compile_commands.json");
+  const outPath = join38(outDir, "compile_commands.json");
   await fs20.writeFile(outPath, JSON.stringify(entries, null, 2));
   const capHit = sources.length >= MAX_STUB_SOURCES;
   console.log(`[workspace-prep] ${repoId}: wrote ${entries.length.toString()}-entry compile_commands stub to .repowise/${capHit ? " (cap reached \u2014 additional sources truncated)" : ""}`);
@@ -8861,7 +8930,7 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 async function fileExists15(repoRoot, name) {
   try {
-    await fs20.access(join37(repoRoot, name));
+    await fs20.access(join38(repoRoot, name));
     return true;
   } catch {
     return false;
@@ -8872,7 +8941,7 @@ async function detectWorkspaceDeps(repoRoot) {
   if (await fileExists15(repoRoot, "package.json")) {
     let pkgRaw = "";
     try {
-      pkgRaw = await fs20.readFile(join37(repoRoot, "package.json"), "utf8");
+      pkgRaw = await fs20.readFile(join38(repoRoot, "package.json"), "utf8");
     } catch {
     }
     if (pkgRaw) {
@@ -8975,7 +9044,7 @@ async function runWorkspacePreps(opts) {
   if (opts.missing.length === 0)
     return [];
   const safeRepoId = opts.repoId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  const logPath2 = join37(getConfigDir(), `install-log.${safeRepoId}.txt`);
+  const logPath2 = join38(getConfigDir(), `install-log.${safeRepoId}.txt`);
   await fs20.mkdir(getConfigDir(), { recursive: true });
   const stream = opts.logStream ?? createWriteStream2(logPath2, { flags: "a" });
   stream.on("error", () => {
@@ -9126,7 +9195,7 @@ async function prepareWorkspaceDepsForRepos(repos) {
 init_registry();
 import { execFile as execFileCb, spawn as spawn10 } from "child_process";
 import { access as access3, readdir as readdir4 } from "fs/promises";
-import { join as join38 } from "path";
+import { join as join39 } from "path";
 import { promisify as promisify4 } from "util";
 var execFile6 = promisify4(execFileCb);
 var DEFAULT_BUILD_TIMEOUT_MS = 10 * 60 * 1e3;
@@ -9179,7 +9248,7 @@ async function ensureIndexable(indexRoot, language, options = {}) {
     }
   }
   try {
-    await access3(join38(indexRoot, spec.indexStoreProbe));
+    await access3(join39(indexRoot, spec.indexStoreProbe));
     return { ready: true, built: false };
   } catch {
   }
@@ -9219,7 +9288,9 @@ async function ensureIndexable(indexRoot, language, options = {}) {
 init_src();
 init_registry();
 import { execFile as execFileCb2 } from "child_process";
+import { dirname as dirname16 } from "path";
 import { promisify as promisify5 } from "util";
+init_daemon_path();
 
 // ../listener/dist/typed-resolution/lsp-upgrade-strategy.js
 var goStrategy = {
@@ -9701,7 +9772,13 @@ async function isCommandOnPath4(command) {
     return false;
   const probeCmd = process.platform === "win32" ? "where" : "which";
   try {
-    await execFile7(probeCmd, [command], { timeout: 5e3 });
+    await execFile7(probeCmd, [command], {
+      timeout: 5e3,
+      env: {
+        ...process.env,
+        PATH: buildLspSpawnPath(process.env.PATH, dirname16(process.execPath), managedBinDirs())
+      }
+    });
     return true;
   } catch {
     return false;
@@ -9905,13 +9982,13 @@ init_config_dir();
 import { execFile as execFileCb3 } from "child_process";
 import { createHash as createHash5 } from "crypto";
 import { mkdir as mkdir15, readdir as readdir5, rm, stat as stat6 } from "fs/promises";
-import { join as join39 } from "path";
+import { join as join40 } from "path";
 import { promisify as promisify6 } from "util";
 var execFile8 = promisify6(execFileCb3);
 var GIT_OP_TIMEOUT_MS = 6e4;
 var MAX_CONCURRENT_WORKTREES = 3;
 function worktreeBaseDir() {
-  return join39(getConfigDir(), "lsp-worktrees");
+  return join40(getConfigDir(), "lsp-worktrees");
 }
 async function reapOrphanWorktrees(maxAgeMs = 24 * 60 * 60 * 1e3, base = worktreeBaseDir()) {
   let reaped = 0;
@@ -9923,7 +10000,7 @@ async function reapOrphanWorktrees(maxAgeMs = 24 * 60 * 60 * 1e3, base = worktre
   }
   const cutoff = Date.now() - maxAgeMs;
   for (const entry of entries) {
-    const dir = join39(base, entry);
+    const dir = join40(base, entry);
     try {
       const info = await stat6(dir);
       if (!info.isDirectory() || info.mtimeMs > cutoff)
@@ -9956,7 +10033,7 @@ async function prepareCommittedTree(repoRoot, commitSha, options = {}) {
   }
   const base = options.worktreeBase ?? worktreeBaseDir();
   const dirName = createHash5("sha256").update(`${repoRoot}\0${commitSha}`).digest("hex").slice(0, 16) + "-" + commitSha.slice(0, 12);
-  const worktreePath = join39(base, dirName);
+  const worktreePath = join40(base, dirName);
   try {
     await mkdir15(base, { recursive: true });
     await git(["-C", repoRoot, "worktree", "prune"]).catch(() => void 0);
@@ -10292,7 +10369,7 @@ var CRASH_LOOP_WINDOW_MS = 3e4;
 var CRASH_LOOP_THRESHOLD = 3;
 async function readRawToolConfig() {
   try {
-    const configPath = join40(getConfigDir(), "config.json");
+    const configPath = join41(getConfigDir(), "config.json");
     const data = await readFile13(configPath, "utf-8");
     const raw = JSON.parse(data);
     return {
@@ -10367,11 +10444,11 @@ function resolveAuditRoots() {
     return override.split(":").map((s) => s.trim()).filter(Boolean);
   }
   const out = /* @__PURE__ */ new Set();
-  let dir = dirname15(process.execPath);
+  let dir = dirname17(process.execPath);
   for (let i = 0; i < 8; i += 1) {
-    out.add(join40(dir, "node_modules"));
-    out.add(join40(dir, "lib", "node_modules"));
-    const parent = dirname15(dir);
+    out.add(join41(dir, "node_modules"));
+    out.add(join41(dir, "lib", "node_modules"));
+    const parent = dirname17(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -10635,7 +10712,7 @@ async function checkStaleContext(repos, state, groups) {
     if (group?.offline.isOffline)
       continue;
     const { statSync: statSync2, readdirSync: readdirSync2 } = await import("fs");
-    const contextPath = join40(repo.localPath, "repowise-context");
+    const contextPath = join41(repo.localPath, "repowise-context");
     let isMissingOrEmpty = false;
     try {
       const s = statSync2(contextPath);
@@ -10700,7 +10777,7 @@ async function reconcileAgentInstructions(repos) {
   const { graphOnly } = await readRawToolConfig();
   const variant = graphOnly ? "graph" : "full";
   for (const repo of repos) {
-    const path = join40(repo.localPath, "repowise-context", "project-overview.md");
+    const path = join41(repo.localPath, "repowise-context", "project-overview.md");
     let content;
     try {
       content = await readFile13(path, "utf-8");
@@ -10784,7 +10861,7 @@ async function startListener() {
   }
   const configDir = getConfigDir();
   await mkdir16(configDir, { recursive: true });
-  const lockPath = join40(configDir, "listener.lock");
+  const lockPath = join41(configDir, "listener.lock");
   await writeFile15(lockPath, "", { flag: "a" });
   let lockIsHeld = false;
   try {
@@ -10827,7 +10904,7 @@ async function startListener() {
     return;
   }
   if (config2.repos.length === 0 && !config2.autoDiscoverRepos) {
-    console.error(`No repos configured. Add repos to ${join40(configDir, "config.json")}`);
+    console.error(`No repos configured. Add repos to ${join41(configDir, "config.json")}`);
     await releaseLockAndExit();
     process.exitCode = 1;
     return;
@@ -10894,8 +10971,8 @@ async function startListener() {
   const packageName = true ? "repowisestage" : "repowise";
   let currentVersion = "";
   try {
-    const selfDir = dirname15(fileURLToPath3(import.meta.url));
-    const pkgJsonPath = join40(selfDir, "..", "..", "package.json");
+    const selfDir = dirname17(fileURLToPath3(import.meta.url));
+    const pkgJsonPath = join41(selfDir, "..", "..", "package.json");
     const pkgJson = JSON.parse(await readFile13(pkgJsonPath, "utf-8"));
     currentVersion = pkgJson.version;
   } catch (err) {
@@ -11126,6 +11203,9 @@ async function startListener() {
           void warmReposLsp(newRepos, mcpRuntime.lspWorkspaces, config2.lspOverrides).catch(() => {
           });
         }
+        void reconcileMcpConfigs(newRepos, packageName).catch((err) => {
+          console.warn("[mcp-config] front-load for newly-registered repo(s) failed:", err instanceof Error ? err.message : String(err));
+        });
       }
     } catch {
     }
@@ -11398,7 +11478,7 @@ async function startListener() {
         } catch {
         }
       }
-      const credentialsPath = join40(getConfigDir(), "credentials.json");
+      const credentialsPath = join41(getConfigDir(), "credentials.json");
       let credentialsChanged = false;
       let watcher = null;
       try {
@@ -11443,8 +11523,8 @@ if (isDirectRun) {
 }
 
 // src/lib/env.ts
-import { homedir as homedir6 } from "os";
-import { join as join41 } from "path";
+import { homedir as homedir7 } from "os";
+import { join as join42 } from "path";
 var IS_STAGING2 = true ? true : false;
 var PRODUCTION = {
   apiUrl: "https://api.repowise.ai",
@@ -11464,7 +11544,7 @@ function getEnvConfig() {
   return IS_STAGING2 ? STAGING : PRODUCTION;
 }
 function getConfigDir2() {
-  return join41(homedir6(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
+  return join42(homedir7(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
 }
 function getPackageName() {
   return true ? "repowisestage" : "repowise";
@@ -11475,11 +11555,11 @@ import chalk from "chalk";
 
 // src/lib/config.ts
 import { readFile as readFile14, writeFile as writeFile16, mkdir as mkdir17, rename as rename4, unlink as unlink10 } from "fs/promises";
-import { join as join42 } from "path";
+import { join as join43 } from "path";
 import lockfile5 from "proper-lockfile";
 async function getConfig() {
   try {
-    const data = await readFile14(join42(getConfigDir2(), "config.json"), "utf-8");
+    const data = await readFile14(join43(getConfigDir2(), "config.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return {};
@@ -11487,7 +11567,7 @@ async function getConfig() {
 }
 async function saveConfig(config2) {
   const dir = getConfigDir2();
-  const path = join42(dir, "config.json");
+  const path = join43(dir, "config.json");
   await mkdir17(dir, { recursive: true });
   const tmpPath = path + ".tmp";
   try {
@@ -11503,7 +11583,7 @@ async function saveConfig(config2) {
 }
 async function mergeAndSaveConfig(updates) {
   const dir = getConfigDir2();
-  const path = join42(dir, "config.json");
+  const path = join43(dir, "config.json");
   await mkdir17(dir, { recursive: true });
   try {
     await writeFile16(path, "", { flag: "a" });
@@ -11574,7 +11654,7 @@ async function showWelcome(currentVersion) {
 
 // src/commands/create.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname17, join as join48 } from "path";
+import { dirname as dirname19, join as join49 } from "path";
 init_src();
 import chalk8 from "chalk";
 import ora from "ora";
@@ -11583,7 +11663,7 @@ import ora from "ora";
 import { createHash as createHash6, randomBytes as randomBytes3 } from "crypto";
 import { readFile as readFile15, writeFile as writeFile17, mkdir as mkdir18, chmod as chmod4, unlink as unlink11 } from "fs/promises";
 import http from "http";
-import { join as join43 } from "path";
+import { join as join44 } from "path";
 var CLI_CALLBACK_PORT = 19876;
 var CALLBACK_TIMEOUT_MS = 12e4;
 function getCognitoConfigForStorage() {
@@ -11749,7 +11829,7 @@ async function refreshTokens2(refreshToken) {
 }
 async function getStoredCredentials2() {
   try {
-    const credPath = join43(getConfigDir2(), "credentials.json");
+    const credPath = join44(getConfigDir2(), "credentials.json");
     const data = await readFile15(credPath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
@@ -11761,14 +11841,14 @@ async function getStoredCredentials2() {
 }
 async function storeCredentials2(credentials) {
   const dir = getConfigDir2();
-  const credPath = join43(dir, "credentials.json");
+  const credPath = join44(dir, "credentials.json");
   await mkdir18(dir, { recursive: true, mode: 448 });
   await writeFile17(credPath, JSON.stringify(credentials, null, 2));
   await chmod4(credPath, 384);
 }
 async function clearCredentials() {
   try {
-    await unlink11(join43(getConfigDir2(), "credentials.json"));
+    await unlink11(join44(getConfigDir2(), "credentials.json"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -11976,9 +12056,9 @@ async function selectAiTools() {
 
 // src/lib/gitignore.ts
 import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
-import { join as join44 } from "path";
+import { join as join45 } from "path";
 function ensureGitignore(repoRoot, entry) {
-  const gitignorePath = join44(repoRoot, ".gitignore");
+  const gitignorePath = join45(repoRoot, ".gitignore");
   if (existsSync2(gitignorePath)) {
     const content = readFileSync2(gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
@@ -11995,7 +12075,7 @@ function ensureGitignore(repoRoot, entry) {
 // src/lib/graph-cache.ts
 init_config_dir();
 import { mkdirSync, writeFileSync as writeFileSync2, renameSync, unlinkSync } from "fs";
-import { dirname as dirname16, join as join45 } from "path";
+import { dirname as dirname18, join as join46 } from "path";
 var SAFE_REPO_ID = /^[A-Za-z0-9_.-]{1,128}$/;
 function assertSafeRepoId2(repoId) {
   if (!repoId || typeof repoId !== "string" || !SAFE_REPO_ID.test(repoId) || repoId === "." || repoId === ".." || repoId.startsWith(".")) {
@@ -12004,7 +12084,7 @@ function assertSafeRepoId2(repoId) {
 }
 function graphCachePath(repoId) {
   assertSafeRepoId2(repoId);
-  return join45(getConfigDir(), "graphs", `${repoId}.json`);
+  return join46(getConfigDir(), "graphs", `${repoId}.json`);
 }
 function isUsableGraph(parsed) {
   if (typeof parsed !== "object" || parsed === null) return false;
@@ -12022,9 +12102,27 @@ function readErrorCode(body) {
     return void 0;
   }
 }
+async function readBodyBounded(res, ctrl, bodyTimeoutMs) {
+  const bodyPromise = res.text();
+  void bodyPromise.catch(() => {
+  });
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      ctrl.abort();
+      reject(new Error("GRAPH_BODY_TIMEOUT"));
+    }, bodyTimeoutMs);
+  });
+  try {
+    return await Promise.race([bodyPromise, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
 async function ensureGraphDownloaded(opts) {
   const fetchFn = opts.fetchFn ?? fetch;
   const timeoutMs = opts.timeoutMs ?? 1e4;
+  const bodyTimeoutMs = opts.bodyTimeoutMs ?? 12e4;
   const maxRetries = opts.maxRetries ?? 3;
   const sleep2 = opts.sleepFn ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
   let targetPath;
@@ -12081,7 +12179,16 @@ async function ensureGraphDownloaded(opts) {
     if (!res.ok) {
       return { status: "error", message: `HTTP ${String(res.status)}` };
     }
-    const body = await res.text();
+    let body;
+    try {
+      body = await readBodyBounded(res, ctrl, bodyTimeoutMs);
+    } catch (err) {
+      if (attempt < maxRetries) {
+        await sleep2(2e3 * attempt);
+        continue;
+      }
+      return { status: "error", message: err instanceof Error ? err.message : String(err) };
+    }
     let parsed;
     try {
       parsed = JSON.parse(body);
@@ -12096,7 +12203,7 @@ async function ensureGraphDownloaded(opts) {
       return { status: "not_found", message: "EMPTY_GRAPH" };
     }
     try {
-      mkdirSync(dirname16(targetPath), { recursive: true });
+      mkdirSync(dirname18(targetPath), { recursive: true });
       const tmp = `${targetPath}.${String(process.pid)}.${Math.random().toString(36).slice(2)}.tmp`;
       try {
         writeFileSync2(tmp, body, { encoding: "utf-8", mode: 384 });
@@ -12247,7 +12354,7 @@ async function handleInterview(syncId, questionId, questionText, questionContext
     const message = err instanceof Error ? err.message : String(err);
     if (message.includes("not awaiting input") || message.includes("expired")) {
       console.log(chalk3.dim("  Pipeline has already moved on \u2014 continuing."));
-      return;
+      return { finished: true };
     }
     try {
       await new Promise((r) => setTimeout(r, 1e3));
@@ -12257,7 +12364,7 @@ async function handleInterview(syncId, questionId, questionText, questionContext
       });
     } catch {
       console.log(chalk3.yellow("  Could not submit answer \u2014 pipeline will continue."));
-      return;
+      return { finished: false };
     }
   }
   if (action === "done") {
@@ -12268,6 +12375,7 @@ async function handleInterview(syncId, questionId, questionText, questionContext
     console.log(chalk3.dim("  Answer recorded."));
   }
   console.log("");
+  return { finished: action === "done" || questionCounter >= MAX_QUESTIONS };
 }
 
 // src/lib/progress-renderer.ts
@@ -12300,6 +12408,12 @@ var ProgressRenderer = class {
   privacyShieldShown = false;
   discoveryShown = false;
   interviewCompleteShown = false;
+  // FIX-10: the scan runs in PARALLEL with the interview, so scanProgress
+  // arrives mid-interview. Hold scan rendering until the interview is
+  // definitively over (setInterviewComplete) so the coffee/Code-Analysis/graph
+  // block never interrupts the Q&A. Buffer the latest progress meanwhile.
+  interviewComplete = false;
+  pendingScanProgress = null;
   scanHeaderShown = false;
   scanSummaryShown = false;
   graphSubtitleShown = false;
@@ -12601,6 +12715,21 @@ var ProgressRenderer = class {
     }
     return `${stepLabel}... ${chalk4.dim(`(${overallPct}%)`)}`;
   }
+  /**
+   * FIX-10 — mark the interview definitively over. Unlocks scan-progress
+   * rendering and flushes any progress buffered during the interview, so the
+   * coffee → Code-Analysis → graph-ready block appears in order AFTER the last
+   * question (renderScanProgress is idempotent via its *Shown latches).
+   * Idempotent; safe to call from multiple completion paths.
+   */
+  setInterviewComplete(spinner) {
+    if (this.interviewComplete) return;
+    this.interviewComplete = true;
+    if (this.pendingScanProgress) {
+      this.renderScanProgress(this.pendingScanProgress, spinner);
+      this.pendingScanProgress = null;
+    }
+  }
   update(syncResult, spinner) {
     if (syncResult.privacyShieldEnabled !== void 0) {
       this.renderPrivacyShield(syncResult.privacyShieldEnabled, spinner);
@@ -12609,7 +12738,11 @@ var ProgressRenderer = class {
       this.renderDiscovery(syncResult.discoveryResult, spinner);
     }
     if (syncResult.scanProgress) {
-      this.renderScanProgress(syncResult.scanProgress, spinner);
+      if (this.interviewComplete) {
+        this.renderScanProgress(syncResult.scanProgress, spinner);
+      } else {
+        this.pendingScanProgress = syncResult.scanProgress;
+      }
     }
     if (syncResult.generationProgress?.fileStatuses && syncResult.generationProgress.fileStatuses.length > 0) {
       this.renderFileStatuses(syncResult.generationProgress.fileStatuses, spinner);
@@ -12669,7 +12802,7 @@ import chalk6 from "chalk";
 
 // src/lib/dep-installer.ts
 import { promises as fs21 } from "fs";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 var SUPPORTED_DEP_LANGUAGES = /* @__PURE__ */ new Set([
   "typescript",
   "javascript",
@@ -12686,7 +12819,7 @@ var exists = async (p) => {
   }
 };
 async function fileExists16(repoRoot, name) {
-  return exists(join46(repoRoot, name));
+  return exists(join47(repoRoot, name));
 }
 async function detectNodePackageManager(repoRoot) {
   if (await fileExists16(repoRoot, "pnpm-lock.yaml")) {
@@ -12764,11 +12897,11 @@ async function detectMissingDeps(repoRoot, scopedLanguages) {
 import { spawn as spawn11 } from "child_process";
 import { createWriteStream as createWriteStream3 } from "fs";
 import { promises as fs22 } from "fs";
-import { join as join47 } from "path";
+import { join as join48 } from "path";
 var DEFAULT_INSTALL_TIMEOUT_MS = 10 * 60 * 1e3;
 async function runMissingDepInstalls(opts) {
   const safeRepoId = opts.repoId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  const logPath2 = join47(getConfigDir2(), `install-log.${safeRepoId}.txt`);
+  const logPath2 = join48(getConfigDir2(), `install-log.${safeRepoId}.txt`);
   await fs22.mkdir(getConfigDir2(), { recursive: true });
   const stream = opts.logStream ?? createWriteStream3(logPath2, { flags: "a" });
   stream.on("error", () => {
@@ -12815,7 +12948,7 @@ async function runOne2(dep, repoRoot, stream, timeoutMs) {
 }
 async function runPipFlow(repoRoot, stream, timeoutMs) {
   await runSimple(["python3", "-m", "venv", ".venv"], repoRoot, stream, timeoutMs);
-  const venvPip = process.platform === "win32" ? join47(".venv", "Scripts", "pip.exe") : join47(".venv", "bin", "pip");
+  const venvPip = process.platform === "win32" ? join48(".venv", "Scripts", "pip.exe") : join48(".venv", "bin", "pip");
   await runSimple([venvPip, "install", "-r", "requirements.txt"], repoRoot, stream, timeoutMs);
 }
 function runSimple(cmd, repoRoot, stream, timeoutMs) {
@@ -13229,6 +13362,8 @@ async function create() {
     const progressRenderer = new ProgressRenderer();
     let depInstallShown = false;
     let seenAwaitingInput = false;
+    let interviewComplete = false;
+    let interviewQuestionsAnswered = 0;
     let lspWaitStartedAt = null;
     let lspFellBackNoticeShown = false;
     let depInstallPromise = null;
@@ -13269,6 +13404,8 @@ async function create() {
     try {
       while (true) {
         if (++pollAttempts > MAX_POLL_ATTEMPTS) {
+          progressRenderer.setInterviewComplete(spinner);
+          progressRenderer.finalize();
           spinner.fail(chalk8.red("Pipeline timed out. Check dashboard for status."));
           process.exitCode = 1;
           return;
@@ -13288,6 +13425,10 @@ async function create() {
         if (sigintBusy) {
           continue;
         }
+        if (!interviewComplete && graphOnly) {
+          interviewComplete = true;
+          progressRenderer.setInterviewComplete(spinner);
+        }
         progressRenderer.update(syncResult, spinner);
         if (!graphOnly && syncResult.status === "in_progress") {
           if (syncResult.lspWaitState === "awaiting" || syncResult.lspWaitState === "analyzing") {
@@ -13307,13 +13448,19 @@ async function create() {
         }
         if (syncResult.status === "awaiting_input" && syncResult.questionId && syncResult.questionText) {
           spinner.stop();
-          await handleInterview(
+          const estimatedQ = syncResult.discoveryResult?.estimatedInterviewQuestions;
+          const { finished } = await handleInterview(
             syncId,
             syncResult.questionId,
             syncResult.questionText,
             syncResult.questionContext ?? void 0,
-            syncResult.discoveryResult?.estimatedInterviewQuestions
+            estimatedQ
           );
+          interviewQuestionsAnswered++;
+          if (!interviewComplete && (finished || estimatedQ !== void 0 && estimatedQ > 0 && interviewQuestionsAnswered >= estimatedQ)) {
+            interviewComplete = true;
+            progressRenderer.setInterviewComplete(spinner);
+          }
           spinner.start("Resuming pipeline...");
           continue;
         }
@@ -13333,6 +13480,7 @@ async function create() {
           depInstallPromise = result.installPromise;
         }
         if (syncResult.status === "completed") {
+          progressRenderer.setInterviewComplete(spinner);
           progressRenderer.finalize();
           const generatedFiles = syncResult.filesGenerated ?? [];
           const fileCount = generatedFiles.length;
@@ -13357,6 +13505,7 @@ async function create() {
           break;
         }
         if (syncResult.status === "failed") {
+          progressRenderer.setInterviewComplete(spinner);
           progressRenderer.finalize();
           spinner.fail(chalk8.red(`Pipeline failed: ${syncResult.error ?? "Unknown error"}`));
           process.exitCode = 1;
@@ -13372,7 +13521,7 @@ async function create() {
         const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
         const files = listResult.data?.files ?? listResult.files ?? [];
         if (files.length > 0) {
-          const contextDir = join48(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          const contextDir = join49(repoRoot, DEFAULT_CONTEXT_FOLDER);
           mkdirSync2(contextDir, { recursive: true });
           let downloadedCount = 0;
           let failedCount = 0;
@@ -13386,8 +13535,8 @@ async function create() {
             const response = await fetch(presignedUrl);
             if (response.ok) {
               const content = await response.text();
-              const filePath = join48(contextDir, file.fileName);
-              mkdirSync2(dirname17(filePath), { recursive: true });
+              const filePath = join49(contextDir, file.fileName);
+              mkdirSync2(dirname19(filePath), { recursive: true });
               writeFileSync3(filePath, content, "utf-8");
               downloadedCount++;
             } else {
@@ -13637,7 +13786,7 @@ Files are stored on our servers (not in git). Retry when online.`
 
 // src/commands/member.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname18, join as join49, resolve, sep } from "path";
+import { dirname as dirname20, join as join50, resolve, sep } from "path";
 import chalk9 from "chalk";
 import ora2 from "ora";
 var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
@@ -13791,7 +13940,7 @@ async function member() {
     spinner.succeed(`Found ${chalk9.bold(files.length)} context files on server`);
     const { tools } = await selectAiTools();
     spinner.start("Downloading context files...");
-    const contextDir = join49(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    const contextDir = join50(repoRoot, DEFAULT_CONTEXT_FOLDER2);
     mkdirSync3(contextDir, { recursive: true });
     let downloadedCount = 0;
     let failedCount = 0;
@@ -13812,7 +13961,7 @@ async function member() {
         const response = await fetch(presignedUrl);
         if (response.ok) {
           const content = await response.text();
-          mkdirSync3(dirname18(safePath), { recursive: true });
+          mkdirSync3(dirname20(safePath), { recursive: true });
           writeFileSync4(safePath, content, "utf-8");
           downloadedCount++;
         } else {
@@ -13990,10 +14139,10 @@ import ora3 from "ora";
 
 // src/lib/tenant-graph-purge.ts
 import { promises as fs23 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join50 } from "path";
-async function purgeForeignGraphs(validRepoIds, home = homedir7()) {
-  const graphsDir = join50(home, ".repowise", "graphs");
+import { homedir as homedir8 } from "os";
+import { join as join51 } from "path";
+async function purgeForeignGraphs(validRepoIds, home = homedir8()) {
+  const graphsDir = join51(home, ".repowise", "graphs");
   const result = { kept: [], removed: [] };
   let entries;
   try {
@@ -14011,7 +14160,7 @@ async function purgeForeignGraphs(validRepoIds, home = homedir7()) {
       result.kept.push(entry);
       continue;
     }
-    const path = join50(graphsDir, entry);
+    const path = join51(graphsDir, entry);
     try {
       const stat8 = await fs23.lstat(path);
       if (stat8.isSymbolicLink()) {
@@ -14104,11 +14253,11 @@ async function logout() {
 
 // src/commands/status.ts
 import { readFile as readFile16 } from "fs/promises";
-import { basename as basename4, join as join51 } from "path";
+import { basename as basename4, join as join52 } from "path";
 async function status() {
   const configDir = getConfigDir2();
-  const STATE_PATH = join51(configDir, "listener-state.json");
-  const CONFIG_PATH = join51(configDir, "config.json");
+  const STATE_PATH = join52(configDir, "listener-state.json");
+  const CONFIG_PATH = join52(configDir, "config.json");
   let state = null;
   try {
     const data = await readFile16(STATE_PATH, "utf-8");
@@ -14156,7 +14305,7 @@ async function status() {
 
 // src/commands/sync.ts
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname19, join as join52 } from "path";
+import { dirname as dirname21, join as join53 } from "path";
 import chalk12 from "chalk";
 import ora4 from "ora";
 var POLL_INTERVAL_MS2 = 3e3;
@@ -14305,7 +14454,7 @@ async function sync() {
       const listResult = await apiRequest(`/v1/repos/${repoId}/context`);
       const files = listResult.data?.files ?? listResult.files ?? [];
       if (files.length > 0) {
-        const contextDir = join52(repoRoot, DEFAULT_CONTEXT_FOLDER3);
+        const contextDir = join53(repoRoot, DEFAULT_CONTEXT_FOLDER3);
         mkdirSync4(contextDir, { recursive: true });
         let downloadedCount = 0;
         let failedCount = 0;
@@ -14319,8 +14468,8 @@ async function sync() {
           const response = await fetch(presignedUrl);
           if (response.ok) {
             const content = await response.text();
-            const filePath = join52(contextDir, file.fileName);
-            mkdirSync4(dirname19(filePath), { recursive: true });
+            const filePath = join53(contextDir, file.fileName);
+            mkdirSync4(dirname21(filePath), { recursive: true });
             writeFileSync5(filePath, content, "utf-8");
             downloadedCount++;
           } else {
@@ -14575,7 +14724,7 @@ async function config() {
 // src/commands/mcp-log.ts
 import { createDecipheriv as createDecipheriv2 } from "crypto";
 import { mkdir as mkdir19, readFile as readFile17, stat as stat7, writeFile as writeFile18 } from "fs/promises";
-import { dirname as dirname20, join as join53 } from "path";
+import { dirname as dirname22, join as join54 } from "path";
 var FLAG_FILE = "mcp-log.flag";
 var LOG_FILE = "mcp-log.jsonl.enc";
 var KEY_FILE = "mcp-log.key";
@@ -14583,14 +14732,14 @@ var ENDPOINT_FILE = "listener.endpoint";
 var IV_BYTES2 = 12;
 var TAG_BYTES2 = 16;
 function flagPath() {
-  return join53(getConfigDir2(), FLAG_FILE);
+  return join54(getConfigDir2(), FLAG_FILE);
 }
 function logPath() {
-  return join53(getConfigDir2(), LOG_FILE);
+  return join54(getConfigDir2(), LOG_FILE);
 }
 async function writeFlag(flag) {
   const path = flagPath();
-  await mkdir19(dirname20(path), { recursive: true });
+  await mkdir19(dirname22(path), { recursive: true });
   await writeFile18(path, JSON.stringify(flag, null, 2), { encoding: "utf-8", mode: 384 });
 }
 async function mcpLogOn() {
@@ -14627,14 +14776,14 @@ async function trySendConsentToServer() {
   let apiUrl = null;
   let token = null;
   try {
-    const body = await readFile17(join53(getConfigDir2(), "config.json"), "utf-8");
+    const body = await readFile17(join54(getConfigDir2(), "config.json"), "utf-8");
     const parsed = JSON.parse(body);
     apiUrl = parsed.repos?.find((r) => Boolean(r.apiUrl))?.apiUrl ?? parsed.defaultApiUrl ?? null;
   } catch {
     return false;
   }
   try {
-    const body = await readFile17(join53(getConfigDir2(), "credentials.json"), "utf-8");
+    const body = await readFile17(join54(getConfigDir2(), "credentials.json"), "utf-8");
     const parsed = JSON.parse(body);
     token = parsed.idToken ?? null;
   } catch {
@@ -14704,7 +14853,7 @@ async function mcpLogStatus() {
     process.stderr.write("Log size:        no file yet\n");
   }
   try {
-    const endpointBody = await readFile17(join53(getConfigDir2(), ENDPOINT_FILE), "utf-8");
+    const endpointBody = await readFile17(join54(getConfigDir2(), ENDPOINT_FILE), "utf-8");
     const match = /endpoint=([^\n]+)/.exec(endpointBody);
     process.stderr.write(`MCP endpoint:    ${match?.[1] ?? "(malformed endpoint file)"}
 `);
@@ -14735,7 +14884,7 @@ async function mcpLogViewingFlags(flags = {}) {
   const key = await readKey();
   if (!key) {
     process.stderr.write(
-      `No encryption key at ${join53(getConfigDir2(), KEY_FILE)} \u2014 listener may not have started yet.
+      `No encryption key at ${join54(getConfigDir2(), KEY_FILE)} \u2014 listener may not have started yet.
 `
     );
     return;
@@ -14811,7 +14960,7 @@ async function mcpLogViewingFlags(flags = {}) {
 }
 async function readKey() {
   try {
-    const body = await readFile17(join53(getConfigDir2(), KEY_FILE), "utf-8");
+    const body = await readFile17(join54(getConfigDir2(), KEY_FILE), "utf-8");
     const parsed = Buffer.from(body.trim(), "base64");
     if (parsed.length !== 32) return null;
     return parsed;
@@ -14855,7 +15004,7 @@ import chalk14 from "chalk";
 
 // src/lib/graph-loader.ts
 import { promises as fs24 } from "fs";
-import { join as join54, resolve as resolve2 } from "path";
+import { join as join55, resolve as resolve2 } from "path";
 import { gunzipSync } from "zlib";
 var RELATIVE_GRAPH_PATH = "repowise-context/.meta/dependency-graph.json";
 var GZIPPED_GRAPH_PATH = "repowise-context/.meta/dependency-graph.json.gz";
@@ -14872,8 +15021,8 @@ var GraphNotFoundError = class extends Error {
 var cache = /* @__PURE__ */ new Map();
 async function loadGraph(repoRoot = process.cwd()) {
   const root = resolve2(repoRoot);
-  const gzPath = join54(root, GZIPPED_GRAPH_PATH);
-  const plainPath = join54(root, RELATIVE_GRAPH_PATH);
+  const gzPath = join55(root, GZIPPED_GRAPH_PATH);
+  const plainPath = join55(root, RELATIVE_GRAPH_PATH);
   const cached = cache.get(root);
   if (cached) {
     return { graph: cached, path: plainPath, bytes: 0, parseMs: 0, fromCache: true };
@@ -15288,13 +15437,13 @@ function registerQueryCommand(program2) {
 
 // src/commands/uninstall.ts
 import { promises as fs28 } from "fs";
-import { homedir as homedir9 } from "os";
-import { join as join58 } from "path";
+import { homedir as homedir10 } from "os";
+import { join as join59 } from "path";
 import chalk15 from "chalk";
 
 // src/lib/cleanup/marker-blocks.ts
 import { promises as fs25 } from "fs";
-import { join as join55 } from "path";
+import { join as join56 } from "path";
 var MARKER_START = "<!-- repowise-start -->";
 var MARKER_END = "<!-- repowise-end -->";
 var CONTEXT_FILES = [
@@ -15334,7 +15483,7 @@ async function stripMarkerBlock(filePath) {
 async function stripAllMarkerBlocks(repoRoot) {
   const out = [];
   for (const relative of CONTEXT_FILES) {
-    const full = join55(repoRoot, relative);
+    const full = join56(repoRoot, relative);
     const result = await stripMarkerBlock(full).catch((err) => ({
       path: full,
       status: "untouched",
@@ -15347,18 +15496,18 @@ async function stripAllMarkerBlocks(repoRoot) {
 
 // src/lib/cleanup/mcp-configs.ts
 import { promises as fs26 } from "fs";
-import { join as join56 } from "path";
+import { join as join57 } from "path";
 function mcpConfigPaths(repoRoot, home) {
   return [
-    join56(repoRoot, ".mcp.json"),
-    join56(repoRoot, ".cursor", "mcp.json"),
-    join56(repoRoot, ".vscode", "mcp.json"),
-    join56(repoRoot, ".roo", "mcp.json"),
-    join56(home, ".cline", "mcp.json"),
-    join56(home, ".codeium", "windsurf", "mcp_config.json"),
-    join56(home, ".gemini", "settings.json"),
-    join56(home, ".codex", "mcp.json"),
-    join56(home, ".roo", "mcp.json")
+    join57(repoRoot, ".mcp.json"),
+    join57(repoRoot, ".cursor", "mcp.json"),
+    join57(repoRoot, ".vscode", "mcp.json"),
+    join57(repoRoot, ".roo", "mcp.json"),
+    join57(home, ".cline", "mcp.json"),
+    join57(home, ".codeium", "windsurf", "mcp_config.json"),
+    join57(home, ".gemini", "settings.json"),
+    join57(home, ".codex", "mcp.json"),
+    join57(home, ".roo", "mcp.json")
   ];
 }
 async function removeRepowiseFromConfig(path, serverName) {
@@ -15398,11 +15547,11 @@ async function removeAllMcpEntries(repoRoot, home, repoId) {
 
 // src/lib/cleanup/local-state.ts
 import { promises as fs27 } from "fs";
-import { homedir as homedir8 } from "os";
-import { join as join57, resolve as resolve3 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join58, resolve as resolve3 } from "path";
 async function clearLocalState(homeOverride) {
-  const home = homeOverride ?? homedir8();
-  const target = resolve3(join57(home, ".repowise"));
+  const home = homeOverride ?? homedir9();
+  const target = resolve3(join58(home, ".repowise"));
   if (target === resolve3(home) || !target.startsWith(resolve3(home))) {
     return { path: target, status: "error", error: "refused: not under home" };
   }
@@ -15437,7 +15586,7 @@ async function stopAndUninstallService(uninstaller) {
 // src/commands/uninstall.ts
 async function uninstall2(opts = {}) {
   const tier = opts.tier ?? "uninstall";
-  const home = opts.home ?? homedir9();
+  const home = opts.home ?? homedir10();
   const repoRoot = opts.repoRoot ?? process.cwd();
   const loadRepoIds = opts.loadRepoIds ?? defaultLoadRepoIds;
   const report = { tier, removed: [], preserved: [], skipped: [] };
@@ -15446,7 +15595,7 @@ async function uninstall2(opts = {}) {
   else if (svc.error) report.skipped.push({ path: "listener service", reason: svc.error });
   if (tier === "stop") return report;
   try {
-    await fs28.unlink(join58(home, ".repowise", "credentials.json"));
+    await fs28.unlink(join59(home, ".repowise", "credentials.json"));
     report.removed.push("credentials");
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -15485,7 +15634,7 @@ async function uninstall2(opts = {}) {
 }
 async function defaultLoadRepoIds(home) {
   try {
-    const raw = await fs28.readFile(join58(home, ".repowise", "config.json"), "utf-8");
+    const raw = await fs28.readFile(join59(home, ".repowise", "config.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return (parsed.repos ?? []).map((r) => r.repoId);
   } catch {
@@ -15534,10 +15683,10 @@ Done \u2014 ${report.removed.length} removed, ${report.skipped.length} skipped.
 init_config_dir();
 import { promises as fs29 } from "fs";
 import { createInterface as createInterface2 } from "readline";
-import { join as join59 } from "path";
+import { join as join60 } from "path";
 var DEFAULT_MAX = 200 * 1024;
 async function mcpShim(opts) {
-  const endpointPath = opts.endpointFile ?? join59(getConfigDir(), "listener.endpoint");
+  const endpointPath = opts.endpointFile ?? join60(getConfigDir(), "listener.endpoint");
   const stdin = opts.stdin ?? process.stdin;
   const stdout = opts.stdout ?? process.stdout;
   const stderr = opts.stderr ?? process.stderr;
@@ -16285,8 +16434,8 @@ async function lspOn() {
 
 // bin/repowise.ts
 var __filename = fileURLToPath4(import.meta.url);
-var __dirname = dirname21(__filename);
-var pkg = JSON.parse(readFileSync3(join60(__dirname, "..", "..", "package.json"), "utf-8"));
+var __dirname = dirname23(__filename);
+var pkg = JSON.parse(readFileSync3(join61(__dirname, "..", "..", "package.json"), "utf-8"));
 var program = new Command();
 program.name(getPackageName()).description("AI-optimized codebase context generator").version(pkg.version).hook("preAction", async () => {
   await showWelcome(pkg.version);