@klhapp/skillmux 1.5.2 → 1.7.0

package/src/cli.ts

@@ -4,7 +4,6 @@ import { Database } from "bun:sqlite";
 import { existsSync, lstatSync, mkdirSync, rmSync } from "node:fs";
 import { hostname } from "node:os";
 import { join } from "node:path";
-import { generateDataset } from "./dataset-generator";
 
 import { createClients } from "./clients";
 import {
@@ -116,7 +115,6 @@ import { runTarget } from "./commands/target";
 const KNOWN_COMMANDS = [
   "context",
   "config",
-  "calibrate",
   "completions",
   "serve",
   "index",
@@ -147,7 +145,6 @@ function isDockerHostManagementCommand(command: string, subCommand: string): boo
       "local-vault",
       "models",
       "context",
-      "calibrate",
       "eval",
     ].includes(command)
   ) {
@@ -210,7 +207,7 @@ async function main() {
     return;
   }
 
-  // Parse global flags for context/config/calibrate
+  // Parse global flags for context/config
   for (let i = 0; i < rawArgv.length; i++) {
     const arg = rawArgv[i];
     if (arg === "--json") isJson = true;
@@ -235,10 +232,10 @@ async function main() {
     return;
   }
 
-  // Only resolve target if command is target-aware or context/config/calibrate
+  // Only resolve target if command is target-aware or context/config
   const isLocalConfigInit = command === "config" && rawArgv[1] === "init";
   if (
-    (["context", "config", "calibrate"].includes(command) &&
+    (["context", "config"].includes(command) &&
       !isLocalConfigInit) ||
     flagContext ||
     flagServer
@@ -272,11 +269,9 @@ async function main() {
         });
         break;
       case "calibrate":
-        await handleCalibrateCommand(adapter, subCommand, rawArgv.slice(1), {
-          target: resolvedTarget,
-          isJson,
-        });
-        break;
+        throw new Error(
+          'skillmux calibrate was removed in 2.0. Threshold calibration was removed; use "skillmux eval" for ranking evaluation.',
+        );
       case "completions":
         await handleCompletionsCommand(subCommand);
         break;
@@ -364,7 +359,7 @@ async function main() {
         const suggestion = suggestCorrection(command, KNOWN_COMMANDS);
         const msg = suggestion
           ? `Unknown command "${command}". Did you mean "${suggestion}"?`
-          : `usage: skillmux <serve|index|sync|init|project|target|core pin/unpin|report|scan|install|eval|doctor|skill which|local-vault init|config show|models download|calibrate generate-dataset>`;
+          : `usage: skillmux <serve|index|sync|init|project|target|core pin/unpin|report|scan|install|eval|doctor|skill which|local-vault init|config show|models download>`;
         throw new Error(msg);
       }
     }
@@ -463,169 +458,6 @@ async function handleContextCommand(
   throw new Error("usage: skillmux context <add|list|current|use|remove>");
 }
 
-async function handleCalibrateCommand(
-  adapter: TargetAdapter,
-  sub: string,
-  args: string[],
-  ctx: { target: ResolvedTarget; isJson: boolean },
-) {
-  if (sub === "run") {
-    let datasetPath: string | undefined;
-    let minAutoMatchPrecision: number | undefined;
-    let minRetrievalRecallAtK: number | undefined;
-    let minDeliveredShortlistRecallAtK: number | undefined;
-    let minAutoMatchCount: number | undefined;
-    let concurrency: number | undefined;
-    let resumeRunId: string | undefined;
-    let timing = false;
-    const readNumber = (flag: string, raw: string | undefined): number => {
-      if (raw === undefined) throw new Error(`${flag} requires a value`);
-      const value = Number(raw);
-      if (!Number.isFinite(value)) throw new Error(`${flag} must be a number`);
-      return value;
-    };
-    for (let i = 1; i < args.length; i++) {
-      const option = args[i];
-      if (option === "--dataset") {
-        datasetPath = args[++i];
-        if (!datasetPath) throw new Error("--dataset requires a path value");
-      } else if (option === "--min-auto-match-precision") {
-        minAutoMatchPrecision = readNumber(option, args[++i]);
-      } else if (option === "--min-retrieval-recall-at-k") {
-        minRetrievalRecallAtK = readNumber(option, args[++i]);
-      } else if (option === "--min-delivered-shortlist-recall-at-k") {
-        minDeliveredShortlistRecallAtK = readNumber(option, args[++i]);
-      } else if (option === "--min-auto-match-count") {
-        minAutoMatchCount = readNumber(option, args[++i]);
-        if (!Number.isInteger(minAutoMatchCount) || minAutoMatchCount < 1) {
-          throw new Error("--min-auto-match-count must be a positive integer");
-        }
-      } else if (option === "--concurrency") {
-        const raw = args[++i];
-        if (raw === undefined) throw new Error("--concurrency requires a value");
-        const val = Number(raw);
-        if (!Number.isInteger(val) || val < 1) {
-          throw new Error("--concurrency must be a positive integer");
-        }
-        concurrency = val;
-      } else if (option === "--resume") {
-        resumeRunId = args[++i];
-        if (!resumeRunId) throw new Error("--resume requires a run_id value");
-      } else if (option === "--timing") {
-        timing = true;
-      } else {
-        throw new Error(`unknown calibrate run option: ${option}`);
-      }
-    }
-    for (const [flag, value] of [
-      ["--min-auto-match-precision", minAutoMatchPrecision],
-      ["--min-retrieval-recall-at-k", minRetrievalRecallAtK],
-      ["--min-delivered-shortlist-recall-at-k", minDeliveredShortlistRecallAtK],
-    ] as const) {
-      if (value !== undefined && (value < 0 || value > 1)) {
-        throw new Error(`${flag} must be between 0 and 1`);
-      }
-    }
-    const res = await adapter.calibrateRun({
-      datasetPath,
-      minAutoMatchPrecision,
-      minRetrievalRecallAtK,
-      minDeliveredShortlistRecallAtK,
-      minAutoMatchCount,
-      concurrency,
-      resumeRunId,
-      timing,
-      onTimingSummary: timing
-        ? (summary) => {
-            // Write timing report to stderr only — stdout remains valid JSON under --json.
-            // Cumulative fields are total worker time across concurrent queries and may
-            // exceed wall_ms. They do not sum to wall time.
-            process.stderr.write(
-              [
-                "--- calibrate run timing ---",
-                `cases_total:                ${summary.cases_total}`,
-                `cases_executed:             ${summary.cases_executed}  (retrieved in this invocation)`,
-                `cases_reused:               ${summary.cases_reused}  (loaded from prior interrupted run)`,
-                `wall_ms:                    ${summary.wall_ms.toFixed(1)}`,
-                `vault_sync_ms:              ${summary.vault_sync_ms.toFixed(1)}`,
-                "cumulative worker time (concurrent totals; may exceed wall_ms):",
-                `  cumulative_embedding_ms:  ${summary.cumulative_embedding_ms.toFixed(1)}`,
-                `  cumulative_lexical_ms:    ${summary.cumulative_lexical_ms.toFixed(1)}`,
-                `  cumulative_vector_ms:     ${summary.cumulative_vector_ms.toFixed(1)}`,
-                `  cumulative_reranker_ms:   ${summary.cumulative_reranker_ms.toFixed(1)}`,
-                `  cumulative_checkpoint_ms: ${summary.cumulative_checkpoint_ms.toFixed(1)}`,
-                `policy_evaluation_ms:       ${summary.policy_evaluation_ms.toFixed(1)}`,
-                "",
-              ].join("\n"),
-            );
-          }
-        : undefined,
-    });
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderCalibrationTarget(ctx.target);
-      console.log(`Calibration run complete.`);
-      if (res.result) console.log(JSON.stringify(res.result, null, 2));
-    });
-    return;
-  }
-
-
-  if (sub === "list") {
-    const res = await adapter.calibrateList();
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderCalibrationTarget(ctx.target);
-      renderTable(
-        [
-          { key: "run_id", header: "RUN_ID" },
-          { key: "created_at", header: "CREATED_AT" },
-          { key: "status", header: "STATUS" },
-        ],
-        res,
-      );
-    });
-    return;
-  }
-
-  if (sub === "show") {
-    const runId = args[1];
-    if (!runId) throw new Error("usage: skillmux calibrate show <run_id>");
-    const res = await adapter.calibrateShow(runId);
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderCalibrationTarget(ctx.target);
-      console.log(JSON.stringify(res, null, 2));
-    });
-    return;
-  }
-
-  if (sub === "apply") {
-    const runId = args[1];
-    if (!runId) throw new Error("usage: skillmux calibrate apply <run_id>");
-    const res = await adapter.calibrateApply(runId);
-    emitSuccess({ isJson: ctx.isJson, target: ctx.target }, res, () => {
-      renderCalibrationTarget(ctx.target);
-      console.log(`Applied calibration run "${runId}"`);
-    });
-    return;
-  }
-
-  if (sub === "generate-dataset") {
-    await runCalibrateGenerateDataset(args.slice(1));
-    return;
-  }
-
-  throw new Error(
-    "usage: skillmux calibrate generate-dataset [--vault <path>] [--out <file>]",
-  );
-}
-
-function renderCalibrationTarget(target: ResolvedTarget): void {
-  if (target.type === "local") {
-    console.log("Target: local");
-  } else {
-    console.log(`Target: remote (${target.name} -> ${target.server})`);
-  }
-}
-
 async function handleCompletionsCommand(shell: string) {
   if (shell !== "bash" && shell !== "zsh" && shell !== "fish") {
     throw new Error("usage: skillmux completions <bash|zsh|fish>");
@@ -701,11 +533,6 @@ Setup:
   skillmux core <pin|unpin> <skill_id>... [--yes] [--dry-run] [--json]
   skillmux skill which <skill_id>
 
-Calibration:
-  skillmux calibrate run [--dataset <path>] [--concurrency <n>] [--resume <run_id>]
-                         [--timing] [--json]
-  skillmux calibrate <list|show|apply|generate-dataset>
-
 Init clients:
   claude-code, codex, gemini-cli, opencode, github-copilot, windsurf,
   antigravity, goose, hermes, skillmux-mcp
@@ -715,7 +542,7 @@ Init targets:
 
 Commands:
   serve, index, sync, init, project, target, core, report, scan, install, eval, doctor, skill,
-  local-vault, config, models, calibrate, context, completions`);
+  local-vault, config, models, context, completions`);
 }
 
 // ---------------------------------------------------------------------------
@@ -785,13 +612,17 @@ async function runEval(options: { isJson: boolean }): Promise<void> {
     throw new Error(`eval requires local embeddings: ${String(error)}`);
   });
   emitSuccess({ isJson: options.isJson }, report, () => {
-    console.log(`holdout queries: ${report.queries}`);
-    console.log(`lexical recall@3: ${report.lexical.recall_at_3.toFixed(3)}`);
-    console.log(`lexical recall@5: ${report.lexical.recall_at_5.toFixed(3)}`);
-    console.log(`lexical MRR:      ${report.lexical.mrr.toFixed(3)}`);
-    console.log(`hybrid recall@3:  ${report.hybrid.recall_at_3.toFixed(3)}`);
-    console.log(`hybrid recall@5:  ${report.hybrid.recall_at_5.toFixed(3)}`);
-    console.log(`hybrid MRR:       ${report.hybrid.mrr.toFixed(3)}`);
+    console.log(`holdout queries:   ${report.queries}`);
+    console.log(`judged queries:    ${report.judged_queries}`);
+    console.log(`unjudged queries:  ${report.unjudged_queries}`);
+    console.log(`lexical recall@5:  ${report.lexical.recall_at_5.toFixed(3)}`);
+    console.log(`lexical recall@10: ${report.lexical.recall_at_10.toFixed(3)}`);
+    console.log(`lexical MRR:       ${report.lexical.mrr.toFixed(3)}`);
+    console.log(`lexical nDCG@10:   ${report.lexical.ndcg_at_10.toFixed(3)}`);
+    console.log(`hybrid recall@5:   ${report.hybrid.recall_at_5.toFixed(3)}`);
+    console.log(`hybrid recall@10:  ${report.hybrid.recall_at_10.toFixed(3)}`);
+    console.log(`hybrid MRR:        ${report.hybrid.mrr.toFixed(3)}`);
+    console.log(`hybrid nDCG@10:    ${report.hybrid.ndcg_at_10.toFixed(3)}`);
   });
 }
 
@@ -1777,47 +1608,6 @@ async function runInstall(
   }
 }
 
-function parseCalibrateGenerateDatasetArgs(args: string[]): {
-  vault?: string;
-  out?: string;
-} {
-  let vault: string | undefined;
-  let out: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const option = args[i];
-    if (option === "--vault") {
-      const value = args[++i];
-      if (!value) throw new Error("--vault requires a path value");
-      vault = value;
-    } else if (option === "--out") {
-      const value = args[++i];
-      if (!value) throw new Error("--out requires a file path value");
-      out = value;
-    } else {
-      throw new Error(`unknown calibrate option: ${option}`);
-    }
-  }
-  return { vault, out };
-}
-
-async function runCalibrateGenerateDataset(args: string[]): Promise<void> {
-  const { vault: vaultArg, out: outArg } =
-    parseCalibrateGenerateDatasetArgs(args);
-  const config = await loadConfig();
-  const vaultPath = expandHome(vaultArg ?? config.vault_path);
-  const outPath = expandHome(outArg ?? join(config.state_dir, "queries.json"));
-
-  const skills = await scanVault(vaultPath);
-  const dataset = generateDataset(skills);
-
-  const parentDir = join(outPath, "..");
-  mkdirSync(parentDir, { recursive: true });
-  await Bun.write(outPath, JSON.stringify(dataset, null, 2) + "\n");
-  console.log(
-    `generated synthetic dataset with ${dataset.length} cases at ${outPath}`,
-  );
-}
-
 if (import.meta.main) {
   await main();
 }

package/src/completions.ts

@@ -3,7 +3,6 @@ export type ShellType = "bash" | "zsh" | "fish";
 const TOP_LEVEL_COMMANDS: { name: string; description: string }[] = [
   { name: "context", description: "Manage connection contexts" },
   { name: "config", description: "Manage configuration" },
-  { name: "calibrate", description: "Manage policy calibration" },
   { name: "serve", description: "Start MCP server" },
   { name: "index", description: "Rebuild local search index" },
   { name: "sync", description: "Synchronize vault skills" },
@@ -45,9 +44,6 @@ _skillmux_completions() {
         config)
             COMPREPLY=( $(compgen -W "init show get validate diff set status" -- "$cur") )
             ;;
-        calibrate)
-            COMPREPLY=( $(compgen -W "run list show apply generate-dataset" -- "$cur") )
-            ;;
         completions)
             COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") )
             ;;

package/src/config-service.ts

@@ -60,11 +60,8 @@ export const RELOADABLE_KEYS = [
   "recall.k_lexical",
   "recall.k_vector",
   "recall.k_rerank",
-  "output.ambiguous_candidate_limit",
-  "thresholds.candidate_limit",
-  "thresholds.match_score",
-  "thresholds.match_margin",
-  "thresholds.candidate_floor",
+  "output.top_k",
+  "output.max_top_k",
   "inference.embedding.endpoint",
   "inference.embedding.api_key_env",
   "inference.reranker.adapter",
@@ -123,7 +120,7 @@ export async function getEffectiveConfig(configPath?: string): Promise<{
   sources: ConfigSourceMap;
   rawToml: Record<string, unknown>;
 }> {
-  const path = configPath ?? DEFAULT_CONFIG_PATH;
+  const path = configPath ?? process.env.SKILLMUX_CONFIG ?? DEFAULT_CONFIG_PATH;
   const effective = await loadConfig(path);
   const rawToml: Record<string, unknown> = {};
 
@@ -150,11 +147,8 @@ export async function getEffectiveConfig(configPath?: string): Promise<{
     "recall.k_lexical",
     "recall.k_vector",
     "recall.k_rerank",
-    "output.ambiguous_candidate_limit",
-    "thresholds.candidate_limit",
-    "thresholds.match_score",
-    "thresholds.match_margin",
-    "thresholds.candidate_floor",
+    "output.top_k",
+    "output.max_top_k",
     "inference.mode",
     "inference.bundle",
     "inference.models_dir",
@@ -200,15 +194,8 @@ export function isEnvMasked(key: string, allowEnvOverrides: boolean = true): boo
   if (key === "recall.k_lexical" && (process.env.SKILLMUX_RECALL_K_LEXICAL || process.env.RECALL_K_LEXICAL)) return true;
   if (key === "recall.k_vector" && (process.env.SKILLMUX_RECALL_K_VECTOR || process.env.RECALL_K_VECTOR)) return true;
   if (key === "recall.k_rerank" && (process.env.SKILLMUX_RECALL_K_RERANK || process.env.RECALL_K_RERANK)) return true;
-  if (
-    (key === "output.ambiguous_candidate_limit" || key === "thresholds.candidate_limit") &&
-    (process.env.SKILLMUX_OUTPUT_AMBIGUOUS_CANDIDATE_LIMIT ||
-      process.env.AMBIGUOUS_CANDIDATE_LIMIT ||
-      process.env.SKILLMUX_CANDIDATE_LIMIT ||
-      process.env.CANDIDATE_LIMIT)
-  ) {
-    return true;
-  }
+  if (key === "output.top_k" && (process.env.SKILLMUX_OUTPUT_TOP_K || process.env.OUTPUT_TOP_K)) return true;
+  if (key === "output.max_top_k" && (process.env.SKILLMUX_OUTPUT_MAX_TOP_K || process.env.OUTPUT_MAX_TOP_K)) return true;
   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.SKILLMUX_EMBED_DEVICE || process.env.EMBED_DEVICE)) return true;
   if (key === "inference.embedding.dtype" && (process.env.SKILLMUX_EMBED_DTYPE || process.env.EMBED_DTYPE)) return true;
@@ -229,6 +216,12 @@ export function isEnvMasked(key: string, allowEnvOverrides: boolean = true): boo
 }
 
 export function validateDottedKey(key: string): void {
+  if (key === "output.ambiguous_candidate_limit") {
+    throw new Error("output.ambiguous_candidate_limit is obsolete in 2.0. Use output.top_k instead.");
+  }
+  if (key.startsWith("thresholds.") || key.startsWith("inference.thresholds.")) {
+    throw new Error("thresholds are obsolete in 2.0. Threshold calibration was removed; use output.top_k.");
+  }
   const allowed = new Set([
     "config.environment_overrides",
     "vault_path",
@@ -236,11 +229,8 @@ export function validateDottedKey(key: string): void {
     "recall.k_lexical",
     "recall.k_vector",
     "recall.k_rerank",
-    "output.ambiguous_candidate_limit",
-    "thresholds.candidate_limit",
-    "thresholds.match_score",
-    "thresholds.match_margin",
-    "thresholds.candidate_floor",
+    "output.top_k",
+    "output.max_top_k",
     "inference.mode",
     "inference.bundle",
     "inference.models_dir",
@@ -279,11 +269,8 @@ export function parseDottedValue(key: string, valueStr: string): unknown {
     "recall.k_lexical",
     "recall.k_vector",
     "recall.k_rerank",
-    "output.ambiguous_candidate_limit",
-    "thresholds.candidate_limit",
-    "thresholds.match_score",
-    "thresholds.match_margin",
-    "thresholds.candidate_floor",
+    "output.top_k",
+    "output.max_top_k",
     "inference.embedding.dimension",
     "inference.timeout_ms",
     "server.rate_limit.requests_per_minute",
@@ -328,7 +315,7 @@ export async function setDottedKey(
     throw new Error(`Cannot set environment-masked configuration key "${key}"`);
   }
 
-  const path = opts?.configPath ?? DEFAULT_CONFIG_PATH;
+  const path = opts?.configPath ?? process.env.SKILLMUX_CONFIG ?? DEFAULT_CONFIG_PATH;
   const targetName = opts?.targetName ?? "local";
 
   const { effective: priorEffective, rawToml } = await getEffectiveConfig(path);
@@ -445,7 +432,7 @@ export async function getLocalConfigStatus(configPath?: string): Promise<ConfigS
 
   return {
     target: "local",
-    desired_source: configPath ?? DEFAULT_CONFIG_PATH,
+    desired_source: configPath ?? process.env.SKILLMUX_CONFIG ?? DEFAULT_CONFIG_PATH,
     desired_source_hash: hash,
     active_revision: hash,
     active_source_hash: hash,

package/src/config-watcher.ts

@@ -12,15 +12,11 @@ import type { Config } from "./types";
 
 export const LIVE_RELOAD_KEYS = new Set([
   "config.environment_overrides",
-  "inference.thresholds.match_score",
-  "inference.thresholds.match_margin",
-  "inference.thresholds.candidate_floor",
-  "inference.calibration.run_id",
   "recall.k_lexical",
   "recall.k_vector",
   "recall.k_rerank",
-  "output.ambiguous_candidate_limit",
-  "thresholds.candidate_limit",
+  "output.top_k",
+  "output.max_top_k",
   "inference.embedding.endpoint",
   "inference.embedding.api_key_env",
   "inference.reranker.adapter",

package/src/config.ts

@@ -43,14 +43,11 @@ const configSchema = z.object({
     message: "recall.k_rerank cannot exceed k_lexical + k_vector",
   }),
   output: z.object({
-    ambiguous_candidate_limit: z.number().int().positive().default(5),
-  }).strict().optional(),
-  thresholds: z.object({
-    candidate_limit: z.number().int().positive().optional(),
-    match_score: z.number().optional(),
-    match_margin: z.number().nonnegative().optional(),
-    candidate_floor: z.number().optional(),
-  }).strict().optional(),
+    top_k: z.number().int().positive().default(10),
+    max_top_k: z.number().int().positive().default(50),
+  }).strict().refine((o) => o.top_k <= o.max_top_k, {
+    message: "output.top_k cannot exceed output.max_top_k",
+  }).default({ top_k: 10, max_top_k: 50 }),
   inference: z.discriminatedUnion("mode", [
     z.object({
       mode: z.literal("local"),
@@ -74,8 +71,6 @@ const configSchema = z.object({
         model: z.string().min(1),
         api_key_env: z.string().min(1).optional(),
       }).strict().optional(),
-      thresholds: remoteThresholdsSchema.optional(),
-      calibration: z.object({ run_id: z.string().min(1) }).strict().optional(),
     }).strict(),
   ]),
   server: z.object({
@@ -93,7 +88,15 @@ const configSchema = z.object({
       token_env: z.string().min(1),
     }).strict().optional(),
   }).strict().optional(),
-}).strict();
+}).strict().refine((cfg) => {
+  const hasReranker = cfg.inference.mode === "remote" && !!cfg.inference.reranker;
+  if (hasReranker && cfg.output.max_top_k > cfg.recall.k_rerank) {
+    return false;
+  }
+  return true;
+}, {
+  message: "output.max_top_k cannot exceed recall.k_rerank when reranking is enabled",
+});
 
 // Fallback values only; a config.toml (SKILLMUX_CONFIG or default path)
 // overrides them. The local bundle is the zero-config OSS path.
@@ -107,8 +110,7 @@ const DEFAULTS: Config = {
   local_vault_paths: [],
   state_dir: "~/.local/state/skillmux",
   recall: { k_lexical: 20, k_vector: 20, k_rerank: 10 },
-  thresholds: { candidate_limit: 5 },
-  output: { ambiguous_candidate_limit: 5 },
+  output: { top_k: 10, max_top_k: 50 },
   inference: {
     mode: "local",
     bundle: LOCAL_BUNDLE_ID,
@@ -232,6 +234,18 @@ export async function loadConfig(path?: string): Promise<Config> {
         "The old client appended /v1/embeddings.",
     );
   }
+  const removedLegacyOutputEnv = [
+    "SKILLMUX_OUTPUT_AMBIGUOUS_CANDIDATE_LIMIT",
+    "AMBIGUOUS_CANDIDATE_LIMIT",
+    "SKILLMUX_CANDIDATE_LIMIT",
+    "CANDIDATE_LIMIT",
+  ].find((name) => process.env[name] !== undefined);
+  if (removedLegacyOutputEnv) {
+    throw new Error(
+      `${removedLegacyOutputEnv} is no longer supported. Use SKILLMUX_OUTPUT_TOP_K instead.`,
+    );
+  }
+
   const configPath = resolveConfigPath(path);
   const file = Bun.file(expandHome(configPath));
 
@@ -248,6 +262,26 @@ export async function loadConfig(path?: string): Promise<Config> {
     merged = baseConfig;
   } else {
     const parsed = Bun.TOML.parse(await file.text()) as Record<string, unknown>;
+    if ("thresholds" in parsed) {
+      throw new Error(
+        "The [thresholds] table is obsolete in 2.0. Threshold calibration was removed; use [output] with top_k.",
+      );
+    }
+    if (isPlainObject(parsed.output) && "ambiguous_candidate_limit" in parsed.output) {
+      throw new Error(
+        "output.ambiguous_candidate_limit is obsolete in 2.0. Use output.top_k instead.",
+      );
+    }
+    if (isPlainObject(parsed.inference) && "thresholds" in parsed.inference) {
+      throw new Error(
+        "inference.thresholds is obsolete in 2.0. Threshold calibration was removed.",
+      );
+    }
+    if (isPlainObject(parsed.inference) && "calibration" in parsed.inference) {
+      throw new Error(
+        "inference.calibration is obsolete in 2.0 and should be deleted. Threshold calibration was removed; use skillmux eval for ranking evaluation.",
+      );
+    }
     if ("embedding" in parsed || "rerank" in parsed || "remote_timeout_ms" in parsed) {
       throw new Error(
         "Legacy inference config is not supported. Move [embedding], [rerank], and remote_timeout_ms under [inference] using config.remote.example.toml.",
@@ -279,30 +313,9 @@ export async function loadConfig(path?: string): Promise<Config> {
         throw new Error("Remote inference requires an inference.embedding section.");
       }
     }
-    if (parsed.thresholds && typeof parsed.thresholds === "object" && (parsed.thresholds as Record<string, unknown>).candidate_limit !== undefined) {
-      console.error("skillmux: thresholds.candidate_limit is deprecated, use output.ambiguous_candidate_limit instead");
-      if (!parsed.output || (parsed.output as Record<string, unknown>).ambiguous_candidate_limit === undefined) {
-        parsed.output = {
-          ...(typeof parsed.output === "object" && parsed.output !== null ? parsed.output : {}),
-          ambiguous_candidate_limit: (parsed.thresholds as Record<string, unknown>).candidate_limit,
-        };
-      }
-    }
 
     if (parsed.inference && typeof parsed.inference === "object" && "mode" in parsed.inference) {
       if (parsed.inference.mode === "remote") {
-        if ("thresholds" in parsed.inference) {
-          const rawRemoteThresholds = (parsed.inference as Record<string, unknown>).thresholds;
-          if (
-            typeof rawRemoteThresholds === "object" &&
-            rawRemoteThresholds !== null &&
-            !("match_score" in rawRemoteThresholds) &&
-            !("match_margin" in rawRemoteThresholds) &&
-            !("candidate_floor" in rawRemoteThresholds)
-          ) {
-            throw new Error("Invalid inference.thresholds in config.toml: must specify at least one threshold.");
-          }
-        }
         const withoutInference = { ...parsed };
         delete withoutInference.inference;
         merged = {
@@ -318,12 +331,7 @@ export async function loadConfig(path?: string): Promise<Config> {
   }
 
   if (!merged.output) {
-    merged.output = { ambiguous_candidate_limit: merged.thresholds?.candidate_limit ?? 5 };
-  }
-  if (!merged.thresholds) {
-    merged.thresholds = { candidate_limit: merged.output.ambiguous_candidate_limit };
-  } else if (merged.thresholds.candidate_limit === undefined) {
-    merged.thresholds.candidate_limit = merged.output.ambiguous_candidate_limit;
+    merged.output = { top_k: 10, max_top_k: 50 };
   }
 
   // Warn about deprecated generic environment variables regardless of override policy
@@ -333,8 +341,8 @@ export async function loadConfig(path?: string): Promise<Config> {
     RECALL_K_LEXICAL: "SKILLMUX_RECALL_K_LEXICAL",
     RECALL_K_VECTOR: "SKILLMUX_RECALL_K_VECTOR",
     RECALL_K_RERANK: "SKILLMUX_RECALL_K_RERANK",
-    AMBIGUOUS_CANDIDATE_LIMIT: "SKILLMUX_OUTPUT_AMBIGUOUS_CANDIDATE_LIMIT",
-    CANDIDATE_LIMIT: "SKILLMUX_OUTPUT_AMBIGUOUS_CANDIDATE_LIMIT",
+    OUTPUT_TOP_K: "SKILLMUX_OUTPUT_TOP_K",
+    OUTPUT_MAX_TOP_K: "SKILLMUX_OUTPUT_MAX_TOP_K",
     EMBED_MODEL: "SKILLMUX_EMBED_MODEL",
     EMBED_ENDPOINT: "SKILLMUX_EMBED_ENDPOINT",
     EMBED_DIMENSION: "SKILLMUX_EMBED_DIMENSION",
@@ -398,14 +406,17 @@ export async function loadConfig(path?: string): Promise<Config> {
       if (!Number.isInteger(k) || k < 1) throw new Error(`Invalid recall.k_rerank: ${kRerankStr}`);
       merged.recall.k_rerank = k;
     }
-    const ambiguousLimitStr =
-      getEnv("SKILLMUX_OUTPUT_AMBIGUOUS_CANDIDATE_LIMIT", "AMBIGUOUS_CANDIDATE_LIMIT") ??
-      getEnv("SKILLMUX_CANDIDATE_LIMIT", "CANDIDATE_LIMIT");
-    if (ambiguousLimitStr) {
-      const lim = Number(ambiguousLimitStr);
-      if (!Number.isInteger(lim) || lim < 1) throw new Error(`Invalid output.ambiguous_candidate_limit: ${ambiguousLimitStr}`);
-      merged.output.ambiguous_candidate_limit = lim;
-      merged.thresholds.candidate_limit = lim;
+    const topKStr = getEnv("SKILLMUX_OUTPUT_TOP_K", "OUTPUT_TOP_K");
+    if (topKStr) {
+      const k = Number(topKStr);
+      if (!Number.isInteger(k) || k < 1) throw new Error(`Invalid output.top_k: ${topKStr}`);
+      merged.output.top_k = k;
+    }
+    const maxTopKStr = getEnv("SKILLMUX_OUTPUT_MAX_TOP_K", "OUTPUT_MAX_TOP_K");
+    if (maxTopKStr) {
+      const k = Number(maxTopKStr);
+      if (!Number.isInteger(k) || k < 1) throw new Error(`Invalid output.max_top_k: ${maxTopKStr}`);
+      merged.output.max_top_k = k;
     }
   }
 
@@ -441,16 +452,6 @@ export async function loadConfig(path?: string): Promise<Config> {
     if (merged.inference.reranker && (!merged.inference.reranker.endpoint || !merged.inference.reranker.model)) {
       throw new Error("Configured inference.reranker requires adapter, endpoint, and model.");
     }
-    if (merged.inference.reranker && !merged.inference.thresholds) {
-      const warningKey = "inference.reranker.without-thresholds";
-      if (!warnedEnv.has(warningKey)) {
-        warnedEnv.add(warningKey);
-        console.error(
-          "skillmux: configured reranker has no calibrated inference.thresholds; " +
-            "routing will remain ambiguous until you run `skillmux calibrate run`.",
-        );
-      }
-    }
     const embedEndpoint = getEnv("SKILLMUX_EMBED_ENDPOINT", "EMBED_ENDPOINT");
     const embedModel = getEnv("SKILLMUX_EMBED_MODEL", "EMBED_MODEL");
     const embedDimStr = getEnv("SKILLMUX_EMBED_DIMENSION", "EMBED_DIMENSION");