wensity 0.1.14 → 0.1.15

package/README.md

@@ -92,6 +92,10 @@ with their icons as authored.
 | `wensity login` | Save a Wensity API token for Pro component access |
 | `wensity logout` | Remove saved credentials |
 | `wensity whoami` | Verify the saved token and print the account and plan |
+| `wensity skills add <name...>` | Install Wensity Design Skills for your AI agents (`--all` for every skill your plan includes) |
+| `wensity skills list` | Every skill, Free or Pro, with the installed and latest version |
+| `wensity skills update [name...]` | Get the latest version, leaving files you edited alone unless `--force` |
+| `wensity skills remove <name...>` | Delete the skill files the CLI wrote, keeping any you edited |
 | `wensity version` | Print the CLI version |
 
 Useful flags:
@@ -104,6 +108,34 @@ Useful flags:
 | `--force` | Allow `init` to overwrite an existing `wensity.json` |
 | `--json` | Machine readable output where supported |
 
+## Design Skills
+
+Agent skills that teach Claude Code, Codex, Cursor, Copilot, Windsurf, Gemini
+CLI and OpenCode how to design interfaces. Free skills need no account; Pro
+skills come with Wensity Pro and use the saved login.
+
+```bash
+npx wensity@latest skills add typography layout
+npx wensity@latest login
+npx wensity@latest skills add motion
+```
+
+Names work in full (`wensity-motion`), short (`motion`), or as the slug on the
+site (`ux-writing`). Skills go where each agent reads them: `.claude/skills/`
+for Claude Code and `.agents/skills/` for the others. The CLI picks the ones
+your project already uses, asks once when there are none, or takes
+`--agent claude` / `--agent agents`. Add `--global` to install in your home
+folder for every project, and `--dry-run` to see the changes first.
+
+Each install is recorded in `wensity-skills.json` (with `--global`,
+`~/.config/wensity/skills.json`) with the hash of every file written, so
+`update` and `remove` never touch a file you changed. Every file is checked
+against its hash before anything is written, and a failed install changes
+nothing.
+
+Pro skill files carry one license line for your account. Keep them out of
+public repositories.
+
 ## Authentication
 
 Free components need no account. Wensity Pro components and blocks require an

package/dist/index.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
 // src/commands.ts
-import { randomBytes } from "crypto";
-import { existsSync as existsSync5 } from "fs";
-import { mkdir as mkdir7, readFile as readFile8, stat, writeFile as writeFile6 } from "fs/promises";
-import { dirname as dirname8, join as join11, relative as relative8 } from "path";
+import { randomBytes as randomBytes3 } from "crypto";
+import { existsSync as existsSync6 } from "fs";
+import { mkdir as mkdir8, readFile as readFile9, stat, writeFile as writeFile7 } from "fs/promises";
+import { dirname as dirname9, join as join13, relative as relative8 } from "path";
 
 // ../install-core/src/constants.ts
 var CONFIG_FILE_NAME = "wensity.json";
@@ -17,7 +17,7 @@ var DEFAULT_UTILS_ALIAS = "@/lib/utils";
 
 // src/constants.ts
 var CLI_NAME = "wensity";
-var CLI_VERSION = "0.1.14";
+var CLI_VERSION = "0.1.15";
 var INIT_PRIMITIVE_CSS_SLUG = "button";
 var HELP_TEXT = `Wensity CLI ${CLI_VERSION}
 
@@ -31,6 +31,10 @@ Usage:
   wensity list [--type component|block] [options]
   wensity add <slug...> [--type component|block] [options]
   wensity update <slug...> [--type component|block] [options]
+  wensity skills add <name...> [--all] [--agent claude|agents] [--global] [--dry-run] [--yes] [--force]
+  wensity skills list [--global] [--json]
+  wensity skills update [name...] [--global] [--dry-run] [--force]
+  wensity skills remove <name...> [--global] [--dry-run]
   wensity version
 
 Commands:
@@ -43,6 +47,7 @@ Commands:
   list       List registry components or blocks
   add        Download one or more component/block source files into this project
   update     Re-download one or more components/blocks and overwrite the local copies
+  skills     Add, list, update or remove Wensity Design Skills for your AI agents
   version    Print the CLI version
 
 Options:
@@ -58,6 +63,10 @@ Options:
   --no-install         Write files without running the package manager
   --dry-run            Print planned writes and installs without changing files
   --json               Print machine-readable output where supported
+  --agent <agent>      skills: claude (.claude/skills) or agents (.agents/skills); repeat for both
+  --global             skills: install in your home folder for every project
+  --all                skills add: every skill your plan includes
+  --yes                skills: no questions; installs for both agents when none is found
   --help               Show help
   --version            Print the CLI version
 
@@ -70,6 +79,12 @@ Preset notes:
   init --template writes a minimal app scaffold in the current directory before Wensity files
   add/update accept several slugs at once and read style.iconLibrary for UI primitives only (Tabler|Lucide)
   Invalid/expired/unsupported codes exit non-zero with an actionable message
+
+Skills notes:
+  Names work in full (wensity-motion), short (motion), or as the site slug (ux-writing)
+  Free skills need no login; Pro skills use the token saved by wensity login
+  Installs are recorded in wensity-skills.json (with --global: ~/.config/wensity/skills.json)
+  update and remove never touch a file you edited unless you pass --force (update only)
 `;
 
 // ../install-core/src/errors.ts
@@ -246,7 +261,7 @@ function originOf(url) {
   }
 }
 function defaultSleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function parseJsonOrNull(text) {
   try {
@@ -293,7 +308,12 @@ var UPSTREAM_ERROR_CODES = {
   component_source_unreadable: "source_unavailable",
   block_source_unreadable: "source_unavailable",
   component_source_graph_unreadable: "source_unavailable",
-  cli_auth_failed: "server_error"
+  cli_auth_failed: "server_error",
+  pro_required: "entitlement_required",
+  license_inactive: "entitlement_required",
+  skill_not_found: "item_not_found",
+  skill_version_not_found: "item_not_found",
+  skill_unavailable: "source_unavailable"
 };
 function errorCodeFor(upstream) {
   const known = upstream.error ? UPSTREAM_ERROR_CODES[upstream.error] : void 0;
@@ -503,6 +523,15 @@ function createWensityClient(options) {
       }
       return await fetchComponentSource(slug, opts);
     },
+    fetchSkillIndex: () => get(joinUrl(registryOrigin(registryUrl), "/api/skills")),
+    async fetchSkillPayload(name, tier) {
+      const path = `/api/cli/skills/${encodeURIComponent(name)}`;
+      if (tier === "pro") {
+        if (!token) throw proRequired(name, name, "skill");
+        return get(joinUrl(apiBaseUrl, path), true);
+      }
+      return get(joinUrl(registryOrigin(registryUrl), path));
+    },
     async whoami() {
       if (!token) {
         throw new WensityError("auth_required", "No Wensity API token is configured.");
@@ -718,7 +747,7 @@ async function apply(options) {
         details: { reason: "precondition_mismatch", path: file.relativePath, expected: "present", found: "absent" }
       });
     }
-    return { ...file, absolutePath, existed: Boolean(stat2), mode: stat2 ? stat2.mode & 511 : void 0 };
+    return { ...file, absolutePath, existed: Boolean(stat2), requestedMode: file.mode, mode: stat2 ? stat2.mode & 511 : void 0 };
   });
   const workDir = ensureWorkDir(projectRoot);
   const journalDir = join3(workDir, planId);
@@ -769,7 +798,7 @@ async function apply(options) {
     await writeJournal("in_progress", "staging");
     for (const [index, target] of targets.entries()) {
       failedPath = target.relativePath;
-      await writeSynced(join3(journalDir, "staged", String(index)), target.content, target.mode ?? 420);
+      await writeSynced(join3(journalDir, "staged", String(index)), target.content, target.requestedMode ?? target.mode ?? 420);
       emit({ type: "stage", path: target.relativePath });
       fault("stage", index);
     }
@@ -947,7 +976,7 @@ async function place(staged, target, platform, hooks, emit, projectRoot) {
     } catch (error) {
       const retryable = isNodeError(error) && WINDOWS_RETRY_CODES.has(error.code ?? "");
       if (!retryable || attempt >= attempts) throw error;
-      await new Promise((resolve3) => setTimeout(resolve3, 25 * 2 ** (attempt - 1)));
+      await new Promise((resolve4) => setTimeout(resolve4, 25 * 2 ** (attempt - 1)));
     }
   }
   return stagedFile;
@@ -4097,8 +4126,8 @@ function runPackageManagerCommand(projectRoot, packageManager, args, options = {
   const ownGroup = !inherit && platform !== "win32";
   const timeoutMs = options.timeoutMs ?? (inherit ? void 0 : PACKAGE_MANAGER_TIMEOUT_MS);
   const started = Date.now();
-  return new Promise((resolve3) => {
-    let stdout2 = "";
+  return new Promise((resolve4) => {
+    let stdout3 = "";
     let stderr = "";
     let timedOut = false;
     const child = (options.spawnImpl ?? spawn)(invocation.command, invocation.args, {
@@ -4131,7 +4160,7 @@ function runPackageManagerCommand(projectRoot, packageManager, args, options = {
       killTree();
     }, timeoutMs);
     child.stdout?.on("data", (chunk) => {
-      stdout2 = (stdout2 + chunk.toString("utf8")).slice(-OUTPUT_KEEP);
+      stdout3 = (stdout3 + chunk.toString("utf8")).slice(-OUTPUT_KEEP);
     });
     child.stderr?.on("data", (chunk) => {
       stderr = (stderr + chunk.toString("utf8")).slice(-OUTPUT_KEEP);
@@ -4148,7 +4177,7 @@ function runPackageManagerCommand(projectRoot, packageManager, args, options = {
       removeSignalHandlers();
       child.stdout?.destroy();
       child.stderr?.destroy();
-      resolve3({ invocation, exitCode, stdout: stdout2, stderr, durationMs: Date.now() - started, timedOut, ...spawnError ? { spawnError } : {} });
+      resolve4({ invocation, exitCode, stdout: stdout3, stderr, durationMs: Date.now() - started, timedOut, ...spawnError ? { spawnError } : {} });
     };
     child.on("error", (error) => void finish(null, error.message));
     child.on("exit", (code) => void finish(code));
@@ -4203,7 +4232,7 @@ function groupAlive(pid) {
 async function waitForGroupExit(pid) {
   const deadline = Date.now() + TREE_EXIT_WAIT_MS;
   while (groupAlive(pid) && Date.now() < deadline) {
-    await new Promise((resolve3) => setTimeout(resolve3, 20));
+    await new Promise((resolve4) => setTimeout(resolve4, 20));
   }
 }
 function installArgs(packageManager, dependencies) {
@@ -4498,7 +4527,8 @@ function expectsValue(name) {
     "preset",
     "preset-file",
     "template",
-    "package-manager"
+    "package-manager",
+    "agent"
   ].includes(name);
 }
 function normalizeOptionName(name) {
@@ -6163,6 +6193,917 @@ function withSourceExtension(path, extension) {
   return toPosixPath(join10(directory === "." ? "" : directory, `${fileName}.${extension}`));
 }
 
+// src/skills.ts
+import { randomBytes as randomBytes2 } from "crypto";
+import { homedir as homedir2 } from "os";
+import { stdin as stdin2, stdout as stdout2 } from "process";
+import { createInterface } from "readline/promises";
+
+// ../install-core/src/lock.ts
+import { randomBytes } from "crypto";
+import { closeSync as closeSync2, lstatSync as lstatSync5, openSync as openSync2, readFileSync as readFileSync5, unlinkSync as unlinkSync2, writeSync as writeSync2 } from "fs";
+import { join as join11 } from "path";
+var STALE_LOCK_MS = 10 * 6e4;
+function acquireInstallLock(projectRoot, options) {
+  const now = options.now ?? Date.now;
+  const alive = options.isProcessAlive ?? isProcessAlive;
+  const dir = ensureWorkDir(projectRoot);
+  const path = join11(dir, LOCK_FILE);
+  const contents = { pid: process.pid, startedAt: now(), planId: options.planId, nonce: randomBytes(16).toString("hex") };
+  for (let attempt = 0; attempt < 2; attempt += 1) {
+    let fd;
+    try {
+      fd = openSync2(path, "wx", 384);
+    } catch (error) {
+      if (!(isNodeError(error) && error.code === "EEXIST")) throw error;
+      const existing = inspectExisting(path);
+      const stale = existing && now() - existing.startedAt > STALE_LOCK_MS && !alive(existing.pid);
+      if (attempt === 0 && stale) {
+        unlinkSync2(path);
+        continue;
+      }
+      throw new WensityError("write_failed", "Another Wensity installation is in progress for this project. Retry when it finishes.", {
+        details: { reason: "install_locked", ...existing ? { heldSince: new Date(existing.startedAt).toISOString() } : {} }
+      });
+    }
+    try {
+      writeSync2(fd, JSON.stringify(contents));
+    } finally {
+      closeSync2(fd);
+    }
+    let released = false;
+    return {
+      release() {
+        if (released) return;
+        released = true;
+        try {
+          const stat2 = lstatSync5(path);
+          if (!stat2.isFile() || stat2.isSymbolicLink()) return;
+          const current = JSON.parse(readFileSync5(path, "utf8"));
+          if (current.nonce === contents.nonce) unlinkSync2(path);
+        } catch {
+        }
+        removeWorkDirIfEmpty(projectRoot);
+      }
+    };
+  }
+  throw new WensityError("write_failed", "Could not acquire the Wensity install lock.");
+}
+function inspectExisting(path) {
+  let stat2;
+  try {
+    stat2 = lstatSync5(path);
+  } catch {
+    return void 0;
+  }
+  if (stat2.isSymbolicLink() || !stat2.isFile()) {
+    throw new WensityError(
+      "path_unsafe",
+      `${WORK_DIR_NAME}/${LOCK_FILE} is not a regular file. It was not followed or removed; delete it yourself.`
+    );
+  }
+  try {
+    const parsed = JSON.parse(readFileSync5(path, "utf8"));
+    if (typeof parsed.pid === "number" && typeof parsed.startedAt === "number") return parsed;
+  } catch {
+  }
+  return void 0;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return isNodeError(error) && error.code === "EPERM";
+  }
+}
+
+// ../install-core/src/skills.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync5, lstatSync as lstatSync6, readFileSync as readFileSync6 } from "fs";
+import { mkdir as mkdir7, readFile as readFile8, rename as rename3, rm as rm3, rmdir, unlink, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname8, join as join12, posix as posix4, resolve as resolve3 } from "path";
+var SKILL_AGENTS = ["claude", "agents"];
+var SKILL_AGENT_DIRS = {
+  claude: ".claude/skills",
+  agents: ".agents/skills"
+};
+var SKILL_AGENT_LABELS = {
+  claude: "Claude Code",
+  agents: "Codex, Cursor, Copilot, Windsurf, Gemini CLI, OpenCode"
+};
+var AGENT_MARKERS = {
+  claude: [".claude", "CLAUDE.md"],
+  agents: [".agents", "AGENTS.md", ".codex", ".cursor", ".windsurf", ".gemini", "GEMINI.md", ".opencode", ".github/copilot-instructions.md"]
+};
+var SKILL_LOCK_FILE = "wensity-skills.json";
+function skillAliases(skill) {
+  return [.../* @__PURE__ */ new Set([skill.name, skill.name.replace(/^wensity-/, ""), skill.slug])];
+}
+function resolveSkillNames(index, inputs) {
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const skill of index.skills) for (const alias of skillAliases(skill)) byAlias.set(alias, skill);
+  const resolved = [];
+  const unknown = [];
+  for (const input of inputs) {
+    const skill = byAlias.get(input.trim().toLowerCase());
+    if (!skill) unknown.push(input);
+    else if (!resolved.includes(skill)) resolved.push(skill);
+  }
+  if (unknown.length > 0) {
+    const lines = unknown.map((input) => {
+      const suggestions = suggestSkillNames(index, input);
+      return suggestions.length > 0 ? `Unknown skill "${input}". Did you mean ${suggestions.join(", ")}?` : `Unknown skill "${input}".`;
+    });
+    throw new WensityError("item_not_found", `${lines.join("\n")}
+Run \`wensity skills list\` to see every skill.`);
+  }
+  return resolved;
+}
+function suggestSkillNames(index, input) {
+  const wanted = input.trim().toLowerCase().replace(/^wensity-/, "");
+  const scored = index.skills.map((skill) => {
+    const best = Math.min(
+      ...skillAliases(skill).map((alias) => {
+        const short = alias.replace(/^wensity-/, "");
+        if (wanted.length >= 3 && (short.includes(wanted) || wanted.includes(short))) return 0;
+        return editDistance(wanted, short);
+      })
+    );
+    return { name: skill.name.replace(/^wensity-/, ""), best };
+  });
+  const limit = Math.max(2, Math.floor(wanted.length / 3));
+  return scored.filter((entry) => entry.best <= limit).sort((a, b) => a.best - b.best || a.name.localeCompare(b.name)).slice(0, 3).map((entry) => entry.name);
+}
+function editDistance(a, b) {
+  const row = Array.from({ length: b.length + 1 }, (_, index) => index);
+  for (let i = 1; i <= a.length; i += 1) {
+    let previous = row[0];
+    row[0] = i;
+    for (let j = 1; j <= b.length; j += 1) {
+      const current = row[j];
+      row[j] = Math.min(row[j] + 1, row[j - 1] + 1, previous + (a[i - 1] === b[j - 1] ? 0 : 1));
+      previous = current;
+    }
+  }
+  return row[b.length];
+}
+function compareSkillVersions(a, b) {
+  const x = a.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  const y = b.split(".").map((part) => Number.parseInt(part, 10) || 0);
+  for (let i = 0; i < 3; i += 1) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) - (y[i] ?? 0);
+  return 0;
+}
+function changesBetween(skill, from, to) {
+  return (skill.changes ?? []).filter(
+    (change) => compareSkillVersions(change.version, from) > 0 && compareSkillVersions(change.version, to) <= 0
+  );
+}
+function skillsWithUpdates(index, lock, except = []) {
+  return index.skills.filter((skill) => {
+    const entry = lock.skills[skill.name];
+    return entry !== void 0 && !except.includes(skill.name) && compareSkillVersions(entry.version, skill.version) < 0;
+  });
+}
+function detectSkillAgents(root) {
+  return SKILL_AGENTS.filter((agent) => AGENT_MARKERS[agent].some((marker) => existsSync5(join12(root, ...marker.split("/")))));
+}
+function parseSkillAgent(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "claude" || normalized === "claude-code") return "claude";
+  if (normalized === "agents" || normalized === "other" || normalized === "codex" || normalized === "cursor") return "agents";
+  throw new WensityError("config_invalid", `Unknown agent "${value}". Use --agent claude (Claude Code) or --agent agents (Codex, Cursor, Copilot, Windsurf, Gemini CLI, OpenCode).`);
+}
+function findSkillsProjectRoot(cwd, home) {
+  const start = resolve3(cwd);
+  const stop = home ? resolve3(home) : void 0;
+  let current = start;
+  while (true) {
+    if (current === stop) break;
+    if ([SKILL_LOCK_FILE, "package.json", ".git"].some((marker) => existsSync5(join12(current, marker)))) return current;
+    const parent = dirname8(current);
+    if (parent === current) break;
+    current = parent;
+  }
+  if (start === stop) {
+    throw new WensityError("project_ambiguous", "Your home folder is not a project. Run this from your project folder, or add --global to install for every project.");
+  }
+  if (dirname8(start) === start) {
+    throw new WensityError("project_ambiguous", `${start} is a filesystem root, not a project. Run this from your project folder.`);
+  }
+  return start;
+}
+function skillLockPath(options) {
+  if (!options.global) return join12(options.root, SKILL_LOCK_FILE);
+  const env = options.env;
+  if (env.WENSITY_SKILLS_LOCK_FILE) return env.WENSITY_SKILLS_LOCK_FILE;
+  const home = env.HOME;
+  if (!env.WENSITY_CONFIG_HOME && !env.XDG_CONFIG_HOME && !home) {
+    throw new WensityError("config_missing", "HOME is not set, so the CLI cannot find its config folder.");
+  }
+  const configHome = env.WENSITY_CONFIG_HOME ?? env.XDG_CONFIG_HOME ?? join12(home, ".config");
+  return join12(configHome, "wensity", "skills.json");
+}
+function skillFolder(agent, name) {
+  return posix4.join(SKILL_AGENT_DIRS[agent], name);
+}
+function emptySkillLock() {
+  return { version: 1, skills: {} };
+}
+async function readSkillLock(path) {
+  let text;
+  try {
+    const stat2 = lstatSync6(path);
+    if (stat2.isSymbolicLink() || !stat2.isFile()) {
+      throw new WensityError("path_unsafe", `${path} is not a regular file. Remove it and try again.`);
+    }
+    text = await readFile8(path, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return emptySkillLock();
+    throw error;
+  }
+  try {
+    const parsed = JSON.parse(text);
+    if (parsed.version !== 1 || !parsed.skills || typeof parsed.skills !== "object") throw new Error("bad shape");
+    return { version: 1, skills: parsed.skills };
+  } catch {
+    throw new WensityError("config_invalid", `${path} is not a valid skills record. Fix or delete it, then try again.`);
+  }
+}
+async function writeSkillLock(path, lock) {
+  if (Object.keys(lock.skills).length === 0) {
+    await rm3(path, { force: true });
+    return;
+  }
+  const sorted = {
+    version: 1,
+    skills: Object.fromEntries(Object.keys(lock.skills).sort().map((name) => [name, lock.skills[name]]))
+  };
+  await mkdir7(dirname8(path), { recursive: true });
+  const temp = join12(dirname8(path), `.wensity-skills.${randomUUID2()}.tmp`);
+  await writeFile6(temp, `${JSON.stringify(sorted, null, 2)}
+`, "utf8");
+  await rename3(temp, path);
+}
+var SAFE_SEGMENT2 = /^[A-Za-z0-9._-]+$/;
+function sanitizeSkillFilePath(path) {
+  const unsafe3 = () => new WensityError("path_unsafe", `Unsafe skill file path from the server: ${path.slice(0, 120)}`);
+  if (typeof path !== "string" || path.length === 0 || path.length > MAX_TARGET_PATH_LENGTH) throw unsafe3();
+  if (/^[\\/]/.test(path) || /^[A-Za-z]:/.test(path) || path.includes("\\")) throw unsafe3();
+  const parts = path.split("/");
+  for (const part of parts) {
+    if (part === "" || part === "." || part === ".." || !SAFE_SEGMENT2.test(part)) throw unsafe3();
+  }
+  return parts.join("/");
+}
+function verifySkillPayload(payload, expectedName) {
+  if (!payload || payload.name !== expectedName || !Array.isArray(payload.files) || payload.files.length === 0) {
+    throw new WensityError("source_integrity_failed", `The server sent an unexpected answer for ${expectedName}. Nothing was written.`);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const files = payload.files.map((file) => {
+    const path = sanitizeSkillFilePath(file.path);
+    if (seen.has(path.toLowerCase())) throw new WensityError("source_integrity_failed", `${expectedName} lists ${path} twice. Nothing was written.`);
+    seen.add(path.toLowerCase());
+    if (typeof file.content !== "string" || file.content.includes("\0")) {
+      throw new WensityError("source_integrity_failed", `${expectedName}/${path} is not a text file. Nothing was written.`);
+    }
+    if (sha256(file.content) !== file.sha256) {
+      throw new WensityError("source_integrity_failed", `${expectedName}/${path} did not match its checksum. Nothing was written. Try again.`);
+    }
+    const content = file.content.replace(/\r\n?/g, "\n");
+    return { ...file, path, content, sha256: sha256(content), executable: file.executable === true };
+  });
+  if (!files.some((file) => file.path === "SKILL.md")) {
+    throw new WensityError("source_integrity_failed", `${expectedName} has no SKILL.md. Nothing was written.`);
+  }
+  return { ...payload, files };
+}
+function assertNoSymlinkedDirs(root, relativePath) {
+  const segments = relativePath.split("/").filter(Boolean);
+  let current = root;
+  for (const segment of segments.slice(0, -1)) {
+    current = join12(current, segment);
+    let stat2;
+    try {
+      stat2 = lstatSync6(current);
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT") return;
+      throw error;
+    }
+    if (stat2.isSymbolicLink()) {
+      throw new WensityError("path_unsafe", `${toPosixPath(current)} is a symlink. Wensity does not write skills through symlinks; point --agent at a real folder or remove the link.`);
+    }
+    if (!stat2.isDirectory()) {
+      throw new WensityError("path_unsafe", `${toPosixPath(current)} is a file, not a folder. Nothing was written.`);
+    }
+  }
+}
+function readDiskHash(absolutePath) {
+  try {
+    const stat2 = lstatSync6(absolutePath);
+    if (stat2.isSymbolicLink() || !stat2.isFile()) {
+      throw new WensityError("path_unsafe", `${toPosixPath(absolutePath)} is not a regular file. Nothing was written.`);
+    }
+    return sha256(readFileSync6(absolutePath));
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function planSkillInstall(input) {
+  const { root, payload, previous, force } = input;
+  const writes = [];
+  const deletes = [];
+  const outcomes = [];
+  const targets = { ...previous?.targets ?? {} };
+  for (const agent of input.agents) {
+    const folder = skillFolder(agent, payload.name);
+    const recorded = previous?.targets[agent]?.files ?? {};
+    const nextFiles = {};
+    for (const file of payload.files) {
+      const relativePath = posix4.join(folder, file.path);
+      assertNoSymlinkedDirs(root, relativePath);
+      const absolutePath = resolveInside(root, relativePath);
+      const onDisk = readDiskHash(absolutePath);
+      const wasWritten = recorded[file.path];
+      const edited = onDisk !== void 0 && wasWritten !== void 0 && onDisk !== wasWritten;
+      const stranger = onDisk !== void 0 && wasWritten === void 0 && onDisk !== file.sha256;
+      const mode = file.executable ? 493 : void 0;
+      let status;
+      if (onDisk === void 0) {
+        status = "added";
+        writes.push({ relativePath, content: file.content, action: "create", ...mode ? { mode } : {} });
+        nextFiles[file.path] = file.sha256;
+      } else if (onDisk === file.sha256) {
+        status = "unchanged";
+        nextFiles[file.path] = file.sha256;
+      } else if ((edited || stranger) && !force) {
+        status = edited ? "skipped" : "conflict";
+        if (edited) nextFiles[file.path] = wasWritten;
+      } else {
+        status = "updated";
+        writes.push({ relativePath, content: file.content, action: "overwrite", ...mode ? { mode } : {} });
+        nextFiles[file.path] = file.sha256;
+      }
+      outcomes.push({ agent, relativePath, skillPath: file.path, status });
+    }
+    const current = new Set(payload.files.map((file) => file.path));
+    for (const [skillPath, writtenHash] of Object.entries(recorded)) {
+      if (current.has(skillPath)) continue;
+      const relativePath = posix4.join(folder, sanitizeSkillFilePath(skillPath));
+      assertNoSymlinkedDirs(root, relativePath);
+      const onDisk = readDiskHash(resolveInside(root, relativePath));
+      if (onDisk === void 0) continue;
+      if (onDisk === writtenHash || force) {
+        deletes.push(relativePath);
+        outcomes.push({ agent, relativePath, skillPath, status: "removed" });
+      } else {
+        outcomes.push({ agent, relativePath, skillPath, status: "kept" });
+      }
+    }
+    targets[agent] = { files: nextFiles };
+  }
+  const now = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
+  return {
+    name: payload.name,
+    version: payload.version,
+    ...previous ? { previousVersion: previous.version } : {},
+    writes,
+    deletes,
+    outcomes,
+    entry: {
+      version: payload.version,
+      tier: payload.tier,
+      targets,
+      installedAt: previous?.installedAt ?? now,
+      updatedAt: now
+    }
+  };
+}
+function planSkillRemove(root, name, entry) {
+  const deletes = [];
+  const outcomes = [];
+  const folders = [];
+  for (const agent of SKILL_AGENTS) {
+    const target = entry.targets[agent];
+    if (!target) continue;
+    const folder = skillFolder(agent, name);
+    folders.push(folder);
+    for (const [skillPath, writtenHash] of Object.entries(target.files)) {
+      const relativePath = posix4.join(folder, sanitizeSkillFilePath(skillPath));
+      assertNoSymlinkedDirs(root, relativePath);
+      const onDisk = readDiskHash(resolveInside(root, relativePath));
+      if (onDisk === void 0) continue;
+      if (onDisk === writtenHash) {
+        deletes.push(relativePath);
+        outcomes.push({ agent, relativePath, skillPath, status: "removed" });
+      } else {
+        outcomes.push({ agent, relativePath, skillPath, status: "kept" });
+      }
+    }
+  }
+  return { name, deletes, outcomes, folders };
+}
+async function deleteSkillFiles(root, relativePaths, folders = []) {
+  const parents = /* @__PURE__ */ new Set();
+  for (const relativePath of relativePaths) {
+    assertNoSymlinkedDirs(root, relativePath);
+    const absolutePath = resolveInside(root, relativePath);
+    try {
+      const stat2 = lstatSync6(absolutePath);
+      if (!stat2.isFile()) continue;
+      await unlink(absolutePath);
+    } catch (error) {
+      if (!(isNodeError(error) && error.code === "ENOENT")) throw error;
+    }
+    let dir = posix4.dirname(relativePath);
+    while (folders.some((folder) => dir === folder || dir.startsWith(`${folder}/`))) {
+      parents.add(dir);
+      dir = posix4.dirname(dir);
+    }
+  }
+  for (const folder of folders) parents.add(folder);
+  for (const dir of [...parents].sort((a, b) => b.split("/").length - a.split("/").length)) {
+    try {
+      const absolute = resolveInside(root, dir);
+      if (lstatSync6(absolute).isDirectory()) await rmdir(absolute);
+    } catch {
+    }
+  }
+}
+
+// src/skills.ts
+var PRICING_URL2 = "https://ui.wensity.com/pricing";
+var LOGIN_COMMAND = "npx wensity@latest login";
+var REQUEST_TIMEOUT_MS = 3e4;
+var SKILLS_USAGE = `Usage:
+  wensity skills add <name...> [--all] [--agent claude|agents] [--global] [--dry-run] [--yes] [--force]
+  wensity skills list [--global] [--json]
+  wensity skills update [name...] [--global] [--dry-run] [--force]
+  wensity skills remove <name...> [--global] [--dry-run]`;
+async function skillsCommand(context, parsed, positionals) {
+  const [subcommand, ...names] = positionals;
+  if (parsed.options.has("token")) {
+    throw new CliError(`Skills commands never take a token. Run \`${LOGIN_COMMAND}\` once; the saved login is used from then on.`);
+  }
+  if (!subcommand || !["add", "list", "update", "remove"].includes(subcommand)) {
+    throw new CliError(`${subcommand ? `Unknown skills command: ${subcommand}
+
+` : ""}${SKILLS_USAGE}`);
+  }
+  const setup = createSkillsContext(context, parsed, subcommand === "list");
+  switch (subcommand) {
+    case "add":
+      return addSkills(setup, names);
+    case "update":
+      return updateSkills(setup, names);
+    case "remove":
+      return removeSkills(setup, names);
+    default:
+      return listSkills(setup);
+  }
+}
+function createSkillsContext(context, parsed, lenient) {
+  const global = hasFlag(parsed, "global");
+  const home = context.env.HOME ?? homedir2();
+  let root;
+  if (global) {
+    root = home;
+  } else {
+    try {
+      root = findSkillsProjectRoot(context.cwd, home);
+    } catch (error) {
+      if (!lenient) throw error;
+      root = context.cwd;
+    }
+  }
+  const apiUrl = getStringOption(parsed, "api-url") ?? context.env.WENSITY_API_URL ?? DEFAULT_API_ORIGIN;
+  return {
+    context,
+    parsed,
+    global,
+    root,
+    lockPath: skillLockPath({ global, root, env: context.env }),
+    origin: normalizeUrlOrigin(apiUrl),
+    dryRun: hasFlag(parsed, "dry-run"),
+    force: hasFlag(parsed, "force")
+  };
+}
+async function fetchIndex(setup) {
+  const url = joinUrl(setup.origin, "/api/skills");
+  try {
+    return await requestJson2(url, { timeoutMs: REQUEST_TIMEOUT_MS, breakers: false });
+  } catch (error) {
+    throw explain(error, "the skills list");
+  }
+}
+async function savedToken(setup) {
+  const credentials = await readCredentials(setup.context.env);
+  if (!credentials) return void 0;
+  try {
+    return normalizeUrlOrigin(credentials.apiBaseUrl) === setup.origin ? credentials.token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function fetchPayload(setup, skill, token) {
+  const url = joinUrl(setup.origin, `/api/cli/skills/${encodeURIComponent(skill.name)}`);
+  try {
+    const payload = await requestJson2(url, {
+      timeoutMs: REQUEST_TIMEOUT_MS,
+      breakers: false,
+      // Free skills never carry the token; Pro skills only to the origin it was issued for.
+      ...skill.tier === "pro" && token ? { token } : {}
+    });
+    return verifySkillPayload(payload, skill.name);
+  } catch (error) {
+    throw explain(error, skill.name);
+  }
+}
+var DOWNLOAD_CONCURRENCY = 4;
+async function mapLimit(items, limit, task) {
+  const results = new Array(items.length);
+  let next = 0;
+  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) {
+      const index = next;
+      next += 1;
+      results[index] = await task(items[index]);
+    }
+  });
+  await Promise.all(workers);
+  return results;
+}
+async function downloadSkills(setup, skills, token, options) {
+  if (skills.length === 0) return { payloads: [] };
+  const label = skills.length === 1 ? skills[0].name : `${skills.length} skills`;
+  return withSpinner(`${options.verb} ${label}`, async () => {
+    const byName = /* @__PURE__ */ new Map();
+    const fetchOne = async (skill) => byName.set(skill.name, await fetchPayload(setup, skill, token));
+    const free = skills.filter((skill) => skill.tier === "free");
+    const pro = skills.filter((skill) => skill.tier === "pro");
+    let proDenied;
+    const freeDone = mapLimit(free, DOWNLOAD_CONCURRENCY, fetchOne);
+    if (pro.length > 0) {
+      try {
+        await fetchOne(pro[0]);
+        await mapLimit(pro.slice(1), DOWNLOAD_CONCURRENCY, fetchOne);
+      } catch (error) {
+        if (!(options.skipProWhenDenied && isProAccessDenied(error))) {
+          await freeDone.catch(() => void 0);
+          throw error;
+        }
+        proDenied = error.message;
+      }
+    }
+    await freeDone;
+    const payloads = skills.flatMap((skill) => {
+      const payload = byName.get(skill.name);
+      return payload ? [payload] : [];
+    });
+    return proDenied ? { payloads, proDenied } : { payloads };
+  });
+}
+function proAccessDenied(message) {
+  return Object.assign(new CliError(message), { proAccessDenied: true });
+}
+function isProAccessDenied(error) {
+  return typeof error === "object" && error !== null && error.proAccessDenied === true;
+}
+function explain(error, what) {
+  if (!isWensityError(error)) return error;
+  const upstream = error.upstream;
+  if (error.code === "entitlement_required") {
+    const message = upstream?.message ?? `${what} comes with Wensity Pro.`;
+    return proAccessDenied(message.includes(PRICING_URL2) ? message : `${message}
+Pricing: ${pricingBlue(PRICING_URL2)}`);
+  }
+  if (error.code === "auth_invalid" || error.code === "auth_revoked" || error.code === "auth_user_missing") {
+    if (upstream?.error === "missing_token") return new CliError(`${what} comes with Wensity Pro. Log in first: ${LOGIN_COMMAND}`);
+    return new CliError(`Your saved Wensity login was not accepted (${upstream?.message ?? error.message}).
+Log in again: ${LOGIN_COMMAND}`);
+  }
+  if (error.code === "network_error") {
+    return new CliError(`Could not reach Wensity to get ${what}. Check your connection and try again.
+${error.message}`);
+  }
+  if (error.code === "rate_limited") {
+    return new CliError(`Too many requests right now. Wait a minute and try again.`);
+  }
+  return error;
+}
+function explicitAgents(argv) {
+  const values = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--agent") {
+      const value = argv[index + 1];
+      if (!value || value.startsWith("--")) throw new CliError("--agent expects claude or agents.");
+      values.push(value);
+      index += 1;
+    } else if (token.startsWith("--agent=")) {
+      values.push(token.slice("--agent=".length));
+    }
+  }
+  const agents = values.flatMap((value) => value.split(",")).filter(Boolean).map((value) => parseSkillAgent(value));
+  return SKILL_AGENTS.filter((agent) => agents.includes(agent));
+}
+async function chooseAgents(setup) {
+  const explicit = explicitAgents(setup.context.argv);
+  if (explicit.length > 0) return explicit;
+  const detected = detectSkillAgents(setup.root);
+  if (detected.length > 0) return detected;
+  const interactive = stdin2.isTTY === true && stdout2.isTTY === true && !hasFlag(setup.parsed, "yes");
+  if (!interactive) return [...SKILL_AGENTS];
+  const where = setup.global ? "in your home folder" : "in this project";
+  const rl = createInterface({ input: stdin2, output: stdout2 });
+  try {
+    const answer = await rl.question(
+      [
+        `No agent folders found ${where}. Which agents should get the skills?`,
+        `  1) ${SKILL_AGENT_LABELS.claude} (${SKILL_AGENT_DIRS.claude})`,
+        `  2) ${SKILL_AGENT_LABELS.agents} (${SKILL_AGENT_DIRS.agents})`,
+        "  3) Both",
+        "Choose 1, 2 or 3 [3]: "
+      ].join("\n")
+    );
+    const choice = answer.trim();
+    if (choice === "1") return ["claude"];
+    if (choice === "2") return ["agents"];
+    return [...SKILL_AGENTS];
+  } finally {
+    rl.close();
+  }
+}
+async function addSkills(setup, names) {
+  const all = hasFlag(setup.parsed, "all");
+  if (!all && names.length === 0) throw new CliError(`Name at least one skill, or use --all.
+
+${SKILLS_USAGE}`);
+  if (all && names.length > 0) throw new CliError("Use either skill names or --all, not both.");
+  const index = await fetchIndex(setup);
+  let wanted = all ? [...index.skills] : resolveSkillNames(index, names);
+  const notes = [];
+  const token = wanted.some((skill) => skill.tier === "pro") ? await savedToken(setup) : void 0;
+  const pro = wanted.filter((skill) => skill.tier === "pro");
+  if (pro.length > 0 && !token) {
+    if (!all) {
+      throw new CliError(
+        `${pro.map((skill) => skill.name).join(", ")} ${pro.length === 1 ? "comes" : "come"} with Wensity Pro. Log in first: ${LOGIN_COMMAND}
+Pricing: ${pricingBlue(PRICING_URL2)}`
+      );
+    }
+    wanted = wanted.filter((skill) => skill.tier !== "pro");
+    notes.push(`Pro skills were left out. Log in to add them: ${LOGIN_COMMAND}`);
+  }
+  const { payloads, proDenied } = await downloadSkills(setup, wanted, token, { verb: "Downloading", skipProWhenDenied: all });
+  if (proDenied) notes.push(`Pro skills were left out: ${proDenied}`);
+  const agents = await chooseAgents(setup);
+  await withInstallLock(setup, async () => {
+    const lock = await readSkillLock(setup.lockPath);
+    const plans = payloads.map(
+      (payload) => planSkillInstall({ root: setup.root, payload, agents, previous: lock.skills[payload.name], force: setup.force })
+    );
+    assertNoConflicts2(plans);
+    if (setup.dryRun) return printPlans(setup, plans, "Skills install preview", notes);
+    await commit(setup, plans, lock);
+    printPlans(setup, plans, payloads.length === 1 ? "Skill installed" : "Skills installed", notes);
+    printNextStep(setup, agents);
+    printUpdateNudge(setup, index, lock, payloads.map((payload) => payload.name));
+  });
+}
+async function withInstallLock(setup, task) {
+  if (setup.dryRun) return task();
+  const lock = acquireInstallLock(setup.root, { planId: `skills_${randomBytes2(8).toString("hex")}` });
+  try {
+    return await task();
+  } finally {
+    lock.release();
+  }
+}
+function assertNoConflicts2(plans) {
+  const conflicts = plans.flatMap((plan) => plan.outcomes.filter((outcome) => outcome.status === "conflict").map((outcome) => outcome.relativePath));
+  if (conflicts.length > 0) {
+    throw new WensityError(
+      "file_conflict",
+      `These files are already there and were not written by Wensity. Nothing was changed. Use --force to replace them:
+${conflicts.map((path) => `  - ${path}`).join("\n")}`
+    );
+  }
+}
+async function commit(setup, plans, lock) {
+  const writes = plans.flatMap((plan) => plan.writes);
+  if (writes.length > 0) {
+    const result = await apply({ projectRoot: setup.root, planId: `skills_${randomBytes2(8).toString("hex")}`, files: writes });
+    if (result.status !== "committed") {
+      const where = result.failedPath ? ` while writing ${result.failedPath}` : "";
+      const reverted = result.status === "rolled_back" ? "every file was put back as it was" : `some files could not be restored; see ${result.journalPath}`;
+      throw new WensityError(result.error.code, `Installing skills failed${where}; ${reverted}.
+${result.error.message}`);
+    }
+    if (result.cleanupWarning) warn(result.cleanupWarning);
+  }
+  await deleteSkillFiles(
+    setup.root,
+    plans.flatMap((plan) => plan.deletes),
+    plans.flatMap((plan) => SKILL_AGENTS.filter((agent) => plan.entry.targets[agent]).map((agent) => skillFolder(agent, plan.name)))
+  );
+  for (const plan of plans) lock.skills[plan.name] = plan.entry;
+  await writeSkillLock(setup.lockPath, lock);
+}
+async function updateSkills(setup, names) {
+  const lock = await readSkillLock(setup.lockPath);
+  const installed = Object.keys(lock.skills);
+  if (installed.length === 0) {
+    throw new CliError(`No Wensity skills are installed ${setup.global ? "globally" : "in this project"}. Add one with: npx wensity@latest skills add <name>`);
+  }
+  const index = await fetchIndex(setup);
+  const wanted = names.length === 0 ? index.skills.filter((skill) => installed.includes(skill.name)) : resolveSkillNames(index, names);
+  const missing = wanted.filter((skill) => !lock.skills[skill.name]);
+  if (missing.length > 0) {
+    throw new CliError(`${missing.map((skill) => skill.name).join(", ")} ${missing.length === 1 ? "is" : "are"} not installed here. Add with: npx wensity@latest skills add ${missing.map((skill) => skill.name.replace(/^wensity-/, "")).join(" ")}`);
+  }
+  const gone = installed.filter((name) => names.length === 0 && !index.skills.some((skill) => skill.name === name));
+  const notes = gone.map((name) => `${name} is no longer in the pack. It was left as it is; remove it with: npx wensity@latest skills remove ${name}`);
+  const token = wanted.some((skill) => skill.tier === "pro") ? await savedToken(setup) : void 0;
+  const lockedPro = wanted.filter((skill) => skill.tier === "pro");
+  if (lockedPro.length > 0 && !token) {
+    throw new CliError(`Updating ${lockedPro.map((skill) => skill.name).join(", ")} needs your Wensity Pro login. Log in first: ${LOGIN_COMMAND}`);
+  }
+  const { payloads } = await downloadSkills(setup, wanted, token, { verb: "Checking", skipProWhenDenied: false });
+  await withInstallLock(setup, async () => {
+    const current = await readSkillLock(setup.lockPath);
+    const plans = payloads.map((payload) => {
+      const previous = current.skills[payload.name] ?? lock.skills[payload.name];
+      const agents2 = SKILL_AGENTS.filter((agent) => previous.targets[agent]);
+      return planSkillInstall({ root: setup.root, payload, agents: agents2, previous, force: setup.force });
+    });
+    assertNoConflicts2(plans);
+    if (setup.dryRun) {
+      printPlans(setup, plans, "Skills update preview", notes);
+      printChanges(index, plans);
+      return;
+    }
+    await commit(setup, plans, current);
+    const changed = plans.some((plan) => plan.writes.length > 0 || plan.deletes.length > 0 || plan.previousVersion !== plan.version);
+    printPlans(setup, plans, changed ? "Skills updated" : "Skills are up to date", notes);
+    printChanges(index, plans);
+    const agents = SKILL_AGENTS.filter((agent) => plans.some((plan) => plan.entry.targets[agent]));
+    if (changed) printNextStep(setup, agents);
+    printUpdateNudge(setup, index, current, plans.map((plan) => plan.name));
+  });
+}
+async function removeSkills(setup, names) {
+  if (names.length === 0) throw new CliError(`Name at least one skill to remove.
+
+${SKILLS_USAGE}`);
+  const lock = await readSkillLock(setup.lockPath);
+  const byAlias = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(lock.skills)) {
+    byAlias.set(name, name);
+    byAlias.set(name.replace(/^wensity-/, ""), name);
+  }
+  let resolved = [];
+  const unresolved = names.filter((input) => {
+    const name = byAlias.get(input.trim().toLowerCase());
+    if (name && !resolved.includes(name)) resolved.push(name);
+    return !name;
+  });
+  if (unresolved.length > 0) {
+    const index = await fetchIndex(setup).catch(() => void 0);
+    const known = index ? resolveSkillNames(index, unresolved) : [];
+    const notInstalled = known.filter((skill) => !lock.skills[skill.name]);
+    if (!index || notInstalled.length > 0) {
+      const label = index ? notInstalled.map((skill) => skill.name).join(", ") : unresolved.join(", ");
+      throw new CliError(`${label} ${index && notInstalled.length === 1 ? "is" : "are"} not installed ${setup.global ? "globally" : "in this project"}.`);
+    }
+    resolved = [...resolved, ...known.map((skill) => skill.name).filter((name) => !resolved.includes(name))];
+  }
+  await withInstallLock(setup, async () => {
+    const current = await readSkillLock(setup.lockPath);
+    const plans = resolved.filter((name) => current.skills[name]).map((name) => planSkillRemove(setup.root, name, current.skills[name]));
+    printTitle(setup.dryRun ? "Skills remove preview" : "Skills removed");
+    for (const plan of plans) {
+      const removed = plan.outcomes.filter((outcome) => outcome.status === "removed");
+      const kept = plan.outcomes.filter((outcome) => outcome.status === "kept");
+      if (removed.length > 0) {
+        print(success(`${setup.dryRun ? "Would remove" : "Removed"} ${plan.name} (${removed.length} ${removed.length === 1 ? "file" : "files"})`));
+      } else {
+        print(success(`${setup.dryRun ? "Would stop" : "Stopped"} tracking ${plan.name}`));
+      }
+      if (kept.length > 0) {
+        warn(`${plan.name}: you edited ${kept.length === 1 ? "this file" : "these files"}, so ${kept.length === 1 ? "it was" : "they were"} left in place:
+${formatList(kept.map((outcome) => outcome.relativePath))}`);
+      }
+    }
+    if (setup.dryRun) return;
+    for (const plan of plans) {
+      await deleteSkillFiles(setup.root, plan.deletes, plan.folders);
+      delete current.skills[plan.name];
+    }
+    await writeSkillLock(setup.lockPath, current);
+  });
+}
+async function listSkills(setup) {
+  const [index, lock] = await Promise.all([fetchIndex(setup), readSkillLock(setup.lockPath)]);
+  const rows = index.skills.map((skill) => {
+    const entry = lock.skills[skill.name];
+    const status = !entry ? "" : entry.version === skill.version ? "Up to date" : "Update available";
+    return { skill, entry, status };
+  });
+  if (hasFlag(setup.parsed, "json")) {
+    printJson({
+      pack: index.pack,
+      scope: setup.global ? "global" : "project",
+      skills: rows.map(({ skill, entry, status }) => ({
+        name: skill.name,
+        aliases: skillAliases(skill),
+        tier: skill.tier,
+        title: skill.title,
+        latestVersion: skill.version,
+        installedVersion: entry?.version ?? null,
+        agents: entry ? SKILL_AGENTS.filter((agent) => entry.targets[agent]) : [],
+        updateAvailable: status === "Update available"
+      }))
+    });
+    return;
+  }
+  printTitle(index.pack.title, index.pack.version);
+  print(
+    table(
+      ["Skill", "Title", "Access", "Installed", "Latest", "Status"],
+      rows.map(({ skill, entry, status }) => [
+        skill.name.replace(/^wensity-/, ""),
+        skill.title,
+        badge(skill.tier === "pro" ? "Pro" : "Free", skill.tier),
+        entry?.version ?? "-",
+        skill.version,
+        status
+      ])
+    )
+  );
+  const updates = rows.filter((row) => row.status === "Update available").length;
+  print(
+    nextSteps([
+      updates > 0 ? `Update installed skills: npx wensity@latest skills update${setup.global ? " --global" : ""}` : "Add a skill: npx wensity@latest skills add <skill>",
+      `Pro skills need a login: ${LOGIN_COMMAND}`
+    ])
+  );
+}
+var STATUS_WORDS = {
+  added: "added",
+  updated: "updated",
+  unchanged: "unchanged",
+  skipped: "skipped (you edited it)",
+  removed: "removed",
+  kept: "kept (you edited it)"
+};
+function printPlans(setup, plans, title, notes) {
+  printTitle(title, setup.global ? "global" : toPosixPath(setup.root));
+  for (const plan of plans) {
+    const counts = /* @__PURE__ */ new Map();
+    for (const outcome of plan.outcomes) counts.set(outcome.status, (counts.get(outcome.status) ?? 0) + 1);
+    const summary = Object.keys(STATUS_WORDS).filter((status) => counts.has(status)).map((status) => `${counts.get(status)} ${STATUS_WORDS[status]}`).join(", ");
+    const versions = plan.previousVersion && plan.previousVersion !== plan.version ? `${plan.previousVersion} to ${plan.version}` : plan.version;
+    const agents = SKILL_AGENTS.filter((agent) => plan.outcomes.some((outcome) => outcome.agent === agent)).map((agent) => SKILL_AGENT_DIRS[agent]).join(", ");
+    print(success(`${plan.name} ${versions} in ${agents}: ${summary}`));
+    const changed = plan.outcomes.filter((outcome) => outcome.status !== "unchanged");
+    if (setup.dryRun && changed.length > 0) {
+      print(formatList(changed.map((outcome) => `${outcome.relativePath}  ${STATUS_WORDS[outcome.status] ?? outcome.status}`)));
+    }
+    const skipped = plan.outcomes.filter((outcome) => outcome.status === "skipped" || outcome.status === "kept");
+    if (skipped.length > 0) {
+      warn(`${plan.name}: left your edited ${skipped.length === 1 ? "file" : "files"} as ${skipped.length === 1 ? "it is" : "they are"}. Use --force to replace:
+${formatList(skipped.map((outcome) => outcome.relativePath))}`);
+    }
+  }
+  if (setup.dryRun) print(action("Dry run: nothing was written."));
+  for (const note of notes) warn(note);
+}
+function printChanges(index, plans) {
+  for (const plan of plans) {
+    if (!plan.previousVersion || plan.previousVersion === plan.version) continue;
+    const skill = index.skills.find((entry) => entry.name === plan.name);
+    const changes = skill ? changesBetween(skill, plan.previousVersion, plan.version) : [];
+    if (changes.length === 0) continue;
+    print(action(`What changed in ${plan.name}:`));
+    print(formatList(changes.flatMap((change) => change.notes.map((note) => `${change.version}  ${note}`))));
+  }
+}
+function printUpdateNudge(setup, index, lock, except) {
+  const outdated = skillsWithUpdates(index, lock, except);
+  if (outdated.length === 0) return;
+  const what = outdated.length === 1 ? `${outdated[0].name} has an update` : `${outdated.length} skills have updates`;
+  print(action(`${what}. Run: npx wensity@latest skills update${setup.global ? " --global" : ""}`));
+}
+function printNextStep(setup, agents) {
+  const steps = [];
+  if (agents.includes("claude")) steps.push("Restart Claude Code to load new skills.");
+  if (agents.includes("agents")) steps.push("Start a new session in your agent to load new skills.");
+  print(nextSteps(steps));
+}
+
 // src/commands.ts
 async function run(context) {
   const parsed = parseArgs(context.argv);
@@ -6203,6 +7144,9 @@ async function run(context) {
     case "update":
       await addCommand(context, parsed, positionals, true);
       return;
+    case "skills":
+      await skillsCommand(context, parsed, positionals);
+      return;
     case "version":
       print(CLI_VERSION);
       return;
@@ -6271,7 +7215,7 @@ async function initCommand(context, parsed) {
   const templateFiles = template ? await scaffoldProjectTemplate(context.cwd, template, { dryRun, force }) : [];
   const packageManagerFiles = template ? prepareProjectPackageManager(context.cwd, { ...installOptions, dryRun }) : [];
   const config = template ? applyTemplateToConfig(createDefaultConfig(context.cwd, apiUrl), template) : createDefaultConfig(context.cwd, apiUrl);
-  const configPath = join11(context.cwd, CONFIG_FILE_NAME);
+  const configPath = join13(context.cwd, CONFIG_FILE_NAME);
   const utilityPath = resolveConfiguredFilePath(context.cwd, config.utils);
   const utilityRelativePath = toPosixPath(config.utils.endsWith(".ts") ? config.utils : `${config.utils}.ts`);
   if (dryRun) {
@@ -6321,7 +7265,7 @@ async function initWithPreset(context, options) {
     presetCode: options.presetCode,
     presetFile: options.presetFile
   });
-  const configPath = join11(context.cwd, CONFIG_FILE_NAME);
+  const configPath = join13(context.cwd, CONFIG_FILE_NAME);
   const configExists = await fileExists(configPath);
   const templateFiles = options.template ? await scaffoldProjectTemplate(context.cwd, options.template, {
     dryRun: options.dryRun,
@@ -6541,7 +7485,7 @@ async function preparePresetStyleApplication(projectRoot, config, style, operati
     throw new CliError("No Tailwind CSS path configured. Set tailwind.css in wensity.json.");
   }
   const cssAbsolute = resolveInside(projectRoot, cssRelative);
-  const existingCss = await fileExists(cssAbsolute) ? await readFile8(cssAbsolute, "utf8") : "";
+  const existingCss = await fileExists(cssAbsolute) ? await readFile9(cssAbsolute, "utf8") : "";
   const withBase = upsertBaseCssBlock(existingCss, buildBaseCssBlock(baseColorFromStyle(style)));
   const withTokens = upsertPrimitiveCssBlock(withBase, primitiveCss);
   const nextCss = upsertFontImportBlock(withTokens, fontPlan.block);
@@ -6780,11 +7724,11 @@ async function writeWithRollback(projectRoot, files) {
   }
   const result = await apply({
     projectRoot,
-    planId: `cli_${randomBytes(8).toString("hex")}`,
+    planId: `cli_${randomBytes3(8).toString("hex")}`,
     files: [...byPath.values()].map((file) => ({
       relativePath: toPosixPath(relative8(projectRoot, file.absolutePath)),
       content: file.content,
-      action: existsSync5(file.absolutePath) ? file.kind === "config" ? "modify" : "overwrite" : "create"
+      action: existsSync6(file.absolutePath) ? file.kind === "config" ? "modify" : "overwrite" : "create"
     }))
   });
   if (result.status === "committed") {
@@ -6906,8 +7850,8 @@ function formatAccountPanel(whoami, savedPath) {
   return panel(isPro ? "Wensity Pro" : "Wensity Free", lines);
 }
 async function writeTextFile(path, content) {
-  await mkdir7(dirname8(path), { recursive: true });
-  await writeFile6(path, content, "utf8");
+  await mkdir8(dirname9(path), { recursive: true });
+  await writeFile7(path, content, "utf8");
 }
 function installOptionsFrom(context, parsed) {
   return {
@@ -6918,7 +7862,7 @@ function installOptionsFrom(context, parsed) {
 async function assertInitPostconditions(projectRoot, relativePaths) {
   const missing = [];
   for (const relativePath of new Set(relativePaths)) {
-    const absolute = join11(projectRoot, relativePath);
+    const absolute = join13(projectRoot, relativePath);
     let size = 0;
     try {
       size = (await stat(absolute)).size;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wensity",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Install React components, UI primitives, and shareable Tailwind CSS presets into your Next.js project as source code you own.",
   "license": "MIT",
   "author": "Wensity <hey@wensity.com> (https://wensity.com)",
@@ -53,7 +53,7 @@
     "lucide-react": "^1.24.0",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2",
-    "vitest": "^4.1.5"
+    "vitest": "^4.1.12"
   },
   "publishConfig": {
     "access": "public"