asdm-cli 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3013 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// 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");
+}
+async function readFile(filePath) {
+  try {
+    return await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return null;
+    throw err;
+  }
+}
+async function exists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function removeFile(filePath) {
+  try {
+    await fs.unlink(filePath);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+}
+async function listFiles(dirPath) {
+  const results = [];
+  async function walk(current) {
+    const entries = await fs.readdir(current, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(fullPath);
+      } else {
+        results.push(fullPath);
+      }
+    }
+  }
+  await walk(dirPath);
+  return results;
+}
+function getAsdmConfigDir() {
+  return path.join(os.homedir(), ".config", "asdm");
+}
+function getAsdmCacheDir() {
+  const xdgCache = process.env["XDG_CACHE_HOME"];
+  if (xdgCache) return path.join(xdgCache, "asdm");
+  return path.join(os.homedir(), ".cache", "asdm");
+}
+async function readJson(filePath) {
+  const content = await readFile(filePath);
+  if (content === null) return null;
+  return JSON.parse(content);
+}
+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 init_fs = __esm({
+  "src/utils/fs.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/hash.ts
+import { createHash } from "crypto";
+import { promises as fs2 } from "fs";
+import os2 from "os";
+function hashString(content) {
+  return createHash("sha256").update(content, "utf-8").digest("hex");
+}
+function hashBuffer(buf) {
+  return createHash("sha256").update(buf).digest("hex");
+}
+async function hashFile(filePath) {
+  const content = await fs2.readFile(filePath);
+  return hashBuffer(content);
+}
+function machineId() {
+  const hostname = os2.hostname();
+  const username = os2.userInfo().username;
+  return hashString(`${hostname}:${username}`).slice(0, 12);
+}
+var init_hash = __esm({
+  "src/core/hash.ts"() {
+    "use strict";
+  }
+});
+
+// src/adapters/base.ts
+function createEmittedFile(relativePath, content, adapter, sourcePath) {
+  return {
+    relativePath,
+    content,
+    sha256: hashString(content),
+    adapter,
+    sourcePath
+  };
+}
+function managedFileHeader(provider) {
+  return [
+    `# \u26A0\uFE0F  ASDM MANAGED FILE \u2014 DO NOT EDIT MANUALLY`,
+    `# This file is generated by asdm. Changes will be overwritten on next sync.`,
+    `# To modify: edit the source in your asdm-registry and run \`asdm sync\`.`,
+    `# Provider: ${provider}`,
+    `#`
+  ].join("\n");
+}
+function managedJsonHeader(provider) {
+  return [
+    `// \u26A0\uFE0F  ASDM MANAGED FILE \u2014 DO NOT EDIT MANUALLY`,
+    `// This file is generated by asdm. Changes will be overwritten on next sync.`,
+    `// To modify: edit the source in your asdm-registry and run \`asdm sync\`.`,
+    `// Provider: ${provider}`,
+    `//`
+  ].join("\n");
+}
+var init_base = __esm({
+  "src/adapters/base.ts"() {
+    "use strict";
+    init_hash();
+  }
+});
+
+// src/adapters/opencode.ts
+var opencode_exports = {};
+__export(opencode_exports, {
+  OpenCodeAdapter: () => OpenCodeAdapter,
+  createOpenCodeAdapter: () => createOpenCodeAdapter
+});
+import path8 from "path";
+async function detectOcx() {
+  const os4 = await import("os");
+  const home = os4.homedir();
+  const ocxPaths = [
+    path8.join(home, ".config", "ocx"),
+    path8.join(home, ".ocx")
+  ];
+  for (const p of ocxPaths) {
+    if (await exists(p)) return true;
+  }
+  return false;
+}
+function formatAgentContent(parsed) {
+  const lines = [
+    managedFileHeader(ADAPTER_NAME),
+    ""
+  ];
+  lines.push(parsed.body);
+  return lines.join("\n");
+}
+function formatSkillContent(parsed) {
+  return [
+    managedFileHeader(ADAPTER_NAME),
+    "",
+    parsed.body
+  ].join("\n");
+}
+function formatCommandContent(parsed) {
+  return [
+    managedFileHeader(ADAPTER_NAME),
+    "",
+    parsed.body
+  ].join("\n");
+}
+function generateOpencodeConfig(profile, hasOcx) {
+  const providerConfig = profile.provider_config["opencode"] ?? {};
+  const config = {};
+  if (providerConfig.theme) {
+    config["theme"] = providerConfig.theme;
+  }
+  if (providerConfig.mcp_servers && providerConfig.mcp_servers.length > 0) {
+    config["mcp"] = {
+      servers: providerConfig.mcp_servers.reduce((acc, srv) => {
+        acc[srv.name] = {
+          command: srv.command,
+          args: srv.args ?? []
+        };
+        return acc;
+      }, {})
+    };
+  }
+  if (hasOcx) {
+    config["$schema"] = "https://opencode.ai/config.json";
+  }
+  const json = JSON.stringify(config, null, 2);
+  return `${managedJsonHeader(ADAPTER_NAME)}
+${json}
+`;
+}
+function generateAgentsMd(profile) {
+  const lines = [
+    managedFileHeader(ADAPTER_NAME),
+    "",
+    "# AI Agent Instructions",
+    "",
+    "This project uses ASDM-managed AI agents and skills.",
+    ""
+  ];
+  if (profile.agents.length > 0) {
+    lines.push("## Available Agents", "");
+    for (const agent of profile.agents) {
+      lines.push(`- **${agent}**: See \`.opencode/agents/${agent}.md\``);
+    }
+    lines.push("");
+  }
+  if (profile.skills.length > 0) {
+    lines.push("<available_skills>");
+    for (const skill of profile.skills) {
+      lines.push(`  <skill location=".opencode/skills/${skill}/SKILL.md" />`);
+    }
+    lines.push("</available_skills>");
+    lines.push("");
+  }
+  if (profile.commands.length > 0) {
+    lines.push("## Slash Commands", "");
+    for (const cmd of profile.commands) {
+      lines.push(`- \`/${cmd}\`: See \`.opencode/commands/${cmd}.md\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function createOpenCodeAdapter() {
+  return new OpenCodeAdapter();
+}
+var ADAPTER_NAME, OpenCodeAdapter;
+var init_opencode = __esm({
+  "src/adapters/opencode.ts"() {
+    "use strict";
+    init_fs();
+    init_base();
+    ADAPTER_NAME = "opencode";
+    OpenCodeAdapter = class {
+      name = ADAPTER_NAME;
+      ocxDetected = null;
+      async isOcxAvailable() {
+        if (this.ocxDetected === null) {
+          this.ocxDetected = await detectOcx();
+        }
+        return this.ocxDetected;
+      }
+      emitAgent(parsed, _targetDir) {
+        const relativePath = `.opencode/agents/${parsed.name}.md`;
+        const content = formatAgentContent(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME, parsed.sourcePath)];
+      }
+      emitSkill(parsed, _targetDir) {
+        const relativePath = `.opencode/skills/${parsed.name}/SKILL.md`;
+        const content = formatSkillContent(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME, parsed.sourcePath)];
+      }
+      emitCommand(parsed, _targetDir) {
+        const relativePath = `.opencode/commands/${parsed.name}.md`;
+        const content = formatCommandContent(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME, parsed.sourcePath)];
+      }
+      emitRootInstructions(profile, _targetDir) {
+        const content = generateAgentsMd(profile);
+        return [createEmittedFile("AGENTS.md", content, ADAPTER_NAME, "root")];
+      }
+      async emitConfigAsync(profile, _targetDir) {
+        const hasOcx = await this.isOcxAvailable();
+        const content = generateOpencodeConfig(profile, hasOcx);
+        const relativePath = ".opencode/opencode.jsonc";
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME, "config")];
+      }
+      // Synchronous version (OCX detection skipped — used when sync is not needed)
+      emitConfig(profile, _targetDir) {
+        const content = generateOpencodeConfig(profile, false);
+        const relativePath = ".opencode/opencode.jsonc";
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME, "config")];
+      }
+    };
+  }
+});
+
+// src/adapters/claude-code.ts
+var claude_code_exports = {};
+__export(claude_code_exports, {
+  ClaudeCodeAdapter: () => ClaudeCodeAdapter,
+  createClaudeCodeAdapter: () => createClaudeCodeAdapter
+});
+import path9 from "path";
+function formatAgentContent2(parsed) {
+  return [managedFileHeader(ADAPTER_NAME2), "", parsed.body].join("\n");
+}
+function formatSkillContent2(parsed) {
+  return [managedFileHeader(ADAPTER_NAME2), "", parsed.body].join("\n");
+}
+function formatCommandContent2(parsed) {
+  return [managedFileHeader(ADAPTER_NAME2), "", parsed.body].join("\n");
+}
+function generateClaudeMd(profile) {
+  const lines = [
+    managedFileHeader(ADAPTER_NAME2),
+    "",
+    "# AI Assistant Configuration",
+    ""
+  ];
+  if (profile.agents.length > 0) {
+    lines.push("## Active Agents", "");
+    for (const agent of profile.agents) {
+      lines.push(`- **${agent}**: See \`.claude/agents/${agent}.md\``);
+    }
+    lines.push("");
+  }
+  if (profile.skills.length > 0) {
+    lines.push("## Available Skills", "");
+    lines.push("The following skills are available:", "");
+    lines.push("<available_skills>");
+    for (const skill of profile.skills) {
+      lines.push(`  <skill>`);
+      lines.push(`    <name>${skill}</name>`);
+      lines.push(`    <location>.claude/skills/${skill}/SKILL.md</location>`);
+      lines.push(`  </skill>`);
+    }
+    lines.push("</available_skills>");
+    lines.push("");
+  }
+  if (profile.commands.length > 0) {
+    lines.push("## Slash Commands", "");
+    for (const cmd of profile.commands) {
+      lines.push(`- \`/${cmd}\`: See \`.claude/commands/${cmd}.md\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function createClaudeCodeAdapter() {
+  return new ClaudeCodeAdapter();
+}
+var ADAPTER_NAME2, ClaudeCodeAdapter;
+var init_claude_code = __esm({
+  "src/adapters/claude-code.ts"() {
+    "use strict";
+    init_fs();
+    init_base();
+    ADAPTER_NAME2 = "claude-code";
+    ClaudeCodeAdapter = class {
+      name = ADAPTER_NAME2;
+      emitAgent(parsed, _targetDir) {
+        const relativePath = `.claude/agents/${parsed.name}.md`;
+        const content = formatAgentContent2(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME2, parsed.sourcePath)];
+      }
+      emitSkill(parsed, _targetDir) {
+        const relativePath = `.claude/skills/${parsed.name}/SKILL.md`;
+        const content = formatSkillContent2(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME2, parsed.sourcePath)];
+      }
+      emitCommand(parsed, _targetDir) {
+        const relativePath = `.claude/commands/${parsed.name}.md`;
+        const content = formatCommandContent2(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME2, parsed.sourcePath)];
+      }
+      emitRootInstructions(profile, _targetDir) {
+        const content = generateClaudeMd(profile);
+        return [createEmittedFile(".claude/CLAUDE.md", content, ADAPTER_NAME2, "root")];
+      }
+      emitConfig(_profile, _targetDir) {
+        return [];
+      }
+      /**
+       * Remove all ASDM-managed files from .claude/ in the given project root.
+       * Returns the list of absolute paths that were removed.
+       */
+      async clean(projectRoot) {
+        const claudeDir = path9.join(projectRoot, ".claude");
+        if (!await exists(claudeDir)) return [];
+        const allFiles = await listFiles(claudeDir);
+        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/adapters/copilot.ts
+var copilot_exports = {};
+__export(copilot_exports, {
+  CopilotAdapter: () => CopilotAdapter,
+  createCopilotAdapter: () => createCopilotAdapter
+});
+import path10 from "path";
+function formatAgentContent3(parsed) {
+  const frontmatter = [
+    "---",
+    `name: ${parsed.name}`,
+    `description: ${parsed.description}`,
+    "---",
+    ""
+  ].join("\n");
+  return [managedFileHeader(ADAPTER_NAME3), "", frontmatter, parsed.body].join("\n");
+}
+function formatSkillContent3(parsed) {
+  return [managedFileHeader(ADAPTER_NAME3), "", parsed.body].join("\n");
+}
+function generateCopilotInstructions(profile) {
+  const lines = [
+    managedFileHeader(ADAPTER_NAME3),
+    "",
+    "# GitHub Copilot Instructions",
+    ""
+  ];
+  if (profile.agents.length > 0) {
+    lines.push("## Active Agents", "");
+    for (const agent of profile.agents) {
+      lines.push(`- **${agent}**: See \`.github/agents/${agent}.agent.md\``);
+    }
+    lines.push("");
+  }
+  if (profile.commands.length > 0) {
+    lines.push("## Commands Available", "");
+    for (const cmd of profile.commands) {
+      lines.push(`- **${cmd}**`);
+    }
+    lines.push("");
+  }
+  if (profile.skills.length > 0) {
+    lines.push("## Skills", "");
+    lines.push("The following skills are configured for this workspace:");
+    for (const skill of profile.skills) {
+      lines.push(`- **${skill}**: See \`.github/skills/${skill}/SKILL.md\``);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function createCopilotAdapter() {
+  return new CopilotAdapter();
+}
+var ADAPTER_NAME3, CopilotAdapter;
+var init_copilot = __esm({
+  "src/adapters/copilot.ts"() {
+    "use strict";
+    init_fs();
+    init_base();
+    ADAPTER_NAME3 = "copilot";
+    CopilotAdapter = class {
+      name = ADAPTER_NAME3;
+      emitAgent(parsed, _targetDir) {
+        const relativePath = `.github/agents/${parsed.name}.agent.md`;
+        const content = formatAgentContent3(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME3, parsed.sourcePath)];
+      }
+      emitSkill(parsed, _targetDir) {
+        const relativePath = `.github/skills/${parsed.name}/SKILL.md`;
+        const content = formatSkillContent3(parsed);
+        return [createEmittedFile(relativePath, content, ADAPTER_NAME3, parsed.sourcePath)];
+      }
+      emitCommand(_parsed, _targetDir) {
+        return [];
+      }
+      emitRootInstructions(profile, _targetDir) {
+        const content = generateCopilotInstructions(profile);
+        return [
+          createEmittedFile(".github/copilot-instructions.md", content, ADAPTER_NAME3, "root")
+        ];
+      }
+      emitConfig(_profile, _targetDir) {
+        return [];
+      }
+      /**
+       * Remove all ASDM-managed files from .github/ in the given project root.
+       * Returns the list of absolute paths that were removed.
+       */
+      async clean(projectRoot) {
+        const githubDir = path10.join(projectRoot, ".github");
+        if (!await exists(githubDir)) return [];
+        const allFiles = await listFiles(githubDir);
+        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";
+
+// src/cli/commands/init.ts
+init_fs();
+import { defineCommand } from "citty";
+import path5 from "path";
+
+// src/utils/gitignore.ts
+init_fs();
+import path2 from "path";
+var ASDM_MARKER_START = "# ASDM MANAGED \u2014 start";
+var ASDM_MARKER_END = "# ASDM MANAGED \u2014 end";
+var PROVIDER_ENTRIES = {
+  opencode: [
+    ".opencode/agents/",
+    ".opencode/skills/",
+    ".opencode/commands/"
+  ],
+  "claude-code": [
+    ".claude/agents/",
+    ".claude/skills/",
+    ".claude/commands/",
+    ".claude/CLAUDE.md"
+  ],
+  copilot: [
+    ".github/agents/",
+    ".github/skills/",
+    ".github/copilot-instructions.md"
+  ]
+};
+function getGitignoreEntries(emit) {
+  const lines = [];
+  for (const provider of emit) {
+    const entries = PROVIDER_ENTRIES[provider];
+    if (entries) lines.push(...entries);
+  }
+  return lines;
+}
+function buildBlock(entries) {
+  return [ASDM_MARKER_START, ...entries, ASDM_MARKER_END].join("\n");
+}
+function extractExistingBlock(content) {
+  const startIdx = content.indexOf(ASDM_MARKER_START);
+  const endIdx = content.indexOf(ASDM_MARKER_END);
+  if (startIdx === -1 || endIdx === -1) return "";
+  return content.slice(startIdx, endIdx + ASDM_MARKER_END.length);
+}
+function replaceBlock(content, newBlock) {
+  const startIdx = content.indexOf(ASDM_MARKER_START);
+  const endIdx = content.indexOf(ASDM_MARKER_END);
+  if (startIdx === -1 || endIdx === -1) return content;
+  return content.slice(0, startIdx) + newBlock + content.slice(endIdx + ASDM_MARKER_END.length);
+}
+async function updateGitignore(projectRoot, emit) {
+  const gitignorePath = path2.join(projectRoot, ".gitignore");
+  const entries = getGitignoreEntries(emit);
+  if (entries.length === 0) return false;
+  const existing = await readFile(gitignorePath) ?? "";
+  const newBlock = buildBlock(entries);
+  if (existing.includes(ASDM_MARKER_START)) {
+    const currentBlock = extractExistingBlock(existing);
+    if (currentBlock === newBlock) return false;
+    const newContent2 = replaceBlock(existing, newBlock);
+    await writeFile(gitignorePath, newContent2);
+    return true;
+  }
+  const newContent = existing ? existing.trimEnd() + "\n\n" + newBlock + "\n" : newBlock + "\n";
+  await writeFile(gitignorePath, newContent);
+  return true;
+}
+async function removeGitignoreBlock(projectRoot) {
+  const gitignorePath = path2.join(projectRoot, ".gitignore");
+  const existing = await readFile(gitignorePath);
+  if (existing === null || !existing.includes(ASDM_MARKER_START)) return false;
+  const startIdx = existing.indexOf(ASDM_MARKER_START);
+  const endIdx = existing.indexOf(ASDM_MARKER_END);
+  if (endIdx === -1) return false;
+  const before = existing.slice(0, startIdx).trimEnd();
+  const after = existing.slice(endIdx + ASDM_MARKER_END.length).trimStart();
+  const newContent = before + (after ? "\n" + after : "") + "\n";
+  await writeFile(gitignorePath, newContent);
+  return true;
+}
+
+// src/core/config.ts
+init_fs();
+import path3 from "path";
+
+// src/utils/errors.ts
+var AsdmError = class extends Error {
+  constructor(message, code, suggestion) {
+    super(message);
+    this.code = code;
+    this.suggestion = suggestion;
+    this.name = "AsdmError";
+  }
+};
+var ConfigError = class extends AsdmError {
+  constructor(message, suggestion) {
+    super(message, "CONFIG_ERROR", suggestion);
+    this.name = "ConfigError";
+  }
+};
+var RegistryError = class extends AsdmError {
+  constructor(message, suggestion) {
+    super(message, "REGISTRY_ERROR", suggestion);
+    this.name = "RegistryError";
+  }
+};
+var IntegrityError = class extends AsdmError {
+  constructor(message, suggestion) {
+    super(message, "INTEGRITY_ERROR", suggestion);
+    this.name = "IntegrityError";
+  }
+};
+var ParseError = class extends AsdmError {
+  constructor(message, suggestion) {
+    super(message, "PARSE_ERROR", suggestion);
+    this.name = "ParseError";
+  }
+};
+var PolicyError = class extends AsdmError {
+  constructor(message, suggestion) {
+    super(message, "POLICY_ERROR", suggestion);
+    this.name = "PolicyError";
+  }
+};
+var NetworkError = class extends AsdmError {
+  constructor(message, suggestion) {
+    super(message, "NETWORK_ERROR", suggestion);
+    this.name = "NetworkError";
+  }
+};
+
+// src/core/config.ts
+var PROJECT_CONFIG_FILE = ".asdm.json";
+var USER_CONFIG_FILE = ".asdm.local.json";
+function parseRegistryUrl(url) {
+  const match = url.match(/^github:\/\/([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_-]+)$/);
+  if (!match) {
+    throw new ConfigError(
+      `Invalid registry URL: "${url}"`,
+      "Registry URL must be in format: github://{org}/{repo}"
+    );
+  }
+  return { org: match[1], repo: match[2] };
+}
+async function readProjectConfig(cwd) {
+  const filePath = path3.join(cwd, PROJECT_CONFIG_FILE);
+  const config = await readJson(filePath);
+  if (!config) {
+    throw new ConfigError(
+      `No ${PROJECT_CONFIG_FILE} found in ${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);
+  return config;
+}
+async function readUserConfig(cwd) {
+  const filePath = path3.join(cwd, USER_CONFIG_FILE);
+  return readJson(filePath);
+}
+async function writeUserConfig(cwd, config) {
+  const filePath = path3.join(cwd, USER_CONFIG_FILE);
+  await writeJson(filePath, config);
+}
+function resolveConfig(project, user, policy) {
+  const profile = user?.profile ?? project.profile;
+  const providers = project.providers ?? ["opencode"];
+  if (!policy.allowed_profiles.includes(profile)) {
+    throw new PolicyError(
+      `Profile "${profile}" is not allowed by corporate policy`,
+      `Allowed profiles: ${policy.allowed_profiles.join(", ")}
+Run \`asdm profiles\` to see available profiles`
+    );
+  }
+  const disallowedProviders = providers.filter((p) => !policy.allowed_providers.includes(p));
+  if (disallowedProviders.length > 0) {
+    throw new PolicyError(
+      `Provider(s) not allowed by corporate policy: ${disallowedProviders.join(", ")}`,
+      `Allowed providers: ${policy.allowed_providers.join(", ")}`
+    );
+  }
+  return {
+    registry: project.registry,
+    profile,
+    providers,
+    policy
+  };
+}
+async function createProjectConfig(cwd, registry, profile, providers = ["opencode"]) {
+  const filePath = path3.join(cwd, PROJECT_CONFIG_FILE);
+  const config = {
+    $schema: "https://asdm.dev/schemas/config.schema.json",
+    registry,
+    profile,
+    providers
+  };
+  await writeJson(filePath, config);
+}
+
+// src/core/telemetry.ts
+init_hash();
+import path4 from "path";
+import { promises as fs3 } from "fs";
+var TELEMETRY_FILE = ".asdm-telemetry.jsonl";
+var TelemetryWriter = class {
+  logPath;
+  constructor(projectRoot) {
+    this.logPath = path4.join(projectRoot, TELEMETRY_FILE);
+  }
+  /** Append one telemetry event as a JSONL line */
+  async write(event) {
+    const fullEvent = {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      machineId: machineId(),
+      version: "0.1.0",
+      ...event
+    };
+    const line = JSON.stringify(fullEvent) + "\n";
+    await fs3.appendFile(this.logPath, line, "utf-8");
+  }
+  /** Read and parse all events, silently skipping malformed lines */
+  async readAll() {
+    let content;
+    try {
+      content = await fs3.readFile(this.logPath, "utf-8");
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    return content.split("\n").filter((line) => line.trim().length > 0).flatMap((line) => {
+      try {
+        return [JSON.parse(line)];
+      } catch {
+        return [];
+      }
+    });
+  }
+  /**
+   * Rotate the log file, keeping only the last N entries.
+   * Prevents unbounded growth — default cap is 1000 events.
+   */
+  async rotate(maxEntries = 1e3) {
+    const entries = await this.readAll();
+    if (entries.length <= maxEntries) return;
+    const trimmed = entries.slice(entries.length - maxEntries);
+    const content = trimmed.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    await fs3.writeFile(this.logPath, content, "utf-8");
+  }
+  /** Delete the telemetry log file */
+  async clear() {
+    try {
+      await fs3.unlink(this.logPath);
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+  }
+};
+
+// src/utils/logger.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var FG_RED = "\x1B[31m";
+var FG_GREEN = "\x1B[32m";
+var FG_YELLOW = "\x1B[33m";
+var FG_BLUE = "\x1B[34m";
+var FG_CYAN = "\x1B[36m";
+var FG_WHITE = "\x1B[37m";
+var FG_GRAY = "\x1B[90m";
+var ICONS = {
+  success: "\u2713",
+  error: "\u2717",
+  warn: "\u26A0",
+  info: "\u2139",
+  pending: "\u25CB",
+  arrow: "\u2192",
+  bullet: "\u2022",
+  badge_asdm: "asdm"
+};
+var _quiet = false;
+var _verbose = false;
+var logger = {
+  setQuiet(q) {
+    _quiet = q;
+  },
+  setVerbose(v) {
+    _verbose = v;
+  },
+  /** Brand prefix for main operations */
+  asdm(msg) {
+    if (_quiet) return;
+    console.log(`${BOLD}${FG_CYAN}${ICONS.badge_asdm}${RESET} ${msg}`);
+  },
+  success(msg) {
+    if (_quiet) return;
+    console.log(`${FG_GREEN}${ICONS.success}${RESET} ${msg}`);
+  },
+  error(msg, suggestion) {
+    console.error(`${FG_RED}${ICONS.error}${RESET} ${msg}`);
+    if (suggestion) {
+      console.error(`  ${FG_GRAY}${ICONS.arrow} ${suggestion}${RESET}`);
+    }
+  },
+  warn(msg) {
+    if (_quiet) return;
+    console.warn(`${FG_YELLOW}${ICONS.warn}${RESET} ${msg}`);
+  },
+  info(msg) {
+    if (_quiet) return;
+    console.log(`${FG_BLUE}${ICONS.info}${RESET} ${msg}`);
+  },
+  dim(msg) {
+    if (_quiet) return;
+    console.log(`${DIM}  ${msg}${RESET}`);
+  },
+  verbose(msg) {
+    if (!_verbose) return;
+    console.log(`${FG_GRAY}  [verbose] ${msg}${RESET}`);
+  },
+  bullet(msg, indent = 0) {
+    if (_quiet) return;
+    const pad = "  ".repeat(indent);
+    console.log(`${pad}${FG_GRAY}${ICONS.bullet}${RESET} ${msg}`);
+  },
+  divider() {
+    if (_quiet) return;
+    console.log(`${DIM}${"\u2500".repeat(50)}${RESET}`);
+  },
+  /** Print a table of key-value pairs */
+  table(rows, keyWidth = 20) {
+    if (_quiet) return;
+    for (const [key, value] of rows) {
+      const padded = key.padEnd(keyWidth);
+      console.log(`  ${FG_GRAY}${padded}${RESET} ${value}`);
+    }
+  },
+  /** Status line: ✓ ok / ✗ fail / ⚠ warn */
+  status(label, status, detail) {
+    if (_quiet) return;
+    const icons = {
+      ok: `${FG_GREEN}${ICONS.success}${RESET}`,
+      fail: `${FG_RED}${ICONS.error}${RESET}`,
+      warn: `${FG_YELLOW}${ICONS.warn}${RESET}`,
+      skip: `${FG_GRAY}-${RESET}`
+    };
+    const icon = icons[status] ?? icons["skip"];
+    const labelPad = label.padEnd(40);
+    const detailStr = detail ? `  ${FG_GRAY}${detail}${RESET}` : "";
+    console.log(`  ${icon} ${labelPad}${detailStr}`);
+  },
+  /** Highlight text in cyan bold */
+  highlight(text) {
+    return `${BOLD}${FG_CYAN}${text}${RESET}`;
+  },
+  bold(text) {
+    return `${BOLD}${text}${RESET}`;
+  },
+  white(text) {
+    return `${FG_WHITE}${text}${RESET}`;
+  }
+};
+
+// src/cli/commands/init.ts
+var DEFAULT_REGISTRY = "github://your-org/asdm-registry";
+var init_default = defineCommand({
+  meta: {
+    name: "init",
+    description: "Initialize .asdm.json in the current project"
+  },
+  args: {
+    profile: {
+      type: "positional",
+      description: "Profile to initialize with (default: base)",
+      required: false,
+      default: "base"
+    },
+    registry: {
+      type: "string",
+      description: "Registry URL in github://org/repo format",
+      default: DEFAULT_REGISTRY
+    },
+    force: {
+      type: "boolean",
+      description: "Overwrite existing .asdm.json",
+      default: false
+    },
+    gitignore: {
+      type: "boolean",
+      description: "Add ASDM output dirs to .gitignore after init",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    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.");
+      process.exit(0);
+    }
+    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}"`);
+      logger.info(`Registry: ${registry}`);
+      logger.info("Next step: run `asdm sync` to install agents, skills, and commands");
+      const telemetry = new TelemetryWriter(cwd);
+      telemetry.write({ event: "init.completed", profile, registry }).catch(() => {
+      });
+      if (ctx.args.gitignore) {
+        const updated = await updateGitignore(cwd, providers);
+        if (updated) {
+          logger.success("Updated .gitignore with ASDM managed entries");
+        } else {
+          logger.info(".gitignore already up to date");
+        }
+      } else if (process.stdout.isTTY) {
+        logger.info("\u{1F4A1} Tip: Run 'asdm gitignore' to add ASDM output dirs to .gitignore");
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(message);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/sync.ts
+import { defineCommand as defineCommand2 } from "citty";
+
+// src/core/syncer.ts
+import path11 from "path";
+
+// src/core/registry-client.ts
+var GITHUB_API_BASE = "https://api.github.com";
+var GITHUB_RAW_BASE = "https://github.com";
+function getGithubToken() {
+  return process.env["ASDM_GITHUB_TOKEN"] ?? process.env["GITHUB_TOKEN"];
+}
+function buildHeaders(token) {
+  const headers = {
+    "Accept": "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "asdm-cli/0.1.0"
+  };
+  const tok = token ?? getGithubToken();
+  if (tok) {
+    headers["Authorization"] = `Bearer ${tok}`;
+  }
+  return headers;
+}
+async function fetchWithRetry(url, options, maxRetries = 3) {
+  let lastError;
+  for (let attempt = 0; attempt < maxRetries; attempt++) {
+    if (attempt > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 1e3 * Math.pow(2, attempt - 1)));
+    }
+    try {
+      const response = await fetch(url, options);
+      if (response.status === 403 || response.status === 429) {
+        const retryAfter = response.headers.get("Retry-After");
+        const waitMs = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 6e4;
+        if (attempt < maxRetries - 1) {
+          await new Promise((resolve) => setTimeout(resolve, Math.min(waitMs, 1e4)));
+          continue;
+        }
+      }
+      return response;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      if (attempt === maxRetries - 1) throw new NetworkError(
+        `Network request failed after ${maxRetries} attempts: ${lastError.message}`,
+        "Check your internet connection and GitHub token"
+      );
+    }
+  }
+  throw new NetworkError(
+    `Network request failed: ${lastError?.message ?? "Unknown error"}`,
+    "Check your internet connection and GitHub token"
+  );
+}
+var RegistryClient = class {
+  org;
+  repo;
+  options;
+  constructor(registryUrl, options = {}) {
+    const { org, repo } = parseRegistryUrl(registryUrl);
+    this.org = org;
+    this.repo = repo;
+    this.options = {
+      token: options.token ?? getGithubToken() ?? "",
+      timeout: options.timeout ?? 3e4,
+      maxRetries: options.maxRetries ?? 3
+    };
+  }
+  get headers() {
+    return buildHeaders(this.options.token || void 0);
+  }
+  /**
+   * Fetch the latest release manifest from GitHub Releases.
+   * GET /repos/{org}/{repo}/releases/latest → downloads manifest.json asset
+   */
+  async getLatestManifest() {
+    const url = `${GITHUB_API_BASE}/repos/${this.org}/${this.repo}/releases/latest`;
+    const response = await fetchWithRetry(
+      url,
+      { headers: this.headers },
+      this.options.maxRetries
+    );
+    if (response.status === 404) {
+      throw new RegistryError(
+        `Registry not found: github://${this.org}/${this.repo}`,
+        "Verify the registry URL in .asdm.json and ensure the repo exists with published releases"
+      );
+    }
+    if (!response.ok) {
+      throw new RegistryError(
+        `Failed to fetch latest release: HTTP ${response.status}`,
+        response.status === 401 ? "Set GITHUB_TOKEN or ASDM_GITHUB_TOKEN environment variable" : "Check registry URL and permissions"
+      );
+    }
+    const release = await response.json();
+    const manifestAsset = release.assets.find((a) => a.name === "manifest.json");
+    if (!manifestAsset) {
+      throw new RegistryError(
+        `manifest.json not found in latest release of github://${this.org}/${this.repo}`,
+        "Run the CI workflow to publish a release with manifest.json"
+      );
+    }
+    const manifestResponse = await fetchWithRetry(
+      manifestAsset.browser_download_url,
+      { headers: this.headers },
+      this.options.maxRetries
+    );
+    if (!manifestResponse.ok) {
+      throw new RegistryError(`Failed to download manifest.json: HTTP ${manifestResponse.status}`);
+    }
+    return manifestResponse.json();
+  }
+  /**
+   * Download a specific asset file from a GitHub Release.
+   *
+   * @param assetPath - Registry-relative path (e.g., "agents/code-reviewer.asdm.md")
+   * @param version - Release tag version (e.g., "1.0.0")
+   */
+  async downloadAsset(assetPath, version) {
+    const url = `${GITHUB_RAW_BASE}/${this.org}/${this.repo}/releases/download/v${version}/${assetPath}`;
+    const response = await fetchWithRetry(
+      url,
+      { headers: this.headers },
+      this.options.maxRetries
+    );
+    if (response.status === 404) {
+      throw new RegistryError(
+        `Asset not found: ${assetPath} at version ${version}`,
+        "Run `asdm sync --force` to re-download all assets"
+      );
+    }
+    if (!response.ok) {
+      throw new RegistryError(
+        `Failed to download asset ${assetPath}: HTTP ${response.status}`
+      );
+    }
+    return response.text();
+  }
+  /**
+   * Check if the registry is accessible (for `asdm doctor`).
+   */
+  async ping() {
+    try {
+      const url = `${GITHUB_API_BASE}/repos/${this.org}/${this.repo}`;
+      const response = await fetch(url, { headers: this.headers });
+      return response.status === 200;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/core/profile-resolver.ts
+init_fs();
+import path6 from "path";
+import { parse as parseYaml } from "yaml";
+function mergeProviderConfig(base, override) {
+  const result = { ...base };
+  for (const [provider, config] of Object.entries(override)) {
+    if (result[provider]) {
+      const merged = { ...result[provider] };
+      for (const [key, value] of Object.entries(config)) {
+        if (Array.isArray(value) && Array.isArray(merged[key])) {
+          const combined = [...merged[key], ...value];
+          merged[key] = [...new Set(combined)];
+        } else {
+          merged[key] = value;
+        }
+      }
+      result[provider] = merged;
+    } else {
+      result[provider] = { ...config };
+    }
+  }
+  return result;
+}
+function mergeStringArrays(base, override) {
+  const result = [...base];
+  for (const item of override) {
+    if (item.startsWith("-")) {
+      const toRemove = item.slice(1);
+      const idx = result.indexOf(toRemove);
+      if (idx !== -1) result.splice(idx, 1);
+    } else if (!result.includes(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function resolveProfileFromManifest(manifestProfiles, profileName, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(profileName)) {
+    throw new ConfigError(
+      `Circular profile inheritance in manifest: ${[...visited].join(" \u2192 ")} \u2192 ${profileName}`
+    );
+  }
+  visited.add(profileName);
+  const profile = manifestProfiles[profileName];
+  if (!profile) {
+    throw new ConfigError(`Profile "${profileName}" not found in manifest`);
+  }
+  let resolved = {
+    name: profileName,
+    agents: [],
+    skills: [],
+    commands: [],
+    providers: [],
+    provider_config: {},
+    resolvedFrom: []
+  };
+  for (const parentName of profile.extends ?? []) {
+    const parent = resolveProfileFromManifest(manifestProfiles, parentName, new Set(visited));
+    resolved = {
+      ...resolved,
+      agents: mergeStringArrays(parent.agents, resolved.agents),
+      skills: mergeStringArrays(parent.skills, resolved.skills),
+      commands: mergeStringArrays(parent.commands, resolved.commands),
+      providers: [.../* @__PURE__ */ new Set([...parent.providers, ...resolved.providers])],
+      provider_config: mergeProviderConfig(parent.provider_config, resolved.provider_config),
+      resolvedFrom: [...parent.resolvedFrom]
+    };
+  }
+  resolved = {
+    ...resolved,
+    agents: mergeStringArrays(resolved.agents, profile.agents ?? []),
+    skills: mergeStringArrays(resolved.skills, profile.skills ?? []),
+    commands: mergeStringArrays(resolved.commands, profile.commands ?? []),
+    providers: [.../* @__PURE__ */ new Set([...resolved.providers, ...profile.providers ?? []])],
+    resolvedFrom: [...resolved.resolvedFrom, profileName]
+  };
+  return resolved;
+}
+
+// src/core/manifest.ts
+init_fs();
+function diffManifest(manifest, localShas, assetPaths) {
+  const added = [];
+  const updated = [];
+  const removed = [];
+  const unchanged = [];
+  for (const assetPath of assetPaths) {
+    const manifestAsset = manifest.assets[assetPath];
+    if (!manifestAsset) continue;
+    const localSha = localShas[assetPath];
+    if (!localSha) {
+      added.push(assetPath);
+    } else if (localSha !== manifestAsset.sha256) {
+      updated.push(assetPath);
+    } else {
+      unchanged.push(assetPath);
+    }
+  }
+  for (const assetPath of Object.keys(localShas)) {
+    if (!assetPaths.includes(assetPath) && !manifest.assets[assetPath]) {
+      removed.push(assetPath);
+    }
+  }
+  return { added, updated, removed, unchanged };
+}
+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);
+  }
+  for (const name of skillNames) {
+    const path18 = `skills/${name}/SKILL.asdm.md`;
+    if (manifest.assets[path18]) paths.push(path18);
+  }
+  for (const name of commandNames) {
+    const path18 = `commands/${name}.asdm.md`;
+    if (manifest.assets[path18]) paths.push(path18);
+  }
+  return paths;
+}
+async function loadCachedManifest(cacheDir) {
+  return readJson(`${cacheDir}/manifest.json`);
+}
+
+// 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);
+  return readJson(filePath);
+}
+async function writeLockfile(cwd, lockfile) {
+  const filePath = path7.join(cwd, LOCKFILE_NAME);
+  await writeJson(filePath, {
+    $schema: "https://asdm.dev/schemas/lock.schema.json",
+    ...lockfile
+  });
+}
+function createLockEntry(sha256, source, adapter, version, managed = true) {
+  return { sha256, source, adapter, version, managed };
+}
+function buildLockfile(params) {
+  return {
+    $schema: "https://asdm.dev/schemas/lock.schema.json",
+    synced_at: (/* @__PURE__ */ new Date()).toISOString(),
+    cli_version: params.cliVersion,
+    manifest_version: params.manifestVersion,
+    registry: params.registry,
+    profile: params.profile,
+    resolved_profiles: params.resolvedProfiles,
+    files: params.files
+  };
+}
+
+// src/core/syncer.ts
+init_hash();
+init_fs();
+
+// src/core/parser.ts
+init_hash();
+import { parse as parseYaml2, stringify as stringifyYaml } from "yaml";
+var FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/;
+function parseAsset(content, sourcePath, provider = "opencode") {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    throw new ParseError(
+      `Failed to parse frontmatter in ${sourcePath}`,
+      "Ensure the file has valid YAML frontmatter between --- delimiters"
+    );
+  }
+  const [, frontmatterRaw, body] = match;
+  let frontmatter;
+  try {
+    frontmatter = parseYaml2(frontmatterRaw);
+  } catch (err) {
+    throw new ParseError(
+      `Invalid YAML frontmatter in ${sourcePath}: ${err.message}`,
+      "Validate the frontmatter with a YAML linter"
+    );
+  }
+  const name = frontmatter["name"];
+  const type = frontmatter["type"];
+  const version = frontmatter["version"];
+  const description = frontmatter["description"];
+  if (typeof name !== "string") {
+    throw new ParseError(`Missing required field 'name' in ${sourcePath}`);
+  }
+  if (type !== "agent" && type !== "skill" && type !== "command") {
+    throw new ParseError(
+      `Invalid type '${String(type)}' in ${sourcePath}`,
+      "Type must be one of: 'agent', 'skill', 'command'"
+    );
+  }
+  if (typeof version !== "string") {
+    throw new ParseError(`Missing required field 'version' in ${sourcePath}`);
+  }
+  if (typeof description !== "string") {
+    throw new ParseError(`Missing required field 'description' in ${sourcePath}`);
+  }
+  const providers = frontmatter["providers"] ?? {};
+  const providerConfig = providers[provider] ?? {};
+  const sha256 = hashString(content);
+  return {
+    name,
+    type,
+    version,
+    description,
+    frontmatter,
+    providerConfig,
+    body: body.trim(),
+    sourcePath,
+    sha256
+  };
+}
+
+// src/core/syncer.ts
+async function loadAdapters(providers) {
+  const adapters = [];
+  for (const provider of providers) {
+    switch (provider) {
+      case "opencode": {
+        const { createOpenCodeAdapter: createOpenCodeAdapter2 } = await Promise.resolve().then(() => (init_opencode(), opencode_exports));
+        adapters.push(createOpenCodeAdapter2());
+        break;
+      }
+      case "claude-code": {
+        const { createClaudeCodeAdapter: createClaudeCodeAdapter2 } = await Promise.resolve().then(() => (init_claude_code(), claude_code_exports));
+        adapters.push(createClaudeCodeAdapter2());
+        break;
+      }
+      case "copilot": {
+        const { createCopilotAdapter: createCopilotAdapter2 } = await Promise.resolve().then(() => (init_copilot(), copilot_exports));
+        adapters.push(createCopilotAdapter2());
+        break;
+      }
+    }
+  }
+  return adapters;
+}
+async function getCliVersion() {
+  return "0.1.0";
+}
+async function sync(options) {
+  const startTime = Date.now();
+  const { cwd } = options;
+  options.telemetry?.write({ event: "sync.started" }).catch(() => {
+  });
+  try {
+    const projectConfig = await readProjectConfig(cwd);
+    const userConfig = await readUserConfig(cwd);
+    const client = new RegistryClient(projectConfig.registry);
+    const manifest = await client.getLatestManifest();
+    const resolvedConfig = resolveConfig(projectConfig, userConfig, manifest.policy);
+    const activeProviders = options.provider ? resolvedConfig.providers.filter((p) => p === options.provider) : resolvedConfig.providers;
+    const resolvedProfile = resolveProfileFromManifest(manifest.profiles, resolvedConfig.profile);
+    const assetPaths = getProfileAssetPaths(
+      manifest,
+      resolvedProfile.agents,
+      resolvedProfile.skills,
+      resolvedProfile.commands
+    );
+    const existingLockfile = options.force ? null : await readLockfile(cwd);
+    const localSourceShas = {};
+    if (existingLockfile) {
+      for (const [, entry] of Object.entries(existingLockfile.files)) {
+        if (entry.managed && entry.source) {
+          localSourceShas[entry.source] = entry.sha256;
+        }
+      }
+    }
+    const diff = diffManifest(manifest, localSourceShas, assetPaths);
+    const toDownload = options.force ? assetPaths : [...diff.added, ...diff.updated];
+    const cacheDir = path11.join(getAsdmCacheDir(), manifest.version);
+    await ensureDir(cacheDir);
+    const downloadedAssets = /* @__PURE__ */ new Map();
+    for (const assetPath of toDownload) {
+      const assetMeta = manifest.assets[assetPath];
+      if (!assetMeta) continue;
+      const content = await client.downloadAsset(assetPath, manifest.version);
+      const downloadedSha = hashString(content);
+      if (downloadedSha !== assetMeta.sha256) {
+        throw new IntegrityError(
+          `SHA-256 mismatch for ${assetPath}: expected ${assetMeta.sha256}, got ${downloadedSha}`,
+          "The asset may have been tampered with or the manifest is stale. Run `asdm sync --force`."
+        );
+      }
+      const cachedPath = path11.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);
+      try {
+        const { readFile: readFile2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+        const cached = await readFile2(cachedPath);
+        if (cached) downloadedAssets.set(assetPath, cached);
+      } catch {
+      }
+    }
+    if (options.dryRun || options.noEmit) {
+      const stats2 = {
+        filesAdded: diff.added.length,
+        filesUpdated: diff.updated.length,
+        filesUnchanged: diff.unchanged.length,
+        filesRemoved: diff.removed.length,
+        duration: Date.now() - startTime,
+        manifestVersion: manifest.version,
+        profile: resolvedConfig.profile,
+        providers: activeProviders
+      };
+      options.telemetry?.write({
+        event: "sync.completed",
+        profile: resolvedConfig.profile,
+        registry: resolvedConfig.registry,
+        providers: activeProviders,
+        assetCount: 0,
+        durationMs: stats2.duration
+      }).catch(() => {
+      });
+      return { stats: stats2, emittedFiles: [], dryRun: !!options.dryRun };
+    }
+    const adapters = await loadAdapters(activeProviders);
+    const allEmittedFiles = [];
+    for (const adapter of adapters) {
+      for (const agentName of resolvedProfile.agents) {
+        const assetPath = `agents/${agentName}.asdm.md`;
+        const content = downloadedAssets.get(assetPath);
+        if (!content) continue;
+        const parsed = parseAsset(content, assetPath, adapter.name);
+        const emitted = adapter.emitAgent(parsed, cwd);
+        allEmittedFiles.push(...emitted);
+      }
+      for (const skillName of resolvedProfile.skills) {
+        const assetPath = `skills/${skillName}/SKILL.asdm.md`;
+        const content = downloadedAssets.get(assetPath);
+        if (!content) continue;
+        const parsed = parseAsset(content, assetPath, adapter.name);
+        const emitted = adapter.emitSkill(parsed, cwd);
+        allEmittedFiles.push(...emitted);
+      }
+      for (const commandName of resolvedProfile.commands) {
+        const assetPath = `commands/${commandName}.asdm.md`;
+        const content = downloadedAssets.get(assetPath);
+        if (!content) continue;
+        const parsed = parseAsset(content, assetPath, adapter.name);
+        const emitted = adapter.emitCommand(parsed, cwd);
+        allEmittedFiles.push(...emitted);
+      }
+      const rootFiles = adapter.emitRootInstructions(resolvedProfile, cwd);
+      allEmittedFiles.push(...rootFiles);
+      const configFiles = adapter.emitConfig(resolvedProfile, cwd);
+      allEmittedFiles.push(...configFiles);
+    }
+    for (const emittedFile of allEmittedFiles) {
+      const absolutePath = path11.join(cwd, emittedFile.relativePath);
+      await writeFile(absolutePath, emittedFile.content);
+    }
+    const lockfileFiles = {};
+    for (const emittedFile of allEmittedFiles) {
+      lockfileFiles[emittedFile.relativePath] = createLockEntry(
+        emittedFile.sha256,
+        emittedFile.sourcePath,
+        emittedFile.adapter,
+        manifest.assets[emittedFile.sourcePath]?.version ?? "0.0.0"
+      );
+    }
+    const cliVersion = await getCliVersion();
+    const lockfile = buildLockfile({
+      cliVersion,
+      manifestVersion: manifest.version,
+      registry: resolvedConfig.registry,
+      profile: resolvedConfig.profile,
+      resolvedProfiles: resolvedProfile.resolvedFrom,
+      files: lockfileFiles
+    });
+    await writeLockfile(cwd, lockfile);
+    const stats = {
+      filesAdded: diff.added.length,
+      filesUpdated: diff.updated.length,
+      filesUnchanged: diff.unchanged.length,
+      filesRemoved: diff.removed.length,
+      duration: Date.now() - startTime,
+      manifestVersion: manifest.version,
+      profile: resolvedConfig.profile,
+      providers: activeProviders
+    };
+    options.telemetry?.write({
+      event: "sync.completed",
+      profile: resolvedConfig.profile,
+      registry: resolvedConfig.registry,
+      providers: activeProviders,
+      assetCount: allEmittedFiles.length,
+      durationMs: stats.duration
+    }).catch(() => {
+    });
+    return { stats, emittedFiles: allEmittedFiles, dryRun: false };
+  } catch (err) {
+    options.telemetry?.write({
+      event: "sync.failed",
+      error: err instanceof Error ? err.message : String(err)
+    }).catch(() => {
+    });
+    throw err;
+  }
+}
+
+// src/cli/commands/sync.ts
+var sync_default = defineCommand2({
+  meta: {
+    name: "sync",
+    description: "Synchronize assets from the registry"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Show what would be done without writing files",
+      default: false
+    },
+    force: {
+      type: "boolean",
+      description: "Re-download all assets even if SHA matches",
+      default: false
+    },
+    verbose: {
+      type: "boolean",
+      description: "Print verbose output",
+      default: false
+    },
+    provider: {
+      type: "string",
+      description: "Sync only for a specific provider"
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const dryRun = ctx.args["dry-run"];
+    const verbose = ctx.args.verbose;
+    if (verbose) logger.setVerbose(true);
+    if (dryRun) {
+      logger.info("Dry run \u2014 no files will be written");
+    }
+    logger.asdm("Starting sync\u2026");
+    const telemetry = new TelemetryWriter(cwd);
+    try {
+      const result = await sync({
+        cwd,
+        force: ctx.args.force,
+        dryRun,
+        verbose,
+        provider: ctx.args.provider,
+        telemetry
+      });
+      const { stats } = result;
+      if (dryRun) {
+        logger.info("Sync plan (dry run):");
+        logger.bullet(`${stats.filesAdded} file(s) to add`);
+        logger.bullet(`${stats.filesUpdated} file(s) to update`);
+        logger.bullet(`${stats.filesUnchanged} file(s) unchanged`);
+        logger.bullet(`${stats.filesRemoved} file(s) to remove`);
+        return;
+      }
+      logger.divider();
+      logger.success("Sync complete");
+      logger.table([
+        ["Profile", stats.profile],
+        ["Manifest version", stats.manifestVersion],
+        ["Providers", stats.providers.join(", ")],
+        ["Files added", String(stats.filesAdded)],
+        ["Files updated", String(stats.filesUpdated)],
+        ["Files unchanged", String(stats.filesUnchanged)],
+        ["Duration", `${stats.duration}ms`]
+      ]);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const suggestion = err.suggestion ?? void 0;
+      logger.error(message, suggestion);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/verify.ts
+import { defineCommand as defineCommand3 } from "citty";
+
+// src/core/verifier.ts
+import path12 from "path";
+init_hash();
+init_fs();
+var VERIFY_EXIT_CODES = {
+  OK: 0,
+  MODIFIED: 1,
+  NO_LOCK: 2,
+  OUTDATED: 3
+};
+async function verify(cwd, latestManifestVersion, onlyManaged = true, telemetry) {
+  const lockfile = await readLockfile(cwd);
+  if (!lockfile) {
+    telemetry?.write({ event: "verify.failed" }).catch(() => {
+    });
+    return {
+      exitCode: VERIFY_EXIT_CODES.NO_LOCK,
+      violations: [],
+      checkedFiles: 0
+    };
+  }
+  const violations = [];
+  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);
+    checkedFiles++;
+    const fileExists = await exists(absolutePath);
+    if (!fileExists) {
+      violations.push({
+        filePath: relativePath,
+        type: "missing",
+        expected: entry.sha256
+      });
+      continue;
+    }
+    const actualHash = await hashFile(absolutePath);
+    if (actualHash !== entry.sha256) {
+      violations.push({
+        filePath: relativePath,
+        type: "modified",
+        expected: entry.sha256,
+        actual: actualHash
+      });
+    }
+  }
+  let exitCode = VERIFY_EXIT_CODES.OK;
+  if (violations.length > 0) {
+    exitCode = VERIFY_EXIT_CODES.MODIFIED;
+  } else if (latestManifestVersion && lockfile.manifest_version !== latestManifestVersion) {
+    exitCode = VERIFY_EXIT_CODES.OUTDATED;
+  }
+  if (violations.length > 0) {
+    telemetry?.write({ event: "verify.modified", violations: violations.length }).catch(() => {
+    });
+  } else {
+    telemetry?.write({ event: "verify.passed", violations: 0 }).catch(() => {
+    });
+  }
+  return {
+    exitCode,
+    violations,
+    checkedFiles,
+    currentManifestVersion: lockfile.manifest_version,
+    latestManifestVersion
+  };
+}
+
+// src/cli/commands/verify.ts
+var verify_default = defineCommand3({
+  meta: {
+    name: "verify",
+    description: "Verify integrity of managed files against the lockfile"
+  },
+  args: {
+    strict: {
+      type: "boolean",
+      description: "Exit 1 on any violation (used by git hooks)",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output results as JSON",
+      default: false
+    },
+    quiet: {
+      type: "boolean",
+      description: "Suppress non-error output",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const useJson = ctx.args.json;
+    const quiet = ctx.args.quiet;
+    if (quiet) logger.setQuiet(true);
+    const telemetry = new TelemetryWriter(cwd);
+    if (ctx.args.strict) {
+      const result = await verify(cwd, void 0, true, telemetry);
+      if (useJson) {
+        console.log(JSON.stringify({
+          status: result.exitCode === VERIFY_EXIT_CODES.OK ? "ok" : "error",
+          violations: result.violations
+        }));
+      } else if (result.exitCode === VERIFY_EXIT_CODES.OK) {
+        logger.success("All managed files are intact");
+      } else {
+        for (const v of result.violations) {
+          const icon = v.type === "missing" ? "\u274C" : "\u26A0\uFE0F";
+          logger.error(`${icon} ${v.filePath} (${v.type})`);
+        }
+      }
+      process.exit(result.exitCode);
+    }
+    try {
+      const result = await verify(cwd, void 0, true, telemetry);
+      if (useJson) {
+        console.log(JSON.stringify(result, null, 2));
+        process.exit(result.exitCode);
+      }
+      if (result.exitCode === VERIFY_EXIT_CODES.NO_LOCK) {
+        logger.warn("No lockfile found (.asdm-lock.json)");
+        logger.info("Run `asdm sync` to initialize");
+        process.exit(VERIFY_EXIT_CODES.NO_LOCK);
+      }
+      logger.asdm(`Verified ${result.checkedFiles} managed file(s)`);
+      logger.divider();
+      if (result.violations.length === 0) {
+        logger.success("All managed files are intact");
+      } else {
+        for (const violation of result.violations) {
+          if (violation.type === "missing") {
+            logger.status(violation.filePath, "fail", "\u274C MISSING");
+          } else if (violation.type === "modified") {
+            logger.status(violation.filePath, "warn", "\u26A0\uFE0F  MODIFIED");
+          } else {
+            logger.status(violation.filePath, "warn", `\u26A0\uFE0F  ${violation.type.toUpperCase()}`);
+          }
+        }
+        logger.divider();
+        logger.warn(`${result.violations.length} violation(s) detected`);
+        logger.info("Run `asdm sync --force` to restore managed files");
+      }
+      if (result.exitCode === VERIFY_EXIT_CODES.OUTDATED) {
+        logger.warn(`Manifest is outdated (local: ${result.currentManifestVersion}, latest: ${result.latestManifestVersion})`);
+        logger.info("Run `asdm sync` to update");
+      }
+      process.exit(result.exitCode);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(message);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/status.ts
+import { defineCommand as defineCommand4 } from "citty";
+var status_default = defineCommand4({
+  meta: {
+    name: "status",
+    description: "Show current config and sync status"
+  },
+  async run(_ctx) {
+    const cwd = process.cwd();
+    let projectConfig;
+    try {
+      projectConfig = await readProjectConfig(cwd);
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        logger.warn("Not initialized. Run `asdm init` first.");
+        process.exit(1);
+      }
+      throw err;
+    }
+    const userConfig = await readUserConfig(cwd);
+    const lockfile = await readLockfile(cwd);
+    const activeProfile = userConfig?.profile ?? projectConfig.profile;
+    const providers = projectConfig.providers ?? ["opencode"];
+    logger.asdm("ASDM Status");
+    logger.divider();
+    logger.table([
+      ["Registry", projectConfig.registry],
+      ["Profile (project)", projectConfig.profile],
+      ["Profile (active)", activeProfile],
+      ["Providers", providers.join(", ")]
+    ]);
+    logger.divider();
+    if (!lockfile) {
+      logger.warn("Not synced \u2014 no lockfile found");
+      logger.info("Run `asdm sync` to synchronize assets");
+      return;
+    }
+    const syncedAt = new Date(lockfile.synced_at).toLocaleString();
+    const managedFiles = Object.entries(lockfile.files).filter(([, e]) => e.managed);
+    const agents = [...new Set(managedFiles.filter(([, e]) => e.source.startsWith("agents/")).map(([, e]) => e.source.replace("agents/", "").replace(".asdm.md", "")))];
+    const skills = [...new Set(managedFiles.filter(([, e]) => e.source.startsWith("skills/")).map(([, e]) => e.source.replace("skills/", "").replace("/SKILL.asdm.md", "")))];
+    const commands = [...new Set(managedFiles.filter(([, e]) => e.source.startsWith("commands/")).map(([, e]) => e.source.replace("commands/", "").replace(".asdm.md", "")))];
+    logger.table([
+      ["Last synced", syncedAt],
+      ["Manifest version", lockfile.manifest_version],
+      ["CLI version", lockfile.cli_version],
+      ["Managed files", String(managedFiles.length)],
+      ["Agents", agents.length > 0 ? agents.join(", ") : "(none)"],
+      ["Skills", skills.length > 0 ? skills.join(", ") : "(none)"],
+      ["Commands", commands.length > 0 ? commands.join(", ") : "(none)"]
+    ]);
+    logger.divider();
+    logger.success("Up to date \u2014 run `asdm sync` to check for updates");
+  }
+});
+
+// src/cli/commands/use.ts
+import { defineCommand as defineCommand5 } from "citty";
+var use_default = defineCommand5({
+  meta: {
+    name: "use",
+    description: "Switch the active profile (stored in .asdm.local.json)"
+  },
+  args: {
+    profile: {
+      type: "positional",
+      description: "Profile name to activate",
+      required: true
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const profile = ctx.args.profile;
+    if (!profile) {
+      logger.error("Profile name is required", "Usage: asdm use <profile>");
+      process.exit(1);
+    }
+    try {
+      await readProjectConfig(cwd);
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        logger.error("No .asdm.json found", "Run `asdm init` first");
+        process.exit(1);
+      }
+      throw err;
+    }
+    const cachedManifest = await loadCachedManifest(cwd);
+    if (cachedManifest) {
+      if (!cachedManifest.profiles[profile]) {
+        const available = Object.keys(cachedManifest.profiles).join(", ");
+        logger.error(
+          `Profile "${profile}" not found in manifest`,
+          `Available profiles: ${available}`
+        );
+        process.exit(1);
+      }
+    } else {
+      logger.warn("No cached manifest found \u2014 skipping profile validation");
+    }
+    try {
+      await writeUserConfig(cwd, { profile });
+      logger.success(`Switched to profile "${profile}"`);
+      logger.asdm("Syncing with new profile\u2026");
+      const result = await sync({ cwd });
+      const changed = result.stats.filesAdded + result.stats.filesUpdated;
+      logger.success(`Sync complete \u2014 ${changed} file(s) updated`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const suggestion = err.suggestion ?? void 0;
+      logger.error(message, suggestion);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/profiles.ts
+import { defineCommand as defineCommand6 } from "citty";
+var profiles_default = defineCommand6({
+  meta: {
+    name: "profiles",
+    description: "List available profiles from the registry"
+  },
+  args: {
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    let projectConfig;
+    try {
+      projectConfig = await readProjectConfig(cwd);
+    } catch (err) {
+      if (err instanceof ConfigError) {
+        logger.error("No .asdm.json found", "Run `asdm init` first");
+        process.exit(1);
+      }
+      throw err;
+    }
+    try {
+      const client = new RegistryClient(projectConfig.registry);
+      const manifest = await client.getLatestManifest();
+      if (ctx.args.json) {
+        console.log(JSON.stringify(manifest.profiles, null, 2));
+        return;
+      }
+      logger.asdm(`Available profiles (manifest v${manifest.version})`);
+      logger.divider();
+      const profileEntries = Object.entries(manifest.profiles);
+      if (profileEntries.length === 0) {
+        logger.info("No profiles found in manifest");
+        return;
+      }
+      for (const [name, profile] of profileEntries) {
+        const agents = profile.agents?.length ?? 0;
+        const skills = profile.skills?.length ?? 0;
+        const cmds = profile.commands?.length ?? 0;
+        const extendsFrom = profile.extends?.join(", ") ?? "\u2014";
+        logger.bullet(logger.bold(name));
+        logger.table([
+          ["  Extends", extendsFrom],
+          ["  Agents", String(agents)],
+          ["  Skills", String(skills)],
+          ["  Commands", String(cmds)]
+        ], 12);
+      }
+      logger.divider();
+      logger.info("Use `asdm use <profile>` to switch profiles");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const suggestion = err.suggestion ?? void 0;
+      logger.error(message, suggestion);
+      process.exit(1);
+    }
+  }
+});
+
+// src/cli/commands/agents.ts
+import { defineCommand as defineCommand7 } from "citty";
+var agents_default = defineCommand7({
+  meta: {
+    name: "agents",
+    description: "List installed or available agents"
+  },
+  args: {
+    available: {
+      type: "boolean",
+      description: "List agents available in the registry (requires network)",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    if (ctx.args.available) {
+      await listAvailableAgents(cwd, ctx.args.json);
+      return;
+    }
+    await listInstalledAgents(cwd, ctx.args.json);
+  }
+});
+async function listInstalledAgents(cwd, asJson) {
+  const lockfile = await readLockfile(cwd);
+  if (!lockfile) {
+    logger.warn("No lockfile found \u2014 run `asdm sync` first");
+    process.exit(1);
+  }
+  const agentSources = [...new Set(
+    Object.values(lockfile.files).filter((e) => e.managed && e.source.startsWith("agents/")).map((e) => e.source.replace("agents/", "").replace(".asdm.md", ""))
+  )];
+  if (asJson) {
+    console.log(JSON.stringify(agentSources, null, 2));
+    return;
+  }
+  logger.asdm(`Installed agents (profile: ${lockfile.profile})`);
+  logger.divider();
+  if (agentSources.length === 0) {
+    logger.info("No agents installed");
+    return;
+  }
+  for (const agent of agentSources) {
+    logger.bullet(agent);
+  }
+}
+async function listAvailableAgents(cwd, asJson) {
+  let projectConfig;
+  try {
+    projectConfig = await readProjectConfig(cwd);
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      logger.error("No .asdm.json found", "Run `asdm init` first");
+      process.exit(1);
+    }
+    throw err;
+  }
+  try {
+    const client = new RegistryClient(projectConfig.registry);
+    const manifest = await client.getLatestManifest();
+    const resolved = resolveProfileFromManifest(manifest.profiles, projectConfig.profile);
+    if (asJson) {
+      console.log(JSON.stringify(resolved.agents, null, 2));
+      return;
+    }
+    logger.asdm(`Available agents for profile "${projectConfig.profile}"`);
+    logger.divider();
+    if (resolved.agents.length === 0) {
+      logger.info("No agents defined for this profile");
+      return;
+    }
+    for (const agent of resolved.agents) {
+      const assetKey = `agents/${agent}.asdm.md`;
+      const meta = manifest.assets[assetKey];
+      const version = meta?.version ?? "?";
+      logger.bullet(`${agent}  (v${version})`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const suggestion = err.suggestion ?? void 0;
+    logger.error(message, suggestion);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/skills.ts
+import { defineCommand as defineCommand8 } from "citty";
+var skills_default = defineCommand8({
+  meta: {
+    name: "skills",
+    description: "List installed or available skills"
+  },
+  args: {
+    available: {
+      type: "boolean",
+      description: "List skills available in the registry (requires network)",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    if (ctx.args.available) {
+      await listAvailableSkills(cwd, ctx.args.json);
+      return;
+    }
+    await listInstalledSkills(cwd, ctx.args.json);
+  }
+});
+async function listInstalledSkills(cwd, asJson) {
+  const lockfile = await readLockfile(cwd);
+  if (!lockfile) {
+    logger.warn("No lockfile found \u2014 run `asdm sync` first");
+    process.exit(1);
+  }
+  const skillSources = [...new Set(
+    Object.values(lockfile.files).filter((e) => e.managed && e.source.startsWith("skills/")).map((e) => {
+      const parts = e.source.replace("skills/", "").split("/");
+      return parts[0] ?? e.source;
+    })
+  )];
+  if (asJson) {
+    console.log(JSON.stringify(skillSources, null, 2));
+    return;
+  }
+  logger.asdm(`Installed skills (profile: ${lockfile.profile})`);
+  logger.divider();
+  if (skillSources.length === 0) {
+    logger.info("No skills installed");
+    return;
+  }
+  for (const skill of skillSources) {
+    logger.bullet(skill);
+  }
+}
+async function listAvailableSkills(cwd, asJson) {
+  let projectConfig;
+  try {
+    projectConfig = await readProjectConfig(cwd);
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      logger.error("No .asdm.json found", "Run `asdm init` first");
+      process.exit(1);
+    }
+    throw err;
+  }
+  try {
+    const client = new RegistryClient(projectConfig.registry);
+    const manifest = await client.getLatestManifest();
+    const resolved = resolveProfileFromManifest(manifest.profiles, projectConfig.profile);
+    if (asJson) {
+      console.log(JSON.stringify(resolved.skills, null, 2));
+      return;
+    }
+    logger.asdm(`Available skills for profile "${projectConfig.profile}"`);
+    logger.divider();
+    if (resolved.skills.length === 0) {
+      logger.info("No skills defined for this profile");
+      return;
+    }
+    for (const skill of resolved.skills) {
+      const assetKey = `skills/${skill}/SKILL.asdm.md`;
+      const meta = manifest.assets[assetKey];
+      const version = meta?.version ?? "?";
+      logger.bullet(`${skill}  (v${version})`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const suggestion = err.suggestion ?? void 0;
+    logger.error(message, suggestion);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/commands.ts
+import { defineCommand as defineCommand9 } from "citty";
+var commands_default = defineCommand9({
+  meta: {
+    name: "commands",
+    description: "List installed or available slash commands"
+  },
+  args: {
+    available: {
+      type: "boolean",
+      description: "List commands available in the registry (requires network)",
+      default: false
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    if (ctx.args.available) {
+      await listAvailableCommands(cwd, ctx.args.json);
+      return;
+    }
+    await listInstalledCommands(cwd, ctx.args.json);
+  }
+});
+async function listInstalledCommands(cwd, asJson) {
+  const lockfile = await readLockfile(cwd);
+  if (!lockfile) {
+    logger.warn("No lockfile found \u2014 run `asdm sync` first");
+    process.exit(1);
+  }
+  const commandSources = [...new Set(
+    Object.values(lockfile.files).filter((e) => e.managed && e.source.startsWith("commands/")).map((e) => e.source.replace("commands/", "").replace(".asdm.md", ""))
+  )];
+  if (asJson) {
+    console.log(JSON.stringify(commandSources, null, 2));
+    return;
+  }
+  logger.asdm(`Installed commands (profile: ${lockfile.profile})`);
+  logger.divider();
+  if (commandSources.length === 0) {
+    logger.info("No commands installed");
+    return;
+  }
+  for (const cmd of commandSources) {
+    logger.bullet(`/${cmd}`);
+  }
+}
+async function listAvailableCommands(cwd, asJson) {
+  let projectConfig;
+  try {
+    projectConfig = await readProjectConfig(cwd);
+  } catch (err) {
+    if (err instanceof ConfigError) {
+      logger.error("No .asdm.json found", "Run `asdm init` first");
+      process.exit(1);
+    }
+    throw err;
+  }
+  try {
+    const client = new RegistryClient(projectConfig.registry);
+    const manifest = await client.getLatestManifest();
+    const resolved = resolveProfileFromManifest(manifest.profiles, projectConfig.profile);
+    if (asJson) {
+      console.log(JSON.stringify(resolved.commands, null, 2));
+      return;
+    }
+    logger.asdm(`Available commands for profile "${projectConfig.profile}"`);
+    logger.divider();
+    if (resolved.commands.length === 0) {
+      logger.info("No commands defined for this profile");
+      return;
+    }
+    for (const cmd of resolved.commands) {
+      const assetKey = `commands/${cmd}.asdm.md`;
+      const meta = manifest.assets[assetKey];
+      const version = meta?.version ?? "?";
+      logger.bullet(`/${cmd}  (v${version})`);
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const suggestion = err.suggestion ?? void 0;
+    logger.error(message, suggestion);
+    process.exit(1);
+  }
+}
+
+// src/cli/commands/version.ts
+import { defineCommand as defineCommand10 } from "citty";
+import os3 from "os";
+var version_default = defineCommand10({
+  meta: {
+    name: "version",
+    description: "Print CLI version and environment info"
+  },
+  run(_ctx) {
+    console.log(`asdm v${"0.1.0"}`);
+    console.log(`node  ${process.version}`);
+    console.log(`os    ${os3.type()} ${os3.release()} (${process.platform})`);
+  }
+});
+
+// src/cli/commands/doctor.ts
+import { defineCommand as defineCommand11 } from "citty";
+import path14 from "path";
+
+// src/core/overlay.ts
+init_fs();
+import path13 from "path";
+import { promises as fs4 } from "fs";
+var OVERLAY_SEPARATOR = [
+  "",
+  "<!-- managed content above -->",
+  "",
+  "---",
+  "<!-- LOCAL OVERLAY \u2014 this section is not managed by ASDM -->",
+  ""
+].join("\n");
+async function readOverlays(projectRoot) {
+  const overlaysDir = path13.join(projectRoot, "overlays");
+  const dirExists = await exists(overlaysDir);
+  if (!dirExists) return /* @__PURE__ */ new Map();
+  const entries = await fs4.readdir(overlaysDir, { withFileTypes: true });
+  const overlayMap = /* @__PURE__ */ new Map();
+  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 content = await readFile(overlayPath);
+    if (content === null) continue;
+    overlayMap.set(agentId, { agentId, content, path: overlayPath });
+  }
+  return overlayMap;
+}
+
+// src/cli/commands/doctor.ts
+init_fs();
+function extractAgentNamesFromLockfile(lockfile) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of Object.values(lockfile.files)) {
+    if (entry.source.startsWith("agents/") && entry.source.endsWith(".asdm.md")) {
+      const name = entry.source.slice("agents/".length, -".asdm.md".length);
+      names.add(name);
+    }
+  }
+  return names;
+}
+var doctor_default = defineCommand11({
+  meta: {
+    name: "doctor",
+    description: "Run diagnostics on the ASDM setup"
+  },
+  async run(_ctx) {
+    const cwd = process.cwd();
+    const checks = [];
+    let anyFailed = false;
+    let projectConfig = null;
+    let registryClient = null;
+    const configPath = path14.join(cwd, ".asdm.json");
+    const hasConfig = await exists(configPath);
+    checks.push({
+      label: ".asdm.json present",
+      status: hasConfig ? "ok" : "fail",
+      detail: hasConfig ? void 0 : "Run `asdm init` to create it"
+    });
+    if (!hasConfig) anyFailed = true;
+    if (hasConfig) {
+      try {
+        projectConfig = await readProjectConfig(cwd);
+        registryClient = new RegistryClient(projectConfig.registry);
+        const reachable = await registryClient.ping();
+        checks.push({
+          label: `Registry reachable (${projectConfig.registry})`,
+          status: reachable ? "ok" : "fail",
+          detail: reachable ? void 0 : "Check GITHUB_TOKEN and network connectivity"
+        });
+        if (!reachable) anyFailed = true;
+      } catch {
+        checks.push({
+          label: "Registry reachable",
+          status: "fail",
+          detail: "Could not read registry config"
+        });
+        anyFailed = true;
+      }
+    } else {
+      checks.push({
+        label: "Registry reachable",
+        status: "skip",
+        detail: "Skipped \u2014 no .asdm.json"
+      });
+    }
+    const lockfile = await readLockfile(cwd);
+    checks.push({
+      label: ".asdm-lock.json present",
+      status: lockfile ? "ok" : "warn",
+      detail: lockfile ? void 0 : "Run `asdm sync` to generate lockfile"
+    });
+    if (!lockfile) anyFailed = true;
+    if (lockfile) {
+      const verifyResult = await verify(cwd);
+      if (verifyResult.exitCode === VERIFY_EXIT_CODES.OK) {
+        checks.push({
+          label: `Managed files intact (${verifyResult.checkedFiles} files)`,
+          status: "ok"
+        });
+      } else if (verifyResult.exitCode === VERIFY_EXIT_CODES.MODIFIED) {
+        const count = verifyResult.violations.length;
+        checks.push({
+          label: "Managed files intact",
+          status: "fail",
+          detail: `${count} violation(s) \u2014 run \`asdm verify\` for details`
+        });
+        anyFailed = true;
+      } else {
+        checks.push({
+          label: "Managed files intact",
+          status: "warn",
+          detail: `Exit code ${verifyResult.exitCode}`
+        });
+      }
+      const managedEntries = Object.entries(lockfile.files).filter(([, e]) => e.managed);
+      const missingFiles = [];
+      const resolvedCwd = path14.resolve(cwd);
+      for (const [filePath] of managedEntries) {
+        const absPath = path14.resolve(cwd, filePath);
+        if (!absPath.startsWith(resolvedCwd + path14.sep) && absPath !== resolvedCwd) {
+          continue;
+        }
+        const fileExists = await exists(absPath);
+        if (!fileExists) missingFiles.push(filePath);
+      }
+      checks.push({
+        label: "All managed files on disk",
+        status: missingFiles.length === 0 ? "ok" : "fail",
+        detail: missingFiles.length > 0 ? `${missingFiles.length} missing \u2014 run \`asdm sync --force\`` : void 0
+      });
+      if (missingFiles.length > 0) anyFailed = true;
+    } else {
+      checks.push({
+        label: "Managed files intact",
+        status: "skip",
+        detail: "Skipped \u2014 no lockfile"
+      });
+      checks.push({
+        label: "All managed files on disk",
+        status: "skip",
+        detail: "Skipped \u2014 no lockfile"
+      });
+    }
+    if (lockfile) {
+      const overlays = await readOverlays(cwd);
+      if (overlays.size === 0) {
+        checks.push({
+          label: "Overlay files valid",
+          status: "ok",
+          detail: "No overlays found"
+        });
+      } else {
+        const knownAgents = extractAgentNamesFromLockfile(lockfile);
+        const unknownOverlays = [...overlays.keys()].filter((id) => !knownAgents.has(id));
+        if (unknownOverlays.length === 0) {
+          checks.push({
+            label: `Overlay files valid (${overlays.size} overlay(s))`,
+            status: "ok"
+          });
+        } else {
+          checks.push({
+            label: "Overlay files valid",
+            status: "warn",
+            detail: `Unknown agent(s): ${unknownOverlays.join(", ")} \u2014 not in lockfile`
+          });
+        }
+      }
+    } else {
+      checks.push({
+        label: "Overlay files valid",
+        status: "skip",
+        detail: "Skipped \u2014 no lockfile"
+      });
+    }
+    const gitignoreContent = await readFile(path14.join(cwd, ".gitignore"));
+    const hasAsdmBlock = gitignoreContent?.includes(ASDM_MARKER_START) ?? false;
+    checks.push({
+      label: ".gitignore has ASDM block",
+      status: hasAsdmBlock ? "ok" : "skip",
+      detail: hasAsdmBlock ? void 0 : "Run 'asdm gitignore' to add managed output dirs"
+    });
+    if (lockfile && registryClient) {
+      try {
+        const latestManifest = await registryClient.getLatestManifest();
+        const isUpToDate = lockfile.manifest_version === latestManifest.version;
+        checks.push({
+          label: "Registry version",
+          status: isUpToDate ? "ok" : "warn",
+          detail: isUpToDate ? `Up to date (v${lockfile.manifest_version})` : `Behind \u2014 local v${lockfile.manifest_version}, registry v${latestManifest.version}`
+        });
+      } catch {
+        checks.push({
+          label: "Registry version",
+          status: "skip",
+          detail: "Could not reach registry to check version"
+        });
+      }
+    } else if (!registryClient) {
+      checks.push({
+        label: "Registry version",
+        status: "skip",
+        detail: "Skipped \u2014 no registry config"
+      });
+    } else {
+      checks.push({
+        label: "Registry version",
+        status: "skip",
+        detail: "Skipped \u2014 no lockfile"
+      });
+    }
+    logger.asdm("ASDM Doctor");
+    logger.divider();
+    for (const check of checks) {
+      logger.status(check.label, check.status, check.detail);
+    }
+    logger.divider();
+    if (anyFailed) {
+      logger.error("Some checks failed \u2014 review the output above");
+      process.exit(1);
+    } else {
+      logger.success("All checks passed");
+    }
+  }
+});
+
+// src/cli/commands/clean.ts
+import { defineCommand as defineCommand12 } from "citty";
+import path15 from "path";
+import { promises as fs5 } from "fs";
+import readline from "readline";
+init_fs();
+var LOCKFILE_NAME2 = ".asdm-lock.json";
+async function getFileSizeBytes(filePath) {
+  try {
+    const stat = await fs5.stat(filePath);
+    return stat.size;
+  } catch {
+    return 0;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)} KB`;
+  return `${(kb / 1024).toFixed(2)} MB`;
+}
+async function confirmPrompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y");
+    });
+  });
+}
+var clean_default = defineCommand12({
+  meta: {
+    name: "clean",
+    description: "Remove ASDM-managed files and the lockfile"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Preview what would be removed without deleting",
+      default: false
+    },
+    target: {
+      type: "string",
+      description: "Only clean files for a specific provider (opencode | claude-code | copilot)",
+      alias: "t"
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const dryRun = ctx.args["dry-run"];
+    const target = ctx.args.target;
+    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");
+      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");
+      }
+      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] `
+      );
+      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 = path15.resolve(cwd, relativePath);
+      const fileExists = await exists(absolutePath);
+      if (!fileExists) {
+        logger.dim(`  skip  ${relativePath} (not found)`);
+        skippedMissing++;
+        continue;
+      }
+      if (dryRun) {
+        logger.bullet(`would remove: ${relativePath}`);
+        removed++;
+        continue;
+      }
+      const fileSize = await getFileSizeBytes(absolutePath);
+      await removeFile(absolutePath);
+      totalBytesFreed += fileSize;
+      logger.bullet(`removed: ${relativePath}`);
+      removed++;
+    }
+    const lockfilePath = path15.join(cwd, LOCKFILE_NAME2);
+    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_NAME2} (removed ${target} entries)`);
+      } else if (dryRun) {
+        logger.bullet(`would update: ${LOCKFILE_NAME2} (remove ${target} entries)`);
+      }
+    } 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.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 { promises as fs6 } from "fs";
+
+// src/utils/post-merge-hook.ts
+function generatePostMergeHook() {
+  return `#!/usr/bin/env sh
+# ASDM MANAGED \u2014 post-merge hook
+if [ -f ".asdm.yaml" ] || [ -f ".asdm.json" ]; then
+  echo "\u{1F504} ASDM: syncing after merge..."
+  npx asdm sync
+fi
+`;
+}
+
+// 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
+# 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"
+  }
+};
+function resolveHookTypes(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);
+  }
+  const hookExists = await exists(hookPath);
+  if (hookExists) {
+    const existing = await fs6.readFile(hookPath, "utf-8");
+    if (existing.includes(def.marker)) {
+      logger.info(`ASDM ${hookType} hook is already installed`);
+      return;
+    }
+    logger.warn(`A ${hookType} hook already exists and is not managed by ASDM.`);
+    logger.warn(`Manual action required: add the ASDM logic to ${def.relativePath}`);
+    process.exit(1);
+  }
+  await writeFile(hookPath, def.content);
+  try {
+    await fs6.chmod(hookPath, 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 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);
+  }
+  await removeFile(hookPath);
+  logger.success(`Removed ASDM ${hookType} hook from ${def.relativePath}`);
+}
+var installCommand = defineCommand13({
+  meta: {
+    name: "install",
+    description: "Install ASDM git hooks (pre-commit and/or post-merge)"
+  },
+  args: {
+    hook: {
+      type: "string",
+      description: "Which hook to install: pre-commit | post-merge | all",
+      default: "all"
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const hookTypes = resolveHookTypes(ctx.args.hook);
+    for (const hookType of hookTypes) {
+      await installHook(cwd, hookType);
+    }
+  }
+});
+var uninstallCommand = defineCommand13({
+  meta: {
+    name: "uninstall",
+    description: "Remove ASDM git hooks"
+  },
+  args: {
+    hook: {
+      type: "string",
+      description: "Which hook to remove: pre-commit | post-merge | all",
+      default: "all"
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const hookTypes = resolveHookTypes(ctx.args.hook);
+    for (const hookType of hookTypes) {
+      await uninstallHook(cwd, hookType);
+    }
+  }
+});
+var hooks_default = defineCommand13({
+  meta: {
+    name: "hooks",
+    description: "Manage git hooks for ASDM integrity verification and auto-sync"
+  },
+  subCommands: {
+    install: installCommand,
+    uninstall: uninstallCommand
+  }
+});
+
+// src/cli/commands/gitignore.ts
+import { defineCommand as defineCommand14 } from "citty";
+var gitignore_default = defineCommand14({
+  meta: {
+    name: "gitignore",
+    description: "Add or remove ASDM managed entries in .gitignore"
+  },
+  args: {
+    "dry-run": {
+      type: "boolean",
+      description: "Print what would be added without modifying the file",
+      default: false
+    },
+    remove: {
+      type: "boolean",
+      description: "Remove the ASDM block from .gitignore",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    let providers;
+    try {
+      const config = await readProjectConfig(cwd);
+      providers = config.providers ?? ["opencode"];
+    } catch {
+      logger.error("No .asdm.json found", "Run `asdm init` first");
+      process.exit(1);
+      return;
+    }
+    if (ctx.args.remove) {
+      const removed = await removeGitignoreBlock(cwd);
+      if (removed) {
+        logger.success("Removed ASDM block from .gitignore");
+      } else {
+        logger.info("No ASDM block found in .gitignore \u2014 nothing to remove");
+      }
+      return;
+    }
+    const entries = getGitignoreEntries(providers);
+    if (ctx.args["dry-run"]) {
+      logger.asdm("Would add to .gitignore:");
+      logger.dim(ASDM_MARKER_START);
+      for (const entry of entries) {
+        logger.bullet(entry);
+      }
+      logger.dim(ASDM_MARKER_END);
+      return;
+    }
+    const updated = await updateGitignore(cwd, providers);
+    if (updated) {
+      logger.success(`Updated .gitignore with ${entries.length} ASDM entr${entries.length === 1 ? "y" : "ies"}`);
+    } else {
+      logger.info(".gitignore is already up to date");
+    }
+  }
+});
+
+// src/cli/commands/telemetry.ts
+import { defineCommand as defineCommand15 } from "citty";
+var showCommand = defineCommand15({
+  meta: {
+    name: "show",
+    description: "Show recent telemetry events"
+  },
+  args: {
+    limit: {
+      type: "string",
+      description: "Number of events to show",
+      default: "20"
+    },
+    json: {
+      type: "boolean",
+      description: "Output as JSON",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    const writer = new TelemetryWriter(cwd);
+    const events = await writer.readAll();
+    const limit = Math.max(1, parseInt(ctx.args.limit, 10) || 20);
+    const shown = events.slice(-limit);
+    if (ctx.args.json) {
+      console.log(JSON.stringify(shown, null, 2));
+      return;
+    }
+    if (shown.length === 0) {
+      logger.info("No telemetry events found in .asdm-telemetry.jsonl");
+      return;
+    }
+    logger.asdm(`Last ${shown.length} telemetry event(s)`);
+    logger.divider();
+    for (const event of shown) {
+      const ts = new Date(event.timestamp).toLocaleString();
+      const parts = [];
+      if (event.profile) parts.push(`profile=${event.profile}`);
+      if (event.durationMs != null) parts.push(`${event.durationMs}ms`);
+      if (event.assetCount != null) parts.push(`${event.assetCount} assets`);
+      if (event.violations != null) parts.push(`${event.violations} violation(s)`);
+      if (event.error) parts.push(`error="${event.error}"`);
+      const detail = parts.length > 0 ? `  ${parts.join("  ")}` : "";
+      logger.bullet(`${event.event.padEnd(20)} ${ts}${detail}`);
+    }
+  }
+});
+var clearCommand = defineCommand15({
+  meta: {
+    name: "clear",
+    description: "Clear the local telemetry log"
+  },
+  args: {
+    force: {
+      type: "boolean",
+      description: "Skip confirmation prompt",
+      default: false
+    }
+  },
+  async run(ctx) {
+    const cwd = process.cwd();
+    if (!ctx.args.force) {
+      logger.warn("This will permanently delete all local telemetry data.");
+      logger.info("Use --force to confirm: asdm telemetry clear --force");
+      process.exit(1);
+    }
+    const writer = new TelemetryWriter(cwd);
+    await writer.clear();
+    logger.success("Telemetry log cleared (.asdm-telemetry.jsonl removed)");
+  }
+});
+var telemetry_default = defineCommand15({
+  meta: {
+    name: "telemetry",
+    description: "Manage local telemetry data"
+  },
+  subCommands: {
+    show: showCommand,
+    clear: clearCommand
+  }
+});
+
+// src/core/version-check.ts
+init_fs();
+import path17 from "path";
+var CACHE_FILENAME = "version-check-cache.json";
+var CHECK_INTERVAL_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function isNewerVersion(current, latest) {
+  const parse = (v) => {
+    const parts = v.replace(/^v/, "").split(".");
+    return [
+      parseInt(parts[0] ?? "0", 10),
+      parseInt(parts[1] ?? "0", 10),
+      parseInt(parts[2] ?? "0", 10)
+    ];
+  };
+  const [cMajor, cMinor, cPatch] = parse(current);
+  const [lMajor, lMinor, lPatch] = parse(latest);
+  if (lMajor !== cMajor) return lMajor > cMajor;
+  if (lMinor !== cMinor) return lMinor > cMinor;
+  return lPatch > cPatch;
+}
+async function checkForUpdate(currentVersion) {
+  const cacheDir = getAsdmConfigDir();
+  const cachePath = path17.join(cacheDir, CACHE_FILENAME);
+  const cache = await readJson(cachePath);
+  if (cache) {
+    const ageMs = Date.now() - new Date(cache.checkedAt).getTime();
+    if (ageMs < CHECK_INTERVAL_MS) {
+      return isNewerVersion(currentVersion, cache.latestVersion) ? cache.latestVersion : null;
+    }
+  }
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const response = await fetch("https://registry.npmjs.org/@asdm/cli/latest", {
+      signal: controller.signal,
+      headers: { Accept: "application/json" }
+    });
+    clearTimeout(timer);
+    if (!response.ok) return null;
+    const data = await response.json();
+    const latestVersion = data.version;
+    if (!latestVersion) return null;
+    await ensureDir(cacheDir);
+    await writeJson(cachePath, {
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      latestVersion
+    });
+    return isNewerVersion(currentVersion, latestVersion) ? latestVersion : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/index.ts
+var rootCommand = defineCommand16({
+  meta: {
+    name: "asdm",
+    version: "0.1.0",
+    description: "Agentic Software Delivery Model \u2014 Write Once, Emit Many"
+  },
+  subCommands: {
+    init: init_default,
+    sync: sync_default,
+    verify: verify_default,
+    status: status_default,
+    use: use_default,
+    profiles: profiles_default,
+    agents: agents_default,
+    skills: skills_default,
+    commands: commands_default,
+    version: version_default,
+    doctor: doctor_default,
+    clean: clean_default,
+    hooks: hooks_default,
+    gitignore: gitignore_default,
+    telemetry: telemetry_default
+  }
+});
+function printUpdateBox(currentVersion, latestVersion) {
+  const YELLOW = "\x1B[33m";
+  const BOLD2 = "\x1B[1m";
+  const RESET2 = "\x1B[0m";
+  const updateLine = `  Update available: ${currentVersion} \u2192 ${latestVersion}`;
+  const cmdLine = `  Run: npm install -g @asdm/cli`;
+  const MIN_WIDTH = 45;
+  const innerWidth = Math.max(
+    Math.max(updateLine.length, cmdLine.length) + 2,
+    MIN_WIDTH
+  );
+  const top = `\u256D${"\u2500".repeat(innerWidth)}\u256E`;
+  const r1 = `\u2502${updateLine.padEnd(innerWidth)}\u2502`;
+  const r2 = `\u2502${cmdLine.padEnd(innerWidth)}\u2502`;
+  const bot = `\u2570${"\u2500".repeat(innerWidth)}\u256F`;
+  console.log(`
+${YELLOW}${BOLD2}${top}
+${r1}
+${r2}
+${bot}${RESET2}`);
+}
+async function main() {
+  await runMain(rootCommand);
+  try {
+    const latestVersion = await checkForUpdate("0.1.0");
+    if (latestVersion) {
+      printUpdateBox("0.1.0", latestVersion);
+    }
+  } catch {
+  }
+}
+main();