rush-ai 0.14.1 → 0.16.0

package/dist/index.js

@@ -214,7 +214,7 @@ Built-in default agents (see --default):
   web-builder       site / landing-page builder (returns previewUrl + gitRepoUrl)
   skill-publisher   publishes reusable skills back onto the platform
 
-For agents: run \`rush-ai skill agent-shelf\` for the full playbook.
+For agents: run \`rush-ai playbook agent-shelf\` for the full playbook.
 `;
 function registerAgentCommand(program) {
   const agent = program.command("agent").description("Manage and inspect agents").addHelpText("after", AGENT_HELP_AFTER);
@@ -327,10 +327,9 @@ function registerAgentCommand(program) {
         } catch {
         }
         const candidates = parsed?.candidates;
-        const isValid = Array.isArray(candidates) && candidates.length > 0 && candidates.every(
+        if (Array.isArray(candidates) && candidates.length > 0 && candidates.every(
           (c) => typeof c.id === "string" && typeof c.name === "string"
-        );
-        if (isValid) {
+        )) {
           if (format === "json") {
             output.log(JSON.stringify(parsed, null, 2));
             process.exitCode = 1;
@@ -1410,13 +1409,15 @@ ${MARKER_BEGIN}
 _rush_cli_completion() {
   local cur="\${COMP_WORDS[COMP_CWORD]}"
   local prev="\${COMP_WORDS[COMP_CWORD-1]}"
-  local cmds="auth agent task mcp plugin completion config doctor"
+  local cmds="auth agent task skill playbook mcp plugin completion config doctor"
 
   case "$prev" in
     rush-ai) COMPREPLY=( $(compgen -W "$cmds" -- "$cur") ) ;;
     auth) COMPREPLY=( $(compgen -W "login logout status" -- "$cur") ) ;;
     agent) COMPREPLY=( $(compgen -W "list info" -- "$cur") ) ;;
     task) COMPREPLY=( $(compgen -W "run create status result list watch cancel" -- "$cur") ) ;;
+    skill) COMPREPLY=( $(compgen -W "init find install list info update outdated uninstall publish group doctor" -- "$cur") ) ;;
+    playbook) COMPREPLY=( $(compgen -W "hand-off agent-shelf" -- "$cur") ) ;;
     plugin) COMPREPLY=( $(compgen -W "install list status update uninstall" -- "$cur") ) ;;
     completion) COMPREPLY=( $(compgen -W "install bash zsh fish" -- "$cur") ) ;;
     config) COMPREPLY=( $(compgen -W "show set use create delete list" -- "$cur") ) ;;
@@ -1432,6 +1433,8 @@ _rush_cli_completion() {
     'auth:Authentication commands'
     'agent:Agent management'
     'task:Task operations'
+    'skill:Skill package management'
+    'playbook:Agent usage playbooks'
     'mcp:MCP server'
     'plugin:Plugin management'
     'completion:Shell completion'
@@ -1447,6 +1450,8 @@ ${MARKER_BEGIN}
 complete -c rush-ai -n '__fish_use_subcommand' -a auth -d 'Authentication'
 complete -c rush-ai -n '__fish_use_subcommand' -a agent -d 'Agent management'
 complete -c rush-ai -n '__fish_use_subcommand' -a task -d 'Task operations'
+complete -c rush-ai -n '__fish_use_subcommand' -a skill -d 'Skill package management'
+complete -c rush-ai -n '__fish_use_subcommand' -a playbook -d 'Agent usage playbooks'
 complete -c rush-ai -n '__fish_use_subcommand' -a mcp -d 'MCP server'
 complete -c rush-ai -n '__fish_use_subcommand' -a plugin -d 'Plugin management'
 complete -c rush-ai -n '__fish_use_subcommand' -a completion -d 'Shell completion'
@@ -1455,6 +1460,8 @@ complete -c rush-ai -n '__fish_use_subcommand' -a doctor -d 'System diagnostics'
 complete -c rush-ai -n '__fish_seen_subcommand_from auth' -a 'login logout status'
 complete -c rush-ai -n '__fish_seen_subcommand_from agent' -a 'list info'
 complete -c rush-ai -n '__fish_seen_subcommand_from task' -a 'run create status result list watch cancel'
+complete -c rush-ai -n '__fish_seen_subcommand_from skill' -a 'init find install list info update outdated uninstall publish group doctor'
+complete -c rush-ai -n '__fish_seen_subcommand_from playbook' -a 'hand-off agent-shelf'
 complete -c rush-ai -n '__fish_seen_subcommand_from plugin' -a 'install list status update uninstall'
 complete -c rush-ai -n '__fish_seen_subcommand_from completion' -a 'install bash zsh fish'
 complete -c rush-ai -n '__fish_seen_subcommand_from config' -a 'show set use create delete list'
@@ -1507,7 +1514,8 @@ function registerCompletionCommand(program) {
     if (shell === "fish") {
       try {
         await mkdir(dirname(rcFile), { recursive: true });
-        await writeFile(rcFile, script + "\n");
+        await writeFile(rcFile, `${script}
+`);
         output.success(`Fish completion installed to ${rcFile}`);
       } catch {
         output.error(`Failed to write to ${rcFile}`);
@@ -1527,7 +1535,9 @@ function registerCompletionCommand(program) {
     } catch {
     }
     try {
-      await appendFile(rcFile, "\n" + script + "\n");
+      await appendFile(rcFile, `
+${script}
+`);
       output.success(`Completion installed to ${rcFile}`);
       output.dim(
         `  Run \`source ${rcFile}\` or restart your shell to activate.`
@@ -4290,8 +4300,80 @@ function registerMcpCommand(program) {
   });
 }
 
+// src/commands/playbook/index.ts
+import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync7 } from "fs";
+import { basename as basename2, resolve as resolve9 } from "path";
+var PLAYBOOK_DESCRIPTION = "Print agent usage playbooks (hand-off, agent-shelf, ...) as raw markdown.";
+var PLAYBOOK_HELP_AFTER = `
+Examples:
+  $ npx rush-ai playbook                  Print the playbook index
+  $ npx rush-ai playbook hand-off         Print the hand-off playbook
+  $ npx rush-ai playbook agent-shelf      Print the agent-shelf playbook
+  $ npx rush-ai playbook --list           List available playbooks
+
+Designed to be consumed by AI agents inside IDEs (Cursor, Claude Code,
+Codex, etc). Output is raw markdown on stdout \u2014 pipe it, grep it, feed it
+to your own context.
+`;
+function resolvePlaybooksDir() {
+  const baseDir = import.meta.dirname ?? __dirname;
+  if (!baseDir) return null;
+  const candidates = [
+    resolve9(baseDir, "skills"),
+    resolve9(baseDir, "..", "skills"),
+    resolve9(baseDir, "..", "..", "skills"),
+    resolve9(baseDir, "..", "..", "..", "skills"),
+    resolve9(baseDir, "..", "..", "..", "..", "skills")
+  ];
+  for (const p of candidates) {
+    if (existsSync11(resolve9(p, ".rush-playbooks"))) return p;
+  }
+  return null;
+}
+function listPlaybooks(dir) {
+  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => basename2(f, ".md")).sort();
+}
+function getAvailablePlaybooks() {
+  const dir = resolvePlaybooksDir();
+  return dir ? listPlaybooks(dir) : [];
+}
+function isPlaybookName(name) {
+  if (!name) return false;
+  return getAvailablePlaybooks().includes(name);
+}
+function printPlaybook(name, opts = {}) {
+  const dir = resolvePlaybooksDir();
+  if (!dir) {
+    output.error(
+      "Could not locate the skills/ directory. This is a packaging bug \u2014 please file an issue."
+    );
+    process.exit(2);
+    return;
+  }
+  const available = listPlaybooks(dir);
+  if (opts.list) {
+    for (const s of available) output.log(s);
+    return;
+  }
+  const target = name ?? "README";
+  const file2 = resolve9(dir, `${target}.md`);
+  if (!existsSync11(file2)) {
+    output.error(`Unknown playbook "${target}".`);
+    output.dim(`Available: ${available.join(", ") || "(none)"}`);
+    process.exit(1);
+    return;
+  }
+  process.stdout.write(readFileSync7(file2, "utf-8"));
+}
+function registerPlaybookCommand(program) {
+  program.command("playbook [name]").description(PLAYBOOK_DESCRIPTION).addHelpText("after", PLAYBOOK_HELP_AFTER).option("--list", "List available playbook names and exit").action((name, opts) => {
+    printPlaybook(name, opts);
+  });
+}
+
 // src/commands/plugin/install.ts
-import { resolve as resolve20 } from "path";
+import { rm as rm12 } from "fs/promises";
+import { resolve as resolve21 } from "path";
 
 // src/installers/claude-code/installer.ts
 import { randomUUID as randomUUID4 } from "crypto";
@@ -4309,7 +4391,7 @@ import {
   unlink
 } from "fs/promises";
 import { homedir as homedir5 } from "os";
-import { dirname as dirname4, join as join9, resolve as resolve10 } from "path";
+import { dirname as dirname4, join as join9, resolve as resolve11 } from "path";
 
 // src/installers/claude-code/mcp.ts
 import { execFileSync as execFileSync5 } from "child_process";
@@ -4361,7 +4443,7 @@ function defaultRushBinaryResolver() {
 }
 
 // src/installers/claude-code/paths.ts
-import { resolve as resolve9 } from "path";
+import { resolve as resolve10 } from "path";
 var CLAUDE_DIR = ".claude";
 var PLUGINS_SUBDIR = "plugins";
 var CACHE_SUBDIR = "cache";
@@ -4379,27 +4461,27 @@ var ClaudeCodePaths = class {
   }
   /** `<home>/.claude/` */
   get claudeDir() {
-    return resolve9(this.home, CLAUDE_DIR);
+    return resolve10(this.home, CLAUDE_DIR);
   }
   /** `<home>/.claude/settings.json` */
   get settingsJson() {
-    return resolve9(this.claudeDir, "settings.json");
+    return resolve10(this.claudeDir, "settings.json");
   }
   /** `<home>/.claude/plugins/` */
   get pluginsDir() {
-    return resolve9(this.claudeDir, PLUGINS_SUBDIR);
+    return resolve10(this.claudeDir, PLUGINS_SUBDIR);
   }
   /** `<home>/.claude/plugins/known_marketplaces.json` */
   get knownMarketplacesJson() {
-    return resolve9(this.pluginsDir, "known_marketplaces.json");
+    return resolve10(this.pluginsDir, "known_marketplaces.json");
   }
   /** `<home>/.claude/plugins/installed_plugins.json` */
   get installedPluginsJson() {
-    return resolve9(this.pluginsDir, "installed_plugins.json");
+    return resolve10(this.pluginsDir, "installed_plugins.json");
   }
   /** `<home>/.claude/plugins/cache/` */
   get cacheDir() {
-    return resolve9(this.pluginsDir, CACHE_SUBDIR);
+    return resolve10(this.pluginsDir, CACHE_SUBDIR);
   }
   /**
    * `<home>/.claude/plugins/marketplaces/`。
@@ -4409,34 +4491,34 @@ var ClaudeCodePaths = class {
    * Claude Code 会识别不到 plugin 条目（regression fix，bug #4）。
    */
   get marketplacesRootDir() {
-    return resolve9(this.pluginsDir, "marketplaces");
+    return resolve10(this.pluginsDir, "marketplaces");
   }
   /** `<home>/.claude/plugins/marketplaces/<mkt>/` */
   marketplaceInstallDir(marketplace) {
-    return resolve9(this.marketplacesRootDir, marketplace);
+    return resolve10(this.marketplacesRootDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/` */
   marketplaceCacheDir(marketplace) {
-    return resolve9(this.cacheDir, marketplace);
+    return resolve10(this.cacheDir, marketplace);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/` */
   pluginCacheDir(ref) {
-    return resolve9(this.marketplaceCacheDir(ref.marketplace), ref.name);
+    return resolve10(this.marketplaceCacheDir(ref.marketplace), ref.name);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/` */
   pluginVersionDir(ref, version) {
-    return resolve9(this.pluginCacheDir(ref), version);
+    return resolve10(this.pluginCacheDir(ref), version);
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/.claude-plugin/plugin.json` */
   pluginManifestPath(ref, version) {
-    return resolve9(
+    return resolve10(
       this.pluginVersionDir(ref, version),
       PLUGIN_MANIFEST_RELATIVE
     );
   }
   /** `<home>/.claude/plugins/cache/<mkt>/<plugin>/<version>/<capability>/` */
   capabilityDir(ref, version, capability) {
-    return resolve9(this.pluginVersionDir(ref, version), capability);
+    return resolve10(this.pluginVersionDir(ref, version), capability);
   }
 };
 function pluginKey(ref) {
@@ -4518,7 +4600,7 @@ var ClaudeCodeInstaller = class {
     const { ref, version } = plugin;
     const pluginVersionDir = this.paths.pluginVersionDir(ref, version);
     const key = pluginKey(ref);
-    if (!opts.force) {
+    if (!opts.force && version !== "unknown") {
       let already = false;
       try {
         already = await this.isAlreadyInstalledAtVersion(ref, version);
@@ -4553,7 +4635,7 @@ var ClaudeCodeInstaller = class {
       await mkdir5(pluginVersionDir, { recursive: true });
       writtenFiles.push(pluginVersionDir);
       for (const cap of CAPABILITY_DIRS) {
-        const srcDir = resolve10(plugin.sourceDir, cap);
+        const srcDir = resolve11(plugin.sourceDir, cap);
         if (!await dirExists(srcDir)) continue;
         const dstDir = this.paths.capabilityDir(ref, version, cap);
         await mkdir5(dstDir, { recursive: true });
@@ -4767,8 +4849,8 @@ var ClaudeCodeInstaller = class {
     const kind = await inodeKind(mktDir);
     if (kind === "symlink") {
       const target = await readlink(mktDir).catch(() => null);
-      const resolvedTarget = target !== null ? resolve10(dirname4(mktDir), target) : null;
-      if (resolvedTarget && resolvedTarget === resolve10(src.rootDir)) {
+      const resolvedTarget = target !== null ? resolve11(dirname4(mktDir), target) : null;
+      if (resolvedTarget && resolvedTarget === resolve11(src.rootDir)) {
         return { written: false, path: mktDir };
       }
       throw new Error(
@@ -4837,7 +4919,7 @@ var ClaudeCodeInstaller = class {
     const pluginVersionDir = this.paths.pluginVersionDir(ref, version);
     const dryFiles = [pluginVersionDir];
     for (const cap of CAPABILITY_DIRS) {
-      const srcDir = resolve10(plugin.sourceDir, cap);
+      const srcDir = resolve11(plugin.sourceDir, cap);
       if (!await dirExists(srcDir)) continue;
       const dstDir = this.paths.capabilityDir(ref, version, cap);
       dryFiles.push(dstDir);
@@ -5470,11 +5552,11 @@ import {
 } from "fs/promises";
 import { homedir as homedir6 } from "os";
 import {
-  basename as basename2,
+  basename as basename3,
   dirname as dirname6,
   extname,
   relative as pathRelative,
-  resolve as resolve11
+  resolve as resolve12
 } from "path";
 
 // src/installers/codex/mcp.ts
@@ -5837,7 +5919,7 @@ var CodexInstaller = class {
       };
     }
     const ref = plugin.ref;
-    if (!opts.force && await this.isInstalled(ref)) {
+    if (!opts.force && plugin.version !== "unknown" && await this.isInstalled(ref)) {
       const existingVersion = await detectInstalledVersion(this.home, ref);
       if (existingVersion?.version === plugin.version) {
         return {
@@ -6115,10 +6197,10 @@ var CodexInstaller = class {
     const srcMcp = plugin.manifest.mcpServers;
     if (srcMcp !== void 0 && srcMcp !== null) {
       if (typeof srcMcp === "string") {
-        const destPath = resolve11(versionDir, srcMcp);
+        const destPath = resolve12(versionDir, srcMcp);
         files.push(destPath);
-        const srcPath = resolve11(plugin.sourceDir, srcMcp);
-        const rel = pathRelative(resolve11(plugin.sourceDir), srcPath);
+        const srcPath = resolve12(plugin.sourceDir, srcMcp);
+        const rel = pathRelative(resolve12(plugin.sourceDir), srcPath);
         const traversal = rel === ".." || rel.startsWith("..") || rel.startsWith("/");
         const exists = await pathExists5(srcPath);
         if (traversal || !exists) {
@@ -6263,13 +6345,13 @@ function assertSafePathComponents(ref, version) {
 }
 async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
   if (typeof relativeRef !== "string" || relativeRef.length === 0) return null;
-  const srcPath = resolve11(sourceDir, relativeRef);
-  const rel = pathRelative(resolve11(sourceDir), srcPath);
+  const srcPath = resolve12(sourceDir, relativeRef);
+  const rel = pathRelative(resolve12(sourceDir), srcPath);
   if (rel === ".." || rel.startsWith("..") || rel.startsWith("/")) {
     return null;
   }
   if (!await pathExists5(srcPath)) return null;
-  const destPath = resolve11(versionDir, relativeRef);
+  const destPath = resolve12(versionDir, relativeRef);
   await mkdir7(dirname6(destPath), { recursive: true });
   const raw = await readFile7(srcPath, "utf8");
   await writeFileAtomic(destPath, raw);
@@ -6286,13 +6368,13 @@ async function copyAuthorProvidedMcp(sourceDir, versionDir, relativeRef) {
 }
 async function writeCodexMarketplaceMirror(input) {
   const pluginParent = dirname6(input.pluginDir);
-  const pluginBase = basename2(input.pluginDir);
+  const pluginBase = basename3(input.pluginDir);
   await mkdir7(pluginParent, { recursive: true });
   const tmpPluginDir = await mkdtemp(
-    resolve11(pluginParent, `.${pluginBase}.tmp-`)
+    resolve12(pluginParent, `.${pluginBase}.tmp-`)
   );
   const backupPluginDir = await mkdtemp(
-    resolve11(pluginParent, `.${pluginBase}.bak-`)
+    resolve12(pluginParent, `.${pluginBase}.bak-`)
   );
   let hadExistingPluginDir = false;
   let swappedPluginDir = false;
@@ -6325,7 +6407,7 @@ async function writeCodexMarketplaceMirror(input) {
       try {
         if (await pathExists5(input.pluginDir)) {
           displacedPluginDir = await mkdtemp(
-            resolve11(pluginParent, `.${pluginBase}.failed-`)
+            resolve12(pluginParent, `.${pluginBase}.failed-`)
           );
           await rm7(displacedPluginDir, { recursive: true, force: true });
           await rename6(input.pluginDir, displacedPluginDir);
@@ -6412,7 +6494,7 @@ async function planCodexSkills(plugin) {
   const usedNames = /* @__PURE__ */ new Set();
   const coveredAliases = /* @__PURE__ */ new Set();
   const commandFiles = await listMarkdownFiles(
-    resolve11(plugin.sourceDir, "commands"),
+    resolve12(plugin.sourceDir, "commands"),
     {
       recursive: false
     }
@@ -6422,19 +6504,19 @@ async function planCodexSkills(plugin) {
       commandFiles.map((file2) => markdownSkillAlias(plugin.manifest.name, file2))
     )
   );
-  const nativeSkillsDir = resolve11(plugin.sourceDir, "skills");
+  const nativeSkillsDir = resolve12(plugin.sourceDir, "skills");
   if (await hasCodexSkillDir(nativeSkillsDir)) {
     for (const name of await listCodexSkillNames(nativeSkillsDir)) {
       usedNames.add(name);
       coveredAliases.add(skillAlias(plugin.manifest.name, name));
       sources.push({
         kind: "copy-skill",
-        sourceDir: resolve11(nativeSkillsDir, name),
+        sourceDir: resolve12(nativeSkillsDir, name),
         skillName: name
       });
     }
   } else {
-    const dotSkillsDir = resolve11(plugin.sourceDir, ".skills");
+    const dotSkillsDir = resolve12(plugin.sourceDir, ".skills");
     const claudeSkills = await listMarkdownFiles(dotSkillsDir);
     const claudeAliases = /* @__PURE__ */ new Map();
     for (const file2 of claudeSkills) {
@@ -6473,7 +6555,7 @@ async function planCodexSkills(plugin) {
 async function materializeCodexSkills(plan, dstSkills) {
   for (const source of plan.sources) {
     if (source.kind === "copy-skill") {
-      await cp(source.sourceDir, resolve11(dstSkills, source.skillName), {
+      await cp(source.sourceDir, resolve12(dstSkills, source.skillName), {
         recursive: true,
         dereference: false,
         preserveTimestamps: true,
@@ -6484,7 +6566,7 @@ async function materializeCodexSkills(plan, dstSkills) {
     const raw = await readFile7(source.sourceFile, "utf8");
     const normalized = normalizeSkillMarkdown(raw, source.skillName);
     await writeFileAtomic(
-      resolve11(dstSkills, source.skillName, "SKILL.md"),
+      resolve12(dstSkills, source.skillName, "SKILL.md"),
       normalized
     );
   }
@@ -6570,7 +6652,7 @@ async function listCodexSkillNames(skillsDir) {
   const names = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
-    if (await pathExists5(resolve11(skillsDir, entry.name, "SKILL.md"))) {
+    if (await pathExists5(resolve12(skillsDir, entry.name, "SKILL.md"))) {
       names.push(entry.name);
     }
   }
@@ -6588,7 +6670,7 @@ async function listMarkdownFiles(dir, opts = {}) {
       return;
     }
     for (const entry of entries) {
-      const abs = resolve11(current, entry.name);
+      const abs = resolve12(current, entry.name);
       if (entry.isDirectory()) {
         if (recursive) await walk2(abs);
         continue;
@@ -6616,7 +6698,7 @@ async function markdownSkillAlias(pluginName, filePath) {
   const triggerAlias = extractTriggerAlias(await readFile7(filePath, "utf8"));
   return skillAlias(
     pluginName,
-    triggerAlias ?? basename2(filePath, extname(filePath))
+    triggerAlias ?? basename3(filePath, extname(filePath))
   );
 }
 function markdownPathAlias(pluginName, baseDir, filePath) {
@@ -6647,8 +6729,8 @@ async function writeFileAtomic(filePath, content) {
   const tmp = `${filePath}.${Math.random().toString(36).slice(2)}.tmp`;
   try {
     await writeFile6(tmp, content, { encoding: "utf8", flag: "w" });
-    const { rename: rename9 } = await import("fs/promises");
-    await rename9(tmp, filePath);
+    const { rename: rename10 } = await import("fs/promises");
+    await rename10(tmp, filePath);
   } catch (err) {
     await rm7(tmp, { force: true }).catch(() => {
     });
@@ -6680,7 +6762,7 @@ function parsePluginKey2(key) {
   return { name: key.slice(0, at), marketplace: key.slice(at + 1) };
 }
 async function detectInstalledVersion(home, ref) {
-  const baseDir = resolve11(
+  const baseDir = resolve12(
     codexHomeDir(home),
     "plugins",
     "cache",
@@ -6696,8 +6778,8 @@ async function detectInstalledVersion(home, ref) {
   }
   let best = null;
   for (const entry of entries) {
-    const versionDir = resolve11(baseDir, entry);
-    const manifestPath = resolve11(versionDir, ".codex-plugin", "plugin.json");
+    const versionDir = resolve12(baseDir, entry);
+    const manifestPath = resolve12(versionDir, ".codex-plugin", "plugin.json");
     if (!await pathExists5(manifestPath)) continue;
     try {
       const raw = await readFile7(manifestPath, "utf8");
@@ -6738,7 +6820,7 @@ import {
   writeFile as writeFile8
 } from "fs/promises";
 import { homedir as homedir7 } from "os";
-import { dirname as dirname8, relative, resolve as resolve14 } from "path";
+import { dirname as dirname8, relative, resolve as resolve15 } from "path";
 
 // src/installers/cursor/marker.ts
 var RUSH_AI_MARKER = "<!-- rush-ai:auto-generated -->";
@@ -6857,25 +6939,25 @@ async function pathExists6(p) {
 }
 
 // src/installers/cursor/paths.ts
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 var CURSOR_RELATIVE_DIR = ".cursor";
 function cursorDir(home) {
-  return resolve12(home, CURSOR_RELATIVE_DIR);
+  return resolve13(home, CURSOR_RELATIVE_DIR);
 }
 function cursorMcpJsonPath(home) {
-  return resolve12(cursorDir(home), "mcp.json");
+  return resolve13(cursorDir(home), "mcp.json");
 }
 function cursorRulesDir(home) {
-  return resolve12(cursorDir(home), "rules");
+  return resolve13(cursorDir(home), "rules");
 }
 function cursorRuleMdcPath(home, ruleName) {
-  return resolve12(cursorRulesDir(home), `${ruleName}.mdc`);
+  return resolve13(cursorRulesDir(home), `${ruleName}.mdc`);
 }
 function cursorSkillsDir(home) {
-  return resolve12(cursorDir(home), "skills");
+  return resolve13(cursorDir(home), "skills");
 }
 function cursorSkillDir(home, skillName) {
-  return resolve12(cursorSkillsDir(home), skillName);
+  return resolve13(cursorSkillsDir(home), skillName);
 }
 function bridgeSkillFileReference(skillName) {
   return `.cursor/skills/${skillName}/SKILL.md`;
@@ -6986,9 +7068,9 @@ function quoteIfNeeded(value) {
 
 // src/installers/cursor/skills.ts
 import { readFile as readFile9 } from "fs/promises";
-import { resolve as resolve13 } from "path";
+import { resolve as resolve14 } from "path";
 async function readSkillDescription(skillSourceDir) {
-  const skillMdPath = resolve13(skillSourceDir, "SKILL.md");
+  const skillMdPath = resolve14(skillSourceDir, "SKILL.md");
   let raw;
   try {
     raw = await readFile9(skillMdPath, "utf8");
@@ -7141,7 +7223,7 @@ var CursorInstaller = class {
     const { included, skipped } = partitionCapabilities(plugin.capabilities);
     const force = opts.force === true;
     const dryRun = opts.dryRun === true;
-    if (!force && !dryRun) {
+    if (!force && !dryRun && plugin.version !== "unknown") {
       const store = await RushRegistryStore.load({ home: this.home });
       const existing = store.get(plugin.ref)?.targets?.cursor;
       if (existing && existing.version === plugin.version) {
@@ -7351,10 +7433,10 @@ var CursorInstaller = class {
     const prevEntry = registryStore.get(plugin.ref);
     const prevFiles = new Set(prevEntry?.targets?.cursor?.files ?? []);
     if (plugin.capabilities.includes("skills")) {
-      const skillsSourceDir = resolve14(plugin.sourceDir, "skills");
+      const skillsSourceDir = resolve15(plugin.sourceDir, "skills");
       const skillDirs = await listSkillDirs(skillsSourceDir);
       for (const skillName of skillDirs) {
-        const srcDir = resolve14(skillsSourceDir, skillName);
+        const srcDir = resolve15(skillsSourceDir, skillName);
         const destDir = cursorSkillDir(this.home, skillName);
         const bridgeRulePath = cursorRuleMdcPath(this.home, skillName);
         if (await dirExists2(destDir)) {
@@ -7386,10 +7468,10 @@ var CursorInstaller = class {
       }
     }
     if (plugin.capabilities.includes("rules")) {
-      const rulesSourceDir = resolve14(plugin.sourceDir, "rules");
+      const rulesSourceDir = resolve15(plugin.sourceDir, "rules");
       const rulesFiles = await listRuleMdFiles(rulesSourceDir);
       for (const ruleFile of rulesFiles) {
-        const srcPath = resolve14(rulesSourceDir, ruleFile);
+        const srcPath = resolve15(rulesSourceDir, ruleFile);
         const ruleName = ruleFile.replace(/\.md$/i, "");
         const destPath = cursorRuleMdcPath(this.home, ruleName);
         await assertMdcWritable(destPath, args.force);
@@ -7591,8 +7673,8 @@ async function fileExists(p) {
   }
 }
 async function safeRename(from, to) {
-  const { rename: rename9 } = await import("fs/promises");
-  await rename9(from, to);
+  const { rename: rename10 } = await import("fs/promises");
+  await rename10(from, to);
 }
 async function classifyArtifactPath(p) {
   let s;
@@ -7612,12 +7694,12 @@ async function classifyArtifactPath(p) {
 // src/migration/cleanup.ts
 import { lstat as lstat3, rm as rm10, unlink as unlink2 } from "fs/promises";
 import { homedir as homedir9 } from "os";
-import { resolve as resolve16 } from "path";
+import { resolve as resolve17 } from "path";
 
 // src/migration/detect.ts
 import { access as access9, lstat as lstat2, readFile as readFile11, readlink as readlink2, stat as stat8 } from "fs/promises";
 import { homedir as homedir8 } from "os";
-import { isAbsolute as isAbsolute4, resolve as resolve15 } from "path";
+import { isAbsolute as isAbsolute4, resolve as resolve16 } from "path";
 var LEGACY_ASSET_MANIFEST_RELATIVE = ".rush/plugins/claude-code/asset-manifest.json";
 var LEGACY_ASSETS_DIR_RELATIVE = ".rush/plugins/claude-code/assets";
 var LEGACY_CLAUDE_CODE_DIR_RELATIVE = ".rush/plugins/claude-code";
@@ -7636,7 +7718,7 @@ async function isSymlinkPointingInto(linkPath, expectedTarget) {
     const lst = await lstat2(linkPath);
     if (!lst.isSymbolicLink()) return false;
     const rawTarget = await readlink2(linkPath);
-    const resolvedTarget = isAbsolute4(rawTarget) ? rawTarget : resolve15(linkPath, "..", rawTarget);
+    const resolvedTarget = isAbsolute4(rawTarget) ? rawTarget : resolve16(linkPath, "..", rawTarget);
     return resolvedTarget === expectedTarget || resolvedTarget.startsWith(`${expectedTarget}/`);
   } catch {
     return false;
@@ -7673,10 +7755,10 @@ async function hasLegacyMcpWithoutEnabled(settingsJsonPath) {
 }
 async function detectLegacyInstall(opts = {}) {
   const home = opts.home ?? homedir8();
-  const assetManifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
-  const legacyAssetsDir = resolve15(home, LEGACY_ASSETS_DIR_RELATIVE);
-  const skillSymlinkPath = resolve15(home, LEGACY_SKILL_SYMLINK_RELATIVE);
-  const settingsJsonPath = resolve15(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const assetManifestPath = resolve16(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const legacyAssetsDir = resolve16(home, LEGACY_ASSETS_DIR_RELATIVE);
+  const skillSymlinkPath = resolve16(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const settingsJsonPath = resolve16(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   const [hasAssetManifest, hasLegacySkillSymlink, legacyMcpWithoutEnabled] = await Promise.all([
     pathExists7(assetManifestPath),
     isSymlinkPointingInto(skillSymlinkPath, legacyAssetsDir),
@@ -7691,7 +7773,7 @@ async function detectLegacyInstall(opts = {}) {
 }
 async function detectLegacyVersion(opts = {}) {
   const home = opts.home ?? homedir8();
-  const manifestPath = resolve15(home, LEGACY_ASSET_MANIFEST_RELATIVE);
+  const manifestPath = resolve16(home, LEGACY_ASSET_MANIFEST_RELATIVE);
   try {
     const lst = await stat8(manifestPath);
     if (!lst.isFile()) return "0.7.x";
@@ -7709,7 +7791,7 @@ async function detectLegacyVersion(opts = {}) {
 
 // src/migration/cleanup.ts
 async function cleanupLegacyDir(home) {
-  const dir = resolve16(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
+  const dir = resolve17(home, LEGACY_CLAUDE_CODE_DIR_RELATIVE);
   try {
     await rm10(dir, { recursive: true, force: true });
     return { ok: true };
@@ -7721,7 +7803,7 @@ async function cleanupLegacyDir(home) {
   }
 }
 async function cleanupLegacySymlink(home) {
-  const path4 = resolve16(home, LEGACY_SKILL_SYMLINK_RELATIVE);
+  const path4 = resolve17(home, LEGACY_SKILL_SYMLINK_RELATIVE);
   try {
     let lst;
     try {
@@ -7743,7 +7825,7 @@ async function cleanupLegacySymlink(home) {
   }
 }
 async function cleanupLegacyMcp(home) {
-  const path4 = resolve16(home, CLAUDE_SETTINGS_JSON_RELATIVE);
+  const path4 = resolve17(home, CLAUDE_SETTINGS_JSON_RELATIVE);
   try {
     const { data, existed } = await readJsonFile(
       path4,
@@ -7801,11 +7883,11 @@ function errorMessage(err) {
 // src/migration/log.ts
 import { appendFile as appendFile2, mkdir as mkdir10 } from "fs/promises";
 import { homedir as homedir10 } from "os";
-import { dirname as dirname9, resolve as resolve17 } from "path";
+import { dirname as dirname9, resolve as resolve18 } from "path";
 var MIGRATION_LOG_RELATIVE_PATH = ".rush/plugins/migration-failed.log";
 function resolveMigrationLogPath(opts = {}) {
   const home = opts.home ?? homedir10();
-  return resolve17(home, MIGRATION_LOG_RELATIVE_PATH);
+  return resolve18(home, MIGRATION_LOG_RELATIVE_PATH);
 }
 async function appendMigrationFailure(reason, opts = {}) {
   const now = opts.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
@@ -7830,9 +7912,12 @@ async function appendMigrationFailure(reason, opts = {}) {
 
 // src/migration/migrate.ts
 import { access as access12, readFile as readFile13 } from "fs/promises";
-import { homedir as homedir11 } from "os";
+import { homedir as homedir12 } from "os";
 
 // src/plugins/resolver.ts
+import { randomUUID as randomUUID8 } from "crypto";
+import { mkdir as mkdir11, rename as rename9, rm as rm11 } from "fs/promises";
+import { homedir as homedir11 } from "os";
 import {
   isAbsolute as isAbsolute5,
   relative as pathRelative2,
@@ -7843,7 +7928,7 @@ import {
 // src/plugins/capabilities.ts
 import { constants as fsConstants9 } from "fs";
 import { access as access10, readdir as readdir4, stat as stat9 } from "fs/promises";
-import { extname as extname2, resolve as resolve18 } from "path";
+import { extname as extname2, resolve as resolve19 } from "path";
 var CAPABILITY_ORDER = [
   "commands",
   "skills",
@@ -7872,10 +7957,10 @@ async function scanCapabilities(sourceDir, manifest) {
   return CAPABILITY_ORDER.filter((cap) => found.has(cap));
 }
 async function hasCommands(sourceDir) {
-  return dirHasFileWithExt(resolve18(sourceDir, "commands"), ".md");
+  return dirHasFileWithExt(resolve19(sourceDir, "commands"), ".md");
 }
 async function hasSkills(sourceDir) {
-  const skillsDir = resolve18(sourceDir, "skills");
+  const skillsDir = resolve19(sourceDir, "skills");
   if (await dirExists3(skillsDir)) {
     let entries;
     try {
@@ -7885,7 +7970,7 @@ async function hasSkills(sourceDir) {
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const skillMdPath = resolve18(skillsDir, entry.name, "SKILL.md");
+      const skillMdPath = resolve19(skillsDir, entry.name, "SKILL.md");
       if (await fileExists2(skillMdPath)) {
         return true;
       }
@@ -7894,10 +7979,10 @@ async function hasSkills(sourceDir) {
   return hasClaudeStyleSkills(sourceDir);
 }
 async function hasRules(sourceDir) {
-  return dirHasFileWithExt(resolve18(sourceDir, "rules"), ".md");
+  return dirHasFileWithExt(resolve19(sourceDir, "rules"), ".md");
 }
 async function hasHooks(sourceDir) {
-  const hooksDir = resolve18(sourceDir, "hooks");
+  const hooksDir = resolve19(sourceDir, "hooks");
   if (!await dirExists3(hooksDir)) {
     return false;
   }
@@ -7939,7 +8024,7 @@ async function dirHasFileWithExt(dirPath, ext) {
   );
 }
 async function hasClaudeStyleSkills(sourceDir) {
-  const dotSkillsDir = resolve18(sourceDir, ".skills");
+  const dotSkillsDir = resolve19(sourceDir, ".skills");
   if (!await dirExists3(dotSkillsDir)) {
     return false;
   }
@@ -7951,7 +8036,7 @@ async function hasClaudeStyleSkills(sourceDir) {
       return false;
     }
     for (const entry of entries) {
-      const abs = resolve18(dirPath, entry.name);
+      const abs = resolve19(dirPath, entry.name);
       if (entry.isDirectory()) {
         if (await walk2(abs)) return true;
         continue;
@@ -8031,25 +8116,25 @@ var PluginManifestCorruptError = class extends PluginResolverError {
     this.name = "PluginManifestCorruptError";
   }
 };
-var InvalidPluginVersionError = class extends PluginResolverError {
-  constructor(pluginName, manifestPath, actualValue) {
+var PluginCloneFailedError = class extends PluginResolverError {
+  constructor(pluginName, marketplaceName, cause) {
     super(
-      `plugin.json at '${manifestPath}' has invalid version field (got ${actualValue === void 0 ? "undefined" : `'${actualValue}'`}). Plugin '${pluginName}' must declare a non-empty version (e.g. "0.1.0"); 'unknown' is not allowed (see #906).`
+      `Failed to clone plugin '${pluginName}' from marketplace '${marketplaceName}': ${cause instanceof Error ? cause.message : String(cause)}`
     );
     this.pluginName = pluginName;
-    this.manifestPath = manifestPath;
-    this.actualValue = actualValue;
-    this.name = "InvalidPluginVersionError";
+    this.marketplaceName = marketplaceName;
+    this.cause = cause;
+    this.name = "PluginCloneFailedError";
   }
 };
 
 // src/plugins/manifest.ts
 import { constants as fsConstants10 } from "fs";
 import { access as access11, readFile as readFile12 } from "fs/promises";
-import { resolve as resolve19 } from "path";
+import { resolve as resolve20 } from "path";
 var PLUGIN_MANIFEST_RELATIVE_PATH = ".claude-plugin/plugin.json";
 async function readPluginManifest(pluginName, sourceDir) {
-  const manifestPath = resolve19(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
+  const manifestPath = resolve20(sourceDir, PLUGIN_MANIFEST_RELATIVE_PATH);
   try {
     await access11(manifestPath, fsConstants10.R_OK);
   } catch {
@@ -8081,13 +8166,8 @@ function parsePluginManifest(pluginName, raw, sourcePathForError) {
       "'name' must be a non-empty string"
     );
   }
-  const version = obj.version;
-  if (typeof version !== "string" || version.length === 0 || version.toLowerCase() === "unknown") {
-    throw new InvalidPluginVersionError(
-      pluginName,
-      sourcePathForError,
-      typeof version === "string" ? version : void 0
-    );
+  if (typeof obj.version !== "string" || obj.version.length === 0) {
+    obj.version = "unknown";
   }
   if (obj.mcpServers !== void 0) {
     const m = obj.mcpServers;
@@ -8108,6 +8188,10 @@ var RUSH_AI_MARKETPLACE_NAME3 = "rush-marketplace";
 var RUSH_MCP_SERVER_KEY3 = "rush";
 async function resolvePlugin(ref, marketplace, options = {}) {
   const entry = findPluginEntry(ref, marketplace);
+  await ensurePluginCloned(ref, marketplace, entry, {
+    runner: options.gitRunner,
+    dryRun: options.dryRun
+  });
   const sourceDir = resolvePluginSourceDir(ref, marketplace, entry);
   const manifest = await readPluginManifest(ref.name, sourceDir);
   const capabilities = await scanCapabilities(sourceDir, manifest);
@@ -8137,6 +8221,9 @@ function findPluginEntry(ref, marketplace) {
   return entry;
 }
 function resolvePluginSourceDir(ref, marketplace, entry) {
+  if (hasUrlSource(entry)) {
+    return extractUrlSourceDir(marketplace, entry);
+  }
   const relPath = extractRelativeSourcePath(ref, marketplace, entry);
   if (isAbsolute5(relPath)) {
     throw new PluginSourceUnresolvableError(
@@ -8158,6 +8245,29 @@ function resolvePluginSourceDir(ref, marketplace, entry) {
   }
   return abs;
 }
+function extractUrlSourceDir(marketplace, entry) {
+  const src = entry.source;
+  const cacheDir = pluginCacheDir(marketplace.name, entry.name);
+  const subPath = typeof src.path === "string" ? src.path.trim() : "";
+  if (!subPath) return cacheDir;
+  if (isAbsolute5(subPath)) {
+    throw new PluginSourceUnresolvableError(
+      entry.name,
+      marketplace.name,
+      `URL source subpath must be relative; got absolute '${subPath}'`
+    );
+  }
+  const resolved = pathResolve2(cacheDir, subPath);
+  const rel = pathRelative2(cacheDir, resolved);
+  if (rel === ".." || rel.startsWith(`..${pathSep}`) || isAbsolute5(rel)) {
+    throw new PluginSourceUnresolvableError(
+      entry.name,
+      marketplace.name,
+      `URL source subpath '${subPath}' escapes plugin cache dir`
+    );
+  }
+  return resolved;
+}
 function extractRelativeSourcePath(ref, marketplace, entry) {
   if (entry.source === void 0 || entry.source === null) {
     return `plugins/${entry.name}`;
@@ -8227,12 +8337,93 @@ function defaultRushAiBinaryResolver2() {
   }
   return void 0;
 }
+function pluginCacheDir(marketplaceName, pluginName) {
+  assertSafePathComponent(marketplaceName, "marketplace name");
+  assertSafePathComponent(pluginName, "plugin name");
+  return pathResolve2(
+    homedir11(),
+    ".rush",
+    "plugin-cache",
+    marketplaceName,
+    pluginName
+  );
+}
+function assertSafePathComponent(value, label) {
+  if (value.includes("/") || value.includes("\\") || value === ".." || value.startsWith("../") || value.startsWith("..\\")) {
+    throw new PluginSourceUnresolvableError(
+      value,
+      "",
+      `${label} '${value}' contains unsafe path characters`
+    );
+  }
+}
+function hasUrlSource(entry) {
+  const src = entry.source;
+  return !!src && typeof src === "object" && !Array.isArray(src) && typeof src.url === "string" && src.url.length > 0;
+}
+async function ensurePluginCloned(ref, marketplace, entry, opts) {
+  const src = entry.source;
+  if (!src || typeof src !== "object" || Array.isArray(src)) return;
+  if (typeof src.url !== "string" || !src.url) return;
+  const cacheDir = pluginCacheDir(marketplace.name, entry.name);
+  if (await pathExists2(cacheDir)) return;
+  if (opts?.dryRun) {
+    throw new PluginSourceUnresolvableError(
+      ref.name,
+      marketplace.name,
+      `Plugin '${ref.name}' has not been cached yet. Run without --dry-run first.`
+    );
+  }
+  const git = opts?.runner ?? defaultGitRunner;
+  const parent = pathResolve2(cacheDir, "..");
+  await mkdir11(parent, { recursive: true });
+  const tmpDir = `${cacheDir}.${randomUUID8()}.tmp`;
+  try {
+    const args = ["clone", "--depth", "1"];
+    if (typeof src.ref === "string" && src.ref.length > 0) {
+      args.push("--branch", src.ref);
+    }
+    args.push("--", src.url, tmpDir);
+    const result = await git(args);
+    if (result.exitCode !== 0) {
+      throw new Error(
+        `git clone exited with code ${result.exitCode}: ${result.stderr.trim()}`
+      );
+    }
+    if (typeof src.sha === "string" && src.sha.length > 0) {
+      try {
+        const head = await git(["rev-parse", "HEAD"], { cwd: tmpDir });
+        const actualSha = head.stdout.trim();
+        if (!actualSha.startsWith(src.sha) && !src.sha.startsWith(actualSha)) {
+          output.warn(
+            `Plugin '${ref.name}' sha mismatch (expected ${src.sha.slice(0, 7)}, got ${actualSha.slice(0, 7)})`
+          );
+        }
+      } catch {
+      }
+    }
+    try {
+      await rename9(tmpDir, cacheDir);
+    } catch (err) {
+      if (err.code === "ENOTEMPTY" && await pathExists2(cacheDir)) {
+        await rm11(tmpDir, { recursive: true, force: true });
+        return;
+      }
+      throw err;
+    }
+  } catch (err) {
+    await rm11(tmpDir, { recursive: true, force: true }).catch(() => {
+    });
+    if (err instanceof PluginSourceUnresolvableError) throw err;
+    throw new PluginCloneFailedError(ref.name, marketplace.name, err);
+  }
+}
 
 // src/migration/migrate.ts
 var LEGACY_MIGRATION_KEY = "legacy-rush-0.7.x";
 var SKIP_MIGRATION_ENV = "RUSH_SKIP_MIGRATION";
 async function maybeRunMigration(input) {
-  const home = input.home ?? homedir11();
+  const home = input.home ?? homedir12();
   const now = input.now ?? (() => (/* @__PURE__ */ new Date()).toISOString());
   const envGet = input.env ?? ((key) => process.env[key]);
   const reporter = input.reporter ?? {};
@@ -8804,6 +8995,10 @@ async function runInstall(input) {
         const rushSource = parseSource(`rush://${apiHost}`);
         await cache.add(rushSource, { as: ref.marketplace });
         marketplace = await cache.get(ref.marketplace);
+      } else if (ref.marketplace === "claude-plugins-official") {
+        const source = parseSource("github:anthropics/claude-plugins-official");
+        await cache.add(source, { as: "claude-plugins-official" });
+        marketplace = await cache.get("claude-plugins-official");
       } else {
         throw new RushError(
           `Marketplace '${ref.marketplace}' is not in the local cache. Run 'rush-ai marketplace add <source>' first.`,
@@ -8837,8 +9032,8 @@ async function runInstall(input) {
     }
   }
   if (marketplace.source.kind === "rush") {
-    const pluginDir = resolve20(marketplace.rootDir, "plugins", ref.name);
-    const manifestPath = resolve20(pluginDir, ".claude-plugin/plugin.json");
+    const pluginDir = resolve21(marketplace.rootDir, "plugins", ref.name);
+    const manifestPath = resolve21(pluginDir, ".claude-plugin/plugin.json");
     const alreadyMaterialized = await pathExists2(manifestPath);
     const hasNewSecrets = input.secrets && Object.keys(input.secrets).length > 0;
     const shouldMaterialize = !alreadyMaterialized || force || hasNewSecrets;
@@ -8900,15 +9095,24 @@ async function runInstall(input) {
       }
     }
   }
+  if (force && !dryRun) {
+    const entry = marketplace.manifest.plugins.find((p) => p.name === ref.name);
+    if (entry && hasUrlSource(entry)) {
+      await rm12(pluginCacheDir(ref.marketplace, ref.name), {
+        recursive: true,
+        force: true
+      });
+    }
+  }
   const resolveFn = input.resolvePluginFn ?? resolvePlugin;
   let plugin;
   try {
-    plugin = await resolveFn(ref, marketplace);
+    plugin = await resolveFn(ref, marketplace, { dryRun });
   } catch (err) {
     if (err instanceof PluginNotFoundInMarketplaceError && marketplace.source.kind === "rush") {
       marketplace = await cache.update(ref.marketplace);
       try {
-        plugin = await resolveFn(ref, marketplace);
+        plugin = await resolveFn(ref, marketplace, { dryRun });
       } catch (retryErr) {
         if (retryErr instanceof PluginNotFoundInMarketplaceError) {
           throw new RushError(
@@ -9106,8 +9310,9 @@ function registerInstallCommand(group, _root) {
 function printInstallSummary(result) {
   const { plugin, results, targetExplicit, dryRun } = result;
   const tag = dryRun ? " (dry-run)" : "";
+  const ver = plugin.version !== "unknown" ? ` v${plugin.version}` : "";
   output.log(
-    `Installing ${plugin.ref.name}@${plugin.ref.marketplace} v${plugin.version}...${tag}`
+    `Installing ${plugin.ref.name}@${plugin.ref.marketplace}${ver}...${tag}`
   );
   output.newline();
   for (const r of results) {
@@ -9707,68 +9912,201 @@ function registerPluginCommand(program) {
 }
 
 // src/commands/skill/index.ts
-import { existsSync as existsSync11, readdirSync, readFileSync as readFileSync7 } from "fs";
-import { basename as basename3, resolve as resolve21 } from "path";
-var SKILL_DESCRIPTION = "Print agent usage skills (hand-off, agent-shelf, ...) as raw markdown.";
+import { spawn as spawn2 } from "child_process";
+import { fileURLToPath } from "url";
+var SKILL_DESCRIPTION = "Manage AI agent skills through reskill using Rush auth and registry defaults.";
 var SKILL_HELP_AFTER = `
 Examples:
-  $ npx rush-ai skill                  Print the skills index
-  $ npx rush-ai skill hand-off         Print the hand-off playbook
-  $ npx rush-ai skill agent-shelf      Print the agent-shelf playbook
-  $ npx rush-ai skill --list           List available skills
+  $ rush-ai skill install @kanyun/rush-find-skills
+  $ rush-ai skill find vue
+  $ rush-ai skill list
+  $ rush-ai skill publish --dry-run
+  $ rush-ai skill group list
 
-Designed to be consumed by AI agents inside IDEs (Cursor, Claude Code,
-etc). Output is raw markdown on stdout \u2014 pipe it, grep it, feed it to
-your own context.
+Auth:
+  Use rush-ai auth login/logout/status. rush-ai skill forwards your Rush
+  token to the bundled reskill package manager via RESKILL_TOKEN and
+  defaults RESKILL_REGISTRY to the active Rush API URL.
+
+Notes:
+  rush-ai skill is a thin facade: unknown reskill flags and arguments are
+  forwarded as-is after Rush auth/registry injection.
+
+  The old "rush-ai skill hand-off" playbook path is deprecated. Use
+  "rush-ai playbook hand-off" instead.
 `;
-function resolveSkillsDir() {
-  const baseDir = import.meta.dirname ?? __dirname;
-  if (!baseDir) return null;
-  const candidates = [
-    resolve21(baseDir, "skills"),
-    resolve21(baseDir, "..", "skills"),
-    resolve21(baseDir, "..", "..", "skills"),
-    resolve21(baseDir, "..", "..", "..", "skills"),
-    resolve21(baseDir, "..", "..", "..", "..", "skills")
-  ];
-  for (const p of candidates) {
-    if (existsSync11(p)) return p;
+var DISABLE_RESKILL_UPDATE_CHECK_PRELOAD = `data:text/javascript,${encodeURIComponent(`
+const originalFetch = globalThis.fetch;
+globalThis.fetch = (input, init) => {
+  const url = typeof input === 'string' ? input : input?.url;
+  if (url === 'https://registry.npmjs.org/reskill') {
+    return Promise.resolve(new Response('', { status: 204 }));
+  }
+  return originalFetch(input, init);
+};
+`)}`;
+var AUTH_LIFECYCLE_COMMANDS = /* @__PURE__ */ new Set(["login", "logout", "whoami"]);
+var RESKILL_JSON_COMMANDS = /* @__PURE__ */ new Set([
+  "find",
+  "search",
+  "list",
+  "ls",
+  "info",
+  "outdated",
+  "doctor"
+]);
+var RESKILL_YES_COMMANDS = /* @__PURE__ */ new Set([
+  "install",
+  "i",
+  "uninstall",
+  "un",
+  "remove",
+  "rm",
+  "publish",
+  "pub"
+]);
+function hasAnyFlag(args, flags) {
+  return args.some((arg) => flags.includes(arg));
+}
+function stripRushOnlyFlags(args) {
+  let ci = false;
+  const forwarded = [];
+  for (const arg of args) {
+    if (arg === "--ci") {
+      ci = true;
+      continue;
+    }
+    if (arg.startsWith("--ci=")) {
+      ci = !["0", "false", "no"].includes(
+        arg.slice("--ci=".length).toLowerCase()
+      );
+      continue;
+    }
+    forwarded.push(arg);
   }
-  return null;
+  return { args: forwarded, ci };
+}
+function applyGlobalOptions(args, opts) {
+  const forwarded = [...args];
+  const command = forwarded[0];
+  if (!command) return forwarded;
+  if (opts.json && RESKILL_JSON_COMMANDS.has(command) && !hasAnyFlag(forwarded, ["--json", "-j"])) {
+    forwarded.push("--json");
+  }
+  const needsYes = RESKILL_YES_COMMANDS.has(command) || command === "group" && forwarded[1] === "delete";
+  if (opts.ci && needsYes && !hasAnyFlag(forwarded, ["--yes", "-y"])) {
+    forwarded.push("--yes");
+  }
+  return forwarded;
+}
+function createReskillEnv() {
+  const env = { ...process.env };
+  env.RESKILL_REGISTRY = getGlobalConfig().api;
+  const token = getAuthToken();
+  if (token) {
+    env.RESKILL_TOKEN = token;
+  }
+  return env;
 }
-function listSkills(dir) {
-  return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => basename3(f, ".md")).sort();
+function getReskillInvocation() {
+  return {
+    command: process.execPath,
+    args: [
+      "--import",
+      DISABLE_RESKILL_UPDATE_CHECK_PRELOAD,
+      fileURLToPath(import.meta.resolve("reskill/cli"))
+    ]
+  };
+}
+function runReskill(args) {
+  return new Promise((resolve23, reject) => {
+    const reskill = getReskillInvocation();
+    const child = spawn2(reskill.command, [...reskill.args, ...args], {
+      env: createReskillEnv(),
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("close", (code, signal) => {
+      if (signal) {
+        output.error(`reskill exited from signal ${signal}`);
+        resolve23(1);
+        return;
+      }
+      resolve23(code ?? 1);
+    });
+  });
+}
+function maybeHandleLegacyPlaybook(args) {
+  if (args.length === 1 && args[0] === "--list") {
+    output.warn(
+      "`rush-ai skill --list` is deprecated. Use `rush-ai playbook --list` for playbooks or `rush-ai skill list` for installed skills."
+    );
+    printPlaybook(void 0, { list: true });
+    return true;
+  }
+  const [name] = args;
+  if (isPlaybookName(name)) {
+    output.warn(
+      `\`rush-ai skill ${name}\` is deprecated. Use \`rush-ai playbook ${name}\` instead.`
+    );
+    printPlaybook(name);
+    return true;
+  }
+  return false;
 }
 function registerSkillCommand(program) {
-  program.command("skill [name]").description(SKILL_DESCRIPTION).addHelpText("after", SKILL_HELP_AFTER).option("--list", "List available skill names and exit").action((name, opts) => {
-    const dir = resolveSkillsDir();
-    if (!dir) {
-      output.error(
-        "Could not locate the skills/ directory. This is a packaging bug \u2014 please file an issue."
-      );
-      process.exit(2);
+  const command = program.command("skill [args...]").description(SKILL_DESCRIPTION).addHelpText("after", SKILL_HELP_AFTER).allowUnknownOption(true).allowExcessArguments(true).action(async (rawArgs) => {
+    const initialArgs = rawArgs ?? [];
+    if (maybeHandleLegacyPlaybook(initialArgs)) {
       return;
     }
-    const available = listSkills(dir);
-    if (opts.list) {
-      for (const s of available) output.log(s);
+    const stripped = stripRushOnlyFlags(initialArgs);
+    if (stripped.args.length === 0) {
+      command.help();
       return;
     }
-    const target = name ?? "README";
-    const file2 = resolve21(dir, `${target}.md`);
-    if (!existsSync11(file2)) {
-      output.error(`Unknown skill "${target}".`);
-      output.dim(`Available: ${available.join(", ") || "(none)"}`);
+    const [reskillCommand] = stripped.args;
+    if (reskillCommand && AUTH_LIFECYCLE_COMMANDS.has(reskillCommand)) {
+      output.error(
+        `Use \`rush-ai auth ${reskillCommand === "whoami" ? "status" : reskillCommand}\` instead.`
+      );
+      output.dim(
+        "`rush-ai skill` reuses Rush auth automatically; it does not maintain a separate reskill login state."
+      );
       process.exit(1);
       return;
     }
-    process.stdout.write(readFileSync7(file2, "utf-8"));
+    const globalOpts = command.optsWithGlobals();
+    const forwarded = applyGlobalOptions(stripped.args, {
+      json: globalOpts.json,
+      ci: stripped.ci || isCIMode(globalOpts)
+    });
+    try {
+      const code = await runReskill(forwarded);
+      if (code !== 0) {
+        process.exit(code);
+      }
+    } catch (error) {
+      const err = error;
+      if (err.code === "ENOENT") {
+        output.error(
+          "Could not start the bundled reskill CLI. Reinstall rush-ai and try again."
+        );
+      } else if (err.code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || err.code === "ERR_MODULE_NOT_FOUND") {
+        output.error(
+          "Could not resolve the bundled reskill CLI entry. Reinstall rush-ai and try again."
+        );
+      } else {
+        output.error(`Failed to run reskill: ${err.message}`);
+      }
+      process.exit(1);
+    }
   });
 }
 
 // src/commands/task/index.ts
 import { createWriteStream } from "fs";
-import { mkdir as mkdir11, readFile as readFile14, stat as stat10 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile14, stat as stat10 } from "fs/promises";
 import path3 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
@@ -10136,7 +10474,7 @@ function writeHandoffFile(projectPath, content) {
 var NO_PROJECT_HINT = [
   "No rush project detected for this directory. Either:",
   '  rush-ai task create -a web-builder -p "..."   (build a new site from a prompt)',
-  "  rush-ai task init                              (link an existing local project)"
+  "  rush-ai task link                              (link an existing local project)"
 ].join("\n");
 function registerPushSubcommand(task, program) {
   task.command("push").description(
@@ -10314,7 +10652,7 @@ function pushWithRouting(projectPath, source, envGitRemote) {
   if (!envRemoteUsable) {
     return {
       success: false,
-      stderr: "Cannot push: .rush/env.md identifies a Rush project but has no usable GIT_REMOTE. Re-run `rush-ai task init` to refresh the deploy token, or set `origin` to the Rush GitLab URL."
+      stderr: "Cannot push: .rush/env.md identifies a Rush project but has no usable GIT_REMOTE. Re-run `rush-ai task link` to refresh the deploy token, or set `origin` to the Rush GitLab URL."
     };
   }
   return gitPushUrl(projectPath, envGitRemote);
@@ -11256,7 +11594,7 @@ function formatCreatedAt(ts) {
 var MAX_TEXT_LENGTH = 500;
 function truncateText(text) {
   if (text.length <= MAX_TEXT_LENGTH) return text;
-  return text.slice(0, MAX_TEXT_LENGTH) + "...";
+  return `${text.slice(0, MAX_TEXT_LENGTH)}...`;
 }
 function summarizeTools(parts) {
   const toolParts = parts.filter(
@@ -11287,7 +11625,9 @@ function renderMessages(messages, conversationId, compact) {
     );
     if (textParts.length > 0) {
       for (const tp of textParts) {
-        output.log(`  ${truncateText(tp.text)}`);
+        if (tp.text) {
+          output.log(`  ${truncateText(tp.text)}`);
+        }
       }
     } else if (msg.content) {
       output.log(`  ${truncateText(msg.content)}`);
@@ -11341,7 +11681,7 @@ async function downloadFile(file2, destPath, client) {
   if (!response.body) {
     throw new Error("No response body");
   }
-  await mkdir11(path3.dirname(destPath), { recursive: true });
+  await mkdir12(path3.dirname(destPath), { recursive: true });
   const nodeStream = Readable.fromWeb(
     response.body
   );
@@ -11370,7 +11710,7 @@ Typical flows:
   # Quick one-shot with the default agent (\`rush\`)
   $ rush-ai task create -a rush -p "Summarize the latest release notes"
 
-For agents: run \`rush-ai skill hand-off\` for the full playbook.
+For agents: run \`rush-ai playbook hand-off\` for the full playbook.
 `;
 function registerTaskCommand(program) {
   const task = program.command("task").description("Create and manage tasks").addHelpText("after", TASK_HELP_AFTER);
@@ -11720,7 +12060,7 @@ function registerTaskCommand(program) {
       }
       if (options.last) {
         const n = parseInt(options.last, 10);
-        if (!isNaN(n) && n > 0) {
+        if (!Number.isNaN(n) && n > 0) {
           messages = messages.slice(-n);
         }
       }
@@ -11937,6 +12277,7 @@ function registerCommands(program) {
   registerAgentCommand(program);
   registerTaskCommand(program);
   registerSkillCommand(program);
+  registerPlaybookCommand(program);
   registerCheckCommand(program);
   registerMcpCommand(program);
   registerMarketplaceCommand(program);
@@ -11947,8 +12288,8 @@ function registerCommands(program) {
 }
 
 // src/util/update-check.ts
-import { mkdir as mkdir12, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
-import { homedir as homedir12 } from "os";
+import { mkdir as mkdir13, readFile as readFile15, writeFile as writeFile9 } from "fs/promises";
+import { homedir as homedir13 } from "os";
 import { dirname as dirname10, join as join10 } from "path";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 3e3;
@@ -11972,13 +12313,13 @@ function isNewerVersion(current, latest) {
 }
 async function writeLastCheck(checkFile) {
   try {
-    await mkdir12(dirname10(checkFile), { recursive: true });
+    await mkdir13(dirname10(checkFile), { recursive: true });
     await writeFile9(checkFile, JSON.stringify({ lastCheck: Date.now() }));
   } catch {
   }
 }
 async function checkForUpdate(currentVersion) {
-  const rushDir = join10(homedir12(), ".rush");
+  const rushDir = join10(homedir13(), ".rush");
   const checkFile = join10(rushDir, "update-check.json");
   try {
     if (process.env.CI) return;
@@ -12015,7 +12356,7 @@ var BANNER = `
     ${chalk7.dim("\xB7")} From Cursor / Claude Code, hand off a task to a Rush agent without restating context.
     ${chalk7.dim("\xB7")} Compose workflows where a Rush specialist agent runs as your sub-agent.
 
-  ${chalk7.dim("For agents:")} ${chalk7.cyan("rush-ai skill")} prints ready-to-consume usage playbooks.
+  ${chalk7.dim("For agents:")} ${chalk7.cyan("rush-ai playbook")} prints ready-to-consume usage playbooks.
 `;
 function showWelcomeGuide() {
   const lines = [
@@ -12027,11 +12368,12 @@ function showWelcomeGuide() {
     `    ${chalk7.cyan("rush-ai auth login")}                  Log in to the Rush platform`,
     `    ${chalk7.cyan("rush-ai agent list")}                  Browse available agents`,
     `    ${chalk7.cyan("rush-ai task create -a web-builder")}  Hand a task to a Rush agent`,
+    `    ${chalk7.cyan("rush-ai skill install <skill>")}        Install a Skill through Rush auth`,
     "",
     chalk7.dim("  For AI agents:"),
-    `    ${chalk7.cyan("rush-ai skill")}                       Print usage playbooks (markdown)`,
-    `    ${chalk7.cyan("rush-ai skill hand-off")}              IDE \u2192 Rush task hand-off`,
-    `    ${chalk7.cyan("rush-ai skill agent-shelf")}           Calling a Rush agent as a sub-agent`,
+    `    ${chalk7.cyan("rush-ai playbook")}                    Print usage playbooks (markdown)`,
+    `    ${chalk7.cyan("rush-ai playbook hand-off")}           IDE \u2192 Rush task hand-off`,
+    `    ${chalk7.cyan("rush-ai playbook agent-shelf")}        Calling a Rush agent as a sub-agent`,
     ""
   ];
   try {