aweskill 0.1.5 → 0.1.7

package/dist/index.js

@@ -4,18 +4,41 @@
 import { Command } from "commander";
 import { homedir as homedir2 } from "os";
 
+// src/commands/backup.ts
+import path3 from "path";
+
 // src/lib/backup.ts
-import { access, mkdtemp, mkdir } from "fs/promises";
+import { mkdtemp, mkdir, stat } from "fs/promises";
 import { tmpdir } from "os";
 import path2 from "path";
 import { spawn } from "child_process";
 
+// src/lib/fs.ts
+import { access } from "fs/promises";
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 // src/lib/path.ts
 import { homedir } from "os";
 import path from "path";
 function sanitizeName(input) {
   return input.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").slice(0, 80);
 }
+function expandHomePath(targetPath, homeDir = homedir()) {
+  if (targetPath === "~") {
+    return homeDir;
+  }
+  if (targetPath.startsWith("~/")) {
+    return path.join(homeDir, targetPath.slice(2));
+  }
+  return targetPath;
+}
 function getAweskillPaths(homeDir) {
   const rootDir = path.join(homeDir, ".aweskill");
   return {
@@ -51,11 +74,19 @@ async function runTar(args) {
     });
   });
 }
-async function createSkillsBackupArchive(homeDir) {
-  const { rootDir, skillsDir, backupDir } = getAweskillPaths(homeDir);
-  await mkdir(backupDir, { recursive: true });
-  const archivePath = await nextBackupArchivePath(backupDir);
-  await runTar(["-czf", archivePath, "-C", rootDir, path2.relative(rootDir, skillsDir)]);
+function formatBackupLabel(includeBundles) {
+  return includeBundles ? "skills and bundles" : "skills";
+}
+function archiveEntries(homeDir, includeBundles) {
+  const { rootDir, skillsDir, bundlesDir } = getAweskillPaths(homeDir);
+  return includeBundles ? [path2.relative(rootDir, skillsDir), path2.relative(rootDir, bundlesDir)] : [path2.relative(rootDir, skillsDir)];
+}
+async function createSkillsBackupArchive(homeDir, options = {}) {
+  const { rootDir, backupDir } = getAweskillPaths(homeDir);
+  const includeBundles = options.includeBundles ?? false;
+  const archivePath = await resolveBackupArchivePath(backupDir, options.archivePath);
+  await mkdir(path2.dirname(archivePath), { recursive: true });
+  await runTar(["-czf", archivePath, "-C", rootDir, ...archiveEntries(homeDir, includeBundles)]);
   return archivePath;
 }
 async function extractSkillsArchive(archivePath) {
@@ -63,9 +94,23 @@ async function extractSkillsArchive(archivePath) {
   await runTar(["-xzf", archivePath, "-C", tempDir]);
   return {
     tempDir,
-    extractedSkillsDir: path2.join(tempDir, "skills")
+    extractedSkillsDir: path2.join(tempDir, "skills"),
+    extractedBundlesDir: path2.join(tempDir, "bundles")
   };
 }
+async function resolveBackupArchivePath(backupDir, requestedPath) {
+  if (!requestedPath) {
+    return nextBackupArchivePath(backupDir);
+  }
+  try {
+    const requestedStats = await stat(requestedPath);
+    if (requestedStats.isDirectory()) {
+      return nextBackupArchivePath(requestedPath);
+    }
+  } catch {
+  }
+  return requestedPath;
+}
 async function nextBackupArchivePath(backupDir) {
   const base = `skills-${formatTimestamp(/* @__PURE__ */ new Date())}`;
   const primary = path2.join(backupDir, `${base}.tar.gz`);
@@ -81,38 +126,25 @@ async function nextBackupArchivePath(backupDir) {
     index += 1;
   }
 }
-async function pathExists(targetPath) {
-  try {
-    await access(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 
 // src/commands/backup.ts
-async function runBackup(context) {
-  const archivePath = await createSkillsBackupArchive(context.homeDir);
-  context.write(`Backed up skills to ${archivePath}`);
+async function runBackup(context, options = {}) {
+  const archivePath = await createSkillsBackupArchive(context.homeDir, {
+    archivePath: options.archivePath ? path3.resolve(context.cwd, expandHomePath(options.archivePath, context.homeDir)) : void 0,
+    includeBundles: options.includeBundles
+  });
+  context.write(`Backed up ${formatBackupLabel(options.includeBundles ?? false)} to ${archivePath}`);
   return { archivePath };
 }
 
 // src/lib/bundles.ts
-import { access as access3, mkdir as mkdir3, readFile, readdir as readdir2, rm, writeFile } from "fs/promises";
-import path4 from "path";
+import { mkdir as mkdir3, readFile, readdir as readdir2, rm, writeFile } from "fs/promises";
+import path5 from "path";
 import { parse, stringify } from "yaml";
 
 // src/lib/skills.ts
-import { access as access2, mkdir as mkdir2, readdir } from "fs/promises";
-import path3 from "path";
-async function pathExists2(targetPath) {
-  try {
-    await access2(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
+import { mkdir as mkdir2, readdir } from "fs/promises";
+import path4 from "path";
 async function ensureHomeLayout(homeDir) {
   const paths = getAweskillPaths(homeDir);
   await mkdir2(paths.rootDir, { recursive: true });
@@ -122,53 +154,45 @@ async function ensureHomeLayout(homeDir) {
   await mkdir2(paths.bundlesDir, { recursive: true });
 }
 function getSkillPath(homeDir, skillName) {
-  return path3.join(getAweskillPaths(homeDir).skillsDir, sanitizeName(skillName));
+  return path4.join(getAweskillPaths(homeDir).skillsDir, sanitizeName(skillName));
 }
 async function listSkills(homeDir) {
   const skillsDir = getAweskillPaths(homeDir).skillsDir;
   return listSkillEntriesInDirectory(skillsDir);
 }
 async function listSkillEntriesInDirectory(skillsDir) {
-  if (!await pathExists2(skillsDir)) {
+  if (!await pathExists(skillsDir)) {
     return [];
   }
   const entries = await readdir(skillsDir, { withFileTypes: true });
   const skills = await Promise.all(
     entries.filter((entry) => entry.isDirectory() || entry.isSymbolicLink()).map(async (entry) => {
-      const skillPath = path3.join(skillsDir, entry.name);
+      const skillPath = path4.join(skillsDir, entry.name);
       return {
         name: entry.name,
         path: skillPath,
-        hasSKILLMd: await pathExists2(path3.join(skillPath, "SKILL.md"))
+        hasSKILLMd: await pathExists(path4.join(skillPath, "SKILL.md"))
       };
     })
   );
   return skills.sort((left, right) => left.name.localeCompare(right.name));
 }
 async function assertSkillSource(sourcePath) {
-  const skillReadme = path3.join(sourcePath, "SKILL.md");
-  if (!await pathExists2(skillReadme)) {
+  const skillReadme = path4.join(sourcePath, "SKILL.md");
+  if (!await pathExists(skillReadme)) {
     throw new Error(`Skill source must contain SKILL.md: ${sourcePath}`);
   }
 }
 async function skillExists(homeDir, skillName) {
-  return pathExists2(getSkillPath(homeDir, skillName));
+  return pathExists(getSkillPath(homeDir, skillName));
 }
 
 // src/lib/bundles.ts
-async function pathExists3(targetPath) {
-  try {
-    await access3(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 function bundleFilePath(homeDir, bundleName) {
-  return path4.join(getAweskillPaths(homeDir).bundlesDir, `${sanitizeName(bundleName)}.yaml`);
+  return path5.join(getAweskillPaths(homeDir).bundlesDir, `${sanitizeName(bundleName)}.yaml`);
 }
 function bundleFilePathInDirectory(bundlesDir, bundleName) {
-  return path4.join(bundlesDir, `${sanitizeName(bundleName)}.yaml`);
+  return path5.join(bundlesDir, `${sanitizeName(bundleName)}.yaml`);
 }
 function normalizeBundle(raw, fallbackName) {
   const data = raw ?? {};
@@ -202,7 +226,7 @@ async function readBundleFromDirectory(bundlesDir, bundleName) {
 async function writeBundle(homeDir, bundle) {
   const normalized = normalizeBundle(bundle, bundle.name);
   const filePath = bundleFilePath(homeDir, normalized.name);
-  await mkdir3(path4.dirname(filePath), { recursive: true });
+  await mkdir3(path5.dirname(filePath), { recursive: true });
   await writeFile(filePath, stringify(normalized), "utf8");
   return normalized;
 }
@@ -227,7 +251,7 @@ async function removeSkillFromBundle(homeDir, bundleName, skillName) {
 }
 async function deleteBundle(homeDir, bundleName) {
   const filePath = bundleFilePath(homeDir, bundleName);
-  if (!await pathExists3(filePath)) {
+  if (!await pathExists(filePath)) {
     return false;
   }
   await rm(filePath, { force: true });
@@ -235,25 +259,16 @@ async function deleteBundle(homeDir, bundleName) {
 }
 
 // src/lib/templates.ts
-import { access as access4 } from "fs/promises";
-import path5 from "path";
+import path6 from "path";
 import { fileURLToPath } from "url";
-async function pathExists4(targetPath) {
-  try {
-    await access4(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function getTemplateBundlesDir() {
-  const moduleDir = path5.dirname(fileURLToPath(import.meta.url));
+  const moduleDir = path6.dirname(fileURLToPath(import.meta.url));
   const candidates = [
-    path5.resolve(moduleDir, "..", "..", "template", "bundles"),
-    path5.resolve(moduleDir, "..", "template", "bundles")
+    path6.resolve(moduleDir, "..", "..", "resources", "bundle_templates"),
+    path6.resolve(moduleDir, "..", "resources", "bundle_templates")
   ];
   for (const candidate of candidates) {
-    if (await pathExists4(candidate)) {
+    if (await pathExists(candidate)) {
       return candidate;
     }
   }
@@ -337,8 +352,8 @@ async function runBundleAddTemplate(context, bundleName) {
 }
 
 // src/lib/import.ts
-import { access as access5, cp, lstat, mkdir as mkdir4, readlink, readdir as readdir3, rename, rm as rm2, stat } from "fs/promises";
-import path6 from "path";
+import { cp, lstat, mkdir as mkdir4, readlink, readdir as readdir3, rename, rm as rm2, stat as stat2 } from "fs/promises";
+import path7 from "path";
 var MissingSymlinkSourceError = class extends Error {
   sourcePath;
   resolvedSourcePath;
@@ -349,14 +364,6 @@ var MissingSymlinkSourceError = class extends Error {
     this.resolvedSourcePath = resolvedSourcePath;
   }
 };
-async function pathExists5(targetPath) {
-  try {
-    await access5(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function resolveImportSource(sourcePath) {
   const statResult = await lstat(sourcePath);
   if (!statResult.isSymbolicLink()) {
@@ -366,8 +373,8 @@ async function resolveImportSource(sourcePath) {
     };
   }
   const linkTarget = await readlink(sourcePath);
-  const resolvedSourcePath = path6.resolve(path6.dirname(sourcePath), linkTarget);
-  if (!await pathExists5(resolvedSourcePath)) {
+  const resolvedSourcePath = path7.resolve(path7.dirname(sourcePath), linkTarget);
+  if (!await pathExists(resolvedSourcePath)) {
     throw new MissingSymlinkSourceError(sourcePath, resolvedSourcePath);
   }
   return {
@@ -376,30 +383,30 @@ async function resolveImportSource(sourcePath) {
   };
 }
 async function mergeMissingEntries(sourcePath, destinationPath) {
-  const sourceStat = await stat(sourcePath);
+  const sourceStat = await stat2(sourcePath);
   if (sourceStat.isDirectory()) {
     await mkdir4(destinationPath, { recursive: true });
     const entries = await readdir3(sourcePath, { withFileTypes: true });
     for (const entry of entries) {
-      await mergeMissingEntries(path6.join(sourcePath, entry.name), path6.join(destinationPath, entry.name));
+      await mergeMissingEntries(path7.join(sourcePath, entry.name), path7.join(destinationPath, entry.name));
     }
     return;
   }
-  if (await pathExists5(destinationPath)) {
+  if (await pathExists(destinationPath)) {
     return;
   }
-  await mkdir4(path6.dirname(destinationPath), { recursive: true });
+  await mkdir4(path7.dirname(destinationPath), { recursive: true });
   await cp(sourcePath, destinationPath, { recursive: false, errorOnExist: true, force: false });
 }
 async function copyIntoDestination(sourcePath, destination, override) {
-  if (!override && await pathExists5(destination)) {
+  if (!override && await pathExists(destination)) {
     await mergeMissingEntries(sourcePath, destination);
     return;
   }
   await cp(sourcePath, destination, { recursive: true, errorOnExist: false, force: override });
 }
 async function moveIntoDestination(sourcePath, destination, override) {
-  if (!await pathExists5(destination)) {
+  if (!await pathExists(destination)) {
     await rename(sourcePath, destination);
     return;
   }
@@ -464,8 +471,8 @@ async function listImportableChildren(sourceRoot) {
     if (!(entry.isDirectory() || entry.isSymbolicLink())) {
       continue;
     }
-    const childPath = path6.join(sourceRoot, entry.name);
-    if (await pathExists5(path6.join(childPath, "SKILL.md"))) {
+    const childPath = path7.join(sourceRoot, entry.name);
+    if (await pathExists(path7.join(childPath, "SKILL.md"))) {
       sources.push({
         name: sanitizeName(entry.name),
         path: childPath
@@ -484,12 +491,12 @@ async function listImportableChildren(sourceRoot) {
 async function importSkill(options) {
   const { effectiveSourcePath, isSymlinkSource } = await resolveImportSource(options.sourcePath);
   await assertSkillSource(effectiveSourcePath);
-  const skillName = sanitizeName(path6.basename(options.sourcePath));
+  const skillName = sanitizeName(path7.basename(options.sourcePath));
   if (!skillName) {
     throw new Error(`Unable to infer skill name from path: ${options.sourcePath}`);
   }
   const destination = getSkillPath(options.homeDir, skillName);
-  await mkdir4(path6.dirname(destination), { recursive: true });
+  await mkdir4(path7.dirname(destination), { recursive: true });
   const warnings = [];
   if (isSymlinkSource) {
     warnings.push(`Source ${options.sourcePath} is a symlink; copied from ${effectiveSourcePath} to ${destination}`);
@@ -513,8 +520,8 @@ async function importScannedSkills(options) {
   });
 }
 async function importPath(options) {
-  if (await pathExists5(path6.join(options.sourcePath, "SKILL.md"))) {
-    const skillName = sanitizeName(path6.basename(options.sourcePath));
+  if (await pathExists(path7.join(options.sourcePath, "SKILL.md"))) {
+    const skillName = sanitizeName(path7.basename(options.sourcePath));
     const alreadyExisted = skillName ? await skillExists(options.homeDir, skillName) : false;
     if (alreadyExisted && !options.override) {
       return {
@@ -542,107 +549,268 @@ async function importPath(options) {
 }
 
 // src/lib/scanner.ts
-import { access as access7, lstat as lstat2, readdir as readdir4, readlink as readlink2 } from "fs/promises";
-import path8 from "path";
+import { access as access2, lstat as lstat2, readdir as readdir4, readlink as readlink2 } from "fs/promises";
+import path9 from "path";
 
 // src/lib/agents.ts
-import { access as access6 } from "fs/promises";
-import path7 from "path";
+import path8 from "path";
+function defineAgent(id, displayName, options) {
+  return {
+    id,
+    displayName,
+    defaultProjectionMode: options.defaultProjectionMode ?? "symlink",
+    supportsGlobal: Boolean(options.globalSkillsDir),
+    supportsProject: Boolean(options.projectSkillsDir),
+    rootDir: options.rootDir,
+    globalSkillsDir: options.globalSkillsDir,
+    projectSkillsDir: options.projectSkillsDir
+  };
+}
 var AGENTS = {
-  amp: {
-    id: "amp",
-    displayName: "Amp",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".amp"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".amp", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".amp", "skills")
-  },
-  "claude-code": {
-    id: "claude-code",
-    displayName: "Claude Code",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".claude"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".claude", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".claude", "skills")
-  },
-  cline: {
-    id: "cline",
-    displayName: "Cline",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".cline"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".cline", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".cline", "skills")
-  },
-  codex: {
-    id: "codex",
-    displayName: "Codex",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".codex"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".codex", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".codex", "skills")
-  },
-  cursor: {
-    id: "cursor",
-    displayName: "Cursor",
-    defaultProjectionMode: "copy",
-    rootDir: (homeDir) => path7.join(homeDir, ".cursor"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".cursor", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".cursor", "skills")
-  },
-  "gemini-cli": {
-    id: "gemini-cli",
-    displayName: "Gemini CLI",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".gemini"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".gemini", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".gemini", "skills")
-  },
-  goose: {
-    id: "goose",
-    displayName: "Goose",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".goose"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".goose", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".goose", "skills")
-  },
-  opencode: {
-    id: "opencode",
-    displayName: "OpenCode",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".opencode"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".opencode", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".opencode", "skills")
-  },
-  roo: {
-    id: "roo",
-    displayName: "Roo Code",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".roo"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".roo", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".roo", "skills")
-  },
-  windsurf: {
-    id: "windsurf",
-    displayName: "Windsurf",
-    defaultProjectionMode: "symlink",
-    rootDir: (homeDir) => path7.join(homeDir, ".windsurf"),
-    globalSkillsDir: (homeDir) => path7.join(homeDir, ".windsurf", "skills"),
-    projectSkillsDir: (projectDir) => path7.join(projectDir, ".windsurf", "skills")
-  }
+  adal: defineAgent("adal", "AdaL", {
+    rootDir: (homeDir) => path8.join(homeDir, ".adal"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".adal", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".adal", "skills")
+  }),
+  amp: defineAgent("amp", "Amp", {
+    rootDir: (homeDir) => path8.join(homeDir, ".agents"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".agents", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".agents", "skills")
+  }),
+  antigravity: defineAgent("antigravity", "Antigravity", {
+    rootDir: (homeDir) => path8.join(homeDir, ".gemini", "antigravity"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".gemini", "antigravity", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".gemini", "antigravity", "skills")
+  }),
+  augment: defineAgent("augment", "Augment", {
+    rootDir: (homeDir) => path8.join(homeDir, ".augment"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".augment", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".augment", "skills")
+  }),
+  bob: defineAgent("bob", "IBM Bob", {
+    rootDir: (homeDir) => path8.join(homeDir, ".bob"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".bob", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".bob", "skills")
+  }),
+  "claude-code": defineAgent("claude-code", "Claude Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".claude"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".claude", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".claude", "skills")
+  }),
+  cline: defineAgent("cline", "Cline", {
+    rootDir: (homeDir) => path8.join(homeDir, ".cline"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".cline", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".cline", "skills")
+  }),
+  codebuddy: defineAgent("codebuddy", "CodeBuddy", {
+    rootDir: (homeDir) => path8.join(homeDir, ".codebuddy"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".codebuddy", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".codebuddy", "skills")
+  }),
+  "command-code": defineAgent("command-code", "Command Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".commandcode"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".commandcode", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".commandcode", "skills")
+  }),
+  continue: defineAgent("continue", "Continue", {
+    rootDir: (homeDir) => path8.join(homeDir, ".continue"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".continue", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".continue", "skills")
+  }),
+  codex: defineAgent("codex", "Codex", {
+    rootDir: (homeDir) => path8.join(homeDir, ".codex"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".codex", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".codex", "skills")
+  }),
+  copilot: defineAgent("copilot", "GitHub Copilot", {
+    rootDir: (homeDir) => path8.join(homeDir, ".copilot"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".copilot", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".copilot", "skills")
+  }),
+  cortex: defineAgent("cortex", "Cortex Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".snowflake", "cortex"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".snowflake", "cortex", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".cortex", "skills")
+  }),
+  crush: defineAgent("crush", "Crush", {
+    rootDir: (homeDir) => path8.join(homeDir, ".config", "crush"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".config", "crush", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".config", "crush", "skills")
+  }),
+  cursor: defineAgent("cursor", "Cursor", {
+    rootDir: (homeDir) => path8.join(homeDir, ".cursor"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".cursor", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".cursor", "skills")
+  }),
+  deepagents: defineAgent("deepagents", "Deep Agents", {
+    rootDir: (homeDir) => path8.join(homeDir, ".deepagents"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".deepagents", "agent", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".deepagents", "agent", "skills")
+  }),
+  droid: defineAgent("droid", "Droid", {
+    rootDir: (homeDir) => path8.join(homeDir, ".factory"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".factory", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".factory", "skills")
+  }),
+  firebender: defineAgent("firebender", "Firebender", {
+    rootDir: (homeDir) => path8.join(homeDir, ".firebender"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".firebender", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".firebender", "skills")
+  }),
+  "gemini-cli": defineAgent("gemini-cli", "Gemini CLI", {
+    rootDir: (homeDir) => path8.join(homeDir, ".gemini"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".gemini", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".gemini", "skills")
+  }),
+  "github-copilot": defineAgent("github-copilot", "GitHub Copilot", {
+    rootDir: (homeDir) => path8.join(homeDir, ".copilot"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".copilot", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".copilot", "skills")
+  }),
+  goose: defineAgent("goose", "Goose", {
+    rootDir: (homeDir) => path8.join(homeDir, ".goose"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".goose", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".goose", "skills")
+  }),
+  "iflow-cli": defineAgent("iflow-cli", "iFlow CLI", {
+    rootDir: (homeDir) => path8.join(homeDir, ".iflow"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".iflow", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".iflow", "skills")
+  }),
+  junie: defineAgent("junie", "Junie", {
+    rootDir: (homeDir) => path8.join(homeDir, ".junie"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".junie", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".junie", "skills")
+  }),
+  kilo: defineAgent("kilo", "Kilo Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".kilocode"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".kilocode", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".kilocode", "skills")
+  }),
+  "kiro-cli": defineAgent("kiro-cli", "Kiro CLI", {
+    rootDir: (homeDir) => path8.join(homeDir, ".kiro"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".kiro", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".kiro", "skills")
+  }),
+  "kilo-code": defineAgent("kilo-code", "Kilo Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".kilocode"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".kilocode", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".kilocode", "skills")
+  }),
+  "kimi-cli": defineAgent("kimi-cli", "Kimi Code CLI", {
+    rootDir: (homeDir) => path8.join(homeDir, ".kimi"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".kimi", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".kimi", "skills")
+  }),
+  kode: defineAgent("kode", "Kode", {
+    rootDir: (homeDir) => path8.join(homeDir, ".kode"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".kode", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".kode", "skills")
+  }),
+  mcpjam: defineAgent("mcpjam", "MCPJam", {
+    rootDir: (homeDir) => path8.join(homeDir, ".mcpjam"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".mcpjam", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".mcpjam", "skills")
+  }),
+  "mistral-vibe": defineAgent("mistral-vibe", "Mistral Vibe", {
+    rootDir: (homeDir) => path8.join(homeDir, ".vibe"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".vibe", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".vibe", "skills")
+  }),
+  mux: defineAgent("mux", "Mux", {
+    rootDir: (homeDir) => path8.join(homeDir, ".mux"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".mux", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".mux", "skills")
+  }),
+  neovate: defineAgent("neovate", "Neovate", {
+    rootDir: (homeDir) => path8.join(homeDir, ".neovate"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".neovate", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".neovate", "skills")
+  }),
+  openclaw: defineAgent("openclaw", "OpenClaw", {
+    rootDir: (homeDir) => path8.join(homeDir, ".openclaw"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".openclaw", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".openclaw", "skills")
+  }),
+  "openclaude-ide": defineAgent("openclaude-ide", "OpenClaude IDE", {
+    rootDir: (homeDir) => path8.join(homeDir, ".openclaude"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".openclaude", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".openclaude", "skills")
+  }),
+  openhands: defineAgent("openhands", "OpenHands", {
+    rootDir: (homeDir) => path8.join(homeDir, ".openhands"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".openhands", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".openhands", "skills")
+  }),
+  opencode: defineAgent("opencode", "OpenCode", {
+    rootDir: (homeDir) => path8.join(homeDir, ".opencode"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".opencode", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".opencode", "skills")
+  }),
+  pi: defineAgent("pi", "Pi", {
+    rootDir: (homeDir) => path8.join(homeDir, ".pi", "agent"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".pi", "agent", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".pi", "agent", "skills")
+  }),
+  pochi: defineAgent("pochi", "Pochi", {
+    rootDir: (homeDir) => path8.join(homeDir, ".pochi"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".pochi", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".pochi", "skills")
+  }),
+  qoder: defineAgent("qoder", "Qoder", {
+    rootDir: (homeDir) => path8.join(homeDir, ".qoder"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".qoder", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".qoder", "skills")
+  }),
+  "qwen-code": defineAgent("qwen-code", "Qwen Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".qwen"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".qwen", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".qwen", "skills")
+  }),
+  replit: defineAgent("replit", "Replit", {
+    rootDir: (homeDir) => path8.join(homeDir, ".config", "replit"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".agent", "skills")
+  }),
+  roo: defineAgent("roo", "Roo Code", {
+    rootDir: (homeDir) => path8.join(homeDir, ".roo"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".roo", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".roo", "skills")
+  }),
+  trae: defineAgent("trae", "Trae", {
+    rootDir: (homeDir) => path8.join(homeDir, ".trae"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".trae", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".trae", "skills")
+  }),
+  "trae-cn": defineAgent("trae-cn", "Trae CN", {
+    rootDir: (homeDir) => path8.join(homeDir, ".trae-cn"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".trae-cn", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".trae-cn", "skills")
+  }),
+  warp: defineAgent("warp", "Warp", {
+    rootDir: (homeDir) => path8.join(homeDir, ".warp"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".warp", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".warp", "skills")
+  }),
+  windsurf: defineAgent("windsurf", "Windsurf", {
+    rootDir: (homeDir) => path8.join(homeDir, ".codeium", "windsurf"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".codeium", "windsurf", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".codeium", "windsurf", "skills")
+  }),
+  zencoder: defineAgent("zencoder", "Zencoder", {
+    rootDir: (homeDir) => path8.join(homeDir, ".zencoder"),
+    globalSkillsDir: (homeDir) => path8.join(homeDir, ".zencoder", "skills"),
+    projectSkillsDir: (projectDir) => path8.join(projectDir, ".zencoder", "skills")
+  })
 };
-async function pathExists6(targetPath) {
-  try {
-    await access6(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 function listSupportedAgents() {
-  return Object.values(AGENTS);
+  return Object.values(AGENTS).sort((left, right) => left.id.localeCompare(right.id));
 }
 function listSupportedAgentIds() {
-  return listSupportedAgents().map((agent) => agent.id).sort();
+  return listSupportedAgents().map((agent) => agent.id);
+}
+function supportsScope(agentId, scope) {
+  const definition = getAgentDefinition(agentId);
+  return scope === "global" ? definition.supportsGlobal : definition.supportsProject;
 }
 function isAgentId(value) {
   return value in AGENTS;
@@ -652,7 +820,11 @@ function getAgentDefinition(agentId) {
 }
 function resolveAgentSkillsDir(agentId, scope, baseDir) {
   const definition = getAgentDefinition(agentId);
-  return scope === "global" ? definition.globalSkillsDir(baseDir) : definition.projectSkillsDir(baseDir);
+  const resolver = scope === "global" ? definition.globalSkillsDir : definition.projectSkillsDir;
+  if (!resolver) {
+    throw new Error(`Agent ${agentId} does not support ${scope} scope.`);
+  }
+  return resolver(baseDir);
 }
 function getProjectionMode(agentId) {
   return getAgentDefinition(agentId).defaultProjectionMode;
@@ -660,23 +832,23 @@ function getProjectionMode(agentId) {
 async function detectInstalledAgents(options) {
   const installed = [];
   for (const agent of listSupportedAgents()) {
-    const globalRootPath = agent.rootDir(options.homeDir);
-    const projectPath = options.projectDir ? agent.projectSkillsDir(options.projectDir) : null;
-    if (await pathExists6(globalRootPath)) {
+    const globalRootPath = agent.supportsGlobal ? agent.rootDir(options.homeDir) : null;
+    const projectPath = agent.supportsProject && options.projectDir ? resolveAgentSkillsDir(agent.id, "project", options.projectDir) : null;
+    if (globalRootPath && await pathExists(globalRootPath)) {
       installed.push(agent.id);
       continue;
     }
-    if (projectPath && await pathExists6(projectPath)) {
+    if (projectPath && await pathExists(projectPath)) {
       installed.push(agent.id);
     }
   }
-  return installed.sort();
+  return installed;
 }
 
 // src/lib/scanner.ts
 async function hasSkillReadme(skillDir) {
   try {
-    await access7(path8.join(skillDir, "SKILL.md"));
+    await access2(path9.join(skillDir, "SKILL.md"));
     return true;
   } catch {
     return false;
@@ -689,21 +861,13 @@ async function isSymlinkPath(targetPath) {
     return false;
   }
 }
-async function pathExists7(targetPath) {
-  try {
-    await access7(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
 async function resolveSymlinkSource(targetPath) {
   try {
     const linkTarget = await readlink2(targetPath);
-    const sourcePath = path8.resolve(path8.dirname(targetPath), linkTarget);
+    const sourcePath = path9.resolve(path9.dirname(targetPath), linkTarget);
     return {
       sourcePath,
-      isBroken: !await pathExists7(sourcePath)
+      isBroken: !await pathExists(sourcePath)
     };
   } catch {
     return {
@@ -719,7 +883,7 @@ async function scanDirectory(baseDir, agentId, scope, projectDir) {
       if (!entry.isDirectory() && !entry.isSymbolicLink()) {
         continue;
       }
-      const fullPath = path8.join(baseDir, entry.name);
+      const fullPath = path9.join(baseDir, entry.name);
       const isSymlink = await isSymlinkPath(fullPath);
       const symlinkInfo = isSymlink ? await resolveSymlinkSource(fullPath) : { isBroken: false };
       if (!await hasSkillReadme(fullPath) && !symlinkInfo.isBroken) {
@@ -744,9 +908,13 @@ async function scanDirectory(baseDir, agentId, scope, projectDir) {
 async function scanSkills(options) {
   const results = [];
   for (const agent of listSupportedAgents()) {
-    results.push(...await scanDirectory(agent.globalSkillsDir(options.homeDir), agent.id, "global"));
+    if (supportsScope(agent.id, "global")) {
+      results.push(...await scanDirectory(agent.globalSkillsDir(options.homeDir), agent.id, "global"));
+    }
     for (const projectDir of options.projectDirs ?? []) {
-      results.push(...await scanDirectory(agent.projectSkillsDir(projectDir), agent.id, "project", projectDir));
+      if (supportsScope(agent.id, "project")) {
+        results.push(...await scanDirectory(agent.projectSkillsDir(projectDir), agent.id, "project", projectDir));
+      }
     }
   }
   return results.sort((left, right) => left.path.localeCompare(right.path));
@@ -826,7 +994,7 @@ async function runImport(context, options) {
 
 // src/lib/symlink.ts
 import { cp as cp2, lstat as lstat3, mkdir as mkdir5, readFile as readFile2, readdir as readdir5, readlink as readlink3, rm as rm3, symlink, unlink, writeFile as writeFile2 } from "fs/promises";
-import path9 from "path";
+import path10 from "path";
 var COPY_MARKER = ".aweskill-projection.json";
 async function tryLstat(targetPath) {
   try {
@@ -837,7 +1005,7 @@ async function tryLstat(targetPath) {
 }
 async function readCopyMarker(targetPath) {
   try {
-    const content = await readFile2(path9.join(targetPath, COPY_MARKER), "utf8");
+    const content = await readFile2(path10.join(targetPath, COPY_MARKER), "utf8");
     const parsed = JSON.parse(content);
     return parsed.managedBy === "aweskill" ? parsed : null;
   } catch {
@@ -857,8 +1025,8 @@ async function assertProjectionTargetSafe(mode, sourcePath, targetPath, options
       throw new Error(`Refusing to overwrite non-symlink target: ${targetPath}`);
     }
     const currentTarget = await readlink3(targetPath);
-    const resolvedCurrent = path9.resolve(path9.dirname(targetPath), currentTarget);
-    if (resolvedCurrent === path9.resolve(sourcePath)) {
+    const resolvedCurrent = path10.resolve(path10.dirname(targetPath), currentTarget);
+    if (resolvedCurrent === path10.resolve(sourcePath)) {
       return;
     }
     return;
@@ -875,12 +1043,12 @@ async function assertProjectionTargetSafe(mode, sourcePath, targetPath, options
   }
 }
 async function createSkillSymlink(sourcePath, targetPath, options = {}) {
-  await mkdir5(path9.dirname(targetPath), { recursive: true });
+  await mkdir5(path10.dirname(targetPath), { recursive: true });
   const existing = await tryLstat(targetPath);
   if (existing?.isSymbolicLink()) {
     const currentTarget = await readlink3(targetPath);
-    const resolvedCurrent = path9.resolve(path9.dirname(targetPath), currentTarget);
-    if (resolvedCurrent === path9.resolve(sourcePath)) {
+    const resolvedCurrent = path10.resolve(path10.dirname(targetPath), currentTarget);
+    if (resolvedCurrent === path10.resolve(sourcePath)) {
       return "skipped";
     }
     await unlink(targetPath);
@@ -891,12 +1059,12 @@ async function createSkillSymlink(sourcePath, targetPath, options = {}) {
       throw new Error(`Refusing to overwrite non-symlink target: ${targetPath}`);
     }
   }
-  const linkTarget = path9.relative(path9.dirname(targetPath), sourcePath) || ".";
+  const linkTarget = path10.relative(path10.dirname(targetPath), sourcePath) || ".";
   await symlink(linkTarget, targetPath, "dir");
   return "created";
 }
 async function createSkillCopy(sourcePath, targetPath, options = {}) {
-  await mkdir5(path9.dirname(targetPath), { recursive: true });
+  await mkdir5(path10.dirname(targetPath), { recursive: true });
   const existing = await tryLstat(targetPath);
   if (existing?.isSymbolicLink()) {
     await unlink(targetPath);
@@ -910,8 +1078,8 @@ async function createSkillCopy(sourcePath, targetPath, options = {}) {
     await rm3(targetPath, { force: true, recursive: true });
   }
   await cp2(sourcePath, targetPath, { recursive: true });
-  const marker = { managedBy: "aweskill", sourcePath: path9.resolve(sourcePath) };
-  await writeFile2(path9.join(targetPath, COPY_MARKER), JSON.stringify(marker, null, 2), "utf8");
+  const marker = { managedBy: "aweskill", sourcePath: path10.resolve(sourcePath) };
+  await writeFile2(path10.join(targetPath, COPY_MARKER), JSON.stringify(marker, null, 2), "utf8");
   return "created";
 }
 async function removeManagedProjection(targetPath) {
@@ -937,12 +1105,12 @@ async function listManagedSkillNames(skillsDir, centralSkillsDir) {
   try {
     const entries = await readdir5(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
-      const targetPath = path9.join(skillsDir, entry.name);
+      const targetPath = path10.join(skillsDir, entry.name);
       if (entry.isSymbolicLink()) {
         try {
           const currentTarget = await readlink3(targetPath);
-          const resolvedCurrent = path9.resolve(path9.dirname(targetPath), currentTarget);
-          if (resolvedCurrent.startsWith(path9.resolve(centralSkillsDir))) {
+          const resolvedCurrent = path10.resolve(path10.dirname(targetPath), currentTarget);
+          if (resolvedCurrent.startsWith(path10.resolve(centralSkillsDir))) {
             result.set(entry.name, "symlink");
           }
         } catch {
@@ -974,13 +1142,17 @@ async function resolveAgentsForScope(context, requestedAgents, scope, projectDir
       homeDir: context.homeDir,
       projectDir: scope === "project" ? projectDir : void 0
     });
-    return detected.length > 0 ? detected : listSupportedAgentIds();
+    const candidates = detected.length > 0 ? detected : listSupportedAgentIds();
+    return candidates.filter((agentId) => supportsScope(agentId, scope));
   }
   return uniqueSorted(
     requestedAgents.map((agent) => {
       if (!isAgentId(agent)) {
         throw new Error(`Unsupported agent: ${agent}`);
       }
+      if (!supportsScope(agent, scope)) {
+        throw new Error(`Agent ${agent} does not support ${scope} scope.`);
+      }
       return agent;
     })
   );
@@ -1089,13 +1261,17 @@ async function resolveAgentsForScope2(context, requestedAgents, scope, projectDi
       homeDir: context.homeDir,
       projectDir: scope === "project" ? projectDir : void 0
     });
-    return detected.length > 0 ? detected : listSupportedAgentIds();
+    const candidates = detected.length > 0 ? detected : listSupportedAgentIds();
+    return candidates.filter((agentId) => supportsScope(agentId, scope));
   }
   return uniqueSorted(
     requestedAgents.map((agent) => {
       if (!isAgentId(agent)) {
         throw new Error(`Unsupported agent: ${agent}`);
       }
+      if (!supportsScope(agent, scope)) {
+        throw new Error(`Agent ${agent} does not support ${scope} scope.`);
+      }
       return agent;
     })
   );
@@ -1112,7 +1288,7 @@ async function resolveSkillNames(context, type, names) {
       homeDir: context.homeDir
     });
     const globalManaged = await Promise.all(
-      detected.map(async (agentId) => {
+      detected.filter((agentId) => supportsScope(agentId, "global")).map(async (agentId) => {
         const agentSkillsDir = resolveAgentSkillsDir(agentId, "global", context.homeDir);
         return listManagedSkillNames(agentSkillsDir, centralSkillsDir);
       })
@@ -1220,13 +1396,17 @@ async function resolveAgentsForScope3(context, requestedAgents, scope, projectDi
       homeDir: context.homeDir,
       projectDir: scope === "project" ? projectDir : void 0
     });
-    return detected.length > 0 ? detected : listSupportedAgentIds();
+    const candidates = detected.length > 0 ? detected : listSupportedAgentIds();
+    return candidates.filter((agentId) => supportsScope(agentId, scope));
   }
   return uniqueSorted(
     requestedAgents.map((agent) => {
       if (!isAgentId(agent)) {
         throw new Error(`Unsupported agent: ${agent}`);
       }
+      if (!supportsScope(agent, scope)) {
+        throw new Error(`Agent ${agent} does not support ${scope} scope.`);
+      }
       return agent;
     })
   );
@@ -1421,7 +1601,7 @@ async function runListTemplateBundles(context, options = {}) {
 
 // src/commands/recover.ts
 import { cp as cp3, mkdir as mkdir7, readlink as readlink4, unlink as unlink2 } from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 function getProjectDir4(context, explicitProjectDir) {
   return explicitProjectDir ?? context.cwd;
 }
@@ -1431,13 +1611,17 @@ async function resolveAgentsForScope4(context, requestedAgents, scope, projectDi
       homeDir: context.homeDir,
       projectDir: scope === "project" ? projectDir : void 0
     });
-    return detected.length > 0 ? detected : listSupportedAgentIds();
+    const candidates = detected.length > 0 ? detected : listSupportedAgentIds();
+    return candidates.filter((agentId) => supportsScope(agentId, scope));
   }
   return uniqueSorted(
     requestedAgents.map((agent) => {
       if (!isAgentId(agent)) {
         throw new Error(`Unsupported agent: ${agent}`);
       }
+      if (!supportsScope(agent, scope)) {
+        throw new Error(`Agent ${agent} does not support ${scope} scope.`);
+      }
       return agent;
     })
   );
@@ -1455,15 +1639,15 @@ async function runRecover(context, options) {
       if (mode !== "symlink") {
         continue;
       }
-      const targetPath = path10.join(agentSkillsDir, skillName);
-      const sourcePath = path10.join(centralSkillsDir, skillName);
+      const targetPath = path11.join(agentSkillsDir, skillName);
+      const sourcePath = path11.join(centralSkillsDir, skillName);
       const currentTarget = await readlink4(targetPath);
-      const resolvedCurrent = path10.resolve(path10.dirname(targetPath), currentTarget);
-      if (resolvedCurrent !== path10.resolve(sourcePath)) {
+      const resolvedCurrent = path11.resolve(path11.dirname(targetPath), currentTarget);
+      if (resolvedCurrent !== path11.resolve(sourcePath)) {
         continue;
       }
       await unlink2(targetPath);
-      await mkdir7(path10.dirname(targetPath), { recursive: true });
+      await mkdir7(path11.dirname(targetPath), { recursive: true });
       await cp3(sourcePath, targetPath, { recursive: true });
       recovered.push(`${agentId}:${skillName}`);
     }
@@ -1475,7 +1659,7 @@ async function runRecover(context, options) {
 
 // src/lib/references.ts
 import { rm as rm4 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 async function findSkillReferences(options) {
   const normalizedSkill = sanitizeName(options.skillName);
   const { skillsDir } = getAweskillPaths(options.homeDir);
@@ -1489,6 +1673,9 @@ async function findSkillReferences(options) {
   }
   for (const { scope, dir } of baseDirs) {
     for (const agent of listSupportedAgents()) {
+      if (!supportsScope(agent.id, scope)) {
+        continue;
+      }
       const agentSkillsDir = resolveAgentSkillsDir(agent.id, scope, dir);
       const managed = await listManagedSkillNames(agentSkillsDir, skillsDir);
       if (managed.has(normalizedSkill)) {
@@ -1517,10 +1704,13 @@ async function removeSkillWithReferences(options) {
   }
   for (const { scope, dir } of baseDirs) {
     for (const agent of listSupportedAgents()) {
+      if (!supportsScope(agent.id, scope)) {
+        continue;
+      }
       const agentSkillsDir = resolveAgentSkillsDir(agent.id, scope, dir);
       const managed = await listManagedSkillNames(agentSkillsDir, skillsDir);
       if (managed.has(normalizedSkill)) {
-        await removeManagedProjection(path11.join(agentSkillsDir, normalizedSkill));
+        await removeManagedProjection(path12.join(agentSkillsDir, normalizedSkill));
       }
     }
   }
@@ -1555,34 +1745,58 @@ async function runRemove(context, options) {
 
 // src/commands/restore.ts
 import { cp as cp4, mkdir as mkdir8, rm as rm5 } from "fs/promises";
-import path12 from "path";
+import path13 from "path";
 async function runRestore(context, options) {
-  const { tempDir, extractedSkillsDir } = await extractSkillsArchive(options.archivePath);
+  const includeBundles = options.includeBundles ?? false;
+  const { tempDir, extractedSkillsDir, extractedBundlesDir } = await extractSkillsArchive(options.archivePath);
   try {
     const extracted = await listSkillEntriesInDirectory(extractedSkillsDir);
     if (extracted.length === 0) {
       throw new Error(`Archive does not contain a skills/ directory: ${options.archivePath}`);
     }
-    const { skillsDir } = getAweskillPaths(context.homeDir);
+    const { skillsDir, bundlesDir } = getAweskillPaths(context.homeDir);
     const current = await listSkillEntriesInDirectory(skillsDir);
     const currentNames = new Set(current.map((entry) => entry.name));
     const conflicts = extracted.map((entry) => entry.name).filter((name) => currentNames.has(name));
-    if (conflicts.length > 0 && !options.override) {
-      throw new Error(`Restore would overwrite existing skills: ${conflicts.join(", ")}. Use --override to replace them.`);
+    const extractedBundles = includeBundles ? await listBundlesInDirectory(extractedBundlesDir) : [];
+    const currentBundles = includeBundles ? await listBundlesInDirectory(bundlesDir) : [];
+    const currentBundleNames = new Set(currentBundles.map((bundle) => bundle.name));
+    const bundleConflicts = extractedBundles.map((bundle) => bundle.name).filter((name) => currentBundleNames.has(name));
+    if ((conflicts.length > 0 || bundleConflicts.length > 0) && !options.override) {
+      const conflictMessages = [];
+      if (conflicts.length > 0) {
+        conflictMessages.push(`skills: ${conflicts.join(", ")}`);
+      }
+      if (bundleConflicts.length > 0) {
+        conflictMessages.push(`bundles: ${bundleConflicts.join(", ")}`);
+      }
+      throw new Error(`Restore would overwrite existing ${conflictMessages.join("; ")}. Use --override to replace them.`);
     }
-    const backupArchivePath = await createSkillsBackupArchive(context.homeDir);
+    const backupArchivePath = await createSkillsBackupArchive(context.homeDir, { includeBundles });
     if (options.override) {
       await rm5(skillsDir, { recursive: true, force: true });
-      await mkdir8(path12.dirname(skillsDir), { recursive: true });
+      await mkdir8(path13.dirname(skillsDir), { recursive: true });
       await cp4(extractedSkillsDir, skillsDir, { recursive: true });
+      if (includeBundles) {
+        await rm5(bundlesDir, { recursive: true, force: true });
+        await mkdir8(path13.dirname(bundlesDir), { recursive: true });
+        await cp4(extractedBundlesDir, bundlesDir, { recursive: true });
+      }
     } else {
       await mkdir8(skillsDir, { recursive: true });
       for (const entry of extracted) {
-        await cp4(entry.path, path12.join(skillsDir, entry.name), { recursive: true });
+        await cp4(entry.path, path13.join(skillsDir, entry.name), { recursive: true });
+      }
+      if (includeBundles) {
+        await mkdir8(bundlesDir, { recursive: true });
+        for (const bundle of extractedBundles) {
+          await cp4(path13.join(extractedBundlesDir, `${bundle.name}.yaml`), path13.join(bundlesDir, `${bundle.name}.yaml`), { recursive: true });
+        }
       }
     }
-    context.write(`Restored ${extracted.length} skills from ${options.archivePath}`);
-    context.write(`Backed up current skills to ${backupArchivePath}`);
+    const restoredLabel = includeBundles ? `Restored ${extracted.length} skills and ${extractedBundles.length} bundles from ${options.archivePath}` : `Restored ${extracted.length} skills from ${options.archivePath}`;
+    context.write(restoredLabel);
+    context.write(`Backed up current ${formatBackupLabel(includeBundles)} to ${backupArchivePath}`);
     return { restored: extracted.map((entry) => entry.name), backupArchivePath };
   } finally {
     await rm5(tempDir, { recursive: true, force: true });
@@ -1591,7 +1805,7 @@ async function runRestore(context, options) {
 
 // src/lib/rmdup.ts
 import { mkdir as mkdir9, readdir as readdir7, rename as rename2, rm as rm6 } from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 var NUMERIC_SUFFIX_PATTERN = /^(.*?)-(\d+(?:\.\d+)*)$/;
 function parseSkillName(name) {
   const match = name.match(NUMERIC_SUFFIX_PATTERN);
@@ -1681,13 +1895,13 @@ async function removeDuplicateSkills(homeDir, duplicates, options = {}) {
 async function nextAvailableDupPath(dupSkillsDir, skillName) {
   const entries = new Set(await readdir7(dupSkillsDir).catch(() => []));
   if (!entries.has(skillName)) {
-    return path13.join(dupSkillsDir, skillName);
+    return path14.join(dupSkillsDir, skillName);
   }
   let index = 1;
   while (entries.has(`${skillName}-${index}`)) {
     index += 1;
   }
-  return path13.join(dupSkillsDir, `${skillName}-${index}`);
+  return path14.join(dupSkillsDir, `${skillName}-${index}`);
 }
 
 // src/commands/rmdup.ts
@@ -1729,16 +1943,7 @@ async function runRmdup(context, options) {
 }
 
 // src/commands/sync.ts
-import { access as access8 } from "fs/promises";
-import path14 from "path";
-async function pathExists8(targetPath) {
-  try {
-    await access8(targetPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
+import path15 from "path";
 async function runSync(context, options) {
   const { skillsDir } = getAweskillPaths(context.homeDir);
   const baseDirs = /* @__PURE__ */ new Set();
@@ -1746,19 +1951,22 @@ async function runSync(context, options) {
   if (options.projectDir) {
     baseDirs.add({ scope: "project", dir: options.projectDir });
   }
-  if (await pathExists8(path14.join(context.cwd, ".aweskill.yaml"))) {
+  if (await pathExists(path15.join(context.cwd, ".aweskill.yaml"))) {
     baseDirs.add({ scope: "project", dir: context.cwd });
   }
   let removed = 0;
   const warnings = [];
   for (const { scope, dir } of baseDirs) {
     for (const agent of listSupportedAgents()) {
+      if (!supportsScope(agent.id, scope)) {
+        continue;
+      }
       const skillsDir2 = resolveAgentSkillsDir(agent.id, scope, dir);
       const managed = await listManagedSkillNames(skillsDir2, skillsDir);
       for (const [skillName] of managed) {
-        const sourcePath = path14.join(skillsDir, skillName);
-        if (!await pathExists8(sourcePath)) {
-          const wasRemoved = await removeManagedProjection(path14.join(skillsDir2, skillName));
+        const sourcePath = path15.join(skillsDir, skillName);
+        if (!await pathExists(sourcePath)) {
+          const wasRemoved = await removeManagedProjection(path15.join(skillsDir2, skillName));
           if (wasRemoved) {
             removed += 1;
             warnings.push(`Removed stale projection: ${agent.id}:${skillName} (source missing)`);
@@ -1774,16 +1982,39 @@ async function runSync(context, options) {
   return { removed, warnings };
 }
 
+// src/lib/version.ts
+import { existsSync, readFileSync } from "fs";
+import path16 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function readVersionFromPackageJson(packageJsonPath) {
+  const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+  if (!packageJson.version) {
+    throw new Error(`Missing version in ${packageJsonPath}`);
+  }
+  return packageJson.version;
+}
+function resolveVersionForModuleUrl(moduleUrl) {
+  const moduleDir = path16.dirname(fileURLToPath2(moduleUrl));
+  for (const relativePath of ["../package.json", "../../package.json"]) {
+    const packageJsonPath = path16.resolve(moduleDir, relativePath);
+    if (existsSync(packageJsonPath)) {
+      return readVersionFromPackageJson(packageJsonPath);
+    }
+  }
+  throw new Error(`Cannot find package.json for module ${moduleUrl}`);
+}
+var AWESKILL_VERSION = resolveVersionForModuleUrl(import.meta.url);
+
 // src/lib/runtime.ts
 import { realpathSync } from "fs";
-import { fileURLToPath as fileURLToPath2, pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath3, pathToFileURL } from "url";
 function isDirectCliEntry(importMetaUrl, argv1) {
   if (!argv1) {
     return false;
   }
   try {
     const executedPath = realpathSync(argv1);
-    const modulePath = realpathSync(fileURLToPath2(importMetaUrl));
+    const modulePath = realpathSync(fileURLToPath3(importMetaUrl));
     return pathToFileURL(modulePath).href === pathToFileURL(executedPath).href;
   } catch {
     return importMetaUrl === pathToFileURL(argv1).href;
@@ -1933,10 +2164,10 @@ function formatCliErrorMessage(message) {
       return 'Option --agent <agent> argument missing. Use one or more supported agent ids, for example "codex" or "codex,cursor". Run "aweskill agent supported" to see the supported agent list.';
     }
     const normalizedMessage = message.replace(/^error:\s*/i, "");
-    const bundleFileMatch = normalizedMessage.match(/ENOENT: no such file or directory, open '([^']+\/bundles\/([^/'"]+)\.ya?ml)'/i);
+    const bundleFileMatch = normalizedMessage.match(/ENOENT: no such file or directory, open '([^']+\/(bundles|resources\/bundle_templates)\/([^/'"]+)\.ya?ml)'/i);
     if (bundleFileMatch) {
-      const bundleName = bundleFileMatch[2];
-      if (bundleFileMatch[1]?.includes("/template/bundles/")) {
+      const bundleName = bundleFileMatch[3];
+      if (bundleFileMatch[2] === "resources/bundle_templates") {
         return `Bundle template not found: ${bundleName}. Run "aweskill bundle template list" to see available bundle templates.`;
       }
       return `Bundle not found: ${bundleName}. Run "aweskill bundle list" to see available bundles.`;
@@ -1965,16 +2196,7 @@ function formatCliErrorMessage(message) {
 function writeSupportedAgents(context) {
   const lines = [
     "Supported agents:",
-    "amp (Amp)",
-    "claude-code (Claude Code)",
-    "cline (Cline)",
-    "codex (Codex)",
-    "cursor (Cursor)",
-    "gemini-cli (Gemini CLI)",
-    "goose (Goose)",
-    "opencode (OpenCode)",
-    "roo (Roo Code)",
-    "windsurf (Windsurf)"
+    ...listSupportedAgents().map((agent) => `${agent.id} (${agent.displayName})`)
   ];
   for (const line of lines) {
     context.write(line);
@@ -1992,7 +2214,7 @@ function configureCommandTree(command) {
 function createProgram(overrides = {}) {
   const context = createRuntimeContext(overrides);
   const program = new Command();
-  program.name("aweskill").description("Local skill orchestration CLI for AI agents").version("0.1.5").helpOption("-h, --help", "Display help");
+  program.name("aweskill").description("Local skill orchestration CLI for AI agents").version(AWESKILL_VERSION).helpOption("-h, --help", "Display help");
   const skill = program.command("skill").description("Manage skills in the central store");
   skill.command("list").description("List skills in the central store").option("--verbose", "show all skills instead of a short preview", false).action(async (options) => {
     await runListSkills(context, { verbose: options.verbose });
@@ -2126,15 +2348,22 @@ function createProgram(overrides = {}) {
   store.command("init").description("Create ~/.aweskill layout").option("--scan", "scan existing agent directories after init", false).option("--verbose", "show scanned skill details instead of per-agent totals", false).action(async (options) => {
     await runFramedCommand(" aweskill store init ", async () => runInit(context, options));
   });
-  store.command("backup").description("Create a timestamped archive of the central skills repository").action(async () => {
-    await runFramedCommand(" aweskill store backup ", async () => runBackup(context));
+  store.command("backup").argument("[archive]").description("Create a timestamped archive of the central skills repository").option("--both", "include bundle definitions in the backup archive", false).action(async (archivePath, options) => {
+    await runFramedCommand(
+      " aweskill store backup ",
+      async () => runBackup(context, {
+        archivePath,
+        includeBundles: options.both
+      })
+    );
   });
-  store.command("restore").argument("<archive>").description("Restore skills from a backup archive and auto-back up the current skills first").option("--override", "replace existing skills with the archive contents", false).action(async (archivePath, options) => {
+  store.command("restore").argument("<archive>").description("Restore skills from a backup archive and auto-back up the current skills first").option("--override", "replace existing skills with the archive contents", false).option("--both", "restore bundle definitions and include them in the pre-restore backup", false).action(async (archivePath, options) => {
     await runFramedCommand(
       " aweskill store restore ",
       async () => runRestore(context, {
         archivePath,
-        override: options.override
+        override: options.override,
+        includeBundles: options.both
       })
     );
   });