@cortexkit/aft-pi 0.16.0 → 0.17.0

package/dist/index.js

@@ -17,8 +17,8 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
 import { createRequire as createRequire3 } from "node:module";
-import { homedir as homedir7 } from "node:os";
-import { join as join9 } from "node:path";
+import { homedir as homedir8 } from "node:os";
+import { join as join12 } from "node:path";
 
 // src/shared/status.ts
 function asRecord(value) {
@@ -13880,7 +13880,10 @@ var LspServerSchema = LspServerEntrySchema.extend({
 var LspConfigSchema = exports_external.object({
   servers: exports_external.record(exports_external.string().trim().min(1), LspServerEntrySchema).optional(),
   disabled: exports_external.array(exports_external.string().trim().min(1)).optional(),
-  python: exports_external.enum(["pyright", "ty", "auto"]).optional()
+  python: exports_external.enum(["pyright", "ty", "auto"]).optional(),
+  auto_install: exports_external.boolean().optional(),
+  grace_days: exports_external.number().int().positive().optional(),
+  versions: exports_external.record(exports_external.string().trim().min(1), exports_external.string().trim().min(1)).optional()
 });
 var AftConfigSchema = exports_external.object({
   format_on_edit: exports_external.boolean().optional(),
@@ -13908,7 +13911,7 @@ function resolveLspConfigForConfigure(config2) {
   switch (config2.lsp?.python ?? "auto") {
     case "ty":
       experimentalTy = true;
-      disabled.add("pyright");
+      disabled.add("python");
       break;
     case "pyright":
       experimentalTy = false;
@@ -14060,26 +14063,76 @@ function mergeSemanticConfig(base, override) {
     return;
   return Object.fromEntries(Object.entries(semantic).filter(([, v]) => v !== undefined));
 }
+function mergeLspConfig(base, override) {
+  const projectSafe = {};
+  if (override?.python !== undefined)
+    projectSafe.python = override.python;
+  const userDisabled = base?.disabled ?? [];
+  const lsp = {
+    ...base,
+    ...projectSafe,
+    ...userDisabled.length > 0 ? { disabled: [...userDisabled] } : {}
+  };
+  if (Object.values(lsp).every((v) => v === undefined))
+    return;
+  return Object.fromEntries(Object.entries(lsp).filter(([, v]) => v !== undefined));
+}
+function getProjectLspStrippedKeys(lsp) {
+  if (!lsp)
+    return [];
+  const strippedKeys = [];
+  if (lsp.servers !== undefined)
+    strippedKeys.push("lsp.servers");
+  if (lsp.versions !== undefined)
+    strippedKeys.push("lsp.versions");
+  if (lsp.auto_install !== undefined)
+    strippedKeys.push("lsp.auto_install");
+  if (lsp.grace_days !== undefined)
+    strippedKeys.push("lsp.grace_days");
+  if (lsp.disabled !== undefined)
+    strippedKeys.push("lsp.disabled");
+  return strippedKeys;
+}
+var PROJECT_SAFE_TOP_LEVEL_FIELDS = new Set([
+  "tool_surface",
+  "format_on_edit",
+  "validate_on_edit",
+  "experimental_search_index",
+  "experimental_semantic_search",
+  "experimental_lsp_ty"
+]);
+function pickProjectSafeFields(override) {
+  const safe = {};
+  for (const key of PROJECT_SAFE_TOP_LEVEL_FIELDS) {
+    if (override[key] !== undefined) {
+      safe[key] = override[key];
+    }
+  }
+  return safe;
+}
+function getStrippedTopLevelKeys(override) {
+  const stripped = [];
+  if (override.restrict_to_project_root !== undefined)
+    stripped.push("restrict_to_project_root");
+  if (override.url_fetch_allow_private !== undefined)
+    stripped.push("url_fetch_allow_private");
+  if (override.max_callgraph_files !== undefined)
+    stripped.push("max_callgraph_files");
+  return stripped;
+}
 function mergeConfigs(base, override) {
   const disabledTools = [...base.disabled_tools ?? [], ...override.disabled_tools ?? []];
   const formatter = { ...base.formatter, ...override.formatter };
   const checker = { ...base.checker, ...override.checker };
   const semantic = mergeSemanticConfig(base.semantic, override.semantic);
-  const lspServers = { ...base.lsp?.servers, ...override.lsp?.servers };
-  const disabledLsp = [...base.lsp?.disabled ?? [], ...override.lsp?.disabled ?? []];
-  const lsp = {
-    ...base.lsp,
-    ...override.lsp,
-    ...Object.keys(lspServers).length > 0 ? { servers: lspServers } : {},
-    ...disabledLsp.length > 0 ? { disabled: [...new Set(disabledLsp)] } : {}
-  };
-  const { semantic: _stripSemantic, ...safeOverride } = override;
+  const lsp = mergeLspConfig(base.lsp, override.lsp);
+  const safeOverride = pickProjectSafeFields(override);
   return {
     ...base,
     ...safeOverride,
     ...Object.keys(formatter).length > 0 ? { formatter } : {},
     ...Object.keys(checker).length > 0 ? { checker } : {},
-    ...Object.values(lsp).some((value) => value !== undefined) ? { lsp } : {},
+    ...lsp ? { lsp } : {},
     semantic,
     ...disabledTools.length > 0 ? { disabled_tools: [...new Set(disabledTools)] } : {}
   };
@@ -14100,14 +14153,1377 @@ function loadAftConfig(projectDirectory) {
     if (projectConfig.semantic?.backend !== undefined || projectConfig.semantic?.base_url !== undefined || projectConfig.semantic?.api_key_env !== undefined) {
       warn("Ignoring semantic.backend/base_url/api_key_env from project config (security: use user config for external backends)");
     }
+    const strippedLspKeys = getProjectLspStrippedKeys(projectConfig.lsp);
+    if (strippedLspKeys.length > 0) {
+      warn(`Ignoring ${strippedLspKeys.join(", ")} from project config ${projectConfigPath} (security: these LSP settings only honor user-level config)`);
+    }
+    const strippedTopLevelKeys = getStrippedTopLevelKeys(projectConfig);
+    if (strippedTopLevelKeys.length > 0) {
+      warn(`Ignoring ${strippedTopLevelKeys.join(", ")} from project config ${projectConfigPath} (security: these settings only honor user-level config — a project should not weaken security boundaries for the user)`);
+    }
     config2 = mergeConfigs(config2, projectConfig);
   }
   return config2;
 }
 
-// src/notifications.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+// src/lsp-auto-install.ts
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { createReadStream, statSync as statSync2 } from "node:fs";
+
+// src/lsp-cache.ts
+import {
+  closeSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  openSync,
+  readFileSync as readFileSync2,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "node:fs";
+import { homedir as homedir2 } from "node:os";
 import { join as join3 } from "node:path";
+function aftCacheBase() {
+  const override = process.env.AFT_CACHE_DIR;
+  if (override && override.length > 0)
+    return override;
+  if (process.platform === "win32") {
+    const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
+    const base2 = localAppData || join3(homedir2(), "AppData", "Local");
+    return join3(base2, "aft");
+  }
+  const base = process.env.XDG_CACHE_HOME || join3(homedir2(), ".cache");
+  return join3(base, "aft");
+}
+function lspCacheRoot() {
+  return join3(aftCacheBase(), "lsp-packages");
+}
+function lspPackageDir(npmPackage) {
+  return join3(lspCacheRoot(), encodeURIComponent(npmPackage));
+}
+function lspBinaryPath(npmPackage, binary) {
+  return join3(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+}
+function lspBinDir(npmPackage) {
+  return join3(lspPackageDir(npmPackage), "node_modules", ".bin");
+}
+function isInstalled(npmPackage, binary) {
+  for (const candidate of lspBinaryCandidates(binary)) {
+    try {
+      if (statSync(join3(lspBinDir(npmPackage), candidate)).isFile())
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function lspBinaryCandidates(binary) {
+  if (process.platform !== "win32")
+    return [binary];
+  return [binary, `${binary}.cmd`, `${binary}.exe`, `${binary}.bat`];
+}
+var INSTALLED_META_FILE = ".aft-installed";
+function writeInstalledMetaIn(installDir, version2, sha256) {
+  try {
+    mkdirSync(installDir, { recursive: true });
+    const meta3 = {
+      version: version2,
+      installedAt: new Date().toISOString(),
+      ...sha256 ? { sha256 } : {}
+    };
+    writeFileSync(join3(installDir, INSTALLED_META_FILE), JSON.stringify(meta3), "utf8");
+  } catch (err) {
+    log(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
+  }
+}
+function readInstalledMetaIn(installDir) {
+  const path2 = join3(installDir, INSTALLED_META_FILE);
+  try {
+    if (!statSync(path2).isFile())
+      return null;
+    const raw = readFileSync2(path2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.version !== "string" || parsed.version.length === 0)
+      return null;
+    return {
+      version: parsed.version,
+      installedAt: typeof parsed.installedAt === "string" ? parsed.installedAt : "",
+      ...typeof parsed.sha256 === "string" && parsed.sha256.length > 0 ? { sha256: parsed.sha256 } : {}
+    };
+  } catch {
+    return null;
+  }
+}
+function writeInstalledMeta(packageKey, version2, sha256) {
+  writeInstalledMetaIn(lspPackageDir(packageKey), version2, sha256);
+}
+function readInstalledMeta(packageKey) {
+  return readInstalledMetaIn(lspPackageDir(packageKey));
+}
+function lockPath(npmPackage) {
+  return join3(lspPackageDir(npmPackage), ".aft-installing");
+}
+var STALE_LOCK_MS = 30 * 60 * 1000;
+function acquireInstallLock(lockKey) {
+  mkdirSync(lspPackageDir(lockKey), { recursive: true });
+  const lock = lockPath(lockKey);
+  const tryClaim = () => {
+    try {
+      const fd = openSync(lock, "wx");
+      try {
+        writeFileSync(fd, `${process.pid}
+${new Date().toISOString()}
+`);
+      } finally {
+        closeSync(fd);
+      }
+      return true;
+    } catch (err) {
+      const code = err.code;
+      if (code === "EEXIST")
+        return false;
+      warn(`[lsp] unexpected error acquiring install lock for ${lockKey}: ${err}`);
+      return false;
+    }
+  };
+  if (tryClaim())
+    return true;
+  let owningPid = null;
+  let lockMtimeMs = 0;
+  try {
+    const raw = readFileSync2(lock, "utf8");
+    const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? "";
+    const parsed = Number.parseInt(firstLine, 10);
+    if (Number.isFinite(parsed) && parsed > 0)
+      owningPid = parsed;
+    lockMtimeMs = statSync(lock).mtimeMs;
+  } catch {
+    return tryClaim();
+  }
+  const age = Date.now() - lockMtimeMs;
+  const ageWithinFresh = Math.abs(age) < STALE_LOCK_MS;
+  const skipLiveness = process.platform === "win32";
+  const ownerAlive = !skipLiveness && owningPid !== null && isProcessAlive(owningPid);
+  if (skipLiveness ? ageWithinFresh : ownerAlive && ageWithinFresh) {
+    return false;
+  }
+  log(`[lsp] reclaiming install lock for ${lockKey} (owner_pid=${owningPid ?? "unknown"}, alive=${ownerAlive}, age_ms=${age})`);
+  try {
+    unlinkSync(lock);
+  } catch {}
+  return tryClaim();
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    const code = err.code;
+    if (code === "ESRCH")
+      return false;
+    return true;
+  }
+}
+function releaseInstallLock(lockKey) {
+  const lock = lockPath(lockKey);
+  try {
+    if (existsSync2(lock)) {
+      unlinkSync(lock);
+    }
+  } catch (err) {
+    warn(`[lsp] failed to release install lock for ${lockKey}: ${err}`);
+  }
+}
+async function withInstallLock(lockKey, task) {
+  if (!acquireInstallLock(lockKey))
+    return null;
+  try {
+    return await task();
+  } finally {
+    releaseInstallLock(lockKey);
+  }
+}
+var VERSION_CHECK_FILE = ".aft-version-check";
+function readVersionCheck(npmPackage) {
+  const file2 = join3(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  try {
+    const raw = readFileSync2(file2, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.last_checked === "string") {
+      return {
+        last_checked: parsed.last_checked,
+        latest_eligible: typeof parsed.latest_eligible === "string" ? parsed.latest_eligible : null
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function writeVersionCheck(npmPackage, latest) {
+  mkdirSync(lspPackageDir(npmPackage), { recursive: true });
+  const file2 = join3(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const record2 = {
+    last_checked: new Date().toISOString(),
+    latest_eligible: latest
+  };
+  writeFileSync(file2, JSON.stringify(record2, null, 2));
+}
+function shouldRecheckVersion(record2, weeklyCheckIntervalMs = 7 * 24 * 60 * 60 * 1000) {
+  if (!record2)
+    return true;
+  const age = Date.now() - new Date(record2.last_checked).getTime();
+  if (Number.isNaN(age) || age < 0)
+    return true;
+  return age >= weeklyCheckIntervalMs;
+}
+
+// src/lsp-github-probe.ts
+function pickEligibleRelease(releases, graceDays, now = Date.now()) {
+  const cutoff = now - graceDays * 24 * 60 * 60 * 1000;
+  const candidates = releases.filter((r) => !r.draft && !r.prerelease && typeof r.published_at === "string").map((r) => {
+    const ts = Date.parse(r.published_at);
+    return { release: r, ts };
+  }).filter((c) => !Number.isNaN(c.ts)).sort((a, b) => b.ts - a.ts);
+  const eligible = candidates.filter((c) => c.ts <= cutoff);
+  const blockedByGrace = candidates.length > 0 && eligible.length === 0;
+  const chosen = eligible[0]?.release;
+  if (!chosen) {
+    return { tag: null, assets: [], blockedByGrace };
+  }
+  return {
+    tag: chosen.tag_name,
+    assets: (chosen.assets ?? []).map((a) => ({
+      name: a.name,
+      url: a.browser_download_url,
+      size: a.size
+    })),
+    blockedByGrace: false
+  };
+}
+async function probeGithubReleases(githubRepo, graceDays, fetchImpl = fetch) {
+  const url2 = `https://api.github.com/repos/${githubRepo}/releases?per_page=30`;
+  try {
+    const headers = { accept: "application/vnd.github+json" };
+    if (process.env.GITHUB_TOKEN) {
+      headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+    }
+    const res = await fetchImpl(url2, {
+      headers,
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      warn(`[lsp] github releases probe failed for ${githubRepo}: HTTP ${res.status}`);
+      return null;
+    }
+    const json2 = await res.json();
+    if (!Array.isArray(json2)) {
+      warn(`[lsp] unexpected response shape from github releases for ${githubRepo}`);
+      return null;
+    }
+    return pickEligibleRelease(json2, graceDays);
+  } catch (err) {
+    warn(`[lsp] github releases probe failed for ${githubRepo}: ${err}`);
+    return null;
+  }
+}
+var SAFE_VERSION_RE = /^[A-Za-z0-9._+-]+$/;
+function assertSafeVersion(version2) {
+  if (!SAFE_VERSION_RE.test(version2)) {
+    throw new Error(`unsafe version/tag string ${JSON.stringify(version2)}: must match ${SAFE_VERSION_RE.source}`);
+  }
+}
+function stripTagV(tag) {
+  assertSafeVersion(tag);
+  return tag.startsWith("v") ? tag.slice(1) : tag;
+}
+
+// src/lsp-npm-table.ts
+var NPM_LSP_TABLE = [
+  {
+    id: "typescript",
+    npm: "typescript-language-server",
+    binary: "typescript-language-server",
+    extensions: ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts"],
+    rootMarkers: ["tsconfig.json", "jsconfig.json", "package.json"]
+  },
+  {
+    id: "python",
+    npm: "pyright",
+    binary: "pyright-langserver",
+    extensions: ["py", "pyi"],
+    rootMarkers: ["pyproject.toml", "pyrightconfig.json", "requirements.txt"]
+  },
+  {
+    id: "yaml",
+    npm: "yaml-language-server",
+    binary: "yaml-language-server",
+    extensions: ["yaml", "yml"]
+  },
+  {
+    id: "bash",
+    npm: "bash-language-server",
+    binary: "bash-language-server",
+    extensions: ["sh", "bash", "zsh"]
+  },
+  {
+    id: "dockerfile",
+    npm: "dockerfile-language-server-nodejs",
+    binary: "docker-langserver",
+    extensions: ["dockerfile"],
+    rootMarkers: ["Dockerfile", "dockerfile"]
+  },
+  {
+    id: "vue",
+    npm: "@vue/language-server",
+    binary: "vue-language-server",
+    extensions: ["vue"]
+  },
+  {
+    id: "astro",
+    npm: "@astrojs/language-server",
+    binary: "astro-ls",
+    extensions: ["astro"]
+  },
+  {
+    id: "svelte",
+    npm: "svelte-language-server",
+    binary: "svelteserver",
+    extensions: ["svelte"]
+  },
+  {
+    id: "php-intelephense",
+    npm: "intelephense",
+    binary: "intelephense",
+    extensions: ["php"]
+  },
+  {
+    id: "biome",
+    npm: "@biomejs/biome",
+    binary: "biome",
+    extensions: ["ts", "tsx", "js", "jsx", "mjs", "cjs", "mts", "cts", "json", "jsonc"],
+    rootMarkers: ["biome.json", "biome.jsonc"]
+  }
+];
+
+// src/lsp-project-relevance.ts
+import { existsSync as existsSync3, readdirSync } from "node:fs";
+import { join as join4 } from "node:path";
+var MAX_WALK_DIRS = 200;
+var MAX_WALK_DEPTH = 4;
+var NOISE_DIRS = new Set([
+  ".git",
+  ".next",
+  ".venv",
+  "__pycache__",
+  "build",
+  "dist",
+  "node_modules",
+  "target"
+]);
+function hasRootMarker(projectRoot, rootMarkers) {
+  if (!rootMarkers)
+    return false;
+  for (const marker of rootMarkers) {
+    if (existsSync3(join4(projectRoot, marker)))
+      return true;
+  }
+  return false;
+}
+function relevantExtensionsInProject(projectRoot, extToServer) {
+  const wanted = new Set(Object.keys(extToServer).map((ext) => ext.toLowerCase()));
+  const found = new Set;
+  if (wanted.size === 0)
+    return found;
+  const queue = [{ dir: projectRoot, depth: 0 }];
+  let visitedDirs = 0;
+  while (queue.length > 0 && visitedDirs < MAX_WALK_DIRS) {
+    const current = queue.shift();
+    if (!current)
+      break;
+    visitedDirs += 1;
+    let entries;
+    try {
+      entries = readdirSync(current.dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
+          queue.push({ dir: join4(current.dir, entry.name), depth: current.depth + 1 });
+        }
+        continue;
+      }
+      if (!entry.isFile())
+        continue;
+      const ext = extensionOf(entry.name);
+      if (ext && wanted.has(ext))
+        found.add(ext);
+    }
+  }
+  return found;
+}
+function extensionOf(fileName) {
+  const dot = fileName.lastIndexOf(".");
+  if (dot < 0 || dot === fileName.length - 1)
+    return null;
+  return fileName.slice(dot + 1).toLowerCase();
+}
+
+// src/lsp-registry-probe.ts
+var NPM_REGISTRY_BASE = "https://registry.npmjs.org";
+function pickEligibleVersion(response, graceDays, now = Date.now()) {
+  const times = response.time || {};
+  const cutoff = now - graceDays * 24 * 60 * 60 * 1000;
+  const candidates = [];
+  for (const [version2, publishedAt] of Object.entries(times)) {
+    if (version2 === "created" || version2 === "modified")
+      continue;
+    if (version2.includes("-"))
+      continue;
+    if (typeof publishedAt !== "string")
+      continue;
+    const ts = Date.parse(publishedAt);
+    if (Number.isNaN(ts))
+      continue;
+    candidates.push({ version: version2, publishedAt, ts });
+  }
+  candidates.sort((a, b) => b.ts - a.ts);
+  const eligible = candidates.filter((c) => c.ts <= cutoff);
+  const blockedByGrace = candidates.length > 0 && eligible.length === 0;
+  return {
+    version: eligible[0]?.version ?? null,
+    blockedByGrace,
+    eligible: eligible.map(({ version: version2, publishedAt }) => ({ version: version2, publishedAt }))
+  };
+}
+async function probeRegistry(npmPackage, graceDays, fetchImpl = fetch) {
+  const encoded = encodeURIComponent(npmPackage).replace(/^%40/, "@");
+  const url2 = `${NPM_REGISTRY_BASE}/${encoded}`;
+  try {
+    const res = await fetchImpl(url2, {
+      headers: { accept: "application/json" },
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!res.ok) {
+      warn(`[lsp] registry probe failed for ${npmPackage}: HTTP ${res.status}`);
+      return null;
+    }
+    const json2 = await res.json();
+    return pickEligibleVersion(json2, graceDays);
+  } catch (err) {
+    warn(`[lsp] registry probe failed for ${npmPackage}: ${err}`);
+    return null;
+  }
+}
+
+// src/lsp-auto-install.ts
+function isProjectRelevant(spec, projectRoot, projectExtensions) {
+  if (hasRootMarker(projectRoot, spec.rootMarkers))
+    return true;
+  const extensions = projectExtensions();
+  return spec.extensions.some((ext) => extensions.has(ext.toLowerCase()));
+}
+var npmExtToServerIds = buildExtensionMap(NPM_LSP_TABLE);
+function buildExtensionMap(specs) {
+  const byExt = {};
+  for (const spec of specs) {
+    for (const ext of spec.extensions) {
+      const key = ext.toLowerCase();
+      byExt[key] ??= [];
+      byExt[key].push(spec.id);
+    }
+  }
+  return byExt;
+}
+var inFlightAutoInstalls = new Set;
+function trackInFlightAutoInstall(controller, promise2) {
+  const entry = { controller, promise: promise2 };
+  inFlightAutoInstalls.add(entry);
+  promise2.then(() => inFlightAutoInstalls.delete(entry), () => inFlightAutoInstalls.delete(entry));
+  return promise2;
+}
+async function abortInFlightAutoInstalls() {
+  const installs = Array.from(inFlightAutoInstalls);
+  for (const install of installs) {
+    install.controller.abort();
+  }
+  await Promise.allSettled(installs.map((install) => install.promise));
+}
+async function resolveTargetVersion(spec, config2, fetchImpl = fetch) {
+  const pinned = config2.versions[spec.npm];
+  if (pinned) {
+    assertSafeVersion(pinned);
+    return { version: pinned, pinned: true, probe: null };
+  }
+  const cached2 = readVersionCheck(spec.npm);
+  const weeklyMs = config2.graceDays * 24 * 60 * 60 * 1000;
+  if (!shouldRecheckVersion(cached2, weeklyMs) && cached2?.latest_eligible) {
+    return { version: cached2.latest_eligible, pinned: false, probe: null };
+  }
+  const probe = await probeRegistry(spec.npm, config2.graceDays, fetchImpl);
+  if (!probe) {
+    return {
+      version: cached2?.latest_eligible ?? null,
+      pinned: false,
+      probe: null
+    };
+  }
+  writeVersionCheck(spec.npm, probe.version);
+  return { version: probe.version, pinned: false, probe };
+}
+function runInstall(spec, version2, cwd, signal) {
+  return new Promise((resolve) => {
+    const target = `${spec.npm}@${version2}`;
+    log(`[lsp] installing ${target} to ${cwd}`);
+    if (signal?.aborted) {
+      warn(`[lsp] install ${target} aborted before spawn`);
+      resolve(false);
+      return;
+    }
+    const child = spawn("bun", ["add", target, "--cwd", cwd, "--ignore-scripts", "--silent"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    child.unref();
+    let stderrBuf = "";
+    let settled = false;
+    let killTimer = null;
+    const cleanup = () => {
+      signal?.removeEventListener("abort", onAbort);
+      if (killTimer)
+        clearTimeout(killTimer);
+    };
+    const finish = (ok) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      resolve(ok);
+    };
+    const onAbort = () => {
+      warn(`[lsp] install ${target} aborted during shutdown`);
+      child.kill("SIGTERM");
+      killTimer = setTimeout(() => {
+        if (!settled)
+          child.kill("SIGKILL");
+      }, 5000);
+      killTimer.unref?.();
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted)
+      onAbort();
+    child.stdout?.on("data", () => {});
+    child.stderr?.on("data", (chunk) => {
+      const text = String(chunk);
+      stderrBuf += text;
+      if (stderrBuf.length > 4096) {
+        stderrBuf = stderrBuf.slice(stderrBuf.length - 4096);
+      }
+    });
+    child.on("error", (err) => {
+      error48(`[lsp] install ${target} failed to spawn: ${err}`);
+      finish(false);
+    });
+    child.on("exit", (code) => {
+      if (code === 0) {
+        log(`[lsp] installed ${target}`);
+        finish(true);
+      } else {
+        error48(`[lsp] install ${target} exited with code ${code}; last stderr:
+${stderrBuf.trim()}`);
+        finish(false);
+      }
+    });
+  });
+}
+async function ensureServerInstalled(spec, config2, fetchImpl, signal) {
+  const outcome = await withInstallLock(spec.npm, async () => {
+    const { version: version2, probe } = await resolveTargetVersion(spec, config2, fetchImpl);
+    if (!version2) {
+      const installed = isInstalled(spec.npm, spec.binary);
+      if (installed) {
+        warn(`[lsp] no eligible version of ${spec.npm} (grace=${config2.graceDays}d); keeping existing install`);
+        return { started: false, reason: "kept existing install" };
+      }
+      const blocked = probe?.blockedByGrace ? `all versions are within ${config2.graceDays}-day grace window` : "registry probe failed";
+      warn(`[lsp] skipping ${spec.npm}: ${blocked}`);
+      return { started: false, reason: blocked };
+    }
+    if (isInstalled(spec.npm, spec.binary)) {
+      const installedMeta = readInstalledMeta(spec.npm);
+      if (installedMeta && installedMeta.version === version2) {
+        if (installedMeta.sha256) {
+          const currentHash = await hashInstalledBinary(spec).catch((err) => {
+            warn(`[lsp] could not hash existing ${spec.npm} binary for TOFU check: ${err}`);
+            return null;
+          });
+          if (currentHash && currentHash !== installedMeta.sha256) {
+            error48(`[lsp] ${spec.npm}@${version2}: TOFU sha256 mismatch — refusing to use ` + `tampered binary. Recorded ${installedMeta.sha256}, current ${currentHash}. ` + `Run \`aft doctor --clear\` to re-install from scratch.`);
+            return {
+              started: false,
+              reason: `TOFU sha256 mismatch on ${spec.npm}@${version2} — see plugin log`
+            };
+          }
+        }
+        return { started: false, reason: "already installed" };
+      }
+      if (installedMeta) {
+        log(`[lsp] reinstalling ${spec.npm}: cached ${installedMeta.version} ≠ target ${version2}`);
+      } else {
+        log(`[lsp] reinstalling ${spec.npm}@${version2}: no installed-version metadata recorded`);
+      }
+    }
+    const ok = await runInstall(spec, version2, cachedPackageDir(spec.npm), signal).catch((err) => {
+      error48(`[lsp] background install ${spec.npm} crashed: ${err}`);
+      return false;
+    });
+    if (!ok) {
+      return { started: true, reason: "install failed (see plugin log)" };
+    }
+    const installedHash = await hashInstalledBinary(spec).catch((err) => {
+      warn(`[lsp] could not hash newly-installed ${spec.npm} binary: ${err}`);
+      return null;
+    });
+    if (installedHash) {
+      log(`[lsp] ${spec.npm}@${version2} installed sha256=${installedHash}`);
+    }
+    writeInstalledMeta(spec.npm, version2, installedHash ?? undefined);
+    return { started: true };
+  });
+  if (outcome === null) {
+    return { started: false, reason: "another install in progress" };
+  }
+  return outcome;
+}
+function cachedPackageDir(npmPackage) {
+  return lspBinDir(npmPackage).replace(/[\\/]node_modules[\\/]\.bin[\\/]?$/, "");
+}
+function hashInstalledBinary(spec) {
+  return new Promise((resolve, reject) => {
+    const candidates = process.platform === "win32" ? [
+      lspBinaryPath(spec.npm, spec.binary),
+      lspBinaryPath(spec.npm, `${spec.binary}.cmd`),
+      lspBinaryPath(spec.npm, `${spec.binary}.exe`),
+      lspBinaryPath(spec.npm, `${spec.binary}.bat`)
+    ] : [lspBinaryPath(spec.npm, spec.binary)];
+    let pathToHash = null;
+    for (const p of candidates) {
+      try {
+        if (statSync2(p).isFile()) {
+          pathToHash = p;
+          break;
+        }
+      } catch {}
+    }
+    if (!pathToHash) {
+      reject(new Error(`installed binary not found at any of: ${candidates.join(", ")}`));
+      return;
+    }
+    const hash2 = createHash("sha256");
+    const stream = createReadStream(pathToHash);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash2.update(chunk));
+    stream.on("end", () => resolve(hash2.digest("hex")));
+  });
+}
+function runAutoInstall(projectRoot, config2, fetchImpl = fetch) {
+  const cachedBinDirs = [];
+  const skipped = [];
+  const installPromises = [];
+  let installsStarted = 0;
+  let projectExtensions = null;
+  const getProjectExtensions = () => {
+    projectExtensions ??= relevantExtensionsInProject(projectRoot, npmExtToServerIds);
+    return projectExtensions;
+  };
+  for (const spec of NPM_LSP_TABLE) {
+    if (isInstalled(spec.npm, spec.binary)) {
+      cachedBinDirs.push(lspBinDir(spec.npm));
+    }
+    if (config2.disabled.has(spec.id)) {
+      skipped.push({ id: spec.id, reason: "disabled by config" });
+      continue;
+    }
+    if (!config2.autoInstall) {
+      skipped.push({ id: spec.id, reason: "auto_install: false" });
+      continue;
+    }
+    if (!isProjectRelevant(spec, projectRoot, getProjectExtensions)) {
+      skipped.push({ id: spec.id, reason: "not relevant to project" });
+      continue;
+    }
+    installsStarted += 1;
+    const controller = new AbortController;
+    const promise2 = ensureServerInstalled(spec, config2, fetchImpl, controller.signal).then((outcome) => {
+      if (!outcome.started)
+        installsStarted -= 1;
+      if (outcome.reason && outcome.reason !== "already installed") {
+        skipped.push({ id: spec.id, reason: outcome.reason });
+      }
+    }, (err) => {
+      installsStarted -= 1;
+      const reason = err instanceof Error ? err.message : String(err);
+      skipped.push({ id: spec.id, reason: `install error: ${reason}` });
+      error48(`[lsp] background install ${spec.npm} promise rejected: ${reason}`);
+    });
+    installPromises.push(trackInFlightAutoInstall(controller, promise2));
+  }
+  return {
+    cachedBinDirs,
+    get installsStarted() {
+      return installsStarted;
+    },
+    skipped,
+    installsComplete: Promise.all(installPromises).then(() => {})
+  };
+}
+
+// src/lsp-github-install.ts
+import { execFileSync } from "node:child_process";
+import { createHash as createHash2, randomBytes } from "node:crypto";
+import {
+  copyFileSync,
+  createReadStream as createReadStream2,
+  createWriteStream,
+  existsSync as existsSync4,
+  lstatSync,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readlinkSync,
+  realpathSync,
+  renameSync,
+  rmSync,
+  statSync as statSync3,
+  unlinkSync as unlinkSync2
+} from "node:fs";
+import { dirname, join as join5, relative, resolve } from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+
+// src/lsp-github-table.ts
+function exe(platform, name) {
+  return platform === "win32" ? `${name}.exe` : name;
+}
+var CLANGD = {
+  id: "clangd",
+  githubRepo: "clangd/clangd",
+  binary: "clangd",
+  resolveAsset: (platform, _arch, version2) => {
+    const platformName = platform === "darwin" ? "mac" : platform === "linux" ? "linux" : "windows";
+    return { name: `clangd-${platformName}-${version2}.zip`, archive: "zip" };
+  },
+  binaryPathInArchive: (platform, _arch, version2) => `clangd_${version2}/bin/${exe(platform, "clangd")}`
+};
+var LUA_LS = {
+  id: "lua-ls",
+  githubRepo: "LuaLS/lua-language-server",
+  binary: "lua-language-server",
+  resolveAsset: (platform, arch, version2) => {
+    const ext = platform === "win32" ? "zip" : "tar.gz";
+    const platformName = platform === "darwin" ? "darwin" : platform === "linux" ? "linux" : "win32";
+    const archName = arch === "arm64" ? "arm64" : "x64";
+    return {
+      name: `lua-language-server-${version2}-${platformName}-${archName}.${ext}`,
+      archive: ext
+    };
+  },
+  binaryPathInArchive: (platform, _arch, _version) => `bin/${exe(platform, "lua-language-server")}`
+};
+var ZLS = {
+  id: "zls",
+  githubRepo: "zigtools/zls",
+  binary: "zls",
+  resolveAsset: (platform, arch, _version) => {
+    const ext = platform === "win32" ? "zip" : "tar.xz";
+    const archName = arch === "arm64" ? "aarch64" : "x86_64";
+    const platformName = platform === "darwin" ? "macos" : platform === "linux" ? "linux" : "windows";
+    return { name: `zls-${archName}-${platformName}.${ext}`, archive: ext };
+  },
+  binaryPathInArchive: (platform, _arch, _version) => exe(platform, "zls")
+};
+var TINYMIST = {
+  id: "tinymist",
+  githubRepo: "Myriad-Dreamin/tinymist",
+  binary: "tinymist",
+  resolveAsset: (platform, arch, _version) => {
+    const archName = arch === "arm64" ? "aarch64" : "x86_64";
+    const triple = platform === "darwin" ? "apple-darwin" : platform === "linux" ? "unknown-linux-gnu" : "pc-windows-msvc";
+    const ext = platform === "win32" ? "zip" : "tar.gz";
+    return { name: `tinymist-${archName}-${triple}.${ext}`, archive: ext };
+  },
+  binaryPathInArchive: (platform, _arch, _version) => exe(platform, "tinymist")
+};
+var TEXLAB = {
+  id: "texlab",
+  githubRepo: "latex-lsp/texlab",
+  binary: "texlab",
+  resolveAsset: (platform, arch, _version) => {
+    const archName = arch === "arm64" ? "aarch64" : "x86_64";
+    const platformName = platform === "darwin" ? "macos" : platform === "linux" ? "linux" : "windows";
+    const ext = platform === "win32" ? "zip" : "tar.gz";
+    return { name: `texlab-${archName}-${platformName}.${ext}`, archive: ext };
+  },
+  binaryPathInArchive: (platform, _arch, _version) => exe(platform, "texlab")
+};
+var GITHUB_LSP_TABLE = [
+  CLANGD,
+  LUA_LS,
+  ZLS,
+  TINYMIST,
+  TEXLAB
+];
+function detectHostPlatform() {
+  const platform = process.platform;
+  if (platform !== "darwin" && platform !== "linux" && platform !== "win32")
+    return null;
+  const arch = process.arch;
+  if (arch === "x64")
+    return { platform, arch: "x64" };
+  if (arch === "arm64")
+    return { platform, arch: "arm64" };
+  return null;
+}
+
+// src/lsp-github-install.ts
+function ghCacheRoot() {
+  return join5(aftCacheBase(), "lsp-binaries");
+}
+function ghPackageDir(spec) {
+  return join5(ghCacheRoot(), spec.id);
+}
+function ghBinDir(spec) {
+  return join5(ghPackageDir(spec), "bin");
+}
+function ghExtractDir(spec) {
+  return join5(ghPackageDir(spec), "extracted");
+}
+function ghBinaryPath(spec, platform) {
+  const ext = platform === "win32" ? ".exe" : "";
+  return join5(ghBinDir(spec), `${spec.binary}${ext}`);
+}
+function isGithubInstalled(spec, platform) {
+  for (const candidate of ghBinaryCandidates(spec, platform)) {
+    try {
+      if (statSync3(join5(ghBinDir(spec), candidate)).isFile())
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function ghBinaryCandidates(spec, platform) {
+  if (platform !== "win32")
+    return [spec.binary];
+  return [spec.binary, `${spec.binary}.cmd`, `${spec.binary}.exe`, `${spec.binary}.bat`];
+}
+var MAX_DOWNLOAD_BYTES = 256 * 1024 * 1024;
+var MAX_EXTRACT_BYTES = 1024 * 1024 * 1024;
+function sha256OfFile(path2) {
+  return new Promise((resolve2, reject) => {
+    const hash2 = createHash2("sha256");
+    const stream = createReadStream2(path2);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash2.update(chunk));
+    stream.on("end", () => resolve2(hash2.digest("hex")));
+  });
+}
+async function fetchReleaseByTag(githubRepo, tag, fetchImpl, signal) {
+  const candidates = [];
+  candidates.push(tag);
+  if (!tag.startsWith("v")) {
+    candidates.push(`v${tag}`);
+  } else {
+    candidates.push(tag.slice(1));
+  }
+  const headers = {
+    accept: "application/vnd.github+json",
+    "user-agent": "aft-opencode",
+    "x-github-api-version": "2022-11-28"
+  };
+  if (process.env.GITHUB_TOKEN) {
+    headers.authorization = `Bearer ${process.env.GITHUB_TOKEN}`;
+  }
+  for (const candidate of candidates) {
+    const url2 = `https://api.github.com/repos/${githubRepo}/releases/tags/${encodeURIComponent(candidate)}`;
+    const timeout = controlledTimeoutSignal(15000, signal);
+    try {
+      const res = await fetchImpl(url2, {
+        headers,
+        redirect: "follow",
+        signal: timeout.signal
+      });
+      if (res.status === 404)
+        continue;
+      if (!res.ok) {
+        warn(`[lsp] github release-by-tag ${githubRepo}@${candidate}: HTTP ${res.status}`);
+        return null;
+      }
+      const json2 = await res.json();
+      if (!json2.tag_name || !Array.isArray(json2.assets)) {
+        warn(`[lsp] github release-by-tag ${githubRepo}@${candidate}: malformed response`);
+        return null;
+      }
+      const assets = json2.assets.filter((a) => typeof a.name === "string" && typeof a.browser_download_url === "string").map((a) => ({
+        name: a.name,
+        url: a.browser_download_url,
+        size: typeof a.size === "number" ? a.size : undefined
+      }));
+      return { tag: json2.tag_name, assets };
+    } catch (err) {
+      if (signal?.aborted) {
+        warn(`[lsp] github release-by-tag ${githubRepo}@${candidate}: aborted`);
+        return null;
+      }
+      warn(`[lsp] github release-by-tag ${githubRepo}@${candidate}: ${err}`);
+    } finally {
+      timeout.cleanup();
+    }
+  }
+  return null;
+}
+async function resolveTargetTag(spec, config2, fetchImpl, signal) {
+  const pinned = config2.versions[spec.githubRepo];
+  if (pinned) {
+    try {
+      assertSafeVersion(pinned);
+    } catch (err) {
+      return {
+        tag: null,
+        assets: [],
+        blockedByGrace: false,
+        reason: `invalid pinned version ${JSON.stringify(pinned)}: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    const release = await fetchReleaseByTag(spec.githubRepo, pinned, fetchImpl, signal);
+    if (release) {
+      return {
+        tag: release.tag,
+        assets: release.assets,
+        blockedByGrace: false
+      };
+    }
+    return {
+      tag: null,
+      assets: [],
+      blockedByGrace: false,
+      reason: `pinned tag ${pinned} not found on GitHub`
+    };
+  }
+  const cached2 = readVersionCheck(spec.githubRepo);
+  const weeklyMs = config2.graceDays * 24 * 60 * 60 * 1000;
+  if (!shouldRecheckVersion(cached2, weeklyMs) && cached2?.latest_eligible) {
+    const release = await fetchReleaseByTag(spec.githubRepo, cached2.latest_eligible, fetchImpl);
+    if (release) {
+      return {
+        tag: release.tag,
+        assets: release.assets,
+        blockedByGrace: false
+      };
+    }
+  }
+  const probe = await probeGithubReleases(spec.githubRepo, config2.graceDays, fetchImpl);
+  if (!probe) {
+    return {
+      tag: null,
+      assets: [],
+      blockedByGrace: false,
+      reason: "github releases probe failed"
+    };
+  }
+  writeVersionCheck(spec.githubRepo, probe.tag);
+  return { tag: probe.tag, assets: probe.assets, blockedByGrace: probe.blockedByGrace };
+}
+function controlledTimeoutSignal(timeoutMs, parent) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  timeout.unref?.();
+  const abort = () => controller.abort();
+  parent?.addEventListener("abort", abort, { once: true });
+  if (parent?.aborted)
+    abort();
+  return {
+    signal: controller.signal,
+    cleanup: () => {
+      clearTimeout(timeout);
+      parent?.removeEventListener("abort", abort);
+    }
+  };
+}
+async function downloadFile(url2, destPath, fetchImpl, assetSize, signal) {
+  if (assetSize !== undefined && assetSize > MAX_DOWNLOAD_BYTES) {
+    throw new Error(`asset size ${assetSize} exceeds max ${MAX_DOWNLOAD_BYTES} (set lsp.versions to pin a smaller release if this is wrong)`);
+  }
+  const timeout = controlledTimeoutSignal(120000, signal);
+  try {
+    const res = await fetchImpl(url2, {
+      headers: { accept: "application/octet-stream" },
+      redirect: "follow",
+      signal: timeout.signal
+    });
+    if (!res.ok || !res.body) {
+      throw new Error(`download failed (${res.status})`);
+    }
+    const advertised = Number.parseInt(res.headers.get("content-length") ?? "", 10);
+    if (Number.isFinite(advertised) && advertised > MAX_DOWNLOAD_BYTES) {
+      throw new Error(`Content-Length ${advertised} exceeds max ${MAX_DOWNLOAD_BYTES}`);
+    }
+    mkdirSync2(dirname(destPath), { recursive: true });
+    let bytesWritten = 0;
+    const guard = new TransformStream({
+      transform(chunk, controller) {
+        bytesWritten += chunk.byteLength;
+        if (bytesWritten > MAX_DOWNLOAD_BYTES) {
+          controller.error(new Error(`download exceeded ${MAX_DOWNLOAD_BYTES} bytes after streaming (server lied about size or sent unbounded body)`));
+          return;
+        }
+        controller.enqueue(chunk);
+      }
+    });
+    const guarded = res.body.pipeThrough(guard);
+    const nodeStream = Readable.fromWeb(guarded);
+    await pipeline(nodeStream, createWriteStream(destPath), { signal: timeout.signal });
+  } catch (err) {
+    try {
+      unlinkSync2(destPath);
+    } catch {}
+    throw err;
+  } finally {
+    timeout.cleanup();
+  }
+}
+function validateExtraction(stagingRoot) {
+  const realStagingRoot = realpathSync(stagingRoot);
+  let totalBytes = 0;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = readdirSync2(dir);
+    } catch (err) {
+      throw new Error(`failed to read staging dir ${dir}: ${err}`);
+    }
+    for (const entry of entries) {
+      const full = join5(dir, entry);
+      let lst;
+      try {
+        lst = lstatSync(full);
+      } catch (err) {
+        throw new Error(`failed to lstat ${full}: ${err}`);
+      }
+      if (lst.isSymbolicLink()) {
+        let target = "<unreadable>";
+        try {
+          target = readlinkSync(full);
+        } catch {}
+        throw new Error(`archive contains symlink ${relative(realStagingRoot, full)} → ${target}; rejecting (zip-slip defense)`);
+      }
+      let realFull;
+      try {
+        realFull = realpathSync(full);
+      } catch (err) {
+        throw new Error(`failed to realpath ${full}: ${err}`);
+      }
+      const rel = relative(realStagingRoot, realFull);
+      if (rel.startsWith("..") || resolve(realStagingRoot, rel) !== realFull) {
+        throw new Error(`archive entry escapes staging root: ${full} → ${realFull} (zip-slip defense)`);
+      }
+      if (lst.isDirectory()) {
+        walk(full);
+      } else if (lst.isFile()) {
+        totalBytes += lst.size;
+        if (totalBytes > MAX_EXTRACT_BYTES) {
+          throw new Error(`extracted archive exceeds ${MAX_EXTRACT_BYTES} bytes (decompression bomb defense): saw ${totalBytes} bytes before hitting the cap`);
+        }
+      } else {
+        throw new Error(`archive contains non-file/non-dir entry: ${full}`);
+      }
+    }
+  };
+  walk(realStagingRoot);
+}
+function extractArchiveSafely(archivePath, destDir, archiveType) {
+  const suffix = randomBytes(8).toString("hex");
+  const stagingDir = `${destDir}.staging-${suffix}`;
+  try {
+    rmSync(stagingDir, { recursive: true, force: true });
+  } catch {}
+  mkdirSync2(stagingDir, { recursive: true });
+  try {
+    runPlatformExtractor(archivePath, stagingDir, archiveType);
+    validateExtraction(stagingDir);
+    try {
+      rmSync(destDir, { recursive: true, force: true });
+    } catch {}
+    renameSync(stagingDir, destDir);
+  } catch (err) {
+    try {
+      rmSync(stagingDir, { recursive: true, force: true });
+    } catch {}
+    throw err;
+  }
+}
+function runPlatformExtractor(archivePath, destDir, archiveType) {
+  if (archiveType === "zip") {
+    if (process.platform === "win32") {
+      execFileSync("tar.exe", ["-xf", archivePath, "-C", destDir], {
+        stdio: "pipe",
+        timeout: 180000
+      });
+      return;
+    }
+    execFileSync("unzip", ["-q", "-o", archivePath, "-d", destDir], {
+      stdio: "pipe",
+      timeout: 180000
+    });
+    return;
+  }
+  if (archiveType === "tar.gz") {
+    execFileSync("tar", ["-xzf", archivePath, "-C", destDir], {
+      stdio: "pipe",
+      timeout: 180000
+    });
+    return;
+  }
+  if (archiveType === "tar.xz") {
+    execFileSync("tar", ["-xf", archivePath, "-C", destDir], {
+      stdio: "pipe",
+      timeout: 180000
+    });
+    return;
+  }
+  throw new Error(`unsupported archive type: ${archiveType}`);
+}
+async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl, signal) {
+  const version2 = stripTagV(tag);
+  const expected = spec.resolveAsset(platform, arch, version2);
+  if (!expected) {
+    warn(`[lsp] ${spec.id}: unsupported platform/arch combo ${platform}/${arch}`);
+    return null;
+  }
+  const matchingAsset = assets.find((a) => a.name === expected.name);
+  if (!matchingAsset) {
+    warn(`[lsp] ${spec.id}: asset ${expected.name} not found in release ${tag} (${assets.length} assets available)`);
+    return null;
+  }
+  const pkgDir = ghPackageDir(spec);
+  const extractDir = ghExtractDir(spec);
+  const archivePath = join5(pkgDir, expected.name);
+  log(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
+  try {
+    await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
+  } catch (err) {
+    error48(`[lsp] download ${spec.id} failed: ${err}`);
+    return null;
+  }
+  let archiveSha256;
+  try {
+    archiveSha256 = await sha256OfFile(archivePath);
+  } catch (err) {
+    error48(`[lsp] hash ${spec.id} failed: ${err}`);
+    try {
+      unlinkSync2(archivePath);
+    } catch {}
+    return null;
+  }
+  log(`[lsp] ${spec.id} ${tag} sha256=${archiveSha256}`);
+  const previousMeta = readInstalledMetaIn(ghPackageDir(spec));
+  if (previousMeta && previousMeta.version === tag && previousMeta.sha256) {
+    if (previousMeta.sha256 !== archiveSha256) {
+      error48(`[lsp] ${spec.id} ${tag}: TOFU sha256 mismatch — refusing install. ` + `Previously installed sha256=${previousMeta.sha256}, downloaded sha256=${archiveSha256}. ` + `This means the published release for tag ${tag} changed. Investigate before proceeding.`);
+      try {
+        unlinkSync2(archivePath);
+      } catch {}
+      return null;
+    }
+  }
+  try {
+    extractArchiveSafely(archivePath, extractDir, expected.archive);
+  } catch (err) {
+    error48(`[lsp] extract ${spec.id} failed: ${err}`);
+    return null;
+  } finally {
+    try {
+      unlinkSync2(archivePath);
+    } catch {}
+  }
+  const innerBinaryPath = join5(extractDir, spec.binaryPathInArchive(platform, arch, version2));
+  if (!existsSync4(innerBinaryPath)) {
+    error48(`[lsp] ${spec.id}: extracted binary not found at ${innerBinaryPath}`);
+    return null;
+  }
+  const targetBinary = ghBinaryPath(spec, platform);
+  mkdirSync2(dirname(targetBinary), { recursive: true });
+  try {
+    copyFileSync(innerBinaryPath, targetBinary);
+    if (platform !== "win32") {
+      const { chmodSync } = await import("node:fs");
+      chmodSync(targetBinary, 493);
+    }
+  } catch (err) {
+    error48(`[lsp] ${spec.id}: failed to place binary at ${targetBinary}: ${err}`);
+    return null;
+  }
+  log(`[lsp] installed ${spec.id} ${tag} at ${targetBinary}`);
+  return archiveSha256;
+}
+async function ensureGithubInstalled(spec, config2, fetchImpl, platform, arch, signal) {
+  const outcome = await withInstallLock(spec.githubRepo, async () => {
+    const { tag, assets, blockedByGrace, reason } = await resolveTargetTag(spec, config2, fetchImpl, signal);
+    if (!tag) {
+      const installed = isGithubInstalled(spec, platform);
+      if (installed) {
+        warn(`[lsp] no eligible release of ${spec.githubRepo} (grace=${config2.graceDays}d); keeping existing install`);
+        return { started: false, reason: "kept existing install" };
+      }
+      const fallbackReason = reason ?? (blockedByGrace ? `all releases are within ${config2.graceDays}-day grace window` : "github releases probe failed");
+      warn(`[lsp] skipping ${spec.id}: ${fallbackReason}`);
+      return { started: false, reason: fallbackReason };
+    }
+    if (isGithubInstalled(spec, platform)) {
+      const installedMeta = readInstalledMetaIn(ghPackageDir(spec));
+      if (installedMeta && installedMeta.version === tag) {
+        return { started: false, reason: "already installed" };
+      }
+      if (installedMeta) {
+        log(`[lsp] reinstalling ${spec.id}: cached ${installedMeta.version} ≠ target ${tag}`);
+      } else {
+        log(`[lsp] reinstalling ${spec.id}@${tag}: no installed-version metadata recorded`);
+      }
+    }
+    const archiveSha256 = await downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl, signal).catch((err) => {
+      error48(`[lsp] github install ${spec.id} crashed: ${err}`);
+      return null;
+    });
+    if (!archiveSha256) {
+      return { started: true, reason: "install failed (see plugin log)" };
+    }
+    writeInstalledMetaIn(ghPackageDir(spec), tag, archiveSha256);
+    return { started: true };
+  });
+  if (outcome === null) {
+    return { started: false, reason: "another install in progress" };
+  }
+  return outcome;
+}
+var inFlightGithubInstalls = new Set;
+function trackInFlightGithubInstall(controller, promise2) {
+  const entry = { controller, promise: promise2 };
+  inFlightGithubInstalls.add(entry);
+  promise2.then(() => inFlightGithubInstalls.delete(entry), () => inFlightGithubInstalls.delete(entry));
+  return promise2;
+}
+async function abortInFlightGithubInstalls() {
+  const installs = Array.from(inFlightGithubInstalls);
+  for (const install of installs) {
+    install.controller.abort();
+  }
+  await Promise.allSettled(installs.map((install) => install.promise));
+}
+function runGithubAutoInstall(relevantServers, config2, fetchImpl = fetch) {
+  const cachedBinDirs = [];
+  const skipped = [];
+  const installPromises = [];
+  let installsStarted = 0;
+  const host = detectHostPlatform();
+  if (!host) {
+    for (const spec of GITHUB_LSP_TABLE) {
+      try {
+        if (existsSync4(ghBinDir(spec))) {
+          cachedBinDirs.push(ghBinDir(spec));
+        }
+      } catch {}
+    }
+    return {
+      cachedBinDirs,
+      installsStarted: 0,
+      skipped,
+      installsComplete: Promise.resolve()
+    };
+  }
+  for (const spec of GITHUB_LSP_TABLE) {
+    if (isGithubInstalled(spec, host.platform)) {
+      cachedBinDirs.push(ghBinDir(spec));
+    }
+    if (config2.disabled.has(spec.id)) {
+      skipped.push({ id: spec.id, reason: "disabled by config" });
+      continue;
+    }
+    if (!config2.autoInstall) {
+      skipped.push({ id: spec.id, reason: "auto_install: false" });
+      continue;
+    }
+    if (!relevantServers.has(spec.id)) {
+      skipped.push({ id: spec.id, reason: "not relevant to project" });
+      continue;
+    }
+    installsStarted += 1;
+    const controller = new AbortController;
+    const promise2 = ensureGithubInstalled(spec, config2, fetchImpl, host.platform, host.arch, controller.signal).then((outcome) => {
+      if (!outcome.started)
+        installsStarted -= 1;
+      if (outcome.reason && outcome.reason !== "already installed") {
+        skipped.push({ id: spec.id, reason: outcome.reason });
+      }
+    }, (err) => {
+      installsStarted -= 1;
+      const reason = err instanceof Error ? err.message : String(err);
+      skipped.push({ id: spec.id, reason: `install error: ${reason}` });
+      error48(`[lsp] github install ${spec.id} promise rejected: ${reason}`);
+    });
+    installPromises.push(trackInFlightGithubInstall(controller, promise2));
+  }
+  return {
+    cachedBinDirs,
+    get installsStarted() {
+      return installsStarted;
+    },
+    skipped,
+    installsComplete: Promise.all(installPromises).then(() => {})
+  };
+}
+function discoverRelevantGithubServers(projectRoot) {
+  const extToServerIds = {
+    c: ["clangd"],
+    "c++": ["clangd"],
+    cc: ["clangd"],
+    cpp: ["clangd"],
+    cxx: ["clangd"],
+    h: ["clangd"],
+    "h++": ["clangd"],
+    hpp: ["clangd"],
+    hh: ["clangd"],
+    hxx: ["clangd"],
+    lua: ["lua-ls"],
+    zig: ["zls"],
+    zon: ["zls"],
+    typ: ["tinymist"],
+    typc: ["tinymist"],
+    tex: ["texlab"],
+    bib: ["texlab"]
+  };
+  const rootMarkers = {
+    clangd: ["compile_commands.json", "compile_flags.txt", ".clangd"],
+    "lua-ls": [".luarc.json", ".luarc.jsonc", ".stylua.toml", "stylua.toml"],
+    zls: ["build.zig"],
+    tinymist: ["typst.toml"],
+    texlab: [".latexmkrc", "latexmkrc", ".texlabroot", "texlabroot"]
+  };
+  const relevant = new Set;
+  for (const spec of GITHUB_LSP_TABLE) {
+    if (hasRootMarker(projectRoot, rootMarkers[spec.id]))
+      relevant.add(spec.id);
+  }
+  const extensions = relevantExtensionsInProject(projectRoot, extToServerIds);
+  for (const ext of extensions) {
+    for (const id of extToServerIds[ext] ?? []) {
+      relevant.add(id);
+    }
+  }
+  return relevant;
+}
+
+// src/notifications.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { join as join6 } from "node:path";
 var WARNING_MARKER = "\uD83D\uDD27 AFT: ⚠️";
 var WARNED_TOOLS_FILE = "warned_tools.json";
 function sendIgnoredMessage(client, _sessionId, text) {
@@ -14124,10 +15540,10 @@ function sendIgnoredMessage(client, _sessionId, text) {
 }
 function readWarnedTools(storageDir) {
   try {
-    const warnedToolsPath = join3(storageDir, WARNED_TOOLS_FILE);
-    if (!existsSync2(warnedToolsPath))
+    const warnedToolsPath = join6(storageDir, WARNED_TOOLS_FILE);
+    if (!existsSync5(warnedToolsPath))
       return {};
-    const parsed = JSON.parse(readFileSync2(warnedToolsPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync3(warnedToolsPath, "utf-8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
       return {};
     const warned = {};
@@ -14143,9 +15559,9 @@ function readWarnedTools(storageDir) {
 }
 function writeWarnedTools(storageDir, warned) {
   try {
-    mkdirSync(storageDir, { recursive: true });
-    const warnedToolsPath = join3(storageDir, WARNED_TOOLS_FILE);
-    writeFileSync(warnedToolsPath, `${JSON.stringify(warned, null, 2)}
+    mkdirSync3(storageDir, { recursive: true });
+    const warnedToolsPath = join6(storageDir, WARNED_TOOLS_FILE);
+    writeFileSync2(warnedToolsPath, `${JSON.stringify(warned, null, 2)}
 `);
   } catch {}
 }
@@ -14204,8 +15620,8 @@ async function deliverConfigureWarnings(opts, warnings) {
 }
 
 // src/onnx-runtime.ts
-import { chmodSync, existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync, unlinkSync } from "node:fs";
-import { join as join4 } from "node:path";
+import { chmodSync, existsSync as existsSync6, mkdirSync as mkdirSync4, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "node:fs";
+import { join as join7 } from "node:path";
 var ORT_VERSION = "1.24.4";
 var ORT_REPO = "microsoft/onnxruntime";
 var ORT_PLATFORM_MAP = {
@@ -14258,9 +15674,9 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortDir = join4(storageDir, "onnxruntime", ORT_VERSION);
-  const libPath = join4(ortDir, info?.libName ?? "libonnxruntime.dylib");
-  if (existsSync3(libPath)) {
+  const ortDir = join7(storageDir, "onnxruntime", ORT_VERSION);
+  const libPath = join7(ortDir, info?.libName ?? "libonnxruntime.dylib");
+  if (existsSync6(libPath)) {
     log(`ONNX Runtime found at ${ortDir}`);
     return ortDir;
   }
@@ -14285,7 +15701,7 @@ function findSystemOnnxRuntime(libName) {
     searchPaths.push("/usr/lib", "/usr/lib/x86_64-linux-gnu", "/usr/lib/aarch64-linux-gnu", "/usr/local/lib");
   }
   for (const dir of searchPaths) {
-    if (existsSync3(join4(dir, libName))) {
+    if (existsSync6(join7(dir, libName))) {
       return dir;
     }
   }
@@ -14296,34 +15712,34 @@ async function downloadOnnxRuntime(info, targetDir) {
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   try {
     const tmpDir = `${targetDir}.tmp.${process.pid}`;
-    mkdirSync2(tmpDir, { recursive: true });
-    const archivePath = join4(tmpDir, `onnxruntime.${info.archiveType}`);
-    const { execFileSync } = await import("node:child_process");
-    execFileSync("curl", ["-fsSL", url2, "-o", archivePath], {
+    mkdirSync4(tmpDir, { recursive: true });
+    const archivePath = join7(tmpDir, `onnxruntime.${info.archiveType}`);
+    const { execFileSync: execFileSync2 } = await import("node:child_process");
+    execFileSync2("curl", ["-fsSL", url2, "-o", archivePath], {
       stdio: "pipe",
       timeout: 120000
     });
     if (info.archiveType === "tgz") {
-      execFileSync("tar", ["xzf", archivePath, "-C", tmpDir], { stdio: "pipe" });
+      execFileSync2("tar", ["xzf", archivePath, "-C", tmpDir], { stdio: "pipe" });
     } else {
       await extractZipArchive(archivePath, tmpDir);
     }
-    const extractedDir = join4(tmpDir, info.assetName, "lib");
-    if (!existsSync3(extractedDir)) {
+    const extractedDir = join7(tmpDir, info.assetName, "lib");
+    if (!existsSync6(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync2(targetDir, { recursive: true });
-    const libFiles = readdirSync(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
-    const { lstatSync, symlinkSync, readlinkSync, copyFileSync: cpFile } = await import("node:fs");
+    mkdirSync4(targetDir, { recursive: true });
+    const libFiles = readdirSync3(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
+    const { lstatSync: lstatSync2, symlinkSync, readlinkSync: readlinkSync2, copyFileSync: cpFile } = await import("node:fs");
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join4(extractedDir, libFile);
+      const src = join7(extractedDir, libFile);
       try {
-        const stat = lstatSync(src);
+        const stat = lstatSync2(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
         if (stat.isSymbolicLink()) {
-          symlinks.push({ name: libFile, target: readlinkSync(src) });
+          symlinks.push({ name: libFile, target: readlinkSync2(src) });
         } else {
           realFiles.push(libFile);
         }
@@ -14333,8 +15749,8 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     for (const libFile of realFiles) {
-      const src = join4(extractedDir, libFile);
-      const dst = join4(targetDir, libFile);
+      const src = join7(extractedDir, libFile);
+      const dst = join7(targetDir, libFile);
       try {
         cpFile(src, dst);
         if (process.platform !== "win32") {
@@ -14345,65 +15761,47 @@ async function downloadOnnxRuntime(info, targetDir) {
       }
     }
     for (const link of symlinks) {
-      const dst = join4(targetDir, link.name);
+      const dst = join7(targetDir, link.name);
       try {
-        unlinkSync(dst);
+        unlinkSync3(dst);
       } catch {}
       symlinkSync(link.target, dst);
     }
-    const { rmSync } = await import("node:fs");
-    rmSync(tmpDir, { recursive: true, force: true });
+    const { rmSync: rmSync2 } = await import("node:fs");
+    rmSync2(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
   } catch (err) {
     error48(`Failed to download ONNX Runtime: ${err}`);
     try {
-      const { rmSync } = await import("node:fs");
-      rmSync(`${targetDir}.tmp.${process.pid}`, { recursive: true, force: true });
+      const { rmSync: rmSync2 } = await import("node:fs");
+      rmSync2(`${targetDir}.tmp.${process.pid}`, { recursive: true, force: true });
     } catch {}
     return null;
   }
 }
 async function extractZipArchive(archivePath, destinationDir) {
-  const { execFileSync } = await import("node:child_process");
+  const { execFileSync: execFileSync2 } = await import("node:child_process");
   if (process.platform === "win32") {
-    let powershellError;
-    try {
-      execFileSync("powershell.exe", [
-        "-NoProfile",
-        "-NonInteractive",
-        "-ExecutionPolicy",
-        "Bypass",
-        "-Command",
-        "& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }",
-        archivePath,
-        destinationDir
-      ], { stdio: "pipe", timeout: 120000 });
-      return;
-    } catch (err) {
-      powershellError = err;
-      warn(`PowerShell Expand-Archive failed, falling back to cmd/tar: ${String(err)}`);
-    }
-    try {
-      execFileSync("cmd.exe", ["/d", "/s", "/c", `tar -xf "${archivePath}" -C "${destinationDir}"`], { stdio: "pipe", timeout: 120000 });
-      return;
-    } catch (cmdError) {
-      throw new Error(`ZIP extraction failed via PowerShell and cmd/tar. PowerShell: ${String(powershellError)} | cmd/tar: ${String(cmdError)}`);
-    }
+    execFileSync2("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
+      stdio: "pipe",
+      timeout: 120000
+    });
+    return;
   }
-  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
+  execFileSync2("unzip", ["-q", archivePath, "-d", destinationDir], {
     stdio: "pipe",
     timeout: 120000
   });
 }
 
 // src/pool.ts
-import { realpathSync } from "node:fs";
+import { realpathSync as realpathSync2 } from "node:fs";
 
 // src/bridge.ts
-import { spawn } from "node:child_process";
-import { homedir as homedir2 } from "node:os";
-import { join as join5 } from "node:path";
+import { spawn as spawn2 } from "node:child_process";
+import { homedir as homedir3 } from "node:os";
+import { join as join8 } from "node:path";
 var DEFAULT_BRIDGE_TIMEOUT_MS = 30000;
 var SEMANTIC_TIMEOUT_SAFETY_MARGIN_MS = 5000;
 var MAX_STDOUT_BUFFER = 64 * 1024 * 1024;
@@ -14545,14 +15943,14 @@ class BinaryBridge {
     const line = `${JSON.stringify(request)}
 `;
     const effectiveTimeoutMs = options?.timeoutMs ?? this.timeoutMs;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         warn(`Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms — restarting bridge`);
         reject(new Error(`[aft-pi] Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
         this.handleTimeout();
       }, effectiveTimeoutMs);
-      this.pending.set(id, { resolve, reject, timer });
+      this.pending.set(id, { resolve: resolve2, reject, timer });
       if (!this.process?.stdin?.writable) {
         this.pending.delete(id);
         clearTimeout(timer);
@@ -14595,15 +15993,15 @@ class BinaryBridge {
     if (this.process) {
       const proc = this.process;
       this.process = null;
-      return new Promise((resolve) => {
+      return new Promise((resolve2) => {
         const forceKillTimer = setTimeout(() => {
           proc.kill("SIGKILL");
-          resolve();
+          resolve2();
         }, 5000);
         proc.once("exit", () => {
           clearTimeout(forceKillTimer);
           log("Process exited during shutdown");
-          resolve();
+          resolve2();
         });
         proc.kill("SIGTERM");
       });
@@ -14645,19 +16043,19 @@ class BinaryBridge {
     })();
     const useFastembedBackend = semanticBackend === undefined || semanticBackend === "fastembed" || semanticBackend === "";
     const ortDir = typeof this.configOverrides._ort_dylib_dir === "string" && useFastembedBackend ? this.configOverrides._ort_dylib_dir : null;
-    const ortLibraryPath = ortDir == null ? null : join5(ortDir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
+    const ortLibraryPath = ortDir == null ? null : join8(ortDir, process.platform === "win32" ? "onnxruntime.dll" : process.platform === "darwin" ? "libonnxruntime.dylib" : "libonnxruntime.so");
     const envPath = process.platform === "win32" && ortDir ? `${ortDir};${process.env.PATH ?? ""}` : process.env.PATH;
     const env = {
       ...process.env,
       ...envPath ? { PATH: envPath } : {}
     };
     if (useFastembedBackend) {
-      env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join5(this.configOverrides.storage_dir, "semantic", "models") : join5(homedir2() || "", ".cache", "fastembed"));
+      env.FASTEMBED_CACHE_DIR = process.env.FASTEMBED_CACHE_DIR || (typeof this.configOverrides.storage_dir === "string" ? join8(this.configOverrides.storage_dir, "semantic", "models") : join8(homedir3() || "", ".cache", "fastembed"));
       if (ortLibraryPath) {
         env.ORT_DYLIB_PATH = ortLibraryPath;
       }
     }
-    const child = spawn(this.binaryPath, [], {
+    const child = spawn2(this.binaryPath, [], {
       cwd: this.cwd,
       stdio: ["pipe", "pipe", "pipe"],
       env
@@ -14915,7 +16313,7 @@ class BridgePool {
 function canonicalKey(directory) {
   const stripped = directory.replace(/[/\\]+$/, "");
   try {
-    return realpathSync(stripped);
+    return realpathSync2(stripped);
   } catch {
     return stripped;
   }
@@ -14923,15 +16321,15 @@ function canonicalKey(directory) {
 
 // src/resolver.ts
 import { execSync, spawnSync } from "node:child_process";
-import { chmodSync as chmodSync3, copyFileSync, existsSync as existsSync5, mkdirSync as mkdirSync4, renameSync } from "node:fs";
+import { chmodSync as chmodSync3, copyFileSync as copyFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync6, renameSync as renameSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { homedir as homedir4 } from "node:os";
-import { join as join7 } from "node:path";
+import { homedir as homedir5 } from "node:os";
+import { join as join10 } from "node:path";
 
 // src/downloader.ts
-import { chmodSync as chmodSync2, existsSync as existsSync4, mkdirSync as mkdirSync3, unlinkSync as unlinkSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+import { chmodSync as chmodSync2, existsSync as existsSync7, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join9 } from "node:path";
 
 // src/platform.ts
 var PLATFORM_ARCH_MAP = {
@@ -14952,11 +16350,11 @@ var REPO = "cortexkit/aft";
 function getCacheDir() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA || process.env.APPDATA;
-    const base2 = localAppData || join6(homedir3(), "AppData", "Local");
-    return join6(base2, "aft", "bin");
+    const base2 = localAppData || join9(homedir4(), "AppData", "Local");
+    return join9(base2, "aft", "bin");
   }
-  const base = process.env.XDG_CACHE_HOME || join6(homedir3(), ".cache");
-  return join6(base, "aft", "bin");
+  const base = process.env.XDG_CACHE_HOME || join9(homedir4(), ".cache");
+  return join9(base, "aft", "bin");
 }
 function getBinaryName() {
   return process.platform === "win32" ? "aft.exe" : "aft";
@@ -14964,8 +16362,8 @@ function getBinaryName() {
 function getCachedBinaryPath(version2) {
   if (!version2)
     return null;
-  const binaryPath = join6(getCacheDir(), version2, getBinaryName());
-  return existsSync4(binaryPath) ? binaryPath : null;
+  const binaryPath = join9(getCacheDir(), version2, getBinaryName());
+  return existsSync7(binaryPath) ? binaryPath : null;
 }
 async function downloadBinary(version2) {
   const platformKey = `${process.platform}-${process.arch}`;
@@ -14979,18 +16377,18 @@ async function downloadBinary(version2) {
     error48("Could not determine latest release version.");
     return null;
   }
-  const versionedCacheDir = join6(getCacheDir(), tag);
+  const versionedCacheDir = join9(getCacheDir(), tag);
   const binaryName = getBinaryName();
-  const binaryPath = join6(versionedCacheDir, binaryName);
-  if (existsSync4(binaryPath)) {
+  const binaryPath = join9(versionedCacheDir, binaryName);
+  if (existsSync7(binaryPath)) {
     return binaryPath;
   }
   const downloadUrl = `https://github.com/${REPO}/releases/download/${tag}/${assetName}`;
   const checksumUrl = `https://github.com/${REPO}/releases/download/${tag}/checksums.sha256`;
   log(`Downloading AFT binary (${tag}) for ${platformKey}...`);
   try {
-    if (!existsSync4(versionedCacheDir)) {
-      mkdirSync3(versionedCacheDir, { recursive: true });
+    if (!existsSync7(versionedCacheDir)) {
+      mkdirSync5(versionedCacheDir, { recursive: true });
     }
     const [binaryResponse, checksumResponse] = await Promise.all([
       fetch(downloadUrl, { redirect: "follow" }),
@@ -15010,29 +16408,29 @@ async function downloadBinary(version2) {
       warn(`Checksum verification failed: checksums.sha256 found but no entry for ${assetName}. ` + "Binary download aborted for security reasons.");
       return null;
     }
-    const { createHash } = await import("node:crypto");
-    const actualHash = createHash("sha256").update(Buffer.from(arrayBuffer)).digest("hex");
+    const { createHash: createHash3 } = await import("node:crypto");
+    const actualHash = createHash3("sha256").update(Buffer.from(arrayBuffer)).digest("hex");
     if (actualHash !== expectedHash) {
       throw new Error(`Checksum mismatch for ${assetName}: expected ${expectedHash}, got ${actualHash}. The binary may have been tampered with.`);
     }
     log(`Checksum verified (SHA-256: ${actualHash.slice(0, 16)}...)`);
     const tmpPath = `${binaryPath}.tmp`;
-    const { writeFileSync: writeFileSync2 } = await import("node:fs");
-    writeFileSync2(tmpPath, Buffer.from(arrayBuffer));
+    const { writeFileSync: writeFileSync3 } = await import("node:fs");
+    writeFileSync3(tmpPath, Buffer.from(arrayBuffer));
     if (process.platform !== "win32") {
       chmodSync2(tmpPath, 493);
     }
-    const { renameSync } = await import("node:fs");
-    renameSync(tmpPath, binaryPath);
+    const { renameSync: renameSync2 } = await import("node:fs");
+    renameSync2(tmpPath, binaryPath);
     log(`AFT binary ready at ${binaryPath}`);
     return binaryPath;
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
     error48(`Failed to download AFT binary: ${msg}`);
     const tmpPath = `${binaryPath}.tmp`;
-    if (existsSync4(tmpPath)) {
+    if (existsSync7(tmpPath)) {
       try {
-        unlinkSync2(tmpPath);
+        unlinkSync4(tmpPath);
       } catch {}
     }
     return null;
@@ -15097,18 +16495,18 @@ function copyToVersionedCache(npmBinaryPath) {
     const version2 = rawVersion.replace(/^aft\s+/, "");
     const tag = version2.startsWith("v") ? version2 : `v${version2}`;
     const cacheDir = getCacheDir();
-    const versionedDir = join7(cacheDir, tag);
+    const versionedDir = join10(cacheDir, tag);
     const ext = process.platform === "win32" ? ".exe" : "";
-    const cachedPath = join7(versionedDir, `aft${ext}`);
-    if (existsSync5(cachedPath))
+    const cachedPath = join10(versionedDir, `aft${ext}`);
+    if (existsSync8(cachedPath))
       return cachedPath;
-    mkdirSync4(versionedDir, { recursive: true });
+    mkdirSync6(versionedDir, { recursive: true });
     const tmpPath = `${cachedPath}.tmp`;
-    copyFileSync(npmBinaryPath, tmpPath);
+    copyFileSync2(npmBinaryPath, tmpPath);
     if (process.platform !== "win32") {
       chmodSync3(tmpPath, 493);
     }
-    renameSync(tmpPath, cachedPath);
+    renameSync2(tmpPath, cachedPath);
     log(`Copied npm binary to versioned cache: ${cachedPath}`);
     return cachedPath;
   } catch (err) {
@@ -15147,7 +16545,7 @@ function findBinarySync() {
     const packageBin = `@cortexkit/aft-${key}/bin/aft${ext}`;
     const req = createRequire2(import.meta.url);
     const resolved = req.resolve(packageBin);
-    if (existsSync5(resolved)) {
+    if (existsSync8(resolved)) {
       const copied = copyToVersionedCache(resolved);
       return copied ?? resolved;
     }
@@ -15161,8 +16559,8 @@ function findBinarySync() {
     if (result)
       return result;
   } catch {}
-  const cargoPath = join7(homedir4(), ".cargo", "bin", `aft${ext}`);
-  if (existsSync5(cargoPath))
+  const cargoPath = join10(homedir5(), ".cargo", "bin", `aft${ext}`);
+  if (existsSync8(cargoPath))
     return cargoPath;
   return null;
 }
@@ -15252,7 +16650,7 @@ import { StringEnum } from "@mariozechner/pi-ai";
 import { Type } from "@sinclair/typebox";
 
 // src/tools/render-helpers.ts
-import { homedir as homedir5 } from "node:os";
+import { homedir as homedir6 } from "node:os";
 import { renderDiff } from "@mariozechner/pi-coding-agent";
 import { Container, Spacer, Text } from "@mariozechner/pi-tui";
 function reuseText(last) {
@@ -15262,7 +16660,7 @@ function reuseContainer(last) {
   return last instanceof Container ? last : new Container;
 }
 function shortenPath(path2) {
-  const home = homedir5();
+  const home = homedir6();
   if (path2.startsWith(home))
     return `~${path2.slice(home.length)}`;
   return path2;
@@ -15764,8 +17162,8 @@ function registerFsTools(pi, ctx, surface) {
 
 // src/tools/hoisted.ts
 import { stat } from "node:fs/promises";
-import { homedir as homedir6 } from "node:os";
-import { resolve } from "node:path";
+import { homedir as homedir7 } from "node:os";
+import { resolve as resolve2 } from "node:path";
 import {
   renderDiff as renderDiff2
 } from "@mariozechner/pi-coding-agent";
@@ -16118,13 +17516,13 @@ ${summary}${suffix}`);
   return container;
 }
 function shortenPath2(path2) {
-  const home = homedir6();
+  const home = homedir7();
   if (path2.startsWith(home))
     return `~${path2.slice(home.length)}`;
   return path2;
 }
 async function resolvePathArg(cwd, path2) {
-  const abs = resolve(cwd, path2);
+  const abs = resolve2(cwd, path2);
   try {
     await stat(abs);
     return abs;
@@ -16498,12 +17896,12 @@ function registerNavigateTool(pi, ctx) {
 
 // src/tools/reading.ts
 import { stat as stat2 } from "node:fs/promises";
-import { resolve as resolve2 } from "node:path";
+import { resolve as resolve3 } from "node:path";
 import { Type as Type8 } from "@sinclair/typebox";
 
 // src/shared/discover-files.ts
 import { readdir } from "node:fs/promises";
-import { extname, join as join8 } from "node:path";
+import { extname, join as join11 } from "node:path";
 var OUTLINE_EXTENSIONS = new Set([
   ".ts",
   ".tsx",
@@ -16575,12 +17973,12 @@ async function discoverSourceFiles(dir, maxFiles = 200) {
         return;
       if (entry.isDirectory()) {
         if (!SKIP_DIRS.has(entry.name) && !entry.name.startsWith(".")) {
-          await walk(join8(current, entry.name));
+          await walk(join11(current, entry.name));
         }
       } else if (entry.isFile()) {
         const ext = extname(entry.name).toLowerCase();
         if (OUTLINE_EXTENSIONS.has(ext)) {
-          files.push(join8(current, entry.name));
+          files.push(join11(current, entry.name));
         }
       }
     }
@@ -16691,14 +18089,14 @@ function registerReadingTools(pi, ctx, surface) {
         let dirArg = hasDirectory ? params.directory : undefined;
         if (!dirArg && hasFilePath) {
           try {
-            const resolved = resolve2(extCtx.cwd, params.filePath);
+            const resolved = resolve3(extCtx.cwd, params.filePath);
             const st = await stat2(resolved);
             if (st.isDirectory())
               dirArg = params.filePath;
           } catch {}
         }
         if (dirArg) {
-          const dirPath = resolve2(extCtx.cwd, dirArg);
+          const dirPath = resolve3(extCtx.cwd, dirArg);
           const files = await discoverSourceFiles(dirPath);
           if (files.length === 0) {
             return textResult(`No source files found under ${dirArg}`);
@@ -17272,7 +18670,7 @@ function coerceConfigureWarnings(warnings) {
   return warnings.filter(isConfigureWarning);
 }
 function resolveStorageDir() {
-  return join9(homedir7(), ".pi", "agent", "aft");
+  return join12(homedir8(), ".pi", "agent", "aft");
 }
 function resolveToolSurface(config2) {
   const surface = config2.tool_surface ?? "recommended";
@@ -17355,16 +18753,85 @@ async function src_default(pi) {
       warn(`Failed to prepare ONNX Runtime: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const configOverrides = {
-    ...config2,
-    ...resolveLspConfigForConfigure(config2),
-    restrict_to_project_root: config2.restrict_to_project_root ?? true,
-    storage_dir: storageDir
-  };
-  delete configOverrides.lsp;
+  const configOverrides = {};
+  if (config2.format_on_edit !== undefined)
+    configOverrides.format_on_edit = config2.format_on_edit;
+  if (config2.validate_on_edit !== undefined)
+    configOverrides.validate_on_edit = config2.validate_on_edit;
+  if (config2.formatter !== undefined)
+    configOverrides.formatter = config2.formatter;
+  if (config2.checker !== undefined)
+    configOverrides.checker = config2.checker;
+  configOverrides.restrict_to_project_root = config2.restrict_to_project_root ?? true;
+  if (config2.experimental_search_index !== undefined)
+    configOverrides.experimental_search_index = config2.experimental_search_index;
+  if (config2.experimental_semantic_search !== undefined)
+    configOverrides.experimental_semantic_search = config2.experimental_semantic_search;
+  Object.assign(configOverrides, resolveLspConfigForConfigure(config2));
+  if (config2.semantic !== undefined)
+    configOverrides.semantic = config2.semantic;
+  if (config2.max_callgraph_files !== undefined)
+    configOverrides.max_callgraph_files = config2.max_callgraph_files;
+  if (config2.url_fetch_allow_private !== undefined)
+    configOverrides.url_fetch_allow_private = config2.url_fetch_allow_private;
+  configOverrides.storage_dir = storageDir;
   if (ortDylibDir) {
     configOverrides._ort_dylib_dir = ortDylibDir;
   }
+  try {
+    const lspAutoInstall = config2.lsp?.auto_install ?? true;
+    const lspGraceDays = config2.lsp?.grace_days ?? 7;
+    const lspVersions = config2.lsp?.versions ?? {};
+    const lspDisabled = new Set(config2.lsp?.disabled ?? []);
+    const projectRoot = process.cwd();
+    const npmResult = runAutoInstall(projectRoot, {
+      autoInstall: lspAutoInstall,
+      graceDays: lspGraceDays,
+      versions: lspVersions,
+      disabled: lspDisabled
+    });
+    const relevantGithub = discoverRelevantGithubServers(projectRoot);
+    const ghResult = runGithubAutoInstall(relevantGithub, {
+      autoInstall: lspAutoInstall,
+      graceDays: lspGraceDays,
+      versions: lspVersions,
+      disabled: lspDisabled
+    });
+    const mergedBinDirs = [...npmResult.cachedBinDirs, ...ghResult.cachedBinDirs];
+    if (mergedBinDirs.length > 0) {
+      configOverrides.lsp_paths_extra = mergedBinDirs;
+    }
+    if (npmResult.installsStarted > 0 || ghResult.installsStarted > 0) {
+      log(`[lsp] auto-install: ${npmResult.installsStarted} npm + ${ghResult.installsStarted} github install(s) running in background`);
+    }
+    Promise.all([npmResult.installsComplete, ghResult.installsComplete]).then(() => {
+      const actionable = [...npmResult.skipped, ...ghResult.skipped].filter((s) => {
+        const r = s.reason.toLowerCase();
+        if (r === "auto_install: false")
+          return false;
+        if (r === "disabled by config")
+          return false;
+        if (r === "not relevant to project")
+          return false;
+        if (r === "already installed")
+          return false;
+        if (r === "another install in progress")
+          return false;
+        return true;
+      });
+      if (actionable.length === 0)
+        return;
+      const lines = actionable.map((s) => `  • ${s.id}: ${s.reason}`).join(`
+`);
+      warn(`[lsp] skipped or failed to install ${actionable.length} server(s):
+${lines}
+` + 'Pin a working version with `lsp.versions: { "<package>": "<version>" }` if grace is blocking, ' + "or set `lsp.auto_install: false` to suppress.");
+    }).catch((err) => {
+      warn(`[lsp] install-summary aggregation failed: ${err}`);
+    });
+  } catch (err) {
+    warn(`[lsp] auto-install setup failed: ${err instanceof Error ? err.message : String(err)}`);
+  }
   const pool = new BridgePool(binaryPath, {
     minVersion: PLUGIN_VERSION,
     onConfigureWarnings: async ({ projectRoot, sessionId, client, warnings }) => {
@@ -17421,6 +18888,7 @@ async function src_default(pi) {
   registerStatusCommand(pi, ctx);
   pi.on("session_shutdown", async () => {
     try {
+      await Promise.allSettled([abortInFlightAutoInstalls(), abortInFlightGithubInstalls()]);
       await pool.shutdown();
       log("Bridge pool shut down");
     } catch (err) {
@@ -17429,6 +18897,7 @@ async function src_default(pi) {
   });
   registerShutdownCleanup(async () => {
     try {
+      await Promise.allSettled([abortInFlightAutoInstalls(), abortInFlightGithubInstalls()]);
       await pool.shutdown();
     } catch (err) {
       warn(`Error during process shutdown: ${err instanceof Error ? err.message : String(err)}`);