repowisestage 0.0.40 → 0.0.41

package/dist/bin/repowise.js

@@ -456,404 +456,6 @@ var init_service_installer = __esm({
   }
 });
 
-// ../../packages/shared/src/types/typed-resolution.ts
-function typedResolutionKey(filePath, propertyName, line, column) {
-  return `${filePath}\0${propertyName}\0${line.toString()}\0${column.toString()}`;
-}
-var TYPED_RESOLUTION_SCHEMA_VERSION;
-var init_typed_resolution = __esm({
-  "../../packages/shared/src/types/typed-resolution.ts"() {
-    "use strict";
-    TYPED_RESOLUTION_SCHEMA_VERSION = 1;
-  }
-});
-
-// ../../packages/shared/src/types/billing.ts
-var init_billing = __esm({
-  "../../packages/shared/src/types/billing.ts"() {
-    "use strict";
-  }
-});
-
-// ../../packages/shared/src/constants/platforms.ts
-var init_platforms = __esm({
-  "../../packages/shared/src/constants/platforms.ts"() {
-    "use strict";
-  }
-});
-
-// ../../packages/shared/src/constants/tiers.ts
-var SUBSCRIPTION_TIERS, TIER_LIMITS;
-var init_tiers = __esm({
-  "../../packages/shared/src/constants/tiers.ts"() {
-    "use strict";
-    SUBSCRIPTION_TIERS = {
-      STARTER: "starter",
-      PRO: "pro",
-      TEAM: "team"
-    };
-    TIER_LIMITS = {
-      [SUBSCRIPTION_TIERS.STARTER]: {
-        maxRepos: 1,
-        maxSeats: 1,
-        maxSyncsPerMonth: 10,
-        maxConcurrentSyncs: 1,
-        bedrockEndpoint: "public"
-      },
-      [SUBSCRIPTION_TIERS.PRO]: {
-        maxRepos: 2,
-        maxSeats: 1,
-        maxSyncsPerMonth: 30,
-        maxConcurrentSyncs: 2,
-        bedrockEndpoint: "public"
-      },
-      [SUBSCRIPTION_TIERS.TEAM]: {
-        maxRepos: 3,
-        maxSeats: 999999,
-        maxSyncsPerMonth: 30,
-        maxConcurrentSyncs: 10,
-        bedrockEndpoint: "public"
-      }
-    };
-  }
-});
-
-// ../../packages/shared/src/constants/roles.ts
-function hasPermission(role, permission) {
-  return PERMISSIONS[role][permission];
-}
-function resolveRole(groups) {
-  for (const role of ROLE_PRIORITY) {
-    if (groups.includes(role)) return role;
-  }
-  return ROLES.MEMBER;
-}
-var ROLES, PERMISSIONS, ROLE_PRIORITY;
-var init_roles = __esm({
-  "../../packages/shared/src/constants/roles.ts"() {
-    "use strict";
-    ROLES = {
-      OWNER: "owner",
-      ADMIN: "admin",
-      REPO_MANAGER: "repo_manager",
-      MEMBER: "member"
-    };
-    PERMISSIONS = {
-      [ROLES.OWNER]: {
-        connectRepos: true,
-        viewSync: true,
-        triggerRetry: true,
-        configWatcher: true,
-        inviteMembers: true,
-        manageBilling: true,
-        configAiTools: true,
-        manageTeam: true
-      },
-      [ROLES.ADMIN]: {
-        connectRepos: true,
-        viewSync: true,
-        triggerRetry: true,
-        configWatcher: true,
-        inviteMembers: true,
-        manageBilling: false,
-        configAiTools: true,
-        manageTeam: true
-      },
-      [ROLES.REPO_MANAGER]: {
-        connectRepos: true,
-        viewSync: true,
-        triggerRetry: true,
-        configWatcher: true,
-        inviteMembers: false,
-        manageBilling: false,
-        configAiTools: true,
-        manageTeam: false
-      },
-      [ROLES.MEMBER]: {
-        connectRepos: false,
-        viewSync: true,
-        triggerRetry: true,
-        configWatcher: false,
-        inviteMembers: false,
-        manageBilling: false,
-        configAiTools: true,
-        manageTeam: false
-      }
-    };
-    ROLE_PRIORITY = [
-      ROLES.OWNER,
-      ROLES.ADMIN,
-      ROLES.REPO_MANAGER,
-      ROLES.MEMBER
-    ];
-  }
-});
-
-// ../../packages/shared/src/index.ts
-var init_src = __esm({
-  "../../packages/shared/src/index.ts"() {
-    "use strict";
-    init_typed_resolution();
-    init_billing();
-    init_platforms();
-    init_tiers();
-    init_roles();
-  }
-});
-
-// ../listener/dist/typed-resolution/sidecar-cache.js
-var sidecar_cache_exports = {};
-__export(sidecar_cache_exports, {
-  loadMergedSidecar: () => loadMergedSidecar,
-  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 dirname5, join as join14 } from "path";
-function repoIdSafe(repoId) {
-  return /^[A-Za-z0-9_.-]{1,128}$/.test(repoId) && !repoId.startsWith(".");
-}
-function commitShaSafe(commitSha) {
-  return /^[a-f0-9]{7,64}$/.test(commitSha);
-}
-function sidecarCachePaths(repoId, commitSha) {
-  if (!repoIdSafe(repoId)) {
-    throw new Error(`unsafe repoId: ${repoId}`);
-  }
-  if (!commitShaSafe(commitSha)) {
-    throw new Error(`unsafe commitSha: ${commitSha}`);
-  }
-  const repoDir = join14(getConfigDir(), "typed-resolution", repoId);
-  const fullPath = join14(repoDir, `${commitSha}.jsonl`);
-  return { fullPath, repoDir };
-}
-async function persistMergedSidecar(repoId, commitSha, sidecar) {
-  const { fullPath, repoDir } = sidecarCachePaths(repoId, commitSha);
-  await mkdir8(repoDir, { recursive: true });
-  const tmpPath = `${fullPath}.tmp`;
-  await writeFile8(tmpPath, JSON.stringify(sidecar), "utf-8");
-  const { rename: rename5 } = await import("fs/promises");
-  await rename5(tmpPath, fullPath);
-  try {
-    await sweepSidecarDir(repoDir);
-  } catch {
-  }
-}
-async function sweepSidecarDir(repoDir) {
-  const entries = await readdir3(repoDir);
-  const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
-  if (jsonlFiles.length <= SWEEP_KEEP_MIN)
-    return;
-  const withMtime = [];
-  for (const name of jsonlFiles) {
-    try {
-      const s = await stat2(join14(repoDir, name));
-      withMtime.push({ name, mtimeMs: s.mtimeMs });
-    } catch {
-    }
-  }
-  withMtime.sort((a, b) => b.mtimeMs - a.mtimeMs);
-  const now = Date.now();
-  const candidates = withMtime.slice(SWEEP_KEEP_MIN);
-  for (const { name, mtimeMs } of candidates) {
-    if (now - mtimeMs >= SWEEP_MAX_AGE_MS) {
-      try {
-        await unlink7(join14(repoDir, name));
-      } catch {
-      }
-    }
-  }
-}
-function isValidSidecarEntry(e) {
-  if (!e || typeof e !== "object")
-    return false;
-  const r = e;
-  if (typeof r["filePath"] !== "string")
-    return false;
-  if (typeof r["propertyName"] !== "string")
-    return false;
-  if (typeof r["line"] !== "number" || !Number.isInteger(r["line"]))
-    return false;
-  if (typeof r["column"] !== "number" || !Number.isInteger(r["column"]))
-    return false;
-  if (typeof r["confidence"] !== "number")
-    return false;
-  return true;
-}
-async function loadMergedSidecar(repoId, commitSha) {
-  let body;
-  try {
-    const { fullPath } = sidecarCachePaths(repoId, commitSha);
-    body = await readFile7(fullPath, "utf-8");
-  } catch {
-    return null;
-  }
-  try {
-    const parsed = JSON.parse(body);
-    if (parsed.schemaVersion !== TYPED_RESOLUTION_SCHEMA_VERSION)
-      return null;
-    if (!Array.isArray(parsed.resolutions))
-      return null;
-    const all = parsed.resolutions;
-    const valid = all.filter(isValidSidecarEntry);
-    if (valid.length === 0 && all.length > 0)
-      return null;
-    if (valid.length < all.length * 0.5)
-      return null;
-    return { ...parsed, resolutions: valid };
-  } catch {
-    return null;
-  }
-}
-var SWEEP_MAX_AGE_MS, SWEEP_KEEP_MIN;
-var init_sidecar_cache = __esm({
-  "../listener/dist/typed-resolution/sidecar-cache.js"() {
-    "use strict";
-    init_config_dir();
-    init_src();
-    SWEEP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
-    SWEEP_KEEP_MIN = 5;
-  }
-});
-
-// ../listener/dist/typed-resolution/sidecar-client.js
-var sidecar_client_exports = {};
-__export(sidecar_client_exports, {
-  buildSidecar: () => buildSidecar,
-  buildSidecarIndex: () => buildSidecarIndex,
-  downloadMergedSidecar: () => downloadMergedSidecar,
-  overlayMergedSidecar: () => overlayMergedSidecar,
-  uploadSidecar: () => uploadSidecar
-});
-async function uploadSidecar(req, fetchImpl = fetch) {
-  const url = `${req.apiUrl.replace(/\/$/, "")}/v1/repos/${encodeURIComponent(req.repoId)}/typed-resolution`;
-  const body = JSON.stringify({ ...req.sidecar, commitSha: req.commitSha });
-  const byteLength = Buffer.byteLength(body, "utf8");
-  if (byteLength > UPLOAD_BODY_BYTE_LIMIT) {
-    const msg = `sidecar body too large to upload (${byteLength.toString()} bytes > ${UPLOAD_BODY_BYTE_LIMIT.toString()} byte cap); skipping`;
-    console.warn(`[typed-resolution] ${msg}`);
-    return {
-      uploaded: false,
-      resolutionCount: req.sidecar.resolutions.length,
-      uploadKey: "",
-      error: msg
-    };
-  }
-  const res = await fetchImpl(url, {
-    method: "POST",
-    headers: {
-      "content-type": "application/json",
-      authorization: `Bearer ${req.authToken}`
-    },
-    body
-  });
-  if (!res.ok) {
-    const text = await res.text().catch(() => "");
-    throw new Error(`upload failed: HTTP ${res.status.toString()} ${text}`);
-  }
-  const payload = await res.json();
-  if (!payload.data)
-    throw new Error("upload response missing `data`");
-  return payload.data;
-}
-async function downloadMergedSidecar(req, fetchImpl = fetch) {
-  const url = `${req.apiUrl.replace(/\/$/, "")}/v1/repos/${encodeURIComponent(req.repoId)}/typed-resolution/${encodeURIComponent(req.commitSha)}`;
-  const res = await fetchImpl(url, {
-    method: "GET",
-    headers: { authorization: `Bearer ${req.authToken}` }
-  });
-  if (res.status === 404)
-    return null;
-  if (!res.ok) {
-    throw new Error(`download failed: HTTP ${res.status.toString()}`);
-  }
-  const body = await res.json();
-  if (body.schemaVersion !== TYPED_RESOLUTION_SCHEMA_VERSION)
-    return null;
-  if (!Array.isArray(body.resolutions))
-    return null;
-  return body;
-}
-function buildSidecarIndex(sidecar) {
-  const map = /* @__PURE__ */ new Map();
-  if (!sidecar)
-    return map;
-  for (const r of sidecar.resolutions) {
-    map.set(typedResolutionKey(r.filePath, r.propertyName, r.line, r.column), r);
-  }
-  return map;
-}
-function overlayMergedSidecar(edges, sidecar) {
-  let edgesUpgraded = 0;
-  let edgesUnchanged = 0;
-  const index = buildSidecarIndex(sidecar);
-  for (const edge of edges) {
-    if (!edge.filePath || !edge.propertyName || !edge.location || edge.resolution === "typed") {
-      edgesUnchanged += 1;
-      continue;
-    }
-    const key = typedResolutionKey(edge.filePath, edge.propertyName, edge.location.line, edge.location.column);
-    const hit = index.get(key);
-    if (!hit || hit.targetSymbolId === null) {
-      edgesUnchanged += 1;
-      continue;
-    }
-    edge.to = hit.targetSymbolId;
-    edge.resolution = "typed";
-    edge.confidence = hit.confidence;
-    edgesUpgraded += 1;
-  }
-  return { edgesUpgraded, edgesUnchanged };
-}
-async function buildSidecar(req) {
-  const groupKeyFn = req.groupKey ?? (() => "default");
-  const groups = /* @__PURE__ */ new Map();
-  req.receivers.forEach((receiver, index) => {
-    const key = groupKeyFn(receiver) ?? "__default__";
-    let bucket = groups.get(key);
-    if (!bucket) {
-      bucket = [];
-      groups.set(key, bucket);
-    }
-    bucket.push({ index, receiver });
-  });
-  const resolutions = new Array(req.receivers.length);
-  await Promise.all(Array.from(groups.values()).map(async (bucket) => {
-    for (const { index, receiver } of bucket) {
-      let targetSymbolId;
-      try {
-        targetSymbolId = await req.resolve(receiver);
-      } catch (err) {
-        console.warn(`[typed-resolution] resolve failed for ${receiver.filePath}:${receiver.line.toString()}:${receiver.column.toString()} property=${receiver.propertyName} errMsg=${err instanceof Error ? err.message : String(err)}`);
-        targetSymbolId = null;
-      }
-      resolutions[index] = {
-        filePath: receiver.filePath,
-        propertyName: receiver.propertyName,
-        line: receiver.line,
-        column: receiver.column,
-        targetSymbolId,
-        confidence: 0.9
-      };
-    }
-  }));
-  return {
-    schemaVersion: TYPED_RESOLUTION_SCHEMA_VERSION,
-    producer: req.producer,
-    emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    languages: [...req.languages],
-    resolutions
-  };
-}
-var UPLOAD_BODY_BYTE_LIMIT;
-var init_sidecar_client = __esm({
-  "../listener/dist/typed-resolution/sidecar-client.js"() {
-    "use strict";
-    init_src();
-    UPLOAD_BODY_BYTE_LIMIT = 8 * 1024 * 1024;
-  }
-});
-
 // ../listener/dist/lsp/registry.js
 function detectLanguage(path) {
   const dot = path.lastIndexOf(".");
@@ -895,7 +497,8 @@ var init_registry = __esm({
           args: ["--stdio"],
           extensions: [".ts", ".tsx", ".mts", ".cts"],
           lspLanguageId: "typescript",
-          installHint: "npm i -g typescript typescript-language-server"
+          installHint: "npm i -g typescript typescript-language-server",
+          npmPackage: "typescript-language-server"
         }
       ],
       javascript: [
@@ -906,7 +509,8 @@ var init_registry = __esm({
           args: ["--stdio"],
           extensions: [".js", ".jsx", ".mjs", ".cjs"],
           lspLanguageId: "javascript",
-          installHint: "npm i -g typescript typescript-language-server"
+          installHint: "npm i -g typescript typescript-language-server",
+          npmPackage: "typescript-language-server"
         }
       ],
       python: [
@@ -917,7 +521,8 @@ var init_registry = __esm({
           args: ["--stdio"],
           extensions: [".py", ".pyi"],
           lspLanguageId: "python",
-          installHint: "npm i -g pyright"
+          installHint: "npm i -g pyright",
+          npmPackage: "pyright"
         },
         {
           id: "pylsp",
@@ -1009,7 +614,8 @@ var init_registry = __esm({
           args: ["--stdio"],
           extensions: [".php"],
           lspLanguageId: "php",
-          installHint: "npm i -g intelephense"
+          installHint: "npm i -g intelephense",
+          npmPackage: "intelephense"
         }
       ],
       ruby: [
@@ -1095,7 +701,8 @@ var init_registry = __esm({
           args: ["--stdio"],
           extensions: [".vue"],
           lspLanguageId: "vue",
-          installHint: "npm i -g @vue/language-server"
+          installHint: "npm i -g @vue/language-server",
+          npmPackage: "@vue/language-server"
         }
       ],
       svelte: [
@@ -1106,13 +713,412 @@ var init_registry = __esm({
           args: ["--stdio"],
           extensions: [".svelte"],
           lspLanguageId: "svelte",
-          installHint: "npm i -g svelte-language-server"
+          installHint: "npm i -g svelte-language-server",
+          npmPackage: "svelte-language-server"
         }
       ]
     };
   }
 });
 
+// ../../packages/shared/src/types/typed-resolution.ts
+function typedResolutionKey(filePath, propertyName, line, column) {
+  return `${filePath}\0${propertyName}\0${line.toString()}\0${column.toString()}`;
+}
+var TYPED_RESOLUTION_SCHEMA_VERSION;
+var init_typed_resolution = __esm({
+  "../../packages/shared/src/types/typed-resolution.ts"() {
+    "use strict";
+    TYPED_RESOLUTION_SCHEMA_VERSION = 1;
+  }
+});
+
+// ../../packages/shared/src/types/billing.ts
+var init_billing = __esm({
+  "../../packages/shared/src/types/billing.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/src/constants/platforms.ts
+var init_platforms = __esm({
+  "../../packages/shared/src/constants/platforms.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/shared/src/constants/tiers.ts
+var SUBSCRIPTION_TIERS, TIER_LIMITS;
+var init_tiers = __esm({
+  "../../packages/shared/src/constants/tiers.ts"() {
+    "use strict";
+    SUBSCRIPTION_TIERS = {
+      STARTER: "starter",
+      PRO: "pro",
+      TEAM: "team"
+    };
+    TIER_LIMITS = {
+      [SUBSCRIPTION_TIERS.STARTER]: {
+        maxRepos: 1,
+        maxSeats: 1,
+        maxSyncsPerMonth: 10,
+        maxConcurrentSyncs: 1,
+        bedrockEndpoint: "public"
+      },
+      [SUBSCRIPTION_TIERS.PRO]: {
+        maxRepos: 2,
+        maxSeats: 1,
+        maxSyncsPerMonth: 30,
+        maxConcurrentSyncs: 2,
+        bedrockEndpoint: "public"
+      },
+      [SUBSCRIPTION_TIERS.TEAM]: {
+        maxRepos: 3,
+        maxSeats: 999999,
+        maxSyncsPerMonth: 30,
+        maxConcurrentSyncs: 10,
+        bedrockEndpoint: "public"
+      }
+    };
+  }
+});
+
+// ../../packages/shared/src/constants/roles.ts
+function hasPermission(role, permission) {
+  return PERMISSIONS[role][permission];
+}
+function resolveRole(groups) {
+  for (const role of ROLE_PRIORITY) {
+    if (groups.includes(role)) return role;
+  }
+  return ROLES.MEMBER;
+}
+var ROLES, PERMISSIONS, ROLE_PRIORITY;
+var init_roles = __esm({
+  "../../packages/shared/src/constants/roles.ts"() {
+    "use strict";
+    ROLES = {
+      OWNER: "owner",
+      ADMIN: "admin",
+      REPO_MANAGER: "repo_manager",
+      MEMBER: "member"
+    };
+    PERMISSIONS = {
+      [ROLES.OWNER]: {
+        connectRepos: true,
+        viewSync: true,
+        triggerRetry: true,
+        configWatcher: true,
+        inviteMembers: true,
+        manageBilling: true,
+        configAiTools: true,
+        manageTeam: true
+      },
+      [ROLES.ADMIN]: {
+        connectRepos: true,
+        viewSync: true,
+        triggerRetry: true,
+        configWatcher: true,
+        inviteMembers: true,
+        manageBilling: false,
+        configAiTools: true,
+        manageTeam: true
+      },
+      [ROLES.REPO_MANAGER]: {
+        connectRepos: true,
+        viewSync: true,
+        triggerRetry: true,
+        configWatcher: true,
+        inviteMembers: false,
+        manageBilling: false,
+        configAiTools: true,
+        manageTeam: false
+      },
+      [ROLES.MEMBER]: {
+        connectRepos: false,
+        viewSync: true,
+        triggerRetry: true,
+        configWatcher: false,
+        inviteMembers: false,
+        manageBilling: false,
+        configAiTools: true,
+        manageTeam: false
+      }
+    };
+    ROLE_PRIORITY = [
+      ROLES.OWNER,
+      ROLES.ADMIN,
+      ROLES.REPO_MANAGER,
+      ROLES.MEMBER
+    ];
+  }
+});
+
+// ../../packages/shared/src/index.ts
+var init_src = __esm({
+  "../../packages/shared/src/index.ts"() {
+    "use strict";
+    init_typed_resolution();
+    init_billing();
+    init_platforms();
+    init_tiers();
+    init_roles();
+  }
+});
+
+// ../listener/dist/typed-resolution/sidecar-cache.js
+var sidecar_cache_exports = {};
+__export(sidecar_cache_exports, {
+  loadMergedSidecar: () => loadMergedSidecar,
+  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 dirname5, join as join15 } from "path";
+function repoIdSafe(repoId) {
+  return /^[A-Za-z0-9_.-]{1,128}$/.test(repoId) && !repoId.startsWith(".");
+}
+function commitShaSafe(commitSha) {
+  return /^[a-f0-9]{7,64}$/.test(commitSha);
+}
+function sidecarCachePaths(repoId, commitSha) {
+  if (!repoIdSafe(repoId)) {
+    throw new Error(`unsafe repoId: ${repoId}`);
+  }
+  if (!commitShaSafe(commitSha)) {
+    throw new Error(`unsafe commitSha: ${commitSha}`);
+  }
+  const repoDir = join15(getConfigDir(), "typed-resolution", repoId);
+  const fullPath = join15(repoDir, `${commitSha}.jsonl`);
+  return { fullPath, repoDir };
+}
+async function persistMergedSidecar(repoId, commitSha, sidecar) {
+  const { fullPath, repoDir } = sidecarCachePaths(repoId, commitSha);
+  await mkdir8(repoDir, { recursive: true });
+  const tmpPath = `${fullPath}.tmp`;
+  await writeFile8(tmpPath, JSON.stringify(sidecar), "utf-8");
+  const { rename: rename5 } = await import("fs/promises");
+  await rename5(tmpPath, fullPath);
+  try {
+    await sweepSidecarDir(repoDir);
+  } catch {
+  }
+}
+async function sweepSidecarDir(repoDir) {
+  const entries = await readdir3(repoDir);
+  const jsonlFiles = entries.filter((e) => e.endsWith(".jsonl"));
+  if (jsonlFiles.length <= SWEEP_KEEP_MIN)
+    return;
+  const withMtime = [];
+  for (const name of jsonlFiles) {
+    try {
+      const s = await stat2(join15(repoDir, name));
+      withMtime.push({ name, mtimeMs: s.mtimeMs });
+    } catch {
+    }
+  }
+  withMtime.sort((a, b) => b.mtimeMs - a.mtimeMs);
+  const now = Date.now();
+  const candidates = withMtime.slice(SWEEP_KEEP_MIN);
+  for (const { name, mtimeMs } of candidates) {
+    if (now - mtimeMs >= SWEEP_MAX_AGE_MS) {
+      try {
+        await unlink7(join15(repoDir, name));
+      } catch {
+      }
+    }
+  }
+}
+function isValidSidecarEntry(e) {
+  if (!e || typeof e !== "object")
+    return false;
+  const r = e;
+  if (typeof r["filePath"] !== "string")
+    return false;
+  if (typeof r["propertyName"] !== "string")
+    return false;
+  if (typeof r["line"] !== "number" || !Number.isInteger(r["line"]))
+    return false;
+  if (typeof r["column"] !== "number" || !Number.isInteger(r["column"]))
+    return false;
+  if (typeof r["confidence"] !== "number")
+    return false;
+  return true;
+}
+async function loadMergedSidecar(repoId, commitSha) {
+  let body;
+  try {
+    const { fullPath } = sidecarCachePaths(repoId, commitSha);
+    body = await readFile7(fullPath, "utf-8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.schemaVersion !== TYPED_RESOLUTION_SCHEMA_VERSION)
+      return null;
+    if (!Array.isArray(parsed.resolutions))
+      return null;
+    const all = parsed.resolutions;
+    const valid = all.filter(isValidSidecarEntry);
+    if (valid.length === 0 && all.length > 0)
+      return null;
+    if (valid.length < all.length * 0.5)
+      return null;
+    return { ...parsed, resolutions: valid };
+  } catch {
+    return null;
+  }
+}
+var SWEEP_MAX_AGE_MS, SWEEP_KEEP_MIN;
+var init_sidecar_cache = __esm({
+  "../listener/dist/typed-resolution/sidecar-cache.js"() {
+    "use strict";
+    init_config_dir();
+    init_src();
+    SWEEP_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+    SWEEP_KEEP_MIN = 5;
+  }
+});
+
+// ../listener/dist/typed-resolution/sidecar-client.js
+var sidecar_client_exports = {};
+__export(sidecar_client_exports, {
+  buildSidecar: () => buildSidecar,
+  buildSidecarIndex: () => buildSidecarIndex,
+  downloadMergedSidecar: () => downloadMergedSidecar,
+  overlayMergedSidecar: () => overlayMergedSidecar,
+  uploadSidecar: () => uploadSidecar
+});
+async function uploadSidecar(req, fetchImpl = fetch) {
+  const url = `${req.apiUrl.replace(/\/$/, "")}/v1/repos/${encodeURIComponent(req.repoId)}/typed-resolution`;
+  const body = JSON.stringify({ ...req.sidecar, commitSha: req.commitSha });
+  const byteLength = Buffer.byteLength(body, "utf8");
+  if (byteLength > UPLOAD_BODY_BYTE_LIMIT) {
+    const msg = `sidecar body too large to upload (${byteLength.toString()} bytes > ${UPLOAD_BODY_BYTE_LIMIT.toString()} byte cap); skipping`;
+    console.warn(`[typed-resolution] ${msg}`);
+    return {
+      uploaded: false,
+      resolutionCount: req.sidecar.resolutions.length,
+      uploadKey: "",
+      error: msg
+    };
+  }
+  const res = await fetchImpl(url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${req.authToken}`
+    },
+    body
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`upload failed: HTTP ${res.status.toString()} ${text}`);
+  }
+  const payload = await res.json();
+  if (!payload.data)
+    throw new Error("upload response missing `data`");
+  return payload.data;
+}
+async function downloadMergedSidecar(req, fetchImpl = fetch) {
+  const url = `${req.apiUrl.replace(/\/$/, "")}/v1/repos/${encodeURIComponent(req.repoId)}/typed-resolution/${encodeURIComponent(req.commitSha)}`;
+  const res = await fetchImpl(url, {
+    method: "GET",
+    headers: { authorization: `Bearer ${req.authToken}` }
+  });
+  if (res.status === 404)
+    return null;
+  if (!res.ok) {
+    throw new Error(`download failed: HTTP ${res.status.toString()}`);
+  }
+  const body = await res.json();
+  if (body.schemaVersion !== TYPED_RESOLUTION_SCHEMA_VERSION)
+    return null;
+  if (!Array.isArray(body.resolutions))
+    return null;
+  return body;
+}
+function buildSidecarIndex(sidecar) {
+  const map = /* @__PURE__ */ new Map();
+  if (!sidecar)
+    return map;
+  for (const r of sidecar.resolutions) {
+    map.set(typedResolutionKey(r.filePath, r.propertyName, r.line, r.column), r);
+  }
+  return map;
+}
+function overlayMergedSidecar(edges, sidecar) {
+  let edgesUpgraded = 0;
+  let edgesUnchanged = 0;
+  const index = buildSidecarIndex(sidecar);
+  for (const edge of edges) {
+    if (!edge.filePath || !edge.propertyName || !edge.location || edge.resolution === "typed") {
+      edgesUnchanged += 1;
+      continue;
+    }
+    const key = typedResolutionKey(edge.filePath, edge.propertyName, edge.location.line, edge.location.column);
+    const hit = index.get(key);
+    if (!hit || hit.targetSymbolId === null) {
+      edgesUnchanged += 1;
+      continue;
+    }
+    edge.to = hit.targetSymbolId;
+    edge.resolution = "typed";
+    edge.confidence = hit.confidence;
+    edgesUpgraded += 1;
+  }
+  return { edgesUpgraded, edgesUnchanged };
+}
+async function buildSidecar(req) {
+  const groupKeyFn = req.groupKey ?? (() => "default");
+  const groups = /* @__PURE__ */ new Map();
+  req.receivers.forEach((receiver, index) => {
+    const key = groupKeyFn(receiver) ?? "__default__";
+    let bucket = groups.get(key);
+    if (!bucket) {
+      bucket = [];
+      groups.set(key, bucket);
+    }
+    bucket.push({ index, receiver });
+  });
+  const resolutions = new Array(req.receivers.length);
+  await Promise.all(Array.from(groups.values()).map(async (bucket) => {
+    for (const { index, receiver } of bucket) {
+      let targetSymbolId;
+      try {
+        targetSymbolId = await req.resolve(receiver);
+      } catch (err) {
+        console.warn(`[typed-resolution] resolve failed for ${receiver.filePath}:${receiver.line.toString()}:${receiver.column.toString()} property=${receiver.propertyName} errMsg=${err instanceof Error ? err.message : String(err)}`);
+        targetSymbolId = null;
+      }
+      resolutions[index] = {
+        filePath: receiver.filePath,
+        propertyName: receiver.propertyName,
+        line: receiver.line,
+        column: receiver.column,
+        targetSymbolId,
+        confidence: 0.9
+      };
+    }
+  }));
+  return {
+    schemaVersion: TYPED_RESOLUTION_SCHEMA_VERSION,
+    producer: req.producer,
+    emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    languages: [...req.languages],
+    resolutions
+  };
+}
+var UPLOAD_BODY_BYTE_LIMIT;
+var init_sidecar_client = __esm({
+  "../listener/dist/typed-resolution/sidecar-client.js"() {
+    "use strict";
+    init_src();
+    UPLOAD_BODY_BYTE_LIMIT = 8 * 1024 * 1024;
+  }
+});
+
 // ../listener/dist/lsp/lsp-tools.js
 var lsp_tools_exports = {};
 __export(lsp_tools_exports, {
@@ -1466,13 +1472,13 @@ var init_lsp_tools = __esm({
 // bin/repowise.ts
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname16, join as join36 } from "path";
+import { dirname as dirname17, join as join45 } from "path";
 import { Command } from "commander";
 
 // ../listener/dist/main.js
 init_config_dir();
-import { readFile as readFile12, writeFile as writeFile14, mkdir as mkdir14 } from "fs/promises";
-import { join as join18, dirname as dirname11 } from "path";
+import { readFile as readFile12, writeFile as writeFile14, mkdir as mkdir14, stat as fsStat } from "fs/promises";
+import { join as join27, dirname as dirname12 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import lockfile3 from "proper-lockfile";
 
@@ -2761,7 +2767,7 @@ async function stopListener() {
 
 // ../listener/dist/mcp/bootstrap.js
 init_config_dir();
-import { join as join17 } from "path";
+import { join as join18 } from "path";
 
 // ../listener/dist/lsp/workspace-session.js
 import { pathToFileURL } from "url";
@@ -3016,25 +3022,193 @@ var LspClient = class extends EventEmitter {
       this.emit("notification", msg["method"], msg["params"]);
       return;
     }
-    if (msg["method"] !== void 0 && msg["id"] !== void 0) {
-      const method = msg["method"];
-      const reqId = msg["id"];
-      if (this.listenerCount("request") === 0) {
-        this.respondError(reqId, -32601, `method not found: ${method}`);
+    if (msg["method"] !== void 0 && msg["id"] !== void 0) {
+      const method = msg["method"];
+      const reqId = msg["id"];
+      if (this.listenerCount("request") === 0) {
+        this.respondError(reqId, -32601, `method not found: ${method}`);
+        return;
+      }
+      this.emit("request", method, msg["params"], reqId);
+    }
+  }
+  failAllPending(err) {
+    for (const pending of this.pending.values()) {
+      if (pending.timer)
+        clearTimeout(pending.timer);
+      pending.reject(err);
+    }
+    this.pending.clear();
+  }
+};
+
+// ../listener/dist/lsp/installer.js
+init_config_dir();
+init_registry();
+import { promises as fs } from "fs";
+import { join as join14 } from "path";
+import { spawn as spawn3 } from "child_process";
+function getLspInstallDir() {
+  return join14(getConfigDir(), "lsp-servers");
+}
+function getLspBinDir() {
+  return join14(getLspInstallDir(), "node_modules", ".bin");
+}
+async function ensureNpmLspInstalled(config2) {
+  if (!config2.npmPackage)
+    return { installed: false, skipped: "no-npm-package" };
+  const installDir = getLspInstallDir();
+  const binPath = join14(installDir, "node_modules", ".bin", config2.command);
+  if (await pathExists(binPath)) {
+    return { installed: false, skipped: "already-present" };
+  }
+  try {
+    await fs.mkdir(installDir, { recursive: true });
+    const pkgJsonPath = join14(installDir, "package.json");
+    if (!await pathExists(pkgJsonPath)) {
+      await fs.writeFile(pkgJsonPath, JSON.stringify({ name: "repowise-lsp-servers", private: true, version: "0.0.0" }, null, 2), "utf-8");
+    }
+    await runNpmInstall(installDir, config2.npmPackage);
+    if (!await pathExists(binPath)) {
+      return {
+        installed: false,
+        error: `npm install completed but ${config2.command} still not at ${binPath}`
+      };
+    }
+    return { installed: true };
+  } catch (err) {
+    return {
+      installed: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
+function runNpmInstall(cwd, pkg2) {
+  return new Promise((resolve4, reject) => {
+    const child = spawn3("npm", ["install", "--no-audit", "--no-fund", "--silent", pkg2], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env }
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => reject(err));
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve4();
+      } else {
+        reject(new Error(`npm install ${pkg2} exited ${(code ?? -1).toString()}: ${sanitizeNpmStderr(stderr)}`));
+      }
+    });
+  });
+}
+function sanitizeNpmStderr(raw) {
+  const truncated = raw.split("\n").slice(0, 3).join(" ").trim();
+  return truncated.replace(/(https?:\/\/)[^@\s/]*@/g, (_match, scheme) => `${scheme}<redacted>@`);
+}
+async function pathExists(p) {
+  try {
+    await fs.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function detectRepoLanguages(repoRoot) {
+  const found = /* @__PURE__ */ new Set();
+  let inspected = 0;
+  const MAX_INSPECT = 200;
+  async function inspect(dir) {
+    if (inspected >= MAX_INSPECT)
+      return;
+    let entries;
+    try {
+      entries = await fs.readdir(dir);
+    } catch {
+      return;
+    }
+    for (const name of entries) {
+      if (inspected >= MAX_INSPECT)
         return;
+      if (name.startsWith("."))
+        continue;
+      if (name === "node_modules" || name === "dist" || name === "build")
+        continue;
+      const lang = detectLanguage(name);
+      if (lang) {
+        found.add(lang);
+        inspected += 1;
       }
-      this.emit("request", method, msg["params"], reqId);
     }
   }
-  failAllPending(err) {
-    for (const pending of this.pending.values()) {
-      if (pending.timer)
-        clearTimeout(pending.timer);
-      pending.reject(err);
+  await inspect(repoRoot);
+  let topEntries = [];
+  try {
+    topEntries = await fs.readdir(repoRoot);
+  } catch {
+    return found;
+  }
+  for (const name of topEntries) {
+    if (name.startsWith("."))
+      continue;
+    if (name === "node_modules" || name === "dist" || name === "build")
+      continue;
+    const sub = join14(repoRoot, name);
+    try {
+      const stat7 = await fs.stat(sub);
+      if (stat7.isDirectory())
+        await inspect(sub);
+    } catch {
     }
-    this.pending.clear();
   }
-};
+  return found;
+}
+async function prepareLspServersForRepos(repos) {
+  const detected = /* @__PURE__ */ new Set();
+  for (const r of repos) {
+    if (!r.localPath)
+      continue;
+    try {
+      const stat7 = await fs.stat(r.localPath);
+      if (!stat7.isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    try {
+      const langs = await detectRepoLanguages(r.localPath);
+      for (const l of langs)
+        detected.add(l);
+    } catch {
+    }
+  }
+  const results = [];
+  for (const language of detected) {
+    const configs = LSP_REGISTRY[language];
+    const npmConfig = configs.find((c) => c.npmPackage);
+    if (!npmConfig) {
+      results.push({
+        language,
+        installed: false,
+        alreadyPresent: false,
+        skippedNoNpmPackage: true,
+        hint: configs[0]?.installHint
+      });
+      continue;
+    }
+    const outcome = await ensureNpmLspInstalled(npmConfig);
+    results.push({
+      language,
+      installed: outcome.installed,
+      alreadyPresent: outcome.skipped === "already-present",
+      skippedNoNpmPackage: false,
+      error: outcome.error
+    });
+  }
+  return results;
+}
 
 // ../listener/dist/lsp/workspace-session.js
 function keyOf(args) {
@@ -3050,10 +3224,14 @@ var WorkspaceManager = class {
     this.idleTimeoutMs = opts.idleTimeoutMs ?? 10 * 60 * 1e3;
     this.maxSessions = opts.maxSessions ?? 32;
     this.clientFactory = opts.clientFactory ?? ((config2, cwd) => {
+      const env = { ...process.env };
+      const lspBin = getLspBinDir();
+      env.PATH = env.PATH ? `${env.PATH}:${lspBin}` : lspBin;
       const client = new LspClient({
         command: config2.command,
         args: config2.args,
-        cwd
+        cwd,
+        env
       });
       client.on("stderr", (line) => {
         process.stderr.write(`[lsp:${config2.id}] ${line}`);
@@ -3381,7 +3559,7 @@ var PathEscapeError = class extends Error {
 // ../listener/dist/mcp/graph-cache.js
 init_config_dir();
 import { readFile as readFile8, stat as stat3 } from "fs/promises";
-import { join as join15 } from "path";
+import { join as join16 } from "path";
 var EVICT_DEBOUNCE_MS = 6e4;
 function assertSafeRepoId(repoId) {
   if (!repoId || typeof repoId !== "string") {
@@ -3396,7 +3574,7 @@ function assertSafeRepoId(repoId) {
 }
 function createGraphCache(options = {}) {
   const evictMs = options.evictDebounceMs ?? EVICT_DEBOUNCE_MS;
-  const resolvePath = options.resolveGraphPath ?? ((repoId) => join15(defaultRepoWiseHome(), "graphs", `${repoId}.json`));
+  const resolvePath = options.resolveGraphPath ?? ((repoId) => join16(defaultRepoWiseHome(), "graphs", `${repoId}.json`));
   const entries = /* @__PURE__ */ new Map();
   const inFlight = /* @__PURE__ */ new Map();
   async function loadFromDisk(repoId) {
@@ -3905,7 +4083,7 @@ async function isLocallyConsented(flagPath2) {
 init_config_dir();
 import { createServer } from "http";
 import { mkdir as mkdir13, writeFile as writeFile13 } from "fs/promises";
-import { dirname as dirname10, join as join16 } from "path";
+import { dirname as dirname10, join as join17 } from "path";
 import { createHash as createHash2, randomUUID as randomUUID2 } from "crypto";
 
 // ../listener/dist/mcp/sanitize.js
@@ -5258,7 +5436,7 @@ function extractBearer(header) {
   return m ? m[1] : null;
 }
 function defaultEndpointFile() {
-  return join16(getConfigDir(), "listener.endpoint");
+  return join17(getConfigDir(), "listener.endpoint");
 }
 
 // ../listener/dist/mcp/bootstrap.js
@@ -5266,7 +5444,7 @@ async function startMcp(options) {
   const disabled = process.env.REPOWISE_MCP_DISABLED === "true";
   const graphsDir = options.graphsDir ?? defaultGraphsDir();
   const graphCache = createGraphCache({
-    resolveGraphPath: (repoId) => join17(graphsDir, `${repoId}.json`)
+    resolveGraphPath: (repoId) => join18(graphsDir, `${repoId}.json`)
   });
   if (disabled) {
     return {
@@ -5289,11 +5467,11 @@ async function startMcp(options) {
   }
   const firstRepoLocal = options.repos.find((r) => r.localPath)?.localPath;
   const mcpHome = defaultMcpHome();
-  const logFilePath = join17(mcpHome, "mcp-log.jsonl.enc");
-  const keyStore = createFileKeyStore(join17(mcpHome, "mcp-log.key"));
+  const logFilePath = join18(mcpHome, "mcp-log.jsonl.enc");
+  const keyStore = createFileKeyStore(join18(mcpHome, "mcp-log.key"));
   const mcpLogger = createMcpLogger({ filePath: logFilePath, keyStore });
-  const flagFilePath = join17(mcpHome, "mcp-log.flag");
-  const watermarkFilePath = join17(mcpHome, "mcp-log.watermark");
+  const flagFilePath = join18(mcpHome, "mcp-log.flag");
+  const watermarkFilePath = join18(mcpHome, "mcp-log.watermark");
   let uploader = null;
   let lastConsentState = false;
   function ensureUploader() {
@@ -5337,7 +5515,7 @@ async function startMcp(options) {
       apiBaseUrl: repo.apiUrl,
       getAuthToken: options.getAuthToken,
       repoId: repo.repoId,
-      targetPath: join17(graphsDir, `${repo.repoId}.json`),
+      targetPath: join18(graphsDir, `${repo.repoId}.json`),
       graphCache,
       ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
     }));
@@ -5413,7 +5591,7 @@ async function startMcp(options) {
           apiBaseUrl: repo.apiUrl,
           getAuthToken: options.getAuthToken,
           repoId: repo.repoId,
-          targetPath: join17(graphsDir, `${repo.repoId}.json`),
+          targetPath: join18(graphsDir, `${repo.repoId}.json`),
           graphCache,
           ...options.fetchImpl ? { fetchImpl: options.fetchImpl } : {}
         }));
@@ -5434,12 +5612,389 @@ async function startMcp(options) {
   };
 }
 function defaultGraphsDir() {
-  return join17(getConfigDir(), "graphs");
+  return join18(getConfigDir(), "graphs");
 }
 function defaultMcpHome() {
   return getConfigDir();
 }
 
+// ../listener/dist/mcp/auto-config/index.js
+import { homedir as homedir4 } from "os";
+
+// ../listener/dist/mcp/auto-config/writers/claude-code.js
+import { promises as fs3 } from "fs";
+import { join as join19 } from "path";
+
+// ../listener/dist/mcp/auto-config/markers.js
+import { promises as fs2 } from "fs";
+import { dirname as dirname11 } from "path";
+async function writeMergedConfig(params) {
+  const current = await readConfig(params.path);
+  const servers = { ...current.mcpServers ?? {} };
+  servers[params.serverName] = params.spec;
+  const next = { ...current, mcpServers: servers };
+  const canonical = canonicalize(next);
+  const existing = safeExistingContent(params.path, current);
+  if (existing === canonical)
+    return "unchanged";
+  await fs2.mkdir(dirname11(params.path), { recursive: true });
+  await fs2.writeFile(params.path, canonical, "utf-8");
+  return "written";
+}
+async function removeFromConfig(path, serverName) {
+  const current = await readConfig(path);
+  if (!current.mcpServers || !(serverName in current.mcpServers))
+    return;
+  const servers = { ...current.mcpServers };
+  delete servers[serverName];
+  const next = { ...current, mcpServers: servers };
+  if (Object.keys(servers).length === 0) {
+    delete next.mcpServers;
+  }
+  await fs2.writeFile(path, canonicalize(next), "utf-8");
+}
+async function readConfig(path) {
+  try {
+    const raw = await fs2.readFile(path, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (err.code === "ENOENT")
+      return {};
+    throw err;
+  }
+}
+function canonicalize(config2) {
+  const serversSorted = {};
+  if (config2.mcpServers) {
+    const keys = Object.keys(config2.mcpServers).sort();
+    for (const k of keys)
+      serversSorted[k] = normalizeSpec(config2.mcpServers[k]);
+  }
+  const top = {};
+  const otherKeys = Object.keys(config2).filter((k) => k !== "mcpServers").sort();
+  for (const k of otherKeys)
+    top[k] = config2[k];
+  if (Object.keys(serversSorted).length > 0)
+    top.mcpServers = serversSorted;
+  return JSON.stringify(top, null, 2) + "\n";
+}
+function normalizeSpec(spec) {
+  const out = { command: spec.command };
+  if (spec.args && spec.args.length > 0)
+    out.args = [...spec.args];
+  if (spec.env && Object.keys(spec.env).length > 0) {
+    const sorted = {};
+    for (const k of Object.keys(spec.env).sort())
+      sorted[k] = spec.env[k];
+    out.env = sorted;
+  }
+  return out;
+}
+function safeExistingContent(path, current) {
+  try {
+    return canonicalize(current);
+  } catch {
+    return null;
+  }
+  void path;
+}
+
+// ../listener/dist/mcp/auto-config/writers/claude-code.js
+var claudeCodeWriter = {
+  tool: "claude-code",
+  async detect(repoRoot, home) {
+    return await fileExists2(join19(repoRoot, "CLAUDE.md")) || await hasClaudeBinary(home);
+  },
+  async write(ctx) {
+    const path = join19(ctx.repoRoot, ".mcp.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join19(ctx.repoRoot, ".mcp.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists2(path) {
+  try {
+    await fs3.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function hasClaudeBinary(home) {
+  return fileExists2(join19(home, ".claude", "claude.json"));
+}
+
+// ../listener/dist/mcp/auto-config/writers/cline.js
+import { promises as fs4 } from "fs";
+import { join as join20 } from "path";
+var clineWriter = {
+  tool: "cline",
+  async detect(repoRoot, home) {
+    return await fileExists3(join20(repoRoot, ".clinerules")) || await fileExists3(join20(home, ".cline"));
+  },
+  async write(ctx) {
+    const path = join20(ctx.home, ".cline", "mcp.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join20(ctx.home, ".cline", "mcp.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists3(path) {
+  try {
+    await fs4.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/codex.js
+import { promises as fs5 } from "fs";
+import { join as join21 } from "path";
+var codexWriter = {
+  tool: "codex",
+  async detect(_repoRoot, home) {
+    return fileExists4(join21(home, ".codex"));
+  },
+  async write(ctx) {
+    const path = join21(ctx.home, ".codex", "mcp.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join21(ctx.home, ".codex", "mcp.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists4(path) {
+  try {
+    await fs5.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/copilot.js
+import { promises as fs6 } from "fs";
+import { join as join22 } from "path";
+var copilotWriter = {
+  tool: "copilot",
+  async detect(repoRoot) {
+    return fileExists5(join22(repoRoot, ".vscode"));
+  },
+  async write(ctx) {
+    const path = join22(ctx.repoRoot, ".vscode", "mcp.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join22(ctx.repoRoot, ".vscode", "mcp.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists5(path) {
+  try {
+    await fs6.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/cursor.js
+import { promises as fs7 } from "fs";
+import { join as join23 } from "path";
+var cursorWriter = {
+  tool: "cursor",
+  async detect(repoRoot) {
+    return await fileExists6(join23(repoRoot, ".cursor")) || await fileExists6(join23(repoRoot, ".cursorrules"));
+  },
+  async write(ctx) {
+    const path = join23(ctx.repoRoot, ".cursor", "mcp.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join23(ctx.repoRoot, ".cursor", "mcp.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists6(path) {
+  try {
+    await fs7.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/gemini-cli.js
+import { promises as fs8 } from "fs";
+import { join as join24 } from "path";
+var geminiCliWriter = {
+  tool: "gemini-cli",
+  async detect(_repoRoot, home) {
+    return fileExists7(join24(home, ".gemini"));
+  },
+  async write(ctx) {
+    const path = join24(ctx.home, ".gemini", "settings.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join24(ctx.home, ".gemini", "settings.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists7(path) {
+  try {
+    await fs8.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/roo.js
+import { promises as fs9 } from "fs";
+import { join as join25 } from "path";
+var rooWriter = {
+  tool: "roo",
+  async detect(repoRoot, home) {
+    return await fileExists8(join25(repoRoot, ".roo")) || await fileExists8(join25(home, ".roo"));
+  },
+  async write(ctx) {
+    const repoConfig = join25(ctx.repoRoot, ".roo", "mcp.json");
+    const useRepoScope = await fileExists8(join25(ctx.repoRoot, ".roo"));
+    const path = useRepoScope ? repoConfig : join25(ctx.home, ".roo", "mcp.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join25(ctx.repoRoot, ".roo", "mcp.json"), `repowise-${ctx.repoId}`);
+    await removeFromConfig(join25(ctx.home, ".roo", "mcp.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists8(path) {
+  try {
+    await fs9.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/windsurf.js
+import { promises as fs10 } from "fs";
+import { join as join26 } from "path";
+var windsurfWriter = {
+  tool: "windsurf",
+  async detect(_repoRoot, home) {
+    return fileExists9(join26(home, ".codeium", "windsurf"));
+  },
+  async write(ctx) {
+    const path = join26(ctx.home, ".codeium", "windsurf", "mcp_config.json");
+    const status2 = await writeMergedConfig({
+      path,
+      serverName: `repowise-${ctx.repoId}`,
+      spec: { command: ctx.shimCmd, args: ["--repo-id", ctx.repoId] }
+    });
+    return { status: status2, path };
+  },
+  async remove(ctx) {
+    await removeFromConfig(join26(ctx.home, ".codeium", "windsurf", "mcp_config.json"), `repowise-${ctx.repoId}`);
+  }
+};
+async function fileExists9(path) {
+  try {
+    await fs10.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ../listener/dist/mcp/auto-config/writers/index.js
+var WRITERS = [
+  claudeCodeWriter,
+  clineWriter,
+  codexWriter,
+  copilotWriter,
+  cursorWriter,
+  geminiCliWriter,
+  rooWriter,
+  windsurfWriter
+];
+
+// ../listener/dist/mcp/auto-config/index.js
+async function runAutoConfig(opts) {
+  const home = opts.home ?? homedir4();
+  const writers = opts.writers ?? WRITERS;
+  const results = [];
+  for (const writer of writers) {
+    let detected;
+    try {
+      detected = await writer.detect(opts.repoRoot, home);
+    } catch (err) {
+      results.push({
+        tool: writer.tool,
+        detected: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      continue;
+    }
+    if (!detected) {
+      results.push({ tool: writer.tool, detected: false });
+      continue;
+    }
+    try {
+      const outcome = await writer.write({
+        repoRoot: opts.repoRoot,
+        repoId: opts.repoId,
+        shimCmd: opts.shimCmd,
+        home
+      });
+      results.push({ tool: writer.tool, detected: true, outcome });
+    } catch (err) {
+      results.push({
+        tool: writer.tool,
+        detected: true,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return results;
+}
+
 // ../listener/dist/typed-resolution/resolver-loop.js
 init_src();
 init_registry();
@@ -5644,7 +6199,7 @@ var CRASH_LOOP_WINDOW_MS = 3e4;
 var CRASH_LOOP_THRESHOLD = 3;
 async function readRawToolConfig() {
   try {
-    const configPath = join18(getConfigDir(), "config.json");
+    const configPath = join27(getConfigDir(), "config.json");
     const data = await readFile12(configPath, "utf-8");
     const raw = JSON.parse(data);
     return {
@@ -5705,11 +6260,11 @@ function resolveAuditRoots() {
     return override.split(":").map((s) => s.trim()).filter(Boolean);
   }
   const out = /* @__PURE__ */ new Set();
-  let dir = dirname11(process.execPath);
+  let dir = dirname12(process.execPath);
   for (let i = 0; i < 8; i += 1) {
-    out.add(join18(dir, "node_modules"));
-    out.add(join18(dir, "lib", "node_modules"));
-    const parent = dirname11(dir);
+    out.add(join27(dir, "node_modules"));
+    out.add(join27(dir, "lib", "node_modules"));
+    const parent = dirname12(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -5928,7 +6483,7 @@ async function checkStaleContext(repos, state, groups) {
     if (group?.offline.isOffline)
       continue;
     const { statSync: statSync2, readdirSync: readdirSync2 } = await import("fs");
-    const contextPath = join18(repo.localPath, "repowise-context");
+    const contextPath = join27(repo.localPath, "repowise-context");
     let isMissingOrEmpty = false;
     try {
       const s = statSync2(contextPath);
@@ -5957,9 +6512,36 @@ async function checkStaleContext(repos, state, groups) {
   }
   return dirty;
 }
+async function reconcileMcpConfigs(repos, packageName) {
+  const shimCmd = packageName;
+  for (const repo of repos) {
+    if (!repo.localPath)
+      continue;
+    try {
+      const s = await fsStat(repo.localPath);
+      if (!s.isDirectory())
+        continue;
+    } catch {
+      continue;
+    }
+    try {
+      const results = await runAutoConfig({
+        repoRoot: repo.localPath,
+        repoId: repo.repoId,
+        shimCmd
+      });
+      const written = results.filter((r) => r.detected && r.outcome?.status === "written");
+      if (written.length > 0) {
+        console.log(`[mcp-config] Wrote ${written.length.toString()} config(s) for ${repo.repoId}: ${written.map((r) => `${r.tool}=${r.outcome.path}`).join(", ")}`);
+      }
+    } catch (err) {
+      console.warn(`[mcp-config] Reconcile failed for ${repo.repoId}:`, err instanceof Error ? err.message : String(err));
+    }
+  }
+}
 async function reconcileAgentInstructions(repos) {
   for (const repo of repos) {
-    const path = join18(repo.localPath, "repowise-context", "project-overview.md");
+    const path = join27(repo.localPath, "repowise-context", "project-overview.md");
     let content;
     try {
       content = await readFile12(path, "utf-8");
@@ -6021,7 +6603,7 @@ async function startListener() {
   }
   const configDir = getConfigDir();
   await mkdir14(configDir, { recursive: true });
-  const lockPath = join18(configDir, "listener.lock");
+  const lockPath = join27(configDir, "listener.lock");
   await writeFile14(lockPath, "", { flag: "a" });
   let lockIsHeld = false;
   try {
@@ -6064,7 +6646,7 @@ async function startListener() {
     return;
   }
   if (config2.repos.length === 0 && !config2.autoDiscoverRepos) {
-    console.error(`No repos configured. Add repos to ${join18(configDir, "config.json")}`);
+    console.error(`No repos configured. Add repos to ${join27(configDir, "config.json")}`);
     await releaseLockAndExit();
     process.exitCode = 1;
     return;
@@ -6131,8 +6713,8 @@ async function startListener() {
   const packageName = true ? "repowisestage" : "repowise";
   let currentVersion = "";
   try {
-    const selfDir = dirname11(fileURLToPath3(import.meta.url));
-    const pkgJsonPath = join18(selfDir, "..", "..", "package.json");
+    const selfDir = dirname12(fileURLToPath3(import.meta.url));
+    const pkgJsonPath = join27(selfDir, "..", "..", "package.json");
     const pkgJson = JSON.parse(await readFile12(pkgJsonPath, "utf-8"));
     currentVersion = pkgJson.version;
   } catch (err) {
@@ -6185,6 +6767,29 @@ async function startListener() {
   } catch (err) {
     console.warn("[reconcile] Initial agent instructions reconciliation failed:", err instanceof Error ? err.message : String(err));
   }
+  void (async () => {
+    try {
+      await reconcileMcpConfigs(config2.repos, packageName);
+    } catch (err) {
+      console.warn("[mcp-config] Initial MCP config reconciliation failed:", err instanceof Error ? err.message : String(err));
+    }
+  })();
+  void (async () => {
+    try {
+      const lspResults = await prepareLspServersForRepos(config2.repos);
+      for (const r of lspResults) {
+        if (r.installed) {
+          console.log(`[lsp-install] Installed ${r.language} LSP server`);
+        } else if (r.skippedNoNpmPackage && r.hint) {
+          console.log(`[lsp-install] ${r.language} LSP not auto-installable. To enable: ${r.hint}`);
+        } else if (r.error) {
+          console.warn(`[lsp-install] ${r.language} install failed: ${r.error}`);
+        }
+      }
+    } catch (err) {
+      console.warn("[lsp-install] Pre-install scan failed:", err instanceof Error ? err.message : String(err));
+    }
+  })();
   const typedResolutionHooks = mcpRuntime?.lspWorkspaces ? buildTypedResolutionHooks({
     workspaces: mcpRuntime.lspWorkspaces,
     graphCache: mcpRuntime.graphCache,
@@ -6385,6 +6990,11 @@ async function startListener() {
       } catch (err) {
         console.warn("[reconcile] Agent instructions reconciliation failed:", err instanceof Error ? err.message : String(err));
       }
+      try {
+        await reconcileMcpConfigs(config2.repos, packageName);
+      } catch (err) {
+        console.warn("[mcp-config] Reconciliation failed:", err instanceof Error ? err.message : String(err));
+      }
     }
     if (latestCliVersion && currentVersion && !config2.noAutoUpdate && (state.crashCount ?? 0) < CRASH_LOOP_THRESHOLD) {
       if (latestCliVersion !== state.lastUpdateTargetVersion) {
@@ -6448,12 +7058,12 @@ async function startListener() {
         } catch {
         }
       }
-      const credentialsPath = join18(getConfigDir(), "credentials.json");
+      const credentialsPath = join27(getConfigDir(), "credentials.json");
       let credentialsChanged = false;
       let watcher = null;
       try {
-        const fs8 = await import("fs");
-        watcher = fs8.watch(credentialsPath, () => {
+        const fs18 = await import("fs");
+        watcher = fs18.watch(credentialsPath, () => {
           credentialsChanged = true;
         });
       } catch {
@@ -6493,8 +7103,8 @@ if (isDirectRun) {
 }
 
 // src/lib/env.ts
-import { homedir as homedir4 } from "os";
-import { join as join19 } from "path";
+import { homedir as homedir5 } from "os";
+import { join as join28 } from "path";
 var IS_STAGING2 = true ? true : false;
 var PRODUCTION = {
   apiUrl: "https://api.repowise.ai",
@@ -6514,7 +7124,7 @@ function getEnvConfig() {
   return IS_STAGING2 ? STAGING : PRODUCTION;
 }
 function getConfigDir2() {
-  return join19(homedir4(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
+  return join28(homedir5(), IS_STAGING2 ? ".repowise-staging" : ".repowise");
 }
 function getPackageName() {
   return true ? "repowisestage" : "repowise";
@@ -6525,11 +7135,11 @@ 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 join20 } from "path";
+import { join as join29 } from "path";
 import lockfile4 from "proper-lockfile";
 async function getConfig() {
   try {
-    const data = await readFile13(join20(getConfigDir2(), "config.json"), "utf-8");
+    const data = await readFile13(join29(getConfigDir2(), "config.json"), "utf-8");
     return JSON.parse(data);
   } catch {
     return {};
@@ -6537,7 +7147,7 @@ async function getConfig() {
 }
 async function saveConfig(config2) {
   const dir = getConfigDir2();
-  const path = join20(dir, "config.json");
+  const path = join29(dir, "config.json");
   await mkdir15(dir, { recursive: true });
   const tmpPath = path + ".tmp";
   try {
@@ -6553,7 +7163,7 @@ async function saveConfig(config2) {
 }
 async function mergeAndSaveConfig(updates) {
   const dir = getConfigDir2();
-  const path = join20(dir, "config.json");
+  const path = join29(dir, "config.json");
   await mkdir15(dir, { recursive: true });
   try {
     await writeFile15(path, "", { flag: "a" });
@@ -6624,7 +7234,7 @@ async function showWelcome(currentVersion) {
 
 // src/commands/create.ts
 import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname12, join as join24 } from "path";
+import { dirname as dirname13, join as join33 } from "path";
 init_src();
 import chalk5 from "chalk";
 import ora from "ora";
@@ -6633,7 +7243,7 @@ import ora from "ora";
 import { createHash as createHash3, 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 http from "http";
-import { join as join21 } from "path";
+import { join as join30 } from "path";
 var CLI_CALLBACK_PORT = 19876;
 var CALLBACK_TIMEOUT_MS = 12e4;
 function getCognitoConfigForStorage() {
@@ -6799,7 +7409,7 @@ async function refreshTokens2(refreshToken) {
 }
 async function getStoredCredentials2() {
   try {
-    const credPath = join21(getConfigDir2(), "credentials.json");
+    const credPath = join30(getConfigDir2(), "credentials.json");
     const data = await readFile14(credPath, "utf-8");
     return JSON.parse(data);
   } catch (err) {
@@ -6811,14 +7421,14 @@ async function getStoredCredentials2() {
 }
 async function storeCredentials2(credentials) {
   const dir = getConfigDir2();
-  const credPath = join21(dir, "credentials.json");
+  const credPath = join30(dir, "credentials.json");
   await mkdir16(dir, { recursive: true, mode: 448 });
   await writeFile16(credPath, JSON.stringify(credentials, null, 2));
   await chmod4(credPath, 384);
 }
 async function clearCredentials() {
   try {
-    await unlink10(join21(getConfigDir2(), "credentials.json"));
+    await unlink10(join30(getConfigDir2(), "credentials.json"));
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
@@ -7025,10 +7635,10 @@ async function selectAiTools() {
 
 // src/lib/ai-tools.ts
 import { readFile as readFile15, writeFile as writeFile17, mkdir as mkdir17 } from "fs/promises";
-import { join as join22 } from "path";
+import { join as join31 } from "path";
 var REPOWISE_HOOK_MARKER = "repowise-context";
 async function writeClaudeSubagentHook(repoRoot, contextFolder) {
-  const settingsPath = join22(repoRoot, ".claude", "settings.json");
+  const settingsPath = join31(repoRoot, ".claude", "settings.json");
   let settings = {};
   try {
     const raw = await readFile15(settingsPath, "utf-8");
@@ -7063,15 +7673,15 @@ async function writeClaudeSubagentHook(repoRoot, contextFolder) {
   }
   hooks["SubagentStart"] = subagentStart;
   settings["hooks"] = hooks;
-  await mkdir17(join22(repoRoot, ".claude"), { recursive: true });
+  await mkdir17(join31(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 } from "fs";
-import { join as join23 } from "path";
+import { join as join32 } from "path";
 function ensureGitignore(repoRoot, entry) {
-  const gitignorePath = join23(repoRoot, ".gitignore");
+  const gitignorePath = join32(repoRoot, ".gitignore");
   if (existsSync(gitignorePath)) {
     const content = readFileSync2(gitignorePath, "utf-8");
     const lines = content.split("\n").map((l) => l.trim());
@@ -7861,7 +8471,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 = join24(repoRoot, DEFAULT_CONTEXT_FOLDER);
+          const contextDir = join33(repoRoot, DEFAULT_CONTEXT_FOLDER);
           mkdirSync(contextDir, { recursive: true });
           let downloadedCount = 0;
           let failedCount = 0;
@@ -7875,8 +8485,8 @@ async function create() {
             const response = await fetch(presignedUrl);
             if (response.ok) {
               const content = await response.text();
-              const filePath = join24(contextDir, file.fileName);
-              mkdirSync(dirname12(filePath), { recursive: true });
+              const filePath = join33(contextDir, file.fileName);
+              mkdirSync(dirname13(filePath), { recursive: true });
               writeFileSync2(filePath, content, "utf-8");
               downloadedCount++;
             } else {
@@ -8017,7 +8627,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 dirname13, join as join25, resolve, sep } from "path";
+import { dirname as dirname14, join as join34, resolve, sep } from "path";
 import chalk6 from "chalk";
 import ora2 from "ora";
 var DEFAULT_CONTEXT_FOLDER2 = "repowise-context";
@@ -8141,7 +8751,7 @@ async function member() {
     spinner.succeed(`Found ${chalk6.bold(files.length)} context files on server`);
     const { tools } = await selectAiTools();
     spinner.start("Downloading context files...");
-    const contextDir = join25(repoRoot, DEFAULT_CONTEXT_FOLDER2);
+    const contextDir = join34(repoRoot, DEFAULT_CONTEXT_FOLDER2);
     mkdirSync2(contextDir, { recursive: true });
     let downloadedCount = 0;
     let failedCount = 0;
@@ -8162,7 +8772,7 @@ async function member() {
         const response = await fetch(presignedUrl);
         if (response.ok) {
           const content = await response.text();
-          mkdirSync2(dirname13(safePath), { recursive: true });
+          mkdirSync2(dirname14(safePath), { recursive: true });
           writeFileSync3(safePath, content, "utf-8");
           downloadedCount++;
         } else {
@@ -8286,15 +8896,15 @@ import chalk7 from "chalk";
 import ora3 from "ora";
 
 // src/lib/tenant-graph-purge.ts
-import { promises as fs } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join26 } from "path";
-async function purgeForeignGraphs(validRepoIds, home = homedir5()) {
-  const graphsDir = join26(home, ".repowise", "graphs");
+import { promises as fs11 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join35 } from "path";
+async function purgeForeignGraphs(validRepoIds, home = homedir6()) {
+  const graphsDir = join35(home, ".repowise", "graphs");
   const result = { kept: [], removed: [] };
   let entries;
   try {
-    entries = await fs.readdir(graphsDir);
+    entries = await fs11.readdir(graphsDir);
   } catch (err) {
     if (err.code === "ENOENT") return result;
     throw err;
@@ -8308,15 +8918,15 @@ async function purgeForeignGraphs(validRepoIds, home = homedir5()) {
       result.kept.push(entry);
       continue;
     }
-    const path = join26(graphsDir, entry);
+    const path = join35(graphsDir, entry);
     try {
-      const stat7 = await fs.lstat(path);
+      const stat7 = await fs11.lstat(path);
       if (stat7.isSymbolicLink()) {
-        await fs.unlink(path);
+        await fs11.unlink(path);
         result.removed.push(entry);
         continue;
       }
-      await fs.rm(path, { recursive: true, force: true });
+      await fs11.rm(path, { recursive: true, force: true });
       result.removed.push(entry);
     } catch {
     }
@@ -8401,11 +9011,11 @@ async function logout() {
 
 // src/commands/status.ts
 import { readFile as readFile16 } from "fs/promises";
-import { basename as basename2, join as join27 } from "path";
+import { basename as basename2, join as join36 } from "path";
 async function status() {
   const configDir = getConfigDir2();
-  const STATE_PATH = join27(configDir, "listener-state.json");
-  const CONFIG_PATH = join27(configDir, "config.json");
+  const STATE_PATH = join36(configDir, "listener-state.json");
+  const CONFIG_PATH = join36(configDir, "config.json");
   let state = null;
   try {
     const data = await readFile16(STATE_PATH, "utf-8");
@@ -8453,7 +9063,7 @@ async function status() {
 
 // src/commands/sync.ts
 import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname14, join as join28 } from "path";
+import { dirname as dirname15, join as join37 } from "path";
 import chalk9 from "chalk";
 import ora4 from "ora";
 var POLL_INTERVAL_MS2 = 3e3;
@@ -8602,7 +9212,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 = join28(repoRoot, DEFAULT_CONTEXT_FOLDER3);
+        const contextDir = join37(repoRoot, DEFAULT_CONTEXT_FOLDER3);
         mkdirSync3(contextDir, { recursive: true });
         let downloadedCount = 0;
         let failedCount = 0;
@@ -8616,8 +9226,8 @@ async function sync() {
           const response = await fetch(presignedUrl);
           if (response.ok) {
             const content = await response.text();
-            const filePath = join28(contextDir, file.fileName);
-            mkdirSync3(dirname14(filePath), { recursive: true });
+            const filePath = join37(contextDir, file.fileName);
+            mkdirSync3(dirname15(filePath), { recursive: true });
             writeFileSync4(filePath, content, "utf-8");
             downloadedCount++;
           } else {
@@ -8869,7 +9479,7 @@ 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 dirname15, join as join29 } from "path";
+import { dirname as dirname16, join as join38 } from "path";
 var FLAG_FILE = "mcp-log.flag";
 var LOG_FILE = "mcp-log.jsonl.enc";
 var KEY_FILE = "mcp-log.key";
@@ -8877,10 +9487,10 @@ var ENDPOINT_FILE = "listener.endpoint";
 var IV_BYTES2 = 12;
 var TAG_BYTES2 = 16;
 function flagPath() {
-  return join29(getConfigDir2(), FLAG_FILE);
+  return join38(getConfigDir2(), FLAG_FILE);
 }
 function logPath() {
-  return join29(getConfigDir2(), LOG_FILE);
+  return join38(getConfigDir2(), LOG_FILE);
 }
 async function readFlag() {
   try {
@@ -8896,7 +9506,7 @@ async function readFlag() {
 }
 async function writeFlag(flag) {
   const path = flagPath();
-  await mkdir18(dirname15(path), { recursive: true });
+  await mkdir18(dirname16(path), { recursive: true });
   await writeFile18(path, JSON.stringify(flag, null, 2), { encoding: "utf-8", mode: 384 });
 }
 async function showConsentPrompt() {
@@ -8967,14 +9577,14 @@ async function trySendConsentToServer() {
   let apiUrl = null;
   let token = null;
   try {
-    const body = await readFile17(join29(getConfigDir2(), "config.json"), "utf-8");
+    const body = await readFile17(join38(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(join29(getConfigDir2(), "credentials.json"), "utf-8");
+    const body = await readFile17(join38(getConfigDir2(), "credentials.json"), "utf-8");
     const parsed = JSON.parse(body);
     token = parsed.idToken ?? null;
   } catch {
@@ -9027,7 +9637,7 @@ async function mcpLogStatus() {
     process.stderr.write("Log size:        no file yet\n");
   }
   try {
-    const endpointBody = await readFile17(join29(getConfigDir2(), ENDPOINT_FILE), "utf-8");
+    const endpointBody = await readFile17(join38(getConfigDir2(), ENDPOINT_FILE), "utf-8");
     const match = /endpoint=([^\n]+)/.exec(endpointBody);
     process.stderr.write(`MCP endpoint:    ${match?.[1] ?? "(malformed endpoint file)"}
 `);
@@ -9054,7 +9664,7 @@ Run \`repowise mcp-log on\` to grant consent and view them.
   const key = await readKey();
   if (!key) {
     process.stderr.write(
-      `No encryption key at ${join29(getConfigDir2(), KEY_FILE)} \u2014 listener may not have started yet.
+      `No encryption key at ${join38(getConfigDir2(), KEY_FILE)} \u2014 listener may not have started yet.
 `
     );
     return;
@@ -9130,7 +9740,7 @@ Run \`repowise mcp-log on\` to grant consent and view them.
 }
 async function readKey() {
   try {
-    const body = await readFile17(join29(getConfigDir2(), KEY_FILE), "utf-8");
+    const body = await readFile17(join38(getConfigDir2(), KEY_FILE), "utf-8");
     const parsed = Buffer.from(body.trim(), "base64");
     if (parsed.length !== 32) return null;
     return parsed;
@@ -9173,8 +9783,8 @@ async function mcpLog(subcommand, flags = {}) {
 import chalk11 from "chalk";
 
 // src/lib/graph-loader.ts
-import { promises as fs2 } from "fs";
-import { join as join30, resolve as resolve2 } from "path";
+import { promises as fs12 } from "fs";
+import { join as join39, 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";
@@ -9191,8 +9801,8 @@ var GraphNotFoundError = class extends Error {
 var cache = /* @__PURE__ */ new Map();
 async function loadGraph(repoRoot = process.cwd()) {
   const root = resolve2(repoRoot);
-  const gzPath = join30(root, GZIPPED_GRAPH_PATH);
-  const plainPath = join30(root, RELATIVE_GRAPH_PATH);
+  const gzPath = join39(root, GZIPPED_GRAPH_PATH);
+  const plainPath = join39(root, RELATIVE_GRAPH_PATH);
   const cached = cache.get(root);
   if (cached) {
     return { graph: cached, path: plainPath, bytes: 0, parseMs: 0, fromCache: true };
@@ -9200,14 +9810,14 @@ async function loadGraph(repoRoot = process.cwd()) {
   let graphPath = null;
   let raw = null;
   try {
-    raw = await fs2.readFile(gzPath);
+    raw = await fs12.readFile(gzPath);
     graphPath = gzPath;
   } catch (err) {
     if (err.code !== "ENOENT") throw err;
   }
   if (!raw) {
     try {
-      raw = await fs2.readFile(plainPath);
+      raw = await fs12.readFile(plainPath);
       graphPath = plainPath;
     } catch (err) {
       if (err.code === "ENOENT") {
@@ -9606,14 +10216,14 @@ function registerQueryCommand(program2) {
 }
 
 // src/commands/uninstall.ts
-import { promises as fs6 } from "fs";
-import { homedir as homedir7 } from "os";
-import { join as join34 } from "path";
+import { promises as fs16 } from "fs";
+import { homedir as homedir8 } from "os";
+import { join as join43 } from "path";
 import chalk12 from "chalk";
 
 // src/lib/cleanup/marker-blocks.ts
-import { promises as fs3 } from "fs";
-import { join as join31 } from "path";
+import { promises as fs13 } from "fs";
+import { join as join40 } from "path";
 var MARKER_START = "<!-- repowise-start -->";
 var MARKER_END = "<!-- repowise-end -->";
 var CONTEXT_FILES = [
@@ -9629,7 +10239,7 @@ var CONTEXT_FILES = [
 async function stripMarkerBlock(filePath) {
   let raw;
   try {
-    raw = await fs3.readFile(filePath, "utf-8");
+    raw = await fs13.readFile(filePath, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT")
       return { path: filePath, status: "missing" };
@@ -9644,16 +10254,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 fs3.unlink(filePath);
+    await fs13.unlink(filePath);
     return { path: filePath, status: "deleted" };
   }
-  await fs3.writeFile(filePath, stripped + "\n", "utf-8");
+  await fs13.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 = join31(repoRoot, relative);
+    const full = join40(repoRoot, relative);
     const result = await stripMarkerBlock(full).catch((err) => ({
       path: full,
       status: "untouched",
@@ -9665,25 +10275,25 @@ async function stripAllMarkerBlocks(repoRoot) {
 }
 
 // src/lib/cleanup/mcp-configs.ts
-import { promises as fs4 } from "fs";
-import { join as join32 } from "path";
+import { promises as fs14 } from "fs";
+import { join as join41 } from "path";
 function mcpConfigPaths(repoRoot, home) {
   return [
-    join32(repoRoot, ".mcp.json"),
-    join32(repoRoot, ".cursor", "mcp.json"),
-    join32(repoRoot, ".vscode", "mcp.json"),
-    join32(repoRoot, ".roo", "mcp.json"),
-    join32(home, ".cline", "mcp.json"),
-    join32(home, ".codeium", "windsurf", "mcp_config.json"),
-    join32(home, ".gemini", "settings.json"),
-    join32(home, ".codex", "mcp.json"),
-    join32(home, ".roo", "mcp.json")
+    join41(repoRoot, ".mcp.json"),
+    join41(repoRoot, ".cursor", "mcp.json"),
+    join41(repoRoot, ".vscode", "mcp.json"),
+    join41(repoRoot, ".roo", "mcp.json"),
+    join41(home, ".cline", "mcp.json"),
+    join41(home, ".codeium", "windsurf", "mcp_config.json"),
+    join41(home, ".gemini", "settings.json"),
+    join41(home, ".codex", "mcp.json"),
+    join41(home, ".roo", "mcp.json")
   ];
 }
 async function removeRepowiseFromConfig(path, serverName) {
   let raw;
   try {
-    raw = await fs4.readFile(path, "utf-8");
+    raw = await fs14.readFile(path, "utf-8");
   } catch (err) {
     if (err.code === "ENOENT") return { path, status: "not-found" };
     return { path, status: "error", error: err.message };
@@ -9703,7 +10313,7 @@ async function removeRepowiseFromConfig(path, serverName) {
   } else {
     next.mcpServers = servers;
   }
-  await fs4.writeFile(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
+  await fs14.writeFile(path, JSON.stringify(next, null, 2) + "\n", "utf-8");
   return { path, status: "removed" };
 }
 async function removeAllMcpEntries(repoRoot, home, repoId) {
@@ -9716,17 +10326,17 @@ async function removeAllMcpEntries(repoRoot, home, repoId) {
 }
 
 // src/lib/cleanup/local-state.ts
-import { promises as fs5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join33, resolve as resolve3 } from "path";
+import { promises as fs15 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join42, resolve as resolve3 } from "path";
 async function clearLocalState(homeOverride) {
-  const home = homeOverride ?? homedir6();
-  const target = resolve3(join33(home, ".repowise"));
+  const home = homeOverride ?? homedir7();
+  const target = resolve3(join42(home, ".repowise"));
   if (target === resolve3(home) || !target.startsWith(resolve3(home))) {
     return { path: target, status: "error", error: "refused: not under home" };
   }
   try {
-    await fs5.rm(target, { recursive: true, force: false });
+    await fs15.rm(target, { recursive: true, force: false });
     return { path: target, status: "removed" };
   } catch (err) {
     if (err.code === "ENOENT")
@@ -9756,7 +10366,7 @@ async function stopAndUninstallService(uninstaller) {
 // src/commands/uninstall.ts
 async function uninstall2(opts = {}) {
   const tier = opts.tier ?? "uninstall";
-  const home = opts.home ?? homedir7();
+  const home = opts.home ?? homedir8();
   const repoRoot = opts.repoRoot ?? process.cwd();
   const loadRepoIds = opts.loadRepoIds ?? defaultLoadRepoIds;
   const report = { tier, removed: [], preserved: [], skipped: [] };
@@ -9765,7 +10375,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 fs6.unlink(join34(home, ".repowise", "credentials.json"));
+    await fs16.unlink(join43(home, ".repowise", "credentials.json"));
     report.removed.push("credentials");
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -9792,7 +10402,7 @@ async function uninstall2(opts = {}) {
   const allPaths = mcpConfigPaths(repoRoot, home);
   for (const p of allPaths) {
     try {
-      await fs6.access(p);
+      await fs16.access(p);
     } catch {
     }
   }
@@ -9804,7 +10414,7 @@ async function uninstall2(opts = {}) {
 }
 async function defaultLoadRepoIds(home) {
   try {
-    const raw = await fs6.readFile(join34(home, ".repowise", "config.json"), "utf-8");
+    const raw = await fs16.readFile(join43(home, ".repowise", "config.json"), "utf-8");
     const parsed = JSON.parse(raw);
     return (parsed.repos ?? []).map((r) => r.repoId);
   } catch {
@@ -9850,13 +10460,13 @@ Done \u2014 ${report.removed.length} removed, ${report.skipped.length} skipped.
 }
 
 // src/commands/mcp-shim.ts
-import { promises as fs7 } from "fs";
+import { promises as fs17 } from "fs";
 import { createInterface as createInterface2 } from "readline";
-import { homedir as homedir8 } from "os";
-import { join as join35 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join44 } from "path";
 var DEFAULT_MAX = 200 * 1024;
 async function mcpShim(opts) {
-  const endpointPath = opts.endpointFile ?? join35(homedir8(), ".repowise", "listener.endpoint");
+  const endpointPath = opts.endpointFile ?? join44(homedir9(), ".repowise", "listener.endpoint");
   const stdin = opts.stdin ?? process.stdin;
   const stdout = opts.stdout ?? process.stdout;
   const stderr = opts.stderr ?? process.stderr;
@@ -9927,7 +10537,7 @@ async function mcpShim(opts) {
 }
 async function readEndpoint(path) {
   try {
-    const raw = (await fs7.readFile(path, "utf-8")).trim();
+    const raw = (await fs17.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 };
@@ -10141,14 +10751,14 @@ function writeError(stream, id, code, message) {
 
 // src/commands/lsp.ts
 init_registry();
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import chalk13 from "chalk";
 async function isOnPath(command) {
   if (/[^\w./+-]/.test(command)) return false;
   const isWin = process.platform === "win32";
   const probeCmd = isWin ? "where" : "which";
   return new Promise((resolve4) => {
-    const child = spawn3(probeCmd, [command], { stdio: "ignore" });
+    const child = spawn4(probeCmd, [command], { stdio: "ignore" });
     child.on("close", (code) => {
       resolve4(code === 0);
     });
@@ -10209,8 +10819,8 @@ async function lspDoctor() {
 
 // bin/repowise.ts
 var __filename = fileURLToPath4(import.meta.url);
-var __dirname = dirname16(__filename);
-var pkg = JSON.parse(readFileSync3(join36(__dirname, "..", "..", "package.json"), "utf-8"));
+var __dirname = dirname17(__filename);
+var pkg = JSON.parse(readFileSync3(join45(__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);