@kurokeita/add-skill 1.20.0 → 2.0.0

package/dist/bin/cli.js

@@ -6,8 +6,7 @@ import { Command } from "commander";
 import pc6 from "picocolors";
 
 // src/commands/add.ts
-import os4 from "node:os";
-import path6 from "node:path";
+import path4 from "node:path";
 import {
   autocompleteMultiselect,
   cancel,
@@ -23,99 +22,30 @@ import {
 import fs4 from "fs-extra";
 import pc2 from "picocolors";
 
-// src/utils/github.ts
-import os from "node:os";
-import path from "node:path";
-import fs from "fs-extra";
-async function fetchSkillFromGitHub(url) {
-  const regex = /github\.com\/([^/]+)\/([^/]+)\/(?:tree|blob)\/([^/]+)\/(.+)/;
-  const match = url.match(regex);
-  if (!match) {
-    throw new Error(
-      "Invalid GitHub URL. Format: https://github.com/owner/repo/tree/branch/path/to/skill or blob/branch/path/to/file"
-    );
-  }
-  const [, owner, repo, ref, skillPath] = match;
-  const skillName = path.basename(skillPath);
-  const initialApiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${skillPath}?ref=${ref}`;
-  const tempDir = path.join(os.tmpdir(), "ai-agents-install", skillName);
-  await fs.ensureDir(tempDir);
-  await fs.emptyDir(tempDir);
-  let isFile = false;
-  async function downloadDirectory(apiUrl, localDir) {
-    const response = await fetch(apiUrl, {
-      headers: {
-        "User-Agent": "ai-agents-cli",
-        Accept: "application/vnd.github.v3+json"
-      }
-    });
-    if (!response.ok) {
-      throw new Error(
-        `Failed to fetch from GitHub (${response.status}): ${response.statusText}`
-      );
-    }
-    const data = await response.json();
-    if (!Array.isArray(data) && data.type === "file") {
-      isFile = true;
-      const item = data;
-      if (item.download_url) {
-        const fileContentResponse = await fetch(item.download_url);
-        if (!fileContentResponse.ok) {
-          throw new Error(
-            `Failed to download ${item.name}: ${fileContentResponse.statusText}`
-          );
-        }
-        const content = await fileContentResponse.text();
-        await fs.writeFile(path.join(localDir, item.name), content);
-      }
-      return;
-    }
-    if (!Array.isArray(data)) {
-      throw new Error(
-        "Invalid response from GitHub API. Expected directory listing or file object."
-      );
-    }
-    const files = data;
-    for (const item of files) {
-      if (item.type === "file" && item.download_url) {
-        const fileContentResponse = await fetch(item.download_url);
-        if (!fileContentResponse.ok) {
-          console.warn(
-            `Failed to download ${item.name}: ${fileContentResponse.statusText}`
-          );
-          continue;
-        }
-        const content = await fileContentResponse.text();
-        await fs.writeFile(path.join(localDir, item.name), content);
-      } else if (item.type === "dir") {
-        const newLocalDir = path.join(localDir, item.name);
-        await fs.ensureDir(newLocalDir);
-        await downloadDirectory(item.url, newLocalDir);
-      }
-    }
-  }
-  await downloadDirectory(initialApiUrl, tempDir);
-  return { tempDir, skillName, isFile };
-}
-
-// src/utils/paths.ts
-import fs2 from "node:fs";
+// src/utils/agent-setup.ts
+import { execFileSync } from "node:child_process";
 import os2 from "node:os";
 import path2 from "node:path";
+import fs2 from "fs-extra";
+
+// src/utils/paths.ts
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { fileURLToPath } from "node:url";
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
+var __dirname = path.dirname(__filename);
 function hasBundledAssets(rootDir) {
   return ["skills", "agents", "workflows"].some(
-    (dir) => fs2.existsSync(path2.join(rootDir, dir))
+    (dir) => fs.existsSync(path.join(rootDir, dir))
   );
 }
 function resolveProjectRoot(moduleDir) {
-  const sourceRoot = path2.resolve(moduleDir, "../..");
+  const sourceRoot = path.resolve(moduleDir, "../..");
   if (hasBundledAssets(sourceRoot)) {
     return sourceRoot;
   }
-  return path2.resolve(moduleDir, "..");
+  return path.resolve(moduleDir, "..");
 }
 var PROJECT_ROOT = resolveProjectRoot(__dirname);
 var PLATFORM_LABELS = {
@@ -127,26 +57,26 @@ var PLATFORM_LABELS = {
   windsurf: "Windsurf"
 };
 var PLATFORM_PATHS_SKILLS = {
-  antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_skills"),
-  "claude-code": path2.join(os2.homedir(), ".claude/skills"),
-  codex: path2.join(os2.homedir(), ".codex/skills"),
-  copilot: path2.join(os2.homedir(), ".copilot/skills"),
-  gemini: path2.join(os2.homedir(), ".gemini/skills"),
-  windsurf: path2.join(os2.homedir(), ".codeium/windsurf/skills")
+  antigravity: path.join(os.homedir(), ".gemini/antigravity/global_skills"),
+  "claude-code": path.join(os.homedir(), ".claude/skills"),
+  codex: path.join(os.homedir(), ".codex/skills"),
+  copilot: path.join(os.homedir(), ".copilot/skills"),
+  gemini: path.join(os.homedir(), ".gemini/skills"),
+  windsurf: path.join(os.homedir(), ".codeium/windsurf/skills")
 };
 var PLATFORM_PATHS_AGENTS = {
-  "claude-code": path2.join(os2.homedir(), ".claude/agents"),
-  codex: path2.join(os2.homedir(), ".codex/skills"),
-  copilot: path2.join(os2.homedir(), ".copilot/agents"),
-  gemini: path2.join(os2.homedir(), ".gemini/agents")
+  "claude-code": path.join(os.homedir(), ".claude/agents"),
+  codex: path.join(os.homedir(), ".codex/skills"),
+  copilot: path.join(os.homedir(), ".copilot/agents"),
+  gemini: path.join(os.homedir(), ".gemini/agents")
 };
 var PLATFORM_PATHS_WORKFLOWS = {
-  antigravity: path2.join(os2.homedir(), ".gemini/antigravity/global_workflows"),
-  "claude-code": path2.join(os2.homedir(), ".claude/skills"),
-  codex: path2.join(os2.homedir(), ".codex/skills"),
-  copilot: path2.join(os2.homedir(), ".copilot/prompts"),
-  gemini: path2.join(os2.homedir(), ".gemini/commands"),
-  windsurf: path2.join(os2.homedir(), ".codeium/windsurf/global_workflows")
+  antigravity: path.join(os.homedir(), ".gemini/antigravity/global_workflows"),
+  "claude-code": path.join(os.homedir(), ".claude/commands"),
+  codex: path.join(os.homedir(), ".codex/skills"),
+  copilot: path.join(os.homedir(), ".copilot/prompts"),
+  gemini: path.join(os.homedir(), ".gemini/commands"),
+  windsurf: path.join(os.homedir(), ".codeium/windsurf/global_workflows")
 };
 var PROJECT_RELATIVE_PLATFORM_PATHS_SKILLS = {
   antigravity: ".gemini/antigravity/skills",
@@ -164,7 +94,7 @@ var PROJECT_RELATIVE_PLATFORM_PATHS_AGENTS = {
 };
 var PROJECT_RELATIVE_PLATFORM_PATHS_WORKFLOWS = {
   antigravity: ".gemini/antigravity/workflows",
-  "claude-code": ".claude/skills",
+  "claude-code": ".claude/commands",
   codex: ".codex/skills",
   copilot: ".copilot/prompts",
   gemini: ".gemini/commands",
@@ -173,7 +103,7 @@ var PROJECT_RELATIVE_PLATFORM_PATHS_WORKFLOWS = {
 function resolveProjectPaths(relative, root) {
   const out = {};
   for (const [platform, rel] of Object.entries(relative)) {
-    if (rel) out[platform] = path2.join(root, rel);
+    if (rel) out[platform] = path.join(root, rel);
   }
   return out;
 }
@@ -187,438 +117,352 @@ function getProjectPlatformPathsWorkflows(root) {
   return resolveProjectPaths(PROJECT_RELATIVE_PLATFORM_PATHS_WORKFLOWS, root);
 }
 var TYPE_DIRS = {
-  skill: path2.join(PROJECT_ROOT, "skills"),
-  agent: path2.join(PROJECT_ROOT, "agents"),
-  workflow: path2.join(PROJECT_ROOT, "workflows")
+  skill: path.join(PROJECT_ROOT, "skills"),
+  agent: path.join(PROJECT_ROOT, "agents"),
+  workflow: path.join(PROJECT_ROOT, "workflows")
 };
-function getGlobalTargetPaths(type) {
-  switch (type) {
-    case "agent":
-      return PLATFORM_PATHS_AGENTS;
-    case "workflow":
-      return PLATFORM_PATHS_WORKFLOWS;
-    default:
-      return PLATFORM_PATHS_SKILLS;
-  }
-}
-function getProjectTargetPaths(type, root) {
-  switch (type) {
-    case "agent":
-      return getProjectPlatformPathsAgents(root);
-    case "workflow":
-      return getProjectPlatformPathsWorkflows(root);
-    default:
-      return getProjectPlatformPathsSkills(root);
-  }
-}
-function getTargetPaths(type, scope = "global", projectRoot) {
+var TYPE_SUBDIRS = {
+  skill: "skills",
+  agent: "agents",
+  workflow: "commands"
+};
+var AGENT_SETUP_SCRIPTS_DIR = path.join(
+  PROJECT_ROOT,
+  "skills/universalize-agents/scripts"
+);
+var HOOK_TEMPLATES_DIR = path.join(
+  PROJECT_ROOT,
+  "skills/universalize-agents/reference/hook-templates"
+);
+function getAgentsBase(scope, root) {
   if (scope === "project") {
-    const root = projectRoot ?? process.cwd();
-    return getProjectTargetPaths(type, root);
+    return path.join(root ?? process.cwd(), ".agents");
   }
-  return getGlobalTargetPaths(type);
+  return path.join(os.homedir(), ".agents");
 }
 
-// src/utils/platforms/antigravity.ts
-var AntigravityHandler = class {
-  platform = "antigravity";
-  getTargetFileName(itemName, _) {
-    return itemName;
-  }
-  transform(content, _, __) {
-    return content;
-  }
-};
-
-// src/utils/platforms/claude-code.ts
-import path3 from "node:path";
-import yaml from "js-yaml";
-var frontmatterRegex = /^---\n([\s\S]*?)\n---/;
-var CLAUDE_CODE_TOOLS = [
-  "Read",
-  "Edit",
-  "Write",
-  "Bash",
-  "Glob",
-  "Grep",
-  "WebFetch",
-  "WebSearch"
-];
-var ClaudeCodeHandler = class {
-  platform = "claude-code";
-  getTargetFileName(itemName, type) {
-    if (type === "agent") {
-      const name = itemName.replace(/\.md$/, "");
-      return path3.join(name, `${name}.md`);
-    }
-    if (type === "workflow") {
-      const name = itemName.replace(/\.md$/, "");
-      return path3.join(name, "SKILL.md");
-    }
-    return itemName;
-  }
-  transform(content, type, itemName) {
-    if (type === "skill") return content;
-    if (type === "agent") {
-      return this.transformAgent(content, itemName);
-    }
-    if (type === "workflow") {
-      return this.transformWorkflow(content, itemName);
-    }
-    return content;
-  }
-  transformAgent(content, itemName) {
-    const match = content.match(frontmatterRegex);
-    let frontmatter = {
-      name: itemName.replace(/\.md$/, ""),
-      description: "",
-      tools: CLAUDE_CODE_TOOLS
+// src/utils/agent-setup.ts
+var LINK_SUBDIRS = ["skills", "agents", "commands"];
+function getScopePaths(scope, root) {
+  if (scope === "project") {
+    return {
+      skills: getProjectPlatformPathsSkills(root),
+      agents: getProjectPlatformPathsAgents(root),
+      commands: getProjectPlatformPathsWorkflows(root)
     };
-    let body = content;
-    if (match) {
-      try {
-        const parsed = yaml.load(match[1]);
-        frontmatter = { ...frontmatter, ...parsed };
-        frontmatter.tools = CLAUDE_CODE_TOOLS;
-        delete frontmatter.target;
-        body = content.replace(frontmatterRegex, "").trim();
-      } catch (_) {
-      }
-    }
-    const yamlStr = yaml.dump(frontmatter);
-    return `---
-${yamlStr}---
-
-${body}`;
   }
-  transformWorkflow(content, itemName) {
-    const name = itemName.replace(/\.md$/, "");
-    const match = content.match(frontmatterRegex);
-    let description = "";
-    let body = content.trim();
-    if (match) {
-      try {
-        const parsed = yaml.load(match[1]);
-        if (typeof parsed.description === "string" && parsed.description.trim()) {
-          description = parsed.description.trim();
-        }
-        if (typeof parsed.name === "string" && parsed.name.trim()) {
-        }
-      } catch (_) {
-      }
-      body = content.replace(frontmatterRegex, "").trim();
-    }
-    if (!description) {
-      const titleMatch = body.match(/^#\s+(.+)$/m);
-      const title = titleMatch?.[1]?.trim() || name;
-      description = `Workflow: ${title}`;
-    }
-    const frontmatter = yaml.dump({
-      name,
-      description,
-      "user-invocable": true
-    });
-    return `---
-${frontmatter}---
-
-${body}`;
-  }
-};
-
-// src/utils/platforms/codex.ts
-import path4 from "node:path";
-import fs3 from "fs-extra";
-import yaml2 from "js-yaml";
-var frontmatterRegex2 = /^---\n([\s\S]*?)\n---/;
-var CODEX_TYPE_FIELD = "x-ai-agents-type";
-function extractTitle(body) {
-  const match = body.match(/^#\s+(.+)$/m);
-  return match?.[1]?.trim();
-}
-function buildDescription(type, itemName, title) {
-  const subject = title || itemName;
-  if (type === "agent") {
-    return `This skill should be used when Codex needs to follow the ${subject} agent instructions.`;
-  }
-  if (type === "workflow") {
-    return `This skill should be used when Codex needs to follow the ${subject} workflow instructions.`;
-  }
-  return `This skill should be used when Codex needs the ${subject} skill.`;
-}
-function toYamlFrontmatter(name, description, extraFields = {}) {
-  const normalizedName = name.replace(/\n+/g, " ").trim();
-  const normalizedDescription = description.replace(/\n+/g, " ").trim();
-  return yaml2.dump(
-    {
-      name: normalizedName,
-      description: normalizedDescription,
-      ...extraFields
-    },
-    { lineWidth: -1 }
-  ).trimEnd();
-}
-function parseCodexType(content) {
-  const match = content.match(frontmatterRegex2);
-  if (!match) return "skill";
-  try {
-    const parsed = yaml2.load(match[1]);
-    if (parsed && typeof parsed === "object") {
-      const type = parsed[CODEX_TYPE_FIELD];
-      if (type === "agent" || type === "workflow" || type === "skill") {
-        return type;
-      }
+  return {
+    skills: PLATFORM_PATHS_SKILLS,
+    agents: PLATFORM_PATHS_AGENTS,
+    commands: PLATFORM_PATHS_WORKFLOWS
+  };
+}
+function buildLinkMap(scope, root, presentSubdirs, platforms) {
+  const scopePaths = getScopePaths(scope, root);
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const sub of LINK_SUBDIRS) {
+    if (!presentSubdirs.includes(sub)) continue;
+    const platformDirs = scopePaths[sub];
+    for (const [platform, dest] of Object.entries(platformDirs)) {
+      if (!dest) continue;
+      if (platforms && !platforms.includes(platform)) continue;
+      const formattedDest = scope === "project" ? path2.relative(root, dest).replace(/\\/g, "/") : dest;
+      const line = `${sub}|${formattedDest}`;
+      if (seen.has(line)) continue;
+      seen.add(line);
+      lines.push(line);
     }
-  } catch {
-    return "skill";
   }
-  return "skill";
-}
-async function codexEntryMatchesType(basePath, entry, requestedType) {
-  let targetPath = null;
-  if (entry.isDirectory()) {
-    targetPath = path4.join(basePath, entry.name, "SKILL.md");
-  } else if (entry.isFile() && entry.name.endsWith(".md")) {
-    targetPath = path4.join(basePath, entry.name);
-  }
-  if (!targetPath) return false;
+  return lines.join("\n");
+}
+async function isRealConflict(target) {
   try {
-    const content = await fs3.readFile(targetPath, "utf-8");
-    return parseCodexType(content) === requestedType;
+    const stat = await fs2.lstat(target);
+    return !stat.isSymbolicLink();
   } catch {
     return false;
   }
 }
-var CodexHandler = class {
-  platform = "codex";
-  getTargetFileName(itemName, type) {
-    if (type === "agent" || type === "workflow") {
-      return path4.join(path4.parse(itemName).name, "SKILL.md");
-    }
-    return itemName;
-  }
-  transform(content, type, itemName) {
-    if (type === "skill") return content;
-    if (type !== "agent" && type !== "workflow") return content;
-    let name = itemName;
-    let description = "";
-    let body = content.trim();
-    const match = content.match(frontmatterRegex2);
-    if (match) {
-      body = content.replace(frontmatterRegex2, "").trim();
-      try {
-        const parsed = yaml2.load(match[1]);
-        if (parsed && typeof parsed === "object") {
-          const frontmatter = parsed;
-          if (typeof frontmatter.name === "string" && frontmatter.name.trim()) {
-            name = frontmatter.name.trim();
-          }
-          if (typeof frontmatter.description === "string" && frontmatter.description.trim()) {
-            description = frontmatter.description.trim();
-          }
+async function detectConflicts(agentsBase, platforms, scope, root) {
+  const scopePaths = getScopePaths(scope, root);
+  const conflicts = [];
+  for (const sub of LINK_SUBDIRS) {
+    const srcDir = path2.join(agentsBase, sub);
+    if (!await fs2.pathExists(srcDir)) continue;
+    const entries = await fs2.readdir(srcDir);
+    const platformDirs = Object.entries(scopePaths[sub]).filter(
+      ([platform, dest]) => !!dest && platforms.includes(platform)
+    );
+    for (const entry of entries) {
+      const targetPaths = [];
+      for (const [, dest] of platformDirs) {
+        const target = path2.join(dest, entry);
+        if (await isRealConflict(target)) {
+          targetPaths.push(target);
         }
-      } catch {
-        name = itemName;
-        description = "";
       }
-    }
-    if (!description) {
-      description = buildDescription(type, itemName, extractTitle(body));
-    }
-    const yamlStr = toYamlFrontmatter(name, description, {
-      [CODEX_TYPE_FIELD]: type
-    });
-    return `---
-${yamlStr}
----
-
-${body}`;
-  }
-};
-
-// src/utils/platforms/copilot.ts
-import yaml3 from "js-yaml";
-var CopilotHandler = class {
-  platform = "copilot";
-  getTargetFileName(itemName, type) {
-    if (type === "agent") {
-      return `${itemName.replace(/\.md$/, "")}.md`;
-    }
-    return itemName;
-  }
-  transform(content, type, itemName) {
-    if (type !== "agent") return content;
-    const frontmatterRegex3 = /^---\n([\s\S]*?)\n---/;
-    const match = content.match(frontmatterRegex3);
-    let frontmatter = {
-      name: itemName,
-      description: "",
-      target: "github-copilot",
-      tools: ["edit", "terminal", "ls", "grep_search", "githubRepo"]
-    };
-    let body = content;
-    if (match) {
-      try {
-        const parsed = yaml3.load(match[1]);
-        frontmatter = { ...frontmatter, ...parsed };
-        frontmatter.target = "github-copilot";
-        frontmatter.tools = [
-          "edit",
-          "terminal",
-          "ls",
-          "grep_search",
-          "githubRepo"
-        ];
-        body = content.replace(frontmatterRegex3, "").trim();
-      } catch (_) {
+      if (targetPaths.length > 0) {
+        conflicts.push({ entry, subdir: sub, targetPaths });
       }
     }
-    const yamlStr = yaml3.dump(frontmatter);
-    return `---
-${yamlStr}---
-
-${body}`;
   }
-};
-
-// src/utils/platforms/default.ts
-var DefaultHandler = class {
-  constructor(platform = "default") {
-    this.platform = platform;
+  return conflicts;
+}
+async function removeAgentDirEntries(targetPaths) {
+  for (const target of targetPaths) {
+    await fs2.remove(target);
   }
-  getTargetFileName(itemName, _type) {
-    return itemName;
+}
+async function dropAgentsEntry(agentsBase, subdir, entry) {
+  await fs2.remove(path2.join(agentsBase, subdir, entry));
+}
+async function presentLinkSubdirs(agentsBase) {
+  const present = [];
+  for (const sub of LINK_SUBDIRS) {
+    if (await fs2.pathExists(path2.join(agentsBase, sub))) {
+      present.push(sub);
+    }
   }
-  transform(content, _type, _itemName) {
-    return content;
+  return present;
+}
+async function installAgentSetupScripts(agentsBase, scope, linkMap) {
+  const hooksDir = path2.join(agentsBase, "hooks");
+  await fs2.ensureDir(hooksDir);
+  const agentsDirToken = scope === "project" ? ".agents" : agentsBase;
+  const shPath = path2.join(hooksDir, "agent-setup.sh");
+  const ps1Path = path2.join(hooksDir, "agent-setup.ps1");
+  for (const [src, dest] of [
+    ["agent-setup.sh", shPath],
+    ["agent-setup.ps1", ps1Path]
+  ]) {
+    let content = await fs2.readFile(
+      path2.join(AGENT_SETUP_SCRIPTS_DIR, src),
+      "utf-8"
+    );
+    content = content.replace(/__AGENTS_DIR__/g, agentsDirToken).replace(/^__LINK_MAP__$/m, linkMap);
+    await fs2.writeFile(dest, content);
   }
-};
-
-// src/utils/platforms/gemini.ts
-import yaml4 from "js-yaml";
-
-// src/utils/toml.ts
-function convertToGeminiCommandTOML(markdownContent) {
-  const lines = markdownContent.split("\n");
-  let description = "";
-  for (let i = 0; i < lines.length; i++) {
-    const trimmedLine = lines[i].trim();
-    if (trimmedLine && trimmedLine !== "---" && !trimmedLine.startsWith("<!--")) {
-      if (trimmedLine.startsWith("#")) {
-        description = trimmedLine.replace(/^#+\s*/, "");
-      } else {
-        description = trimmedLine;
-      }
-      break;
-    }
+  await fs2.chmod(shPath, 493);
+  return { shPath, ps1Path };
+}
+function jsonEntryEquals(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+function ensureArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function mergeJsonSessionStart(existing, hookKey, entry) {
+  const next = { ...existing };
+  const hooks = { ...next.hooks ?? {} };
+  const list2 = ensureArray(hooks[hookKey]);
+  if (!list2.some((item) => jsonEntryEquals(item, entry))) {
+    list2.push(entry);
+  }
+  hooks[hookKey] = list2;
+  next.hooks = hooks;
+  return next;
+}
+function buildClaudeCodeEntry(command) {
+  return { hooks: [{ type: "command", command }] };
+}
+function buildGeminiEntry(command) {
+  return { matcher: "startup", hooks: [{ type: "command", command }] };
+}
+function buildCopilotEntry(command) {
+  return { type: "command", bash: command, timeoutSec: 30 };
+}
+function buildCodexBlock(command) {
+  return [
+    "[[hooks.SessionStart]]",
+    'matcher = "startup"',
+    "",
+    "[[hooks.SessionStart.hooks]]",
+    'type = "command"',
+    `command = ${JSON.stringify(command)}`,
+    ""
+  ].join("\n");
+}
+function codexBlockAlreadyPresent(existing, command) {
+  return existing.includes(`command = ${JSON.stringify(command)}`);
+}
+async function backupOnce(file) {
+  if (await fs2.pathExists(file) && !await fs2.pathExists(`${file}.bak`)) {
+    await fs2.copy(file, `${file}.bak`);
   }
-  if (description.length > 100) {
-    description = `${description.substring(0, 97)}...`;
+}
+async function readJsonFile(file) {
+  if (!await fs2.pathExists(file)) return {};
+  const raw = await fs2.readFile(file, "utf-8");
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  return JSON.parse(trimmed);
+}
+async function mergeJsonHookFile(file, hookKey, entry) {
+  await fs2.ensureDir(path2.dirname(file));
+  await backupOnce(file);
+  const existing = await readJsonFile(file);
+  const merged = mergeJsonSessionStart(existing, hookKey, entry);
+  await fs2.writeFile(file, `${JSON.stringify(merged, null, "	")}
+`);
+}
+async function mergeCodexHookFile(file, command) {
+  await fs2.ensureDir(path2.dirname(file));
+  await backupOnce(file);
+  const existing = await fs2.pathExists(file) ? await fs2.readFile(file, "utf-8") : "";
+  if (codexBlockAlreadyPresent(existing, command)) return;
+  const sep = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  await fs2.writeFile(file, `${existing}${sep}
+${buildCodexBlock(command)}`);
+}
+function hookConfigFiles(scope, root) {
+  const base = scope === "project" ? root : os2.homedir();
+  const j = (...p) => path2.join(base, ...p);
+  const targets = [];
+  const claudeFile = j(".claude", "settings.json");
+  targets.push({
+    platform: "claude-code",
+    file: claudeFile,
+    merge: (command) => mergeJsonHookFile(
+      claudeFile,
+      "SessionStart",
+      buildClaudeCodeEntry(command)
+    )
+  });
+  const geminiFile = j(".gemini", "settings.json");
+  targets.push({
+    platform: "gemini",
+    file: geminiFile,
+    merge: (command) => mergeJsonHookFile(geminiFile, "SessionStart", buildGeminiEntry(command))
+  });
+  const codexFile = j(".codex", "config.toml");
+  targets.push({
+    platform: "codex",
+    file: codexFile,
+    merge: (command) => mergeCodexHookFile(codexFile, command)
+  });
+  const copilotFile = scope === "project" ? j(".github", "hooks", "agent-setup.json") : j(".copilot", "hooks", "agent-setup.json");
+  targets.push({
+    platform: "copilot",
+    file: copilotFile,
+    merge: (command) => mergeJsonHookFile(
+      copilotFile,
+      "sessionStart",
+      buildCopilotEntry(command)
+    )
+  });
+  return targets;
+}
+function expandSharedConfigPlatforms(platforms) {
+  return platforms.includes("antigravity") ? [...platforms, "gemini"] : platforms;
+}
+async function wireSessionStartHooks(scope, root, command, platforms) {
+  const targets = hookConfigFiles(scope, root);
+  const selected = platforms && expandSharedConfigPlatforms(platforms);
+  const wired = [];
+  for (const target of targets) {
+    if (selected && !selected.includes(target.platform)) continue;
+    await target.merge(command);
+    wired.push(target.platform);
+  }
+  return wired;
+}
+function runAgentSetupScript(shPath) {
+  if (process.platform === "win32") return;
+  execFileSync("bash", [shPath], { stdio: "ignore" });
+}
+async function wireAgentSetup(agentsBase, scope, root, platforms) {
+  const present = await presentLinkSubdirs(agentsBase);
+  const linkMap = buildLinkMap(scope, root, present, platforms);
+  const { shPath } = await installAgentSetupScripts(agentsBase, scope, linkMap);
+  const command = scope === "project" ? path2.join(".agents", "hooks", "agent-setup.sh").replace(/\\/g, "/") : shPath;
+  const wiredPlatforms = await wireSessionStartHooks(
+    scope,
+    root,
+    command,
+    platforms
+  );
+  let ranScript = false;
+  if (process.platform !== "win32") {
+    runAgentSetupScript(shPath);
+    ranScript = true;
   }
-  const escapedContent = markdownContent.replace(/"""/g, '\\"\\"\\"');
-  return `description = ${JSON.stringify(description)}
-
-prompt = """
-${escapedContent.trim()}
-"""
-`;
+  return { wiredPlatforms, ranScript };
 }
 
-// src/utils/platforms/gemini.ts
-var GeminiHandler = class {
-  platform = "gemini";
-  getTargetFileName(itemName, type) {
-    if (type === "workflow") {
-      return `${itemName.replace(/\.md$/, "")}.toml`;
-    }
-    return itemName;
+// src/utils/github.ts
+import os3 from "node:os";
+import path3 from "node:path";
+import fs3 from "fs-extra";
+async function fetchSkillFromGitHub(url) {
+  const regex = /github\.com\/([^/]+)\/([^/]+)\/(?:tree|blob)\/([^/]+)\/(.+)/;
+  const match = url.match(regex);
+  if (!match) {
+    throw new Error(
+      "Invalid GitHub URL. Format: https://github.com/owner/repo/tree/branch/path/to/skill or blob/branch/path/to/file"
+    );
   }
-  transform(content, type, itemName) {
-    if (type === "workflow") {
-      return convertToGeminiCommandTOML(content);
+  const [, owner, repo, ref, skillPath] = match;
+  const skillName = path3.basename(skillPath);
+  const initialApiUrl = `https://api.github.com/repos/${owner}/${repo}/contents/${skillPath}?ref=${ref}`;
+  const tempDir = path3.join(os3.tmpdir(), "ai-agents-install", skillName);
+  await fs3.ensureDir(tempDir);
+  await fs3.emptyDir(tempDir);
+  let isFile = false;
+  async function downloadDirectory(apiUrl, localDir) {
+    const response = await fetch(apiUrl, {
+      headers: {
+        "User-Agent": "ai-agents-cli",
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(
+        `Failed to fetch from GitHub (${response.status}): ${response.statusText}`
+      );
     }
-    if (type === "agent") {
-      const frontmatterRegex3 = /^---\n([\s\S]*?)\n---/;
-      const match = content.match(frontmatterRegex3);
-      let frontmatter = {
-        name: itemName,
-        description: "",
-        tools: [
-          "list_directory",
-          "read_file",
-          "write_file",
-          "glob",
-          "grep_search",
-          "replace",
-          "run_shell_command",
-          "google_web_search",
-          "web_fetch",
-          "ask_user",
-          "save_memory",
-          "activate_skill"
-        ]
-      };
-      let body = content;
-      if (match) {
-        try {
-          const parsed = yaml4.load(match[1]);
-          frontmatter = { ...frontmatter, ...parsed };
-          frontmatter.tools = [
-            "list_directory",
-            "read_file",
-            "write_file",
-            "glob",
-            "grep_search",
-            "replace",
-            "run_shell_command",
-            "google_web_search",
-            "web_fetch",
-            "ask_user",
-            "save_memory",
-            "activate_skill"
-          ];
-          delete frontmatter.skills;
-          body = content.replace(frontmatterRegex3, "").trim();
-        } catch (_) {
+    const data = await response.json();
+    if (!Array.isArray(data) && data.type === "file") {
+      isFile = true;
+      const item = data;
+      if (item.download_url) {
+        const fileContentResponse = await fetch(item.download_url);
+        if (!fileContentResponse.ok) {
+          throw new Error(
+            `Failed to download ${item.name}: ${fileContentResponse.statusText}`
+          );
         }
+        const content = await fileContentResponse.text();
+        await fs3.writeFile(path3.join(localDir, item.name), content);
       }
-      const yamlStr = yaml4.dump(frontmatter);
-      return `---
-${yamlStr}---
-
-${body}`;
+      return;
     }
-    return content;
-  }
-};
-
-// src/utils/platforms/windsurf.ts
-import path5 from "node:path";
-var WindsurfHandler = class {
-  platform = "windsurf";
-  getTargetFileName(itemName, type) {
-    if (type === "agent") {
-      return path5.join(path5.parse(itemName).name, "AGENTS.md");
+    if (!Array.isArray(data)) {
+      throw new Error(
+        "Invalid response from GitHub API. Expected directory listing or file object."
+      );
+    }
+    const files = data;
+    for (const item of files) {
+      if (item.type === "file" && item.download_url) {
+        const fileContentResponse = await fetch(item.download_url);
+        if (!fileContentResponse.ok) {
+          console.warn(
+            `Failed to download ${item.name}: ${fileContentResponse.statusText}`
+          );
+          continue;
+        }
+        const content = await fileContentResponse.text();
+        await fs3.writeFile(path3.join(localDir, item.name), content);
+      } else if (item.type === "dir") {
+        const newLocalDir = path3.join(localDir, item.name);
+        await fs3.ensureDir(newLocalDir);
+        await downloadDirectory(item.url, newLocalDir);
+      }
     }
-    return itemName;
-  }
-  transform(content, _type, _itemName) {
-    return content;
   }
-};
-
-// src/utils/platforms/index.ts
-var handlers = /* @__PURE__ */ new Map();
-function registerHandler(handler) {
-  handlers.set(handler.platform, handler);
-}
-registerHandler(new AntigravityHandler());
-registerHandler(new ClaudeCodeHandler());
-registerHandler(new CodexHandler());
-registerHandler(new CopilotHandler());
-registerHandler(new GeminiHandler());
-registerHandler(new WindsurfHandler());
-function getHandler(platform) {
-  return handlers.get(platform) || new DefaultHandler(platform);
+  await downloadDirectory(initialApiUrl, tempDir);
+  return { tempDir, skillName, isFile };
 }
 
 // src/utils/prompts.ts
@@ -743,11 +587,11 @@ import { isCancel, note, select } from "@clack/prompts";
 import pc from "picocolors";
 
 // src/utils/scope.ts
-import { execFileSync } from "node:child_process";
-import os3 from "node:os";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import os4 from "node:os";
 function isInsideGitWorkTree(cwd) {
   try {
-    const out = execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+    const out = execFileSync2("git", ["rev-parse", "--is-inside-work-tree"], {
       cwd,
       stdio: ["ignore", "pipe", "ignore"],
       encoding: "utf-8"
@@ -760,9 +604,9 @@ function isInsideGitWorkTree(cwd) {
 function resolveScope(scope, options = {}) {
   const cwd = options.cwd ?? process.cwd();
   if (scope === "global") {
-    return { ok: true, scope: "global", root: options.homedir ?? os3.homedir() };
+    return { ok: true, scope: "global", root: options.homedir ?? os4.homedir() };
   }
-  const home = options.homedir ?? os3.homedir();
+  const home = options.homedir ?? os4.homedir();
   if (cwd === home) {
     return { ok: false, reason: "homedir" };
   }
@@ -931,26 +775,6 @@ async function chooseListRemoveScope(options) {
 
 // src/commands/add.ts
 enableAutocompleteMultiSelectShiftAToggle();
-function getPlatformOptions(type) {
-  const paths = getTargetPaths(type);
-  return Object.entries(paths).filter(([_, pathStr]) => !!pathStr).map(([platform, pathStr]) => ({
-    label: PLATFORM_LABELS[platform],
-    value: platform,
-    hint: pathStr.replace(os4.homedir(), "~")
-  }));
-}
-async function installItem(itemName, overwrite, sourcePath, targetBaseDir) {
-  const targetPath = path6.join(targetBaseDir, itemName);
-  if (!await fs4.pathExists(sourcePath)) {
-    throw new Error(`Item '${itemName}' not found at ${sourcePath}`);
-  }
-  if (!overwrite && await fs4.pathExists(targetPath)) {
-    return false;
-  }
-  await fs4.ensureDir(targetBaseDir);
-  await fs4.copy(sourcePath, targetPath, { overwrite });
-  return true;
-}
 async function add(type, url, options) {
   if (!options?.skipIntro) {
     intro(pc2.bgCyan(pc2.black(" AI Manager : Add ")));
@@ -980,6 +804,7 @@ async function add(type, url, options) {
       return;
     }
     let tempDir = null;
+    let isGitHubFile = false;
     let selectedItems = [];
     try {
       if (url) {
@@ -988,6 +813,7 @@ async function add(type, url, options) {
         try {
           const result = await fetchSkillFromGitHub(url);
           tempDir = result.tempDir;
+          isGitHubFile = result.isFile;
           selectedItems = [result.skillName];
           s2.stop(pc2.green(`Fetched ${normalizedType}: ${result.skillName}`));
         } catch (e) {
@@ -1022,24 +848,6 @@ async function add(type, url, options) {
         }
         selectedItems = items;
       }
-      const currentPlatformOptions = getPlatformOptions(normalizedType);
-      if (currentPlatformOptions.length === 0) {
-        cancel(`No supported platforms found for type '${normalizedType}'.`);
-        process.exit(1);
-        return;
-      }
-      const platforms = await multiselect({
-        message: "Select target platforms:",
-        options: currentPlatformOptions,
-        required: true
-      });
-      if (isCancel2(platforms)) {
-        if (tempDir) await fs4.remove(tempDir);
-        if (isSingleShot) break;
-        currentType = void 0;
-        continue;
-      }
-      const selectedPlatforms = platforms;
       const scopeChoice = await chooseInstallScope({ flag: options?.scope });
       if ("rejected" in scopeChoice) {
         if (tempDir) await fs4.remove(tempDir);
@@ -1056,11 +864,9 @@ async function add(type, url, options) {
         continue;
       }
       const { scope: chosenScope, root: scopeRoot } = scopeChoice;
-      const supportedPaths = getTargetPaths(
-        normalizedType,
-        chosenScope,
-        scopeRoot
-      );
+      const agentsBase = getAgentsBase(chosenScope, scopeRoot);
+      const subdir = TYPE_SUBDIRS[normalizedType] ?? "skills";
+      const targetBase = path4.join(agentsBase, subdir);
       if (chosenScope === "project") {
         const proceed = await confirm({
           message: `Install to project scope at ${pc2.cyan(scopeRoot)}?`,
@@ -1073,116 +879,66 @@ async function add(type, url, options) {
           continue;
         }
       }
-      const existingItems = [];
-      for (const platform of selectedPlatforms) {
-        const targetBase = supportedPaths[platform];
-        if (!targetBase) continue;
-        const handler = getHandler(platform);
-        for (const item of selectedItems) {
-          const targetItemName = handler.getTargetFileName(item, normalizedType);
-          const targetPath = path6.join(targetBase, targetItemName);
-          if (await fs4.pathExists(targetPath)) {
-            existingItems.push({ item, platform });
-          }
+      const subdirName = subdir;
+      const preExisting = [];
+      for (const item of selectedItems) {
+        const targetName = normalizedType === "skill" ? path4.parse(item).name : item;
+        if (await fs4.pathExists(path4.join(targetBase, targetName))) {
+          preExisting.push({ entry: targetName, subdir: subdirName });
         }
       }
-      let overwrite = true;
-      if (existingItems.length > 0) {
-        const limit = 5;
-        const displayList = existingItems.slice(0, limit).map((e) => `${pc2.bold(e.item)} (${e.platform})`).join(", ");
-        const remainder = existingItems.length - limit;
-        const message = remainder > 0 ? `The following items already exist: ${displayList}, and ${remainder} others.` : `The following items already exist: ${displayList}.`;
-        note2(message, "Attention");
-        const shouldOverwrite = await confirm({
-          message: "Do you want to overwrite existing items?",
-          initialValue: false
+      const skipEntries = /* @__PURE__ */ new Set();
+      if (preExisting.length > 0) {
+        const toOverwrite = await multiselect({
+          message: "These entries already exist in .agents. Choose which to OVERWRITE (unselected entries are kept and skipped):",
+          options: preExisting.map((p) => ({ label: p.entry, value: p.entry })),
+          required: false
         });
-        if (isCancel2(shouldOverwrite)) {
+        if (isCancel2(toOverwrite)) {
           if (tempDir) await fs4.remove(tempDir);
           if (isSingleShot) break;
           currentType = void 0;
           continue;
         }
-        overwrite = shouldOverwrite;
+        const keep = new Set(toOverwrite);
+        for (const { entry } of preExisting) {
+          if (!keep.has(entry)) skipEntries.add(entry);
+        }
       }
       note2(
-        `Installing ${selectedItems.length} ${normalizedType}s to ${selectedPlatforms.length} platforms (scope: ${chosenScope})...`,
+        `Installing ${selectedItems.length} ${normalizedType}s to ${targetBase} (scope: ${chosenScope})...`,
         "Summary"
       );
       const s = spinner();
       s.start("Installing...");
       const errors = [];
       let installedCount = 0;
-      let skippedCount = 0;
-      for (const platform of selectedPlatforms) {
-        const targetBase = supportedPaths[platform];
-        if (!targetBase) continue;
-        for (const item of selectedItems) {
-          const message = `Installing ${pc2.bold(item)} to ${pc2.cyan(platform)}...`;
-          s.message(message);
-          try {
-            let currentSourcePath;
-            if (url && tempDir) {
-              const potentialFile = path6.join(tempDir, item);
-              if (await fs4.pathExists(potentialFile) && (await fs4.stat(potentialFile)).isFile()) {
-                currentSourcePath = potentialFile;
-              } else {
-                currentSourcePath = tempDir;
-              }
-            } else {
-              const src = path6.join(TYPE_DIRS[normalizedType], item);
-              if ((await fs4.stat(src)).isFile()) {
-                currentSourcePath = src;
-              } else {
-                currentSourcePath = src;
-              }
-            }
-            const handler = getHandler(platform);
-            const targetItemName = handler.getTargetFileName(
-              item,
-              normalizedType
-            );
-            if ((normalizedType === "agent" || normalizedType === "workflow") && currentSourcePath.endsWith(".md")) {
-              const targetPath = path6.join(targetBase, targetItemName);
-              if (!overwrite && await fs4.pathExists(targetPath)) {
-                skippedCount++;
-              } else {
-                let content = await fs4.readFile(currentSourcePath, "utf-8");
-                content = handler.transform(
-                  content,
-                  normalizedType,
-                  path6.parse(item).name
-                );
-                await fs4.ensureDir(path6.dirname(targetPath));
-                await fs4.writeFile(targetPath, content);
-                installedCount++;
-              }
-              continue;
-            }
-            const installed = await installItem(
-              targetItemName,
-              overwrite,
-              currentSourcePath,
-              targetBase
-            );
-            if (installed) {
-              installedCount++;
-            } else {
-              skippedCount++;
-            }
-          } catch (err) {
-            const errorMessage = err instanceof Error ? err.message : String(err);
-            errors.push(`${item} -> ${platform}: ${errorMessage}`);
+      await fs4.ensureDir(targetBase);
+      for (const item of selectedItems) {
+        const targetName = normalizedType === "skill" ? path4.parse(item).name : item;
+        if (skipEntries.has(targetName)) continue;
+        s.message(`Installing ${pc2.bold(item)}...`);
+        try {
+          const sourcePath = url && tempDir ? isGitHubFile ? path4.join(tempDir, item) : tempDir : path4.join(TYPE_DIRS[normalizedType], item);
+          if (!await fs4.pathExists(sourcePath)) {
+            throw new Error(`Item '${item}' not found at ${sourcePath}`);
           }
+          const targetPath = path4.join(targetBase, targetName);
+          await fs4.copy(sourcePath, targetPath, { overwrite: true });
+          installedCount++;
+        } catch (err) {
+          const errorMessage = err instanceof Error ? err.message : String(err);
+          errors.push(`${item}: ${errorMessage}`);
         }
       }
       if (tempDir) {
         await fs4.remove(tempDir);
+        tempDir = null;
       }
       if (errors.length > 0) {
         s.stop(
           pc2.yellow(
-            `Completed with errors. Installed: ${installedCount}, Skipped: ${skippedCount}, Errors: ${errors.length}`
+            `Completed with errors. Installed: ${installedCount}, Errors: ${errors.length}`
           )
         );
         console.error(pc2.red("\nErrors encountered:"));
@@ -1192,10 +948,13 @@ async function add(type, url, options) {
       } else {
         s.stop(
           pc2.green(
-            `Successfully installed ${installedCount} ${normalizedType}s. (${skippedCount} skipped)`
+            `Successfully installed ${installedCount} ${normalizedType}s.`
           )
         );
       }
+      if (installedCount > 0) {
+        await maybeWireAgentSetup(agentsBase, chosenScope, scopeRoot);
+      }
     } catch (error) {
       if (tempDir) await fs4.remove(tempDir);
       cancel(`An error occurred: ${error}`);
@@ -1209,9 +968,66 @@ async function add(type, url, options) {
     outro("You're all set!");
   }
 }
+async function maybeWireAgentSetup(agentsBase, scope, root) {
+  const wire = await confirm({
+    message: "Wire the agent-setup session-start hook now?",
+    initialValue: true
+  });
+  if (isCancel2(wire) || !wire) return;
+  const selected = await multiselect({
+    message: "Which agents should be wired?",
+    options: Object.keys(PLATFORM_LABELS).map((platform) => ({
+      label: PLATFORM_LABELS[platform],
+      value: platform
+    })),
+    required: true
+  });
+  if (isCancel2(selected)) return;
+  const platforms = selected;
+  const resolved = await resolveConflicts(agentsBase, platforms, scope, root);
+  if (resolved === "cancelled") return;
+  const s = spinner();
+  s.start("Wiring agent-setup hook...");
+  try {
+    const result = await wireAgentSetup(agentsBase, scope, root, platforms);
+    s.stop(
+      pc2.green(
+        `Wired session-start hook for: ${result.wiredPlatforms.join(", ")}.`
+      )
+    );
+    if (platforms.includes("windsurf")) {
+      note2(
+        "Windsurf has no session-start hook; its symlinks are created once now. Re-run .agents/hooks/agent-setup.sh to refresh.",
+        "Note"
+      );
+    }
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    s.error(`Failed to wire agent-setup hook: ${errorMessage}`);
+  }
+}
+async function resolveConflicts(agentsBase, platforms, scope, root) {
+  const conflicts = await detectConflicts(agentsBase, platforms, scope, root);
+  if (conflicts.length === 0) return "ok";
+  const overwrite = await multiselect({
+    message: "These entries already exist in the selected agent dirs. Choose which to OVERWRITE (unselected entries are dropped from .agents):",
+    options: conflicts.map((c) => ({ label: c.entry, value: c.entry })),
+    required: false
+  });
+  if (isCancel2(overwrite)) return "cancelled";
+  const toOverwrite = new Set(overwrite);
+  for (const conflict of conflicts) {
+    if (toOverwrite.has(conflict.entry)) {
+      await removeAgentDirEntries(conflict.targetPaths);
+    } else {
+      await dropAgentsEntry(agentsBase, conflict.subdir, conflict.entry);
+    }
+  }
+  return "ok";
+}
 
 // src/commands/import.ts
-import path7 from "node:path";
+import path5 from "node:path";
 import {
   cancel as cancel2,
   confirm as confirm2,
@@ -1280,12 +1096,12 @@ async function importItem(type, url, options) {
       throw e;
     }
     const shouldFlatten = (normalizedType === "agent" || normalizedType === "workflow") && !isFile;
-    const targetPath = shouldFlatten ? targetBaseDir : path7.join(targetBaseDir, itemName);
+    const targetPath = shouldFlatten ? targetBaseDir : path5.join(targetBaseDir, itemName);
     if (shouldFlatten) {
       const srcFiles = await fs5.readdir(tempDir);
       const conflicts = [];
       for (const file of srcFiles) {
-        if (await fs5.pathExists(path7.join(targetBaseDir, file))) {
+        if (await fs5.pathExists(path5.join(targetBaseDir, file))) {
           conflicts.push(file);
         }
       }
@@ -1316,7 +1132,7 @@ async function importItem(type, url, options) {
     s.start(`Importing ${itemName} to ${targetBaseDir}...`);
     await fs5.ensureDir(targetBaseDir);
     if (isFile) {
-      await fs5.copy(path7.join(tempDir, itemName), targetPath, {
+      await fs5.copy(path5.join(tempDir, itemName), targetPath, {
         overwrite: true
       });
     } else {
@@ -1341,68 +1157,40 @@ async function importItem(type, url, options) {
 
 // src/commands/list.ts
 import os5 from "node:os";
+import path6 from "node:path";
 import { cancel as cancel3, intro as intro3, isCancel as isCancel4, outro as outro3, select as select4 } from "@clack/prompts";
 import fs6 from "fs-extra";
 import pc4 from "picocolors";
-async function collectItemsForPlatform(platform, fullPath, normalizedType) {
-  const items = [];
-  const entries = await fs6.readdir(fullPath, { withFileTypes: true });
-  for (const entry of entries) {
-    if (platform === "codex") {
-      if (await codexEntryMatchesType(fullPath, entry, normalizedType)) {
-        items.push(entry.name);
-      }
-      continue;
-    }
-    if (entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")) {
-      items.push(entry.name);
-    }
-  }
-  items.sort();
-  return items;
+async function collectEntries(subdirPath) {
+  const entries = await fs6.readdir(subdirPath, { withFileTypes: true });
+  return entries.filter(
+    (entry) => entry.isDirectory() || entry.isFile() && entry.name.endsWith(".md")
+  ).map((entry) => entry.name).sort();
 }
-function displayPath(absolute, root, scope) {
-  if (scope === "global") return absolute.replace(os5.homedir(), "~");
-  const rel = absolute.startsWith(root) ? `.${absolute.slice(root.length)}` : absolute;
-  return rel;
+function displayBase(base, scope) {
+  if (scope === "global") return base.replace(os5.homedir(), "~");
+  return base;
 }
 async function listLocalForScopes(normalizedType, sections) {
+  const subdir = TYPE_SUBDIRS[normalizedType];
   console.log(pc4.bold(pc4.blue(`Installed ${normalizedType}s (Local):`)));
   let foundAny = false;
-  const platformsByOrder = [];
   for (const section of sections) {
-    for (const platform of Object.keys(section.paths)) {
-      if (!platformsByOrder.includes(platform)) platformsByOrder.push(platform);
-    }
-  }
-  for (const platform of platformsByOrder) {
-    let printedHeader = false;
-    for (const section of sections) {
-      const fullPath = section.paths[platform];
-      if (!fullPath) continue;
-      if (!await fs6.pathExists(fullPath)) continue;
-      const items = await collectItemsForPlatform(
-        platform,
-        fullPath,
-        normalizedType
-      );
-      if (items.length === 0) continue;
-      foundAny = true;
-      if (!printedHeader) {
-        console.log(pc4.cyan(`  ${platform}:`));
-        printedHeader = true;
+    const subdirPath = path6.join(section.base, subdir);
+    if (!await fs6.pathExists(subdirPath)) continue;
+    const items = await collectEntries(subdirPath);
+    if (items.length === 0) continue;
+    foundAny = true;
+    if (sections.length > 1) {
+      const scopeLabel = section.scope === "global" ? "Global" : "Project";
+      const display = displayBase(section.base, section.scope);
+      console.log(pc4.cyan(`  ${scopeLabel} (${display}):`));
+      for (const item of items) {
+        console.log(`    - ${item}`);
       }
-      if (sections.length > 1) {
-        const scopeLabel = section.scope === "global" ? "Global" : "Project";
-        const display = displayPath(fullPath, section.root, section.scope);
-        console.log(pc4.dim(`    ${scopeLabel} (${display}):`));
-        for (const item of items) {
-          console.log(`      - ${item}`);
-        }
-      } else {
-        for (const item of items) {
-          console.log(`    - ${item}`);
-        }
+    } else {
+      for (const item of items) {
+        console.log(`  - ${item}`);
       }
     }
   }
@@ -1411,33 +1199,21 @@ async function listLocalForScopes(normalizedType, sections) {
   }
   console.log("");
 }
-function buildSections(normalizedType, scope, homedir, projectRoot) {
+function buildSections(scope, projectRoot) {
   const sections = [];
   if (scope === "global" || scope === "both") {
+    sections.push({ scope: "global", base: getAgentsBase("global") });
+  }
+  if ((scope === "project" || scope === "both") && projectRoot) {
     sections.push({
-      scope: "global",
-      root: homedir,
-      paths: getTargetPaths(normalizedType, "global")
+      scope: "project",
+      base: getAgentsBase("project", projectRoot)
     });
   }
-  if (scope === "project" || scope === "both") {
-    if (projectRoot) {
-      sections.push({
-        scope: "project",
-        root: projectRoot,
-        paths: getTargetPaths(normalizedType, "project", projectRoot)
-      });
-    }
-  }
   return sections;
 }
-async function performListing(type, local) {
+async function performListing(type) {
   const normalizedType = type.toLowerCase().endsWith("s") ? type.slice(0, -1) : type.toLowerCase();
-  if (local) {
-    throw new Error(
-      "performListing should not be called for local mode; use listLocalForScopes"
-    );
-  }
   if (!TYPE_DIRS[normalizedType]) {
     console.error(
       pc4.red(`Unknown type: ${type}. Supported types: skill, agent, workflow`)
@@ -1519,16 +1295,14 @@ async function list(type, options) {
         for (const t of typesToList) {
           const normalizedType = t.toLowerCase().endsWith("s") ? t.slice(0, -1) : t.toLowerCase();
           const sections = buildSections(
-            normalizedType,
             scopeChoice.scope,
-            scopeChoice.homedir,
             scopeChoice.projectRoot
           );
           await listLocalForScopes(normalizedType, sections);
         }
       } else {
         for (const t of typesToList) {
-          await performListing(t, false);
+          await performListing(t);
         }
       }
       if (isSingleShot) break;
@@ -1543,14 +1317,13 @@ async function list(type, options) {
 }
 
 // src/commands/remove.ts
-import path8 from "node:path";
+import path7 from "node:path";
 import {
   autocompleteMultiselect as autocompleteMultiselect2,
   cancel as cancel4,
   confirm as confirm3,
   intro as intro4,
   isCancel as isCancel5,
-  multiselect as multiselect2,
   note as note3,
   outro as outro4,
   select as select5,
@@ -1559,57 +1332,83 @@ import {
 import fs7 from "fs-extra";
 import pc5 from "picocolors";
 enableAutocompleteMultiSelectShiftAToggle();
-function buildScopedTargetPaths(normalizedType, scope, projectRoot) {
+function buildScopedBases(scope, homedir, projectRoot) {
   const out = [];
   if (scope === "global" || scope === "both") {
     out.push({
       scope: "global",
-      paths: getTargetPaths(normalizedType, "global")
+      base: getAgentsBase("global"),
+      root: homedir
     });
   }
   if ((scope === "project" || scope === "both") && projectRoot) {
     out.push({
       scope: "project",
-      paths: getTargetPaths(normalizedType, "project", projectRoot)
+      base: getAgentsBase("project", projectRoot),
+      root: projectRoot
     });
   }
   return out;
 }
-async function scanInstalledItems(scopedPaths, normalizedType) {
+async function scanInstalledItems(scopedBases, subdir, normalizedType) {
   const seen = /* @__PURE__ */ new Set();
   const items = [];
-  const showScopePrefix = scopedPaths.length > 1;
-  for (const { scope, paths } of scopedPaths) {
-    for (const [platform, pathStr] of Object.entries(paths)) {
-      if (!pathStr) continue;
-      if (!await fs7.pathExists(pathStr)) continue;
-      const entries = await fs7.readdir(pathStr, { withFileTypes: true });
-      for (const entry of entries) {
-        let qualifies = false;
-        if (platform === "codex") {
-          qualifies = await codexEntryMatchesType(
-            pathStr,
-            entry,
-            normalizedType
-          );
-        } else if (entry.isDirectory() || normalizedType === "workflow" && entry.isFile() && entry.name.endsWith(".md") || normalizedType === "agent" && entry.isFile() && entry.name.endsWith(".md")) {
-          qualifies = true;
-        }
-        if (!qualifies) continue;
-        const key = showScopePrefix ? `${scope}:${entry.name}` : entry.name;
-        if (seen.has(key)) continue;
-        seen.add(key);
-        items.push({
-          key,
-          name: entry.name,
-          scope,
-          label: showScopePrefix ? `[${scope}] ${entry.name}` : entry.name
-        });
-      }
+  const showScopePrefix = scopedBases.length > 1;
+  for (const { scope, base } of scopedBases) {
+    const subdirPath = path7.join(base, subdir);
+    if (!await fs7.pathExists(subdirPath)) continue;
+    const entries = await fs7.readdir(subdirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const qualifies = entry.isDirectory() || normalizedType !== "skill" && entry.isFile() && entry.name.endsWith(".md");
+      if (!qualifies) continue;
+      const key = showScopePrefix ? `${scope}:${entry.name}` : entry.name;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      items.push({
+        key,
+        name: entry.name,
+        scope,
+        label: showScopePrefix ? `[${scope}] ${entry.name}` : entry.name
+      });
     }
   }
   return items.sort((a, b) => a.label.localeCompare(b.label));
 }
+function getPlatformDirs(scope, root, normalizedType) {
+  if (scope === "project") {
+    switch (normalizedType) {
+      case "agent":
+        return getProjectPlatformPathsAgents(root);
+      case "workflow":
+        return getProjectPlatformPathsWorkflows(root);
+      default:
+        return getProjectPlatformPathsSkills(root);
+    }
+  }
+  switch (normalizedType) {
+    case "agent":
+      return PLATFORM_PATHS_AGENTS;
+    case "workflow":
+      return PLATFORM_PATHS_WORKFLOWS;
+    default:
+      return PLATFORM_PATHS_SKILLS;
+  }
+}
+async function pruneDanglingLinks(platformDirs, entry, removedAgentsPath) {
+  for (const dir of Object.values(platformDirs)) {
+    if (!dir) continue;
+    const link = path7.join(dir, entry);
+    try {
+      const stat = await fs7.lstat(link);
+      if (!stat.isSymbolicLink()) continue;
+      const resolved = await fs7.realpath(link).catch(() => "");
+      if (resolved === removedAgentsPath || resolved === "") {
+        await fs7.remove(link);
+      }
+    } catch {
+    }
+  }
+}
 async function remove(type, options) {
   if (!options?.skipIntro) {
     intro4(pc5.bgCyan(pc5.black(" AI Manager : Remove ")));
@@ -1633,6 +1432,7 @@ async function remove(type, options) {
       currentType = selectedType;
     }
     const normalizedType = currentType.toLowerCase().endsWith("s") ? currentType.slice(0, -1) : currentType;
+    const subdir = TYPE_SUBDIRS[normalizedType] ?? "skills";
     const scopeChoice = await chooseListRemoveScope({
       action: "remove",
       flag: options?.scope
@@ -1649,14 +1449,18 @@ async function remove(type, options) {
       currentType = void 0;
       continue;
     }
-    const scopedPaths = buildScopedTargetPaths(
-      normalizedType,
+    const scopedBases = buildScopedBases(
       scopeChoice.scope,
+      scopeChoice.homedir,
       scopeChoice.projectRoot
     );
     const s = spinner3();
     s.start("Scanning for installed items...");
-    const scannedItems = await scanInstalledItems(scopedPaths, normalizedType);
+    const scannedItems = await scanInstalledItems(
+      scopedBases,
+      subdir,
+      normalizedType
+    );
     s.stop(`Found ${scannedItems.length} installed ${normalizedType}s.`);
     if (scannedItems.length === 0) {
       note3(`No installed ${normalizedType}s found.`, "Information");
@@ -1678,30 +1482,8 @@ async function remove(type, options) {
     }
     const itemsByKey = new Map(scannedItems.map((i) => [i.key, i]));
     const selectedScannedItems = itemSelections.map((key) => itemsByKey.get(key)).filter((i) => !!i);
-    const supportedPlatforms = /* @__PURE__ */ new Set();
-    for (const { paths } of scopedPaths) {
-      for (const platform of Object.keys(paths)) {
-        if (paths[platform])
-          supportedPlatforms.add(platform);
-      }
-    }
-    const platformOptions = [...supportedPlatforms].map((platform) => ({
-      label: PLATFORM_LABELS[platform],
-      value: platform
-    }));
-    const platformSelections = await multiselect2({
-      message: "Select platforms to remove from:",
-      options: platformOptions,
-      required: true
-    });
-    if (isCancel5(platformSelections)) {
-      if (isSingleShot) break;
-      currentType = void 0;
-      continue;
-    }
-    const selectedPlatforms = platformSelections;
     const confirmDelete = await confirm3({
-      message: `Are you sure you want to remove ${selectedScannedItems.length} item(s) from ${selectedPlatforms.length} platform(s)?`,
+      message: `Are you sure you want to remove ${selectedScannedItems.length} item(s) from .agents?`,
       initialValue: false
     });
     if (isCancel5(confirmDelete) || !confirmDelete) {
@@ -1714,29 +1496,31 @@ async function remove(type, options) {
     let removedCount = 0;
     let notFoundCount = 0;
     const errors = [];
-    const pathsByScope = /* @__PURE__ */ new Map();
-    for (const { scope, paths } of scopedPaths) {
-      pathsByScope.set(scope, paths);
+    const basesByScope = /* @__PURE__ */ new Map();
+    for (const sb of scopedBases) {
+      basesByScope.set(sb.scope, sb);
     }
-    for (const platform of selectedPlatforms) {
-      for (const item of selectedScannedItems) {
-        const targetBase = pathsByScope.get(item.scope)?.[platform];
-        if (!targetBase) continue;
-        const targetPath = path8.join(targetBase, item.name);
-        if (await fs7.pathExists(targetPath)) {
-          sDel.message(
-            `Removing ${pc5.bold(item.label)} from ${pc5.cyan(platform)}...`
+    for (const item of selectedScannedItems) {
+      const scoped = basesByScope.get(item.scope);
+      if (!scoped) continue;
+      const agentsPath = path7.join(scoped.base, subdir, item.name);
+      if (await fs7.pathExists(agentsPath)) {
+        sDel.message(`Removing ${pc5.bold(item.label)} from .agents...`);
+        try {
+          await fs7.remove(agentsPath);
+          removedCount++;
+          const platformDirs = getPlatformDirs(
+            item.scope,
+            scoped.root,
+            normalizedType
           );
-          try {
-            await fs7.remove(targetPath);
-            removedCount++;
-          } catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            errors.push(`${item.label} (${platform}): ${msg}`);
-          }
-        } else {
-          notFoundCount++;
+          await pruneDanglingLinks(platformDirs, item.name, agentsPath);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          errors.push(`${item.label}: ${msg}`);
         }
+      } else {
+        notFoundCount++;
       }
     }
     if (errors.length > 0) {