@przeprogramowani/10x-cli 1.10.0 → 1.12.0

package/README.md

@@ -49,6 +49,7 @@ Once installed, just tell your agent to **set up 10x-cli** and it will pick up t
 10x get m1l1    # Fetch and apply lesson artifacts
 10x sync        # Update everything you've downloaded; show what changed
 10x doctor      # Check everything is working
+10x bench       # Show the 10xBench top-10 model leaderboard
 ```
 
 ## Commands
@@ -60,6 +61,7 @@ Once installed, just tell your agent to **set up 10x-cli** and it will pick up t
 | `10x get <ref>` | Fetch a lesson and apply artifacts to your workspace |
 | `10x sync` | Bulk-download / refresh lessons and report what changed upstream |
 | `10x doctor` | Diagnose auth, API connectivity, and local config |
+| `10x bench` | Live top-10 AI model leaderboard from [10xbench.ai](https://10xbench.ai) — no login needed |
 
 ### `10x get` Flags
 
@@ -163,6 +165,21 @@ all. **Change visibility covers skills and prompts** — configs are create-only
 conflict is reported, not a failure), `1` if any lesson failed to fetch. The full
 report is still emitted on a partial failure.
 
+### `10x bench`
+
+Shows the [10xBench](https://10xbench.ai) leaderboard — the top 10 AI models
+benchmarked on vibe-coding the Przeprogramowani.pl website — rendered as
+color-coded score bars in your terminal. Public data, works without logging in.
+
+```bash
+10x bench             # Top 10 models with scores, runs, and cost per run
+10x bench --limit 5   # Just the top 5
+10x bench --json      # Machine-readable (also auto-selected when piped)
+```
+
+The data refreshes whenever new benchmark results are published on 10xbench.ai.
+Colors honor `NO_COLOR` and are disabled automatically when output is piped.
+
 ### Global Flags
 
 - `--json` — Machine-readable JSON output (auto-detected when piped)

package/dist/index.mjs

@@ -2271,7 +2271,7 @@ var cac = (name = "") => new CAC(name);
 // package.json
 var package_default = {
   name: "@przeprogramowani/10x-cli",
-  version: "1.10.0",
+  version: "1.12.0",
   description: "Open-source CLI for 10xDevs course content",
   repository: {
     type: "git",
@@ -3262,6 +3262,10 @@ function verbose(ctx, message) {
   process.stderr.write(`[verbose] ${message}
 `);
 }
+function exitNotImplemented(command, phase, flags = {}) {
+  const ctx = resolveContext(flags);
+  outputError(ctx, "not_implemented", `'10x ${command}' lands in ${phase}.`, ExitCodes.ERROR, "See thoughts/shared/plans/2026-04-07-10x-cli-design.md for the full roadmap.");
+}
 
 // src/lib/auth-guard.ts
 var DEFAULT_REFRESH_WINDOW_MS = 5 * 60 * 1000;
@@ -3521,9 +3525,451 @@ function handleLoginError(ctx, status, code, error) {
   outputError(ctx, code || "auth_error", "Authentication failed.", ExitCodes.ERROR, error ? `Server said: ${error}` : undefined);
 }
 
+// src/lib/bench-client.ts
+var DEFAULT_BENCH_BASE = "https://10xbench.ai";
+var PROD_HOSTNAME2 = "10xbench.ai";
+var DEV_HOSTNAMES2 = new Set(["localhost", "127.0.0.1"]);
+function resolveBenchBase() {
+  const override = process.env["BENCH_BASE_URL"];
+  if (!override)
+    return DEFAULT_BENCH_BASE;
+  let url;
+  try {
+    url = new URL(override);
+  } catch {
+    throw new Error(`BENCH_BASE_URL is not a valid URL: ${JSON.stringify(override)}`);
+  }
+  if (url.pathname !== "/" && url.pathname !== "") {
+    throw new Error(`BENCH_BASE_URL must not include a path (got ${JSON.stringify(url.pathname)})`);
+  }
+  if (url.search !== "" || url.hash !== "") {
+    throw new Error("BENCH_BASE_URL must not include a query string or fragment");
+  }
+  if (url.protocol === "https:" && url.hostname === PROD_HOSTNAME2) {
+    return `${url.protocol}//${url.host}`;
+  }
+  if (url.protocol === "http:" && DEV_HOSTNAMES2.has(url.hostname)) {
+    return `${url.protocol}//${url.host}`;
+  }
+  throw new Error(`BENCH_BASE_URL must be ${DEFAULT_BENCH_BASE} or http://localhost[:port] (got ${JSON.stringify(override)})`);
+}
+var SUPPORTED_LEADERBOARD_SCHEMA = 1;
+var LEADERBOARD_PATH = "/api/leaderboard.json";
+var DEFAULT_TIMEOUT_MS3 = 30000;
+function isLeaderboardResponse(value) {
+  if (value === null || typeof value !== "object")
+    return false;
+  const v2 = value;
+  return typeof v2.schemaVersion === "number" && typeof v2.generatedAt === "string" && typeof v2.totalModels === "number" && Array.isArray(v2.leaderboard);
+}
+async function fetchLeaderboard(options = {}) {
+  const url = `${resolveBenchBase()}${LEADERBOARD_PATH}`;
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: {
+        accept: "application/json",
+        "user-agent": "10x-cli"
+      },
+      signal: options.signal ?? AbortSignal.timeout(DEFAULT_TIMEOUT_MS3)
+    });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, status: 0, code: "network_error", error: message };
+  }
+  const text = await response.text();
+  if (!response.ok) {
+    return {
+      ok: false,
+      status: response.status,
+      code: `http_${response.status}`,
+      error: response.statusText || "Leaderboard request failed."
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return {
+      ok: false,
+      status: response.status,
+      code: "bench_unavailable",
+      error: "The leaderboard endpoint returned a non-JSON response."
+    };
+  }
+  if (!isLeaderboardResponse(parsed)) {
+    return {
+      ok: false,
+      status: response.status,
+      code: "bench_unavailable",
+      error: "The leaderboard endpoint returned an unexpected shape."
+    };
+  }
+  return {
+    ok: true,
+    status: response.status,
+    data: parsed,
+    responseHeaders: response.headers,
+    rawBody: text
+  };
+}
+
+// src/lib/format.ts
+function formatReleaseAt(iso, now = new Date) {
+  const date = new Date(iso);
+  if (!Number.isFinite(date.getTime()))
+    return iso;
+  const absolute = date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
+    timeZone: "UTC"
+  });
+  const msPerDay = 24 * 60 * 60 * 1000;
+  const startOfTarget = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
+  const startOfNow = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+  const days = Math.round((startOfTarget - startOfNow) / msPerDay);
+  if (days <= 0)
+    return absolute;
+  if (days === 1)
+    return `${absolute} (tomorrow)`;
+  return `${absolute} (in ${days} days)`;
+}
+
+// src/commands/bench.ts
+function registerBenchCommand(cli) {
+  cli.command("bench", "Show the 10xBench top-10 model leaderboard (10xbench.ai)").option("--limit <n>", "Show only the top N models").action(async (options) => {
+    const ctx = resolveContext(options);
+    await runBench(ctx, options);
+  });
+}
+async function runBench(ctx, options) {
+  const limit = parseLimit(ctx, options.limit);
+  verbose(ctx, `fetching leaderboard from ${resolveBenchBase()}`);
+  const result = await fetchLeaderboard();
+  if (!result.ok) {
+    handleBenchError(ctx, result.status, result.code, result.error);
+  }
+  const data = result.data;
+  if (data.schemaVersion !== SUPPORTED_LEADERBOARD_SCHEMA) {
+    outputError(ctx, "unsupported_schema", `The leaderboard now uses format version ${data.schemaVersion}, but this CLI only understands version ${SUPPORTED_LEADERBOARD_SCHEMA}.`, ExitCodes.ERROR, "Run 'npm install -g @przeprogramowani/10x-cli@latest' to update, or visit https://10xbench.ai.");
+  }
+  renderLeaderboard(ctx, data, limit);
+}
+function parseLimit(ctx, raw) {
+  if (raw === undefined)
+    return null;
+  const n = typeof raw === "number" ? raw : Number.parseInt(raw, 10);
+  if (!Number.isInteger(n) || n < 1) {
+    outputError(ctx, "invalid_limit", `'${raw}' is not a valid limit.`, ExitCodes.USAGE, "Pass a positive whole number, for example '10x bench --limit 5'.");
+  }
+  return n;
+}
+function handleBenchError(ctx, status, code, error) {
+  if (status === 0) {
+    outputError(ctx, "network_error", "Could not reach 10xbench.ai.", ExitCodes.ERROR, "Check your internet connection and run '10x bench' again.");
+  }
+  if (code === "bench_unavailable") {
+    outputError(ctx, "bench_unavailable", "The 10xBench leaderboard is temporarily unavailable.", ExitCodes.ERROR, "Try again in a few minutes, or visit https://10xbench.ai directly.");
+  }
+  outputError(ctx, code || "bench_failed", "Failed to load the leaderboard.", ExitCodes.ERROR, error ? `Server said: ${error}` : undefined);
+}
+function colorsEnabled() {
+  return process.env["NO_COLOR"] === undefined && process.stderr.isTTY === true;
+}
+var STYLE = {
+  bold: "1",
+  dim: "2",
+  red: "31",
+  green: "32",
+  yellow: "33",
+  cyan: "36"
+};
+function paint(style, text) {
+  if (!colorsEnabled())
+    return text;
+  return `\x1B[${style}m${text}\x1B[0m`;
+}
+function scoreStyle(percentage) {
+  if (percentage >= 90)
+    return STYLE.green;
+  if (percentage >= 60)
+    return STYLE.yellow;
+  return STYLE.red;
+}
+var BAR_WIDTH = 20;
+function scoreBar(percentage) {
+  const clamped = Math.min(Math.max(percentage, 0), 100);
+  const filled = Math.round(clamped / 100 * BAR_WIDTH);
+  return "█".repeat(filled) + "░".repeat(BAR_WIDTH - filled);
+}
+function renderLeaderboard(ctx, data, limit) {
+  const ranked = limit === null ? data.leaderboard : data.leaderboard.slice(0, limit);
+  if (ctx.json) {
+    output(ctx, "", {
+      source: resolveBenchBase(),
+      generatedAt: data.generatedAt,
+      totalAttempts: data.totalAttempts,
+      totalModels: data.totalModels,
+      models: ranked.map((e2, i) => ({
+        rank: i + 1,
+        model: e2.modelName,
+        modelBaseId: e2.modelBaseId,
+        score: e2.averageScore,
+        maxScore: e2.averageMaxScore,
+        percentage: e2.averagePercentage,
+        attempts: e2.attemptCount,
+        environment: e2.agentEnvironment,
+        averageCost: e2.averageCost
+      }))
+    });
+    return;
+  }
+  if (ranked.length === 0) {
+    output(ctx, "The leaderboard has no results yet.", undefined);
+    return;
+  }
+  const names = ranked.map((e2) => sanitize(e2.modelName));
+  const details = ranked.map((e2) => formatDetail(e2));
+  const nameWidth = Math.max(...names.map((n) => n.length));
+  const detailWidth = Math.max(...details.map((d2) => d2.length));
+  const rankWidth = String(ranked.length).length;
+  const lines = [];
+  lines.push(paint(STYLE.bold, `10xBench — Top ${ranked.length} of ${data.totalModels} models`) + paint(STYLE.dim, `  (${data.totalAttempts} attempts scored)`));
+  lines.push("");
+  for (let i = 0;i < ranked.length; i++) {
+    lines.push(formatRow(ranked[i], i + 1, names[i], details[i], rankWidth, nameWidth, detailWidth));
+  }
+  lines.push("");
+  lines.push(paint(STYLE.dim, `Data as of ${formatReleaseAt(data.generatedAt)} — ${resolveBenchBase()}`));
+  output(ctx, lines.join(`
+`), undefined);
+}
+function formatDetail(entry) {
+  const score = `${entry.averageScore.toFixed(1)}/${entry.averageMaxScore.toFixed(0)}`;
+  const runs = `${entry.attemptCount} run${entry.attemptCount === 1 ? "" : "s"}`;
+  const cost = entry.averageCost === null || entry.averageCost === undefined ? "" : `, ~$${entry.averageCost.toFixed(2)}/run`;
+  return `(${score}, ${runs}${cost})`;
+}
+function formatRow(entry, rank, name, detail, rankWidth, nameWidth, detailWidth) {
+  const style = scoreStyle(entry.averagePercentage);
+  const rankCell = String(rank).padStart(rankWidth);
+  const nameCell = name.padEnd(nameWidth);
+  const pctCell = `${entry.averagePercentage.toFixed(1)}%`.padStart(6);
+  return [
+    `  ${paint(rank <= 3 ? STYLE.bold : STYLE.dim, rankCell)}`,
+    rank <= 3 ? paint(STYLE.bold, nameCell) : nameCell,
+    paint(style, scoreBar(entry.averagePercentage)),
+    paint(style, pctCell),
+    detail.padEnd(detailWidth),
+    paint(STYLE.dim, sanitize(entry.agentEnvironment))
+  ].join("  ");
+}
+
+// src/commands/bench-kit.ts
+import { spawn } from "node:child_process";
+import {
+  cpSync,
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync3,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  readdirSync,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join as join2, resolve } from "node:path";
+
+// src/lib/experimental.ts
+var EXPERIMENTAL_ENV = "TENX_CLI_EXPERIMENTAL";
+function experimentalEnabled(env = process.env) {
+  const value = env[EXPERIMENTAL_ENV];
+  return value === "1" || value === "true";
+}
+function requireExperimental(command, flags, env = process.env) {
+  if (experimentalEnabled(env))
+    return;
+  const ctx = resolveContext(flags);
+  outputError(ctx, "experimental_locked", `'10x ${command}' is experimental and currently locked.`, ExitCodes.FORBIDDEN, `Set ${EXPERIMENTAL_ENV}=1 and run '10x ${command}' again.`);
+}
+
+// src/commands/bench-kit.ts
+var TEMPLATE_REPO_URL = "https://github.com/przeprogramowani/10x-bench-kit";
+function registerBenchKitCommand(cli) {
+  if (!experimentalEnabled())
+    return;
+  cli.command("bench-kit <action> [dir]", "Manage a benchmark instance (actions: init, update; experimental)").option("--template-version <tag>", "Template tag to install (default: latest)").option("--yes", "Run non-interactively, accepting defaults").example("10x bench-kit init my-benchmark").example("10x bench-kit init my-benchmark --template-version v0.1.0").action(async (action, dir, options) => {
+    requireExperimental(`bench-kit ${action}`, options);
+    const ctx = resolveContext(options);
+    if (action === "init") {
+      await runBenchKitInit(ctx, dir, options);
+      return;
+    }
+    if (action === "update") {
+      exitNotImplemented("bench-kit update", "a later bench-kit phase", options);
+    }
+    outputError(ctx, "unknown_action", `'${action}' is not a bench-kit action.`, ExitCodes.USAGE, "Run '10x bench-kit init [dir]' or '10x bench-kit update'.");
+  });
+}
+async function runBenchKitInit(ctx, dirArg, options, deps = defaultDeps) {
+  const targetDir = resolve(dirArg ?? ".");
+  const requestedRef = normalizeRef(ctx, options.templateVersion);
+  await preflight(ctx, deps);
+  const existingVersion = readInstanceVersion(targetDir);
+  const repair = existingVersion !== null;
+  if (repair && requestedRef !== null) {
+    outputError(ctx, "version_conflict", `This directory already holds a benchmark instance on template version ${existingVersion}.`, ExitCodes.USAGE, "Run '10x bench-kit update' to change the template version of an existing instance.");
+  }
+  if (!repair && existsSync2(targetDir) && readdirSync(targetDir).length > 0) {
+    outputError(ctx, "target_not_empty", `Directory '${targetDir}' is not empty and is not a benchmark instance.`, ExitCodes.ERROR, "Run '10x bench-kit init <dir>' with an empty or new directory.");
+  }
+  const scratch = mkdtempSync(join2(tmpdir(), "bench-kit-"));
+  try {
+    verbose(ctx, `cloning ${TEMPLATE_REPO_URL} (${requestedRef ?? "latest"}) into ${scratch}`);
+    const clone = await deps.cloneTemplate(requestedRef, scratch);
+    if (!clone.ok) {
+      outputError(ctx, "clone_failed", `Could not download the template from ${TEMPLATE_REPO_URL}.`, ExitCodes.ERROR, clone.error ? `Git said: ${clone.error.trim()}` : "Check your internet connection and run '10x bench-kit init' again.");
+    }
+    const templateVersion = readTemplateVersion(ctx, scratch);
+    mkdirSync3(targetDir, { recursive: true });
+    const copied = materialize(scratch, targetDir, { skipExisting: repair });
+    const manifest = {
+      templateVersion,
+      templateRef: requestedRef ?? "latest",
+      templateSource: TEMPLATE_REPO_URL,
+      initializedAt: deps.now().toISOString()
+    };
+    writeFileSync2(join2(targetDir, ".bench-kit", "instance.json"), `${JSON.stringify(manifest, null, 2)}
+`);
+    let committed = false;
+    if (!repair) {
+      committed = await freshGitInit(ctx, deps, targetDir, templateVersion);
+    }
+    const humanLines = repair ? [
+      `Repaired the benchmark instance in '${targetDir}' (template ${templateVersion}).`,
+      `Restored ${copied} missing file${copied === 1 ? "" : "s"}; your tasks, evaluation pool and config were not touched.`
+    ] : [
+      `Created a benchmark instance in '${targetDir}' from template ${templateVersion}.`,
+      committed ? "Initialized a fresh git repository with an initial commit." : "Initialized a fresh git repository (initial commit skipped — commit the files yourself).",
+      "Next: wire up secrets, then run 'bench validate' before the first run."
+    ];
+    output(ctx, humanLines.join(`
+`), {
+      dir: targetDir,
+      mode: repair ? "repair" : "init",
+      templateVersion,
+      templateRef: manifest.templateRef,
+      filesCopied: copied,
+      gitInitialized: !repair,
+      committed
+    });
+  } finally {
+    rmSync2(scratch, { recursive: true, force: true });
+  }
+}
+function normalizeRef(ctx, raw) {
+  if (raw === undefined)
+    return null;
+  const ref = raw.trim();
+  if (ref === "" || ref === "latest")
+    return null;
+  if (!/^[A-Za-z0-9._/-]+$/.test(ref)) {
+    outputError(ctx, "invalid_template_version", `'${raw}' is not a valid template tag.`, ExitCodes.USAGE, "Pass a tag name, for example '10x bench-kit init --template-version v0.1.0'.");
+  }
+  return ref;
+}
+async function preflight(ctx, deps) {
+  if (!await deps.toolAvailable("git")) {
+    outputError(ctx, "preflight_failed", "Git is required to download the template and initialize the instance.", ExitCodes.ERROR, "Install git (https://git-scm.com) and run '10x bench-kit init' again.");
+  }
+  const hasEngine = await deps.toolAvailable("docker") || await deps.toolAvailable("podman");
+  if (!hasEngine) {
+    verbose(ctx, "neither docker nor podman found — benchmark runs will need one later");
+  }
+}
+function readInstanceVersion(dir) {
+  const versionFile = join2(dir, ".bench-kit", "VERSION");
+  if (!existsSync2(versionFile))
+    return null;
+  return readFileSync2(versionFile, "utf8").trim();
+}
+function readTemplateVersion(ctx, cloneDir) {
+  const versionFile = join2(cloneDir, ".bench-kit", "VERSION");
+  if (!existsSync2(versionFile)) {
+    outputError(ctx, "invalid_template", "The downloaded template has no .bench-kit/VERSION file.", ExitCodes.ERROR, "Pass a valid tag via '10x bench-kit init --template-version <tag>'.");
+  }
+  return readFileSync2(versionFile, "utf8").trim();
+}
+function materialize(srcDir, destDir, opts) {
+  let copied = 0;
+  const walk = (rel) => {
+    for (const entry of readdirSync(join2(srcDir, rel), { withFileTypes: true })) {
+      if (rel === "" && entry.name === ".git")
+        continue;
+      const relPath = join2(rel, entry.name);
+      const from = join2(srcDir, relPath);
+      const to = join2(destDir, relPath);
+      if (entry.isDirectory()) {
+        mkdirSync3(to, { recursive: true });
+        walk(relPath);
+        continue;
+      }
+      if (opts.skipExisting && existsSync2(to))
+        continue;
+      cpSync(from, to);
+      copied++;
+    }
+  };
+  walk("");
+  return copied;
+}
+async function freshGitInit(ctx, deps, dir, templateVersion) {
+  const init = await deps.runGit(["init"], dir);
+  if (!init.ok) {
+    outputError(ctx, "git_init_failed", "Could not initialize a git repository in the instance directory.", ExitCodes.ERROR, init.error ? `Git said: ${init.error.trim()}` : undefined);
+  }
+  const add = await deps.runGit(["add", "-A"], dir);
+  const commit = add.ok ? await deps.runGit(["commit", "-m", `chore: bench-kit init (template ${templateVersion})`], dir) : add;
+  if (!commit.ok) {
+    verbose(ctx, `initial commit failed (${commit.error.trim()}) — files are staged, commit manually`);
+    return false;
+  }
+  return true;
+}
+function run(cmd, args, cwd) {
+  return new Promise((resolvePromise) => {
+    const child = spawn(cmd, args, { cwd, stdio: ["ignore", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", (err) => resolvePromise({ ok: false, error: err.message }));
+    child.on("close", (code) => resolvePromise({ ok: code === 0, error: stderr }));
+  });
+}
+var defaultDeps = {
+  async toolAvailable(cmd) {
+    const result = await run(cmd, ["--version"]);
+    return result.ok;
+  },
+  cloneTemplate(ref, destDir) {
+    const args = ["clone", "--depth", "1"];
+    if (ref !== null)
+      args.push("--branch", ref);
+    args.push(TEMPLATE_REPO_URL, destDir);
+    return run("git", args);
+  },
+  runGit(args, cwd) {
+    return run("git", args, cwd);
+  },
+  now: () => new Date
+};
+
 // src/commands/doctor.ts
-import { existsSync as existsSync2, accessSync, constants } from "node:fs";
-import { join as join2 } from "node:path";
+import { existsSync as existsSync3, accessSync, constants } from "node:fs";
+import { join as join3 } from "node:path";
 
 // src/lib/signing.ts
 import { createHash, createPublicKey, verify } from "node:crypto";
@@ -3732,28 +4178,6 @@ function apiBaseUrl() {
   return resolveApiBase();
 }
 
-// src/lib/format.ts
-function formatReleaseAt(iso, now = new Date) {
-  const date = new Date(iso);
-  if (!Number.isFinite(date.getTime()))
-    return iso;
-  const absolute = date.toLocaleDateString("en-US", {
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-    timeZone: "UTC"
-  });
-  const msPerDay = 24 * 60 * 60 * 1000;
-  const startOfTarget = Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate());
-  const startOfNow = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
-  const days = Math.round((startOfTarget - startOfNow) / msPerDay);
-  if (days <= 0)
-    return absolute;
-  if (days === 1)
-    return `${absolute} (tomorrow)`;
-  return `${absolute} (in ${days} days)`;
-}
-
 // src/lib/tool-profile.ts
 var SENTINEL_BEGIN = "<!-- BEGIN @przeprogramowani/10x-cli -->";
 var SENTINEL_END = "<!-- END @przeprogramowani/10x-cli -->";
@@ -4041,7 +4465,7 @@ async function checkApiConnectivity() {
 }
 function checkConfigDirectory() {
   const dir = configDir();
-  if (!existsSync2(dir)) {
+  if (!existsSync3(dir)) {
     return {
       name: "config",
       label: "Config",
@@ -4106,8 +4530,8 @@ function checkToolDirectory() {
   const toolId = readToolConfig()?.tool ?? DEFAULT_TOOL;
   const profile = PROFILES[toolId] ?? PROFILES[DEFAULT_TOOL];
   const dirName = profile.manifestDir;
-  const toolDir = join2(cwd, dirName);
-  if (!existsSync2(toolDir)) {
+  const toolDir = join3(cwd, dirName);
+  if (!existsSync3(toolDir)) {
     return {
       name: "tool-dir",
       label: profile.displayName,
@@ -4139,7 +4563,7 @@ function checkToolDirectory() {
 }
 
 // src/commands/get.ts
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 
 // src/lib/conflict-prompt.ts
 function createConflictResolver(tty) {
@@ -4224,8 +4648,8 @@ function parseModuleRef(raw) {
 
 // src/lib/manifest.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, renameSync as renameSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "node:fs";
-import { dirname as dirname2, join as join3 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync3, renameSync as renameSync2, rmSync as rmSync3, writeFileSync as writeFileSync3 } from "node:fs";
+import { dirname as dirname2, join as join4 } from "node:path";
 var MANIFEST_FILENAME = ".10x-cli-manifest.json";
 var CLI_PACKAGE_NAME = "@przeprogramowani/10x-cli";
 var MANIFEST_VERSION = 3;
@@ -4233,12 +4657,12 @@ function contentHash(content) {
   return createHash2("sha256").update(content, "utf8").digest("hex");
 }
 function readManifest(dir) {
-  const manifestPath = join3(dir, MANIFEST_FILENAME);
-  if (!existsSync3(manifestPath))
+  const manifestPath = join4(dir, MANIFEST_FILENAME);
+  if (!existsSync4(manifestPath))
     return null;
   let raw;
   try {
-    raw = readFileSync2(manifestPath, "utf8");
+    raw = readFileSync3(manifestPath, "utf8");
   } catch {
     return null;
   }
@@ -4253,14 +4677,14 @@ function readManifest(dir) {
   return parsed;
 }
 function writeManifest(dir, manifest) {
-  if (!existsSync3(dir)) {
-    mkdirSync3(dir, { recursive: true });
+  if (!existsSync4(dir)) {
+    mkdirSync4(dir, { recursive: true });
   }
-  const manifestPath = join3(dir, MANIFEST_FILENAME);
-  mkdirSync3(dirname2(manifestPath), { recursive: true });
+  const manifestPath = join4(dir, MANIFEST_FILENAME);
+  mkdirSync4(dirname2(manifestPath), { recursive: true });
   const tmp = `${manifestPath}.tmp`;
-  rmSync2(tmp, { force: true });
-  writeFileSync2(tmp, `${JSON.stringify(manifest, null, 2)}
+  rmSync3(tmp, { force: true });
+  writeFileSync3(tmp, `${JSON.stringify(manifest, null, 2)}
 `);
   renameSync2(tmp, manifestPath);
 }
@@ -4360,10 +4784,10 @@ function buildUnionFiles(lessons) {
 }
 
 // src/lib/tool-detect.ts
-import { existsSync as existsSync4 } from "node:fs";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { join as join5 } from "node:path";
 function detectTools(projectRoot) {
-  const hit = (rel) => existsSync4(join4(projectRoot, rel));
+  const hit = (rel) => existsSync5(join5(projectRoot, rel));
   const signals = [];
   if (hit(".claude/" + MANIFEST_FILENAME)) {
     signals.push({
@@ -4471,23 +4895,23 @@ function topDetectedProfile(signals) {
 
 // src/lib/tool-switch.ts
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   lstatSync,
-  mkdirSync as mkdirSync5,
-  readFileSync as readFileSync5,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync6,
   renameSync as renameSync3,
   rmdirSync as rmdirSync2,
-  rmSync as rmSync4,
+  rmSync as rmSync5,
   statSync,
-  writeFileSync as writeFileSync4
+  writeFileSync as writeFileSync5
 } from "node:fs";
-import { dirname as dirname4, join as join6 } from "node:path";
+import { dirname as dirname4, join as join7 } from "node:path";
 
 // src/lib/fs-utils.ts
-import { readFileSync as readFileSync3 } from "node:fs";
+import { readFileSync as readFileSync4 } from "node:fs";
 function readFileOrNull(path) {
   try {
-    return readFileSync3(path, "utf8");
+    return readFileSync4(path, "utf8");
   } catch {
     return null;
   }
@@ -4563,15 +4987,15 @@ function stripBlock(content, begin, end, label, warnings) {
 // src/lib/writer.ts
 import {
   chmodSync as chmodSync2,
-  existsSync as existsSync5,
-  mkdirSync as mkdirSync4,
-  readFileSync as readFileSync4,
-  readdirSync,
+  existsSync as existsSync6,
+  mkdirSync as mkdirSync5,
+  readFileSync as readFileSync5,
+  readdirSync as readdirSync2,
   rmdirSync,
-  rmSync as rmSync3,
-  writeFileSync as writeFileSync3
+  rmSync as rmSync4,
+  writeFileSync as writeFileSync4
 } from "node:fs";
-import { dirname as dirname3, join as join5 } from "node:path";
+import { dirname as dirname3, join as join6 } from "node:path";
 var CLI_VERSION = package_default.version;
 var DEFAULT_COURSE = "10xdevs3";
 async function applyBundle(bundle, projectRoot, options = {}) {
@@ -4581,7 +5005,7 @@ async function applyBundle(bundle, projectRoot, options = {}) {
   const profile = options.profile ?? PROFILES[DEFAULT_TOOL];
   const onConflict = options.onConflict;
   const applyCourseRules = options.applyCourseRules !== false;
-  const manifestDir = join5(projectRoot, profile.manifestDir);
+  const manifestDir = join6(projectRoot, profile.manifestDir);
   const prevManifest = readManifest(manifestDir);
   const plan = planBundle(bundle, projectRoot, { profile, applyCourseRules });
   const nextSkillHashes = {};
@@ -4683,7 +5107,7 @@ async function applyBundle(bundle, projectRoot, options = {}) {
     }
     prompts.push({ name: prompt.name, path: target, action: finalAction, userBackupPath });
   }
-  const rulesFilePath = join5(projectRoot, profile.rulesFile);
+  const rulesFilePath = join6(projectRoot, profile.rulesFile);
   const existingRules = readFileOrEmpty(rulesFilePath);
   const { action: rulesAction, content: newRulesContent } = planRules(existingRules, bundle, profile, applyCourseRules);
   if (!dryRun && rulesAction !== "unchanged") {
@@ -4705,24 +5129,24 @@ async function applyBundle(bundle, projectRoot, options = {}) {
   for (const entry of removed.skillDirs) {
     removalResult.skills.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial)
-      rmSync3(entry.path, { recursive: true, force: true });
+      rmSync4(entry.path, { recursive: true, force: true });
   }
   for (const entry of removed.skillFiles) {
     removalResult.skills.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial) {
-      rmSync3(entry.path, { force: true });
+      rmSync4(entry.path, { force: true });
       removeEmptyParentDirs(entry.path, entry.skillDirAbs);
     }
   }
   for (const entry of removed.prompts) {
     removalResult.prompts.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial)
-      rmSync3(entry.path, { force: true });
+      rmSync4(entry.path, { force: true });
   }
   for (const entry of removed.configs) {
     removalResult.configs.push({ name: entry.name, path: entry.path, action: "removed" });
     if (!dryRun && !partial)
-      rmSync3(entry.path, { force: true });
+      rmSync4(entry.path, { force: true });
   }
   if (!dryRun && !partial) {
     const catalogContentHash = options.catalogContentHash ?? prevManifest?.lessons?.[bundle.lessonId]?.catalogContentHash;
@@ -4803,13 +5227,13 @@ function planBundle(bundle, projectRoot, options = {}) {
     assertSafeName(prompt.name, "prompt");
   for (const config of bundle.configs)
     assertSafeName(config.name, "config");
-  const manifestDir = join5(projectRoot, profile.manifestDir);
+  const manifestDir = join6(projectRoot, profile.manifestDir);
   const prevManifest = readManifest(manifestDir);
   const skills = bundle.skills.map((skill) => {
-    const skillDir = join5(projectRoot, profile.skillDir(skill.name));
+    const skillDir = join6(projectRoot, profile.skillDir(skill.name));
     const prevEntry = prevManifest?.files.skills[skill.name];
     const files = skill.files.map((file) => {
-      const target = join5(skillDir, file.path);
+      const target = join6(skillDir, file.path);
       const storedHash = prevEntry?.contentHashes?.[file.path];
       const { action, isConflict } = computeFileAction(target, file.content, storedHash);
       return {
@@ -4823,7 +5247,7 @@ function planBundle(bundle, projectRoot, options = {}) {
     return { name: skill.name, files };
   });
   const prompts = bundle.prompts.map((prompt) => {
-    const target = join5(projectRoot, profile.promptPath(prompt.name));
+    const target = join6(projectRoot, profile.promptPath(prompt.name));
     const storedHash = prevManifest?.files.promptHashes?.[`${prompt.name}.md`];
     const { action, isConflict } = computeFileAction(target, prompt.content, storedHash);
     return {
@@ -4834,12 +5258,12 @@ function planBundle(bundle, projectRoot, options = {}) {
       upstreamChanged: computeUpstreamChanged(prompt.content, storedHash, action)
     };
   });
-  const rulesFilePath = join5(projectRoot, profile.rulesFile);
+  const rulesFilePath = join6(projectRoot, profile.rulesFile);
   const existingRules = readFileOrEmpty(rulesFilePath);
   const { action: rulesAction } = planRules(existingRules, bundle, profile, applyCourseRules);
   const configs = bundle.configs.map((config) => {
-    const target = join5(projectRoot, profile.configPath(config.name));
-    const action = existsSync5(target) ? "skipped" : "created";
+    const target = join6(projectRoot, profile.configPath(config.name));
+    const action = existsSync6(target) ? "skipped" : "created";
     return {
       name: config.name,
       path: target,
@@ -4893,11 +5317,11 @@ function planRules(existingRules, bundle, profile, applyCourseRules) {
   return { action, content: newRules };
 }
 function computeFileAction(filePath, newContent, storedHash) {
-  if (!existsSync5(filePath))
+  if (!existsSync6(filePath))
     return { action: "created", isConflict: false };
   let current;
   try {
-    current = readFileSync4(filePath, "utf8");
+    current = readFileSync5(filePath, "utf8");
   } catch {
     return { action: "updated", isConflict: false };
   }
@@ -4918,21 +5342,21 @@ function buildUserBackupPath(filePath) {
   return `${filePath.slice(0, lastDot)}.user${filePath.slice(lastDot)}`;
 }
 function copyFileSync(src, dest) {
-  mkdirSync4(dirname3(dest), { recursive: true });
-  writeFileSync3(dest, readFileSync4(src));
+  mkdirSync5(dirname3(dest), { recursive: true });
+  writeFileSync4(dest, readFileSync5(src));
 }
 function readFileOrEmpty(filePath) {
-  if (!existsSync5(filePath))
+  if (!existsSync6(filePath))
     return "";
   try {
-    return readFileSync4(filePath, "utf8");
+    return readFileSync5(filePath, "utf8");
   } catch {
     return "";
   }
 }
 function writeFileAt(filePath, content) {
-  mkdirSync4(dirname3(filePath), { recursive: true });
-  writeFileSync3(filePath, content);
+  mkdirSync5(dirname3(filePath), { recursive: true });
+  writeFileSync4(filePath, content);
 }
 function computeRemovals(prevManifest, bundle, profile, projectRoot) {
   const empty = {
@@ -4975,7 +5399,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
   for (const [skillName, skill] of Object.entries(prevLessonEntry.skills)) {
     if (!isSafeName(skillName))
       continue;
-    const skillDirAbs = join5(projectRoot, profile.skillDir(skillName));
+    const skillDirAbs = join6(projectRoot, profile.skillDir(skillName));
     if (!currentSkills.has(skillName)) {
       if (protectedSkills.has(skillName)) {
         const prot = protectedSkills.get(skillName);
@@ -4986,7 +5410,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
             continue;
           removed.skillFiles.push({
             name: `${skillName}/${relPath}`,
-            path: join5(skillDirAbs, relPath),
+            path: join6(skillDirAbs, relPath),
             skillDirAbs
           });
         }
@@ -5005,7 +5429,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
         continue;
       removed.skillFiles.push({
         name: `${skillName}/${relPath}`,
-        path: join5(skillDirAbs, relPath),
+        path: join6(skillDirAbs, relPath),
         skillDirAbs
       });
     }
@@ -5020,7 +5444,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
     const promptName = promptFile.replace(/\.md$/, "");
     removed.prompts.push({
       name: promptFile,
-      path: join5(projectRoot, profile.promptPath(promptName))
+      path: join6(projectRoot, profile.promptPath(promptName))
     });
   }
   for (const configFile of prevLessonEntry.configs) {
@@ -5032,7 +5456,7 @@ function computeRemovals(prevManifest, bundle, profile, projectRoot) {
       continue;
     removed.configs.push({
       name: configFile,
-      path: join5(projectRoot, profile.configPath(configFile))
+      path: join6(projectRoot, profile.configPath(configFile))
     });
   }
   return removed;
@@ -5041,7 +5465,7 @@ function removeEmptyParentDirs(filePath, skillDirAbs) {
   let dir = dirname3(filePath);
   while (dir.startsWith(skillDirAbs) && dir !== skillDirAbs) {
     try {
-      if (readdirSync(dir).length > 0)
+      if (readdirSync2(dir).length > 0)
         return;
       rmdirSync(dir);
     } catch {
@@ -5055,10 +5479,10 @@ function findOrphanedManifests(projectRoot, currentProfile) {
   for (const profile of Object.values(PROFILES)) {
     if (profile.toolId === currentProfile.toolId)
       continue;
-    const manifestPath = join5(projectRoot, profile.manifestDir, MANIFEST_FILENAME);
-    if (!existsSync5(manifestPath))
+    const manifestPath = join6(projectRoot, profile.manifestDir, MANIFEST_FILENAME);
+    if (!existsSync6(manifestPath))
       continue;
-    const manifest = readManifest(join5(projectRoot, profile.manifestDir));
+    const manifest = readManifest(join6(projectRoot, profile.manifestDir));
     if (!manifest)
       continue;
     out.push({ profile, manifestPath, manifest });
@@ -5137,8 +5561,8 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
       summary.skipped.push({ path: skillName, reason: "unsafe name in manifest" });
       continue;
     }
-    const fromSkillDir = join6(projectRoot, oldProfile.skillDir(skillName));
-    const toSkillDir = join6(projectRoot, newProfile.skillDir(skillName));
+    const fromSkillDir = join7(projectRoot, oldProfile.skillDir(skillName));
+    const toSkillDir = join7(projectRoot, newProfile.skillDir(skillName));
     let anyMoved = false;
     for (const relPath of entry.files) {
       if (!isSafeSkillFilePath(relPath)) {
@@ -5148,8 +5572,8 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
         });
         continue;
       }
-      const from = join6(fromSkillDir, relPath);
-      const to = join6(toSkillDir, relPath);
+      const from = join7(fromSkillDir, relPath);
+      const to = join7(toSkillDir, relPath);
       if (moveIfSafe(from, to, summary.skipped))
         anyMoved = true;
     }
@@ -5163,8 +5587,8 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
       continue;
     }
     const promptName = promptFile.replace(/\.md$/, "");
-    const from = join6(projectRoot, oldProfile.promptPath(promptName));
-    const to = join6(projectRoot, newProfile.promptPath(promptName));
+    const from = join7(projectRoot, oldProfile.promptPath(promptName));
+    const to = join7(projectRoot, newProfile.promptPath(promptName));
     if (moveIfSafe(from, to, summary.skipped)) {
       summary.movedOrRemoved.prompts.push(promptFile);
     }
@@ -5174,15 +5598,15 @@ function migrateArtifacts(projectRoot, orphan, newProfile) {
       summary.skipped.push({ path: configFile, reason: "unsafe name in manifest" });
       continue;
     }
-    const from = join6(projectRoot, oldProfile.configPath(configFile));
-    const to = join6(projectRoot, newProfile.configPath(configFile));
+    const from = join7(projectRoot, oldProfile.configPath(configFile));
+    const to = join7(projectRoot, newProfile.configPath(configFile));
     if (moveIfSafe(from, to, summary.skipped)) {
       summary.movedOrRemoved.configs.push(configFile);
     }
   }
   summary.sentinelStripped = stripSentinelFromRulesFile(projectRoot, oldProfile);
-  rmSync4(orphan.manifestPath, { force: true });
-  tryRemoveEmptyDir(join6(projectRoot, oldProfile.manifestDir));
+  rmSync5(orphan.manifestPath, { force: true });
+  tryRemoveEmptyDir(join7(projectRoot, oldProfile.manifestDir));
   return summary;
 }
 function deleteArtifacts(projectRoot, orphan) {
@@ -5199,7 +5623,7 @@ function deleteArtifacts(projectRoot, orphan) {
       summary.skipped.push({ path: skillName, reason: "unsafe name in manifest" });
       continue;
     }
-    const skillDir = join6(projectRoot, oldProfile.skillDir(skillName));
+    const skillDir = join7(projectRoot, oldProfile.skillDir(skillName));
     for (const relPath of entry.files) {
       if (!isSafeSkillFilePath(relPath)) {
         summary.skipped.push({
@@ -5208,9 +5632,9 @@ function deleteArtifacts(projectRoot, orphan) {
         });
         continue;
       }
-      rmSync4(join6(skillDir, relPath), { force: true });
+      rmSync5(join7(skillDir, relPath), { force: true });
     }
-    rmSync4(skillDir, { recursive: true, force: true });
+    rmSync5(skillDir, { recursive: true, force: true });
     summary.movedOrRemoved.skills.push(skillName);
   }
   for (const promptFile of orphan.manifest.files.prompts) {
@@ -5219,7 +5643,7 @@ function deleteArtifacts(projectRoot, orphan) {
       continue;
     }
     const promptName = promptFile.replace(/\.md$/, "");
-    rmSync4(join6(projectRoot, oldProfile.promptPath(promptName)), { force: true });
+    rmSync5(join7(projectRoot, oldProfile.promptPath(promptName)), { force: true });
     summary.movedOrRemoved.prompts.push(promptFile);
   }
   for (const configFile of orphan.manifest.files.configs) {
@@ -5227,27 +5651,27 @@ function deleteArtifacts(projectRoot, orphan) {
       summary.skipped.push({ path: configFile, reason: "unsafe name in manifest" });
       continue;
     }
-    rmSync4(join6(projectRoot, oldProfile.configPath(configFile)), { force: true });
+    rmSync5(join7(projectRoot, oldProfile.configPath(configFile)), { force: true });
     summary.movedOrRemoved.configs.push(configFile);
   }
   summary.sentinelStripped = stripSentinelFromRulesFile(projectRoot, oldProfile);
-  rmSync4(orphan.manifestPath, { force: true });
-  const manifestDirAbs = join6(projectRoot, oldProfile.manifestDir);
-  tryRemoveEmptyDir(join6(manifestDirAbs, "skills"));
-  tryRemoveEmptyDir(join6(manifestDirAbs, "prompts"));
-  tryRemoveEmptyDir(join6(manifestDirAbs, "config-templates"));
+  rmSync5(orphan.manifestPath, { force: true });
+  const manifestDirAbs = join7(projectRoot, oldProfile.manifestDir);
+  tryRemoveEmptyDir(join7(manifestDirAbs, "skills"));
+  tryRemoveEmptyDir(join7(manifestDirAbs, "prompts"));
+  tryRemoveEmptyDir(join7(manifestDirAbs, "config-templates"));
   tryRemoveEmptyDir(manifestDirAbs);
   return summary;
 }
 function moveIfSafe(from, to, skipped) {
-  if (!existsSync6(from)) {
+  if (!existsSync7(from)) {
     return false;
   }
   if (lstatSync(from).isSymbolicLink()) {
     skipped.push({ path: from, reason: "source is a symlink" });
     return false;
   }
-  if (existsSync6(to)) {
+  if (existsSync7(to)) {
     if (!filesAreIdentical(from, to)) {
       skipped.push({
         path: to,
@@ -5255,22 +5679,22 @@ function moveIfSafe(from, to, skipped) {
       });
       return false;
     }
-    rmSync4(from, { force: true });
+    rmSync5(from, { force: true });
     return true;
   }
-  mkdirSync5(dirname4(to), { recursive: true });
+  mkdirSync6(dirname4(to), { recursive: true });
   try {
     renameSync3(from, to);
   } catch (err) {
     const code = err?.code;
     if (code !== "EXDEV")
       throw err;
-    const bytes = readFileSync5(from);
+    const bytes = readFileSync6(from);
     const tmp = `${to}.tmp`;
-    writeFileSync4(tmp, bytes);
+    writeFileSync5(tmp, bytes);
     renameSync3(tmp, to);
     try {
-      rmSync4(from, { force: true });
+      rmSync5(from, { force: true });
     } catch {
       skipped.push({
         path: from,
@@ -5282,8 +5706,8 @@ function moveIfSafe(from, to, skipped) {
   return true;
 }
 function stripSentinelFromRulesFile(projectRoot, oldProfile) {
-  const rulesPath = join6(projectRoot, oldProfile.rulesFile);
-  if (!existsSync6(rulesPath))
+  const rulesPath = join7(projectRoot, oldProfile.rulesFile);
+  if (!existsSync7(rulesPath))
     return false;
   const existing = readFileOrNull(rulesPath);
   if (existing === null)
@@ -5292,9 +5716,9 @@ function stripSentinelFromRulesFile(projectRoot, oldProfile) {
   if (!removed)
     return false;
   if (content.trim().length === 0) {
-    rmSync4(rulesPath, { force: true });
+    rmSync5(rulesPath, { force: true });
   } else {
-    writeFileSync4(rulesPath, content);
+    writeFileSync5(rulesPath, content);
   }
   return true;
 }
@@ -5304,13 +5728,13 @@ function filesAreIdentical(a2, b2) {
     const bStat = statSync(b2);
     if (aStat.size !== bStat.size)
       return false;
-    return readFileSync5(a2).equals(readFileSync5(b2));
+    return readFileSync6(a2).equals(readFileSync6(b2));
   } catch {
     return false;
   }
 }
 function tryRemoveEmptyDir(dir) {
-  if (!existsSync6(dir))
+  if (!existsSync7(dir))
     return;
   try {
     rmdirSync2(dir);
@@ -5517,7 +5941,7 @@ async function runGet(ctx, ref, options) {
   const isFiltered = options.type !== undefined;
   const bundle = filterBundle(ctx, result.data, options);
   const isTTY = process.stdout.isTTY === true;
-  const prevManifest = readManifest(join7(process.cwd(), profile.manifestDir));
+  const prevManifest = readManifest(join8(process.cwd(), profile.manifestDir));
   if (prevManifest && prevManifest.manifestVersion === 2) {
     showUpgradeNotice(isTTY);
   }
@@ -5887,7 +6311,7 @@ function renderModuleDetail(ctx, module) {
 }
 
 // src/commands/sync.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var DEFAULT_COURSE4 = "10xdevs3";
 var SUPPORTED_LANGS = ["en", "pl"];
 function registerSyncCommand(cli) {
@@ -5933,7 +6357,7 @@ async function runSync(ctx, options) {
     }
     return true;
   });
-  const manifest = readManifest(join8(process.cwd(), profile.manifestDir));
+  const manifest = readManifest(join9(process.cwd(), profile.manifestDir));
   const manifestLessonIds = new Set(manifest?.lessons ? Object.keys(manifest.lessons) : []);
   let targets = unlocked;
   if (moduleFilter !== undefined)
@@ -6297,6 +6721,8 @@ registerGetCommand(cli);
 registerListCommand(cli);
 registerSyncCommand(cli);
 registerDoctorCommand(cli);
+registerBenchCommand(cli);
+registerBenchKitCommand(cli);
 cli.help();
 cli.version(package_default.version);
 try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@przeprogramowani/10x-cli",
-  "version": "1.10.0",
+  "version": "1.12.0",
   "description": "Open-source CLI for 10xDevs course content",
   "repository": {
     "type": "git",

package/skills/10x-cli-guide/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: 10x-cli-guide
-description: "Invoke this skill when the user asks how to USE the 10x-cli day-to-day — fetching lessons, listing modules, switching AI tools, troubleshooting errors, understanding where artifacts land, or working on a specific OS (Windows, Linux, macOS). Covers commands (get, list, doctor, auth --status/--logout), tool profiles, artifact locations, common errors, and platform-specific tips. Excludes: first-time installation and onboarding (use 10x-cli-setup instead), developing or contributing to 10x-cli source code, and general programming help."
+description: "Invoke this skill when the user asks how to USE the 10x-cli day-to-day — fetching lessons, listing modules, switching AI tools, troubleshooting errors, understanding where artifacts land, checking the 10xBench model leaderboard, or working on a specific OS (Windows, Linux, macOS). Covers commands (get, list, doctor, auth --status/--logout, bench), tool profiles, artifact locations, common errors, and platform-specific tips. Excludes: first-time installation and onboarding (use 10x-cli-setup instead), developing or contributing to 10x-cli source code, and general programming help."
 ---
 
 # 10x-cli Daily Usage Guide
@@ -117,6 +117,22 @@ Exit code 78 means at least one check failed.
 
 Sessions refresh transparently — if a token is near expiry, the next command refreshes it automatically. You only need to re-auth manually if the session has fully expired.
 
+### `10x bench` — 10xBench model leaderboard
+
+```bash
+10x bench             # Top 10 AI models with color-coded score bars
+10x bench --limit 5   # Just the top 5
+10x bench --json      # Machine-readable envelope (also when piped)
+```
+
+Shows the live leaderboard from [10xbench.ai](https://10xbench.ai) — AI models
+benchmarked on vibe-coding the Przeprogramowani.pl website. Each row has the
+average score, number of runs, cost per run where measured, and the agent
+harness used. **No authentication needed** — this works before `10x auth`.
+Data updates when new benchmark results are published; superseded model
+versions are already filtered out upstream. If it reports the leaderboard as
+unavailable, the site may be mid-deploy — retry in a few minutes.
+
 ---
 
 ## Switching Tools