repowisestage 0.0.58 → 0.0.59

package/dist/bin/repowise.js

@@ -25,19 +25,19 @@ var init_config_dir = __esm({
 // ../listener/dist/process-manager.js
 import { spawn } from "child_process";
 import { openSync, closeSync } from "fs";
-import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir6, unlink as unlink4 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile7, mkdir as mkdir7, unlink as unlink5 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
 function repowiseDir() {
   return getConfigDir();
 }
 function pidPath() {
-  return join9(repowiseDir(), "listener.pid");
+  return join10(repowiseDir(), "listener.pid");
 }
 function logDirPath() {
-  return join9(repowiseDir(), "logs");
+  return join10(repowiseDir(), "logs");
 }
 function resolveListenerCommand() {
   try {
@@ -51,7 +51,7 @@ function resolveListenerCommand() {
 }
 async function readPid() {
   try {
-    const content = await readFile5(pidPath(), "utf-8");
+    const content = await readFile6(pidPath(), "utf-8");
     const pid = parseInt(content.trim(), 10);
     return Number.isNaN(pid) ? null : pid;
   } catch (err) {
@@ -75,10 +75,10 @@ async function startBackground() {
       return pid2;
   }
   const logDir2 = logDirPath();
-  await mkdir6(logDir2, { recursive: true });
+  await mkdir7(logDir2, { recursive: true });
   const cmd = resolveListenerCommand();
-  const stdoutFd = openSync(join9(logDir2, "listener-stdout.log"), "a");
-  const stderrFd = openSync(join9(logDir2, "listener-stderr.log"), "a");
+  const stdoutFd = openSync(join10(logDir2, "listener-stdout.log"), "a");
+  const stderrFd = openSync(join10(logDir2, "listener-stderr.log"), "a");
   const child = spawn(process.execPath, [cmd.script, ...cmd.args], {
     detached: true,
     stdio: ["ignore", stdoutFd, stderrFd],
@@ -91,7 +91,7 @@ async function startBackground() {
   const pid = child.pid;
   if (!pid)
     throw new Error("Failed to spawn listener process");
-  await writeFile6(pidPath(), String(pid));
+  await writeFile7(pidPath(), String(pid));
   return pid;
 }
 async function stopProcess() {
@@ -126,7 +126,7 @@ async function isRunning() {
 }
 async function removePidFile() {
   try {
-    await unlink4(pidPath());
+    await unlink5(pidPath());
   } catch {
   }
 }
@@ -146,13 +146,13 @@ __export(service_installer_exports, {
   stopService: () => stopService,
   uninstall: () => uninstall
 });
-import { execFile as execFile3 } from "child_process";
-import { writeFile as writeFile7, mkdir as mkdir7, unlink as unlink5 } from "fs/promises";
+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 join12 } from "path";
+import { join as join13 } from "path";
 function exec(cmd, args) {
   return new Promise((resolve5, reject) => {
-    execFile3(cmd, args, (err, stdout) => {
+    execFile4(cmd, args, (err, stdout) => {
       if (err) {
         reject(err);
         return;
@@ -162,10 +162,10 @@ function exec(cmd, args) {
   });
 }
 function plistPath() {
-  return join12(homedir3(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
+  return join13(homedir3(), "Library", "LaunchAgents", `${PLIST_LABEL}.plist`);
 }
 function logDir() {
-  return join12(getConfigDir(), "logs");
+  return join13(getConfigDir(), "logs");
 }
 function buildPlist() {
   const cmd = resolveListenerCommand();
@@ -187,9 +187,9 @@ ${programArgs}
     <key>KeepAlive</key>
     <true/>
     <key>StandardOutPath</key>
-    <string>${join12(logs, "listener-stdout.log")}</string>
+    <string>${join13(logs, "listener-stdout.log")}</string>
     <key>StandardErrorPath</key>
-    <string>${join12(logs, "listener-stderr.log")}</string>
+    <string>${join13(logs, "listener-stderr.log")}</string>
     <key>ProcessType</key>
     <string>Background</string>
     <!--
@@ -217,13 +217,13 @@ ${programArgs}
 </plist>`;
 }
 async function darwinInstall() {
-  await mkdir7(logDir(), { recursive: true });
-  await mkdir7(join12(homedir3(), "Library", "LaunchAgents"), { recursive: true });
+  await mkdir8(logDir(), { recursive: true });
+  await mkdir8(join13(homedir3(), "Library", "LaunchAgents"), { recursive: true });
   try {
     await exec("launchctl", ["unload", plistPath()]);
   } catch {
   }
-  await writeFile7(plistPath(), buildPlist());
+  await writeFile8(plistPath(), buildPlist());
   await exec("launchctl", ["load", plistPath()]);
 }
 async function darwinUninstall() {
@@ -232,7 +232,7 @@ async function darwinUninstall() {
   } catch {
   }
   try {
-    await unlink5(plistPath());
+    await unlink6(plistPath());
   } catch {
   }
 }
@@ -245,7 +245,7 @@ async function darwinIsInstalled() {
   }
 }
 function unitPath() {
-  return join12(homedir3(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
+  return join13(homedir3(), ".config", "systemd", "user", `${SYSTEMD_SERVICE}.service`);
 }
 function buildUnit() {
   const cmd = resolveListenerCommand();
@@ -261,16 +261,16 @@ Type=simple
 ExecStart=${execStart}
 Restart=always
 RestartSec=10
-StandardOutput=append:${join12(logs, "listener-stdout.log")}
-StandardError=append:${join12(logs, "listener-stderr.log")}
+StandardOutput=append:${join13(logs, "listener-stdout.log")}
+StandardError=append:${join13(logs, "listener-stderr.log")}
 
 [Install]
 WantedBy=default.target`;
 }
 async function linuxInstall() {
-  await mkdir7(logDir(), { recursive: true });
-  await mkdir7(join12(homedir3(), ".config", "systemd", "user"), { recursive: true });
-  await writeFile7(unitPath(), buildUnit());
+  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]);
@@ -285,7 +285,7 @@ async function linuxUninstall() {
   } catch {
   }
   try {
-    await unlink5(unitPath());
+    await unlink6(unitPath());
   } catch {
   }
   try {
@@ -302,7 +302,7 @@ async function linuxIsInstalled() {
   }
 }
 async function win32Install() {
-  await mkdir7(logDir(), { recursive: true });
+  await mkdir8(logDir(), { recursive: true });
   const cmd = resolveListenerCommand();
   const taskCmd = [process.execPath, cmd.script, ...cmd.args].map((a) => `"${a}"`).join(" ");
   await exec("schtasks", [
@@ -517,7 +517,10 @@ async function probeServers(isAvailable, env = process.env, configOverrides) {
   }
   return out;
 }
-var LSP_REGISTRY;
+function getBuildSpec(language) {
+  return BUILD_SPECS[language] ?? null;
+}
+var LSP_REGISTRY, BUILD_SPECS;
 var init_registry = __esm({
   "../listener/dist/lsp/registry.js"() {
     "use strict";
@@ -798,7 +801,8 @@ var init_registry = __esm({
           extensions: [".swift"],
           lspLanguageId: "swift",
           installHint: "Bundled with Xcode Command Line Tools on macOS",
-          toolchainInstallKey: "sourcekit-lsp"
+          toolchainInstallKey: "sourcekit-lsp",
+          requiresBuild: true
         }
       ],
       dart: [
@@ -913,6 +917,17 @@ var init_registry = __esm({
         }
       ]
     };
+    BUILD_SPECS = {
+      swift: {
+        gateCommands: ["swift", "xcrun"],
+        gateExecs: [{ command: "xcode-select", args: ["-p"] }],
+        manifests: ["Package.swift", "*.xcodeproj", "*.xcworkspace"],
+        platform: "darwin",
+        command: "swift",
+        args: ["build"],
+        indexStoreProbe: ".build/index/store"
+      }
+    };
   }
 });
 
@@ -1467,12 +1482,12 @@ import { createGunzip } from "zlib";
 import { spawn as spawn4 } from "child_process";
 import { pipeline } from "stream/promises";
 import { createHash as createHash2 } from "crypto";
-import { join as join14, dirname as dirname5 } from "path";
+import { join as join15, dirname as dirname5 } from "path";
 function getNativeLspDir() {
-  return join14(getLspInstallDir(), "native");
+  return join15(getLspInstallDir(), "native");
 }
 function getNativeLspBinDir() {
-  return join14(getNativeLspDir(), "bin");
+  return join15(getNativeLspDir(), "bin");
 }
 async function ensureNativeLspInstalled(lspKey) {
   const entry = NATIVE_LSP_VERSIONS[lspKey];
@@ -1498,15 +1513,15 @@ async function ensureNativeLspInstalled(lspKey) {
     }
   }
   const usesWrapper = Boolean(asset.launcherJarGlob && asset.wrapperBinaryName);
-  const versionDir = join14(getNativeLspDir(), lspKey, entry.version);
+  const versionDir = join15(getNativeLspDir(), lspKey, entry.version);
   if (usesWrapper && asset.launcherJarGlob && asset.wrapperBinaryName) {
     const jarPath = await resolveGlobInsideDir(versionDir, asset.launcherJarGlob);
-    const shimPath = join14(getNativeLspBinDir(), asset.wrapperBinaryName);
+    const shimPath = join15(getNativeLspBinDir(), asset.wrapperBinaryName);
     if (jarPath && await pathExists(shimPath)) {
       return { installed: false, alreadyPresent: true, binaryPath: shimPath };
     }
   } else {
-    const installedBinary = join14(versionDir, asset.binaryPath);
+    const installedBinary = join15(versionDir, asset.binaryPath);
     if (await pathExists(installedBinary)) {
       await ensureSymlinkInBin(lspKey, installedBinary, asset.binaryPath);
       return { installed: false, alreadyPresent: true, binaryPath: installedBinary };
@@ -1514,7 +1529,7 @@ async function ensureNativeLspInstalled(lspKey) {
   }
   try {
     await fs.mkdir(versionDir, { recursive: true });
-    const tmpDownload = join14(versionDir, `.${asset.filename}.download`);
+    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) {
       return {
@@ -1556,7 +1571,7 @@ async function ensureNativeLspInstalled(lspKey) {
       await pruneStaleVersions(lspKey, entry.version);
       return { installed: true, alreadyPresent: false, binaryPath: shimPath };
     }
-    const installedBinary = join14(versionDir, asset.binaryPath);
+    const installedBinary = join15(versionDir, asset.binaryPath);
     if (!await pathExists(installedBinary)) {
       return {
         installed: false,
@@ -1580,7 +1595,7 @@ async function resolveGlobInsideDir(versionDir, glob) {
   const parts = glob.split("/");
   let dir = versionDir;
   for (let i = 0; i < parts.length - 1; i += 1) {
-    dir = join14(dir, parts[i]);
+    dir = join15(dir, parts[i]);
   }
   const pattern = parts[parts.length - 1];
   const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
@@ -1593,10 +1608,10 @@ async function resolveGlobInsideDir(versionDir, glob) {
   }
   const matches = entries.filter((e) => re.test(e)).sort();
   const last = matches[matches.length - 1];
-  return last ? join14(dir, last) : null;
+  return last ? join15(dir, last) : null;
 }
 async function pruneStaleVersions(lspKey, currentVersion) {
-  const lspDir = join14(getNativeLspDir(), lspKey);
+  const lspDir = join15(getNativeLspDir(), lspKey);
   let entries;
   try {
     entries = await fs.readdir(lspDir);
@@ -1605,7 +1620,7 @@ async function pruneStaleVersions(lspKey, currentVersion) {
   }
   await Promise.all(entries.filter((name) => name !== currentVersion).map(async (name) => {
     try {
-      await fs.rm(join14(lspDir, name), { recursive: true, force: true });
+      await fs.rm(join15(lspDir, name), { recursive: true, force: true });
     } catch {
     }
   }));
@@ -1619,9 +1634,9 @@ function cmdQuote(value) {
 async function writeJdtlsWrapper(input) {
   const binDir = getNativeLspBinDir();
   await fs.mkdir(binDir, { recursive: true });
-  const shimPath = join14(binDir, input.binaryName);
+  const shimPath = join15(binDir, input.binaryName);
   const platformCfgDir = process.platform === "darwin" ? "config_mac" : process.platform === "win32" ? "config_win" : "config_linux";
-  const workspaceBase = join14(input.versionDir, "workspaces");
+  const workspaceBase = join15(input.versionDir, "workspaces");
   const qLauncher = shQuote(input.launcherJarPath);
   const qConfig = shQuote(`${input.versionDir}/${platformCfgDir}`);
   const qWorkspaceBase = shQuote(workspaceBase);
@@ -1681,7 +1696,7 @@ async function ensureSymlinkInBin(lspKey, target, sourceAssetPath) {
   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 = join14(binDir, linkName);
+  const linkPath = join15(binDir, linkName);
   try {
     await fs.unlink(linkPath);
   } catch {
@@ -1730,12 +1745,12 @@ async function extractAsset(source, destDir, asset) {
     return;
   }
   if (filename.endsWith(".gz")) {
-    const outPath = join14(destDir, asset.binaryPath);
+    const outPath = join15(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, join14(destDir, asset.binaryPath));
+  await fs.copyFile(source, join15(destDir, asset.binaryPath));
 }
 async function runExternal(cmd, args) {
   return new Promise((resolve5, reject) => {
@@ -1773,9 +1788,9 @@ var init_native_installer = __esm({
 // ../listener/dist/lsp/coursier-installer.js
 import { promises as fs2 } from "fs";
 import { spawn as spawn5 } from "child_process";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 function getCoursierBinDir() {
-  return join15(getLspInstallDir(), "coursier-bin");
+  return join16(getLspInstallDir(), "coursier-bin");
 }
 async function ensureCoursierLspInstalled(key) {
   const entry = COURSIER_LSPS[key];
@@ -1783,8 +1798,8 @@ async function ensureCoursierLspInstalled(key) {
     return { installed: false, alreadyPresent: false, skipped: "no-coursier-entry" };
   }
   const binDir = getCoursierBinDir();
-  const binaryPath = join15(binDir, entry.appName);
-  const binaryPathExe = join15(binDir, `${entry.appName}.bat`);
+  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 };
   }
@@ -1797,8 +1812,8 @@ async function ensureCoursierLspInstalled(key) {
       error: csBootstrap.error ?? csBootstrap.skipped
     };
   }
-  const csPath = join15(getNativeLspBinDir(), "coursier");
-  const csPathExe = join15(getNativeLspBinDir(), "coursier.exe");
+  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 {
@@ -1864,7 +1879,7 @@ var init_coursier_installer = __esm({
 import { spawn as spawn6 } from "child_process";
 import { promises as fs3 } from "fs";
 import { homedir as homedir4 } from "os";
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 async function ensureToolchainLspInstalled(key) {
   const entry = TOOLCHAIN_LSPS[key];
   if (!entry) {
@@ -1912,7 +1927,7 @@ async function ensureToolchainLspInstalled(key) {
       error: err instanceof Error ? err.message : String(err)
     };
   }
-  const binaryPath = join16(binDir, entry.binaryName);
+  const binaryPath = join17(binDir, entry.binaryName);
   if (!await pathExists3(binaryPath)) {
     return {
       installed: false,
@@ -1929,14 +1944,14 @@ async function resolveToolchainBinDir(entry) {
   }
   if (entry.toolchainBinDir) {
     if (entry.toolchain === "go") {
-      const gopath = process.env["GOPATH"] ?? join16(homedir4(), "go");
-      return join16(gopath, "bin");
+      const gopath = process.env["GOPATH"] ?? join17(homedir4(), "go");
+      return join17(gopath, "bin");
     }
-    return join16(homedir4(), entry.toolchainBinDir);
+    return join17(homedir4(), entry.toolchainBinDir);
   }
   if (entry.toolchain === "gem") {
     const userdir = await captureStdout("gem", ["env", "userdir"]);
-    return join16(userdir.trim(), "bin");
+    return join17(userdir.trim(), "bin");
   }
   throw new Error(`no bin-dir resolution for toolchain ${entry.toolchain}`);
 }
@@ -1946,10 +1961,10 @@ function getToolchainBinDirs() {
     if (entry.bundled || !entry.toolchain || !entry.toolchainBinDir)
       continue;
     if (entry.toolchain === "go") {
-      const gopath = process.env["GOPATH"] ?? join16(homedir4(), "go");
-      dirs.add(join16(gopath, "bin"));
+      const gopath = process.env["GOPATH"] ?? join17(homedir4(), "go");
+      dirs.add(join17(gopath, "bin"));
     } else {
-      dirs.add(join16(homedir4(), entry.toolchainBinDir));
+      dirs.add(join17(homedir4(), entry.toolchainBinDir));
     }
   }
   return [...dirs];
@@ -2017,20 +2032,20 @@ var init_toolchain_installer = __esm({
 
 // ../listener/dist/lsp/installer.js
 import { promises as fs4 } from "fs";
-import { join as join17, dirname as dirname6 } from "path";
+import { join as join18, dirname as dirname6 } from "path";
 import { spawn as spawn7 } from "child_process";
 import lockfile3 from "proper-lockfile";
 function getLspInstallDir() {
-  return join17(getConfigDir(), "lsp-servers");
+  return join18(getConfigDir(), "lsp-servers");
 }
 function getLspBinDir() {
-  return join17(getLspInstallDir(), "node_modules", ".bin");
+  return join18(getLspInstallDir(), "node_modules", ".bin");
 }
 async function ensureNpmLspInstalled(config2) {
   if (!config2.npmPackage)
     return { installed: false, skipped: "no-npm-package" };
   const installDir = getLspInstallDir();
-  const binPath = join17(installDir, "node_modules", ".bin", config2.command);
+  const binPath = join18(installDir, "node_modules", ".bin", config2.command);
   if (await pathExists4(binPath)) {
     return { installed: false, skipped: "already-present" };
   }
@@ -2052,7 +2067,7 @@ async function ensureNpmLspInstalled(config2) {
       if (await pathExists4(binPath)) {
         return { installed: false, skipped: "already-present" };
       }
-      const pkgJsonPath = join17(installDir, "package.json");
+      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");
       }
@@ -2081,7 +2096,7 @@ async function ensureNpmLspInstalled(config2) {
 }
 async function resolveNpmCommand() {
   const nodeDir = dirname6(process.execPath);
-  for (const candidate of [join17(nodeDir, "npm"), join17(nodeDir, "npm.cmd")]) {
+  for (const candidate of [join18(nodeDir, "npm"), join18(nodeDir, "npm.cmd")]) {
     try {
       await fs4.access(candidate);
       return candidate;
@@ -2172,10 +2187,10 @@ async function detectRepoLanguages(repoRoot) {
       continue;
     if (name === "node_modules" || name === "dist" || name === "build")
       continue;
-    const sub = join17(repoRoot, name);
+    const sub = join18(repoRoot, name);
     try {
-      const stat7 = await fs4.stat(sub);
-      if (stat7.isDirectory())
+      const stat8 = await fs4.stat(sub);
+      if (stat8.isDirectory())
         await inspect(sub);
     } catch {
     }
@@ -2188,8 +2203,8 @@ async function prepareLspServersForRepos(repos, options = {}) {
     if (!r.localPath)
       continue;
     try {
-      const stat7 = await fs4.stat(r.localPath);
-      if (!stat7.isDirectory())
+      const stat8 = await fs4.stat(r.localPath);
+      if (!stat8.isDirectory())
         continue;
     } catch {
       continue;
@@ -2293,8 +2308,8 @@ __export(sidecar_cache_exports, {
   persistMergedSidecar: () => persistMergedSidecar,
   sidecarCachePaths: () => sidecarCachePaths
 });
-import { mkdir as mkdir8, readFile as readFile7, readdir as readdir3, stat as stat2, unlink as unlink7, writeFile as writeFile8 } from "fs/promises";
-import { dirname as dirname8, join as join18 } from "path";
+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";
 function repoIdSafe(repoId) {
   return /^[A-Za-z0-9_.-]{1,128}$/.test(repoId) && !repoId.startsWith(".");
 }
@@ -2308,15 +2323,15 @@ function sidecarCachePaths(repoId, commitSha) {
   if (!commitShaSafe(commitSha)) {
     throw new Error(`unsafe commitSha: ${commitSha}`);
   }
-  const repoDir = join18(getConfigDir(), "typed-resolution", repoId);
-  const fullPath = join18(repoDir, `${commitSha}.jsonl`);
+  const repoDir = join19(getConfigDir(), "typed-resolution", repoId);
+  const fullPath = join19(repoDir, `${commitSha}.jsonl`);
   return { fullPath, repoDir };
 }
 async function persistMergedSidecar(repoId, commitSha, sidecar) {
   const { fullPath, repoDir } = sidecarCachePaths(repoId, commitSha);
-  await mkdir8(repoDir, { recursive: true });
+  await mkdir9(repoDir, { recursive: true });
   const tmpPath = `${fullPath}.tmp`;
-  await writeFile8(tmpPath, JSON.stringify(sidecar), "utf-8");
+  await writeFile9(tmpPath, JSON.stringify(sidecar), "utf-8");
   const { rename: rename5 } = await import("fs/promises");
   await rename5(tmpPath, fullPath);
   try {
@@ -2332,7 +2347,7 @@ async function sweepSidecarDir(repoDir) {
   const withMtime = [];
   for (const name of jsonlFiles) {
     try {
-      const s = await stat2(join18(repoDir, name));
+      const s = await stat2(join19(repoDir, name));
       withMtime.push({ name, mtimeMs: s.mtimeMs });
     } catch {
     }
@@ -2343,7 +2358,7 @@ async function sweepSidecarDir(repoDir) {
   for (const { name, mtimeMs } of candidates) {
     if (now - mtimeMs >= SWEEP_MAX_AGE_MS) {
       try {
-        await unlink7(join18(repoDir, name));
+        await unlink8(join19(repoDir, name));
       } catch {
       }
     }
@@ -2369,7 +2384,7 @@ async function loadMergedSidecar(repoId, commitSha) {
   let body;
   try {
     const { fullPath } = sidecarCachePaths(repoId, commitSha);
-    body = await readFile7(fullPath, "utf-8");
+    body = await readFile8(fullPath, "utf-8");
   } catch {
     return null;
   }
@@ -2954,7 +2969,7 @@ async function postLspInstallOutcomes(input) {
     const ctrl = new AbortController();
     const timer = setTimeout(() => {
       ctrl.abort();
-    }, REQUEST_TIMEOUT_MS);
+    }, REQUEST_TIMEOUT_MS3);
     try {
       const res = await fetchImpl(url, {
         method: "POST",
@@ -2989,30 +3004,30 @@ async function postLspInstallOutcomes(input) {
     console.warn(`[lsp-telemetry] unexpected failure: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-var REQUEST_TIMEOUT_MS;
+var REQUEST_TIMEOUT_MS3;
 var init_telemetry = __esm({
   "../listener/dist/lsp/telemetry.js"() {
     "use strict";
-    REQUEST_TIMEOUT_MS = 5e3;
+    REQUEST_TIMEOUT_MS3 = 5e3;
   }
 });
 
 // bin/repowise.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname20, join as join52 } from "path";
+import { dirname as dirname20, join as join59 } from "path";
 import { Command } from "commander";
 
 // ../listener/dist/main.js
 init_config_dir();
-import { readFile as readFile12, writeFile as writeFile14, mkdir as mkdir14, stat as fsStat } from "fs/promises";
-import { join as join32, dirname as dirname15 } from "path";
+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 { fileURLToPath as fileURLToPath3 } from "url";
 import lockfile4 from "proper-lockfile";
 
 // ../../packages/shared/dist/lib/ai-tools.js
-import { readFile, writeFile, mkdir, readdir, stat, unlink } from "fs/promises";
-import { join as join2, dirname } from "path";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, readdir, stat, unlink as unlink2 } from "fs/promises";
+import { join as join3, dirname } from "path";
 
 // ../../packages/shared/dist/lib/project-overview-injection.js
 var START_MARKER = "<!-- repowise:agent-instructions:start -->";
@@ -3029,7 +3044,7 @@ Treat RepoWise as your default starting point for every task that touches this c
 1. **Always start with RepoWise.** Before any task \u2014 questions, planning, coding, debugging, refactoring, tests, code review \u2014 gather context from RepoWise FIRST. Skipping it leads to wrong patterns, duplicated abstractions, and missed constraints.
 
 2. **Use the three-tier hierarchy in this order:**
-   - **Tier 1 \u2014 RepoWise MCP** for surgical structural queries: symbol resolution, callers, references, call graphs, refactor impact, dependency graphs, type info (\`mcp__repowise__find_symbol\`, \`mcp__repowise__get_impact\`, \`mcp__repowise__lsp_definition\`, etc.). Each tool's description tells you when to use it.
+   - **Tier 1 \u2014 RepoWise MCP** for surgical structural queries: symbol resolution, callers, references, call graphs, refactor impact, dependency graphs, type info (\`find_symbol\`, \`get_impact\`, \`lsp_definition\`, etc. \u2014 the server is named "RepoWise MCP for <repo>", so hosts that prefix tool names expose them accordingly). Each tool's description tells you when to use it.
    - **Tier 2 \u2014 Context files in \`repowise-context/\`** for narrative context: how a domain is designed, what patterns exist, what conventions to follow. Use the *Context File Routing Map* below to pick which files to read.
    - **Tier 3 \u2014 Native code search** (\`read_file\` / \`grep\` / \`glob\` on raw source) ONLY when tiers 1-2 don't cover the question, or for ephemeral state (recent commits, in-flight branches).
 
@@ -3055,7 +3070,7 @@ Treat RepoWise as your default starting point for every task that touches this c
 
        _Powered by RepoWise._
 
-   That's it \u2014 one short line, no longer preamble. The host's tool-call UI already shows \`mcp__repowise__*\` calls visibly; this tag adds the same surface for context-file reads. If you didn't use RepoWise on this turn, omit the tag \u2014 never fake it.
+   That's it \u2014 one short line, no longer preamble. The host's tool-call UI already shows RepoWise MCP calls visibly; this tag adds the same surface for context-file reads. If you didn't use RepoWise on this turn, omit the tag \u2014 never fake it.
 
 8. **Surface MCP gaps explicitly.** If RepoWise MCP is unavailable (no \`.mcp.json\` configured, listener not running), tell the user \u2014 don't silently fall back to \`grep\`.
 ${END_MARKER}`;
@@ -3084,7 +3099,353 @@ function injectAgentInstructions(content) {
   return canonicalBlock + lineEnding + lineEnding + content;
 }
 
+// ../../packages/shared/dist/lib/enforcement-hooks.js
+import { execFile } from "child_process";
+import { readFile, writeFile, mkdir, unlink } from "fs/promises";
+import { basename, join as join2 } from "path";
+var REPOWISE_MANAGED_COMMENT = "# repowise-managed";
+function isRepoWiseHookCommand(command) {
+  if (command.includes(REPOWISE_MANAGED_COMMENT))
+    return true;
+  return command.startsWith("echo '") && command.includes("additionalContext") && command.includes("/project-overview.md");
+}
+function sanitizeForShellText(value) {
+  return value.replace(/['\r\n]/g, "");
+}
+function mcpServerName(repoName) {
+  return `RepoWise MCP for ${repoName}`;
+}
+function claudeToolPrefix(repoName) {
+  return `mcp__${mcpServerName(repoName).replace(/ /g, "_")}__`;
+}
+var GRAPH_TOOLS = "find_symbol, get_symbol, get_impact, find_callers, find_references, batch_query";
+var LSP_TOOLS = "lsp_definition, lsp_references, lsp_hover";
+function buildRepoWiseFirstDirective(repoName, contextFolder, style = "generic") {
+  const repo = sanitizeForShellText(repoName);
+  const folder = sanitizeForShellText(contextFolder);
+  const toolNaming = style === "claude" ? `${claudeToolPrefix(repo)}<tool>, e.g. ${claudeToolPrefix(repo)}find_symbol` : `the "${mcpServerName(repo)}" MCP server`;
+  return `RepoWise-first: before any codebase task, gather context from RepoWise first. Tier 1: RepoWise MCP graph tools (${toolNaming}; tools: ${GRAPH_TOOLS}) and LSP tools (${LSP_TOOLS}) for symbol resolution and blast radius. Tier 2: ${folder}/ files, starting with ${folder}/project-overview.md. Tier 3: native file search only when tiers 1-2 do not cover the question. If these tools are deferred in your environment, load them via tool search before calling.`;
+}
+function buildSubagentDirective(contextFolder) {
+  const folder = sanitizeForShellText(contextFolder);
+  return `IMPORTANT: Read ${folder}/project-overview.md before performing any work. This file maps every context file to its domain.`;
+}
+function assertShellSafe(payload) {
+  if (payload.includes("'")) {
+    throw new Error("hook payload must not contain single quotes");
+  }
+  if (/[\r\n]/.test(payload)) {
+    throw new Error("hook payload must be a single line");
+  }
+}
+function buildHookEchoCommand(eventName, additionalContext) {
+  const json = JSON.stringify({
+    hookSpecificOutput: { hookEventName: eventName, additionalContext }
+  });
+  assertShellSafe(json);
+  return `echo '${json}' ${REPOWISE_MANAGED_COMMENT}`;
+}
+function buildPlainJsonEchoCommand(payload) {
+  const json = JSON.stringify(payload);
+  assertShellSafe(json);
+  return `echo '${json}' ${REPOWISE_MANAGED_COMMENT}`;
+}
+function upsertRepoWiseEntry(entries, next) {
+  const list = Array.isArray(entries) ? entries : [];
+  const idx = list.findIndex((entry) => entry?.hooks?.some?.((h) => typeof h?.command === "string" && isRepoWiseHookCommand(h.command)));
+  if (idx >= 0) {
+    list[idx] = next;
+  } else {
+    list.push(next);
+  }
+  return list;
+}
+function removeRepoWiseEntries(entries) {
+  const list = Array.isArray(entries) ? entries : [];
+  return list.filter((entry) => !entry?.hooks?.some?.((h) => typeof h?.command === "string" && isRepoWiseHookCommand(h.command)));
+}
+function mergeHookEvents(existingContent, events) {
+  let settings = {};
+  if (existingContent) {
+    let parsed;
+    try {
+      parsed = JSON.parse(existingContent);
+    } catch {
+      return existingContent;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return existingContent;
+    }
+    settings = parsed;
+  }
+  if (settings["hooks"] !== void 0 && !isPlainObject(settings["hooks"])) {
+    return existingContent ?? JSON.stringify(settings, null, 2) + "\n";
+  }
+  const hooks = isPlainObject(settings["hooks"]) ? settings["hooks"] : {};
+  for (const [event, entry] of Object.entries(events)) {
+    if (hooks[event] !== void 0 && !Array.isArray(hooks[event])) {
+      continue;
+    }
+    hooks[event] = upsertRepoWiseEntry(hooks[event], entry);
+  }
+  settings["hooks"] = hooks;
+  const next = JSON.stringify(settings, null, 2) + "\n";
+  return existingContent === next ? existingContent : next;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function removeHookEvents(existingContent, eventNames) {
+  let settings;
+  try {
+    const parsed = JSON.parse(existingContent);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      return existingContent;
+    settings = parsed;
+  } catch {
+    return existingContent;
+  }
+  const hooks = settings["hooks"] && typeof settings["hooks"] === "object" && !Array.isArray(settings["hooks"]) ? settings["hooks"] : null;
+  if (!hooks)
+    return existingContent;
+  for (const event of eventNames) {
+    if (hooks[event] !== void 0 && !Array.isArray(hooks[event])) {
+      continue;
+    }
+    const remaining = removeRepoWiseEntries(hooks[event]);
+    if (remaining.length > 0) {
+      hooks[event] = remaining;
+    } else {
+      delete hooks[event];
+    }
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete settings["hooks"];
+  }
+  if (Object.keys(settings).length === 0)
+    return null;
+  const next = JSON.stringify(settings, null, 2) + "\n";
+  return existingContent === next ? existingContent : next;
+}
+function mergeClaudeHookSettings(existingContent, params) {
+  return mergeHookEvents(existingContent, {
+    SubagentStart: {
+      matcher: "",
+      hooks: [
+        {
+          type: "command",
+          command: buildHookEchoCommand("SubagentStart", buildSubagentDirective(params.contextFolder))
+        }
+      ]
+    },
+    UserPromptSubmit: {
+      hooks: [
+        {
+          type: "command",
+          command: buildHookEchoCommand("UserPromptSubmit", buildRepoWiseFirstDirective(params.repoName, params.contextFolder, "claude"))
+        }
+      ]
+    }
+  });
+}
+function removeClaudeHookSettings(existingContent) {
+  return removeHookEvents(existingContent, ["SubagentStart", "UserPromptSubmit"]);
+}
+function mergeGeminiHookSettings(existingContent, params) {
+  return mergeHookEvents(existingContent, {
+    BeforeAgent: {
+      hooks: [
+        {
+          type: "command",
+          name: "repowise-first",
+          command: buildPlainJsonEchoCommand({
+            hookSpecificOutput: {
+              additionalContext: buildRepoWiseFirstDirective(params.repoName, params.contextFolder)
+            }
+          })
+        }
+      ]
+    }
+  });
+}
+function removeGeminiHookSettings(existingContent) {
+  return removeHookEvents(existingContent, ["BeforeAgent"]);
+}
+function mergeCodexHookSettings(existingContent, params) {
+  return mergeHookEvents(existingContent, {
+    UserPromptSubmit: {
+      hooks: [
+        {
+          type: "command",
+          command: buildHookEchoCommand("UserPromptSubmit", buildRepoWiseFirstDirective(params.repoName, params.contextFolder))
+        }
+      ]
+    }
+  });
+}
+function removeCodexHookSettings(existingContent) {
+  return removeHookEvents(existingContent, ["UserPromptSubmit"]);
+}
+function buildCopilotHooksFile(params) {
+  const command = buildPlainJsonEchoCommand({
+    additionalContext: buildRepoWiseFirstDirective(params.repoName, params.contextFolder)
+  });
+  return JSON.stringify({
+    version: 1,
+    hooks: {
+      sessionStart: [{ type: "command", bash: command, powershell: command, timeoutSec: 10 }]
+    }
+  }, null, 2) + "\n";
+}
+function buildClineHookScript(params) {
+  const command = buildPlainJsonEchoCommand({
+    contextModification: buildRepoWiseFirstDirective(params.repoName, params.contextFolder)
+  });
+  return [
+    "#!/bin/sh",
+    "# repowise-context hook managed by RepoWise. Do not edit; regenerated on sync.",
+    command,
+    ""
+  ].join("\n");
+}
+var GITIGNORE_START = "# repowise:start (managed by RepoWise, do not edit between markers)";
+var GITIGNORE_END = "# repowise:end";
+function updateGitignoreBlock(existingContent, changes) {
+  let content = existingContent ?? "";
+  const lineEnding = content.includes("\r\n") ? "\r\n" : "\n";
+  let startIdx = content.indexOf(GITIGNORE_START);
+  let endIdx = startIdx === -1 ? -1 : content.indexOf(GITIGNORE_END, startIdx);
+  let hasBlock = startIdx !== -1 && endIdx > startIdx;
+  if (!hasBlock && (content.includes(GITIGNORE_START) || content.includes(GITIGNORE_END))) {
+    content = content.split(/\r?\n/).filter((line) => {
+      const t = line.trim();
+      return t !== GITIGNORE_START && t !== GITIGNORE_END;
+    }).join(lineEnding);
+    startIdx = -1;
+    endIdx = -1;
+    hasBlock = false;
+  }
+  const current = /* @__PURE__ */ new Set();
+  if (hasBlock) {
+    const inner = content.slice(startIdx + GITIGNORE_START.length, endIdx);
+    for (const line of inner.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (trimmed.length > 0 && !trimmed.startsWith("#"))
+        current.add(trimmed);
+    }
+  }
+  for (const p of changes.add ?? [])
+    current.add(p);
+  for (const p of changes.remove ?? [])
+    current.delete(p);
+  const entries = [...current].sort();
+  const block = entries.length === 0 ? "" : [GITIGNORE_START, ...entries, GITIGNORE_END].join(lineEnding);
+  let next;
+  if (hasBlock) {
+    const before = content.slice(0, startIdx);
+    const after = content.slice(endIdx + GITIGNORE_END.length);
+    if (block === "") {
+      next = before.replace(/(\r?\n){2,}$/, lineEnding) + after.replace(/^\r?\n/, "");
+      if (next.trim() === "")
+        return "";
+    } else {
+      next = before + block + after;
+    }
+  } else if (block === "") {
+    next = content;
+  } else {
+    const separator = content.length === 0 ? "" : content.endsWith(lineEnding) ? lineEnding : lineEnding + lineEnding;
+    next = content + separator + block + lineEnding;
+  }
+  return next === (existingContent ?? "") ? existingContent ?? "" : next;
+}
+var CLAUDE_PROJECT_SETTINGS = ".claude/settings.json";
+var CLAUDE_LOCAL_SETTINGS = ".claude/settings.local.json";
+async function isGitTracked(repoRoot, relPath) {
+  return new Promise((resolve5) => {
+    execFile("git", ["ls-files", "--error-unmatch", relPath], { cwd: repoRoot }, (err) => {
+      if (!err)
+        return resolve5(true);
+      if (err.code === 1 || err.code === 128)
+        return resolve5(false);
+      resolve5(true);
+    });
+  });
+}
+async function applyGitignoreChanges(repoRoot, changes) {
+  const path = join2(repoRoot, ".gitignore");
+  let existing = null;
+  try {
+    existing = await readFile(path, "utf-8");
+  } catch {
+  }
+  const next = updateGitignoreBlock(existing, changes);
+  if (next !== (existing ?? "")) {
+    await writeFile(path, next, "utf-8");
+  }
+}
+async function writeClaudeHooksToRepo(repoRoot, contextFolder) {
+  const repoName = basename(repoRoot);
+  const projectTracked = await isGitTracked(repoRoot, CLAUDE_PROJECT_SETTINGS);
+  if (projectTracked) {
+    let trackedContent = "";
+    try {
+      trackedContent = await readFile(join2(repoRoot, CLAUDE_PROJECT_SETTINGS), "utf-8");
+    } catch {
+    }
+    const trackedHasOurHooks = trackedContent.includes(REPOWISE_MANAGED_COMMENT) || trackedContent.includes("additionalContext") && trackedContent.includes("/project-overview.md");
+    if (trackedHasOurHooks) {
+      await applyGitignoreChanges(repoRoot, {
+        remove: [CLAUDE_PROJECT_SETTINGS, CLAUDE_LOCAL_SETTINGS]
+      });
+      return { status: "unchanged", relPath: CLAUDE_PROJECT_SETTINGS };
+    }
+  }
+  const targetRel = projectTracked ? CLAUDE_LOCAL_SETTINGS : CLAUDE_PROJECT_SETTINGS;
+  const targetPath = join2(repoRoot, targetRel);
+  let existing = null;
+  try {
+    existing = await readFile(targetPath, "utf-8");
+  } catch {
+  }
+  const merged = mergeClaudeHookSettings(existing, { repoName, contextFolder });
+  let status2 = "unchanged";
+  if (merged !== existing) {
+    await mkdir(join2(repoRoot, ".claude"), { recursive: true });
+    await writeFile(targetPath, merged, "utf-8");
+    status2 = "written";
+  }
+  if (status2 === "written") {
+    await applyGitignoreChanges(repoRoot, {
+      add: [targetRel],
+      remove: [projectTracked ? CLAUDE_PROJECT_SETTINGS : CLAUDE_LOCAL_SETTINGS]
+    });
+  }
+  return { status: status2, relPath: targetRel };
+}
+async function removeClaudeHooksFromRepo(repoRoot) {
+  for (const rel of [CLAUDE_PROJECT_SETTINGS, CLAUDE_LOCAL_SETTINGS]) {
+    const path = join2(repoRoot, rel);
+    let existing;
+    try {
+      existing = await readFile(path, "utf-8");
+    } catch {
+      continue;
+    }
+    const next = removeClaudeHookSettings(existing);
+    if (next === null) {
+      await unlink(path);
+    } else if (next !== existing) {
+      await writeFile(path, next, "utf-8");
+    }
+  }
+  await applyGitignoreChanges(repoRoot, {
+    remove: [CLAUDE_PROJECT_SETTINGS, CLAUDE_LOCAL_SETTINGS]
+  });
+}
+
 // ../../packages/shared/dist/lib/ai-tools.js
+var AI_TOOLS_REFERENCE_REV = 2;
 var AI_TOOL_CONFIG = {
   cursor: {
     label: "Cursor",
@@ -3155,6 +3516,15 @@ var AI_TOOL_CONFIG = {
     format: "markdown",
     owned: true
   },
+  kilo: {
+    label: "Kilo Code",
+    fileName: "repowise.md",
+    filePath: ".kilocode/rules/repowise.md",
+    markerStart: "<!-- repowise-start -->",
+    markerEnd: "<!-- repowise-end -->",
+    format: "markdown",
+    owned: true
+  },
   gemini: {
     label: "Gemini CLI",
     fileName: "GEMINI.md",
@@ -3227,6 +3597,8 @@ function generateReference(tool, repoName, contextFolder, contextFiles) {
     return { path: f.relativePath, desc: isOverview ? `${desc} (full index of all files)` : desc };
   });
   const hasFiles = fileLines.length > 0;
+  const mcpName = repoName.replace(/`/g, "");
+  const mcpNamingNote = tool === "claude-code" ? `**RepoWise MCP tool naming in this repo:** tools are exposed as \`${claudeToolPrefix(mcpName)}<tool>\`, e.g. \`${claudeToolPrefix(mcpName)}find_symbol\`, \`${claudeToolPrefix(mcpName)}get_impact\`, \`${claudeToolPrefix(mcpName)}lsp_definition\`.` : `**RepoWise MCP server for this repo:** "${mcpServerName(mcpName)}" \u2014 graph tools: find_symbol, get_symbol, get_impact, find_callers, find_references, batch_query; LSP tools: lsp_definition, lsp_references, lsp_hover.`;
   const contentLines = [
     `## Project Context \u2014 ${safeName}`,
     "",
@@ -3235,6 +3607,8 @@ function generateReference(tool, repoName, contextFolder, contextFiles) {
     AI_AGENT_USAGE_INSTRUCTIONS,
     "",
     `**Start here:** \`${contextFolder}/project-overview.md\` \u2014 the routing document that maps every context file to its domain.`,
+    "",
+    mcpNamingNote,
     ""
   ];
   if (hasFiles) {
@@ -3252,10 +3626,10 @@ function generateReference(tool, repoName, contextFolder, contextFiles) {
 }
 async function updateToolConfig(repoRoot, tool, repoName, contextFolder, contextFiles) {
   const config2 = AI_TOOL_CONFIG[tool];
-  const fullPath = join2(repoRoot, config2.filePath);
+  const fullPath = join3(repoRoot, config2.filePath);
   const dir = dirname(fullPath);
   if (dir !== repoRoot) {
-    await mkdir(dir, { recursive: true });
+    await mkdir2(dir, { recursive: true });
   }
   const referenceBlock = generateReference(tool, repoName, contextFolder, contextFiles);
   if (config2.owned) {
@@ -3265,13 +3639,13 @@ async function updateToolConfig(repoRoot, tool, repoName, contextFolder, context
       created2 = false;
     } catch {
     }
-    await writeFile(fullPath, referenceBlock, "utf-8");
+    await writeFile2(fullPath, referenceBlock, "utf-8");
     return { created: created2 };
   }
   let existing = "";
   let created = true;
   try {
-    existing = await readFile(fullPath, "utf-8");
+    existing = await readFile2(fullPath, "utf-8");
     created = false;
   } catch (err) {
     if (err.code !== "ENOENT")
@@ -3288,14 +3662,43 @@ async function updateToolConfig(repoRoot, tool, repoName, contextFolder, context
     const separator = existing.length > 0 && !existing.endsWith("\n") ? "\n\n" : existing.length > 0 ? "\n" : "";
     content = existing + separator + referenceBlock + "\n";
   }
-  await writeFile(fullPath, content, "utf-8");
+  await writeFile2(fullPath, content, "utf-8");
   return { created };
 }
+async function removeToolConfig(repoRoot, tool) {
+  const config2 = AI_TOOL_CONFIG[tool];
+  const fullPath = join3(repoRoot, config2.filePath);
+  if (config2.owned) {
+    try {
+      await unlink2(fullPath);
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+    }
+    return;
+  }
+  let existing;
+  try {
+    existing = await readFile2(fullPath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return;
+    throw err;
+  }
+  const startIdx = existing.indexOf(config2.markerStart);
+  const endIdx = existing.indexOf(config2.markerEnd);
+  if (startIdx === -1 || endIdx === -1)
+    return;
+  const before = existing.slice(0, startIdx);
+  const after = existing.slice(endIdx + config2.markerEnd.length);
+  const content = (before + after).replace(/\n{3,}/g, "\n\n").trim() + "\n";
+  await writeFile2(fullPath, content, "utf-8");
+}
 async function migrateToolConfig(repoRoot, tool, repoName, contextFolder, contextFiles) {
   const config2 = AI_TOOL_CONFIG[tool];
   if (!config2.legacyFilePath)
     return { migrated: false, legacyRemoved: false };
-  const legacyPath = join2(repoRoot, config2.legacyFilePath);
+  const legacyPath = join3(repoRoot, config2.legacyFilePath);
   let legacyIsFile = false;
   try {
     const s = await stat(legacyPath);
@@ -3308,7 +3711,7 @@ async function migrateToolConfig(repoRoot, tool, repoName, contextFolder, contex
     await updateToolConfig(repoRoot, tool, repoName, contextFolder, contextFiles);
     return { migrated: false, legacyRemoved: false };
   }
-  const legacyContent = await readFile(legacyPath, "utf-8");
+  const legacyContent = await readFile2(legacyPath, "utf-8");
   let cleaned = legacyContent;
   const oldMarkers = [
     { start: "# --- repowise-start ---", end: "# --- repowise-end ---" },
@@ -3324,16 +3727,16 @@ async function migrateToolConfig(repoRoot, tool, repoName, contextFolder, contex
   cleaned = cleaned.replace(/\n{3,}/g, "\n\n").trim();
   if (tool === "cline") {
     if (cleaned.length > 0) {
-      await unlink(legacyPath);
-      await mkdir(join2(repoRoot, ".clinerules"), { recursive: true });
-      await writeFile(join2(repoRoot, ".clinerules/user-rules.md"), cleaned + "\n", "utf-8");
+      await unlink2(legacyPath);
+      await mkdir2(join3(repoRoot, ".clinerules"), { recursive: true });
+      await writeFile2(join3(repoRoot, ".clinerules/user-rules.md"), cleaned + "\n", "utf-8");
     } else {
-      await unlink(legacyPath);
+      await unlink2(legacyPath);
     }
   } else if (cleaned.length > 0) {
-    await writeFile(legacyPath, cleaned + "\n", "utf-8");
+    await writeFile2(legacyPath, cleaned + "\n", "utf-8");
   } else {
-    await unlink(legacyPath);
+    await unlink2(legacyPath);
   }
   await updateToolConfig(repoRoot, tool, repoName, contextFolder, contextFiles);
   return { migrated: true, legacyRemoved: cleaned.length === 0 };
@@ -3351,16 +3754,44 @@ async function detectInstalledTools(repoRoot) {
   for (const [tool, config2] of Object.entries(AI_TOOL_CONFIG)) {
     if (tool !== "codex" && config2.filePath === "AGENTS.md")
       continue;
-    if (await fileExists(join2(repoRoot, config2.filePath))) {
+    if (await fileExists(join3(repoRoot, config2.filePath))) {
       detected.push(tool);
-    } else if (config2.legacyFilePath && await fileExists(join2(repoRoot, config2.legacyFilePath))) {
+    } else if (config2.legacyFilePath && await fileExists(join3(repoRoot, config2.legacyFilePath))) {
       detected.push(tool);
     }
   }
-  return detected;
+  return detected.map((t) => t === "roo-code" ? "kilo" : t).filter(dedupe);
+}
+function dedupe(value, index, arr) {
+  return arr.indexOf(value) === index;
+}
+async function migrateRooToKilo(repoRoot) {
+  let migrated = false;
+  if (await fileExists(join3(repoRoot, ".roo/rules/repowise.md"))) {
+    await removeToolConfig(repoRoot, "roo-code");
+    migrated = true;
+  }
+  const legacyPath = join3(repoRoot, ".roo/rules.md");
+  try {
+    const legacy = await readFile2(legacyPath, "utf-8");
+    const config2 = AI_TOOL_CONFIG["roo-code"];
+    const si = legacy.indexOf(config2.markerStart);
+    const ei = legacy.indexOf(config2.markerEnd);
+    if (si !== -1 && ei > si) {
+      const cleaned = (legacy.slice(0, si) + legacy.slice(ei + config2.markerEnd.length)).replace(/\n{3,}/g, "\n\n").trim();
+      if (cleaned.length > 0) {
+        await writeFile2(legacyPath, cleaned + "\n", "utf-8");
+      } else {
+        await unlink2(legacyPath);
+      }
+      migrated = true;
+    }
+  } catch {
+  }
+  return migrated;
 }
 async function scanLocalContextFiles(repoRoot, contextFolder) {
-  const folderPath = join2(repoRoot, contextFolder);
+  const folderPath = join3(repoRoot, contextFolder);
   try {
     const entries = await readdir(folderPath, { withFileTypes: true, recursive: true });
     const results = [];
@@ -3368,7 +3799,7 @@ async function scanLocalContextFiles(repoRoot, contextFolder) {
       if (!entry.isFile() || !entry.name.endsWith(".md"))
         continue;
       const parentDir = entry.parentPath ?? folderPath;
-      const fullPath = join2(parentDir, entry.name);
+      const fullPath = join3(parentDir, entry.name);
       const relFromContext = fullPath.slice(folderPath.length + 1);
       results.push({
         fileName: relFromContext,
@@ -3385,8 +3816,8 @@ async function scanLocalContextFiles(repoRoot, contextFolder) {
 
 // ../listener/dist/lib/config.js
 init_config_dir();
-import { readFile as readFile2, writeFile as writeFile2, rename, unlink as unlink2, mkdir as mkdir2, chmod, open } from "fs/promises";
-import { join as join3 } from "path";
+import { readFile as readFile3, writeFile as writeFile3, rename, unlink as unlink3, mkdir as mkdir3, chmod, open } from "fs/promises";
+import { join as join4 } from "path";
 import lockfile from "proper-lockfile";
 function sanitizeLspOverrides(raw) {
   if (raw === void 0 || raw === null)
@@ -3404,10 +3835,10 @@ function sanitizeLspOverrides(raw) {
 var DEFAULT_API_URL = true ? "https://staging-api.repowise.ai" : "https://api.repowise.ai";
 async function getListenerConfig() {
   const configDir = getConfigDir();
-  const configPath = join3(configDir, "config.json");
+  const configPath = join4(configDir, "config.json");
   const apiUrl = process.env["REPOWISE_API_URL"] ?? DEFAULT_API_URL;
   try {
-    const data = await readFile2(configPath, "utf-8");
+    const data = await readFile3(configPath, "utf-8");
     const raw = JSON.parse(data);
     const validRepos = (raw.repos ?? []).filter((r) => typeof r === "object" && r !== null && typeof r.repoId === "string" && typeof r.localPath === "string");
     const lspOverrides = sanitizeLspOverrides(raw.lspOverrides);
@@ -3433,10 +3864,10 @@ async function getListenerConfig() {
 }
 async function saveListenerConfig(config2) {
   const configDir = getConfigDir();
-  const configPath = join3(configDir, "config.json");
-  await mkdir2(configDir, { recursive: true, mode: 448 });
+  const configPath = join4(configDir, "config.json");
+  await mkdir3(configDir, { recursive: true, mode: 448 });
   try {
-    await writeFile2(configPath, "", { flag: "a" });
+    await writeFile3(configPath, "", { flag: "a" });
   } catch {
   }
   let release = null;
@@ -3444,7 +3875,7 @@ async function saveListenerConfig(config2) {
     release = await lockfile.lock(configPath, { stale: 1e4, retries: 3, realpath: false });
     let raw = {};
     try {
-      const data = await readFile2(configPath, "utf-8");
+      const data = await readFile3(configPath, "utf-8");
       raw = JSON.parse(data);
     } catch {
     }
@@ -3462,7 +3893,7 @@ async function saveListenerConfig(config2) {
     };
     const tmpPath = configPath + ".tmp";
     try {
-      await writeFile2(tmpPath, JSON.stringify(output, null, 2));
+      await writeFile3(tmpPath, JSON.stringify(output, null, 2));
       await chmod(tmpPath, 384);
       let fh;
       try {
@@ -3474,7 +3905,7 @@ async function saveListenerConfig(config2) {
       await rename(tmpPath, configPath);
     } catch (err) {
       try {
-        await unlink2(tmpPath);
+        await unlink3(tmpPath);
       } catch {
       }
       throw err;
@@ -3491,16 +3922,16 @@ async function saveListenerConfig(config2) {
 
 // ../listener/dist/lib/state.js
 init_config_dir();
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, chmod as chmod2, rename as rename2, unlink as unlink3, open as open2 } from "fs/promises";
-import { join as join4 } from "path";
+import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4, chmod as chmod2, rename as rename2, unlink as unlink4, open as open2 } from "fs/promises";
+import { join as join5 } from "path";
 import lockfile2 from "proper-lockfile";
 function emptyState() {
   return { repos: {} };
 }
 async function loadState() {
-  const statePath = join4(getConfigDir(), "listener-state.json");
+  const statePath = join5(getConfigDir(), "listener-state.json");
   try {
-    const data = await readFile3(statePath, "utf-8");
+    const data = await readFile4(statePath, "utf-8");
     const state = JSON.parse(data);
     if (typeof state !== "object" || state === null || typeof state.repos !== "object" || state.repos === null) {
       return emptyState();
@@ -3515,10 +3946,10 @@ async function loadState() {
 }
 async function saveState(state) {
   const configDir = getConfigDir();
-  const statePath = join4(configDir, "listener-state.json");
-  await mkdir3(configDir, { recursive: true, mode: 448 });
+  const statePath = join5(configDir, "listener-state.json");
+  await mkdir4(configDir, { recursive: true, mode: 448 });
   try {
-    await writeFile3(statePath, "", { flag: "a" });
+    await writeFile4(statePath, "", { flag: "a" });
   } catch {
   }
   let release = null;
@@ -3529,7 +3960,7 @@ async function saveState(state) {
   }
   const tmpPath = statePath + ".tmp";
   try {
-    await writeFile3(tmpPath, JSON.stringify(state, null, 2));
+    await writeFile4(tmpPath, JSON.stringify(state, null, 2));
     await chmod2(tmpPath, 384);
     let fh;
     try {
@@ -3541,7 +3972,7 @@ async function saveState(state) {
     await rename2(tmpPath, statePath);
   } catch (err) {
     try {
-      await unlink3(tmpPath);
+      await unlink4(tmpPath);
     } catch {
     }
     throw err;
@@ -3555,7 +3986,7 @@ async function saveState(state) {
 
 // ../listener/dist/lib/reconcile.js
 import { statSync, readdirSync } from "fs";
-import { basename, dirname as dirname2, join as join5 } from "path";
+import { basename as basename2, dirname as dirname2, join as join6 } from "path";
 function reconcileRepos(configRepos, activeRepos, state, apiUrl, options) {
   if (activeRepos.length === 0) {
     return { updated: false, repos: configRepos, changes: [], addedRepos: [] };
@@ -3598,8 +4029,8 @@ function reconcileRepos(configRepos, activeRepos, state, apiUrl, options) {
         };
       }
     }
-    const dirName = basename(repo.localPath);
-    const parentDir = basename(dirname2(repo.localPath));
+    const dirName = basename2(repo.localPath);
+    const parentDir = basename2(dirname2(repo.localPath));
     const fullPathName = `${parentDir}/${dirName}`;
     let matches = activeRepos.filter((ar) => ar.fullName === fullPathName);
     if (matches.length === 0) {
@@ -3673,7 +4104,7 @@ function findLocalRepo(activeRepo, parentDirs, usedPaths) {
   const nameParts = activeRepo.fullName.split("/");
   const repoName = nameParts[nameParts.length - 1];
   for (const parentDir of parentDirs) {
-    const candidate = join5(parentDir, repoName);
+    const candidate = join6(parentDir, repoName);
     if (!usedPaths.has(candidate) && hasContextFolder(candidate)) {
       return candidate;
     }
@@ -3682,7 +4113,7 @@ function findLocalRepo(activeRepo, parentDirs, usedPaths) {
 }
 function hasContextFolder(dirPath) {
   try {
-    const contextPath = join5(dirPath, "repowise-context");
+    const contextPath = join6(dirPath, "repowise-context");
     const s = statSync(contextPath);
     if (!s.isDirectory())
       return false;
@@ -3713,8 +4144,8 @@ function migrateState(state, oldId, newId) {
 
 // ../listener/dist/lib/auth.js
 init_config_dir();
-import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4, chmod as chmod3 } from "fs/promises";
-import { join as join6 } from "path";
+import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5, chmod as chmod3 } from "fs/promises";
+import { join as join7 } from "path";
 function getTokenUrl(creds) {
   const cognito = creds?.cognito;
   const domain = process.env["REPOWISE_COGNITO_DOMAIN"] ?? cognito?.domain ?? "auth-repowise-dev";
@@ -3753,8 +4184,8 @@ async function refreshTokens(refreshToken, creds) {
 }
 async function getStoredCredentials() {
   try {
-    const credPath = join6(getConfigDir(), "credentials.json");
-    const data = await readFile4(credPath, "utf-8");
+    const credPath = join7(getConfigDir(), "credentials.json");
+    const data = await readFile5(credPath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
     if (err.code === "ENOENT" || err instanceof SyntaxError) {
@@ -3765,9 +4196,9 @@ async function getStoredCredentials() {
 }
 async function storeCredentials(credentials) {
   const dir = getConfigDir();
-  const credPath = join6(dir, "credentials.json");
-  await mkdir4(dir, { recursive: true, mode: 448 });
-  await writeFile4(credPath, JSON.stringify(credentials, null, 2));
+  const credPath = join7(dir, "credentials.json");
+  await mkdir5(dir, { recursive: true, mode: 448 });
+  await writeFile5(credPath, JSON.stringify(credentials, null, 2));
   await chmod3(credPath, 384);
 }
 async function getValidCredentials(options) {
@@ -3917,17 +4348,17 @@ function notifyContextUpdated(repoId, fileCount) {
 }
 
 // ../listener/dist/context-fetcher.js
-import { execFile } from "child_process";
-import { mkdir as mkdir5, writeFile as writeFile5 } from "fs/promises";
-import { dirname as dirname3, join as join8 } from "path";
+import { execFile as execFile2 } from "child_process";
+import { mkdir as mkdir6, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname3, join as join9 } from "path";
 import { promisify } from "util";
 
 // ../listener/dist/file-writer.js
 import { access } from "fs/promises";
-import { join as join7 } from "path";
+import { join as join8 } from "path";
 async function verifyContextFolder(localPath) {
   try {
-    await access(join7(localPath, "repowise-context"));
+    await access(join8(localPath, "repowise-context"));
     return true;
   } catch {
     return false;
@@ -3935,7 +4366,7 @@ async function verifyContextFolder(localPath) {
 }
 
 // ../listener/dist/context-fetcher.js
-var execFileAsync = promisify(execFile);
+var execFileAsync = promisify(execFile2);
 async function fetchContextUpdates(localPath) {
   try {
     const { stdout: beforeSha } = await execFileAsync("git", [
@@ -4015,8 +4446,8 @@ async function fetchContextFromServer(repoId, localPath, apiUrl) {
     if (files.length === 0) {
       return { success: true, updatedFiles: [] };
     }
-    const contextDir = join8(localPath, "repowise-context");
-    await mkdir5(contextDir, { recursive: true });
+    const contextDir = join9(localPath, "repowise-context");
+    await mkdir6(contextDir, { recursive: true });
     const updatedFiles = [];
     for (const file of files) {
       if (file.fileName.includes(".."))
@@ -4040,10 +4471,10 @@ async function fetchContextFromServer(repoId, localPath, apiUrl) {
         continue;
       }
       const content = await contentRes.text();
-      const filePath = join8(contextDir, file.fileName);
-      await mkdir5(dirname3(filePath), { recursive: true });
+      const filePath = join9(contextDir, file.fileName);
+      await mkdir6(dirname3(filePath), { recursive: true });
       const finalContent = file.fileName === "project-overview.md" ? injectAgentInstructions(content) : content;
-      await writeFile5(filePath, finalContent, "utf-8");
+      await writeFile6(filePath, finalContent, "utf-8");
       updatedFiles.push(file.fileName);
     }
     console.log(`Context fetch for ${repoId}: downloaded ${updatedFiles.length}/${files.length} file(s)`);
@@ -4059,12 +4490,12 @@ async function fetchContextFromServer(repoId, localPath, apiUrl) {
 init_process_manager();
 
 // ../listener/dist/lib/auto-updater.js
-import { execFile as execFile2 } from "child_process";
+import { execFile as execFile3 } from "child_process";
 import { readFileSync } from "fs";
 import { access as access2, constants, realpath } from "fs/promises";
-import { dirname as dirname4, join as join10 } from "path";
+import { dirname as dirname4, join as join11 } from "path";
 import { promisify as promisify2 } from "util";
-var execFileAsync2 = promisify2(execFile2);
+var execFileAsync2 = promisify2(execFile3);
 var installInFlight = false;
 async function installUpdate(currentVersion, packageName, targetVersion) {
   if (process.env["CI"] === "true")
@@ -4086,12 +4517,12 @@ async function installUpdate(currentVersion, packageName, targetVersion) {
   }
   installInFlight = true;
   try {
-    const npmWrapper = join10(dirname4(process.execPath), "npm");
+    const npmWrapper = join11(dirname4(process.execPath), "npm");
     const npmScript = await realpath(npmWrapper);
     const runNpm = (args) => execFileAsync2(process.execPath, [npmScript, ...args], { timeout: 6e4 });
     try {
       const { stdout: prefix } = await runNpm(["prefix", "-g"]);
-      const npmDir = join10(prefix.trim(), "lib", "node_modules");
+      const npmDir = join11(prefix.trim(), "lib", "node_modules");
       const checkDir = process.platform === "win32" ? prefix.trim() : npmDir;
       await access2(checkDir, constants.W_OK);
     } catch (err) {
@@ -4109,7 +4540,7 @@ async function installUpdate(currentVersion, packageName, targetVersion) {
     }
     try {
       const { stdout: prefix } = await runNpm(["prefix", "-g"]);
-      const installedPkgJson = join10(prefix.trim(), "lib", "node_modules", packageName, "package.json");
+      const installedPkgJson = join11(prefix.trim(), "lib", "node_modules", packageName, "package.json");
       const installedVersion = JSON.parse(readFileSync(installedPkgJson, "utf-8")).version;
       if (installedVersion !== targetVersion) {
         const msg = `post-install check failed: expected ${targetVersion}, found ${installedVersion ?? "unknown"}`;
@@ -4180,7 +4611,7 @@ function comparePrerelease(a, b) {
 import { createHash } from "crypto";
 import { lstat, open as open3, readdir as readdir2 } from "fs/promises";
 import { constants as fsConstants } from "fs";
-import { join as join11, resolve as pathResolve } from "path";
+import { join as join12, resolve as pathResolve } from "path";
 async function verifyBinary(check) {
   const fh = await open3(check.path, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
   const hash = createHash("sha256");
@@ -4230,7 +4661,7 @@ async function auditNativeBindings(rootDir, expected) {
       return;
     }
     for (const entryName of entries) {
-      const full = pathResolve(join11(dir, entryName));
+      const full = pathResolve(join12(dir, entryName));
       const entryStat = await lstat(full).catch(() => null);
       if (!entryStat)
         continue;
@@ -4271,8 +4702,8 @@ async function auditNativeBindings(rootDir, expected) {
 init_config_dir();
 init_process_manager();
 init_service_installer();
-import { unlink as unlink6 } from "fs/promises";
-import { join as join13 } from "path";
+import { unlink as unlink7 } from "fs/promises";
+import { join as join14 } from "path";
 async function getListenerStatus() {
   const pid = await readPid();
   if (pid !== null) {
@@ -4281,7 +4712,7 @@ async function getListenerStatus() {
       return { running: true, method: "pid", pid, serviceInstalled: serviceInstalled2 };
     }
     try {
-      await unlink6(join13(getConfigDir(), "listener.pid"));
+      await unlink7(join14(getConfigDir(), "listener.pid"));
     } catch {
     }
   }
@@ -4326,11 +4757,11 @@ async function stopListener() {
 
 // ../listener/dist/mcp/bootstrap.js
 init_config_dir();
-import { join as join21 } from "path";
+import { join as join22 } from "path";
 
 // ../listener/dist/lsp/workspace-session.js
 import { pathToFileURL } from "url";
-import { readFile as readFile6 } from "fs/promises";
+import { readFile as readFile7 } from "fs/promises";
 import { resolve as pathResolve2, sep as pathSep, dirname as dirname7 } from "path";
 
 // ../listener/dist/lsp/lsp-client.js
@@ -4776,7 +5207,7 @@ var WorkspaceManager = class {
     }
     const absolute = this.joinPath(session.repoRoot, repoRelativePath);
     const p = (async () => {
-      const text = await readFile6(absolute, "utf-8");
+      const text = await readFile7(absolute, "utf-8");
       session.client.notify("textDocument/didOpen", {
         textDocument: {
           uri,
@@ -5046,8 +5477,8 @@ function buildLspSpawnPath(basePath, nodeDir, lspBinDirs) {
 
 // ../listener/dist/mcp/graph-cache.js
 init_config_dir();
-import { readFile as readFile8, stat as stat3 } from "fs/promises";
-import { join as join19 } from "path";
+import { readFile as readFile9, stat as stat3 } from "fs/promises";
+import { join as join20 } from "path";
 var EVICT_DEBOUNCE_MS = 6e4;
 function assertSafeRepoId(repoId) {
   if (!repoId || typeof repoId !== "string") {
@@ -5062,13 +5493,13 @@ function assertSafeRepoId(repoId) {
 }
 function createGraphCache(options = {}) {
   const evictMs = options.evictDebounceMs ?? EVICT_DEBOUNCE_MS;
-  const resolvePath = options.resolveGraphPath ?? ((repoId) => join19(defaultRepoWiseHome(), "graphs", `${repoId}.json`));
+  const resolvePath = options.resolveGraphPath ?? ((repoId) => join20(defaultRepoWiseHome(), "graphs", `${repoId}.json`));
   const entries = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
   async function loadFromDisk(repoId) {
     const graphPath = resolvePath(repoId);
     const s = await stat3(graphPath);
-    const body = await readFile8(graphPath, "utf-8");
+    const body = await readFile9(graphPath, "utf-8");
     const graph = JSON.parse(body);
     if (graph.commitSha && Array.isArray(graph.edges)) {
       try {
@@ -5155,7 +5586,7 @@ function defaultRepoWiseHome() {
 }
 
 // ../listener/dist/mcp/graph-downloader.js
-import { mkdir as mkdir9, rename as rename3, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir10, rename as rename3, writeFile as writeFile10 } from "fs/promises";
 import { dirname as dirname9 } from "path";
 function createGraphDownloader(options) {
   const fetchFn = options.fetchImpl ?? fetch;
@@ -5207,9 +5638,9 @@ function createGraphDownloader(options) {
         message: `graph parse: ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    await mkdir9(dirname9(options.targetPath), { recursive: true });
+    await mkdir10(dirname9(options.targetPath), { recursive: true });
     const tmpPath = `${options.targetPath}.${Date.now()}.tmp`;
-    await writeFile9(tmpPath, body, { encoding: "utf-8", mode: 384 });
+    await writeFile10(tmpPath, body, { encoding: "utf-8", mode: 384 });
     await rename3(tmpPath, options.targetPath);
     options.graphCache.invalidate(options.repoId);
     lastSha = serverSha;
@@ -5232,7 +5663,7 @@ function createGraphDownloader(options) {
 
 // ../listener/dist/mcp/log-encryption.js
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
-import { mkdir as mkdir10, readFile as readFile9, stat as stat4, writeFile as writeFile10 } from "fs/promises";
+import { mkdir as mkdir11, readFile as readFile10, stat as stat4, writeFile as writeFile11 } from "fs/promises";
 import { dirname as dirname10 } from "path";
 var KEY_BYTES = 32;
 var IV_BYTES = 12;
@@ -5260,7 +5691,7 @@ function createFileKeyStore(keyPath) {
         return cached;
       let parsed = null;
       try {
-        const body = await readFile9(keyPath, "utf-8");
+        const body = await readFile10(keyPath, "utf-8");
         const decoded = Buffer.from(body.trim(), "base64");
         if (decoded.length === KEY_BYTES)
           parsed = decoded;
@@ -5280,9 +5711,9 @@ function createFileKeyStore(keyPath) {
         return parsed;
       }
       const fresh = randomBytes(KEY_BYTES);
-      await mkdir10(dirname10(keyPath), { recursive: true });
+      await mkdir11(dirname10(keyPath), { recursive: true });
       const tmp = `${keyPath}.tmp`;
-      await writeFile10(tmp, fresh.toString("base64") + "\n", {
+      await writeFile11(tmp, fresh.toString("base64") + "\n", {
         encoding: "utf-8",
         mode: 384
       });
@@ -5321,7 +5752,7 @@ function decryptLine(encoded, key) {
 }
 
 // ../listener/dist/mcp/mcp-logger.js
-import { appendFile, mkdir as mkdir11, stat as stat5, unlink as unlink8, writeFile as writeFile11, readFile as readFile10 } from "fs/promises";
+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";
 var DEFAULT_MAX_BYTES = 100 * 1024 * 1024;
 function createMcpLogger(options) {
@@ -5336,7 +5767,7 @@ function createMcpLogger(options) {
     if (legacyPath === options.filePath)
       return;
     try {
-      await unlink8(legacyPath);
+      await unlink9(legacyPath);
       console.log(`[mcp-logger] removed legacy plaintext log at ${legacyPath} (one-time migration)`);
     } catch {
     }
@@ -5345,7 +5776,7 @@ function createMcpLogger(options) {
     await migrateLegacyPlaintext();
     const key = await options.keyStore.getKey();
     const encoded = encryptLine(JSON.stringify(entry), key) + "\n";
-    await mkdir11(dirname11(options.filePath), { recursive: true });
+    await mkdir12(dirname11(options.filePath), { recursive: true });
     await appendFile(options.filePath, encoded, { encoding: "utf-8", mode: 384 });
     try {
       const s = await stat5(options.filePath);
@@ -5367,18 +5798,18 @@ function createMcpLogger(options) {
 }
 async function rotate(path, size) {
   const dropAt = Math.floor(size * 0.25);
-  const body = await readFile10(path, "utf-8");
+  const body = await readFile11(path, "utf-8");
   const idx = body.indexOf("\n", dropAt);
   if (idx < 0) {
-    await writeFile11(path, "", { encoding: "utf-8", mode: 384 });
+    await writeFile12(path, "", { encoding: "utf-8", mode: 384 });
     return;
   }
-  await writeFile11(path, body.slice(idx + 1), { encoding: "utf-8", mode: 384 });
+  await writeFile12(path, body.slice(idx + 1), { encoding: "utf-8", mode: 384 });
 }
 
 // ../listener/dist/mcp/mcp-log-uploader.js
 import { randomUUID } from "crypto";
-import { readFile as readFile11, writeFile as writeFile12, mkdir as mkdir12 } from "fs/promises";
+import { readFile as readFile12, writeFile as writeFile13, mkdir as mkdir13 } from "fs/promises";
 import { dirname as dirname12 } from "path";
 var DEFAULT_MAX_ENTRIES = 5e3;
 var DEFAULT_MAX_BYTES2 = 1 * 1024 * 1024;
@@ -5404,7 +5835,7 @@ function createMcpLogUploader(options) {
       }
       let body;
       try {
-        body = await readFile11(options.logFilePath, "utf-8");
+        body = await readFile12(options.logFilePath, "utf-8");
       } catch (err) {
         if (err.code === "ENOENT") {
           return { uploaded: 0, bytesAdvanced: 0 };
@@ -5521,7 +5952,7 @@ function pendingPath(watermarkPath) {
 }
 async function readPendingBatch(watermarkPath) {
   try {
-    const body = await readFile11(pendingPath(watermarkPath), "utf-8");
+    const body = await readFile12(pendingPath(watermarkPath), "utf-8");
     const trimmed = body.trim();
     return /^[A-Za-z0-9-]{8,128}$/.test(trimmed) ? trimmed : null;
   } catch {
@@ -5529,19 +5960,19 @@ async function readPendingBatch(watermarkPath) {
   }
 }
 async function writePendingBatch(watermarkPath, batchId) {
-  await mkdir12(dirname12(watermarkPath), { recursive: true });
-  await writeFile12(pendingPath(watermarkPath), batchId, { encoding: "utf-8", mode: 384 });
+  await mkdir13(dirname12(watermarkPath), { recursive: true });
+  await writeFile13(pendingPath(watermarkPath), batchId, { encoding: "utf-8", mode: 384 });
 }
 async function clearPendingBatch(watermarkPath) {
-  const { unlink: unlink11 } = await import("fs/promises");
+  const { unlink: unlink12 } = await import("fs/promises");
   try {
-    await unlink11(pendingPath(watermarkPath));
+    await unlink12(pendingPath(watermarkPath));
   } catch {
   }
 }
 async function readWatermark(path) {
   try {
-    const body = await readFile11(path, "utf-8");
+    const body = await readFile12(path, "utf-8");
     const parsed = Number.parseInt(body.trim(), 10);
     return Number.isFinite(parsed) && parsed >= 0 ? parsed : 0;
   } catch (err) {
@@ -5551,15 +5982,15 @@ async function readWatermark(path) {
   }
 }
 async function writeWatermark(path, offset) {
-  await mkdir12(dirname12(path), { recursive: true });
+  await mkdir13(dirname12(path), { recursive: true });
   const tmp = `${path}.tmp`;
-  await writeFile12(tmp, offset.toString() + "\n", { encoding: "utf-8", mode: 384 });
+  await writeFile13(tmp, offset.toString() + "\n", { encoding: "utf-8", mode: 384 });
   const { rename: rename5 } = await import("fs/promises");
   await rename5(tmp, path);
 }
 async function isLocallyConsented(flagPath2) {
   try {
-    const body = await readFile11(flagPath2, "utf-8");
+    const body = await readFile12(flagPath2, "utf-8");
     const parsed = JSON.parse(body);
     return parsed.enabled !== false;
   } catch {
@@ -5570,8 +6001,8 @@ async function isLocallyConsented(flagPath2) {
 // ../listener/dist/mcp/mcp-server.js
 init_config_dir();
 import { createServer } from "http";
-import { mkdir as mkdir13, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname13, join as join20 } from "path";
+import { mkdir as mkdir14, writeFile as writeFile14 } from "fs/promises";
+import { dirname as dirname13, join as join21 } from "path";
 import { createHash as createHash3, randomUUID as randomUUID2 } from "crypto";
 
 // ../listener/dist/mcp/sanitize.js
@@ -7089,8 +7520,8 @@ async function readJson(req) {
   }
 }
 async function writeEndpointFile(path, endpoint, secret) {
-  await mkdir13(dirname13(path), { recursive: true });
-  await writeFile13(path, formatEndpointFile({ endpoint, secret }), {
+  await mkdir14(dirname13(path), { recursive: true });
+  await writeFile14(path, formatEndpointFile({ endpoint, secret }), {
     encoding: "utf-8",
     mode: 384
   });
@@ -7103,7 +7534,7 @@ function extractBearer(header) {
   return m ? m[1] : null;
 }
 function defaultEndpointFile() {
-  return join20(getConfigDir(), "listener.endpoint");
+  return join21(getConfigDir(), "listener.endpoint");
 }
 
 // ../listener/dist/mcp/bootstrap.js
@@ -7111,7 +7542,7 @@ async function startMcp(options) {
   const disabled = process.env.REPOWISE_MCP_DISABLED === "true";
   const graphsDir = options.graphsDir ?? defaultGraphsDir();
   const graphCache = createGraphCache({
-    resolveGraphPath: (repoId) => join21(graphsDir, `${repoId}.json`)
+    resolveGraphPath: (repoId) => join22(graphsDir, `${repoId}.json`)
   });
   if (disabled) {
     return {
@@ -7134,12 +7565,12 @@ async function startMcp(options) {
   }
   const firstRepoLocal = options.repos.find((r) => r.localPath)?.localPath;
   const mcpHome = defaultMcpHome();
-  const logFilePath = join21(mcpHome, "mcp-log.jsonl.enc");
-  const keyStore = createFileKeyStore(join21(mcpHome, "mcp-log.key"));
+  const logFilePath = join22(mcpHome, "mcp-log.jsonl.enc");
+  const keyStore = createFileKeyStore(join22(mcpHome, "mcp-log.key"));
   const mcpLogger = createMcpLogger({ filePath: logFilePath, keyStore });
-  const flagFilePath = join21(mcpHome, "mcp-log.flag");
-  const watermarkFilePath = join21(mcpHome, "mcp-log.watermark");
-  const consentSentMarkerPath = join21(mcpHome, "mcp-log.consent-sent");
+  const flagFilePath = join22(mcpHome, "mcp-log.flag");
+  const watermarkFilePath = join22(mcpHome, "mcp-log.watermark");
+  const consentSentMarkerPath = join22(mcpHome, "mcp-log.consent-sent");
   let uploader = null;
   let lastConsentState = false;
   let serverConsentEnsuredThisProcess = false;
@@ -7186,7 +7617,7 @@ async function startMcp(options) {
       apiBaseUrl: repo.apiUrl,
       getAuthToken: options.getAuthToken,
       repoId: repo.repoId,
-      targetPath: join21(graphsDir, `${repo.repoId}.json`),
+      targetPath: join22(graphsDir, `${repo.repoId}.json`),
       graphCache,
       ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
     }));
@@ -7271,7 +7702,7 @@ async function startMcp(options) {
           apiBaseUrl: repo.apiUrl,
           getAuthToken: options.getAuthToken,
           repoId: repo.repoId,
-          targetPath: join21(graphsDir, `${repo.repoId}.json`),
+          targetPath: join22(graphsDir, `${repo.repoId}.json`),
           graphCache,
           ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
         }));
@@ -7292,15 +7723,15 @@ async function startMcp(options) {
   };
 }
 function defaultGraphsDir() {
-  return join21(getConfigDir(), "graphs");
+  return join22(getConfigDir(), "graphs");
 }
 function defaultMcpHome() {
   return getConfigDir();
 }
 async function logFileExists(path) {
   try {
-    const { stat: stat7 } = await import("fs/promises");
-    const s = await stat7(path);
+    const { stat: stat8 } = await import("fs/promises");
+    const s = await stat8(path);
     return s.size > 0;
   } catch {
     return false;
@@ -7333,10 +7764,10 @@ async function ensureServerConsent(opts) {
     });
     if (!res.ok)
       return;
-    const fs25 = await import("fs/promises");
+    const fs30 = await import("fs/promises");
     const path = await import("path");
-    await fs25.mkdir(path.dirname(opts.markerPath), { recursive: true });
-    await fs25.writeFile(opts.markerPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", {
+    await fs30.mkdir(path.dirname(opts.markerPath), { recursive: true });
+    await fs30.writeFile(opts.markerPath, (/* @__PURE__ */ new Date()).toISOString() + "\n", {
       encoding: "utf-8",
       mode: 384
     });
@@ -7346,11 +7777,11 @@ async function ensureServerConsent(opts) {
 
 // ../listener/dist/mcp/auto-config/index.js
 import { homedir as homedir5 } from "os";
-import { basename as basename2 } from "path";
+import { basename as basename3 } from "path";
 
 // ../listener/dist/mcp/auto-config/writers/claude-code.js
 import { promises as fs6 } from "fs";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 
 // ../listener/dist/mcp/auto-config/markers.js
 import { promises as fs5 } from "fs";
@@ -7430,10 +7861,10 @@ function safeExistingContent(path, current) {
 var claudeCodeWriter = {
   tool: "claude-code",
   async detect(repoRoot, home) {
-    return await fileExists2(join22(repoRoot, "CLAUDE.md")) || await hasClaudeBinary(home);
+    return await fileExists2(join23(repoRoot, "CLAUDE.md")) || await hasClaudeBinary(home);
   },
   async write(ctx) {
-    const path = join22(ctx.repoRoot, ".mcp.json");
+    const path = join23(ctx.repoRoot, ".mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -7443,7 +7874,7 @@ var claudeCodeWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join22(ctx.repoRoot, ".mcp.json");
+    const path = join23(ctx.repoRoot, ".mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -7457,31 +7888,23 @@ async function fileExists2(path) {
   }
 }
 async function hasClaudeBinary(home) {
-  return fileExists2(join22(home, ".claude", "claude.json"));
+  return fileExists2(join23(home, ".claude", "claude.json"));
 }
 
-// ../listener/dist/mcp/auto-config/writers/cline.js
+// ../listener/dist/mcp/auto-config/writers/claude-code-hooks.js
 import { promises as fs7 } from "fs";
-import { join as join23 } from "path";
-var clineWriter = {
-  tool: "cline",
+import { join as join24 } from "path";
+var claudeCodeHooksWriter = {
+  tool: "claude-code-hooks",
   async detect(repoRoot, home) {
-    return await fileExists3(join23(repoRoot, ".clinerules")) || await fileExists3(join23(home, ".cline"));
+    return await fileExists3(join24(repoRoot, "CLAUDE.md")) || await fileExists3(join24(home, ".claude.json"));
   },
   async write(ctx) {
-    const path = join23(ctx.home, ".cline", "mcp.json");
-    await removeFromConfig(path, `repowise-${ctx.repoId}`);
-    const status2 = await writeMergedConfig({
-      path,
-      serverName: `RepoWise MCP for ${ctx.repoName}`,
-      spec: { command: ctx.shimCmd, args: ["mcp-shim", "--repo-id", ctx.repoId] }
-    });
-    return { status: status2, path };
+    const result = await writeClaudeHooksToRepo(ctx.repoRoot, ctx.contextFolder ?? "repowise-context");
+    return { status: result.status, path: join24(ctx.repoRoot, result.relPath) };
   },
   async remove(ctx) {
-    const path = join23(ctx.home, ".cline", "mcp.json");
-    await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
-    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+    await removeClaudeHooksFromRepo(ctx.repoRoot);
   }
 };
 async function fileExists3(path) {
@@ -7493,16 +7916,16 @@ async function fileExists3(path) {
   }
 }
 
-// ../listener/dist/mcp/auto-config/writers/codex.js
+// ../listener/dist/mcp/auto-config/writers/cline.js
 import { promises as fs8 } from "fs";
-import { join as join24 } from "path";
-var codexWriter = {
-  tool: "codex",
-  async detect(_repoRoot, home) {
-    return fileExists4(join24(home, ".codex"));
+import { join as join25 } from "path";
+var clineWriter = {
+  tool: "cline",
+  async detect(repoRoot, home) {
+    return await fileExists4(join25(repoRoot, ".clinerules")) || await fileExists4(join25(home, ".cline"));
   },
   async write(ctx) {
-    const path = join24(ctx.home, ".codex", "mcp.json");
+    const path = join25(ctx.home, ".cline", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -7512,7 +7935,7 @@ var codexWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join24(ctx.home, ".codex", "mcp.json");
+    const path = join25(ctx.home, ".cline", "mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -7526,30 +7949,64 @@ async function fileExists4(path) {
   }
 }
 
-// ../listener/dist/mcp/auto-config/writers/copilot.js
+// ../listener/dist/mcp/auto-config/writers/cline-hooks.js
 import { promises as fs9 } from "fs";
-import { join as join25 } from "path";
-var copilotWriter = {
-  tool: "copilot",
+import { join as join26 } from "path";
+var SCRIPT_REL = ".clinerules/hooks/UserPromptSubmit";
+var OWNERSHIP_MARKER = "managed by RepoWise";
+var clineHooksWriter = {
+  tool: "cline-hooks",
   async detect(repoRoot) {
-    return fileExists5(join25(repoRoot, ".vscode"));
+    return fileExists5(join26(repoRoot, ".clinerules"));
   },
   async write(ctx) {
-    const path = join25(ctx.repoRoot, ".vscode", "mcp.json");
-    await removeFromConfig(path, `repowise-${ctx.repoId}`);
-    const status2 = await writeMergedConfig({
-      path,
-      serverName: `RepoWise MCP for ${ctx.repoName}`,
-      spec: { command: ctx.shimCmd, args: ["mcp-shim", "--repo-id", ctx.repoId] }
+    if (await isGitTracked(ctx.repoRoot, SCRIPT_REL)) {
+      await applyGitignoreChanges(ctx.repoRoot, { remove: [SCRIPT_REL] });
+      return {
+        status: "skipped",
+        reason: `${SCRIPT_REL} is git-tracked; update it manually to opt in`
+      };
+    }
+    const path = join26(ctx.repoRoot, SCRIPT_REL);
+    const next = buildClineHookScript({
+      repoName: ctx.repoName,
+      contextFolder: ctx.contextFolder ?? "repowise-context"
     });
-    return { status: status2, path };
+    const existing = await readOrNull(path);
+    if (existing !== null && !existing.includes(OWNERSHIP_MARKER)) {
+      return {
+        status: "skipped",
+        reason: `${SCRIPT_REL} exists and is user-authored; not overwriting`
+      };
+    }
+    if (existing === next) {
+      await ensureExecutable(path);
+      return { status: "unchanged", path };
+    }
+    await fs9.mkdir(join26(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 = join25(ctx.repoRoot, ".vscode", "mcp.json");
-    await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
-    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+    const path = join26(ctx.repoRoot, SCRIPT_REL);
+    const existing = await readOrNull(path);
+    if (existing !== null && existing.includes(OWNERSHIP_MARKER)) {
+      await fs9.unlink(path);
+    }
+    await applyGitignoreChanges(ctx.repoRoot, { remove: [SCRIPT_REL] });
   }
 };
+async function ensureExecutable(path) {
+  try {
+    const stat8 = await fs9.stat(path);
+    if ((stat8.mode & 73) === 0) {
+      await fs9.chmod(path, 493);
+    }
+  } catch {
+  }
+}
 async function fileExists5(path) {
   try {
     await fs9.access(path);
@@ -7558,17 +8015,24 @@ async function fileExists5(path) {
     return false;
   }
 }
+async function readOrNull(path) {
+  try {
+    return await fs9.readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
 
-// ../listener/dist/mcp/auto-config/writers/cursor.js
+// ../listener/dist/mcp/auto-config/writers/codex.js
 import { promises as fs10 } from "fs";
-import { join as join26 } from "path";
-var cursorWriter = {
-  tool: "cursor",
-  async detect(repoRoot) {
-    return await fileExists6(join26(repoRoot, ".cursor")) || await fileExists6(join26(repoRoot, ".cursorrules"));
+import { join as join27 } from "path";
+var codexWriter = {
+  tool: "codex",
+  async detect(_repoRoot, home) {
+    return fileExists6(join27(home, ".codex"));
   },
   async write(ctx) {
-    const path = join26(ctx.repoRoot, ".cursor", "mcp.json");
+    const path = join27(ctx.home, ".codex", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -7578,7 +8042,7 @@ var cursorWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join26(ctx.repoRoot, ".cursor", "mcp.json");
+    const path = join27(ctx.home, ".codex", "mcp.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
@@ -7592,28 +8056,54 @@ async function fileExists6(path) {
   }
 }
 
-// ../listener/dist/mcp/auto-config/writers/gemini-cli.js
+// ../listener/dist/mcp/auto-config/writers/codex-hooks.js
 import { promises as fs11 } from "fs";
-import { join as join27 } from "path";
-var geminiCliWriter = {
-  tool: "gemini-cli",
-  async detect(_repoRoot, home) {
-    return fileExists7(join27(home, ".gemini"));
+import { join as join28 } 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"));
   },
   async write(ctx) {
-    const path = join27(ctx.home, ".gemini", "settings.json");
-    await removeFromConfig(path, `repowise-${ctx.repoId}`);
-    const status2 = await writeMergedConfig({
-      path,
-      serverName: `RepoWise MCP for ${ctx.repoName}`,
-      spec: { command: ctx.shimCmd, args: ["mcp-shim", "--repo-id", ctx.repoId] }
+    const repoSignal = await fileExists7(join28(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" };
+    }
+    if (await isGitTracked(ctx.repoRoot, HOOKS_REL)) {
+      await applyGitignoreChanges(ctx.repoRoot, { remove: [HOOKS_REL] });
+      return {
+        status: "skipped",
+        reason: `${HOOKS_REL} is git-tracked; add the RepoWise UserPromptSubmit hook manually to opt in`
+      };
+    }
+    const path = join28(ctx.repoRoot, HOOKS_REL);
+    const existing = await readOrNull2(path);
+    const merged = mergeCodexHookSettings(existing, {
+      repoName: ctx.repoName,
+      contextFolder: ctx.contextFolder ?? "repowise-context"
     });
-    return { status: status2, path };
+    if (merged === existing) {
+      return { status: "unchanged", path };
+    }
+    await fs11.mkdir(join28(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 = join27(ctx.home, ".gemini", "settings.json");
-    await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
-    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+    const path = join28(ctx.repoRoot, HOOKS_REL);
+    const existing = await readOrNull2(path);
+    if (existing !== null) {
+      const next = removeCodexHookSettings(existing);
+      if (next === null) {
+        await fs11.unlink(path);
+      } else if (next !== existing) {
+        await fs11.writeFile(path, next, "utf-8");
+      }
+    }
+    await applyGitignoreChanges(ctx.repoRoot, { remove: [HOOKS_REL] });
   }
 };
 async function fileExists7(path) {
@@ -7624,19 +8114,24 @@ async function fileExists7(path) {
     return false;
   }
 }
-
-// ../listener/dist/mcp/auto-config/writers/roo.js
-import { promises as fs12 } from "fs";
-import { join as join28 } from "path";
-var rooWriter = {
-  tool: "roo",
-  async detect(repoRoot, home) {
-    return await fileExists8(join28(repoRoot, ".roo")) || await fileExists8(join28(home, ".roo"));
+async function readOrNull2(path) {
+  try {
+    return await fs11.readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/copilot.js
+import { promises as fs12 } from "fs";
+import { join as join29 } from "path";
+var copilotWriter = {
+  tool: "copilot",
+  async detect(repoRoot) {
+    return fileExists8(join29(repoRoot, ".vscode"));
   },
   async write(ctx) {
-    const repoConfig = join28(ctx.repoRoot, ".roo", "mcp.json");
-    const useRepoScope = await fileExists8(join28(ctx.repoRoot, ".roo"));
-    const path = useRepoScope ? repoConfig : join28(ctx.home, ".roo", "mcp.json");
+    const path = join29(ctx.repoRoot, ".vscode", "mcp.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -7646,12 +8141,9 @@ var rooWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const repoConfig = join28(ctx.repoRoot, ".roo", "mcp.json");
-    const homeConfig = join28(ctx.home, ".roo", "mcp.json");
-    await removeFromConfig(repoConfig, `RepoWise MCP for ${ctx.repoName}`);
-    await removeFromConfig(repoConfig, `repowise-${ctx.repoId}`);
-    await removeFromConfig(homeConfig, `RepoWise MCP for ${ctx.repoName}`);
-    await removeFromConfig(homeConfig, `repowise-${ctx.repoId}`);
+    const path = join29(ctx.repoRoot, ".vscode", "mcp.json");
+    await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
+    await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
 };
 async function fileExists8(path) {
@@ -7663,16 +8155,254 @@ async function fileExists8(path) {
   }
 }
 
-// ../listener/dist/mcp/auto-config/writers/windsurf.js
+// ../listener/dist/mcp/auto-config/writers/copilot-hooks.js
 import { promises as fs13 } from "fs";
-import { join as join29 } from "path";
+import { join as join30 } 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"));
+  },
+  async write(ctx) {
+    const path = join30(ctx.repoRoot, HOOKS_REL2);
+    const next = buildCopilotHooksFile({
+      repoName: ctx.repoName,
+      contextFolder: ctx.contextFolder ?? "repowise-context"
+    });
+    const existing = await readOrNull3(path);
+    if (await isGitTracked(ctx.repoRoot, HOOKS_REL2)) {
+      await applyGitignoreChanges(ctx.repoRoot, { remove: [HOOKS_REL2] });
+      if (existing === next) {
+        return { status: "unchanged", path };
+      }
+      return {
+        status: "skipped",
+        reason: `${HOOKS_REL2} is committed; not modifying a tracked file`
+      };
+    }
+    if (existing === next) {
+      return { status: "unchanged", path };
+    }
+    await fs13.mkdir(join30(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);
+    if (!await isGitTracked(ctx.repoRoot, HOOKS_REL2)) {
+      await fs13.unlink(path).catch(() => {
+      });
+    }
+    await applyGitignoreChanges(ctx.repoRoot, { remove: [HOOKS_REL2] });
+  }
+};
+async function fileExists9(path) {
+  try {
+    await fs13.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOrNull3(path) {
+  try {
+    return await fs13.readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/cursor.js
+import { promises as fs14 } from "fs";
+import { join as join31 } from "path";
+var cursorWriter = {
+  tool: "cursor",
+  async detect(repoRoot) {
+    return await fileExists10(join31(repoRoot, ".cursor")) || await fileExists10(join31(repoRoot, ".cursorrules"));
+  },
+  async write(ctx) {
+    const path = join31(ctx.repoRoot, ".cursor", "mcp.json");
+    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `RepoWise MCP for ${ctx.repoName}`,
+      spec: { command: ctx.shimCmd, args: ["mcp-shim", "--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    const path = join31(ctx.repoRoot, ".cursor", "mcp.json");
+    await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
+    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists10(path) {
+  try {
+    await fs14.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/gemini-cli.js
+import { promises as fs15 } from "fs";
+import { join as join32 } from "path";
+var geminiCliWriter = {
+  tool: "gemini-cli",
+  async detect(_repoRoot, home) {
+    return fileExists11(join32(home, ".gemini"));
+  },
+  async write(ctx) {
+    const path = join32(ctx.home, ".gemini", "settings.json");
+    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `RepoWise MCP for ${ctx.repoName}`,
+      spec: { command: ctx.shimCmd, args: ["mcp-shim", "--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    const path = join32(ctx.home, ".gemini", "settings.json");
+    await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
+    await removeFromConfig(path, `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists11(path) {
+  try {
+    await fs15.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/gemini-hooks.js
+import { promises as fs16 } from "fs";
+import { join as join33 } 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"));
+  },
+  async write(ctx) {
+    const repoSignal = await fileExists12(join33(ctx.repoRoot, ".gemini")) || await fileExists12(join33(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" };
+    }
+    if (await isGitTracked(ctx.repoRoot, SETTINGS_REL)) {
+      await applyGitignoreChanges(ctx.repoRoot, { remove: [SETTINGS_REL] });
+      return {
+        status: "skipped",
+        reason: `${SETTINGS_REL} is git-tracked; add the RepoWise BeforeAgent hook manually to opt in`
+      };
+    }
+    const path = join33(ctx.repoRoot, SETTINGS_REL);
+    const existing = await readOrNull4(path);
+    const merged = mergeGeminiHookSettings(existing, {
+      repoName: ctx.repoName,
+      contextFolder: ctx.contextFolder ?? "repowise-context"
+    });
+    if (merged === existing) {
+      return { status: "unchanged", path };
+    }
+    await fs16.mkdir(join33(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 existing = await readOrNull4(path);
+    if (existing !== null) {
+      const next = removeGeminiHookSettings(existing);
+      if (next === null) {
+        await fs16.unlink(path);
+      } else if (next !== existing) {
+        await fs16.writeFile(path, next, "utf-8");
+      }
+    }
+    await applyGitignoreChanges(ctx.repoRoot, { remove: [SETTINGS_REL] });
+  }
+};
+async function fileExists12(path) {
+  try {
+    await fs16.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOrNull4(path) {
+  try {
+    return await fs16.readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/roo.js
+import { promises as fs17 } from "fs";
+import { join as join34 } from "path";
+var rooWriter = {
+  tool: "roo",
+  async detect(repoRoot, home) {
+    return await fileExists13(join34(repoRoot, ".roo")) || await fileExists13(join34(home, ".roo"));
+  },
+  async write(ctx) {
+    const repoConfig = join34(ctx.repoRoot, ".roo", "mcp.json");
+    const before = await readOrNull5(repoConfig);
+    await this.remove(ctx);
+    const after = await readOrNull5(repoConfig);
+    return {
+      status: before === after ? "unchanged" : "written",
+      path: repoConfig
+    };
+  },
+  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");
+    for (const path of [repoConfig, homeConfig, homeSettings]) {
+      await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`).catch(() => {
+      });
+      await removeFromConfig(path, `repowise-${ctx.repoId}`).catch(() => {
+      });
+    }
+  }
+};
+async function fileExists13(path) {
+  try {
+    await fs17.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOrNull5(path) {
+  try {
+    return await fs17.readFile(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/windsurf.js
+import { promises as fs18 } from "fs";
+import { join as join35 } from "path";
 var windsurfWriter = {
   tool: "windsurf",
   async detect(_repoRoot, home) {
-    return fileExists9(join29(home, ".codeium", "windsurf"));
+    return fileExists14(join35(home, ".codeium", "windsurf"));
   },
   async write(ctx) {
-    const path = join29(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+    const path = join35(ctx.home, ".codeium", "windsurf", "mcp_config.json");
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
     const status2 = await writeMergedConfig({
       path,
@@ -7682,14 +8412,14 @@ var windsurfWriter = {
     return { status: status2, path };
   },
   async remove(ctx) {
-    const path = join29(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+    const path = join35(ctx.home, ".codeium", "windsurf", "mcp_config.json");
     await removeFromConfig(path, `RepoWise MCP for ${ctx.repoName}`);
     await removeFromConfig(path, `repowise-${ctx.repoId}`);
   }
 };
-async function fileExists9(path) {
+async function fileExists14(path) {
   try {
-    await fs13.access(path);
+    await fs18.access(path);
     return true;
   } catch {
     return false;
@@ -7699,11 +8429,16 @@ async function fileExists9(path) {
 // ../listener/dist/mcp/auto-config/writers/index.js
 var WRITERS = [
   claudeCodeWriter,
+  claudeCodeHooksWriter,
   clineWriter,
+  clineHooksWriter,
   codexWriter,
+  codexHooksWriter,
   copilotWriter,
+  copilotHooksWriter,
   cursorWriter,
   geminiCliWriter,
+  geminiHooksWriter,
   rooWriter,
   windsurfWriter
 ];
@@ -7732,10 +8467,12 @@ async function runAutoConfig(opts) {
     try {
       const outcome = await writer.write({
         repoRoot: opts.repoRoot,
-        repoName: basename2(opts.repoRoot),
+        repoName: basename3(opts.repoRoot),
         repoId: opts.repoId,
         shimCmd: opts.shimCmd,
-        home
+        home,
+        contextFolder: opts.contextFolder,
+        selectedTools: opts.selectedTools
       });
       results.push({ tool: writer.tool, detected: true, outcome });
     } catch (err) {
@@ -7755,8 +8492,8 @@ init_installer();
 // ../listener/dist/lsp/warm.js
 init_registry();
 init_lsp_tools();
-import { promises as fs14 } from "fs";
-import { join as join30 } from "path";
+import { promises as fs19 } from "fs";
+import { join as join36 } from "path";
 async function collectRepresentativeFiles(repoRoot) {
   const reps = /* @__PURE__ */ new Map();
   let inspected = 0;
@@ -7766,7 +8503,7 @@ async function collectRepresentativeFiles(repoRoot) {
       return;
     let entries;
     try {
-      entries = await fs14.readdir(dir);
+      entries = await fs19.readdir(dir);
     } catch {
       return;
     }
@@ -7788,7 +8525,7 @@ async function collectRepresentativeFiles(repoRoot) {
   await inspect(repoRoot, "");
   let topEntries = [];
   try {
-    topEntries = await fs14.readdir(repoRoot);
+    topEntries = await fs19.readdir(repoRoot);
   } catch {
     return reps;
   }
@@ -7797,10 +8534,10 @@ async function collectRepresentativeFiles(repoRoot) {
       continue;
     if (name === "node_modules" || name === "dist" || name === "build")
       continue;
-    const sub = join30(repoRoot, name);
+    const sub = join36(repoRoot, name);
     try {
-      const stat7 = await fs14.stat(sub);
-      if (stat7.isDirectory())
+      const stat8 = await fs19.stat(sub);
+      if (stat8.isDirectory())
         await inspect(sub, name);
     } catch {
     }
@@ -7813,8 +8550,8 @@ async function warmReposLsp(repos, workspaces, lspOverrides, isAvailable) {
     if (!repoRoot)
       continue;
     try {
-      const stat7 = await fs14.stat(repoRoot);
-      if (!stat7.isDirectory())
+      const stat8 = await fs19.stat(repoRoot);
+      if (!stat8.isDirectory())
         continue;
     } catch {
       continue;
@@ -7842,12 +8579,12 @@ async function warmReposLsp(repos, workspaces, lspOverrides, isAvailable) {
 
 // ../listener/dist/lib/workspace-prep.js
 init_config_dir();
-import { promises as fs15 } from "fs";
-import { spawn as spawn9, execFile as execFile4 } from "child_process";
+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 join31 } from "path";
+import { join as join37 } from "path";
 import { promisify as promisify3 } from "util";
-var execFileAsync3 = promisify3(execFile4);
+var execFileAsync3 = promisify3(execFile5);
 async function isCommandOnPath2(cmd) {
   try {
     await execFileAsync3("which", [cmd], { timeout: 2e3 });
@@ -7879,7 +8616,7 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
     ".repowise/compile_commands.json"
   ];
   for (const c of candidates) {
-    if (await fileExists10(repoRoot, c))
+    if (await fileExists15(repoRoot, c))
       return false;
   }
   const sources = [];
@@ -7899,7 +8636,7 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
       return;
     let ents;
     try {
-      ents = await fs15.readdir(dir, { withFileTypes: true });
+      ents = await fs20.readdir(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -7909,7 +8646,7 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
       if (e.isDirectory()) {
         if (skip.has(e.name) || e.name.startsWith("."))
           continue;
-        await rec(join31(dir, e.name));
+        await rec(join37(dir, e.name));
         continue;
       }
       const dot = e.name.lastIndexOf(".");
@@ -7918,7 +8655,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: join31(dir, e.name), ext });
+      sources.push({ path: join37(dir, e.name), ext });
     }
   }
   await rec(repoRoot);
@@ -7934,18 +8671,18 @@ async function maybeWriteClangdStub(repoRoot, repoId) {
       command: `${driver} ${std} -I. -I./include -c "${src}"`
     };
   });
-  const outDir = join31(repoRoot, ".repowise");
-  await fs15.mkdir(outDir, { recursive: true });
-  const outPath = join31(outDir, "compile_commands.json");
-  await fs15.writeFile(outPath, JSON.stringify(entries, null, 2));
+  const outDir = join37(repoRoot, ".repowise");
+  await fs20.mkdir(outDir, { recursive: true });
+  const outPath = join37(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)" : ""}`);
   return true;
 }
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
-async function fileExists10(repoRoot, name) {
+async function fileExists15(repoRoot, name) {
   try {
-    await fs15.access(join31(repoRoot, name));
+    await fs20.access(join37(repoRoot, name));
     return true;
   } catch {
     return false;
@@ -7953,10 +8690,10 @@ async function fileExists10(repoRoot, name) {
 }
 async function detectWorkspaceDeps(repoRoot) {
   const missing = [];
-  if (await fileExists10(repoRoot, "package.json")) {
+  if (await fileExists15(repoRoot, "package.json")) {
     let pkgRaw = "";
     try {
-      pkgRaw = await fs15.readFile(join31(repoRoot, "package.json"), "utf8");
+      pkgRaw = await fs20.readFile(join37(repoRoot, "package.json"), "utf8");
     } catch {
     }
     if (pkgRaw) {
@@ -7968,16 +8705,16 @@ async function detectWorkspaceDeps(repoRoot) {
       } catch {
       }
       if (hasFrameworkDep) {
-        const installed = await fileExists10(repoRoot, "node_modules/.package-lock.json") || await fileExists10(repoRoot, "node_modules/.modules.yaml") || await fileExists10(repoRoot, "node_modules/.yarn-integrity") || await fileExists10(repoRoot, "node_modules/.bun-tag");
+        const installed = await fileExists15(repoRoot, "node_modules/.package-lock.json") || await fileExists15(repoRoot, "node_modules/.modules.yaml") || await fileExists15(repoRoot, "node_modules/.yarn-integrity") || await fileExists15(repoRoot, "node_modules/.bun-tag");
         if (!installed) {
           let command = ["npm", "install", "--no-audit", "--no-fund"];
-          if (await fileExists10(repoRoot, "pnpm-lock.yaml")) {
+          if (await fileExists15(repoRoot, "pnpm-lock.yaml")) {
             command = ["pnpm", "install", "--frozen-lockfile"];
-          } else if (await fileExists10(repoRoot, "yarn.lock")) {
+          } else if (await fileExists15(repoRoot, "yarn.lock")) {
             command = ["yarn", "install", "--frozen-lockfile"];
-          } else if (await fileExists10(repoRoot, "bun.lock") || await fileExists10(repoRoot, "bun.lockb")) {
+          } else if (await fileExists15(repoRoot, "bun.lock") || await fileExists15(repoRoot, "bun.lockb")) {
             command = ["bun", "install", "--frozen-lockfile"];
-          } else if (await fileExists10(repoRoot, "package-lock.json")) {
+          } else if (await fileExists15(repoRoot, "package-lock.json")) {
             command = ["npm", "ci"];
           }
           missing.push({
@@ -7990,8 +8727,8 @@ async function detectWorkspaceDeps(repoRoot) {
       }
     }
   }
-  if (await fileExists10(repoRoot, "Gemfile")) {
-    const installed = await fileExists10(repoRoot, "Gemfile.lock") && (await fileExists10(repoRoot, "vendor/bundle") || await fileExists10(repoRoot, ".bundle/config"));
+  if (await fileExists15(repoRoot, "Gemfile")) {
+    const installed = await fileExists15(repoRoot, "Gemfile.lock") && (await fileExists15(repoRoot, "vendor/bundle") || await fileExists15(repoRoot, ".bundle/config"));
     if (!installed) {
       missing.push({
         ecosystem: "bundler",
@@ -8001,7 +8738,7 @@ async function detectWorkspaceDeps(repoRoot) {
       });
     }
   }
-  if (await fileExists10(repoRoot, "Cargo.toml")) {
+  if (await fileExists15(repoRoot, "Cargo.toml")) {
     missing.push({
       ecosystem: "cargo",
       artefactName: "cargo registry cache",
@@ -8009,8 +8746,8 @@ async function detectWorkspaceDeps(repoRoot) {
       command: ["cargo", "metadata", "--format-version", "1", "--offline=false"]
     });
   }
-  if (await fileExists10(repoRoot, "pubspec.yaml")) {
-    if (!await fileExists10(repoRoot, ".dart_tool/package_config.json")) {
+  if (await fileExists15(repoRoot, "pubspec.yaml")) {
+    if (!await fileExists15(repoRoot, ".dart_tool/package_config.json")) {
       missing.push({
         ecosystem: "dart-pub",
         artefactName: ".dart_tool/",
@@ -8019,7 +8756,7 @@ async function detectWorkspaceDeps(repoRoot) {
       });
     }
   }
-  if (await fileExists10(repoRoot, "pom.xml")) {
+  if (await fileExists15(repoRoot, "pom.xml")) {
     missing.push({
       ecosystem: "maven",
       artefactName: "maven (manual)",
@@ -8027,7 +8764,7 @@ async function detectWorkspaceDeps(repoRoot) {
       command: []
     });
   }
-  if (await fileExists10(repoRoot, "build.gradle") || await fileExists10(repoRoot, "build.gradle.kts")) {
+  if (await fileExists15(repoRoot, "build.gradle") || await fileExists15(repoRoot, "build.gradle.kts")) {
     missing.push({
       ecosystem: "gradle",
       artefactName: "gradle (manual)",
@@ -8035,8 +8772,8 @@ async function detectWorkspaceDeps(repoRoot) {
       command: []
     });
   }
-  if (await fileExists10(repoRoot, "build.sbt")) {
-    const hasBloop = await fileExists10(repoRoot, ".bloop");
+  if (await fileExists15(repoRoot, "build.sbt")) {
+    const hasBloop = await fileExists15(repoRoot, ".bloop");
     if (hasBloop) {
       missing.push({
         ecosystem: "sbt",
@@ -8059,8 +8796,8 @@ async function runWorkspacePreps(opts) {
   if (opts.missing.length === 0)
     return [];
   const safeRepoId = opts.repoId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  const logPath2 = join31(getConfigDir(), `install-log.${safeRepoId}.txt`);
-  await fs15.mkdir(getConfigDir(), { recursive: true });
+  const logPath2 = join37(getConfigDir(), `install-log.${safeRepoId}.txt`);
+  await fs20.mkdir(getConfigDir(), { recursive: true });
   const stream = opts.logStream ?? createWriteStream2(logPath2, { flags: "a" });
   stream.on("error", () => {
   });
@@ -8206,11 +8943,104 @@ async function prepareWorkspaceDepsForRepos(repos) {
   }
 }
 
+// ../listener/dist/lsp/build-orchestrator.js
+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 { promisify as promisify4 } from "util";
+var execFile6 = promisify4(execFileCb);
+var DEFAULT_BUILD_TIMEOUT_MS = 10 * 60 * 1e3;
+async function isCommandOnPath3(command) {
+  try {
+    await execFile6(process.platform === "win32" ? "where" : "which", [command], {
+      timeout: 5e3
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasBuildableManifest(root, language) {
+  const spec = getBuildSpec(language);
+  if (!spec)
+    return false;
+  let entries;
+  try {
+    entries = await readdir4(root);
+  } catch {
+    return false;
+  }
+  return spec.manifests.some((m) => m.startsWith("*.") ? entries.some((e) => e.endsWith(m.slice(1))) : entries.includes(m));
+}
+async function ensureIndexable(indexRoot, language, options = {}) {
+  const spec = getBuildSpec(language);
+  if (!spec)
+    return { ready: true };
+  if (!await hasBuildableManifest(indexRoot, language)) {
+    return { ready: true };
+  }
+  if (spec.platform && (options.platform ?? process.platform) !== spec.platform) {
+    return { ready: false, reason: "no-toolchain" };
+  }
+  const probe = options.isOnPath ?? isCommandOnPath3;
+  for (const cmd of spec.gateCommands) {
+    if (!await probe(cmd)) {
+      console.warn(`[build-orchestrator] ${language}: '${cmd}' not on PATH \u2014 skipping build (AST-only for this language)`);
+      return { ready: false, reason: "no-toolchain" };
+    }
+  }
+  const exec2 = options.execImpl ?? execFile6;
+  for (const gate of spec.gateExecs) {
+    try {
+      await exec2(gate.command, [...gate.args], { timeout: 15e3 });
+    } catch {
+      console.warn(`[build-orchestrator] ${language}: '${gate.command} ${gate.args.join(" ")}' failed \u2014 skipping build`);
+      return { ready: false, reason: "no-toolchain" };
+    }
+  }
+  try {
+    await access3(join38(indexRoot, spec.indexStoreProbe));
+    return { ready: true, built: false };
+  } catch {
+  }
+  const timeoutMs = options.timeoutMs ?? DEFAULT_BUILD_TIMEOUT_MS;
+  const spawnImpl = options.spawnImpl ?? spawn10;
+  const ok = await new Promise((resolve5) => {
+    const child = spawnImpl(spec.command, [...spec.args], {
+      cwd: indexRoot,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const killTimer = setTimeout(() => {
+      console.warn(`[build-orchestrator] ${language}: build exceeded ${(timeoutMs / 1e3).toString()}s \u2014 killing (AST-only)`);
+      child.kill("SIGKILL");
+    }, timeoutMs);
+    const onChunk = () => {
+      options.onActivity?.();
+    };
+    child.stdout?.on("data", onChunk);
+    child.stderr?.on("data", onChunk);
+    child.on("error", () => {
+      clearTimeout(killTimer);
+      resolve5(false);
+    });
+    child.on("close", (code) => {
+      clearTimeout(killTimer);
+      resolve5(code === 0);
+    });
+  });
+  if (!ok) {
+    return { ready: false, reason: "build-failed" };
+  }
+  console.log(`[build-orchestrator] ${language}: cold build complete at ${indexRoot}`);
+  return { ready: true, built: true };
+}
+
 // ../listener/dist/typed-resolution/resolver-loop.js
 init_src();
 init_registry();
-import { execFile as execFileCb } from "child_process";
-import { promisify as promisify4 } from "util";
+import { execFile as execFileCb2 } from "child_process";
+import { promisify as promisify5 } from "util";
 
 // ../listener/dist/typed-resolution/lsp-upgrade-strategy.js
 var goStrategy = {
@@ -8686,13 +9516,13 @@ async function resolveReceiverViaStrategy(session, uri, receiver, repoRoot, opts
 init_sidecar_cache();
 init_sidecar_client();
 var BREAKER_TRIP_THRESHOLD = 3;
-var execFile5 = promisify4(execFileCb);
-async function isCommandOnPath3(command) {
+var execFile7 = promisify5(execFileCb2);
+async function isCommandOnPath4(command) {
   if (/[^\w./+-]/.test(command))
     return false;
   const probeCmd = process.platform === "win32" ? "where" : "which";
   try {
-    await execFile5(probeCmd, [command], { timeout: 5e3 });
+    await execFile7(probeCmd, [command], { timeout: 5e3 });
     return true;
   } catch {
     return false;
@@ -8700,7 +9530,7 @@ async function isCommandOnPath3(command) {
 }
 async function isWorkingTreeAtCommit(repoRoot, commitSha) {
   try {
-    const { stdout } = await execFile5("git", ["-C", repoRoot, "rev-parse", "HEAD"], {
+    const { stdout } = await execFile7("git", ["-C", repoRoot, "rev-parse", "HEAD"], {
       timeout: 5e3
     });
     const head = stdout.trim();
@@ -8733,85 +9563,52 @@ async function runProducerCycle(input, fetchImpl = fetch) {
   const breakerOpenEvents = {};
   const pathProbeCache = /* @__PURE__ */ new Map();
   const missingBinaryLanguages = /* @__PURE__ */ new Set();
-  const sidecar = await buildSidecar({
-    receivers,
-    producer: input.producer,
-    languages: [],
-    // populated below by mutating after observation
-    // Item 14 — fan out across languages so pyright + gopls + tsserver
-    // run in parallel. The groupKey is the detected language; serial
-    // within a language so we don't overwhelm a single LSP server.
-    groupKey: (receiver) => detectLanguage(receiver.filePath),
-    resolve: async (receiver) => {
-      const cached = warmCacheIndex.get(typedResolutionKey(receiver.filePath, receiver.propertyName, receiver.line, receiver.column));
-      if (cached) {
-        warmHits += 1;
-        return cached.targetSymbolId;
+  const resolveOneReceiver = async (receiver) => {
+    const cached = warmCacheIndex.get(typedResolutionKey(receiver.filePath, receiver.propertyName, receiver.line, receiver.column));
+    if (cached) {
+      warmHits += 1;
+      return cached.targetSymbolId;
+    }
+    const language = detectLanguage(receiver.filePath);
+    if (!language)
+      return null;
+    seenLanguages.add(language);
+    if (trippedLanguages.has(language))
+      return null;
+    if (missingBinaryLanguages.has(language))
+      return null;
+    const config2 = getEffectiveConfig(language, process.env, input.lspOverrides);
+    if (!config2)
+      return null;
+    let onPath = pathProbeCache.get(language);
+    if (onPath === void 0) {
+      const probe = input.isOnPath ?? isCommandOnPath4;
+      onPath = await probe(config2.command);
+      pathProbeCache.set(language, onPath);
+      if (!onPath) {
+        missingBinaryLanguages.add(language);
+        console.warn(`[typed-resolution] ${language}: ${config2.command} not on PATH \u2014 skipping LSP upgrade for this cycle. install: ${config2.installHint}`);
       }
-      const language = detectLanguage(receiver.filePath);
-      if (!language)
-        return null;
-      seenLanguages.add(language);
-      if (trippedLanguages.has(language))
-        return null;
-      if (missingBinaryLanguages.has(language))
-        return null;
-      const config2 = getEffectiveConfig(language, process.env, input.lspOverrides);
-      if (!config2)
-        return null;
-      let onPath = pathProbeCache.get(language);
-      if (onPath === void 0) {
-        const probe = input.isOnPath ?? isCommandOnPath3;
-        onPath = await probe(config2.command);
-        pathProbeCache.set(language, onPath);
-        if (!onPath) {
-          missingBinaryLanguages.add(language);
-          console.warn(`[typed-resolution] ${language}: ${config2.command} not on PATH \u2014 skipping LSP upgrade for this cycle. install: ${config2.installHint}`);
+    }
+    if (!onPath)
+      return null;
+    try {
+      const session = await input.workspaces.getOrOpen({
+        repoRoot: input.repoRoot,
+        language,
+        config: config2
+      });
+      const uri = await input.workspaces.ensureOpen(session, receiver.filePath);
+      let methodErrorsForReceiver = 0;
+      const attempt = await resolveReceiverViaStrategy(session, uri, receiver, input.repoRoot, {
+        onMethodError: () => {
+          methodErrorsForReceiver += 1;
         }
-      }
-      if (!onPath)
-        return null;
-      try {
-        const session = await input.workspaces.getOrOpen({
-          repoRoot: input.repoRoot,
-          language,
-          config: config2
-        });
-        const uri = await input.workspaces.ensureOpen(session, receiver.filePath);
-        let methodErrorsForReceiver = 0;
-        const attempt = await resolveReceiverViaStrategy(session, uri, receiver, input.repoRoot, {
-          onMethodError: () => {
-            methodErrorsForReceiver += 1;
-          }
-        });
-        const hasResult = attempt !== null && (attempt.targetSymbolId !== null || attempt.targets.length > 0);
-        if (hasResult) {
-          consecutiveFailures.set(language, 0);
-        } else if (methodErrorsForReceiver > 0) {
-          const next = (consecutiveFailures.get(language) ?? 0) + 1;
-          consecutiveFailures.set(language, next);
-          if (next >= BREAKER_TRIP_THRESHOLD && !trippedLanguages.has(language)) {
-            trippedLanguages.add(language);
-            breakerOpenEvents[language] = (breakerOpenEvents[language] ?? 0) + 1;
-            console.warn(`[typed-resolution] breaker tripped for language=${language} after ${next.toString()} consecutive failures \u2014 skipping further LSP calls this cycle`);
-          }
-          return null;
-        } else {
-          consecutiveFailures.set(language, 0);
-          return null;
-        }
-        const lookupKey = typedResolutionKey(receiver.filePath, receiver.propertyName, receiver.line, receiver.column);
-        const schemaKind = attempt.kind === "definition" || attempt.kind === "implementation" || attempt.kind === "typeDefinition" || attempt.kind === "workspace-symbol-fallback" ? attempt.kind : void 0;
-        telemetryByKey.set(lookupKey, {
-          kind: schemaKind,
-          lspMethod: attempt.method,
-          targets: attempt.targets.length > 0 ? attempt.targets : void 0,
-          lspLatencyMs: attempt.lspLatencyMs,
-          confidence: attempt.targets.length > 1 ? attempt.baseConfidence / attempt.targets.length : attempt.baseConfidence
-        });
-        return attempt.targetSymbolId;
-      } catch (err) {
-        console.warn(`[typed-resolution] LSP query failed for ${receiver.filePath}:${receiver.line.toString()}:${receiver.column.toString()} property=${receiver.propertyName} errMsg=${err instanceof Error ? err.message : String(err)}`);
+      });
+      const hasResult = attempt !== null && (attempt.targetSymbolId !== null || attempt.targets.length > 0);
+      if (hasResult) {
+        consecutiveFailures.set(language, 0);
+      } else if (methodErrorsForReceiver > 0) {
         const next = (consecutiveFailures.get(language) ?? 0) + 1;
         consecutiveFailures.set(language, next);
         if (next >= BREAKER_TRIP_THRESHOLD && !trippedLanguages.has(language)) {
@@ -8820,7 +9617,52 @@ async function runProducerCycle(input, fetchImpl = fetch) {
           console.warn(`[typed-resolution] breaker tripped for language=${language} after ${next.toString()} consecutive failures \u2014 skipping further LSP calls this cycle`);
         }
         return null;
+      } else {
+        consecutiveFailures.set(language, 0);
+        return null;
+      }
+      const lookupKey = typedResolutionKey(receiver.filePath, receiver.propertyName, receiver.line, receiver.column);
+      const schemaKind = attempt.kind === "definition" || attempt.kind === "implementation" || attempt.kind === "typeDefinition" || attempt.kind === "workspace-symbol-fallback" ? attempt.kind : void 0;
+      telemetryByKey.set(lookupKey, {
+        kind: schemaKind,
+        lspMethod: attempt.method,
+        targets: attempt.targets.length > 0 ? attempt.targets : void 0,
+        lspLatencyMs: attempt.lspLatencyMs,
+        confidence: attempt.targets.length > 1 ? attempt.baseConfidence / attempt.targets.length : attempt.baseConfidence
+      });
+      return attempt.targetSymbolId;
+    } catch (err) {
+      console.warn(`[typed-resolution] LSP query failed for ${receiver.filePath}:${receiver.line.toString()}:${receiver.column.toString()} property=${receiver.propertyName} errMsg=${err instanceof Error ? err.message : String(err)}`);
+      const next = (consecutiveFailures.get(language) ?? 0) + 1;
+      consecutiveFailures.set(language, next);
+      if (next >= BREAKER_TRIP_THRESHOLD && !trippedLanguages.has(language)) {
+        trippedLanguages.add(language);
+        breakerOpenEvents[language] = (breakerOpenEvents[language] ?? 0) + 1;
+        console.warn(`[typed-resolution] breaker tripped for language=${language} after ${next.toString()} consecutive failures \u2014 skipping further LSP calls this cycle`);
       }
+      return null;
+    }
+  };
+  let processedCount = 0;
+  let resolvedOkCount = 0;
+  const sidecar = await buildSidecar({
+    receivers,
+    producer: input.producer,
+    languages: [],
+    // populated below by mutating after observation
+    // Item 14 — fan out across languages so pyright + gopls + tsserver
+    // run in parallel. The groupKey is the detected language; serial
+    // within a language so we don't overwhelm a single LSP server.
+    groupKey: (receiver) => detectLanguage(receiver.filePath),
+    // Phase 4 — instrument per-receiver progress for the wait-status
+    // reporter (resolved deltas drive the server's stall verdict).
+    resolve: async (receiver) => {
+      const out = await resolveOneReceiver(receiver);
+      processedCount += 1;
+      if (out !== null)
+        resolvedOkCount += 1;
+      input.onReceiverProcessed?.(processedCount, receivers.length, resolvedOkCount);
+      return out;
     }
   });
   const enriched = sidecar.resolutions.map((entry) => {
@@ -8879,6 +9721,234 @@ async function runDownloaderCycle(input, fetchImpl = fetch) {
   return { downloaded: true, edgesUpgraded: result.edgesUpgraded };
 }
 
+// ../listener/dist/typed-resolution/committed-checkout.js
+init_config_dir();
+import { execFile as execFileCb3 } from "child_process";
+import { createHash as createHash4 } from "crypto";
+import { mkdir as mkdir15, readdir as readdir5, rm, stat as stat6 } from "fs/promises";
+import { join as join39 } 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");
+}
+async function reapOrphanWorktrees(maxAgeMs = 24 * 60 * 60 * 1e3, base = worktreeBaseDir()) {
+  let reaped = 0;
+  let entries;
+  try {
+    entries = await readdir5(base);
+  } catch {
+    return 0;
+  }
+  const cutoff = Date.now() - maxAgeMs;
+  for (const entry of entries) {
+    const dir = join39(base, entry);
+    try {
+      const info = await stat6(dir);
+      if (!info.isDirectory() || info.mtimeMs > cutoff)
+        continue;
+      await rm(dir, { recursive: true, force: true });
+      reaped += 1;
+    } catch {
+    }
+  }
+  if (reaped > 0) {
+    console.log(`[typed-resolution] reaped ${reaped.toString()} orphaned LSP worktree(s)`);
+  }
+  return reaped;
+}
+async function prepareCommittedTree(repoRoot, commitSha, options = {}) {
+  const exec2 = options.execImpl ?? execFile8;
+  const git = (args) => exec2("git", args, { timeout: GIT_OP_TIMEOUT_MS });
+  try {
+    const { stdout: headRaw } = await git(["-C", repoRoot, "rev-parse", "HEAD"]);
+    const head = headRaw.trim();
+    const atCommit = head === commitSha || head.startsWith(commitSha) || commitSha.startsWith(head);
+    if (atCommit) {
+      const { stdout: status2 } = await git(["-C", repoRoot, "status", "--porcelain"]);
+      if (status2.trim().length === 0) {
+        return { indexRoot: repoRoot, reused: true, cleanup: () => Promise.resolve() };
+      }
+    }
+  } catch {
+    return null;
+  }
+  const base = options.worktreeBase ?? worktreeBaseDir();
+  const dirName = createHash4("sha256").update(`${repoRoot}\0${commitSha}`).digest("hex").slice(0, 16) + "-" + commitSha.slice(0, 12);
+  const worktreePath = join39(base, dirName);
+  try {
+    await mkdir15(base, { recursive: true });
+    await git(["-C", repoRoot, "worktree", "prune"]).catch(() => void 0);
+    const existing = await readdir5(base).catch(() => []);
+    const max = options.maxConcurrentWorktrees ?? MAX_CONCURRENT_WORKTREES;
+    if (!existing.includes(dirName) && existing.length >= max) {
+      console.warn(`[typed-resolution] worktree budget exceeded (${existing.length.toString()}/${max.toString()}) \u2014 proceeding AST-only`);
+      return null;
+    }
+    if (!existing.includes(dirName)) {
+      await git(["-C", repoRoot, "worktree", "add", "--detach", worktreePath, commitSha]);
+    }
+    const cleanup = async () => {
+      try {
+        await exec2("git", ["-C", repoRoot, "worktree", "remove", "--force", worktreePath], {
+          timeout: GIT_OP_TIMEOUT_MS
+        });
+      } catch {
+      }
+      await rm(worktreePath, { recursive: true, force: true }).catch(() => void 0);
+      await exec2("git", ["-C", repoRoot, "worktree", "prune"], {
+        timeout: GIT_OP_TIMEOUT_MS
+      }).catch(() => void 0);
+    };
+    return { indexRoot: worktreePath, reused: false, cleanup };
+  } catch (err) {
+    console.warn(`[typed-resolution] committed checkout failed \u2014 proceeding AST-only: ${err instanceof Error ? err.message : String(err)}`);
+    await rm(worktreePath, { recursive: true, force: true }).catch(() => void 0);
+    return null;
+  }
+}
+
+// ../listener/dist/typed-resolution/status-reporter.js
+var REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_INTERVAL_MS = 6e4;
+var NO_WAIT_STOP_THRESHOLD = 2;
+function createStatusReporter(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const url = `${options.apiUrl.replace(/\/+$/, "")}/v1/listeners/typed-resolution-status`;
+  let timer = null;
+  let pollSeq = 0;
+  let lastResolvedCount = 0;
+  let consecutiveNoWait = 0;
+  let stopped = false;
+  let lastPostFailed = false;
+  async function post(state, snapshot, resolvedDelta) {
+    pollSeq += 1;
+    const body = JSON.stringify({
+      repoId: options.repoId,
+      commitSha: options.commitSha,
+      state,
+      resolvedDelta,
+      remainingReceivers: snapshot.remainingReceivers,
+      indexingActive: snapshot.indexingActive,
+      pollSeq
+    });
+    const attempt = async (token) => {
+      const ctrl = new AbortController();
+      const t = setTimeout(() => {
+        ctrl.abort();
+      }, REQUEST_TIMEOUT_MS);
+      try {
+        return await fetchImpl(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${token}`
+          },
+          body,
+          signal: ctrl.signal
+        });
+      } finally {
+        clearTimeout(t);
+      }
+    };
+    lastPostFailed = false;
+    try {
+      let res = await attempt(await options.getAuthToken());
+      if ((res.status === 401 || res.status === 403) && options.getAuthTokenForceRefresh) {
+        res = await attempt(await options.getAuthTokenForceRefresh());
+      }
+      if (!res.ok) {
+        lastPostFailed = true;
+        console.warn(`[typed-resolution] status push failed: HTTP ${res.status.toString()} (server silence window is the backstop)`);
+        return;
+      }
+      const payload = await res.json().catch(() => null);
+      const data = payload?.data;
+      if (data?.accepted === false && data.reason === "disabled") {
+        consecutiveNoWait += 1;
+        if (consecutiveNoWait >= NO_WAIT_STOP_THRESHOLD && timer) {
+          clearInterval(timer);
+          timer = null;
+        }
+      } else {
+        consecutiveNoWait = 0;
+      }
+    } catch (err) {
+      lastPostFailed = true;
+      console.warn(`[typed-resolution] status push error (ignored): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  function tick() {
+    const snapshot = options.getSnapshot();
+    const delta = Math.max(0, snapshot.resolvedCount - lastResolvedCount);
+    lastResolvedCount = snapshot.resolvedCount;
+    void post(delta > 0 ? "progressing" : "stalled", snapshot, delta);
+  }
+  return {
+    start() {
+      if (timer || stopped)
+        return;
+      tick();
+      timer = setInterval(tick, options.intervalMs ?? DEFAULT_INTERVAL_MS);
+    },
+    async reportCompleted() {
+      this.stop();
+      const snapshot = options.getSnapshot();
+      const delta = Math.max(0, snapshot.resolvedCount - lastResolvedCount);
+      await post("completed", snapshot, delta);
+      if (lastPostFailed)
+        await post("completed", snapshot, delta);
+    },
+    async reportCrashed() {
+      this.stop();
+      await post("crashed", options.getSnapshot(), 0);
+      if (lastPostFailed)
+        await post("crashed", options.getSnapshot(), 0);
+    },
+    stop() {
+      stopped = true;
+      if (timer) {
+        clearInterval(timer);
+        timer = null;
+      }
+    }
+  };
+}
+
+// ../listener/dist/typed-resolution/graph-fetch.js
+var REQUEST_TIMEOUT_MS2 = 3e4;
+async function fetchProducerGraph(apiUrl, authToken, repoId, fetchImpl = fetch) {
+  const url = `${apiUrl.replace(/\/+$/, "")}/v1/repos/${encodeURIComponent(repoId)}/graph`;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => {
+    ctrl.abort();
+  }, REQUEST_TIMEOUT_MS2);
+  try {
+    const res = await fetchImpl(url, {
+      headers: { Authorization: `Bearer ${authToken}` },
+      signal: ctrl.signal
+    });
+    if (!res.ok) {
+      console.warn(`[typed-resolution] graph fetch failed: HTTP ${res.status.toString()}`);
+      return null;
+    }
+    const parsed = await res.json();
+    if (typeof parsed !== "object" || parsed === null)
+      return null;
+    const graph = parsed;
+    if (typeof graph.commitSha !== "string" || graph.commitSha.length === 0)
+      return null;
+    return graph;
+  } catch (err) {
+    console.warn(`[typed-resolution] graph fetch error: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // ../listener/dist/typed-resolution/hooks.js
 function buildTypedResolutionHooks(options) {
   const producer = options.producer ?? "repowise-listener/0.0.0";
@@ -8921,6 +9991,102 @@ function buildTypedResolutionHooks(options) {
         ...lspOverrides ? { lspOverrides } : {}
       });
     },
+    async onSidecarRequested(repoId, commitSha, localPath) {
+      if (!await hasBuildableManifest(localPath, "swift")) {
+        return;
+      }
+      console.log(`[typed-resolution] sidecar.requested for ${repoId}@${commitSha.slice(0, 12)} \u2014 preparing Swift build`);
+      const prepared = await prepareCommittedTree(localPath, commitSha);
+      if (!prepared)
+        return;
+      const result = await ensureIndexable(prepared.indexRoot, "swift");
+      if (!result.ready) {
+        console.warn(`[typed-resolution] Swift prep for ${repoId} skipped: ${result.reason ?? "unknown"} (AST-only for swift)`);
+        await prepared.cleanup().catch(() => void 0);
+      }
+    },
+    async onGraphReady(repoId, commitSha, localPath) {
+      const apiUrl = options.repoApiUrls.get(repoId);
+      if (!apiUrl)
+        return;
+      const token = await resolveToken();
+      if (!token)
+        return;
+      const graph = await fetchProducerGraph(apiUrl, token, repoId);
+      const shaMatches = graph !== null && (graph.commitSha === commitSha || graph.commitSha.startsWith(commitSha) || commitSha.startsWith(graph.commitSha));
+      if (!graph || !shaMatches) {
+        console.warn(`[typed-resolution] graph.ready for ${repoId}@${commitSha.slice(0, 12)} but fetched graph is ${graph ? `at ${graph.commitSha.slice(0, 12)}` : "missing"} \u2014 skipping`);
+        return;
+      }
+      const receivers = graph.unresolvedReceivers ?? [];
+      const snapshot = {
+        resolvedCount: 0,
+        remainingReceivers: receivers.length,
+        // Until the first receiver completes, session spawn + server
+        // indexing is the activity signal that keeps the wait alive.
+        indexingActive: true
+      };
+      const reporter = createStatusReporter({
+        apiUrl,
+        repoId,
+        commitSha: graph.commitSha,
+        getAuthToken: options.getAuthToken,
+        ...options.getAuthTokenForceRefresh ? { getAuthTokenForceRefresh: options.getAuthTokenForceRefresh } : {},
+        getSnapshot: () => ({ ...snapshot })
+      });
+      reporter.start();
+      let prepared = null;
+      try {
+        if (receivers.length === 0) {
+          await reporter.reportCompleted();
+          return;
+        }
+        prepared = await prepareCommittedTree(localPath, graph.commitSha);
+        if (!prepared) {
+          await reporter.reportCrashed();
+          return;
+        }
+        const buildResult = await ensureIndexable(prepared.indexRoot, "swift", {
+          onActivity: () => {
+            snapshot.indexingActive = true;
+          }
+        });
+        if (!buildResult.ready) {
+          console.warn(`[typed-resolution] swift build unavailable for ${repoId}: ${buildResult.reason ?? "unknown"} \u2014 continuing without it`);
+        }
+        const lspOverrides = options.getLspOverrides?.();
+        const result = await runProducerCycle({
+          apiUrl,
+          authToken: token,
+          repoId,
+          repoRoot: prepared.indexRoot,
+          graph,
+          workspaces: options.workspaces,
+          producer,
+          ...lspOverrides ? { lspOverrides } : {},
+          onReceiverProcessed: (processed, total, resolvedCount) => {
+            snapshot.resolvedCount = resolvedCount;
+            snapshot.remainingReceivers = Math.max(0, total - processed);
+            snapshot.indexingActive = false;
+          }
+        });
+        if (result) {
+          await reporter.reportCompleted();
+        } else {
+          await reporter.reportCrashed();
+        }
+      } catch (err) {
+        console.warn(`[typed-resolution] graph.ready producer failed for ${repoId}: ${err instanceof Error ? err.message : String(err)}`);
+        await reporter.reportCrashed().catch(() => void 0);
+      } finally {
+        reporter.stop();
+        if (prepared) {
+          await prepared.cleanup().catch((cleanupErr) => {
+            console.warn(`[typed-resolution] worktree cleanup failed: ${cleanupErr instanceof Error ? cleanupErr.message : String(cleanupErr)}`);
+          });
+        }
+      }
+    },
     async onSidecarMerged(repoId, commitSha) {
       const apiUrl = options.repoApiUrls.get(repoId);
       if (!apiUrl)
@@ -8947,8 +10113,8 @@ var CRASH_LOOP_WINDOW_MS = 3e4;
 var CRASH_LOOP_THRESHOLD = 3;
 async function readRawToolConfig() {
   try {
-    const configPath = join32(getConfigDir(), "config.json");
-    const data = await readFile12(configPath, "utf-8");
+    const configPath = join40(getConfigDir(), "config.json");
+    const data = await readFile13(configPath, "utf-8");
     const raw = JSON.parse(data);
     return {
       aiTools: Array.isArray(raw["aiTools"]) ? raw["aiTools"] : void 0,
@@ -8967,10 +10133,20 @@ async function updateToolConfigsForRepo(localPath, config2, state, repoId) {
   }
   if (tools.length === 0)
     return;
+  if (tools.includes("roo-code")) {
+    tools = tools.map((t) => t === "roo-code" ? "kilo" : t);
+    tools = tools.filter((t, i) => tools.indexOf(t) === i);
+  }
+  await migrateRooToKilo(localPath).catch(() => {
+  });
   const contextFiles = await scanLocalContextFiles(localPath, contextFolder);
   if (contextFiles.length === 0)
     return;
-  const hash = JSON.stringify({ tools, files: contextFiles.map((f) => f.fileName) });
+  const hash = JSON.stringify({
+    rev: AI_TOOLS_REFERENCE_REV,
+    tools,
+    files: contextFiles.map((f) => f.fileName)
+  });
   if (state.repos[repoId]?.lastToolConfigHash === hash)
     return;
   const written = /* @__PURE__ */ new Set();
@@ -9010,8 +10186,8 @@ function resolveAuditRoots() {
   const out = /* @__PURE__ */ new Set();
   let dir = dirname15(process.execPath);
   for (let i = 0; i < 8; i += 1) {
-    out.add(join32(dir, "node_modules"));
-    out.add(join32(dir, "lib", "node_modules"));
+    out.add(join40(dir, "node_modules"));
+    out.add(join40(dir, "lib", "node_modules"));
     const parent = dirname15(dir);
     if (parent === dir)
       break;
@@ -9141,6 +10317,47 @@ async function runProducerHook(notif, localPath, ctx) {
     console.warn(`[typed-resolution] producer failed for ${notif.repoId}: ${prodErr instanceof Error ? prodErr.message : String(prodErr)}`);
   }
 }
+var processedSideEffectNotifs = /* @__PURE__ */ new Set();
+var MAX_PROCESSED_SIDE_EFFECT_NOTIFS = 512;
+function alreadyProcessedSideEffect(notificationId) {
+  if (processedSideEffectNotifs.has(notificationId))
+    return true;
+  processedSideEffectNotifs.add(notificationId);
+  if (processedSideEffectNotifs.size > MAX_PROCESSED_SIDE_EFFECT_NOTIFS) {
+    const oldest = processedSideEffectNotifs.values().next().value;
+    if (oldest !== void 0)
+      processedSideEffectNotifs.delete(oldest);
+  }
+  return false;
+}
+async function handleSidecarRequested(notif, ctx) {
+  if (!ctx.typedResolutionHooks?.onSidecarRequested || !notif.commitSha)
+    return;
+  if (alreadyProcessedSideEffect(notif.notificationId))
+    return;
+  const localPath = ctx.repoLocalPaths.get(notif.repoId);
+  if (!localPath)
+    return;
+  try {
+    await ctx.typedResolutionHooks.onSidecarRequested(notif.repoId, notif.commitSha, localPath);
+  } catch (prepErr) {
+    console.warn(`[typed-resolution] sidecar.requested prep failed for ${notif.repoId}: ${prepErr instanceof Error ? prepErr.message : String(prepErr)}`);
+  }
+}
+async function handleGraphReady(notif, ctx) {
+  if (!ctx.typedResolutionHooks?.onGraphReady || !notif.commitSha)
+    return;
+  if (alreadyProcessedSideEffect(notif.notificationId))
+    return;
+  const localPath = ctx.repoLocalPaths.get(notif.repoId);
+  if (!localPath)
+    return;
+  try {
+    await ctx.typedResolutionHooks.onGraphReady(notif.repoId, notif.commitSha, localPath);
+  } catch (resolveErr) {
+    console.warn(`[typed-resolution] graph.ready resolve failed for ${notif.repoId}: ${resolveErr instanceof Error ? resolveErr.message : String(resolveErr)}`);
+  }
+}
 async function handleSidecarMerged(notif, ctx) {
   if (!ctx.typedResolutionHooks || !notif.commitSha)
     return;
@@ -9171,6 +10388,10 @@ async function processNotifications(notifications, state, repoLocalPaths, apiUrl
         updateCount++;
     } else if (notif.type === "sidecar.merged") {
       await handleSidecarMerged(notif, ctx);
+    } else if (notif.type === "sidecar.requested") {
+      await handleSidecarRequested(notif, ctx);
+    } else if (notif.type === "graph.ready") {
+      await handleGraphReady(notif, ctx);
     } else {
       state.repos[notif.repoId] = {
         ...state.repos[notif.repoId],
@@ -9231,7 +10452,7 @@ async function checkStaleContext(repos, state, groups) {
     if (group?.offline.isOffline)
       continue;
     const { statSync: statSync2, readdirSync: readdirSync2 } = await import("fs");
-    const contextPath = join32(repo.localPath, "repowise-context");
+    const contextPath = join40(repo.localPath, "repowise-context");
     let isMissingOrEmpty = false;
     try {
       const s = statSync2(contextPath);
@@ -9262,6 +10483,7 @@ async function checkStaleContext(repos, state, groups) {
 }
 async function reconcileMcpConfigs(repos, packageName) {
   const shimCmd = packageName;
+  const { contextFolder, aiTools } = await readRawToolConfig();
   for (const repo of repos) {
     if (!repo.localPath)
       continue;
@@ -9276,7 +10498,9 @@ async function reconcileMcpConfigs(repos, packageName) {
       const results = await runAutoConfig({
         repoRoot: repo.localPath,
         repoId: repo.repoId,
-        shimCmd
+        shimCmd,
+        contextFolder,
+        selectedTools: aiTools
       });
       const written = results.filter((r) => r.detected && r.outcome?.status === "written");
       if (written.length > 0) {
@@ -9289,10 +10513,10 @@ async function reconcileMcpConfigs(repos, packageName) {
 }
 async function reconcileAgentInstructions(repos) {
   for (const repo of repos) {
-    const path = join32(repo.localPath, "repowise-context", "project-overview.md");
+    const path = join40(repo.localPath, "repowise-context", "project-overview.md");
     let content;
     try {
-      content = await readFile12(path, "utf-8");
+      content = await readFile13(path, "utf-8");
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT" || code === "ENOTDIR" || code === "EACCES" || code === "EPERM" || code === "EISDIR") {
@@ -9305,7 +10529,7 @@ async function reconcileAgentInstructions(repos) {
     if (injected === content)
       continue;
     try {
-      await writeFile14(path, injected, "utf-8");
+      await writeFile15(path, injected, "utf-8");
       console.log(`[reconcile] Reconciled agent instructions for ${repo.repoId}`);
     } catch (err) {
       console.warn(`[reconcile] write failed for ${repo.repoId}:`, err instanceof Error ? err.message : String(err));
@@ -9350,9 +10574,9 @@ async function startListener() {
     console.warn(`[integrity] audit failed: ${err instanceof Error ? err.message : String(err)}`);
   }
   const configDir = getConfigDir();
-  await mkdir14(configDir, { recursive: true });
-  const lockPath = join32(configDir, "listener.lock");
-  await writeFile14(lockPath, "", { flag: "a" });
+  await mkdir16(configDir, { recursive: true });
+  const lockPath = join40(configDir, "listener.lock");
+  await writeFile15(lockPath, "", { flag: "a" });
   let lockIsHeld = false;
   try {
     lockIsHeld = await lockfile4.check(lockPath, { stale: 3e4, realpath: false });
@@ -9394,7 +10618,7 @@ async function startListener() {
     return;
   }
   if (config2.repos.length === 0 && !config2.autoDiscoverRepos) {
-    console.error(`No repos configured. Add repos to ${join32(configDir, "config.json")}`);
+    console.error(`No repos configured. Add repos to ${join40(configDir, "config.json")}`);
     await releaseLockAndExit();
     process.exitCode = 1;
     return;
@@ -9462,8 +10686,8 @@ async function startListener() {
   let currentVersion = "";
   try {
     const selfDir = dirname15(fileURLToPath3(import.meta.url));
-    const pkgJsonPath = join32(selfDir, "..", "..", "package.json");
-    const pkgJson = JSON.parse(await readFile12(pkgJsonPath, "utf-8"));
+    const pkgJsonPath = join40(selfDir, "..", "..", "package.json");
+    const pkgJson = JSON.parse(await readFile13(pkgJsonPath, "utf-8"));
     currentVersion = pkgJson.version;
   } catch (err) {
     console.log(`[auto-update] Version detection failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -9591,6 +10815,9 @@ async function startListener() {
       console.warn("[workspace-prep] Pre-install scan failed:", err instanceof Error ? err.message : String(err));
     }
   })();
+  void reapOrphanWorktrees().catch((reapErr) => {
+    console.warn(`[typed-resolution] worktree reap failed: ${reapErr instanceof Error ? reapErr.message : String(reapErr)}`);
+  });
   const typedResolutionHooks = mcpRuntime?.lspWorkspaces ? buildTypedResolutionHooks({
     workspaces: mcpRuntime.lspWorkspaces,
     graphCache: mcpRuntime.graphCache,
@@ -9887,12 +11114,12 @@ async function startListener() {
         } catch {
         }
       }
-      const credentialsPath = join32(getConfigDir(), "credentials.json");
+      const credentialsPath = join40(getConfigDir(), "credentials.json");
       let credentialsChanged = false;
       let watcher = null;
       try {
-        const fs25 = await import("fs");
-        watcher = fs25.watch(credentialsPath, () => {
+        const fs30 = await import("fs");
+        watcher = fs30.watch(credentialsPath, () => {
           credentialsChanged = true;
         });
       } catch {
@@ -9933,7 +11160,7 @@ if (isDirectRun) {
 
 // src/lib/env.ts
 import { homedir as homedir6 } from "os";
-import { join as join33 } from "path";
+import { join as join41 } from "path";
 var IS_STAGING2 = true ? true : false;
 var PRODUCTION = {
   apiUrl: "https://api.repowise.ai",
@@ -9953,7 +11180,7 @@ function getEnvConfig() {
   return IS_STAGING2 ? STAGING : PRODUCTION;
 }
 function getConfigDir2() {
-  return join33(homedir6(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
+  return join41(homedir6(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
 }
 function getPackageName() {
   return true ? "repowisestage" : "repowise";
@@ -9963,12 +11190,12 @@ function getPackageName() {
 import chalk from "chalk";
 
 // src/lib/config.ts
-import { readFile as readFile13, writeFile as writeFile15, mkdir as mkdir15, rename as rename4, unlink as unlink9 } from "fs/promises";
-import { join as join34 } from "path";
+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 lockfile5 from "proper-lockfile";
 async function getConfig() {
   try {
-    const data = await readFile13(join34(getConfigDir2(), "config.json"), "utf-8");
+    const data = await readFile14(join42(getConfigDir2(), "config.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return {};
@@ -9976,15 +11203,15 @@ async function getConfig() {
 }
 async function saveConfig(config2) {
   const dir = getConfigDir2();
-  const path = join34(dir, "config.json");
-  await mkdir15(dir, { recursive: true });
+  const path = join42(dir, "config.json");
+  await mkdir17(dir, { recursive: true });
   const tmpPath = path + ".tmp";
   try {
-    await writeFile15(tmpPath, JSON.stringify(config2, null, 2));
+    await writeFile16(tmpPath, JSON.stringify(config2, null, 2));
     await rename4(tmpPath, path);
   } catch (err) {
     try {
-      await unlink9(tmpPath);
+      await unlink10(tmpPath);
     } catch {
     }
     throw err;
@@ -9992,10 +11219,10 @@ async function saveConfig(config2) {
 }
 async function mergeAndSaveConfig(updates) {
   const dir = getConfigDir2();
-  const path = join34(dir, "config.json");
-  await mkdir15(dir, { recursive: true });
+  const path = join42(dir, "config.json");
+  await mkdir17(dir, { recursive: true });
   try {
-    await writeFile15(path, "", { flag: "a" });
+    await writeFile16(path, "", { flag: "a" });
   } catch {
   }
   let release = null;
@@ -10003,7 +11230,7 @@ async function mergeAndSaveConfig(updates) {
     release = await lockfile5.lock(path, { stale: 1e4, retries: 3, realpath: false });
     let raw = {};
     try {
-      raw = JSON.parse(await readFile13(path, "utf-8"));
+      raw = JSON.parse(await readFile14(path, "utf-8"));
     } catch {
     }
     const merged = { ...raw, ...updates };
@@ -10063,16 +11290,16 @@ async function showWelcome(currentVersion) {
 
 // src/commands/create.ts
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname16, join as join40 } from "path";
+import { dirname as dirname16, join as join47 } from "path";
 init_src();
 import chalk8 from "chalk";
 import ora from "ora";
 
 // src/lib/auth.ts
-import { createHash as createHash4, randomBytes as randomBytes3 } from "crypto";
-import { readFile as readFile14, writeFile as writeFile16, mkdir as mkdir16, chmod as chmod4, unlink as unlink10 } from "fs/promises";
+import { createHash as createHash5, 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 join35 } from "path";
+import { join as join43 } from "path";
 var CLI_CALLBACK_PORT = 19876;
 var CALLBACK_TIMEOUT_MS = 12e4;
 function getCognitoConfigForStorage() {
@@ -10096,7 +11323,7 @@ function generateCodeVerifier() {
   return randomBytes3(32).toString("base64url");
 }
 function generateCodeChallenge(verifier) {
-  return createHash4("sha256").update(verifier).digest("base64url");
+  return createHash5("sha256").update(verifier).digest("base64url");
 }
 function generateState() {
   return randomBytes3(32).toString("hex");
@@ -10238,8 +11465,8 @@ async function refreshTokens2(refreshToken) {
 }
 async function getStoredCredentials2() {
   try {
-    const credPath = join35(getConfigDir2(), "credentials.json");
-    const data = await readFile14(credPath, "utf-8");
+    const credPath = join43(getConfigDir2(), "credentials.json");
+    const data = await readFile15(credPath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
     if (err.code === "ENOENT" || err instanceof SyntaxError) {
@@ -10250,14 +11477,14 @@ async function getStoredCredentials2() {
 }
 async function storeCredentials2(credentials) {
   const dir = getConfigDir2();
-  const credPath = join35(dir, "credentials.json");
-  await mkdir16(dir, { recursive: true, mode: 448 });
-  await writeFile16(credPath, JSON.stringify(credentials, null, 2));
+  const credPath = join43(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 unlink10(join35(getConfigDir2(), "credentials.json"));
+    await unlink11(join43(getConfigDir2(), "credentials.json"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -10432,7 +11659,8 @@ async function selectAiTools() {
     new Separator(chalk2.dim("\u2500\u2500 More Tools \u2500\u2500")),
     { name: "Cline", value: "cline" },
     { name: "Codex", value: "codex" },
-    { name: "Roo Code", value: "roo-code" },
+    // Roo Code shut down 2026-05-15; Kilo Code is the community successor.
+    { name: "Kilo Code", value: "kilo" },
     { name: "Gemini CLI", value: "gemini" },
     new Separator(chalk2.dim("\u2500\u2500 Cloud Agents \u2500\u2500")),
     { name: "Warp", value: "warp" },
@@ -10462,55 +11690,11 @@ async function selectAiTools() {
   }
 }
 
-// src/lib/ai-tools.ts
-import { readFile as readFile15, writeFile as writeFile17, mkdir as mkdir17 } from "fs/promises";
-import { join as join36 } from "path";
-var REPOWISE_HOOK_MARKER = "repowise-context";
-async function writeClaudeSubagentHook(repoRoot, contextFolder) {
-  const settingsPath = join36(repoRoot, ".claude", "settings.json");
-  let settings = {};
-  try {
-    const raw = await readFile15(settingsPath, "utf-8");
-    settings = JSON.parse(raw);
-  } catch {
-  }
-  if (!settings["hooks"] || typeof settings["hooks"] !== "object") {
-    settings["hooks"] = {};
-  }
-  const hooks = settings["hooks"];
-  const repoWiseHook = {
-    matcher: "",
-    hooks: [
-      {
-        type: "command",
-        command: `echo '{"additionalContext":"IMPORTANT: Read ${contextFolder}/project-overview.md before performing any work. This file maps every context file to its domain."}'`
-      }
-    ]
-  };
-  const subagentStart = Array.isArray(hooks["SubagentStart"]) ? hooks["SubagentStart"] : [];
-  const existingIdx = subagentStart.findIndex((entry) => {
-    const entryHooks = entry["hooks"];
-    return entryHooks?.some((h) => {
-      const cmd = h["command"];
-      return typeof cmd === "string" && cmd.includes(REPOWISE_HOOK_MARKER);
-    });
-  });
-  if (existingIdx >= 0) {
-    subagentStart[existingIdx] = repoWiseHook;
-  } else {
-    subagentStart.push(repoWiseHook);
-  }
-  hooks["SubagentStart"] = subagentStart;
-  settings["hooks"] = hooks;
-  await mkdir17(join36(repoRoot, ".claude"), { recursive: true });
-  await writeFile17(settingsPath, JSON.stringify(settings, null, 2) + "\n", "utf-8");
-}
-
 // src/lib/gitignore.ts
 import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync2 } from "fs";
-import { join as join37 } from "path";
+import { join as join44 } from "path";
 function ensureGitignore(repoRoot, entry) {
-  const gitignorePath = join37(repoRoot, ".gitignore");
+  const gitignorePath = join44(repoRoot, ".gitignore");
   if (existsSync2(gitignorePath)) {
     const content = readFileSync2(gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
@@ -11076,8 +12260,8 @@ async function promptDepInstallConsent(missing, opts) {
 import chalk6 from "chalk";
 
 // src/lib/dep-installer.ts
-import { promises as fs16 } from "fs";
-import { join as join38 } from "path";
+import { promises as fs21 } from "fs";
+import { join as join45 } from "path";
 var SUPPORTED_DEP_LANGUAGES = /* @__PURE__ */ new Set([
   "typescript",
   "javascript",
@@ -11087,26 +12271,26 @@ var SUPPORTED_DEP_LANGUAGES = /* @__PURE__ */ new Set([
 ]);
 var exists = async (p) => {
   try {
-    await fs16.access(p);
+    await fs21.access(p);
     return true;
   } catch {
     return false;
   }
 };
-async function fileExists11(repoRoot, name) {
-  return exists(join38(repoRoot, name));
+async function fileExists16(repoRoot, name) {
+  return exists(join45(repoRoot, name));
 }
 async function detectNodePackageManager(repoRoot) {
-  if (await fileExists11(repoRoot, "pnpm-lock.yaml")) {
+  if (await fileExists16(repoRoot, "pnpm-lock.yaml")) {
     return { ecosystem: "pnpm", command: ["pnpm", "install", "--frozen-lockfile"] };
   }
-  if (await fileExists11(repoRoot, "yarn.lock")) {
+  if (await fileExists16(repoRoot, "yarn.lock")) {
     return { ecosystem: "yarn", command: ["yarn", "install", "--frozen-lockfile"] };
   }
-  if (await fileExists11(repoRoot, "bun.lock") || await fileExists11(repoRoot, "bun.lockb")) {
+  if (await fileExists16(repoRoot, "bun.lock") || await fileExists16(repoRoot, "bun.lockb")) {
     return { ecosystem: "bun", command: ["bun", "install", "--frozen-lockfile"] };
   }
-  if (await fileExists11(repoRoot, "package-lock.json")) {
+  if (await fileExists16(repoRoot, "package-lock.json")) {
     return { ecosystem: "npm", command: ["npm", "ci"] };
   }
   return { ecosystem: "npm", command: ["npm", "install", "--no-audit", "--no-fund"] };
@@ -11114,8 +12298,8 @@ async function detectNodePackageManager(repoRoot) {
 async function detectMissingDeps(repoRoot, scopedLanguages) {
   const missing = [];
   const wantsNode = scopedLanguages.has("typescript") || scopedLanguages.has("javascript");
-  if (wantsNode && await fileExists11(repoRoot, "package.json")) {
-    const nodeModulesComplete = await fileExists11(repoRoot, "node_modules/.package-lock.json") || await fileExists11(repoRoot, "node_modules/.modules.yaml") || await fileExists11(repoRoot, "node_modules/.yarn-integrity") || await fileExists11(repoRoot, "node_modules/.bun-tag");
+  if (wantsNode && await fileExists16(repoRoot, "package.json")) {
+    const nodeModulesComplete = await fileExists16(repoRoot, "node_modules/.package-lock.json") || await fileExists16(repoRoot, "node_modules/.modules.yaml") || await fileExists16(repoRoot, "node_modules/.yarn-integrity") || await fileExists16(repoRoot, "node_modules/.bun-tag");
     if (!nodeModulesComplete) {
       const pm = await detectNodePackageManager(repoRoot);
       missing.push({
@@ -11128,9 +12312,9 @@ async function detectMissingDeps(repoRoot, scopedLanguages) {
     }
   }
   if (scopedLanguages.has("python")) {
-    if (await fileExists11(repoRoot, "requirements.txt")) {
+    if (await fileExists16(repoRoot, "requirements.txt")) {
       const venvPipPath = process.platform === "win32" ? "Scripts/pip.exe" : "bin/pip";
-      const venvPresent = await fileExists11(repoRoot, `.venv/${venvPipPath}`) || await fileExists11(repoRoot, `venv/${venvPipPath}`);
+      const venvPresent = await fileExists16(repoRoot, `.venv/${venvPipPath}`) || await fileExists16(repoRoot, `venv/${venvPipPath}`);
       if (!venvPresent) {
         missing.push({
           kind: "pip-venv",
@@ -11142,7 +12326,7 @@ async function detectMissingDeps(repoRoot, scopedLanguages) {
     }
   }
   if (scopedLanguages.has("go")) {
-    if (await fileExists11(repoRoot, "go.mod")) {
+    if (await fileExists16(repoRoot, "go.mod")) {
       missing.push({
         kind: "simple",
         ecosystem: "go",
@@ -11153,8 +12337,8 @@ async function detectMissingDeps(repoRoot, scopedLanguages) {
     }
   }
   if (scopedLanguages.has("php")) {
-    if (await fileExists11(repoRoot, "composer.json")) {
-      if (!await fileExists11(repoRoot, "vendor")) {
+    if (await fileExists16(repoRoot, "composer.json")) {
+      if (!await fileExists16(repoRoot, "vendor")) {
         missing.push({
           kind: "simple",
           ecosystem: "composer",
@@ -11169,15 +12353,15 @@ async function detectMissingDeps(repoRoot, scopedLanguages) {
 }
 
 // src/lib/dep-installer-runner.ts
-import { spawn as spawn10 } from "child_process";
+import { spawn as spawn11 } from "child_process";
 import { createWriteStream as createWriteStream3 } from "fs";
-import { promises as fs17 } from "fs";
-import { join as join39 } from "path";
+import { promises as fs22 } from "fs";
+import { join as join46 } 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 = join39(getConfigDir2(), `install-log.${safeRepoId}.txt`);
-  await fs17.mkdir(getConfigDir2(), { recursive: true });
+  const logPath2 = join46(getConfigDir2(), `install-log.${safeRepoId}.txt`);
+  await fs22.mkdir(getConfigDir2(), { recursive: true });
   const stream = opts.logStream ?? createWriteStream3(logPath2, { flags: "a" });
   stream.on("error", () => {
   });
@@ -11223,7 +12407,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" ? join39(".venv", "Scripts", "pip.exe") : join39(".venv", "bin", "pip");
+  const venvPip = process.platform === "win32" ? join46(".venv", "Scripts", "pip.exe") : join46(".venv", "bin", "pip");
   await runSimple([venvPip, "install", "-r", "requirements.txt"], repoRoot, stream, timeoutMs);
 }
 function runSimple(cmd, repoRoot, stream, timeoutMs) {
@@ -11236,7 +12420,7 @@ $ ${cmd.join(" ")}
       reject(new Error("runSimple called with empty command"));
       return;
     }
-    const child = spawn10(head, cmd.slice(1), {
+    const child = spawn11(head, cmd.slice(1), {
       cwd: repoRoot,
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -11591,91 +12775,142 @@ async function create() {
     const progressRenderer = new ProgressRenderer();
     let depInstallShown = false;
     let seenAwaitingInput = false;
+    let lspWaitStartedAt = null;
+    let lspFellBackNoticeShown = false;
     let depInstallPromise = null;
     let lspInstallPromise = null;
     if (repoRoot) {
       const lspResult = await maybeInstallLspServers({ repoRoot, spinner });
       lspInstallPromise = lspResult.installPromise;
     }
-    while (true) {
-      if (++pollAttempts > MAX_POLL_ATTEMPTS) {
-        spinner.fail(chalk8.red("Pipeline timed out. Check dashboard for status."));
-        process.exitCode = 1;
-        return;
-      }
-      await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
-      let syncResult;
-      try {
-        syncResult = await apiRequest(`/v1/sync/${syncId}/status`);
-        pollErrors = 0;
-      } catch (pollErr) {
-        pollErrors++;
-        if (pollErrors >= MAX_POLL_ERRORS) {
-          throw pollErr;
-        }
-        continue;
-      }
-      progressRenderer.update(syncResult, spinner);
-      if (syncResult.status === "awaiting_input") {
-        seenAwaitingInput = true;
-      }
-      if (syncResult.status === "awaiting_input" && syncResult.questionId && syncResult.questionText) {
+    let sigintBusy = false;
+    const onSigint = () => {
+      if (sigintBusy) return;
+      sigintBusy = true;
+      void (async () => {
         spinner.stop();
-        await handleInterview(
-          syncId,
-          syncResult.questionId,
-          syncResult.questionText,
-          syncResult.questionContext ?? void 0,
-          syncResult.discoveryResult?.estimatedInterviewQuestions
-        );
-        spinner.start("Resuming pipeline...");
-        continue;
-      }
-      const interviewPhaseDone = seenAwaitingInput || syncResult.discoveryResult?.estimatedInterviewQuestions === 0;
-      if (!depInstallShown && repoRoot && repoId && syncResult.discoveryResult?.languages && syncResult.discoveryResult.languages.length > 0 && syncResult.status !== "awaiting_input" && !syncResult.scanProgress && interviewPhaseDone) {
-        depInstallShown = true;
-        const scopedLanguages = new Set(
-          syncResult.discoveryResult.languages.map((l) => l.name.toLowerCase())
-        );
-        const result = await maybePromptAndInstallDeps({
-          repoRoot,
-          repoId,
-          scopedLanguages,
-          spinner,
-          resumeText: "Resuming pipeline..."
-        });
-        depInstallPromise = result.installPromise;
-      }
-      if (syncResult.status === "completed") {
-        progressRenderer.finalize();
-        const generatedFiles = syncResult.filesGenerated ?? [];
-        const fileCount = generatedFiles.length;
-        if (fileCount > 0) {
-          const coreCount = generatedFiles.filter(
-            (f) => CORE_FILES.has(f.split("/").pop() ?? f)
-          ).length;
-          const tailoredCount = fileCount - coreCount;
-          spinner.succeed(
-            `Context generation complete \u2014 ${coreCount} core + ${tailoredCount} tailored files`
+        try {
+          const { confirm: confirm3 } = await import("@inquirer/prompts");
+          const abort = await confirm3({
+            message: "Scan is still running. Abort it? (No = continue in background)",
+            default: false
+          });
+          if (!abort) {
+            console.log(
+              chalk8.dim(
+                "Scan continues on the server \u2014 watch progress in the dashboard; context arrives via the listener."
+              )
+            );
+            process.exit(0);
+          }
+          await apiRequest(`/v1/sync/${syncId}/cancel`, { method: "POST" });
+          console.log(chalk8.yellow("Scan aborted."));
+          process.exit(1);
+        } catch {
+          process.exit(130);
+        }
+      })();
+    };
+    process.on("SIGINT", onSigint);
+    try {
+      while (true) {
+        if (++pollAttempts > MAX_POLL_ATTEMPTS) {
+          spinner.fail(chalk8.red("Pipeline timed out. Check dashboard for status."));
+          process.exitCode = 1;
+          return;
+        }
+        await new Promise((r) => setTimeout(r, POLL_INTERVAL_MS));
+        let syncResult;
+        try {
+          syncResult = await apiRequest(`/v1/sync/${syncId}/status`);
+          pollErrors = 0;
+        } catch (pollErr) {
+          pollErrors++;
+          if (pollErrors >= MAX_POLL_ERRORS) {
+            throw pollErr;
+          }
+          continue;
+        }
+        if (sigintBusy) {
+          continue;
+        }
+        progressRenderer.update(syncResult, spinner);
+        if (!graphOnly && syncResult.status === "in_progress") {
+          if (syncResult.lspWaitState === "awaiting" || syncResult.lspWaitState === "analyzing") {
+            lspWaitStartedAt ??= Date.now();
+            spinner.text = `Analyzing repo for accurate dependency graph\u2026 (${formatElapsed(Date.now() - lspWaitStartedAt)})`;
+          } else if (syncResult.lspWaitState === "fell-back" && !lspFellBackNoticeShown) {
+            lspFellBackNoticeShown = true;
+            spinner.stop();
+            console.log(
+              chalk8.dim("  Typed analysis unavailable \u2014 using fast static analysis for this scan.")
+            );
+            spinner.start();
+          }
+        }
+        if (syncResult.status === "awaiting_input") {
+          seenAwaitingInput = true;
+        }
+        if (syncResult.status === "awaiting_input" && syncResult.questionId && syncResult.questionText) {
+          spinner.stop();
+          await handleInterview(
+            syncId,
+            syncResult.questionId,
+            syncResult.questionText,
+            syncResult.questionContext ?? void 0,
+            syncResult.discoveryResult?.estimatedInterviewQuestions
           );
-        } else if (graphOnly) {
-          spinner.succeed("Knowledge graph built \u2014 MCP ready (Free plan).");
-        } else {
-          spinner.warn(chalk8.yellow("Pipeline completed but no context files were generated."));
-          console.log(
-            chalk8.yellow(
-              "  This may be due to AI throttling or a parsing issue. Try running `repowise create` again."
-            )
+          spinner.start("Resuming pipeline...");
+          continue;
+        }
+        const interviewPhaseDone = seenAwaitingInput || syncResult.discoveryResult?.estimatedInterviewQuestions === 0;
+        if (!depInstallShown && repoRoot && repoId && syncResult.discoveryResult?.languages && syncResult.discoveryResult.languages.length > 0 && syncResult.status !== "awaiting_input" && interviewPhaseDone) {
+          depInstallShown = true;
+          const scopedLanguages = new Set(
+            syncResult.discoveryResult.languages.map((l) => l.name.toLowerCase())
           );
+          const result = await maybePromptAndInstallDeps({
+            repoRoot,
+            repoId,
+            scopedLanguages,
+            spinner,
+            resumeText: "Resuming pipeline..."
+          });
+          depInstallPromise = result.installPromise;
+        }
+        if (syncResult.status === "completed") {
+          progressRenderer.finalize();
+          const generatedFiles = syncResult.filesGenerated ?? [];
+          const fileCount = generatedFiles.length;
+          if (fileCount > 0) {
+            const coreCount = generatedFiles.filter(
+              (f) => CORE_FILES.has(f.split("/").pop() ?? f)
+            ).length;
+            const tailoredCount = fileCount - coreCount;
+            spinner.succeed(
+              `Context generation complete \u2014 ${coreCount} core + ${tailoredCount} tailored files`
+            );
+          } else if (graphOnly) {
+            spinner.succeed("Knowledge graph built \u2014 MCP ready (Free plan).");
+          } else {
+            spinner.warn(chalk8.yellow("Pipeline completed but no context files were generated."));
+            console.log(
+              chalk8.yellow(
+                "  This may be due to AI throttling or a parsing issue. Try running `repowise create` again."
+              )
+            );
+          }
+          break;
+        }
+        if (syncResult.status === "failed") {
+          progressRenderer.finalize();
+          spinner.fail(chalk8.red(`Pipeline failed: ${syncResult.error ?? "Unknown error"}`));
+          process.exitCode = 1;
+          return;
         }
-        break;
-      }
-      if (syncResult.status === "failed") {
-        progressRenderer.finalize();
-        spinner.fail(chalk8.red(`Pipeline failed: ${syncResult.error ?? "Unknown error"}`));
-        process.exitCode = 1;
-        return;
       }
+    } finally {
+      process.removeListener("SIGINT", onSigint);
     }
     if (repoRoot && !graphOnly) {
       spinner.start("Downloading context files from server...");
@@ -11683,7 +12918,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 = join40(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          const contextDir = join47(repoRoot, DEFAULT_CONTEXT_FOLDER);
           mkdirSync(contextDir, { recursive: true });
           let downloadedCount = 0;
           let failedCount = 0;
@@ -11697,7 +12932,7 @@ async function create() {
             const response = await fetch(presignedUrl);
             if (response.ok) {
               const content = await response.text();
-              const filePath = join40(contextDir, file.fileName);
+              const filePath = join47(contextDir, file.fileName);
               mkdirSync(dirname16(filePath), { recursive: true });
               writeFileSync2(filePath, content, "utf-8");
               downloadedCount++;
@@ -11773,8 +13008,8 @@ Files are stored on our servers (not in git). Retry when online.`
         results.push(`  ${wasCreated ? "Created" : "Updated"} AGENTS.md`);
       }
       if (tools.includes("claude-code")) {
-        await writeClaudeSubagentHook(repoRoot, contextFolder);
-        results.push("  Configured .claude/settings.json (SubagentStart hook)");
+        const { relPath } = await writeClaudeHooksToRepo(repoRoot, contextFolder);
+        results.push(`  Configured ${relPath} (RepoWise-first + SubagentStart hooks, local-only)`);
       }
       spinner.succeed("AI tools configured");
       console.log(chalk8.dim(results.join("\n")));
@@ -11900,7 +13135,7 @@ Files are stored on our servers (not in git). Retry when online.`
 
 // src/commands/member.ts
 import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname17, join as join41, resolve, sep } from "path";
+import { dirname as dirname17, join as join48, resolve, sep } from "path";
 import chalk9 from "chalk";
 import ora2 from "ora";
 var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
@@ -12054,7 +13289,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 = join41(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    const contextDir = join48(repoRoot, DEFAULT_CONTEXT_FOLDER2);
     mkdirSync2(contextDir, { recursive: true });
     let downloadedCount = 0;
     let failedCount = 0;
@@ -12125,8 +13360,8 @@ async function member() {
         configured.push(`${created ? "Created" : "Updated"} AGENTS.md`);
       }
       if (tools.includes("claude-code")) {
-        await writeClaudeSubagentHook(repoRoot, DEFAULT_CONTEXT_FOLDER2);
-        configured.push("Configured .claude/settings.json (SubagentStart hook)");
+        const { relPath } = await writeClaudeHooksToRepo(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+        configured.push(`Configured ${relPath} (RepoWise-first + SubagentStart hooks, local-only)`);
       }
       spinner.succeed("AI tools configured");
       for (const msg of configured) {
@@ -12252,15 +13487,15 @@ import chalk10 from "chalk";
 import ora3 from "ora";
 
 // src/lib/tenant-graph-purge.ts
-import { promises as fs18 } from "fs";
+import { promises as fs23 } from "fs";
 import { homedir as homedir7 } from "os";
-import { join as join42 } from "path";
+import { join as join49 } from "path";
 async function purgeForeignGraphs(validRepoIds, home = homedir7()) {
-  const graphsDir = join42(home, ".repowise", "graphs");
+  const graphsDir = join49(home, ".repowise", "graphs");
   const result = { kept: [], removed: [] };
   let entries;
   try {
-    entries = await fs18.readdir(graphsDir);
+    entries = await fs23.readdir(graphsDir);
   } catch (err) {
     if (err.code === "ENOENT") return result;
     throw err;
@@ -12274,15 +13509,15 @@ async function purgeForeignGraphs(validRepoIds, home = homedir7()) {
       result.kept.push(entry);
       continue;
     }
-    const path = join42(graphsDir, entry);
+    const path = join49(graphsDir, entry);
     try {
-      const stat7 = await fs18.lstat(path);
-      if (stat7.isSymbolicLink()) {
-        await fs18.unlink(path);
+      const stat8 = await fs23.lstat(path);
+      if (stat8.isSymbolicLink()) {
+        await fs23.unlink(path);
         result.removed.push(entry);
         continue;
       }
-      await fs18.rm(path, { recursive: true, force: true });
+      await fs23.rm(path, { recursive: true, force: true });
       result.removed.push(entry);
     } catch {
     }
@@ -12367,11 +13602,11 @@ async function logout() {
 
 // src/commands/status.ts
 import { readFile as readFile16 } from "fs/promises";
-import { basename as basename3, join as join43 } from "path";
+import { basename as basename4, join as join50 } from "path";
 async function status() {
   const configDir = getConfigDir2();
-  const STATE_PATH = join43(configDir, "listener-state.json");
-  const CONFIG_PATH = join43(configDir, "config.json");
+  const STATE_PATH = join50(configDir, "listener-state.json");
+  const CONFIG_PATH = join50(configDir, "config.json");
   let state = null;
   try {
     const data = await readFile16(STATE_PATH, "utf-8");
@@ -12403,7 +13638,7 @@ async function status() {
     const configData = await readFile16(CONFIG_PATH, "utf-8");
     const config2 = JSON.parse(configData);
     for (const repo of config2.repos ?? []) {
-      repoNames.set(repo.repoId, basename3(repo.localPath));
+      repoNames.set(repo.repoId, basename4(repo.localPath));
     }
   } catch {
   }
@@ -12419,7 +13654,7 @@ async function status() {
 
 // src/commands/sync.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname18, join as join44 } from "path";
+import { dirname as dirname18, join as join51 } from "path";
 import chalk12 from "chalk";
 import ora4 from "ora";
 var POLL_INTERVAL_MS2 = 3e3;
@@ -12568,7 +13803,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 = join44(repoRoot, DEFAULT_CONTEXT_FOLDER3);
+        const contextDir = join51(repoRoot, DEFAULT_CONTEXT_FOLDER3);
         mkdirSync3(contextDir, { recursive: true });
         let downloadedCount = 0;
         let failedCount = 0;
@@ -12582,7 +13817,7 @@ async function sync() {
           const response = await fetch(presignedUrl);
           if (response.ok) {
             const content = await response.text();
-            const filePath = join44(contextDir, file.fileName);
+            const filePath = join51(contextDir, file.fileName);
             mkdirSync3(dirname18(filePath), { recursive: true });
             writeFileSync4(filePath, content, "utf-8");
             downloadedCount++;
@@ -12603,7 +13838,7 @@ async function sync() {
         }
         try {
           const existingConfig = await getConfig();
-          const aiTools = existingConfig.aiTools ?? [];
+          const aiTools = (existingConfig.aiTools ?? []).map((t) => t === "roo-code" ? "kilo" : t).filter((t, i, arr) => arr.indexOf(t) === i);
           if (aiTools.length > 0) {
             const contextFiles = await scanLocalContextFiles(repoRoot, DEFAULT_CONTEXT_FOLDER3);
             if (contextFiles.length > 0) {
@@ -12834,8 +14069,8 @@ async function config() {
 
 // src/commands/mcp-log.ts
 import { createDecipheriv as createDecipheriv2 } from "crypto";
-import { mkdir as mkdir18, readFile as readFile17, stat as stat6, writeFile as writeFile18 } from "fs/promises";
-import { dirname as dirname19, join as join45 } from "path";
+import { mkdir as mkdir19, readFile as readFile17, stat as stat7, writeFile as writeFile18 } from "fs/promises";
+import { dirname as dirname19, join as join52 } from "path";
 var FLAG_FILE = "mcp-log.flag";
 var LOG_FILE = "mcp-log.jsonl.enc";
 var KEY_FILE = "mcp-log.key";
@@ -12843,14 +14078,14 @@ var ENDPOINT_FILE = "listener.endpoint";
 var IV_BYTES2 = 12;
 var TAG_BYTES2 = 16;
 function flagPath() {
-  return join45(getConfigDir2(), FLAG_FILE);
+  return join52(getConfigDir2(), FLAG_FILE);
 }
 function logPath() {
-  return join45(getConfigDir2(), LOG_FILE);
+  return join52(getConfigDir2(), LOG_FILE);
 }
 async function writeFlag(flag) {
   const path = flagPath();
-  await mkdir18(dirname19(path), { recursive: true });
+  await mkdir19(dirname19(path), { recursive: true });
   await writeFile18(path, JSON.stringify(flag, null, 2), { encoding: "utf-8", mode: 384 });
 }
 async function mcpLogOn() {
@@ -12887,14 +14122,14 @@ async function trySendConsentToServer() {
   let apiUrl = null;
   let token = null;
   try {
-    const body = await readFile17(join45(getConfigDir2(), "config.json"), "utf-8");
+    const body = await readFile17(join52(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(join45(getConfigDir2(), "credentials.json"), "utf-8");
+    const body = await readFile17(join52(getConfigDir2(), "credentials.json"), "utf-8");
     const parsed = JSON.parse(body);
     token = parsed.idToken ?? null;
   } catch {
@@ -12955,7 +14190,7 @@ async function mcpLogStatus() {
   process.stderr.write(`Log file:        ${logPath()}
 `);
   try {
-    const s = await stat6(logPath());
+    const s = await stat7(logPath());
     process.stderr.write(
       `Log size:        ${formatBytes(s.size)} (last modified ${s.mtime.toISOString()})
 `
@@ -12964,7 +14199,7 @@ async function mcpLogStatus() {
     process.stderr.write("Log size:        no file yet\n");
   }
   try {
-    const endpointBody = await readFile17(join45(getConfigDir2(), ENDPOINT_FILE), "utf-8");
+    const endpointBody = await readFile17(join52(getConfigDir2(), ENDPOINT_FILE), "utf-8");
     const match = /endpoint=([^\n]+)/.exec(endpointBody);
     process.stderr.write(`MCP endpoint:    ${match?.[1] ?? "(malformed endpoint file)"}
 `);
@@ -12995,7 +14230,7 @@ async function mcpLogViewingFlags(flags = {}) {
   const key = await readKey();
   if (!key) {
     process.stderr.write(
-      `No encryption key at ${join45(getConfigDir2(), KEY_FILE)} \u2014 listener may not have started yet.
+      `No encryption key at ${join52(getConfigDir2(), KEY_FILE)} \u2014 listener may not have started yet.
 `
     );
     return;
@@ -13041,11 +14276,11 @@ async function mcpLogViewingFlags(flags = {}) {
       }
     }
     if (flags.follow) {
-      let lastSize = (await stat6(path)).size;
+      let lastSize = (await stat7(path)).size;
       while (true) {
         await new Promise((resolve5) => setTimeout(resolve5, 1e3));
         try {
-          const s = await stat6(path);
+          const s = await stat7(path);
           if (s.size > lastSize) {
             const fresh = await readFile17(path, "utf-8");
             const tail = fresh.slice(lastSize);
@@ -13071,7 +14306,7 @@ async function mcpLogViewingFlags(flags = {}) {
 }
 async function readKey() {
   try {
-    const body = await readFile17(join45(getConfigDir2(), KEY_FILE), "utf-8");
+    const body = await readFile17(join52(getConfigDir2(), KEY_FILE), "utf-8");
     const parsed = Buffer.from(body.trim(), "base64");
     if (parsed.length !== 32) return null;
     return parsed;
@@ -13114,8 +14349,8 @@ async function mcpLog(subcommand, flags = {}) {
 import chalk14 from "chalk";
 
 // src/lib/graph-loader.ts
-import { promises as fs19 } from "fs";
-import { join as join46, resolve as resolve2 } from "path";
+import { promises as fs24 } from "fs";
+import { join as join53, 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";
@@ -13132,8 +14367,8 @@ var GraphNotFoundError = class extends Error {
 var cache = /* @__PURE__ */ new Map();
 async function loadGraph(repoRoot = process.cwd()) {
   const root = resolve2(repoRoot);
-  const gzPath = join46(root, GZIPPED_GRAPH_PATH);
-  const plainPath = join46(root, RELATIVE_GRAPH_PATH);
+  const gzPath = join53(root, GZIPPED_GRAPH_PATH);
+  const plainPath = join53(root, RELATIVE_GRAPH_PATH);
   const cached = cache.get(root);
   if (cached) {
     return { graph: cached, path: plainPath, bytes: 0, parseMs: 0, fromCache: true };
@@ -13141,14 +14376,14 @@ async function loadGraph(repoRoot = process.cwd()) {
   let graphPath = null;
   let raw = null;
   try {
-    raw = await fs19.readFile(gzPath);
+    raw = await fs24.readFile(gzPath);
     graphPath = gzPath;
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   if (!raw) {
     try {
-      raw = await fs19.readFile(plainPath);
+      raw = await fs24.readFile(plainPath);
       graphPath = plainPath;
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -13547,14 +14782,14 @@ function registerQueryCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-import { promises as fs23 } from "fs";
+import { promises as fs28 } from "fs";
 import { homedir as homedir9 } from "os";
-import { join as join50 } from "path";
+import { join as join57 } from "path";
 import chalk15 from "chalk";
 
 // src/lib/cleanup/marker-blocks.ts
-import { promises as fs20 } from "fs";
-import { join as join47 } from "path";
+import { promises as fs25 } from "fs";
+import { join as join54 } from "path";
 var MARKER_START = "<!-- repowise-start -->";
 var MARKER_END = "<!-- repowise-end -->";
 var CONTEXT_FILES = [
@@ -13570,7 +14805,7 @@ var CONTEXT_FILES = [
 async function stripMarkerBlock(filePath) {
   let raw;
   try {
-    raw = await fs20.readFile(filePath, "utf-8");
+    raw = await fs25.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT")
       return { path: filePath, status: "missing" };
@@ -13585,16 +14820,16 @@ async function stripMarkerBlock(filePath) {
   const after = raw.slice(endIdx + MARKER_END.length).replace(/^\n+/, "");
   const stripped = (before + (before && after ? "\n\n" : "") + after).trim();
   if (stripped.length === 0) {
-    await fs20.unlink(filePath);
+    await fs25.unlink(filePath);
     return { path: filePath, status: "deleted" };
   }
-  await fs20.writeFile(filePath, stripped + "\n", "utf-8");
+  await fs25.writeFile(filePath, stripped + "\n", "utf-8");
   return { path: filePath, status: "stripped" };
 }
 async function stripAllMarkerBlocks(repoRoot) {
   const out = [];
   for (const relative of CONTEXT_FILES) {
-    const full = join47(repoRoot, relative);
+    const full = join54(repoRoot, relative);
     const result = await stripMarkerBlock(full).catch((err) => ({
       path: full,
       status: "untouched",
@@ -13606,25 +14841,25 @@ async function stripAllMarkerBlocks(repoRoot) {
 }
 
 // src/lib/cleanup/mcp-configs.ts
-import { promises as fs21 } from "fs";
-import { join as join48 } from "path";
+import { promises as fs26 } from "fs";
+import { join as join55 } from "path";
 function mcpConfigPaths(repoRoot, home) {
   return [
-    join48(repoRoot, ".mcp.json"),
-    join48(repoRoot, ".cursor", "mcp.json"),
-    join48(repoRoot, ".vscode", "mcp.json"),
-    join48(repoRoot, ".roo", "mcp.json"),
-    join48(home, ".cline", "mcp.json"),
-    join48(home, ".codeium", "windsurf", "mcp_config.json"),
-    join48(home, ".gemini", "settings.json"),
-    join48(home, ".codex", "mcp.json"),
-    join48(home, ".roo", "mcp.json")
+    join55(repoRoot, ".mcp.json"),
+    join55(repoRoot, ".cursor", "mcp.json"),
+    join55(repoRoot, ".vscode", "mcp.json"),
+    join55(repoRoot, ".roo", "mcp.json"),
+    join55(home, ".cline", "mcp.json"),
+    join55(home, ".codeium", "windsurf", "mcp_config.json"),
+    join55(home, ".gemini", "settings.json"),
+    join55(home, ".codex", "mcp.json"),
+    join55(home, ".roo", "mcp.json")
   ];
 }
 async function removeRepowiseFromConfig(path, serverName) {
   let raw;
   try {
-    raw = await fs21.readFile(path, "utf-8");
+    raw = await fs26.readFile(path, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return { path, status: "not-found" };
     return { path, status: "error", error: err.message };
@@ -13644,7 +14879,7 @@ async function removeRepowiseFromConfig(path, serverName) {
   } else {
     next.mcpServers = servers;
   }
-  await fs21.writeFile(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  await fs26.writeFile(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
   return { path, status: "removed" };
 }
 async function removeAllMcpEntries(repoRoot, home, repoId) {
@@ -13657,17 +14892,17 @@ async function removeAllMcpEntries(repoRoot, home, repoId) {
 }
 
 // src/lib/cleanup/local-state.ts
-import { promises as fs22 } from "fs";
+import { promises as fs27 } from "fs";
 import { homedir as homedir8 } from "os";
-import { join as join49, resolve as resolve3 } from "path";
+import { join as join56, resolve as resolve3 } from "path";
 async function clearLocalState(homeOverride) {
   const home = homeOverride ?? homedir8();
-  const target = resolve3(join49(home, ".repowise"));
+  const target = resolve3(join56(home, ".repowise"));
   if (target === resolve3(home) || !target.startsWith(resolve3(home))) {
     return { path: target, status: "error", error: "refused: not under home" };
   }
   try {
-    await fs22.rm(target, { recursive: true, force: false });
+    await fs27.rm(target, { recursive: true, force: false });
     return { path: target, status: "removed" };
   } catch (err) {
     if (err.code === "ENOENT")
@@ -13706,7 +14941,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 fs23.unlink(join50(home, ".repowise", "credentials.json"));
+    await fs28.unlink(join57(home, ".repowise", "credentials.json"));
     report.removed.push("credentials");
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -13733,7 +14968,7 @@ async function uninstall2(opts = {}) {
   const allPaths = mcpConfigPaths(repoRoot, home);
   for (const p of allPaths) {
     try {
-      await fs23.access(p);
+      await fs28.access(p);
     } catch {
     }
   }
@@ -13745,7 +14980,7 @@ async function uninstall2(opts = {}) {
 }
 async function defaultLoadRepoIds(home) {
   try {
-    const raw = await fs23.readFile(join50(home, ".repowise", "config.json"), "utf-8");
+    const raw = await fs28.readFile(join57(home, ".repowise", "config.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return (parsed.repos ?? []).map((r) => r.repoId);
   } catch {
@@ -13792,12 +15027,12 @@ Done \u2014 ${report.removed.length} removed, ${report.skipped.length} skipped.
 
 // src/commands/mcp-shim.ts
 init_config_dir();
-import { promises as fs24 } from "fs";
+import { promises as fs29 } from "fs";
 import { createInterface as createInterface2 } from "readline";
-import { join as join51 } from "path";
+import { join as join58 } from "path";
 var DEFAULT_MAX = 200 * 1024;
 async function mcpShim(opts) {
-  const endpointPath = opts.endpointFile ?? join51(getConfigDir(), "listener.endpoint");
+  const endpointPath = opts.endpointFile ?? join58(getConfigDir(), "listener.endpoint");
   const stdin = opts.stdin ?? process.stdin;
   const stdout = opts.stdout ?? process.stdout;
   const stderr = opts.stderr ?? process.stderr;
@@ -13870,7 +15105,7 @@ async function mcpShim(opts) {
 }
 async function readEndpoint(path) {
   try {
-    const raw = (await fs24.readFile(path, "utf-8")).trim();
+    const raw = (await fs29.readFile(path, "utf-8")).trim();
     if (!raw) return null;
     if (raw.startsWith("http://") || raw.startsWith("https://")) {
       return { endpoint: raw.split("\n")[0].trim(), secret: null };
@@ -14110,7 +15345,7 @@ init_registry();
 init_native_installer();
 init_coursier_installer();
 init_toolchain_installer();
-import { spawn as spawn11 } from "child_process";
+import { spawn as spawn12 } from "child_process";
 import { resolve as resolve4 } from "path";
 import chalk16 from "chalk";
 async function isOnPath(command) {
@@ -14118,7 +15353,7 @@ async function isOnPath(command) {
   const isWin = process.platform === "win32";
   const probeCmd = isWin ? "where" : "which";
   return new Promise((resolve5) => {
-    const child = spawn11(probeCmd, [command], { stdio: "ignore" });
+    const child = spawn12(probeCmd, [command], { stdio: "ignore" });
     child.on("close", (code) => {
       resolve5(code === 0);
     });
@@ -14285,13 +15520,13 @@ function formatInstallLine(lang, outcome) {
 }
 var MAX_KEEP_WARM_MINUTES = 240;
 async function autoDetectLanguages(cwd) {
-  const { readdir: readdir4 } = await import("fs/promises");
+  const { readdir: readdir6 } = await import("fs/promises");
   const seen = /* @__PURE__ */ new Set();
   async function walk(dir, depth) {
     if (depth > 1) return;
     let entries;
     try {
-      entries = await readdir4(dir, { withFileTypes: true });
+      entries = await readdir6(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -14546,7 +15781,7 @@ async function lspOn() {
 // bin/repowise.ts
 var __filename = fileURLToPath4(import.meta.url);
 var __dirname = dirname20(__filename);
-var pkg = JSON.parse(readFileSync3(join52(__dirname, "..", "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync3(join59(__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);