@klhapp/skillmux 1.0.0 → 1.1.0

package/src/commands/project.ts

@@ -0,0 +1,412 @@
+import { existsSync, lstatSync } from "node:fs";
+import { basename } from "node:path";
+import { expandHome } from "../config";
+import { planClientSurfaces, SUPPORTED_CLIENT_IDS } from "../init-clients";
+import {
+  parseManifest,
+  pinProject,
+  unpinProject,
+  updateProjectPaths,
+  updateProjectTargets,
+  upsertProject,
+  validateManifest,
+  writeManifestAtomic,
+} from "../manifest";
+import { resolveProjectDirectory, suggestProjectName } from "../project-setup";
+import {
+  parseCommaList,
+  promptMultiSelect,
+  promptText,
+  shouldUseWizard,
+} from "../prompts";
+import { emitSuccess, isInteractive } from "../output";
+import { confirmAction, confirmIfNeeded, loadManifestContext } from "./shared";
+const PROJECT_INIT_USAGE =
+  "usage: skillmux project init [path] [--name <group>] [--skill <id>...] [--client <id>...] [--target <name>...] [--yes] [--no-sync]";
+
+interface ProjectInitArgs {
+  path: string;
+  name: string;
+  skills: string[];
+  clients: string[];
+  targets: string[];
+  yes: boolean;
+  sync: boolean;
+}
+
+export function configuredTargetForSurface(
+  manifest: ReturnType<typeof parseManifest>,
+  surface: { targetName: string; path: string },
+): string | undefined {
+  if (manifest.targets[surface.targetName]) return surface.targetName;
+  return Object.entries(manifest.targets).find(
+    ([, target]) => expandHome(target.dir) === surface.path,
+  )?.[0];
+}
+
+function configuredTargetsForClients(
+  manifest: ReturnType<typeof parseManifest>,
+  clients: readonly string[],
+): string[] {
+  return planClientSurfaces(clients).surfaces.map((surface) => {
+    const target = configuredTargetForSurface(manifest, surface);
+    if (target) return target;
+    const client = surface.clients[0]!;
+    throw new Error(
+      `client target for "${client}" is not configured; run "skillmux init --client ${client} --yes" first`,
+    );
+  });
+}
+
+function parseProjectInitArgs(args: string[]): ProjectInitArgs {
+  let projectPath: string | undefined;
+  let name: string | undefined;
+  const skills: string[] = [];
+  const clients: string[] = [];
+  const targets: string[] = [];
+  let yes = false;
+  let sync = true;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === "--name") {
+      name = args[++i];
+      if (!name) throw new Error("--name requires a group name");
+    } else if (arg === "--skill") {
+      const skill = args[++i];
+      if (!skill) throw new Error("--skill requires a skill_id");
+      skills.push(skill);
+    } else if (arg === "--target") {
+      const target = args[++i];
+      if (!target) throw new Error("--target requires a name");
+      targets.push(target);
+    } else if (arg === "--client") {
+      const client = args[++i];
+      if (!client) throw new Error("--client requires a name");
+      clients.push(client);
+    } else if (arg === "--yes") {
+      yes = true;
+    } else if (arg === "--no-sync") {
+      sync = false;
+    } else if (
+      arg === "--dry-run" ||
+      arg === "--json" ||
+      arg === "--interactive"
+    ) {
+      continue;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`unknown project init option: ${arg}`);
+    } else if (projectPath) {
+      throw new Error(PROJECT_INIT_USAGE);
+    } else {
+      projectPath = arg;
+    }
+  }
+
+  const path = resolveProjectDirectory(
+    projectPath ? expandHome(projectPath) : undefined,
+  );
+  return {
+    path,
+    name: name ?? suggestProjectName(basename(path)),
+    skills,
+    clients,
+    targets,
+    yes,
+    sync,
+  };
+}
+
+export async function runProject(
+  subCommand: string,
+  args: string[],
+  options: {
+    isJson: boolean;
+    dryRun: boolean;
+    sync: (args: string[]) => Promise<void>;
+  },
+): Promise<void> {
+  if (subCommand === "list" || subCommand === "show") {
+    const { manifest } = await loadManifestContext();
+    const names =
+      subCommand === "show"
+        ? [args[0] ?? ""]
+        : Object.keys(manifest.project ?? {});
+    if (subCommand === "show" && !manifest.project?.[names[0]!]) {
+      throw new Error(`[project.${names[0]}] does not exist`);
+    }
+    const projects = names.map((name) => ({
+      name,
+      paths: manifest.project?.[name]!.paths ?? [],
+      skills: manifest.project?.[name]!.skills ?? [],
+      targets: Object.entries(manifest.targets)
+        .filter(([, target]) => target.project_groups.includes(name))
+        .map(([target]) => target),
+    }));
+    emitSuccess({ isJson: options.isJson }, { projects }, () => {
+      if (projects.length === 0) {
+        console.log("no project groups configured");
+      } else {
+        for (const project of projects) {
+          console.log(`${project.name}:`);
+          console.log(`  paths: ${project.paths.join(", ") || "(none)"}`);
+          console.log(`  skills: ${project.skills.join(", ") || "(none)"}`);
+          console.log(`  targets: ${project.targets.join(", ") || "(none)"}`);
+        }
+      }
+    });
+    return;
+  }
+  if (subCommand === "add-path" || subCommand === "remove-path") {
+    const group = args[0];
+    if (!group)
+      throw new Error(
+        `usage: skillmux project ${subCommand} <group> [path] --yes`,
+      );
+    const rawPath = args[1]?.startsWith("-") ? undefined : args[1];
+    const projectPath = resolveProjectDirectory(
+      rawPath ? expandHome(rawPath) : undefined,
+    );
+    const yes = args.includes("--yes");
+    if (!existsSync(projectPath) || !lstatSync(projectPath).isDirectory()) {
+      throw new Error(`project path is not a directory: ${projectPath}`);
+    }
+    const { config, vaultPath, manifestPath, manifest } =
+      await loadManifestContext();
+    const updated = updateProjectPaths(manifest, group, {
+      ...(subCommand === "add-path"
+        ? { add: [projectPath] }
+        : { remove: [projectPath] }),
+    });
+    validateManifest(
+      updated,
+      vaultPath,
+      config.local_vault_paths.map(expandHome),
+    );
+    if (options.dryRun) {
+      console.log(`${subCommand}: [project.${group}] ${projectPath} (dry-run)`);
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: yes,
+        isJson: options.isJson,
+        prompt: `${subCommand} ${projectPath} in [project.${group}]?`,
+        nonInteractiveError: `skillmux project ${subCommand} requires --yes when run non-interactively`,
+      }))
+    )
+      return;
+    writeManifestAtomic(manifestPath, updated);
+    console.log(`${subCommand}: [project.${group}] ${projectPath}`);
+    return;
+  }
+  if (subCommand === "pin" || subCommand === "unpin") {
+    const group = args[0];
+    const skills = args.slice(1).filter((arg) => !arg.startsWith("-"));
+    if (!group || skills.length === 0) {
+      throw new Error(
+        `usage: skillmux project ${subCommand} <group> <skill_id>... --yes`,
+      );
+    }
+    const yes = args.includes("--yes");
+    const { config, vaultPath, manifestPath, manifest } =
+      await loadManifestContext();
+    let updated = manifest;
+    for (const skill of skills) {
+      updated =
+        subCommand === "pin"
+          ? pinProject(updated, skill, group)
+          : unpinProject(updated, skill, group);
+    }
+    validateManifest(
+      updated,
+      vaultPath,
+      config.local_vault_paths.map(expandHome),
+    );
+    if (options.dryRun) {
+      console.log(
+        `${subCommand}: [project.${group}] ${skills.join(", ")} (dry-run)`,
+      );
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: yes,
+        isJson: options.isJson,
+        prompt: `${subCommand} ${skills.join(", ")} in [project.${group}]?`,
+        nonInteractiveError: `skillmux project ${subCommand} requires --yes when run non-interactively`,
+      }))
+    )
+      return;
+    writeManifestAtomic(manifestPath, updated);
+    console.log(`${subCommand}: [project.${group}] ${skills.join(", ")}`);
+    return;
+  }
+  if (subCommand === "attach" || subCommand === "detach") {
+    const group = args[0];
+    if (!group)
+      throw new Error(
+        `usage: skillmux project ${subCommand} <group> (--client <id>... | --target <name>...) --yes`,
+      );
+    const clients: string[] = [];
+    const requestedTargets: string[] = [];
+    for (let i = 1; i < args.length; i++) {
+      if (args[i] === "--client") {
+        const value = args[++i];
+        if (!value) throw new Error("--client requires a name");
+        clients.push(value);
+      } else if (args[i] === "--target") {
+        const value = args[++i];
+        if (!value) throw new Error("--target requires a name");
+        requestedTargets.push(value);
+      } else if (
+        args[i] !== "--yes" &&
+        args[i] !== "--dry-run" &&
+        args[i] !== "--json"
+      ) {
+        throw new Error(`unknown project ${subCommand} option: ${args[i]}`);
+      }
+    }
+    const { config, vaultPath, manifestPath, manifest } =
+      await loadManifestContext();
+    const clientTargets = configuredTargetsForClients(manifest, clients);
+    const targets = [...new Set([...requestedTargets, ...clientTargets])];
+    if (targets.length === 0) {
+      throw new Error(`project ${subCommand} requires --client or --target`);
+    }
+    const updated = updateProjectTargets(manifest, group, {
+      ...(subCommand === "attach" ? { attach: targets } : { detach: targets }),
+    });
+    validateManifest(
+      updated,
+      vaultPath,
+      config.local_vault_paths.map(expandHome),
+    );
+    if (options.dryRun) {
+      console.log(
+        `${subCommand}: [project.${group}] ${targets.join(", ")} (dry-run)`,
+      );
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: args.includes("--yes"),
+        isJson: options.isJson,
+        prompt: `${subCommand} [project.${group}] to ${targets.join(", ")}?`,
+        nonInteractiveError: `skillmux project ${subCommand} requires --yes when run non-interactively`,
+      }))
+    )
+      return;
+    writeManifestAtomic(manifestPath, updated);
+    console.log(`${subCommand}: [project.${group}] ${targets.join(", ")}`);
+    return;
+  }
+  if (subCommand !== "init") throw new Error(PROJECT_INIT_USAGE);
+  let request = parseProjectInitArgs(args);
+  const guided = shouldUseWizard(args, {
+    interactive: isInteractive(),
+    json: options.isJson,
+    dryRun: options.dryRun,
+  });
+  if (!existsSync(request.path))
+    throw new Error(`project path does not exist: ${request.path}`);
+  if (!lstatSync(request.path).isDirectory()) {
+    throw new Error(`project path is not a directory: ${request.path}`);
+  }
+
+  const { config, vaultPath, manifestPath, manifest } =
+    await loadManifestContext();
+  const localVaultPaths = config.local_vault_paths.map(expandHome);
+  if (guided) {
+    const name = await promptText("Project group", request.name);
+    const availableClients = SUPPORTED_CLIENT_IDS.filter((client) => {
+      const surface = planClientSurfaces([client]).surfaces[0];
+      return (
+        surface !== undefined &&
+        configuredTargetForSurface(manifest, surface) !== undefined
+      );
+    });
+    const clients = await promptMultiSelect(
+      "Which clients should receive project skills?",
+      availableClients.map((client) => ({
+        value: client,
+        label: client,
+        selected:
+          request.clients.length === 0 || request.clients.includes(client),
+      })),
+    );
+    const skills = parseCommaList(
+      await promptText(
+        "Project skill IDs, comma-separated",
+        request.skills.join(","),
+      ),
+    );
+    request = { ...request, name, clients, skills };
+  }
+  const clientTargets = configuredTargetsForClients(manifest, request.clients);
+  const targets = [...new Set([...request.targets, ...clientTargets])];
+  const updated = upsertProject(manifest, {
+    name: request.name,
+    paths: [request.path],
+    skills: request.skills,
+    targets,
+  });
+  const { notes } = validateManifest(updated, vaultPath, localVaultPaths);
+  const plan = {
+    mode: "project",
+    project: request.name,
+    path: request.path,
+    skills: request.skills,
+    clients: request.clients,
+    targets,
+    sync: request.sync,
+    notes,
+  };
+
+  if (options.dryRun) {
+    emitSuccess({ isJson: options.isJson }, { plan }, () =>
+      console.log(`project plan: ${JSON.stringify(plan)}`),
+    );
+    return;
+  }
+  if (!request.yes) {
+    if (!options.isJson && isInteractive()) {
+      if (guided) {
+        console.log("\nReview");
+        console.log(`  project: ${request.name}`);
+        console.log(`  path: ${request.path}`);
+        console.log(`  clients: ${request.clients.join(", ") || "(none)"}`);
+        console.log(`  skills: ${request.skills.join(", ") || "(none)"}`);
+        console.log(`  sync: ${request.sync ? "yes" : "no"}`);
+      }
+      if (
+        !(await confirmAction(
+          `Apply project setup for ${request.name} at ${request.path}?`,
+        ))
+      ) {
+        console.log("project setup cancelled");
+        return;
+      }
+    } else {
+      throw new Error(
+        "skillmux project init requires --yes when run non-interactively",
+      );
+    }
+  }
+
+  writeManifestAtomic(manifestPath, updated);
+  if (request.sync) {
+    try {
+      await options.sync([]);
+    } catch (error) {
+      throw new Error(
+        `project configuration was saved, but sync failed; fix the reported issue and run "skillmux sync": ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      );
+    }
+  }
+  emitSuccess({ isJson: options.isJson }, { result: plan }, () =>
+    console.log(`project "${request.name}" ready at ${request.path}`),
+  );
+}

package/src/commands/shared.ts

@@ -0,0 +1,45 @@
+import { createInterface } from "node:readline/promises";
+import { expandHome, loadConfig } from "../config";
+import { parseManifest, resolveManifestPath } from "../manifest";
+import { isInteractive } from "../output";
+
+export async function confirmAction(prompt: string): Promise<boolean> {
+  const readline = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    const answer = (await readline.question(`${prompt} [y/N] `))
+      .trim()
+      .toLowerCase();
+    return answer === "y" || answer === "yes";
+  } finally {
+    readline.close();
+  }
+}
+
+export async function loadManifestContext() {
+  const config = await loadConfig();
+  const vaultPath = expandHome(config.vault_path);
+  const manifestPath = resolveManifestPath(vaultPath);
+  if (!manifestPath) {
+    throw new Error(
+      `no skillmux.toml found at ${vaultPath}; run skillmux init first`,
+    );
+  }
+  const manifest = parseManifest(await Bun.file(manifestPath).text());
+  return { config, vaultPath, manifestPath, manifest };
+}
+
+export async function confirmIfNeeded(opts: {
+  confirmed: boolean;
+  isJson: boolean;
+  prompt: string;
+  nonInteractiveError: string;
+}): Promise<boolean> {
+  if (opts.confirmed) return true;
+  if (opts.isJson || !isInteractive()) {
+    throw new Error(opts.nonInteractiveError);
+  }
+  return confirmAction(opts.prompt);
+}

package/src/commands/target.ts

@@ -0,0 +1,110 @@
+import { expandHome } from "../config";
+import { planClientSurfaces, SUPPORTED_CLIENT_IDS } from "../init-clients";
+import { planInitManifest, applyInit } from "../init";
+import { writeManifestAtomic } from "../manifest";
+import { emitSuccess } from "../output";
+import { confirmIfNeeded, loadManifestContext } from "./shared";
+export async function runTarget(
+  subCommand: string,
+  args: string[],
+  options: { isJson: boolean; dryRun: boolean },
+): Promise<void> {
+  const { vaultPath, manifestPath, manifest } = await loadManifestContext();
+
+  if (subCommand === "list" || subCommand === "show") {
+    const names =
+      subCommand === "show" ? [args[0] ?? ""] : Object.keys(manifest.targets);
+    if (subCommand === "show" && !manifest.targets[names[0]!]) {
+      throw new Error(`target "${names[0]}" does not exist`);
+    }
+    const targets = names.map((name) => {
+      const target = manifest.targets[name]!;
+      const clients = SUPPORTED_CLIENT_IDS.filter((client) => {
+        const surface = planClientSurfaces([client]).surfaces[0];
+        return surface !== undefined && surface.path === expandHome(target.dir);
+      });
+      return { name, ...target, clients };
+    });
+    emitSuccess({ isJson: options.isJson }, { targets }, () => {
+      if (targets.length === 0) {
+        console.log("no targets configured");
+      } else {
+        for (const target of targets) {
+          console.log(`${target.name}:`);
+          console.log(`  dir: ${target.dir}`);
+          console.log(`  host: ${target.host ?? "(global)"}`);
+          console.log(`  clients: ${target.clients.join(", ") || "(custom)"}`);
+          console.log(
+            `  projects: ${target.project_groups.join(", ") || "(none)"}`,
+          );
+        }
+      }
+    });
+    return;
+  }
+
+  if (subCommand === "add") {
+    const name = args[0];
+    const dirIndex = args.indexOf("--dir");
+    const rawPath = dirIndex === -1 ? undefined : args[dirIndex + 1];
+    if (!name || !rawPath)
+      throw new Error("usage: skillmux target add <name> --dir <dir> --yes");
+    const path = expandHome(rawPath);
+    if (options.dryRun) {
+      const planned = planInitManifest(vaultPath, [{ name, dir: path }], []);
+      emitSuccess(
+        { isJson: options.isJson },
+        { target: planned.targets[name] },
+        () => console.log(`target add: ${name} -> ${path} (dry-run)`),
+      );
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: args.includes("--yes"),
+        isJson: options.isJson,
+        prompt: `Adopt target ${name} at ${path}?`,
+        nonInteractiveError:
+          "skillmux target add requires --yes when run non-interactively",
+      }))
+    )
+      return;
+    applyInit(vaultPath, [{ name, dir: path }]);
+    console.log(`target "${name}" added at ${path}`);
+    return;
+  }
+
+  if (subCommand === "remove") {
+    const name = args[0];
+    if (!name || !manifest.targets[name]) {
+      throw new Error(
+        name
+          ? `target "${name}" does not exist`
+          : "usage: skillmux target remove <name> --yes",
+      );
+    }
+    if (options.dryRun) {
+      console.log(`target remove: ${name} (files preserved, dry-run)`);
+      return;
+    }
+    if (
+      !(await confirmIfNeeded({
+        confirmed: args.includes("--yes"),
+        isJson: options.isJson,
+        prompt: `Remove target ${name} from the manifest and preserve its files?`,
+        nonInteractiveError:
+          "skillmux target remove requires --yes when run non-interactively",
+      }))
+    )
+      return;
+    const targets = { ...manifest.targets };
+    delete targets[name];
+    writeManifestAtomic(manifestPath, { ...manifest, targets });
+    console.log(
+      `target "${name}" removed from the manifest; files preserved at ${manifest.targets[name]!.dir}`,
+    );
+    return;
+  }
+
+  throw new Error("usage: skillmux target <list|show|add|remove>");
+}

package/src/config-mutation.ts

@@ -0,0 +1,65 @@
+import { writeFileSync, renameSync } from "node:fs";
+
+export interface ThresholdsPatchOptions {
+  matchScore: number;
+  matchMargin: number;
+  candidateFloor: number;
+  runId: string;
+}
+
+/**
+ * Remove a TOML section header and all lines until the next section header
+ * (or end of file). Matches exact header string at start of line.
+ */
+export function removeSectionBlock(source: string, header: string): string {
+  const lines = source.split("\n");
+  const out: string[] = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.trimEnd();
+    if (trimmed === header || trimmed.startsWith(header + " ")) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && line.trimStart().startsWith("[")) {
+      skipping = false;
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join("\n");
+}
+
+/**
+ * Surgically patch a TOML string to set [inference.thresholds] values and
+ * [inference.calibration] run_id while preserving unrelated sections and comments.
+ */
+export function patchToml(
+  source: string,
+  opts: ThresholdsPatchOptions,
+): string {
+  const thresholdsBlock = `[inference.thresholds]\nmatch_score = ${opts.matchScore}\nmatch_margin = ${opts.matchMargin}\ncandidate_floor = ${opts.candidateFloor}\n`;
+  const calibrationBlock = `[inference.calibration]\nrun_id = "${opts.runId}"\n`;
+
+  // Remove any existing [inference.thresholds] and [inference.calibration] sections
+  let result = removeSectionBlock(source, "[inference.thresholds]");
+  result = removeSectionBlock(result, "[inference.calibration]");
+
+  // Append both sections cleanly
+  result = result.trimEnd() + "\n\n" + thresholdsBlock + "\n" + calibrationBlock;
+  return result;
+}
+
+/**
+ * Atomically write patched TOML to disk via temp file write and renameSync.
+ */
+export async function patchTomlFile(
+  tomlPath: string,
+  opts: ThresholdsPatchOptions,
+): Promise<void> {
+  const existing = await Bun.file(tomlPath).text();
+  const patched = patchToml(existing, opts);
+
+  const tmpPath = `${tomlPath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, patched);
+  renameSync(tmpPath, tomlPath);
+}

package/src/config-service.ts

@@ -44,6 +44,10 @@ export const RESTART_REQUIRED_KEYS = [
   "inference.bundle",
   "inference.models_dir",
   "state_dir",
+  "inference.embedding.model",
+  "inference.embedding.dimension",
+  "inference.embedding.device",
+  "inference.embedding.dtype",
 ];
 
 export const RELOADABLE_KEYS = [
@@ -54,12 +58,13 @@ export const RELOADABLE_KEYS = [
   "thresholds.match_score",
   "thresholds.match_margin",
   "thresholds.candidate_floor",
-  "inference.embedding.model",
-  "inference.embedding.dimension",
-  "inference.embedding.device",
-  "inference.embedding.dtype",
-  "inference.embedding.base_url",
+  "inference.embedding.endpoint",
   "inference.embedding.api_key_env",
+  "inference.reranker.adapter",
+  "inference.reranker.endpoint",
+  "inference.reranker.model",
+  "inference.reranker.api_key_env",
+  "inference.timeout_ms",
   "server.rate_limit.enabled",
   "server.rate_limit.requests_per_minute",
   "server.rate_limit.trust_proxy",
@@ -146,8 +151,12 @@ export async function getEffectiveConfig(configPath?: string): Promise<{
     "inference.embedding.dimension",
     "inference.embedding.device",
     "inference.embedding.dtype",
-    "inference.embedding.base_url",
+    "inference.embedding.endpoint",
     "inference.embedding.api_key_env",
+    "inference.reranker.adapter",
+    "inference.reranker.endpoint",
+    "inference.reranker.model",
+    "inference.reranker.api_key_env",
     "inference.timeout_ms",
     "server.auth_enabled",
     "server.auth_token_env",
@@ -178,8 +187,12 @@ export function isEnvMasked(key: string): boolean {
   if (key === "inference.models_dir" && (process.env.SKILLMUX_MODELS_DIR || process.env.SKILL_ROUTER_MODELS_DIR)) return true;
   if (key === "inference.embedding.device" && process.env.EMBED_DEVICE) return true;
   if (key === "inference.embedding.dtype" && process.env.EMBED_DTYPE) return true;
-  if (key === "inference.embedding.base_url" && (process.env.SKILLMUX_EMBED_BASE_URL || process.env.EMBED_BASE_URL)) return true;
+  if (key === "inference.embedding.endpoint" && (process.env.SKILLMUX_EMBED_ENDPOINT || process.env.EMBED_ENDPOINT)) return true;
   if (key === "inference.embedding.model" && (process.env.SKILLMUX_EMBED_MODEL || process.env.EMBED_MODEL)) return true;
+  if (key === "inference.embedding.dimension" && (process.env.SKILLMUX_EMBED_DIMENSION || process.env.EMBED_DIMENSION)) return true;
+  if (key === "inference.reranker.adapter" && (process.env.SKILLMUX_RERANK_ADAPTER || process.env.RERANK_ADAPTER)) return true;
+  if (key === "inference.reranker.endpoint" && (process.env.SKILLMUX_RERANK_ENDPOINT || process.env.RERANK_ENDPOINT)) return true;
+  if (key === "inference.reranker.model" && (process.env.SKILLMUX_RERANK_MODEL || process.env.RERANK_MODEL)) return true;
   if (key === "server.auth_enabled" && process.env.HTTP_AUTH_ENABLED) return true;
   if (key === "server.auth_token_env" && process.env.HTTP_AUTH_TOKEN_ENV) return true;
   if (key === "server.hostname" && process.env.HTTP_HOSTNAME) return true;
@@ -206,8 +219,12 @@ export function validateDottedKey(key: string): void {
     "inference.embedding.dimension",
     "inference.embedding.device",
     "inference.embedding.dtype",
-    "inference.embedding.base_url",
+    "inference.embedding.endpoint",
     "inference.embedding.api_key_env",
+    "inference.reranker.adapter",
+    "inference.reranker.endpoint",
+    "inference.reranker.model",
+    "inference.reranker.api_key_env",
     "inference.timeout_ms",
     "server.auth_enabled",
     "server.auth_token_env",