asdm-cli 0.1.2 → 0.3.0

package/dist/index.mjs

@@ -10,33 +10,19 @@ var __export = (target, all) => {
 };
 
 // src/utils/fs.ts
-var fs_exports = {};
-__export(fs_exports, {
-  copyFile: () => copyFile,
-  ensureDir: () => ensureDir,
-  exists: () => exists,
-  getAsdmCacheDir: () => getAsdmCacheDir,
-  getAsdmConfigDir: () => getAsdmConfigDir,
-  listFiles: () => listFiles,
-  normalizePath: () => normalizePath,
-  readFile: () => readFile,
-  readJson: () => readJson,
-  removeFile: () => removeFile,
-  writeFile: () => writeFile,
-  writeJson: () => writeJson
-});
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";
-function normalizePath(p) {
-  return p.replace(/\\/g, "/");
-}
 async function ensureDir(dirPath) {
   await fs.mkdir(dirPath, { recursive: true });
 }
 async function writeFile(filePath, content) {
   await ensureDir(path.dirname(filePath));
-  await fs.writeFile(filePath, content, "utf-8");
+  if (typeof content === "string") {
+    await fs.writeFile(filePath, content, "utf-8");
+  } else {
+    await fs.writeFile(filePath, content);
+  }
 }
 async function readFile(filePath) {
   try {
@@ -80,6 +66,23 @@ async function listFiles(dirPath) {
 function getAsdmConfigDir() {
   return path.join(os.homedir(), ".config", "asdm");
 }
+function resolveGlobalEmitPath(relativePath, provider) {
+  const prefix = PROVIDER_PATH_PREFIXES[provider];
+  const globalDir = PROVIDER_GLOBAL_DIRS[provider];
+  if (!prefix || !globalDir) return null;
+  if (!relativePath.startsWith(prefix)) return null;
+  const stripped = relativePath.slice(prefix.length);
+  const resolved = path.resolve(globalDir, stripped);
+  const safeBase = path.resolve(globalDir) + path.sep;
+  if (!resolved.startsWith(safeBase)) return null;
+  return resolved;
+}
+function getGlobalLockfilePath() {
+  return path.join(getAsdmConfigDir(), "global-lock.json");
+}
+function getGlobalConfigPath() {
+  return path.join(getAsdmConfigDir(), "config.json");
+}
 function getAsdmCacheDir() {
   const xdgCache = process.env["XDG_CACHE_HOME"];
   if (xdgCache) return path.join(xdgCache, "asdm");
@@ -93,13 +96,23 @@ async function readJson(filePath) {
 async function writeJson(filePath, data) {
   await writeFile(filePath, JSON.stringify(data, null, 2));
 }
-async function copyFile(src, dest) {
-  await ensureDir(path.dirname(dest));
-  await fs.copyFile(src, dest);
-}
+var PROVIDER_GLOBAL_DIRS, PROVIDER_PATH_PREFIXES;
 var init_fs = __esm({
   "src/utils/fs.ts"() {
     "use strict";
+    PROVIDER_GLOBAL_DIRS = {
+      opencode: process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "opencode") : path.join(os.homedir(), ".config", "opencode"),
+      "claude-code": process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "Claude") : path.join(os.homedir(), ".claude"),
+      copilot: process.platform === "win32" ? path.join(os.homedir(), "AppData", "Roaming", "GitHub Copilot") : path.join(os.homedir(), ".config", "github-copilot"),
+      // agents-dir uses %USERPROFILE%\.agents on all platforms (no AppData variant)
+      "agents-dir": path.join(os.homedir(), ".agents")
+    };
+    PROVIDER_PATH_PREFIXES = {
+      opencode: ".opencode/",
+      "claude-code": ".claude/",
+      copilot: ".github/",
+      "agents-dir": ".agents/"
+    };
   }
 });
 
@@ -531,8 +544,79 @@ var init_copilot = __esm({
   }
 });
 
+// src/adapters/agents-dir.ts
+var agents_dir_exports = {};
+__export(agents_dir_exports, {
+  AgentsDirAdapter: () => AgentsDirAdapter,
+  createAgentsDirAdapter: () => createAgentsDirAdapter
+});
+import path11 from "path";
+function formatAgentContent4(parsed) {
+  return [managedFileHeader(ADAPTER_NAME4), "", parsed.body].join("\n");
+}
+function formatSkillContent4(parsed) {
+  return [managedFileHeader(ADAPTER_NAME4), "", parsed.body].join("\n");
+}
+function formatCommandContent3(parsed) {
+  return [managedFileHeader(ADAPTER_NAME4), "", parsed.body].join("\n");
+}
+function createAgentsDirAdapter() {
+  return new AgentsDirAdapter();
+}
+var ADAPTER_NAME4, AgentsDirAdapter;
+var init_agents_dir = __esm({
+  "src/adapters/agents-dir.ts"() {
+    "use strict";
+    init_fs();
+    init_base();
+    ADAPTER_NAME4 = "agents-dir";
+    AgentsDirAdapter = class {
+      name = ADAPTER_NAME4;
+      emitAgent(parsed, _targetDir) {
+        const relativePath = `.agents/agents/${parsed.name}.md`;
+        const content = formatAgentContent4(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME4, parsed.sourcePath)];
+      }
+      emitSkill(parsed, _targetDir) {
+        const relativePath = `.agents/skills/${parsed.name}/SKILL.md`;
+        const content = formatSkillContent4(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME4, parsed.sourcePath)];
+      }
+      emitCommand(parsed, _targetDir) {
+        const relativePath = `.agents/commands/${parsed.name}.md`;
+        const content = formatCommandContent3(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME4, parsed.sourcePath)];
+      }
+      emitRootInstructions(_profile, _targetDir) {
+        return [];
+      }
+      emitConfig(_profile, _targetDir) {
+        return [];
+      }
+      /**
+       * Remove all ASDM-managed files from .agents/ in the given project root.
+       * Returns the list of absolute paths that were removed.
+       */
+      async clean(projectRoot) {
+        const agentsDir = path11.join(projectRoot, ".agents");
+        if (!await exists(agentsDir)) return [];
+        const allFiles = await listFiles(agentsDir);
+        const removedPaths = [];
+        for (const filePath of allFiles) {
+          const content = await readFile(filePath);
+          if (content && content.includes("ASDM MANAGED FILE")) {
+            await removeFile(filePath);
+            removedPaths.push(filePath);
+          }
+        }
+        return removedPaths;
+      }
+    };
+  }
+});
+
 // src/cli/index.ts
-import { defineCommand as defineCommand16, runMain } from "citty";
+import { defineCommand as defineCommand17, runMain } from "citty";
 
 // src/cli/commands/init.ts
 init_fs();
@@ -679,6 +763,26 @@ function parseRegistryUrl(url) {
   }
   return { org: match[1], repo: match[2] };
 }
+function validateProjectConfig(config, label) {
+  if (!config.registry) {
+    throw new ConfigError(`Missing required field 'registry' in ${label}`);
+  }
+  if (!config.profile) {
+    throw new ConfigError(`Missing required field 'profile' in ${label}`);
+  }
+  parseRegistryUrl(config.registry);
+}
+async function readProjectConfigFromPath(filePath) {
+  const config = await readJson(filePath);
+  if (!config) {
+    throw new ConfigError(
+      `No config found at ${filePath}`,
+      "Run `asdm init` to initialize"
+    );
+  }
+  validateProjectConfig(config, path3.basename(filePath));
+  return config;
+}
 async function readProjectConfig(cwd) {
   const filePath = path3.join(cwd, PROJECT_CONFIG_FILE);
   const config = await readJson(filePath);
@@ -688,13 +792,7 @@ async function readProjectConfig(cwd) {
       "Run `asdm init --profile <name>` to initialize"
     );
   }
-  if (!config.registry) {
-    throw new ConfigError(`Missing required field 'registry' in ${PROJECT_CONFIG_FILE}`);
-  }
-  if (!config.profile) {
-    throw new ConfigError(`Missing required field 'profile' in ${PROJECT_CONFIG_FILE}`);
-  }
-  parseRegistryUrl(config.registry);
+  validateProjectConfig(config, PROJECT_CONFIG_FILE);
   return config;
 }
 async function readUserConfig(cwd) {
@@ -729,8 +827,7 @@ Run \`asdm profiles\` to see available profiles`
     policy
   };
 }
-async function createProjectConfig(cwd, registry, profile, providers = ["opencode"]) {
-  const filePath = path3.join(cwd, PROJECT_CONFIG_FILE);
+async function createProjectConfigAtPath(filePath, registry, profile, providers = ["opencode"]) {
   const config = {
     $schema: "https://asdm.dev/schemas/config.schema.json",
     registry,
@@ -739,6 +836,10 @@ async function createProjectConfig(cwd, registry, profile, providers = ["opencod
   };
   await writeJson(filePath, config);
 }
+async function createProjectConfig(cwd, registry, profile, providers = ["opencode"]) {
+  const filePath = path3.join(cwd, PROJECT_CONFIG_FILE);
+  await createProjectConfigAtPath(filePath, registry, profile, providers);
+}
 
 // src/core/telemetry.ts
 init_hash();
@@ -755,7 +856,7 @@ var TelemetryWriter = class {
     const fullEvent = {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       machineId: machineId(),
-      version: "0.1.2",
+      version: "0.3.0",
       ...event
     };
     const line = JSON.stringify(fullEvent) + "\n";
@@ -924,7 +1025,12 @@ var init_default = defineCommand({
     },
     force: {
       type: "boolean",
-      description: "Overwrite existing .asdm.json",
+      description: "Overwrite existing config",
+      default: false
+    },
+    global: {
+      type: "boolean",
+      description: "Write config to ~/.config/asdm/config.json instead of .asdm.json",
       default: false
     },
     gitignore: {
@@ -935,15 +1041,36 @@ var init_default = defineCommand({
   },
   async run(ctx) {
     const cwd = process.cwd();
+    const profile = ctx.args.profile || "base";
+    const registry = ctx.args.registry || DEFAULT_REGISTRY;
+    const providers = ["opencode"];
+    if (ctx.args.global) {
+      const targetPath = getGlobalConfigPath();
+      const alreadyExists2 = await exists(targetPath);
+      if (alreadyExists2 && !ctx.args.force) {
+        logger.warn(`Global config already exists at ${targetPath}. Use --force to overwrite.`);
+        return;
+      }
+      try {
+        await ensureDir(path5.dirname(targetPath));
+        await createProjectConfigAtPath(targetPath, registry, profile, providers);
+        logger.success(`Global config written to ${targetPath}`);
+        logger.info(`Registry: ${registry}`);
+        logger.info("Next step: run `asdm sync --global` to install agents, skills, and commands");
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error(message);
+        process.exitCode = 1;
+        return;
+      }
+      return;
+    }
     const configPath = path5.join(cwd, ".asdm.json");
     const alreadyExists = await exists(configPath);
     if (alreadyExists && !ctx.args.force) {
       logger.warn(".asdm.json already exists. Use --force to overwrite.");
       return;
     }
-    const profile = ctx.args.profile || "base";
-    const registry = ctx.args.registry || DEFAULT_REGISTRY;
-    const providers = ["opencode"];
     try {
       await createProjectConfig(cwd, registry, profile, providers);
       logger.success(`Initialized .asdm.json with profile "${profile}"`);
@@ -973,9 +1100,10 @@ var init_default = defineCommand({
 
 // src/cli/commands/sync.ts
 import { defineCommand as defineCommand2 } from "citty";
+import path13 from "path";
 
 // src/core/syncer.ts
-import path11 from "path";
+import path12 from "path";
 
 // src/core/registry-client.ts
 var GITHUB_API_BASE = "https://api.github.com";
@@ -1244,16 +1372,16 @@ function diffManifest(manifest, localShas, assetPaths) {
 function getProfileAssetPaths(manifest, agentNames, skillNames, commandNames) {
   const paths = [];
   for (const name of agentNames) {
-    const path18 = `agents/${name}.asdm.md`;
-    if (manifest.assets[path18]) paths.push(path18);
+    const path22 = `agents/${name}.asdm.md`;
+    if (manifest.assets[path22]) paths.push(path22);
   }
   for (const name of skillNames) {
-    const path18 = `skills/${name}/SKILL.asdm.md`;
-    if (manifest.assets[path18]) paths.push(path18);
+    const path22 = `skills/${name}/SKILL.asdm.md`;
+    if (manifest.assets[path22]) paths.push(path22);
   }
   for (const name of commandNames) {
-    const path18 = `commands/${name}.asdm.md`;
-    if (manifest.assets[path18]) paths.push(path18);
+    const path22 = `commands/${name}.asdm.md`;
+    if (manifest.assets[path22]) paths.push(path22);
   }
   return paths;
 }
@@ -1264,13 +1392,13 @@ async function loadCachedManifest(cacheDir) {
 // src/core/lockfile.ts
 init_fs();
 import path7 from "path";
-var LOCKFILE_NAME = ".asdm-lock.json";
-async function readLockfile(cwd) {
-  const filePath = path7.join(cwd, LOCKFILE_NAME);
+var LOCKFILE_FILENAME = ".asdm-lock.json";
+async function readLockfile(cwd, lockfilePath) {
+  const filePath = lockfilePath ?? path7.join(cwd, LOCKFILE_FILENAME);
   return readJson(filePath);
 }
-async function writeLockfile(cwd, lockfile) {
-  const filePath = path7.join(cwd, LOCKFILE_NAME);
+async function writeLockfile(cwd, lockfile, lockfilePath) {
+  const filePath = lockfilePath ?? path7.join(cwd, LOCKFILE_FILENAME);
   await writeJson(filePath, {
     $schema: "https://asdm.dev/schemas/lock.schema.json",
     ...lockfile
@@ -1373,12 +1501,17 @@ async function loadAdapters(providers) {
         adapters.push(createCopilotAdapter2());
         break;
       }
+      case "agents-dir": {
+        const { createAgentsDirAdapter: createAgentsDirAdapter2 } = await Promise.resolve().then(() => (init_agents_dir(), agents_dir_exports));
+        adapters.push(createAgentsDirAdapter2());
+        break;
+      }
     }
   }
   return adapters;
 }
 async function getCliVersion() {
-  return "0.1.2";
+  return "0.3.0";
 }
 async function sync(options) {
   const startTime = Date.now();
@@ -1386,7 +1519,8 @@ async function sync(options) {
   options.telemetry?.write({ event: "sync.started" }).catch(() => {
   });
   try {
-    const projectConfig = await readProjectConfig(cwd);
+    const configFilePath = options.configPath ?? path12.join(cwd, ".asdm.json");
+    const projectConfig = await readProjectConfigFromPath(configFilePath);
     const userConfig = await readUserConfig(cwd);
     const client = new RegistryClient(projectConfig.registry);
     const manifest = await client.getLatestManifest();
@@ -1399,7 +1533,8 @@ async function sync(options) {
       resolvedProfile.skills,
       resolvedProfile.commands
     );
-    const existingLockfile = options.force ? null : await readLockfile(cwd);
+    const lockfilePath = options.global ? getGlobalLockfilePath() : void 0;
+    const existingLockfile = options.force ? null : await readLockfile(cwd, lockfilePath);
     const localSourceShas = {};
     if (existingLockfile) {
       for (const [, entry] of Object.entries(existingLockfile.files)) {
@@ -1410,7 +1545,7 @@ async function sync(options) {
     }
     const diff = diffManifest(manifest, localSourceShas, assetPaths);
     const toDownload = options.force ? assetPaths : [...diff.added, ...diff.updated];
-    const cacheDir = path11.join(getAsdmCacheDir(), manifest.version);
+    const cacheDir = path12.join(getAsdmCacheDir(), manifest.version);
     await ensureDir(cacheDir);
     const downloadedAssets = /* @__PURE__ */ new Map();
     for (const assetPath of toDownload) {
@@ -1424,17 +1559,16 @@ async function sync(options) {
           "The asset may have been tampered with or the manifest is stale. Run `asdm sync --force`."
         );
       }
-      const cachedPath = path11.join(cacheDir, assetPath);
+      const cachedPath = path12.join(cacheDir, assetPath);
       if (!options.dryRun) {
         await writeFile(cachedPath, content);
       }
       downloadedAssets.set(assetPath, content);
     }
     for (const assetPath of diff.unchanged) {
-      const cachedPath = path11.join(cacheDir, assetPath);
+      const cachedPath = path12.join(cacheDir, assetPath);
       try {
-        const { readFile: readFile2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        const cached = await readFile2(cachedPath);
+        const cached = await readFile(cachedPath);
         if (cached) downloadedAssets.set(assetPath, cached);
       } catch {
       }
@@ -1493,12 +1627,21 @@ async function sync(options) {
       const configFiles = adapter.emitConfig(resolvedProfile, cwd);
       allEmittedFiles.push(...configFiles);
     }
+    const resolvedPaths = /* @__PURE__ */ new Map();
     for (const emittedFile of allEmittedFiles) {
-      const absolutePath = path11.join(cwd, emittedFile.relativePath);
+      const absolutePath = options.global ? resolveGlobalEmitPath(emittedFile.relativePath, emittedFile.adapter) : path12.join(cwd, emittedFile.relativePath);
+      if (absolutePath !== null) {
+        resolvedPaths.set(emittedFile.relativePath, absolutePath);
+      }
+    }
+    for (const emittedFile of allEmittedFiles) {
+      const absolutePath = resolvedPaths.get(emittedFile.relativePath);
+      if (absolutePath === void 0) continue;
       await writeFile(absolutePath, emittedFile.content);
     }
     const lockfileFiles = {};
     for (const emittedFile of allEmittedFiles) {
+      if (!resolvedPaths.has(emittedFile.relativePath)) continue;
       lockfileFiles[emittedFile.relativePath] = createLockEntry(
         emittedFile.sha256,
         emittedFile.sourcePath,
@@ -1515,7 +1658,7 @@ async function sync(options) {
       resolvedProfiles: resolvedProfile.resolvedFrom,
       files: lockfileFiles
     });
-    await writeLockfile(cwd, lockfile);
+    await writeLockfile(cwd, lockfile, lockfilePath);
     const stats = {
       filesAdded: diff.added.length,
       filesUpdated: diff.updated.length,
@@ -1547,6 +1690,19 @@ async function sync(options) {
 }
 
 // src/cli/commands/sync.ts
+init_fs();
+async function resolveConfigPath(cwd, isGlobal) {
+  const localPath = path13.join(cwd, ".asdm.json");
+  if (await exists(localPath)) return localPath;
+  if (isGlobal) {
+    const globalPath = getGlobalConfigPath();
+    if (await exists(globalPath)) return globalPath;
+  }
+  throw new ConfigError(
+    "No config found.",
+    isGlobal ? "Run `asdm init` (project) or `asdm init --global` (machine-wide setup)." : "Run `asdm init` to initialize this project."
+  );
+}
 var sync_default = defineCommand2({
   meta: {
     name: "sync",
@@ -1571,6 +1727,11 @@ var sync_default = defineCommand2({
     provider: {
       type: "string",
       description: "Sync only for a specific provider"
+    },
+    global: {
+      type: "boolean",
+      description: "Install to global provider config directories instead of project-local folders",
+      default: false
     }
   },
   async run(ctx) {
@@ -1584,12 +1745,15 @@ var sync_default = defineCommand2({
     logger.asdm("Starting sync\u2026");
     const telemetry = new TelemetryWriter(cwd);
     try {
+      const configPath = await resolveConfigPath(cwd, ctx.args.global ?? false);
       const result = await sync({
         cwd,
+        configPath,
         force: ctx.args.force,
         dryRun,
         verbose,
         provider: ctx.args.provider,
+        global: ctx.args.global ?? false,
         telemetry
       });
       const { stats } = result;
@@ -1626,7 +1790,7 @@ var sync_default = defineCommand2({
 import { defineCommand as defineCommand3 } from "citty";
 
 // src/core/verifier.ts
-import path12 from "path";
+import path14 from "path";
 init_hash();
 init_fs();
 var VERIFY_EXIT_CODES = {
@@ -1635,8 +1799,9 @@ var VERIFY_EXIT_CODES = {
   NO_LOCK: 2,
   OUTDATED: 3
 };
-async function verify(cwd, latestManifestVersion, onlyManaged = true, telemetry) {
-  const lockfile = await readLockfile(cwd);
+async function verify(cwd, latestManifestVersion, onlyManaged = true, telemetry, lockfilePath) {
+  const lockfile = await readLockfile(cwd, lockfilePath);
+  const isGlobal = lockfilePath !== void 0;
   if (!lockfile) {
     telemetry?.write({ event: "verify.failed" }).catch(() => {
     });
@@ -1650,7 +1815,7 @@ async function verify(cwd, latestManifestVersion, onlyManaged = true, telemetry)
   let checkedFiles = 0;
   const filesToCheck = onlyManaged ? Object.entries(lockfile.files).filter(([, entry]) => entry.managed) : Object.entries(lockfile.files);
   for (const [relativePath, entry] of filesToCheck) {
-    const absolutePath = path12.join(cwd, relativePath);
+    const absolutePath = isGlobal ? resolveGlobalEmitPath(relativePath, entry.adapter) ?? path14.join(cwd, relativePath) : path14.join(cwd, relativePath);
     checkedFiles++;
     const fileExists = await exists(absolutePath);
     if (!fileExists) {
@@ -1694,6 +1859,17 @@ async function verify(cwd, latestManifestVersion, onlyManaged = true, telemetry)
 }
 
 // src/cli/commands/verify.ts
+init_fs();
+async function fetchLatestManifestVersion(cwd) {
+  try {
+    const config = await readProjectConfig(cwd);
+    const client = new RegistryClient(config.registry);
+    const manifest = await client.getLatestManifest();
+    return manifest.version;
+  } catch {
+    return void 0;
+  }
+}
 var verify_default = defineCommand3({
   meta: {
     name: "verify",
@@ -1714,6 +1890,16 @@ var verify_default = defineCommand3({
       type: "boolean",
       description: "Suppress non-error output",
       default: false
+    },
+    global: {
+      type: "boolean",
+      description: "Verify files installed to global provider config directories",
+      default: false
+    },
+    offline: {
+      type: "boolean",
+      description: "Skip remote manifest version check (exit code 3 will never trigger)",
+      default: false
     }
   },
   async run(ctx) {
@@ -1722,8 +1908,9 @@ var verify_default = defineCommand3({
     const quiet = ctx.args.quiet;
     if (quiet) logger.setQuiet(true);
     const telemetry = new TelemetryWriter(cwd);
+    const lockfilePath = ctx.args.global ? getGlobalLockfilePath() : void 0;
     if (ctx.args.strict) {
-      const result = await verify(cwd, void 0, true, telemetry);
+      const result = await verify(cwd, void 0, true, telemetry, lockfilePath);
       if (useJson) {
         console.log(JSON.stringify({
           status: result.exitCode === VERIFY_EXIT_CODES.OK ? "ok" : "error",
@@ -1740,16 +1927,20 @@ var verify_default = defineCommand3({
       process.exitCode = result.exitCode;
       return;
     }
+    let latestManifestVersion;
+    if (!ctx.args.offline && !ctx.args.global) {
+      latestManifestVersion = await fetchLatestManifestVersion(cwd);
+    }
     try {
-      const result = await verify(cwd, void 0, true, telemetry);
+      const result = await verify(cwd, latestManifestVersion, true, telemetry, lockfilePath);
       if (useJson) {
         console.log(JSON.stringify(result, null, 2));
         process.exitCode = result.exitCode;
         return;
       }
       if (result.exitCode === VERIFY_EXIT_CODES.NO_LOCK) {
-        logger.warn("No lockfile found (.asdm-lock.json)");
-        logger.info("Run `asdm sync` to initialize");
+        logger.warn(lockfilePath ? "No global lockfile found" : "No lockfile found (.asdm-lock.json)");
+        logger.info(lockfilePath ? "Run `asdm sync --global` to initialize" : "Run `asdm sync` to initialize");
         process.exitCode = VERIFY_EXIT_CODES.NO_LOCK;
         return;
       }
@@ -2252,7 +2443,7 @@ var version_default = defineCommand10({
     description: "Print CLI version and environment info"
   },
   run(_ctx) {
-    console.log(`asdm v${"0.1.2"}`);
+    console.log(`asdm v${"0.3.0"}`);
     console.log(`node  ${process.version}`);
     console.log(`os    ${os3.type()} ${os3.release()} (${process.platform})`);
   }
@@ -2260,11 +2451,11 @@ var version_default = defineCommand10({
 
 // src/cli/commands/doctor.ts
 import { defineCommand as defineCommand11 } from "citty";
-import path14 from "path";
+import path16 from "path";
 
 // src/core/overlay.ts
 init_fs();
-import path13 from "path";
+import path15 from "path";
 import { promises as fs4 } from "fs";
 var OVERLAY_SEPARATOR = [
   "",
@@ -2275,7 +2466,7 @@ var OVERLAY_SEPARATOR = [
   ""
 ].join("\n");
 async function readOverlays(projectRoot) {
-  const overlaysDir = path13.join(projectRoot, "overlays");
+  const overlaysDir = path15.join(projectRoot, "overlays");
   const dirExists = await exists(overlaysDir);
   if (!dirExists) return /* @__PURE__ */ new Map();
   const entries = await fs4.readdir(overlaysDir, { withFileTypes: true });
@@ -2283,7 +2474,7 @@ async function readOverlays(projectRoot) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".md")) continue;
     const agentId = entry.name.slice(0, -".md".length);
-    const overlayPath = path13.join(overlaysDir, entry.name);
+    const overlayPath = path15.join(overlaysDir, entry.name);
     const content = await readFile(overlayPath);
     if (content === null) continue;
     overlayMap.set(agentId, { agentId, content, path: overlayPath });
@@ -2314,7 +2505,7 @@ var doctor_default = defineCommand11({
     let anyFailed = false;
     let projectConfig = null;
     let registryClient = null;
-    const configPath = path14.join(cwd, ".asdm.json");
+    const configPath = path16.join(cwd, ".asdm.json");
     const hasConfig = await exists(configPath);
     checks.push({
       label: ".asdm.json present",
@@ -2379,10 +2570,10 @@ var doctor_default = defineCommand11({
       }
       const managedEntries = Object.entries(lockfile.files).filter(([, e]) => e.managed);
       const missingFiles = [];
-      const resolvedCwd = path14.resolve(cwd);
+      const resolvedCwd = path16.resolve(cwd);
       for (const [filePath] of managedEntries) {
-        const absPath = path14.resolve(cwd, filePath);
-        if (!absPath.startsWith(resolvedCwd + path14.sep) && absPath !== resolvedCwd) {
+        const absPath = path16.resolve(cwd, filePath);
+        if (!absPath.startsWith(resolvedCwd + path16.sep) && absPath !== resolvedCwd) {
           continue;
         }
         const fileExists = await exists(absPath);
@@ -2437,7 +2628,7 @@ var doctor_default = defineCommand11({
         detail: "Skipped \u2014 no lockfile"
       });
     }
-    const gitignoreContent = await readFile(path14.join(cwd, ".gitignore"));
+    const gitignoreContent = await readFile(path16.join(cwd, ".gitignore"));
     const hasAsdmBlock = gitignoreContent?.includes(ASDM_MARKER_START) ?? false;
     checks.push({
       label: ".gitignore has ASDM block",
@@ -2491,11 +2682,11 @@ var doctor_default = defineCommand11({
 
 // src/cli/commands/clean.ts
 import { defineCommand as defineCommand12 } from "citty";
-import path15 from "path";
+import path17 from "path";
 import { promises as fs5 } from "fs";
 import readline from "readline";
 init_fs();
-var LOCKFILE_NAME2 = ".asdm-lock.json";
+var LOCKFILE_NAME = ".asdm-lock.json";
 async function getFileSizeBytes(filePath) {
   try {
     const stat = await fs5.stat(filePath);
@@ -2533,9 +2724,14 @@ var clean_default = defineCommand12({
       description: "Preview what would be removed without deleting",
       default: false
     },
+    global: {
+      type: "boolean",
+      description: "Clean files installed to global provider config directories",
+      default: false
+    },
     target: {
       type: "string",
-      description: "Only clean files for a specific provider (opencode | claude-code | copilot)",
+      description: "Only clean files for a specific provider (opencode | claude-code | copilot | agents-dir)",
       alias: "t"
     }
   },
@@ -2543,119 +2739,226 @@ var clean_default = defineCommand12({
     const cwd = process.cwd();
     const dryRun = ctx.args["dry-run"];
     const target = ctx.args.target;
+    const isGlobal = ctx.args.global ?? false;
     if (dryRun) {
       logger.info("Dry run \u2014 no files will be removed");
     }
-    const lockfile = await readLockfile(cwd);
-    if (!lockfile) {
-      logger.warn("No lockfile found \u2014 nothing to clean");
+    if (isGlobal) {
+      await runGlobalClean(dryRun, target);
       return;
     }
-    const managedEntries = Object.entries(lockfile.files).filter(([, entry]) => {
-      if (!entry.managed) return false;
-      if (target) return entry.adapter === target;
-      return true;
-    });
-    if (managedEntries.length === 0) {
-      if (target) {
-        logger.warn(`No managed files found for provider "${target}"`);
-      } else {
-        logger.warn("No managed files found \u2014 nothing to clean");
-      }
+    await runLocalClean(cwd, dryRun, target);
+  }
+});
+async function runGlobalClean(dryRun, target) {
+  const globalLockfilePath = getGlobalLockfilePath();
+  const lockfile = await readLockfile(process.cwd(), globalLockfilePath);
+  if (!lockfile) {
+    logger.warn("No global lockfile found \u2014 nothing to clean");
+    return;
+  }
+  const managedEntries = Object.entries(lockfile.files).filter(([, entry]) => {
+    if (!entry.managed) return false;
+    if (target) return entry.adapter === target;
+    return true;
+  });
+  if (managedEntries.length === 0) {
+    if (target) {
+      logger.warn(`No globally managed files found for provider "${target}"`);
+    } else {
+      logger.warn("No globally managed files found \u2014 nothing to clean");
+    }
+    return;
+  }
+  if (!dryRun && process.stdout.isTTY && process.stdin.isTTY) {
+    const suffix = target ? ` for provider "${target}"` : "";
+    const confirmed = await confirmPrompt(
+      `About to delete ${managedEntries.length} globally managed file(s)${suffix}. Continue? [y/N] `
+    );
+    if (!confirmed) {
+      logger.info("Aborted \u2014 no files were removed");
       return;
     }
-    const managedPaths = managedEntries.map(([filePath]) => filePath);
-    const resolvedCwd = path15.resolve(cwd);
-    const safePaths = managedPaths.filter((relativePath) => {
-      const absPath = path15.resolve(cwd, relativePath);
-      return absPath.startsWith(resolvedCwd + path15.sep) || absPath === resolvedCwd;
-    });
-    const skippedSuspicious = managedPaths.length - safePaths.length;
-    if (skippedSuspicious > 0) {
-      logger.warn(`Skipping ${skippedSuspicious} path(s) outside project root`);
-    }
-    if (!dryRun && process.stdout.isTTY && process.stdin.isTTY) {
-      const suffix = target ? ` for provider "${target}"` : "";
-      const confirmed = await confirmPrompt(
-        `About to delete ${safePaths.length} file(s)${suffix}. Continue? [y/N] `
+  }
+  logger.asdm(`Cleaning ${managedEntries.length} globally managed file(s)\u2026`);
+  logger.divider();
+  let removed = 0;
+  let skippedMissing = 0;
+  let totalBytesFreed = 0;
+  for (const [relativePath, entry] of managedEntries) {
+    const absolutePath = resolveGlobalEmitPath(relativePath, entry.adapter);
+    if (absolutePath === null) {
+      logger.dim(`  skip  ${relativePath} (project-root file, not applicable in global mode)`);
+      skippedMissing++;
+      continue;
+    }
+    const filePresent = await exists(absolutePath);
+    if (!filePresent) {
+      logger.dim(`  skip  ${absolutePath} (not found)`);
+      skippedMissing++;
+      continue;
+    }
+    if (dryRun) {
+      logger.bullet(`would remove: ${absolutePath}`);
+      removed++;
+      continue;
+    }
+    const fileSize = await getFileSizeBytes(absolutePath);
+    await removeFile(absolutePath);
+    totalBytesFreed += fileSize;
+    logger.bullet(`removed: ${absolutePath}`);
+    removed++;
+  }
+  const lockfilePresent = await exists(globalLockfilePath);
+  if (target) {
+    if (!dryRun && lockfilePresent) {
+      const updatedFiles = Object.fromEntries(
+        Object.entries(lockfile.files).filter(([, entry]) => entry.adapter !== target)
       );
-      if (!confirmed) {
-        logger.info("Aborted \u2014 no files were removed");
-        return;
+      const hasRemainingEntries = Object.keys(updatedFiles).length > 0;
+      if (hasRemainingEntries) {
+        await writeLockfile(process.cwd(), { ...lockfile, files: updatedFiles }, globalLockfilePath);
+        logger.bullet(`updated: global lockfile (removed ${target} entries)`);
+      } else {
+        await removeFile(globalLockfilePath);
+        logger.bullet(`removed: global lockfile (no entries remaining)`);
       }
+    } else if (dryRun) {
+      logger.bullet(`would update: global lockfile (remove ${target} entries)`);
     }
-    logger.asdm(`Cleaning ${safePaths.length} managed file(s)\u2026`);
-    logger.divider();
-    let removed = 0;
-    let skippedMissing = 0;
-    let totalBytesFreed = 0;
-    for (const relativePath of safePaths) {
-      const absolutePath = path15.resolve(cwd, relativePath);
-      const fileExists = await exists(absolutePath);
-      if (!fileExists) {
-        logger.dim(`  skip  ${relativePath} (not found)`);
-        skippedMissing++;
-        continue;
-      }
+  } else {
+    if (lockfilePresent) {
       if (dryRun) {
-        logger.bullet(`would remove: ${relativePath}`);
-        removed++;
-        continue;
-      }
-      const fileSize = await getFileSizeBytes(absolutePath);
-      await removeFile(absolutePath);
-      totalBytesFreed += fileSize;
-      logger.bullet(`removed: ${relativePath}`);
-      removed++;
+        logger.bullet(`would remove: global lockfile`);
+      } else {
+        const lockfileSize = await getFileSizeBytes(globalLockfilePath);
+        await removeFile(globalLockfilePath);
+        totalBytesFreed += lockfileSize;
+        logger.bullet(`removed: global lockfile`);
+      }
     }
-    const lockfilePath = path15.join(cwd, LOCKFILE_NAME2);
-    const lockfileOnDisk = await exists(lockfilePath);
+  }
+  logger.divider();
+  if (dryRun) {
+    const suffix = target ? ` for provider "${target}"` : "";
+    logger.info(`${removed} file(s) would be removed${suffix}, ${skippedMissing} skipped`);
+    logger.info("Run without --dry-run to actually remove them");
+  } else {
+    const suffix = target ? ` (${target})` : "";
+    logger.success(`Cleaned ${removed} globally managed file(s)${suffix} \u2014 ${formatBytes(totalBytesFreed)} freed`);
+    if (skippedMissing > 0) logger.dim(`  ${skippedMissing} file(s) were already missing`);
+    logger.info("Run `asdm sync --global` to reinstall");
+  }
+}
+async function runLocalClean(cwd, dryRun, target) {
+  const lockfile = await readLockfile(cwd);
+  if (!lockfile) {
+    logger.warn("No lockfile found \u2014 nothing to clean");
+    return;
+  }
+  const managedEntries = Object.entries(lockfile.files).filter(([, entry]) => {
+    if (!entry.managed) return false;
+    if (target) return entry.adapter === target;
+    return true;
+  });
+  if (managedEntries.length === 0) {
     if (target) {
-      if (!dryRun && lockfileOnDisk) {
-        const updatedFiles = Object.fromEntries(
-          Object.entries(lockfile.files).filter(([, entry]) => entry.adapter !== target)
-        );
-        await writeLockfile(cwd, { ...lockfile, files: updatedFiles });
-        logger.bullet(`updated: ${LOCKFILE_NAME2} (removed ${target} entries)`);
-      } else if (dryRun) {
-        logger.bullet(`would update: ${LOCKFILE_NAME2} (remove ${target} entries)`);
-      }
+      logger.warn(`No managed files found for provider "${target}"`);
     } else {
-      if (lockfileOnDisk) {
-        if (dryRun) {
-          logger.bullet(`would remove: ${LOCKFILE_NAME2}`);
-        } else {
-          const lockfileSize = await getFileSizeBytes(lockfilePath);
-          await removeFile(lockfilePath);
-          totalBytesFreed += lockfileSize;
-          logger.bullet(`removed: ${LOCKFILE_NAME2}`);
-        }
-      }
+      logger.warn("No managed files found \u2014 nothing to clean");
+    }
+    return;
+  }
+  const managedPaths = managedEntries.map(([filePath]) => filePath);
+  const resolvedCwd = path17.resolve(cwd);
+  const safePaths = managedPaths.filter((relativePath) => {
+    const absPath = path17.resolve(cwd, relativePath);
+    return absPath.startsWith(resolvedCwd + path17.sep) || absPath === resolvedCwd;
+  });
+  const skippedSuspicious = managedPaths.length - safePaths.length;
+  if (skippedSuspicious > 0) {
+    logger.warn(`Skipping ${skippedSuspicious} path(s) outside project root`);
+  }
+  if (!dryRun && process.stdout.isTTY && process.stdin.isTTY) {
+    const suffix = target ? ` for provider "${target}"` : "";
+    const confirmed = await confirmPrompt(
+      `About to delete ${safePaths.length} file(s)${suffix}. Continue? [y/N] `
+    );
+    if (!confirmed) {
+      logger.info("Aborted \u2014 no files were removed");
+      return;
+    }
+  }
+  logger.asdm(`Cleaning ${safePaths.length} managed file(s)\u2026`);
+  logger.divider();
+  let removed = 0;
+  let skippedMissing = 0;
+  let totalBytesFreed = 0;
+  for (const relativePath of safePaths) {
+    const absolutePath = path17.resolve(cwd, relativePath);
+    const filePresent = await exists(absolutePath);
+    if (!filePresent) {
+      logger.dim(`  skip  ${relativePath} (not found)`);
+      skippedMissing++;
+      continue;
     }
-    logger.divider();
     if (dryRun) {
-      const suffix = target ? ` for provider "${target}"` : "";
-      logger.info(`${removed} file(s) would be removed${suffix}, ${skippedMissing} not found`);
-      logger.info("Run without --dry-run to actually remove them");
-    } else {
-      const suffix = target ? ` (${target})` : "";
-      logger.success(`Cleaned ${removed} managed file(s)${suffix} \u2014 ${formatBytes(totalBytesFreed)} freed`);
-      if (skippedMissing > 0) logger.dim(`  ${skippedMissing} file(s) were already missing`);
-      logger.info("Run `asdm sync` to reinstall");
+      logger.bullet(`would remove: ${relativePath}`);
+      removed++;
+      continue;
+    }
+    const fileSize = await getFileSizeBytes(absolutePath);
+    await removeFile(absolutePath);
+    totalBytesFreed += fileSize;
+    logger.bullet(`removed: ${relativePath}`);
+    removed++;
+  }
+  const lockfilePath = path17.join(cwd, LOCKFILE_NAME);
+  const lockfileOnDisk = await exists(lockfilePath);
+  if (target) {
+    if (!dryRun && lockfileOnDisk) {
+      const updatedFiles = Object.fromEntries(
+        Object.entries(lockfile.files).filter(([, entry]) => entry.adapter !== target)
+      );
+      await writeLockfile(cwd, { ...lockfile, files: updatedFiles });
+      logger.bullet(`updated: ${LOCKFILE_NAME} (removed ${target} entries)`);
+    } else if (dryRun) {
+      logger.bullet(`would update: ${LOCKFILE_NAME} (remove ${target} entries)`);
+    }
+  } else {
+    if (lockfileOnDisk) {
+      if (dryRun) {
+        logger.bullet(`would remove: ${LOCKFILE_NAME}`);
+      } else {
+        const lockfileSize = await getFileSizeBytes(lockfilePath);
+        await removeFile(lockfilePath);
+        totalBytesFreed += lockfileSize;
+        logger.bullet(`removed: ${LOCKFILE_NAME}`);
+      }
     }
   }
-});
+  logger.divider();
+  if (dryRun) {
+    const suffix = target ? ` for provider "${target}"` : "";
+    logger.info(`${removed} file(s) would be removed${suffix}, ${skippedMissing} not found`);
+    logger.info("Run without --dry-run to actually remove them");
+  } else {
+    const suffix = target ? ` (${target})` : "";
+    logger.success(`Cleaned ${removed} managed file(s)${suffix} \u2014 ${formatBytes(totalBytesFreed)} freed`);
+    if (skippedMissing > 0) logger.dim(`  ${skippedMissing} file(s) were already missing`);
+    logger.info("Run `asdm sync` to reinstall");
+  }
+}
 
 // src/cli/commands/hooks.ts
 init_fs();
 import { defineCommand as defineCommand13 } from "citty";
-import path16 from "path";
+import path19 from "path";
 import { promises as fs6 } from "fs";
 
 // src/utils/post-merge-hook.ts
-function generatePostMergeHook() {
-  return `#!/usr/bin/env sh
-# ASDM MANAGED \u2014 post-merge hook
+function generatePostMergeHookBody() {
+  return `# ASDM MANAGED \u2014 post-merge hook
 if [ -f ".asdm.yaml" ] || [ -f ".asdm.json" ]; then
   echo "\u{1F504} ASDM: syncing after merge..."
   npx asdm sync
@@ -2663,43 +2966,108 @@ fi
 `;
 }
 
+// src/utils/husky-detect.ts
+init_fs();
+import path18 from "path";
+function parseMajorVersion(versionString) {
+  const stripped = versionString.replace(/^[^0-9]*/, "");
+  const majorPart = stripped.split(".")[0] ?? "";
+  const major = parseInt(majorPart, 10);
+  return isNaN(major) ? null : major;
+}
+function majorToHuskyVersion(major) {
+  return major >= 9 ? "v9+" : "v8";
+}
+async function detectHusky(cwd) {
+  const huskyDirPath = path18.join(cwd, ".husky");
+  const huskyDirExists = await exists(huskyDirPath);
+  const pkg = await readJson(path18.join(cwd, "package.json"));
+  const huskyVersionString = pkg?.devDependencies?.["husky"] ?? pkg?.dependencies?.["husky"];
+  if (huskyVersionString !== void 0) {
+    const major = parseMajorVersion(huskyVersionString);
+    const version2 = major !== null ? majorToHuskyVersion(major) : "v9+";
+    return {
+      detected: true,
+      version: version2,
+      huskyDir: huskyDirExists ? huskyDirPath : null
+    };
+  }
+  if (!huskyDirExists) {
+    return { detected: false, version: null, huskyDir: null };
+  }
+  const huskyShExists = await exists(path18.join(huskyDirPath, "_", "husky.sh"));
+  const version = huskyShExists ? "v8" : "v9+";
+  return {
+    detected: true,
+    version,
+    huskyDir: huskyDirPath
+  };
+}
+
 // src/cli/commands/hooks.ts
-var HOOK_DEFINITIONS = {
-  "pre-commit": {
-    relativePath: ".git/hooks/pre-commit",
-    content: `#!/usr/bin/env sh
-# ASDM \u2014 managed pre-commit hook
+var HOOK_BODIES = {
+  "pre-commit": `# ASDM \u2014 managed pre-commit hook
 # Verifies integrity of managed files before allowing commits.
 npx asdm verify --strict --quiet
 `,
-    marker: "ASDM \u2014 managed pre-commit hook",
-    description: "runs `asdm verify --strict --quiet` before every commit"
-  },
-  "post-merge": {
-    relativePath: ".git/hooks/post-merge",
-    content: generatePostMergeHook(),
-    marker: "ASDM MANAGED \u2014 post-merge hook",
-    description: "runs `asdm sync` after git pull/merge"
-  }
+  "post-merge": generatePostMergeHookBody()
+};
+var HOOK_MARKERS = {
+  "pre-commit": "ASDM \u2014 managed pre-commit hook",
+  "post-merge": "ASDM MANAGED \u2014 post-merge hook"
+};
+var HOOK_DESCRIPTIONS = {
+  "pre-commit": "runs `asdm verify --strict --quiet` before every commit",
+  "post-merge": "runs `asdm sync` after git pull/merge"
 };
 function resolveHookTypes(hookFlag) {
-  if (hookFlag === "pre-commit" || hookFlag === "post-merge") {
-    return [hookFlag];
-  }
+  if (hookFlag === "pre-commit" || hookFlag === "post-merge") return [hookFlag];
   return ["pre-commit", "post-merge"];
 }
-async function installHook(cwd, hookType) {
-  const def = HOOK_DEFINITIONS[hookType];
-  const hookPath = path16.join(cwd, def.relativePath);
-  const gitDir = path16.join(cwd, ".git");
-  const hasGit = await exists(gitDir);
-  if (!hasGit) {
-    logger.error("No .git directory found", "Run `git init` first");
-    process.exit(1);
+function determineHookMode(huskyInfo, noHusky) {
+  if (noHusky || !huskyInfo.detected) return "git";
+  if (huskyInfo.version === "v8") return "husky-v8";
+  return "husky-v9+";
+}
+function buildHookContent(body, mode) {
+  if (mode === "git") return `#!/usr/bin/env sh
+${body}`;
+  if (mode === "husky-v8") return `#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+${body}`;
+  return body;
+}
+function resolveHookDefinition(cwd, hookType, huskyInfo, noHusky) {
+  const mode = determineHookMode(huskyInfo, noHusky);
+  const body = HOOK_BODIES[hookType];
+  const marker = HOOK_MARKERS[hookType];
+  const description = HOOK_DESCRIPTIONS[hookType];
+  const relativePath = mode === "git" ? `.git/hooks/${hookType}` : `.husky/${hookType}`;
+  const content = buildHookContent(body, mode);
+  return {
+    absolutePath: path19.join(cwd, relativePath),
+    relativePath,
+    content,
+    marker,
+    description
+  };
+}
+async function installHook(cwd, hookType, huskyInfo, noHusky) {
+  const mode = determineHookMode(huskyInfo, noHusky);
+  const def = resolveHookDefinition(cwd, hookType, huskyInfo, noHusky);
+  if (mode === "git") {
+    const hasGit = await exists(path19.join(cwd, ".git"));
+    if (!hasGit) {
+      logger.error("No .git directory found", "Run `git init` first");
+      process.exit(1);
+    }
+  } else {
+    await ensureDir(path19.join(cwd, ".husky"));
   }
-  const hookExists = await exists(hookPath);
+  const hookExists = await exists(def.absolutePath);
   if (hookExists) {
-    const existing = await fs6.readFile(hookPath, "utf-8");
+    const existing = await fs6.readFile(def.absolutePath, "utf-8");
     if (existing.includes(def.marker)) {
       logger.info(`ASDM ${hookType} hook is already installed`);
       return;
@@ -2708,30 +3076,42 @@ async function installHook(cwd, hookType) {
     logger.warn(`Manual action required: add the ASDM logic to ${def.relativePath}`);
     process.exit(1);
   }
-  await writeFile(hookPath, def.content);
+  await writeFile(def.absolutePath, def.content);
   try {
-    await fs6.chmod(hookPath, 493);
+    await fs6.chmod(def.absolutePath, 493);
   } catch {
   }
   logger.success(`Installed ${hookType} hook at ${def.relativePath}`);
   logger.info(`The hook ${def.description}`);
 }
 async function uninstallHook(cwd, hookType) {
-  const def = HOOK_DEFINITIONS[hookType];
-  const hookPath = path16.join(cwd, def.relativePath);
-  const hookExists = await exists(hookPath);
-  if (!hookExists) {
-    logger.info(`No ${hookType} hook found \u2014 nothing to remove`);
-    return;
+  const marker = HOOK_MARKERS[hookType];
+  const candidates = [
+    {
+      relativePath: `.git/hooks/${hookType}`,
+      absolutePath: path19.join(cwd, ".git", "hooks", hookType)
+    },
+    {
+      relativePath: `.husky/${hookType}`,
+      absolutePath: path19.join(cwd, ".husky", hookType)
+    }
+  ];
+  let removed = false;
+  for (const { relativePath, absolutePath } of candidates) {
+    const hookExists = await exists(absolutePath);
+    if (!hookExists) continue;
+    const content = await fs6.readFile(absolutePath, "utf-8");
+    if (!content.includes(marker)) {
+      logger.warn(`A ${hookType} hook at ${relativePath} was not installed by ASDM \u2014 skipping`);
+      continue;
+    }
+    await removeFile(absolutePath);
+    logger.success(`Removed ASDM ${hookType} hook from ${relativePath}`);
+    removed = true;
   }
-  const content = await fs6.readFile(hookPath, "utf-8");
-  if (!content.includes(def.marker)) {
-    logger.warn(`The ${hookType} hook was not installed by ASDM \u2014 not removing it`);
-    logger.info(`If you want to remove it manually: rm ${def.relativePath}`);
-    process.exit(1);
+  if (!removed) {
+    logger.info(`No ASDM-managed ${hookType} hook found \u2014 nothing to remove`);
   }
-  await removeFile(hookPath);
-  logger.success(`Removed ASDM ${hookType} hook from ${def.relativePath}`);
 }
 var installCommand = defineCommand13({
   meta: {
@@ -2743,13 +3123,25 @@ var installCommand = defineCommand13({
       type: "string",
       description: "Which hook to install: pre-commit | post-merge | all",
       default: "all"
+    },
+    "no-husky": {
+      type: "boolean",
+      description: "Force .git/hooks/ mode even when Husky is detected",
+      default: false
     }
   },
   async run(ctx) {
     const cwd = process.cwd();
     const hookTypes = resolveHookTypes(ctx.args.hook);
+    const noHusky = ctx.args["no-husky"] ?? false;
+    const huskyInfo = noHusky ? { detected: false, version: null, huskyDir: null } : await detectHusky(cwd);
+    if (huskyInfo.detected) {
+      logger.info(`Using Husky hooks in .husky/ (${huskyInfo.version})`);
+    } else {
+      logger.info("Using Git hooks in .git/hooks/");
+    }
     for (const hookType of hookTypes) {
-      await installHook(cwd, hookType);
+      await installHook(cwd, hookType, huskyInfo, noHusky);
     }
   }
 });
@@ -2925,9 +3317,204 @@ var telemetry_default = defineCommand15({
   }
 });
 
+// src/cli/commands/templates.ts
+init_fs();
+import { defineCommand as defineCommand16 } from "citty";
+import path20 from "path";
+function generateAgentTemplate(name) {
+  return `---
+name: ${name}
+type: agent
+description: "Short description"
+version: "1.0.0"
+tags:
+  - tag1
+  - tag2
+providers:
+  opencode:
+    model: claude-sonnet-4-5
+    permissions: {}
+    tools: []
+  claude-code:
+    model: claude-opus-4-5
+    allowedTools: []
+  copilot:
+    on:
+      push:
+        branches: [main]
+    permissions:
+      contents: read
+---
+
+# ${name}
+
+## Role
+Describe the agent's primary responsibility here.
+
+## Instructions
+- Instruction 1
+- Instruction 2
+
+## Guidelines
+- Guideline 1
+- Guideline 2
+`;
+}
+function generateSkillTemplate(name) {
+  return `---
+name: ${name}
+type: skill
+description: "Short description"
+version: "1.0.0"
+tags:
+  - tag1
+---
+
+# ${name}
+
+## Overview
+Describe the skill purpose.
+
+## Usage
+How to use this skill.
+
+## Examples
+- Example 1
+- Example 2
+`;
+}
+function generateCommandTemplate(name) {
+  return `---
+name: ${name}
+type: command
+description: "Short description"
+version: "1.0.0"
+tags:
+  - tag1
+---
+
+# /${name}
+
+## Description
+What this command does.
+
+## Usage
+\`/${name} [options]\`
+
+## Examples
+- \`/${name}\` \u2014 basic usage
+`;
+}
+async function writeTemplateFile(outputDir, name, content, force) {
+  const filePath = path20.join(outputDir, `${name}.asdm.md`);
+  const alreadyExists = await exists(filePath);
+  if (alreadyExists && !force) {
+    logger.error(
+      `File already exists: ${filePath}`,
+      "Use --force to overwrite"
+    );
+    process.exitCode = 1;
+    return;
+  }
+  await writeFile(filePath, content);
+  logger.success(`Created ${filePath}`);
+}
+var agentCommand = defineCommand16({
+  meta: {
+    name: "agent",
+    description: "Scaffold an agent definition (.asdm.md)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Agent identifier (used as filename and frontmatter name)",
+      required: true
+    },
+    output: {
+      type: "string",
+      description: "Output directory (default: current working directory)"
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing file",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const outputDir = ctx.args.output ?? cwd;
+    await writeTemplateFile(outputDir, ctx.args.name, generateAgentTemplate(ctx.args.name), ctx.args.force);
+  }
+});
+var skillCommand = defineCommand16({
+  meta: {
+    name: "skill",
+    description: "Scaffold a skill definition (.asdm.md)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Skill identifier (used as filename and frontmatter name)",
+      required: true
+    },
+    output: {
+      type: "string",
+      description: "Output directory (default: current working directory)"
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing file",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const outputDir = ctx.args.output ?? cwd;
+    await writeTemplateFile(outputDir, ctx.args.name, generateSkillTemplate(ctx.args.name), ctx.args.force);
+  }
+});
+var commandCommand = defineCommand16({
+  meta: {
+    name: "command",
+    description: "Scaffold a slash-command definition (.asdm.md)"
+  },
+  args: {
+    name: {
+      type: "positional",
+      description: "Command identifier (used as filename and frontmatter name)",
+      required: true
+    },
+    output: {
+      type: "string",
+      description: "Output directory (default: current working directory)"
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing file",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const outputDir = ctx.args.output ?? cwd;
+    await writeTemplateFile(outputDir, ctx.args.name, generateCommandTemplate(ctx.args.name), ctx.args.force);
+  }
+});
+var templates_default = defineCommand16({
+  meta: {
+    name: "templates",
+    description: "Scaffold new .asdm.md asset files from built-in templates"
+  },
+  subCommands: {
+    agent: agentCommand,
+    skill: skillCommand,
+    command: commandCommand
+  }
+});
+
 // src/core/version-check.ts
 init_fs();
-import path17 from "path";
+import path21 from "path";
 var CACHE_FILENAME = "version-check-cache.json";
 var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var FETCH_TIMEOUT_MS2 = 3e3;
@@ -2948,7 +3535,7 @@ function isNewerVersion(current, latest) {
 }
 async function checkForUpdate(currentVersion) {
   const cacheDir = getAsdmConfigDir();
-  const cachePath = path17.join(cacheDir, CACHE_FILENAME);
+  const cachePath = path21.join(cacheDir, CACHE_FILENAME);
   const cache = await readJson(cachePath);
   if (cache) {
     const ageMs = Date.now() - new Date(cache.checkedAt).getTime();
@@ -2984,10 +3571,10 @@ async function checkForUpdate(currentVersion) {
 }
 
 // src/cli/index.ts
-var rootCommand = defineCommand16({
+var rootCommand = defineCommand17({
   meta: {
     name: "asdm",
-    version: "0.1.2",
+    version: "0.3.0",
     description: "Agentic Software Delivery Model \u2014 Write Once, Emit Many"
   },
   subCommands: {
@@ -3005,7 +3592,8 @@ var rootCommand = defineCommand16({
     clean: clean_default,
     hooks: hooks_default,
     gitignore: gitignore_default,
-    telemetry: telemetry_default
+    telemetry: telemetry_default,
+    templates: templates_default
   }
 });
 function printUpdateBox(currentVersion, latestVersion) {
@@ -3033,9 +3621,9 @@ async function main() {
   await runMain(rootCommand);
   if (process.exitCode !== void 0 && process.exitCode !== 0) return;
   try {
-    const latestVersion = await checkForUpdate("0.1.2");
+    const latestVersion = await checkForUpdate("0.3.0");
     if (latestVersion) {
-      printUpdateBox("0.1.2", latestVersion);
+      printUpdateBox("0.3.0", latestVersion);
     }
   } catch {
   }