@the-aico/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,3331 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command10 } from "commander";
+
+// src/utils/errors.ts
+import kleur from "kleur";
+import { ZodError } from "zod";
+
+// src/utils/error-suggestions.ts
+var defaultSuggestions = {
+  // Network errors
+  NETWORK_ERROR: "Check your internet connection or try using a proxy with --proxy option.",
+  FETCH_ERROR: "Verify the registry URL is correct and accessible.",
+  TIMEOUT: "The request timed out. Try again or check your network.",
+  REGISTRY_UNAVAILABLE: "The registry server is unavailable. Try again later.",
+  // Resource errors
+  NOT_FOUND: "The requested resource was not found.",
+  SKILL_NOT_FOUND: "Use `npx aico list --skills` to see available skills.",
+  EMPLOYEE_NOT_FOUND: "Use `npx aico list` to see available employees.",
+  // Configuration errors
+  NOT_INITIALIZED: "Run `npx aico init` to initialize the project.",
+  CONFIG_INVALID: "Check your aico.json for syntax errors or run `npx aico init --force`.",
+  CONFIG_EXISTS: "Use `npx aico init --force` to overwrite existing config.",
+  CONFIG_PARSE_ERROR: "Your aico.json contains invalid JSON. Check for syntax errors.",
+  // Dependency errors
+  DEPENDENCY_MISSING: "Install the missing dependency first, or use `--no-deps` to skip.",
+  CIRCULAR_DEPENDENCY: "Check your skill dependencies for circular references.",
+  // File errors
+  FILE_EXISTS: "Use `--overwrite` to replace existing files.",
+  FILE_NOT_FOUND: "Verify the file path is correct.",
+  PERMISSION_DENIED: "Check file permissions or run with appropriate privileges.",
+  WRITE_ERROR: "Unable to write file. Check disk space and permissions.",
+  // Platform errors
+  PLATFORM_NOT_SUPPORTED: "Supported platforms: claude-code, codex.",
+  // Validation errors
+  VALIDATION_ERROR: "Check the input format and try again.",
+  INVALID_ARGUMENT: "Check the command arguments and options."
+};
+function getSuggestion(code) {
+  return defaultSuggestions[code] || "Please check the error details above.";
+}
+
+// src/utils/errors.ts
+var AicoError = class extends Error {
+  code;
+  suggestion;
+  context;
+  cause;
+  constructor(message, code, options) {
+    super(message);
+    this.name = "AicoError";
+    this.code = code;
+    this.suggestion = options?.suggestion || getSuggestion(code);
+    this.context = options?.context;
+    this.cause = options?.cause;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      suggestion: this.suggestion,
+      context: this.context
+    };
+  }
+};
+function handleError(error, options = {}) {
+  const { verbose = false, exitCode = 1 } = options;
+  console.error("");
+  if (error instanceof AicoError) {
+    console.error(kleur.red("\u2716 Error:"), error.message);
+    console.error("");
+    console.error(kleur.dim("  Code:"), error.code);
+    console.error("");
+    console.error(kleur.cyan("  Suggestion:"));
+    console.error(`  ${error.suggestion}`);
+    if (error.context && verbose) {
+      console.error("");
+      console.error(kleur.dim("  Context:"));
+      for (const [key, value] of Object.entries(error.context)) {
+        console.error(`    ${key}: ${JSON.stringify(value)}`);
+      }
+    }
+    if (error.cause && verbose) {
+      console.error("");
+      console.error(kleur.dim("  Caused by:"));
+      if (error.cause instanceof Error) {
+        console.error(`    ${error.cause.message}`);
+      } else {
+        console.error(`    ${String(error.cause)}`);
+      }
+    }
+  } else if (error instanceof ZodError) {
+    console.error(kleur.red("\u2716 Validation Error:"));
+    console.error("");
+    for (const issue of error.issues) {
+      const path9 = issue.path.length > 0 ? issue.path.join(".") : "value";
+      console.error(`  ${kleur.yellow(path9)}: ${issue.message}`);
+    }
+    console.error("");
+    console.error(kleur.cyan("  Suggestion:"));
+    console.error(
+      "  Check the configuration file format or command arguments."
+    );
+  } else if (error instanceof Error) {
+    console.error(kleur.red("\u2716 Error:"), error.message);
+    if (verbose && error.stack) {
+      console.error("");
+      console.error(kleur.dim("  Stack trace:"));
+      const stackLines = error.stack.split("\n").slice(1);
+      for (const line of stackLines.slice(0, 5)) {
+        console.error(kleur.dim(line));
+      }
+      if (stackLines.length > 5) {
+        console.error(kleur.dim(`    ... ${stackLines.length - 5} more lines`));
+      }
+    }
+  } else {
+    console.error(kleur.red("\u2716 Unknown error:"), String(error));
+  }
+  console.error("");
+  console.error(kleur.dim("  If the problem persists, please open an issue:"));
+  console.error(kleur.dim("  https://github.com/yellinzero/aico/issues"));
+  console.error("");
+  process.exit(exitCode);
+}
+function notInitializedError() {
+  return new AicoError(
+    "No aico.json found in current directory.",
+    "NOT_INITIALIZED"
+  );
+}
+function employeeNotFoundError(name) {
+  return new AicoError(
+    `Employee '${name}' not found in registry.`,
+    "EMPLOYEE_NOT_FOUND",
+    { context: { name } }
+  );
+}
+function skillNotFoundError(name) {
+  return new AicoError(
+    `Skill '${name}' not found in registry.`,
+    "SKILL_NOT_FOUND",
+    { context: { name } }
+  );
+}
+function platformNotSupportedError(platform) {
+  return new AicoError(
+    `Platform '${platform}' is not supported.`,
+    "PLATFORM_NOT_SUPPORTED",
+    { context: { platform } }
+  );
+}
+function registryFetchError(url, status) {
+  return new AicoError(
+    `Failed to fetch from registry: ${url} (status: ${status})`,
+    "FETCH_ERROR",
+    { context: { url, status } }
+  );
+}
+
+// src/commands/init.ts
+import { Command } from "commander";
+import prompts from "prompts";
+import { z as z2 } from "zod";
+
+// src/utils/config.ts
+import fs from "fs-extra";
+import os from "os";
+import path from "path";
+
+// src/schema/config.ts
+import { z } from "zod";
+var DEFAULT_REGISTRY_URL = "https://the-aico.com/r/{name}.json";
+var DEFAULT_SCHEMA_URL = "https://the-aico.com/schema/config.json";
+var platformSchema = z.enum(["claude-code", "codex"]);
+var languageSchema = z.string().default("en");
+var platformPathsSchema = z.object({
+  skills: z.string(),
+  commands: z.string()
+});
+var employeeStateSchema = z.object({
+  platforms: z.array(platformSchema),
+  installedAt: z.string(),
+  version: z.string().optional(),
+  // Track installed skills and commands for update detection
+  skills: z.array(z.string()).optional(),
+  commands: z.array(z.string()).optional()
+});
+var skillStateSchema = z.object({
+  version: z.string(),
+  installedAt: z.string(),
+  source: z.enum(["standalone", "employee"]),
+  // standalone = single install, employee = part of employee
+  platforms: z.array(platformSchema)
+});
+var sharedSkillStateSchema = z.object({
+  version: z.string(),
+  installedAt: z.string(),
+  platforms: z.array(platformSchema),
+  // Track which employees depend on this shared skill
+  // When this array becomes empty, the shared skill can be removed
+  usedBy: z.array(z.string())
+});
+var registryConfigSchema = z.union([
+  z.string().refine((s) => s.includes("{name}"), {
+    message: "Registry URL must include {name} placeholder"
+  }),
+  z.object({
+    url: z.string().refine((s) => s.includes("{name}"), {
+      message: "Registry URL must include {name} placeholder"
+    }),
+    headers: z.record(z.string()).optional()
+  })
+]);
+var configSchema = z.object({
+  $schema: z.string().optional(),
+  language: languageSchema.optional(),
+  defaultPlatform: platformSchema,
+  platforms: z.record(platformSchema, platformPathsSchema),
+  employees: z.record(z.string(), employeeStateSchema).default({}),
+  skills: z.record(z.string(), skillStateSchema).default({}),
+  // Standalone skills
+  sharedSkills: z.record(z.string(), sharedSkillStateSchema).default({}),
+  // Shared skills with reference tracking
+  registries: z.record(
+    z.string().refine((key) => key.startsWith("@"), {
+      message: "Registry key must start with @"
+    }),
+    registryConfigSchema
+  ).default({
+    "@the-aico": DEFAULT_REGISTRY_URL
+  })
+});
+var DEFAULT_PLATFORMS = {
+  "claude-code": {
+    skills: ".claude/skills",
+    commands: ".claude/commands"
+  },
+  // Codex 平台配置：
+  // - skills: 项目目录 .codex/skills/（Codex 原生支持项目级 skills）
+  // - commands (prompts): 全局 ~/.codex/prompts/（一次安装所有项目可用）
+  // 调用方式：/prompts:aico.{employee}.{command}
+  // 用户可在 aico.json 中覆盖路径
+  codex: {
+    skills: ".codex/skills",
+    commands: "~/.codex/prompts"
+    // Codex custom prompts (全局)
+  }
+};
+function createDefaultConfig(defaultPlatform = "claude-code") {
+  return {
+    $schema: DEFAULT_SCHEMA_URL,
+    defaultPlatform,
+    platforms: DEFAULT_PLATFORMS,
+    employees: {},
+    skills: {},
+    sharedSkills: {},
+    registries: {
+      "@the-aico": DEFAULT_REGISTRY_URL
+    }
+  };
+}
+
+// src/utils/config.ts
+var CONFIG_FILENAME = "aico.json";
+function expandTilde(filePath) {
+  if (filePath.startsWith("~/") || filePath === "~") {
+    return path.join(os.homedir(), filePath.slice(1));
+  }
+  return filePath;
+}
+function getConfigPath(cwd) {
+  return path.resolve(cwd, CONFIG_FILENAME);
+}
+async function configExists(cwd) {
+  const configPath = getConfigPath(cwd);
+  return fs.pathExists(configPath);
+}
+async function getConfig(cwd) {
+  const configPath = getConfigPath(cwd);
+  if (!await fs.pathExists(configPath)) {
+    return null;
+  }
+  const raw = await fs.readJson(configPath);
+  return configSchema.parse(raw);
+}
+async function writeConfig(cwd, config) {
+  const configPath = getConfigPath(cwd);
+  await fs.writeJson(configPath, config, { spaces: 2 });
+}
+async function updateEmployees(cwd, employeeName, platforms, skills, commands) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw new Error("Config not found");
+  }
+  config.employees[employeeName] = {
+    platforms,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    skills,
+    commands
+  };
+  await writeConfig(cwd, config);
+}
+async function removeEmployee(cwd, employeeName) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw new Error("Config not found");
+  }
+  delete config.employees[employeeName];
+  await writeConfig(cwd, config);
+}
+function resolvePlatformPaths(cwd, config, platform) {
+  const paths = config.platforms[platform];
+  if (!paths) {
+    throw new Error(`Platform ${platform} not configured`);
+  }
+  const skillsPath = expandTilde(paths.skills);
+  const commandsPath = expandTilde(paths.commands);
+  return {
+    skillsDir: path.isAbsolute(skillsPath) ? skillsPath : path.resolve(cwd, skillsPath),
+    commandsDir: path.isAbsolute(commandsPath) ? commandsPath : path.resolve(cwd, commandsPath)
+  };
+}
+async function updateSkill(cwd, skillFullName, version, platforms, source = "standalone") {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw new Error("Config not found");
+  }
+  if (!config.skills) {
+    config.skills = {};
+  }
+  config.skills[skillFullName] = {
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    source,
+    platforms
+  };
+  await writeConfig(cwd, config);
+}
+async function removeSkill(cwd, skillFullName) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw new Error("Config not found");
+  }
+  if (config.skills) {
+    delete config.skills[skillFullName];
+  }
+  await writeConfig(cwd, config);
+}
+async function getInstalledSkills(cwd) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    return [];
+  }
+  const skills = /* @__PURE__ */ new Set();
+  if (config.skills) {
+    for (const skillName of Object.keys(config.skills)) {
+      skills.add(skillName);
+    }
+  }
+  for (const empState of Object.values(config.employees)) {
+    if (empState.skills) {
+      for (const skillName of empState.skills) {
+        skills.add(skillName);
+      }
+    }
+  }
+  return Array.from(skills);
+}
+async function addSharedSkillReference(cwd, sharedSkillFullName, employeeName, version, platforms) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw new Error("Config not found");
+  }
+  if (!config.sharedSkills) {
+    config.sharedSkills = {};
+  }
+  const existing = config.sharedSkills[sharedSkillFullName];
+  if (existing) {
+    if (!existing.usedBy.includes(employeeName)) {
+      existing.usedBy.push(employeeName);
+    }
+    const allPlatforms = /* @__PURE__ */ new Set([...existing.platforms, ...platforms]);
+    existing.platforms = Array.from(allPlatforms);
+    await writeConfig(cwd, config);
+    return { isNew: false };
+  }
+  config.sharedSkills[sharedSkillFullName] = {
+    version,
+    installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    platforms,
+    usedBy: [employeeName]
+  };
+  await writeConfig(cwd, config);
+  return { isNew: true };
+}
+async function removeSharedSkillReference(cwd, sharedSkillFullName, employeeName) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw new Error("Config not found");
+  }
+  const existing = config.sharedSkills?.[sharedSkillFullName];
+  if (!existing) {
+    return { shouldUninstall: false, remainingUsers: [] };
+  }
+  existing.usedBy = existing.usedBy.filter((e) => e !== employeeName);
+  if (existing.usedBy.length === 0) {
+    delete config.sharedSkills[sharedSkillFullName];
+    await writeConfig(cwd, config);
+    return { shouldUninstall: true, remainingUsers: [] };
+  }
+  await writeConfig(cwd, config);
+  return { shouldUninstall: false, remainingUsers: existing.usedBy };
+}
+async function getSharedSkillState(cwd, sharedSkillFullName) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    return null;
+  }
+  return config.sharedSkills?.[sharedSkillFullName] ?? null;
+}
+async function isSharedSkillInstalled(cwd, sharedSkillFullName) {
+  const state = await getSharedSkillState(cwd, sharedSkillFullName);
+  return state !== null;
+}
+
+// src/utils/logger.ts
+import kleur2 from "kleur";
+import ora from "ora";
+var logger = {
+  info: (msg) => {
+    console.log(kleur2.blue("\u2139"), msg);
+  },
+  success: (msg) => {
+    console.log(kleur2.green("\u2713"), msg);
+  },
+  warn: (msg) => {
+    console.log(kleur2.yellow("\u26A0"), msg);
+  },
+  error: (msg) => {
+    console.log(kleur2.red("\u2716"), msg);
+  },
+  log: (msg) => {
+    console.log(msg);
+  },
+  break: () => {
+    console.log();
+  },
+  dim: (msg) => {
+    console.log(kleur2.dim(msg));
+  },
+  bold: (msg) => {
+    console.log(kleur2.bold(msg));
+  },
+  highlight: (msg) => {
+    return kleur2.cyan(msg);
+  },
+  table: (rows) => {
+    for (const row of rows) {
+      console.log("  " + row.join("  "));
+    }
+  },
+  // Format functions (return string without printing)
+  formatSuccess: (msg) => {
+    return kleur2.green(msg);
+  },
+  formatError: (msg) => {
+    return kleur2.red(msg);
+  },
+  formatDim: (msg) => {
+    return kleur2.dim(msg);
+  }
+};
+function spinner(text) {
+  return ora({
+    text,
+    spinner: "dots"
+  });
+}
+
+// src/commands/init.ts
+var initOptionsSchema = z2.object({
+  cwd: z2.string(),
+  defaultPlatform: platformSchema.optional(),
+  force: z2.boolean()
+});
+async function runInit(options) {
+  const { cwd, defaultPlatform, force } = options;
+  if (await configExists(cwd)) {
+    if (!force) {
+      const { overwrite } = await prompts({
+        type: "confirm",
+        name: "overwrite",
+        message: "aico.json already exists. Overwrite?",
+        initial: false
+      });
+      if (!overwrite) {
+        logger.info("Initialization cancelled.");
+        return;
+      }
+    }
+  }
+  const platform = defaultPlatform ?? "claude-code";
+  const config = createDefaultConfig(platform);
+  const s = spinner("Creating aico.json...").start();
+  await writeConfig(cwd, config);
+  s.succeed("Created aico.json");
+  logger.break();
+  logger.success("Project initialized!");
+  logger.dim(`Default platform: ${platform}`);
+  logger.break();
+  logger.info("Next steps:");
+  logger.log(`  ${logger.highlight("npx aico add pm")}  Add the PM employee`);
+  logger.log(
+    `  ${logger.highlight("npx aico list")}   View available employees`
+  );
+}
+var init = new Command().name("init").description("Initialize aico in your project").option(
+  "-p, --default-platform <platform>",
+  "Default platform (claude-code, codex)"
+).option("-f, --force", "Overwrite existing configuration", false).option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (opts) => {
+  try {
+    const options = initOptionsSchema.parse({
+      cwd: opts.cwd,
+      defaultPlatform: opts.defaultPlatform,
+      force: opts.force
+    });
+    await runInit(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/add.ts
+import { Command as Command2 } from "commander";
+import prompts3 from "prompts";
+import { z as z6 } from "zod";
+
+// src/registry/client.ts
+import path3 from "path";
+
+// src/schema/employee.ts
+import { z as z4 } from "zod";
+
+// src/schema/skill.ts
+import YAML from "js-yaml";
+import { z as z3 } from "zod";
+var skillFrontmatterSchema = z3.object({
+  name: z3.string().regex(/^[a-z0-9-]+$/, "Skill name must be hyphen-case"),
+  description: z3.string(),
+  version: z3.string().optional(),
+  category: z3.enum(["pm", "frontend", "backend", "devops", "general"]).optional(),
+  tags: z3.array(z3.string()).optional(),
+  dependencies: z3.array(z3.string()).optional(),
+  mcpDependencies: z3.array(
+    z3.object({
+      name: z3.string(),
+      package: z3.string(),
+      description: z3.string(),
+      docsUrl: z3.string().url()
+    })
+  ).optional()
+});
+var skillFileTypeSchema = z3.enum([
+  "skill",
+  "reference",
+  "asset",
+  "script"
+]);
+var skillFileSchema = z3.object({
+  path: z3.string().min(1),
+  type: skillFileTypeSchema,
+  content: z3.string()
+});
+var skillCategorySchema = z3.enum([
+  "pm",
+  "frontend",
+  "backend",
+  "devops",
+  "general"
+]);
+var skillSchema = z3.object({
+  name: z3.string().regex(/^[a-z0-9-]+$/, "Skill name must be hyphen-case"),
+  namespace: z3.string().regex(
+    /^@[a-z0-9-]+\/[a-z0-9_-]+$/,
+    "Namespace must be @registry/employee format"
+  ),
+  fullName: z3.string().regex(
+    /^@[a-z0-9-]+\/[a-z0-9_-]+\/[a-z0-9-]+$/,
+    "Full name must be @registry/employee/skill format"
+  ),
+  version: z3.string().regex(/^\d+\.\d+\.\d+$/, "Version must be semver format"),
+  description: z3.string(),
+  category: skillCategorySchema,
+  tags: z3.array(z3.string()).default([]),
+  dependencies: z3.array(z3.string()).default([]),
+  mcpDependencies: z3.array(
+    z3.object({
+      name: z3.string(),
+      package: z3.string(),
+      description: z3.string(),
+      docsUrl: z3.string()
+    })
+  ).optional(),
+  files: z3.array(skillFileSchema)
+});
+var skillSummarySchema = z3.object({
+  name: z3.string(),
+  namespace: z3.string(),
+  fullName: z3.string(),
+  version: z3.string(),
+  description: z3.string(),
+  category: z3.string(),
+  tags: z3.array(z3.string())
+});
+var mcpDependencySchema = z3.object({
+  name: z3.string(),
+  package: z3.string(),
+  description: z3.string(),
+  docsUrl: z3.string().url()
+});
+function removeBOM(content) {
+  if (content.charCodeAt(0) === 65279) {
+    return content.slice(1);
+  }
+  return content;
+}
+function parseSkillFrontmatter(content) {
+  content = removeBOM(content);
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    return null;
+  }
+  const yamlContent = match[1] ?? "";
+  let data;
+  try {
+    data = YAML.load(yamlContent);
+  } catch (error) {
+    const yamlError = error;
+    logger.error(`Invalid YAML syntax: ${yamlError.message}`);
+    return null;
+  }
+  const result = skillFrontmatterSchema.safeParse(data);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+    logger.error(`Invalid frontmatter: ${issues}`);
+    return null;
+  }
+  return result.data;
+}
+
+// src/schema/employee.ts
+var fileTypeSchema = z4.enum(["skill", "command", "doc"]);
+var employeeFileSourceSchema = z4.object({
+  path: z4.string().min(1),
+  type: fileTypeSchema
+});
+var employeeFileSchema = employeeFileSourceSchema.extend({
+  content: z4.string().min(1)
+});
+var skillDefSourceSchema = z4.object({
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Skill name must be hyphen-case"),
+  files: z4.array(employeeFileSourceSchema).min(1)
+});
+var commandDefSourceSchema = z4.object({
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Command name must be hyphen-case"),
+  files: z4.array(employeeFileSourceSchema).min(1)
+});
+var docDefSourceSchema = z4.object({
+  name: z4.string(),
+  files: z4.array(employeeFileSourceSchema).min(1)
+});
+var employeeSourceSchema = z4.object({
+  $schema: z4.string().optional(),
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Employee name must be hyphen-case"),
+  role: z4.string().min(1),
+  description: z4.string().optional(),
+  skills: z4.array(skillDefSourceSchema).default([]),
+  commands: z4.array(commandDefSourceSchema).default([]),
+  docs: z4.array(docDefSourceSchema).default([]),
+  dependencies: z4.array(z4.string()).default([])
+});
+var skillDefSchema = z4.object({
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Skill name must be hyphen-case"),
+  files: z4.array(employeeFileSchema).min(1)
+});
+var commandDefSchema = z4.object({
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Command name must be hyphen-case"),
+  files: z4.array(employeeFileSchema).min(1)
+});
+var docDefSchema = z4.object({
+  name: z4.string(),
+  files: z4.array(employeeFileSchema).min(1)
+});
+var employeeSchema = z4.object({
+  $schema: z4.string().optional(),
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Employee name must be hyphen-case"),
+  role: z4.string().min(1),
+  description: z4.string().optional(),
+  skills: z4.array(skillDefSchema).default([]),
+  commands: z4.array(commandDefSchema).default([]),
+  docs: z4.array(docDefSchema).default([]),
+  dependencies: z4.array(z4.string()).default([])
+});
+var employeeSummarySchema = z4.object({
+  name: z4.string(),
+  namespace: z4.string().optional(),
+  fullName: z4.string().optional(),
+  role: z4.string(),
+  description: z4.string().optional(),
+  version: z4.string().optional(),
+  skillCount: z4.number().optional(),
+  commandCount: z4.number().optional(),
+  category: skillCategorySchema.optional()
+});
+var employeeExtendedSchema = z4.object({
+  $schema: z4.string().optional(),
+  name: z4.string().regex(/^[a-z0-9-]+$/, "Employee name must be hyphen-case"),
+  namespace: z4.string().regex(/^@[a-z0-9-]+$/, "Namespace must be @registry format"),
+  fullName: z4.string().regex(
+    /^@[a-z0-9-]+\/[a-z0-9-]+$/,
+    "Full name must be @registry/employee format"
+  ),
+  role: z4.string().min(1),
+  description: z4.string().optional(),
+  version: z4.string().regex(/^\d+\.\d+\.\d+$/, "Version must be semver format"),
+  category: skillCategorySchema,
+  skills: z4.array(z4.string()),
+  // Array of skill fullNames: ["@the-aico/pm/brainstorming", ...]
+  commands: z4.array(commandDefSchema).default([]),
+  docs: z4.array(docDefSchema).default([])
+});
+var registryIndexSchema = z4.object({
+  employees: z4.array(employeeSummarySchema)
+});
+
+// src/schema/registry.ts
+import { z as z5 } from "zod";
+var skillsIndexSchema = z5.array(skillSummarySchema);
+var employeesIndexSchema = z5.array(employeeSummarySchema);
+var registryIndexV2Schema = z5.object({
+  version: z5.literal("2.0").default("2.0"),
+  skills: skillsIndexSchema,
+  employees: employeesIndexSchema
+});
+
+// src/registry/local.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+async function loadLocalEmployee(registryDir, employeeName) {
+  const employeePath = path2.join(registryDir, `${employeeName}.json`);
+  if (!await fs2.pathExists(employeePath)) {
+    return null;
+  }
+  const raw = await fs2.readJson(employeePath);
+  return employeeSchema.parse(raw);
+}
+async function loadLocalIndex(registryDir) {
+  const indexPath = path2.join(registryDir, "index.json");
+  if (!await fs2.pathExists(indexPath)) {
+    return null;
+  }
+  const raw = await fs2.readJson(indexPath);
+  return registryIndexSchema.parse(raw);
+}
+async function loadLocalSkill(registryDir, skillFullName) {
+  const parts = skillFullName.replace("@", "").split("/");
+  if (parts.length !== 3) {
+    return null;
+  }
+  const [registry, employee, skill] = parts;
+  const skillPath = path2.join(registryDir, "skills", registry, employee, `${skill}.json`);
+  if (!await fs2.pathExists(skillPath)) {
+    return null;
+  }
+  const raw = await fs2.readJson(skillPath);
+  return skillSchema.parse(raw);
+}
+
+// src/utils/parse-target.ts
+function parseTarget(input, defaultRegistry = "@the-aico") {
+  const trimmed = input.trim();
+  if (trimmed.startsWith("@")) {
+    const parts = trimmed.split("/");
+    if (parts.length === 2) {
+      const [registry, name] = parts;
+      return {
+        type: "employee",
+        registry,
+        namespace: registry,
+        name,
+        fullName: trimmed
+      };
+    } else if (parts.length === 3) {
+      const [registry, employee, skill] = parts;
+      return {
+        type: "skill",
+        registry,
+        namespace: `${registry}/${employee}`,
+        name: skill,
+        fullName: trimmed
+      };
+    }
+  }
+  return {
+    type: "employee",
+    registry: defaultRegistry,
+    namespace: defaultRegistry,
+    name: trimmed,
+    fullName: `${defaultRegistry}/${trimmed}`
+  };
+}
+function parseSkillFullName(fullName) {
+  const match = fullName.match(/^(@[a-z0-9-]+)\/([a-z0-9_-]+)\/([a-z0-9-]+)$/);
+  if (!match || !match[1] || !match[2] || !match[3]) {
+    return null;
+  }
+  return {
+    registry: match[1],
+    employee: match[2],
+    skill: match[3]
+  };
+}
+
+// src/registry/client.ts
+function resolveRegistryUrl(config, employeeName) {
+  if (typeof config === "string") {
+    return config.replace("{name}", employeeName);
+  }
+  return config.url.replace("{name}", employeeName);
+}
+function getRegistryHeaders(config) {
+  if (typeof config === "object" && config.headers) {
+    return config.headers;
+  }
+  return {};
+}
+function parseEmployeeRef(ref) {
+  if (ref.startsWith("@")) {
+    const parts = ref.split("/");
+    if (parts.length === 2 && parts[0] && parts[1]) {
+      return { registry: parts[0], name: parts[1] };
+    }
+  }
+  return { registry: "@the-aico", name: ref };
+}
+async function fetchEmployee(employeeRef, config, cwd) {
+  const { registry, name } = parseEmployeeRef(employeeRef);
+  const registryConfig = config.registries[registry];
+  if (!registryConfig) {
+    throw new Error(`Registry '${registry}' not found in config`);
+  }
+  const url = resolveRegistryUrl(registryConfig, name);
+  if (url.startsWith("file://")) {
+    const localPath = url.replace("file://", "");
+    const resolvedPath = path3.isAbsolute(localPath) ? localPath : path3.resolve(cwd, localPath);
+    const registryDir = path3.dirname(resolvedPath);
+    const employee = await loadLocalEmployee(registryDir, name);
+    if (!employee) {
+      throw employeeNotFoundError(employeeRef);
+    }
+    return employee;
+  }
+  const headers = getRegistryHeaders(registryConfig);
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw employeeNotFoundError(employeeRef);
+    }
+    throw registryFetchError(url, response.status);
+  }
+  const json = await response.json();
+  return employeeSchema.parse(json);
+}
+async function fetchRegistryIndex(config, cwd, registryName = "@the-aico") {
+  const registryConfig = config.registries[registryName];
+  if (!registryConfig) {
+    throw new Error(`Registry '${registryName}' not found in config`);
+  }
+  const url = resolveRegistryUrl(registryConfig, "index");
+  if (url.startsWith("file://")) {
+    const localPath = url.replace("file://", "").replace("/index.json", "");
+    const resolvedPath = path3.isAbsolute(localPath) ? localPath : path3.resolve(cwd, localPath);
+    const index = await loadLocalIndex(resolvedPath);
+    if (!index) {
+      return { employees: [] };
+    }
+    return index;
+  }
+  const headers = getRegistryHeaders(registryConfig);
+  const response = await fetch(url.replace("{name}.json", "index.json"), { headers });
+  if (!response.ok) {
+    if (response.status === 404) {
+      return { employees: [] };
+    }
+    throw registryFetchError(url, response.status);
+  }
+  const json = await response.json();
+  return registryIndexSchema.parse(json);
+}
+function buildSkillUrl(registryConfig, fullName) {
+  const parsed = parseSkillFullName(fullName);
+  if (!parsed) {
+    throw new Error(`Invalid skill full name: ${fullName}`);
+  }
+  const baseUrl = typeof registryConfig === "string" ? registryConfig.replace("{name}.json", "") : registryConfig.url.replace("{name}.json", "");
+  return `${baseUrl}skills/${parsed.registry.replace("@", "")}/${parsed.employee}/${parsed.skill}.json`;
+}
+async function fetchSkill(fullName, config, cwd) {
+  const parsed = parseSkillFullName(fullName);
+  if (!parsed) {
+    throw new Error(`Invalid skill full name: ${fullName}`);
+  }
+  const registryConfig = config.registries[parsed.registry];
+  if (!registryConfig) {
+    throw new Error(`Registry '${parsed.registry}' not found in config`);
+  }
+  const url = buildSkillUrl(registryConfig, fullName);
+  if (url.startsWith("file://")) {
+    const localPath = url.replace("file://", "");
+    const registryDir = path3.resolve(cwd, localPath.split("/skills/")[0] ?? "");
+    const skill = await loadLocalSkill(registryDir, fullName);
+    if (!skill) {
+      throw skillNotFoundError(fullName);
+    }
+    return skill;
+  }
+  const headers = getRegistryHeaders(registryConfig);
+  const response = await fetch(url, { headers });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw skillNotFoundError(fullName);
+    }
+    throw registryFetchError(url, response.status);
+  }
+  const json = await response.json();
+  return skillSchema.parse(json);
+}
+
+// src/installer/index.ts
+import fs3 from "fs-extra";
+import path4 from "path";
+import prompts2 from "prompts";
+
+// src/installer/platforms/claude-code.ts
+var claudeCodeAdapter = {
+  name: "claude-code",
+  getSkillDirName(employeeName, skillName) {
+    return `aico-${employeeName}-${skillName}`;
+  },
+  getCommandFileName(employeeName, commandName) {
+    return `${employeeName}.${commandName}.md`;
+  }
+};
+
+// src/installer/platforms/codex.ts
+var codexAdapter = {
+  name: "codex",
+  /**
+   * Codex skill directory name
+   * Uses the same naming convention as Claude Code: aico-{employee}-{skill}
+   */
+  getSkillDirName(employeeName, skillName) {
+    return `aico-${employeeName}-${skillName}`;
+  },
+  /**
+   * Codex command file name (Custom Prompts)
+   *
+   * Codex custom prompts are located in .codex/prompts/ directory
+   * The file name (without .md) becomes the command name
+   *
+   * Naming convention: aico.{employee}.{command}.md
+   * Invocation: /prompts:aico.{employee}.{command}
+   *
+   * Example:
+   * - File: .codex/prompts/aico.pm.plan.md
+   * - Invocation: /prompts:aico.pm.plan
+   */
+  getCommandFileName(employeeName, commandName) {
+    return `aico.${employeeName}.${commandName}.md`;
+  }
+};
+
+// src/installer/index.ts
+var adapters = {
+  "claude-code": claudeCodeAdapter,
+  codex: codexAdapter
+};
+async function checkConflicts(employee, config, cwd, platforms) {
+  const conflicts = [];
+  for (const platform of platforms) {
+    const adapter = adapters[platform];
+    const { skillsDir, commandsDir } = resolvePlatformPaths(
+      cwd,
+      config,
+      platform
+    );
+    for (const skill of employee.skills) {
+      const skillDirName = adapter.getSkillDirName(employee.name, skill.name);
+      const skillPath = path4.join(skillsDir, skillDirName);
+      if (await fs3.pathExists(skillPath)) {
+        conflicts.push({ path: skillPath, type: "skill" });
+      }
+    }
+    for (const command of employee.commands) {
+      const commandFileName = adapter.getCommandFileName(
+        employee.name,
+        command.name
+      );
+      const commandPath = path4.join(commandsDir, commandFileName);
+      if (await fs3.pathExists(commandPath)) {
+        conflicts.push({ path: commandPath, type: "command" });
+      }
+    }
+  }
+  return conflicts;
+}
+async function confirmOverwrite(conflicts) {
+  const { proceed } = await prompts2({
+    type: "confirm",
+    name: "proceed",
+    message: `${conflicts.length} file(s) will be overwritten. Continue?`,
+    initial: false
+  });
+  return proceed;
+}
+async function installEmployee(employee, config, cwd, platforms, options) {
+  const results = [];
+  for (const platform of platforms) {
+    const result = await installEmployeeToPlatform(
+      employee,
+      config,
+      cwd,
+      platform,
+      options
+    );
+    results.push(result);
+  }
+  return results;
+}
+async function installEmployeeToPlatform(employee, config, cwd, platform, _options) {
+  const adapter = adapters[platform];
+  const { skillsDir, commandsDir } = resolvePlatformPaths(
+    cwd,
+    config,
+    platform
+  );
+  await fs3.ensureDir(skillsDir);
+  await fs3.ensureDir(commandsDir);
+  let skillsInstalled = 0;
+  let commandsInstalled = 0;
+  for (const skill of employee.skills) {
+    const skillDirName = adapter.getSkillDirName(employee.name, skill.name);
+    const skillDir = path4.join(skillsDir, skillDirName);
+    await fs3.ensureDir(skillDir);
+    for (const file of skill.files) {
+      const filePath = path4.join(skillDir, path4.basename(file.path));
+      let content = file.content;
+      if (file.path.endsWith("SKILL.md")) {
+        content = updateSkillName(content, skillDirName);
+      }
+      await fs3.writeFile(filePath, content, "utf-8");
+    }
+    skillsInstalled++;
+  }
+  for (const command of employee.commands) {
+    const commandFileName = adapter.getCommandFileName(
+      employee.name,
+      command.name
+    );
+    for (const file of command.files) {
+      const filePath = path4.join(commandsDir, commandFileName);
+      await fs3.writeFile(filePath, file.content, "utf-8");
+    }
+    commandsInstalled++;
+  }
+  return {
+    platform,
+    skillsInstalled,
+    commandsInstalled
+  };
+}
+function updateSkillName(content, newName) {
+  return content.replace(/^(---\n[\s\S]*?name:\s*).+$/m, `$1${newName}`);
+}
+async function uninstallEmployee(employeeName, config, cwd, platforms) {
+  for (const platform of platforms) {
+    const { skillsDir, commandsDir } = resolvePlatformPaths(
+      cwd,
+      config,
+      platform
+    );
+    const skillPrefix = `aico-${employeeName}-`;
+    if (await fs3.pathExists(skillsDir)) {
+      const entries = await fs3.readdir(skillsDir);
+      for (const entry of entries) {
+        if (entry.startsWith(skillPrefix)) {
+          await fs3.remove(path4.join(skillsDir, entry));
+        }
+      }
+    }
+    if (await fs3.pathExists(commandsDir)) {
+      const entries = await fs3.readdir(commandsDir);
+      const commandPrefix = platform === "codex" ? `aico.${employeeName}.` : `${employeeName}.`;
+      for (const entry of entries) {
+        if (entry.startsWith(commandPrefix) && entry.endsWith(".md")) {
+          await fs3.remove(path4.join(commandsDir, entry));
+        }
+      }
+    }
+  }
+}
+
+// src/installer/skill-installer.ts
+import fs4 from "fs-extra";
+import path5 from "path";
+function getSkillDirName(fullNameOrName) {
+  if (fullNameOrName.startsWith("@")) {
+    if (fullNameOrName.includes("/_shared/")) {
+      const skillName = fullNameOrName.split("/").pop() || "";
+      return `aico-${skillName}`;
+    }
+    const normalized = fullNameOrName.replace(/^@/, "").replace(/\//g, "-");
+    return normalized;
+  }
+  return fullNameOrName;
+}
+async function installSkill(skill, config, cwd, options) {
+  const { skillsDir } = resolvePlatformPaths(cwd, config, options.platform);
+  const skillDirName = getSkillDirName(skill.fullName);
+  const skillDir = path5.join(skillsDir, skillDirName);
+  if (await fs4.pathExists(skillDir)) {
+    if (!options.overwrite) {
+      return {
+        skill,
+        installed: false,
+        skipped: true,
+        reason: "Already exists",
+        path: skillDir
+      };
+    }
+    await fs4.remove(skillDir);
+  }
+  await fs4.ensureDir(skillDir);
+  for (const file of skill.files) {
+    const filePath = path5.join(skillDir, file.path);
+    let content = file.content;
+    if (file.path === "SKILL.md" || file.path.endsWith("/SKILL.md")) {
+      content = updateSkillFrontmatterName(content, skillDirName);
+    }
+    await fs4.writeFile(filePath, content, "utf-8");
+  }
+  return {
+    skill,
+    installed: true,
+    skipped: false,
+    path: skillDir
+  };
+}
+function updateSkillFrontmatterName(content, newName) {
+  return content.replace(/^(---\n[\s\S]*?name:\s*).+$/m, `$1${newName}`);
+}
+async function uninstallSkill(skillFullName, config, cwd, options) {
+  const { skillsDir } = resolvePlatformPaths(cwd, config, options.platform);
+  const skillDirName = getSkillDirName(skillFullName);
+  const skillDir = path5.join(skillsDir, skillDirName);
+  if (!await fs4.pathExists(skillDir)) {
+    return {
+      skillName: skillFullName,
+      removed: false,
+      files: []
+    };
+  }
+  const files = [];
+  const entries = await fs4.readdir(skillDir);
+  for (const entry of entries) {
+    files.push(path5.join(skillDir, entry));
+  }
+  if (options.dryRun) {
+    return {
+      skillName: skillFullName,
+      removed: false,
+      files
+    };
+  }
+  await fs4.remove(skillDir);
+  return {
+    skillName: skillFullName,
+    removed: true,
+    files
+  };
+}
+
+// src/registry/resolver.ts
+var DependencyResolver = class {
+  constructor(fetchSkill2) {
+    this.fetchSkill = fetchSkill2;
+  }
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Resolve all dependencies for given skills
+   * Returns skills in topological order (dependencies first)
+   */
+  async resolve(skillNames) {
+    const allSkills = [];
+    const visited = /* @__PURE__ */ new Set();
+    for (const name of skillNames) {
+      const skills = await this.fetchWithDependencies(name, visited);
+      allSkills.push(...skills);
+    }
+    const uniqueSkills = this.deduplicateSkills(allSkills);
+    const sortedSkills = this.topologicalSort(uniqueSkills);
+    const skillMap = new Map(uniqueSkills.map((s) => [s.fullName, s]));
+    const trees = skillNames.map((name) => ({
+      root: name,
+      dependencies: [this.buildDependencyTree(name, skillMap)]
+    }));
+    return {
+      skills: sortedSkills,
+      tree: trees[0]
+    };
+  }
+  /**
+   * Recursively fetch a skill and all its dependencies
+   */
+  async fetchWithDependencies(skillName, visited = /* @__PURE__ */ new Set(), path9 = []) {
+    if (path9.includes(skillName)) {
+      const cycle = [...path9, skillName].join(" \u2192 ");
+      throw new AicoError(
+        `Circular dependency detected: ${cycle}`,
+        "CIRCULAR_DEPENDENCY",
+        { suggestion: "Check skill dependencies for cycles." }
+      );
+    }
+    if (visited.has(skillName)) {
+      return [];
+    }
+    visited.add(skillName);
+    let skill = this.cache.get(skillName);
+    if (!skill) {
+      skill = await this.fetchSkill(skillName);
+      this.cache.set(skillName, skill);
+    }
+    const allSkills = [];
+    for (const dep of skill.dependencies) {
+      const depSkills = await this.fetchWithDependencies(
+        dep,
+        visited,
+        [...path9, skillName]
+      );
+      allSkills.push(...depSkills);
+    }
+    allSkills.push(skill);
+    return allSkills;
+  }
+  /**
+   * Remove duplicate skills (keep first occurrence)
+   */
+  deduplicateSkills(skills) {
+    const seen = /* @__PURE__ */ new Map();
+    for (const skill of skills) {
+      if (!seen.has(skill.fullName)) {
+        seen.set(skill.fullName, skill);
+      }
+    }
+    return Array.from(seen.values());
+  }
+  /**
+   * Topological sort using Kahn's algorithm
+   * Returns skills in dependency order (install dependencies first)
+   */
+  topologicalSort(skills) {
+    const inDegree = /* @__PURE__ */ new Map();
+    const graph = /* @__PURE__ */ new Map();
+    const skillMap = /* @__PURE__ */ new Map();
+    for (const skill of skills) {
+      skillMap.set(skill.fullName, skill);
+      if (!inDegree.has(skill.fullName)) {
+        inDegree.set(skill.fullName, 0);
+      }
+      if (!graph.has(skill.fullName)) {
+        graph.set(skill.fullName, []);
+      }
+    }
+    for (const skill of skills) {
+      for (const dep of skill.dependencies) {
+        if (skillMap.has(dep)) {
+          const edges = graph.get(dep) ?? [];
+          edges.push(skill.fullName);
+          graph.set(dep, edges);
+          inDegree.set(skill.fullName, (inDegree.get(skill.fullName) ?? 0) + 1);
+        }
+      }
+    }
+    const queue = [];
+    for (const [name, degree] of inDegree.entries()) {
+      if (degree === 0) {
+        queue.push(name);
+      }
+    }
+    const result = [];
+    while (queue.length > 0) {
+      const node = queue.shift();
+      const skill = skillMap.get(node);
+      if (skill) {
+        result.push(skill);
+      }
+      for (const neighbor of graph.get(node) ?? []) {
+        const newDegree = (inDegree.get(neighbor) ?? 1) - 1;
+        inDegree.set(neighbor, newDegree);
+        if (newDegree === 0) {
+          queue.push(neighbor);
+        }
+      }
+    }
+    if (result.length !== skills.length) {
+      throw new AicoError(
+        "Circular dependency detected in skill graph",
+        "CIRCULAR_DEPENDENCY",
+        { suggestion: "Check skill dependencies for cycles." }
+      );
+    }
+    return result;
+  }
+  /**
+   * Build dependency tree for display
+   */
+  buildDependencyTree(skillName, skillMap, depth = 0, visited = /* @__PURE__ */ new Set()) {
+    const skill = skillMap.get(skillName);
+    if (!skill) {
+      return {
+        fullName: skillName,
+        version: "unknown",
+        children: [],
+        depth
+      };
+    }
+    if (visited.has(skillName)) {
+      return {
+        fullName: skillName + " (circular)",
+        version: skill.version,
+        children: [],
+        depth
+      };
+    }
+    visited.add(skillName);
+    const children = skill.dependencies.filter((dep) => skillMap.has(dep)).map((dep) => this.buildDependencyTree(dep, skillMap, depth + 1, new Set(visited)));
+    return {
+      fullName: skillName,
+      version: skill.version,
+      children,
+      depth
+    };
+  }
+};
+function formatDependencyTree(node, prefix = "") {
+  const lines = [];
+  lines.push(`${node.fullName} (${node.version})`);
+  node.children.forEach((child, index) => {
+    const isLast = index === node.children.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const extension = isLast ? "    " : "\u2502   ";
+    lines.push(`${prefix}${connector}${child.fullName} (${child.version})`);
+    if (child.children.length > 0) {
+      const childLines = formatDependencyTreeRecursive(child.children, prefix + extension);
+      lines.push(...childLines);
+    }
+  });
+  return lines.join("\n");
+}
+function formatDependencyTreeRecursive(nodes, prefix) {
+  const lines = [];
+  nodes.forEach((node, index) => {
+    const isLast = index === nodes.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const extension = isLast ? "    " : "\u2502   ";
+    lines.push(`${prefix}${connector}${node.fullName} (${node.version})`);
+    if (node.children.length > 0) {
+      lines.push(...formatDependencyTreeRecursive(node.children, prefix + extension));
+    }
+  });
+  return lines;
+}
+
+// src/utils/constraint-docs.ts
+import fs5 from "fs-extra";
+import path6 from "path";
+var CONSTRAINT_DOCS = {
+  pm: ["docs/reference/pm/constitution.md"],
+  frontend: ["docs/reference/frontend/constraints.md"],
+  backend: ["docs/reference/backend/constraints.md"]
+};
+async function checkConstraintDocs(employeeName, cwd) {
+  const docs = CONSTRAINT_DOCS[employeeName] || [];
+  const existing = [];
+  const missing = [];
+  for (const doc of docs) {
+    const fullPath = path6.join(cwd, doc);
+    if (await fs5.pathExists(fullPath)) {
+      existing.push(doc);
+    } else {
+      missing.push(doc);
+    }
+  }
+  return { existing, missing };
+}
+function showConstraintDocHints(employeeName, existing, missing) {
+  if (missing.length === 0 && existing.length === 0) {
+    return;
+  }
+  const initCommand = `/${employeeName}.init`;
+  if (missing.length > 0) {
+    logger.break();
+    logger.info(`\u{1F4A1} Tip: Run ${initCommand} to create constraint documents:`);
+    for (const doc of missing) {
+      logger.dim(`   - ${doc}`);
+    }
+  }
+  if (existing.length > 0) {
+    logger.break();
+    logger.info("\u{1F4C4} Existing constraint documents:");
+    for (const doc of existing) {
+      logger.dim(`   - ${doc}`);
+    }
+    logger.dim(`   Run ${initCommand} to update these if needed.`);
+  }
+}
+
+// src/commands/add.ts
+var collectedMCPDeps = /* @__PURE__ */ new Map();
+var constraintDocInfo = /* @__PURE__ */ new Map();
+var addOptionsSchema = z6.object({
+  items: z6.array(z6.string()),
+  cwd: z6.string(),
+  platforms: z6.array(platformSchema).optional(),
+  overwrite: z6.boolean(),
+  yes: z6.boolean(),
+  noDeps: z6.boolean()
+});
+async function selectEmployeesInteractively(cwd) {
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw notInitializedError();
+  }
+  const s = spinner("Fetching available employees...").start();
+  try {
+    const index = await fetchRegistryIndex(config, cwd);
+    s.stop();
+    if (index.employees.length === 0) {
+      logger.warn("No employees available in registry.");
+      return [];
+    }
+    const installedNames = new Set(Object.keys(config.employees));
+    const choices = index.employees.map((emp) => ({
+      title: installedNames.has(emp.name) ? `${emp.name} (${emp.role}) [installed]` : `${emp.name} (${emp.role})`,
+      value: emp.name,
+      description: emp.description,
+      disabled: false
+    }));
+    logger.break();
+    logger.info("Available employees:");
+    logger.break();
+    const { selected } = await prompts3({
+      type: "multiselect",
+      name: "selected",
+      message: "Select employees to add",
+      choices,
+      hint: "- Space to select, Enter to confirm",
+      instructions: false
+    });
+    return selected ?? [];
+  } catch (error) {
+    s.fail("Failed to fetch employee list");
+    throw error;
+  }
+}
+async function runAdd(options) {
+  const { items, cwd, overwrite, yes } = options;
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw notInitializedError();
+  }
+  let platforms;
+  if (options.platforms && options.platforms.length > 0) {
+    platforms = options.platforms;
+  } else {
+    platforms = [config.defaultPlatform];
+  }
+  for (const platform of platforms) {
+    if (!config.platforms[platform]) {
+      throw platformNotSupportedError(platform);
+    }
+  }
+  const targets = items.map((item) => parseTarget(item));
+  const employees = targets.filter((t) => t.type === "employee");
+  const skills = targets.filter((t) => t.type === "skill");
+  for (const target of employees) {
+    await addEmployee(target, config, cwd, platforms, overwrite, yes);
+  }
+  if (skills.length > 0) {
+    await addSkillsWithDeps(
+      skills,
+      config,
+      cwd,
+      platforms,
+      overwrite,
+      options.yes,
+      options.noDeps
+    );
+  }
+  logger.break();
+  logger.success("Installation complete!");
+  logger.dim(`Installed to: ${platforms.join(", ")}`);
+  showMCPDependencyHints();
+  showConstraintDocumentHints();
+}
+async function addEmployee(target, config, cwd, platforms, overwrite, yes) {
+  if (!config) return;
+  const s = spinner(`Adding ${target.name}...`).start();
+  try {
+    const employee = await fetchEmployee(target.fullName, config, cwd);
+    s.text = `Installing ${employee.name} (${employee.role})...`;
+    const conflicts = await checkConflicts(employee, config, cwd, platforms);
+    let shouldOverwrite = overwrite;
+    if (conflicts.length > 0 && !overwrite) {
+      s.stop();
+      if (!yes) {
+        logger.warn(`Found ${conflicts.length} existing file(s):`);
+        for (const conflict of conflicts.slice(0, 5)) {
+          logger.dim(`  - ${conflict.path}`);
+        }
+        if (conflicts.length > 5) {
+          logger.dim(`  ... and ${conflicts.length - 5} more`);
+        }
+        const confirmed = await confirmOverwrite(conflicts);
+        if (!confirmed) {
+          logger.info(`Skipped ${target.name}`);
+          return;
+        }
+        shouldOverwrite = true;
+      }
+      s.start();
+    }
+    const isUpdate = config.employees[employee.name] !== void 0;
+    if (shouldOverwrite && isUpdate) {
+      await uninstallEmployee(employee.name, config, cwd, platforms);
+    }
+    await installEmployee(employee, config, cwd, platforms, {
+      overwrite: shouldOverwrite
+    });
+    const installedSharedSkills = [];
+    if (employee.dependencies && employee.dependencies.length > 0) {
+      s.text = `Installing shared skills for ${employee.name}...`;
+      for (const depFullName of employee.dependencies) {
+        const alreadyInstalled = await isSharedSkillInstalled(cwd, depFullName);
+        if (!alreadyInstalled) {
+          try {
+            const sharedSkill = await fetchSkill(depFullName, config, cwd);
+            for (const platform of platforms) {
+              await installSkill(sharedSkill, config, cwd, {
+                platform,
+                overwrite: shouldOverwrite
+              });
+            }
+            installedSharedSkills.push(depFullName);
+          } catch (err) {
+            s.warn(`Failed to install shared skill ${depFullName}`);
+            logger.dim(
+              `  Error: ${err instanceof Error ? err.message : String(err)}`
+            );
+            continue;
+          }
+        }
+        await addSharedSkillReference(
+          cwd,
+          depFullName,
+          employee.name,
+          "1.0.0",
+          // TODO: get version from skill
+          platforms
+        );
+      }
+    }
+    const skillNames = employee.skills.map((sk) => sk.name);
+    const commandNames = employee.commands.map((c) => c.name);
+    await updateEmployees(
+      cwd,
+      employee.name,
+      platforms,
+      skillNames,
+      commandNames
+    );
+    s.succeed(`Added ${employee.name} (${employee.role})`);
+    logger.dim(`  Skills: ${employee.skills.map((sk) => sk.name).join(", ")}`);
+    if (employee.commands.length > 0) {
+      logger.dim(
+        `  Commands: ${employee.commands.map((c) => `/${employee.name}.${c.name}`).join(", ")}`
+      );
+    }
+    if (installedSharedSkills.length > 0) {
+      logger.dim(
+        `  Shared skills: ${installedSharedSkills.map((s2) => s2.split("/").pop()).join(", ")}`
+      );
+    } else if (employee.dependencies && employee.dependencies.length > 0) {
+      logger.dim(
+        `  Shared skills: ${employee.dependencies.map((s2) => s2.split("/").pop()).join(", ")} (already installed)`
+      );
+    }
+    for (const skill of employee.skills) {
+      const skillFile = skill.files.find((f) => f.path.endsWith("SKILL.md"));
+      if (skillFile) {
+        const frontmatter = parseSkillFrontmatter(skillFile.content);
+        if (frontmatter?.mcpDependencies) {
+          for (const dep of frontmatter.mcpDependencies) {
+            collectedMCPDeps.set(dep.name, dep);
+          }
+        }
+      }
+    }
+    const constraintInfo = await checkConstraintDocs(employee.name, cwd);
+    constraintDocInfo.set(employee.name, constraintInfo);
+  } catch (error) {
+    s.fail(`Failed to add ${target.name}`);
+    throw error;
+  }
+}
+async function addSkillsWithDeps(targets, config, cwd, platforms, overwrite, yes, noDeps) {
+  if (!config) return;
+  const skillNames = targets.map((t) => t.fullName);
+  if (noDeps) {
+    logger.warn("Skipping dependencies. Some skills may not work correctly.");
+    for (const target of targets) {
+      await addSingleSkill(target.fullName, config, cwd, platforms, overwrite);
+    }
+    return;
+  }
+  const s = spinner("Resolving dependencies...").start();
+  try {
+    const resolver = new DependencyResolver(
+      (name) => fetchSkill(name, config, cwd)
+    );
+    const { skills, tree } = await resolver.resolve(skillNames);
+    s.stop();
+    logger.break();
+    logger.log(formatDependencyTree(tree.dependencies[0]));
+    logger.break();
+    const depCount = skills.length - skillNames.length;
+    if (depCount > 0 && !yes) {
+      const { confirmed } = await prompts3({
+        type: "confirm",
+        name: "confirmed",
+        message: `Install ${skills.length} skill(s) (${depCount} dependencies)?`,
+        initial: true
+      });
+      if (!confirmed) {
+        logger.info("Cancelled.");
+        return;
+      }
+    }
+    for (const skill of skills) {
+      await addSingleSkill(
+        skill.fullName,
+        config,
+        cwd,
+        platforms,
+        overwrite,
+        skill
+      );
+    }
+  } catch (error) {
+    s.fail("Failed to resolve dependencies");
+    throw error;
+  }
+}
+async function addSingleSkill(fullName, config, cwd, platforms, overwrite, prefetchedSkill) {
+  if (!config) return;
+  const s = spinner(`Adding skill ${fullName}...`).start();
+  try {
+    const skill = prefetchedSkill ?? await fetchSkill(fullName, config, cwd);
+    s.text = `Installing ${skill.name}...`;
+    for (const platform of platforms) {
+      const result = await installSkill(skill, config, cwd, {
+        platform,
+        overwrite
+      });
+      if (result.skipped && !overwrite) {
+        s.warn(
+          `Skill ${skill.name} already exists (use --overwrite to replace)`
+        );
+        return;
+      }
+    }
+    await updateSkill(cwd, fullName, skill.version, platforms, "standalone");
+    s.succeed(`Added skill ${skill.fullName}`);
+    logger.dim(`  Version: ${skill.version}`);
+    logger.dim(`  Category: ${skill.category}`);
+    if (skill.mcpDependencies) {
+      for (const dep of skill.mcpDependencies) {
+        collectedMCPDeps.set(dep.name, dep);
+      }
+    }
+  } catch (error) {
+    s.fail(`Failed to add skill ${fullName}`);
+    throw error;
+  }
+}
+function showMCPDependencyHints() {
+  if (collectedMCPDeps.size === 0) {
+    return;
+  }
+  logger.break();
+  logger.warn(`Some skills require MCP servers to be configured:`);
+  logger.break();
+  for (const [name, dep] of collectedMCPDeps) {
+    logger.info(`  ${name}`);
+    logger.dim(`    ${dep.description}`);
+    logger.dim(`    Package: ${dep.package}`);
+    logger.dim(`    Docs: ${dep.docsUrl}`);
+    logger.break();
+  }
+  logger.info(
+    "To configure MCP servers, add them to your claude_desktop_config.json"
+  );
+  logger.dim("See: https://docs.claude.ai/mcp");
+  collectedMCPDeps.clear();
+}
+function showConstraintDocumentHints() {
+  if (constraintDocInfo.size === 0) {
+    return;
+  }
+  for (const [employeeName, info] of constraintDocInfo) {
+    showConstraintDocHints(employeeName, info.existing, info.missing);
+  }
+  constraintDocInfo.clear();
+}
+var add = new Command2().name("add").description("Add employees or skills to your project").argument(
+  "[items...]",
+  "Employee or skill names (e.g., pm, @the-aico/pm/brainstorming)"
+).option(
+  "-p, --platform <platform>",
+  "Target platform (can be used multiple times)",
+  (value, previous) => {
+    const result = platformSchema.safeParse(value);
+    if (!result.success) {
+      throw new Error(
+        `Invalid platform: ${value}. Available: claude-code, codex`
+      );
+    }
+    return [...previous, result.data];
+  },
+  []
+).option("-o, --overwrite", "Overwrite existing files", false).option("-y, --yes", "Skip confirmation prompts", false).option("--no-deps", "Skip dependency installation", false).option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (items, opts) => {
+  try {
+    let selectedItems = items;
+    if (items.length === 0) {
+      selectedItems = await selectEmployeesInteractively(opts.cwd);
+      if (selectedItems.length === 0) {
+        logger.info("No employees selected.");
+        return;
+      }
+    }
+    const options = addOptionsSchema.parse({
+      items: selectedItems,
+      cwd: opts.cwd,
+      platforms: opts.platform.length > 0 ? opts.platform : void 0,
+      overwrite: opts.overwrite,
+      yes: opts.yes,
+      noDeps: opts.noDeps ?? false
+    });
+    await runAdd(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/remove.ts
+import { Command as Command3 } from "commander";
+import prompts4 from "prompts";
+import { z as z7 } from "zod";
+var removeOptionsSchema = z7.object({
+  items: z7.array(z7.string()),
+  cwd: z7.string(),
+  platforms: z7.array(platformSchema).optional(),
+  yes: z7.boolean(),
+  force: z7.boolean(),
+  dryRun: z7.boolean()
+});
+async function runRemove(options) {
+  const { items, cwd, yes, force, dryRun } = options;
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw notInitializedError();
+  }
+  const targets = items.map((item) => parseTarget(item));
+  const employees = targets.filter((t) => t.type === "employee");
+  const skills = targets.filter((t) => t.type === "skill");
+  for (const target of employees) {
+    await removeEmployeeItem(
+      target,
+      config,
+      cwd,
+      options.platforms,
+      yes,
+      dryRun
+    );
+  }
+  for (const target of skills) {
+    await removeSkillItem(
+      target,
+      config,
+      cwd,
+      options.platforms,
+      yes,
+      force,
+      dryRun
+    );
+  }
+  logger.break();
+  if (dryRun) {
+    logger.info("Dry run complete. No files were removed.");
+  } else {
+    logger.success("Removal complete!");
+  }
+}
+async function removeEmployeeItem(target, config, cwd, platformsOpt, yes, dryRun) {
+  if (!config) return;
+  const employeeName = target.name;
+  const installedState = config.employees[employeeName];
+  let platforms;
+  if (installedState) {
+    if (platformsOpt && platformsOpt.length > 0) {
+      platforms = platformsOpt.filter(
+        (p) => installedState.platforms.includes(p)
+      );
+      if (platforms.length === 0) {
+        logger.warn(
+          `Employee '${employeeName}' is not installed on specified platform(s). Skipping.`
+        );
+        return;
+      }
+    } else {
+      platforms = installedState.platforms;
+    }
+  } else {
+    if (platformsOpt && platformsOpt.length > 0) {
+      platforms = platformsOpt;
+    } else {
+      platforms = Object.keys(config.platforms);
+    }
+    logger.dim(
+      `Employee '${employeeName}' not in config, will attempt to remove files from: ${platforms.join(", ")}`
+    );
+  }
+  if (!yes && !dryRun) {
+    const { proceed } = await prompts4({
+      type: "confirm",
+      name: "proceed",
+      message: `Remove ${employeeName} from ${platforms.join(", ")}?`,
+      initial: true
+    });
+    if (!proceed) {
+      logger.info(`Skipped ${employeeName}`);
+      return;
+    }
+  }
+  if (dryRun) {
+    logger.info(`Would remove employee: ${employeeName}`);
+    logger.dim(`  Platforms: ${platforms.join(", ")}`);
+    return;
+  }
+  const s = spinner(`Removing ${employeeName}...`).start();
+  try {
+    await uninstallEmployee(employeeName, config, cwd, platforms);
+    let employeeDeps = [];
+    try {
+      const employee = await fetchEmployee(target.fullName, config, cwd);
+      employeeDeps = employee.dependencies || [];
+    } catch {
+      if (config.sharedSkills) {
+        for (const [skillName, state] of Object.entries(config.sharedSkills)) {
+          if (state.usedBy.includes(employeeName)) {
+            employeeDeps.push(skillName);
+          }
+        }
+      }
+    }
+    const removedSharedSkills = [];
+    const keptSharedSkills = [];
+    for (const depFullName of employeeDeps) {
+      const { shouldUninstall, remainingUsers } = await removeSharedSkillReference(cwd, depFullName, employeeName);
+      if (shouldUninstall) {
+        for (const platform of platforms) {
+          await uninstallSkill(depFullName, config, cwd, { platform });
+        }
+        removedSharedSkills.push(depFullName);
+      } else if (remainingUsers.length > 0) {
+        keptSharedSkills.push({ name: depFullName, users: remainingUsers });
+      }
+    }
+    if (installedState) {
+      await removeEmployee(cwd, employeeName);
+    }
+    s.succeed(`Removed ${employeeName}`);
+    logger.dim(`  Removed from: ${platforms.join(", ")}`);
+    if (removedSharedSkills.length > 0) {
+      logger.dim(
+        `  Removed shared skills: ${removedSharedSkills.map((s2) => s2.split("/").pop()).join(", ")}`
+      );
+    }
+    if (keptSharedSkills.length > 0) {
+      for (const { name, users } of keptSharedSkills) {
+        logger.dim(
+          `  Kept shared skill '${name.split("/").pop()}' (still used by: ${users.join(", ")})`
+        );
+      }
+    }
+  } catch (error) {
+    s.fail(`Failed to remove ${employeeName}`);
+    throw error;
+  }
+}
+async function removeSkillItem(target, config, cwd, platformsOpt, yes, force, dryRun) {
+  if (!config) return;
+  const skillFullName = target.fullName;
+  const installedState = config.skills?.[skillFullName];
+  let parentEmployee = null;
+  for (const [empName, empState] of Object.entries(config.employees)) {
+    if (empState.skills?.includes(target.name)) {
+      parentEmployee = empName;
+      break;
+    }
+  }
+  if (parentEmployee && !force) {
+    logger.warn(
+      `Skill '${skillFullName}' is part of employee '${parentEmployee}'.`
+    );
+    logger.dim(
+      "Use --force to remove it anyway, or remove the entire employee."
+    );
+    return;
+  }
+  let platforms;
+  if (installedState) {
+    if (platformsOpt && platformsOpt.length > 0) {
+      platforms = platformsOpt.filter(
+        (p) => installedState.platforms.includes(p)
+      );
+      if (platforms.length === 0) {
+        logger.warn(
+          `Skill '${skillFullName}' is not installed on specified platform(s). Skipping.`
+        );
+        return;
+      }
+    } else {
+      platforms = installedState.platforms;
+    }
+  } else {
+    if (platformsOpt && platformsOpt.length > 0) {
+      platforms = platformsOpt;
+    } else {
+      platforms = [config.defaultPlatform];
+    }
+  }
+  if (!yes && !dryRun) {
+    const { proceed } = await prompts4({
+      type: "confirm",
+      name: "proceed",
+      message: `Remove skill ${skillFullName} from ${platforms.join(", ")}?`,
+      initial: true
+    });
+    if (!proceed) {
+      logger.info(`Skipped ${skillFullName}`);
+      return;
+    }
+  }
+  if (dryRun) {
+    for (const platform of platforms) {
+      const result = await uninstallSkill(skillFullName, config, cwd, {
+        platform,
+        dryRun: true
+      });
+      logger.info(`Would remove skill: ${skillFullName}`);
+      logger.dim(`  Platform: ${platform}`);
+      logger.dim(`  Files: ${result.files.length}`);
+      for (const file of result.files) {
+        logger.dim(`    - ${file}`);
+      }
+    }
+    return;
+  }
+  const s = spinner(`Removing skill ${skillFullName}...`).start();
+  try {
+    for (const platform of platforms) {
+      const result = await uninstallSkill(skillFullName, config, cwd, {
+        platform
+      });
+      if (!result.removed) {
+        logger.dim(`  Skill not found on ${platform}`);
+      }
+    }
+    if (installedState) {
+      await removeSkill(cwd, skillFullName);
+    }
+    s.succeed(`Removed skill ${skillFullName}`);
+    logger.dim(`  Removed from: ${platforms.join(", ")}`);
+  } catch (error) {
+    s.fail(`Failed to remove skill ${skillFullName}`);
+    throw error;
+  }
+}
+var remove = new Command3().name("remove").description("Remove employees or skills from your project").argument("[items...]", "Employee or skill names to remove").option(
+  "-p, --platform <platform>",
+  "Remove from specific platform only",
+  (value, previous) => {
+    const result = platformSchema.safeParse(value);
+    if (!result.success) {
+      throw new Error(
+        `Invalid platform: ${value}. Available: claude-code, codex`
+      );
+    }
+    return [...previous, result.data];
+  },
+  []
+).option("-y, --yes", "Skip confirmation prompts", false).option("-f, --force", "Force remove (ignore dependency warnings)", false).option("--dry-run", "Preview changes without removing", false).option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (items, opts) => {
+  try {
+    if (items.length === 0) {
+      logger.error(
+        "Please specify at least one employee or skill to remove."
+      );
+      logger.dim("Examples:");
+      logger.dim(
+        "  npx aico remove pm                     # Remove employee"
+      );
+      logger.dim(
+        "  npx aico remove @the-aico/pm/brainstorming # Remove skill"
+      );
+      process.exit(1);
+    }
+    const options = removeOptionsSchema.parse({
+      items,
+      cwd: opts.cwd,
+      platforms: opts.platform.length > 0 ? opts.platform : void 0,
+      yes: opts.yes,
+      force: opts.force,
+      dryRun: opts.dryRun
+    });
+    await runRemove(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/list.ts
+import { Command as Command4 } from "commander";
+import { z as z8 } from "zod";
+var listOptionsSchema = z8.object({
+  cwd: z8.string(),
+  installed: z8.boolean()
+});
+async function runList(options) {
+  const { cwd, installed } = options;
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw notInitializedError();
+  }
+  if (installed) {
+    const employees = Object.entries(config.employees);
+    if (employees.length === 0) {
+      logger.info("No employees installed.");
+      logger.dim("Run `npx aico add <employee>` to add an employee.");
+      return;
+    }
+    logger.bold("Installed employees:");
+    logger.break();
+    for (const [name, state] of employees) {
+      const platforms = state.platforms.join(", ");
+      const date = new Date(state.installedAt).toLocaleDateString();
+      logger.log(
+        `  ${logger.highlight(name.padEnd(15))} ${platforms.padEnd(20)} ${date}`
+      );
+    }
+  } else {
+    logger.info("Fetching employee list...");
+    try {
+      const index = await fetchRegistryIndex(config, cwd);
+      if (index.employees.length === 0) {
+        logger.warn("No employees found in registry.");
+        return;
+      }
+      logger.break();
+      logger.bold("Available employees:");
+      logger.break();
+      for (const employee of index.employees) {
+        const installed2 = config.employees[employee.name] ? "\u2713" : " ";
+        const desc = employee.description ?? employee.role;
+        logger.log(
+          `  ${installed2} ${logger.highlight(employee.name.padEnd(15))} ${desc}`
+        );
+      }
+      logger.break();
+      logger.dim("Use `npx aico add <employee>` to add an employee.");
+      logger.dim("Use `npx aico list --installed` to see installed employees.");
+    } catch {
+      logger.warn(
+        "Could not fetch registry. Showing installed employees only."
+      );
+      logger.break();
+      const employees = Object.entries(config.employees);
+      if (employees.length === 0) {
+        logger.info("No employees installed.");
+        return;
+      }
+      for (const [name, state] of employees) {
+        logger.log(
+          `  ${logger.highlight(name.padEnd(15))} ${state.platforms.join(", ")}`
+        );
+      }
+    }
+  }
+}
+var list = new Command4().name("list").description("List available or installed employees").option("-i, --installed", "Show only installed employees", false).option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (opts) => {
+  try {
+    const options = listOptionsSchema.parse({
+      cwd: opts.cwd,
+      installed: opts.installed
+    });
+    await runList(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/build.ts
+import { Command as Command5 } from "commander";
+import fs6 from "fs-extra";
+import path7 from "path";
+import glob from "fast-glob";
+import { z as z9 } from "zod";
+var buildOptionsSchema = z9.object({
+  cwd: z9.string(),
+  employeesDir: z9.string(),
+  outputDir: z9.string(),
+  registry: z9.string(),
+  version: z9.string()
+});
+function inferCategory(employeeName) {
+  const categoryMap = {
+    pm: "pm",
+    frontend: "frontend",
+    backend: "backend",
+    devops: "devops",
+    _shared: "general"
+  };
+  return categoryMap[employeeName] ?? "general";
+}
+async function buildSharedSkills(employeesPath, outputPath, registry, version, skillsIndex) {
+  const sharedDir = path7.join(employeesPath, "_shared", "skills");
+  if (!await fs6.pathExists(sharedDir)) {
+    return 0;
+  }
+  const skillDirs = await glob("*/SKILL.md", {
+    cwd: sharedDir
+  });
+  if (skillDirs.length === 0) {
+    return 0;
+  }
+  const namespace = `${registry}/_shared`;
+  for (const skillPath of skillDirs) {
+    const skillName = path7.dirname(skillPath);
+    const skillFullName = `${namespace}/${skillName}`;
+    const skillFilePath = path7.join(sharedDir, skillPath);
+    const content = await fs6.readFile(skillFilePath, "utf-8");
+    const frontmatter = parseSkillFrontmatter(content);
+    if (!frontmatter) {
+      logger.warn(`Shared skill ${skillName} missing frontmatter, skipping`);
+      continue;
+    }
+    const fullSkill = {
+      name: skillName,
+      namespace,
+      fullName: skillFullName,
+      version,
+      description: frontmatter.description,
+      category: "general",
+      tags: [],
+      dependencies: [],
+      files: [
+        {
+          path: "SKILL.md",
+          type: "skill",
+          content
+        }
+      ]
+    };
+    const skillOutputDir = path7.join(
+      outputPath,
+      "skills",
+      registry.replace("@", ""),
+      "_shared"
+    );
+    await fs6.ensureDir(skillOutputDir);
+    await fs6.writeJson(
+      path7.join(skillOutputDir, `${skillName}.json`),
+      fullSkill,
+      { spaces: 2 }
+    );
+    skillsIndex.push({
+      name: skillName,
+      namespace,
+      fullName: skillFullName,
+      version,
+      description: frontmatter.description,
+      category: "general",
+      tags: []
+    });
+  }
+  return skillDirs.length;
+}
+async function runBuild(options) {
+  const { cwd, employeesDir, outputDir, registry, version } = options;
+  const employeesPath = path7.resolve(cwd, employeesDir);
+  const outputPath = path7.resolve(cwd, outputDir);
+  if (await fs6.pathExists(outputPath)) {
+    await fs6.emptyDir(outputPath);
+  }
+  const employeeFiles = await glob("*/employee.json", {
+    cwd: employeesPath,
+    ignore: ["_template/**"]
+  });
+  if (employeeFiles.length === 0) {
+    logger.warn("No employees found to build.");
+    return;
+  }
+  const s = spinner(`Building ${employeeFiles.length} employee(s)...`).start();
+  const skillsIndex = [];
+  const employeesIndex = [];
+  const legacyIndex = [];
+  for (const employeeFile of employeeFiles) {
+    const employeeName = path7.dirname(employeeFile);
+    const employeeDir = path7.join(employeesPath, employeeName);
+    try {
+      const employeeJson = await fs6.readJson(
+        path7.join(employeeDir, "employee.json")
+      );
+      const employeeSource = employeeSourceSchema.parse(employeeJson);
+      const category = inferCategory(employeeName);
+      const namespace = `${registry}/${employeeName}`;
+      const employeeFullName = `${registry}/${employeeName}`;
+      const employee = {
+        ...employeeSource,
+        skills: employeeSource.skills.map((sk) => ({
+          ...sk,
+          files: sk.files.map((f) => ({ ...f, content: "" }))
+        })),
+        commands: employeeSource.commands.map((c) => ({
+          ...c,
+          files: c.files.map((f) => ({ ...f, content: "" }))
+        })),
+        docs: employeeSource.docs.map((d) => ({
+          ...d,
+          files: d.files.map((f) => ({ ...f, content: "" }))
+        }))
+      };
+      const skillFullNames = [];
+      for (const skill of employee.skills) {
+        const skillFullName = `${namespace}/${skill.name}`;
+        skillFullNames.push(skillFullName);
+        const skillFiles = [];
+        let skillDescription = "";
+        for (const file of skill.files) {
+          const filePath = path7.join(employeeDir, file.path);
+          if (await fs6.pathExists(filePath)) {
+            const content = await fs6.readFile(filePath, "utf-8");
+            file.content = content;
+            if (file.path.endsWith("SKILL.md")) {
+              const frontmatter = parseSkillFrontmatter(content);
+              if (frontmatter) {
+                skillDescription = frontmatter.description;
+              }
+            }
+            skillFiles.push({
+              path: path7.basename(file.path),
+              type: file.type === "skill" ? "skill" : "reference",
+              content
+            });
+          } else {
+            throw new Error(`Skill file not found: ${file.path}`);
+          }
+        }
+        const fullSkill = {
+          name: skill.name,
+          namespace,
+          fullName: skillFullName,
+          version,
+          description: skillDescription,
+          category,
+          tags: [],
+          dependencies: [],
+          files: skillFiles
+        };
+        const skillOutputDir = path7.join(
+          outputPath,
+          "skills",
+          registry.replace("@", ""),
+          employeeName
+        );
+        await fs6.ensureDir(skillOutputDir);
+        await fs6.writeJson(
+          path7.join(skillOutputDir, `${skill.name}.json`),
+          fullSkill,
+          { spaces: 2 }
+        );
+        skillsIndex.push({
+          name: skill.name,
+          namespace,
+          fullName: skillFullName,
+          version,
+          description: skillDescription,
+          category,
+          tags: []
+        });
+      }
+      for (const command of employee.commands) {
+        for (const file of command.files) {
+          const filePath = path7.join(employeeDir, file.path);
+          if (await fs6.pathExists(filePath)) {
+            file.content = await fs6.readFile(filePath, "utf-8");
+          } else {
+            throw new Error(`Command file not found: ${file.path}`);
+          }
+        }
+      }
+      for (const doc of employee.docs) {
+        for (const file of doc.files) {
+          const filePath = path7.join(employeeDir, file.path);
+          if (await fs6.pathExists(filePath)) {
+            file.content = await fs6.readFile(filePath, "utf-8");
+          } else {
+            throw new Error(`Doc file not found: ${file.path}`);
+          }
+        }
+      }
+      const legacyOutputPath = path7.join(outputPath, `${employee.name}.json`);
+      await fs6.ensureDir(outputPath);
+      await fs6.writeJson(legacyOutputPath, employee, { spaces: 2 });
+      const employeeExtended = {
+        $schema: "https://the-aico.com/schema/employee.json",
+        name: employee.name,
+        namespace: registry,
+        fullName: employeeFullName,
+        role: employee.role,
+        description: employee.description,
+        version,
+        category,
+        skills: skillFullNames,
+        commands: employee.commands,
+        docs: employee.docs
+      };
+      const employeesOutputDir = path7.join(outputPath, "employees");
+      await fs6.ensureDir(employeesOutputDir);
+      await fs6.writeJson(
+        path7.join(employeesOutputDir, `${employee.name}.json`),
+        employeeExtended,
+        { spaces: 2 }
+      );
+      employeesIndex.push({
+        name: employee.name,
+        namespace: registry,
+        fullName: employeeFullName,
+        role: employee.role,
+        description: employee.description,
+        version,
+        skillCount: employee.skills.length,
+        commandCount: employee.commands.length,
+        category
+      });
+      legacyIndex.push({
+        name: employee.name,
+        role: employee.role,
+        description: employee.description
+      });
+      s.text = `Built ${employee.name}`;
+    } catch (error) {
+      s.fail(`Failed to build ${employeeName}`);
+      throw error;
+    }
+  }
+  s.text = "Building shared skills...";
+  const sharedSkillCount = await buildSharedSkills(
+    employeesPath,
+    outputPath,
+    registry,
+    version,
+    skillsIndex
+  );
+  if (sharedSkillCount > 0) {
+    s.text = `Built ${sharedSkillCount} shared skill(s)`;
+  }
+  const skillsIndexPath = path7.join(outputPath, "skills", "index.json");
+  await fs6.ensureDir(path7.dirname(skillsIndexPath));
+  await fs6.writeJson(skillsIndexPath, skillsIndex, { spaces: 2 });
+  const employeesIndexPath = path7.join(outputPath, "employees", "index.json");
+  await fs6.ensureDir(path7.dirname(employeesIndexPath));
+  await fs6.writeJson(employeesIndexPath, employeesIndex, { spaces: 2 });
+  const legacyIndexPath = path7.join(outputPath, "index.json");
+  await fs6.writeJson(
+    legacyIndexPath,
+    { employees: legacyIndex },
+    { spaces: 2 }
+  );
+  s.succeed(`Built ${employeeFiles.length} employee(s) to ${outputDir}/`);
+  logger.break();
+  logger.success("Registry build complete!");
+  logger.dim(`  Skills: ${skillsIndex.length} (${sharedSkillCount} shared)`);
+  logger.dim(`  Employees: ${employeesIndex.length}`);
+  logger.break();
+  for (const emp of employeesIndex) {
+    logger.dim(`  - ${emp.name}: ${emp.role} (${emp.skillCount} skills)`);
+  }
+}
+var build = new Command5().name("build").description("Build registry from employees directory").option(
+  "-e, --employees-dir <dir>",
+  "Employees source directory",
+  "employees"
+).option("-o, --output-dir <dir>", "Output directory", "registry").option("-r, --registry <name>", "Registry namespace", "@the-aico").option("-v, --version <version>", "Version number", "1.0.0").option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (opts) => {
+  try {
+    const options = buildOptionsSchema.parse({
+      cwd: opts.cwd,
+      employeesDir: opts.employeesDir,
+      outputDir: opts.outputDir,
+      registry: opts.registry,
+      version: opts.version
+    });
+    await runBuild(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/diff.ts
+import fs7 from "fs-extra";
+import path8 from "path";
+import { Command as Command6 } from "commander";
+import { diffLines } from "diff";
+import { z as z10 } from "zod";
+var adapters2 = {
+  "claude-code": claudeCodeAdapter,
+  codex: codexAdapter
+};
+var diffOptionsSchema = z10.object({
+  employee: z10.string().optional(),
+  cwd: z10.string()
+});
+async function compareFile(localPath, registryContent) {
+  if (!await fs7.pathExists(localPath)) {
+    return null;
+  }
+  const localContent = await fs7.readFile(localPath, "utf-8");
+  const patch = diffLines(localContent, registryContent);
+  const hasChanges = patch.some((part) => part.added || part.removed);
+  return hasChanges ? patch : null;
+}
+async function diffEmployee(employeeName, cwd, config) {
+  if (!config) return null;
+  const installedState = config.employees[employeeName];
+  if (!installedState) {
+    return null;
+  }
+  let registryEmployee;
+  try {
+    registryEmployee = await fetchEmployee(employeeName, config, cwd);
+  } catch {
+    return null;
+  }
+  const platform = installedState.platforms[0] || config.defaultPlatform;
+  const adapter = adapters2[platform];
+  const { skillsDir, commandsDir } = resolvePlatformPaths(
+    cwd,
+    config,
+    platform
+  );
+  const installedSkills = installedState.skills || [];
+  const installedCommands = installedState.commands || [];
+  const registrySkills = registryEmployee.skills.map((s) => s.name);
+  const registryCommands = registryEmployee.commands.map((c) => c.name);
+  const skillsAdded = registrySkills.filter(
+    (s) => !installedSkills.includes(s)
+  );
+  const skillsRemoved = installedSkills.filter(
+    (s) => !registrySkills.includes(s)
+  );
+  const commandsAdded = registryCommands.filter(
+    (c) => !installedCommands.includes(c)
+  );
+  const commandsRemoved = installedCommands.filter(
+    (c) => !registryCommands.includes(c)
+  );
+  const fileChanges = [];
+  for (const skill of registryEmployee.skills) {
+    const skillDirName = adapter.getSkillDirName(employeeName, skill.name);
+    for (const file of skill.files) {
+      const localPath = path8.join(
+        skillsDir,
+        skillDirName,
+        path8.basename(file.path)
+      );
+      let registryContent = file.content;
+      if (file.path.endsWith("SKILL.md")) {
+        registryContent = registryContent.replace(
+          /^(---\n[\s\S]*?name:\s*).+$/m,
+          `$1${skillDirName}`
+        );
+      }
+      if (!await fs7.pathExists(localPath)) {
+        if (!skillsAdded.includes(skill.name)) {
+          fileChanges.push({
+            filePath: localPath,
+            type: "added"
+          });
+        }
+      } else {
+        const patch = await compareFile(localPath, registryContent);
+        if (patch) {
+          fileChanges.push({
+            filePath: localPath,
+            type: "modified",
+            patch
+          });
+        }
+      }
+    }
+  }
+  for (const command of registryEmployee.commands) {
+    const commandFileName = adapter.getCommandFileName(
+      employeeName,
+      command.name
+    );
+    for (const file of command.files) {
+      const localPath = path8.join(commandsDir, commandFileName);
+      if (!await fs7.pathExists(localPath)) {
+        if (!commandsAdded.includes(command.name)) {
+          fileChanges.push({
+            filePath: localPath,
+            type: "added"
+          });
+        }
+      } else {
+        const patch = await compareFile(localPath, file.content);
+        if (patch) {
+          fileChanges.push({
+            filePath: localPath,
+            type: "modified",
+            patch
+          });
+        }
+      }
+    }
+  }
+  for (const skillName of skillsRemoved) {
+    const skillDirName = adapter.getSkillDirName(employeeName, skillName);
+    const skillPath = path8.join(skillsDir, skillDirName);
+    if (await fs7.pathExists(skillPath)) {
+      fileChanges.push({
+        filePath: skillPath,
+        type: "removed"
+      });
+    }
+  }
+  for (const commandName of commandsRemoved) {
+    const commandFileName = adapter.getCommandFileName(
+      employeeName,
+      commandName
+    );
+    const commandPath = path8.join(commandsDir, commandFileName);
+    if (await fs7.pathExists(commandPath)) {
+      fileChanges.push({
+        filePath: commandPath,
+        type: "removed"
+      });
+    }
+  }
+  const hasChanges = skillsAdded.length > 0 || skillsRemoved.length > 0 || commandsAdded.length > 0 || commandsRemoved.length > 0 || fileChanges.length > 0;
+  return {
+    name: employeeName,
+    hasChanges,
+    skillsAdded,
+    skillsRemoved,
+    commandsAdded,
+    commandsRemoved,
+    fileChanges
+  };
+}
+function printDiff(patch) {
+  for (const part of patch) {
+    if (part.added) {
+      process.stdout.write(logger.formatSuccess(part.value));
+    } else if (part.removed) {
+      process.stdout.write(logger.formatError(part.value));
+    } else {
+      process.stdout.write(part.value);
+    }
+  }
+}
+async function runDiff(options) {
+  const { cwd, employee } = options;
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw notInitializedError();
+  }
+  const installedEmployees = Object.keys(config.employees);
+  if (installedEmployees.length === 0) {
+    logger.info("No employees installed.");
+    return;
+  }
+  if (employee) {
+    if (!config.employees[employee]) {
+      logger.error(`Employee '${employee}' is not installed.`);
+      logger.dim(`Installed employees: ${installedEmployees.join(", ")}`);
+      process.exit(1);
+    }
+    const s2 = spinner(`Checking ${employee} for updates...`).start();
+    const diff2 = await diffEmployee(employee, cwd, config);
+    s2.stop();
+    if (!diff2) {
+      logger.error(`Failed to check updates for ${employee}`);
+      return;
+    }
+    if (!diff2.hasChanges) {
+      logger.success(`${employee} is up to date.`);
+      return;
+    }
+    logger.info(`Changes for ${employee}:`);
+    logger.break();
+    if (diff2.skillsAdded.length > 0) {
+      logger.success(`  New skills: ${diff2.skillsAdded.join(", ")}`);
+    }
+    if (diff2.skillsRemoved.length > 0) {
+      logger.warn(`  Removed skills: ${diff2.skillsRemoved.join(", ")}`);
+    }
+    if (diff2.commandsAdded.length > 0) {
+      logger.success(`  New commands: ${diff2.commandsAdded.join(", ")}`);
+    }
+    if (diff2.commandsRemoved.length > 0) {
+      logger.warn(`  Removed commands: ${diff2.commandsRemoved.join(", ")}`);
+    }
+    for (const change of diff2.fileChanges) {
+      const relativePath = path8.relative(cwd, change.filePath);
+      if (change.type === "modified") {
+        logger.info(`  Modified: ${relativePath}`);
+        if (change.patch) {
+          logger.break();
+          printDiff(change.patch);
+          logger.break();
+        }
+      }
+    }
+    logger.break();
+    logger.dim(`Run 'aico add ${employee} --overwrite' to update.`);
+    return;
+  }
+  const s = spinner("Checking for updates...").start();
+  const employeesWithUpdates = [];
+  for (const employeeName of installedEmployees) {
+    const diff2 = await diffEmployee(employeeName, cwd, config);
+    if (diff2?.hasChanges) {
+      employeesWithUpdates.push(diff2);
+    }
+  }
+  s.stop();
+  if (employeesWithUpdates.length === 0) {
+    logger.success("All employees are up to date.");
+    return;
+  }
+  logger.info("The following employees have updates available:");
+  logger.break();
+  for (const diff2 of employeesWithUpdates) {
+    logger.log(`  ${diff2.name}`);
+    if (diff2.skillsAdded.length > 0) {
+      logger.dim(`    + ${diff2.skillsAdded.length} new skill(s)`);
+    }
+    if (diff2.skillsRemoved.length > 0) {
+      logger.dim(`    - ${diff2.skillsRemoved.length} removed skill(s)`);
+    }
+    if (diff2.commandsAdded.length > 0) {
+      logger.dim(`    + ${diff2.commandsAdded.length} new command(s)`);
+    }
+    if (diff2.commandsRemoved.length > 0) {
+      logger.dim(`    - ${diff2.commandsRemoved.length} removed command(s)`);
+    }
+    const modifiedCount = diff2.fileChanges.filter(
+      (f) => f.type === "modified"
+    ).length;
+    if (modifiedCount > 0) {
+      logger.dim(`    ~ ${modifiedCount} modified file(s)`);
+    }
+  }
+  logger.break();
+  logger.dim(`Run 'aico diff <employee>' to see detailed changes.`);
+  logger.dim(`Run 'aico add <employee> --overwrite' to update.`);
+}
+var diff = new Command6().name("diff").description("Check for updates against the registry").argument("[employee]", "Employee name to check").option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (employee, opts) => {
+  try {
+    const options = diffOptionsSchema.parse({
+      employee,
+      cwd: opts.cwd
+    });
+    await runDiff(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/update.ts
+import { Command as Command7 } from "commander";
+import prompts5 from "prompts";
+import { z as z11 } from "zod";
+import kleur3 from "kleur";
+
+// src/utils/version.ts
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const partA = partsA[i] ?? 0;
+    const partB = partsB[i] ?? 0;
+    if (partA < partB) return -1;
+    if (partA > partB) return 1;
+  }
+  return 0;
+}
+function hasUpdate(current, latest) {
+  return compareVersions(current, latest) < 0;
+}
+function formatVersionChange(current, latest) {
+  if (hasUpdate(current, latest)) {
+    return `${current} \u2192 ${latest}`;
+  }
+  return `${current} (up to date)`;
+}
+
+// src/commands/update.ts
+var updateOptionsSchema = z11.object({
+  skills: z11.array(z11.string()),
+  cwd: z11.string(),
+  yes: z11.boolean(),
+  dryRun: z11.boolean()
+});
+async function runUpdate(options) {
+  const { skills, cwd, yes, dryRun } = options;
+  const config = await getConfig(cwd);
+  if (!config) {
+    throw notInitializedError();
+  }
+  logger.info("Checking for updates...");
+  let skillsToCheck;
+  if (skills.length > 0) {
+    skillsToCheck = skills.map((s2) => parseTarget(s2).fullName);
+  } else {
+    skillsToCheck = await getInstalledSkills(cwd);
+  }
+  if (skillsToCheck.length === 0) {
+    logger.info("No skills installed.");
+    return;
+  }
+  const s = spinner("Fetching latest versions...").start();
+  const updateResults = [];
+  for (const skillName of skillsToCheck) {
+    try {
+      const currentState = config.skills?.[skillName];
+      const currentVersion = currentState?.version ?? "0.0.0";
+      const latestSkill = await fetchSkill(skillName, config, cwd);
+      updateResults.push({
+        skillName,
+        currentVersion,
+        latestVersion: latestSkill.version,
+        hasUpdate: hasUpdate(currentVersion, latestSkill.version)
+      });
+    } catch {
+      logger.dim(`  Could not check ${skillName}`);
+    }
+  }
+  s.stop();
+  const updatesAvailable = updateResults.filter((r) => r.hasUpdate);
+  if (updatesAvailable.length === 0) {
+    logger.success("All skills are up to date!");
+    return;
+  }
+  logger.break();
+  logger.log(formatUpdateTable(updateResults));
+  logger.break();
+  if (dryRun) {
+    logger.info(`${updatesAvailable.length} update(s) available.`);
+    return;
+  }
+  if (!yes) {
+    const { confirmed } = await prompts5({
+      type: "confirm",
+      name: "confirmed",
+      message: `Update ${updatesAvailable.length} skill(s)?`,
+      initial: true
+    });
+    if (!confirmed) {
+      logger.info("Cancelled.");
+      return;
+    }
+  }
+  for (const result of updatesAvailable) {
+    const updateSpinner = spinner(`Updating ${result.skillName}...`).start();
+    try {
+      const latestSkill = await fetchSkill(result.skillName, config, cwd);
+      const platform = config.defaultPlatform;
+      await uninstallSkill(result.skillName, config, cwd, { platform });
+      await installSkill(latestSkill, config, cwd, {
+        platform,
+        overwrite: true
+      });
+      await updateSkill(
+        cwd,
+        result.skillName,
+        latestSkill.version,
+        [platform],
+        "standalone"
+      );
+      updateSpinner.succeed(
+        `Updated ${result.skillName} (${formatVersionChange(result.currentVersion, result.latestVersion)})`
+      );
+    } catch (error) {
+      updateSpinner.fail(`Failed to update ${result.skillName}`);
+      throw error;
+    }
+  }
+  logger.break();
+  logger.success("Update complete!");
+}
+function formatUpdateTable(results) {
+  const maxNameLen = Math.max(...results.map((r) => r.skillName.length), 20);
+  const maxVerLen = 10;
+  const lines = [];
+  const header = [
+    "Skill".padEnd(maxNameLen),
+    "Current".padEnd(maxVerLen),
+    "Latest".padEnd(maxVerLen),
+    "Status"
+  ].join(" \u2502 ");
+  const separator = [
+    "\u2500".repeat(maxNameLen),
+    "\u2500".repeat(maxVerLen),
+    "\u2500".repeat(maxVerLen),
+    "\u2500".repeat(16)
+  ].join("\u2500\u253C\u2500");
+  lines.push("\u250C" + separator.replace(/─┼─/g, "\u2500\u252C\u2500") + "\u2510");
+  lines.push("\u2502 " + header + " \u2502");
+  lines.push("\u251C" + separator + "\u2524");
+  for (const r of results) {
+    const status = r.hasUpdate ? kleur3.yellow("update available") : kleur3.green("up to date");
+    const row = [
+      r.skillName.padEnd(maxNameLen),
+      r.currentVersion.padEnd(maxVerLen),
+      r.latestVersion.padEnd(maxVerLen),
+      status
+    ].join(" \u2502 ");
+    lines.push("\u2502 " + row + " \u2502");
+  }
+  lines.push("\u2514" + separator.replace(/─┼─/g, "\u2500\u2534\u2500") + "\u2518");
+  return lines.join("\n");
+}
+var update = new Command7().name("update").description("Update installed skills to latest versions").argument("[skills...]", "Skill names to update (all if empty)").option("--dry-run", "Preview updates without applying", false).option("-y, --yes", "Skip confirmation", false).option("-c, --cwd <cwd>", "Working directory", process.cwd()).action(async (skills, opts) => {
+  try {
+    const options = updateOptionsSchema.parse({
+      skills,
+      cwd: opts.cwd,
+      yes: opts.yes,
+      dryRun: opts.dryRun
+    });
+    await runUpdate(options);
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command8 } from "commander";
+import kleur4 from "kleur";
+function searchItems(query, items) {
+  const q = query.toLowerCase();
+  return items.filter((item) => {
+    if (item.name.toLowerCase().includes(q)) return true;
+    if (item.fullName.toLowerCase().includes(q)) return true;
+    if (item.description.toLowerCase().includes(q)) return true;
+    if (item.tags?.some((tag) => tag.toLowerCase().includes(q))) return true;
+    if (item.category?.toLowerCase().includes(q)) return true;
+    return false;
+  });
+}
+function scoreItem(item, query) {
+  const q = query.toLowerCase();
+  let score = 0;
+  if (item.name.toLowerCase() === q) {
+    score += 100;
+  } else if (item.name.toLowerCase().includes(q)) {
+    score += 50;
+  }
+  if (item.tags?.some((tag) => tag.toLowerCase() === q)) {
+    score += 30;
+  }
+  if (item.category?.toLowerCase() === q) {
+    score += 20;
+  }
+  if (item.description.toLowerCase().includes(q)) {
+    score += 10;
+  }
+  return score;
+}
+function sortByRelevance(items, query) {
+  return items.map((item) => ({ ...item, score: scoreItem(item, query) })).sort((a, b) => b.score - a.score);
+}
+function filterByCategory(items, category) {
+  return items.filter((item) => item.category === category);
+}
+function filterByType(items, type) {
+  return items.filter((item) => item.type === type);
+}
+function formatTable(items) {
+  if (items.length === 0) {
+    return kleur4.yellow("No results found.");
+  }
+  const nameWidth = Math.max(
+    "Name".length,
+    ...items.map((i) => i.fullName.length)
+  );
+  const typeWidth = Math.max("Type".length, ...items.map((i) => i.type.length));
+  const catWidth = Math.max(
+    "Category".length,
+    ...items.map((i) => (i.category || "-").length)
+  );
+  const descWidth = 40;
+  const header = [
+    "Name".padEnd(nameWidth),
+    "Type".padEnd(typeWidth),
+    "Category".padEnd(catWidth),
+    "Description"
+  ].join(" \u2502 ");
+  const separator = [
+    "\u2500".repeat(nameWidth),
+    "\u2500".repeat(typeWidth),
+    "\u2500".repeat(catWidth),
+    "\u2500".repeat(descWidth)
+  ].join("\u2500\u253C\u2500");
+  const rows = items.map((item) => {
+    const desc = item.description.length > descWidth ? item.description.slice(0, descWidth - 3) + "..." : item.description;
+    return [
+      item.fullName.padEnd(nameWidth),
+      item.type.padEnd(typeWidth),
+      (item.category || "-").padEnd(catWidth),
+      desc
+    ].join(" \u2502 ");
+  });
+  return [kleur4.bold(header), separator, ...rows].join("\n");
+}
+function formatJSON(items) {
+  const output = {
+    count: items.length,
+    results: items.map((item) => ({
+      name: item.name,
+      fullName: item.fullName,
+      type: item.type,
+      category: item.category,
+      description: item.description,
+      tags: item.tags,
+      install: item.type === "employee" ? `npx aico add ${item.name}` : `npx aico add ${item.fullName}`
+    }))
+  };
+  return JSON.stringify(output, null, 2);
+}
+var search = new Command8().name("search").description("Search for skills and employees").argument("<query>", "Search query").option(
+  "-c, --category <category>",
+  "Filter by category (pm, frontend, backend)"
+).option("-t, --type <type>", "Filter by type (skill, employee)").option("--json", "Output as JSON").option("--limit <n>", "Limit results", "10").option("--cwd <cwd>", "Working directory", process.cwd()).action(async (query, opts) => {
+  try {
+    const config = await getConfig(opts.cwd);
+    if (!config) {
+      throw notInitializedError();
+    }
+    logger.info("Searching...");
+    const index = await fetchRegistryIndex(config, opts.cwd);
+    const items = [
+      ...index.employees.map((emp) => ({
+        name: emp.name,
+        fullName: emp.fullName || emp.name,
+        description: emp.description || "",
+        category: emp.category,
+        type: "employee"
+      }))
+    ];
+    let results = searchItems(query, items);
+    if (opts.category) {
+      results = filterByCategory(results, opts.category);
+    }
+    if (opts.type) {
+      results = filterByType(results, opts.type);
+    }
+    results = sortByRelevance(results, query);
+    const limit = parseInt(opts.limit, 10);
+    results = results.slice(0, limit);
+    logger.break();
+    if (opts.json) {
+      logger.log(formatJSON(results));
+    } else {
+      logger.log(
+        kleur4.cyan(`Found ${results.length} result(s) for "${query}":`)
+      );
+      logger.break();
+      logger.log(formatTable(results));
+      logger.break();
+      if (results.length > 0) {
+        logger.dim("Install: npx aico add <name>");
+      }
+    }
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/commands/check.ts
+import { Command as Command9 } from "commander";
+import kleur5 from "kleur";
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+function checkNodeVersion() {
+  const version = process.version;
+  const major = parseInt(version.slice(1).split(".")[0] ?? "0", 10);
+  if (major >= 20) {
+    return {
+      name: "Node.js",
+      status: "pass",
+      message: version
+    };
+  }
+  if (major >= 18) {
+    return {
+      name: "Node.js",
+      status: "warn",
+      message: `${version} (recommend >= 20)`
+    };
+  }
+  return {
+    name: "Node.js",
+    status: "fail",
+    message: `${version} (requires >= 18)`
+  };
+}
+async function checkConfig(cwd) {
+  const configPath = join(cwd, "aico.json");
+  if (!existsSync(configPath)) {
+    return {
+      name: "aico.json",
+      status: "fail",
+      message: "not found"
+    };
+  }
+  try {
+    const config = await getConfig(cwd);
+    if (!config) {
+      return {
+        name: "aico.json",
+        status: "fail",
+        message: "invalid"
+      };
+    }
+    if (!config.defaultPlatform) {
+      return {
+        name: "aico.json",
+        status: "warn",
+        message: "missing defaultPlatform"
+      };
+    }
+    return {
+      name: "aico.json",
+      status: "pass",
+      message: "valid"
+    };
+  } catch {
+    return {
+      name: "aico.json",
+      status: "fail",
+      message: "parse error"
+    };
+  }
+}
+function checkPlatformDirs(cwd, platform, platformConfig) {
+  const children = [];
+  const skillsPath = join(cwd, platformConfig.skills);
+  if (existsSync(skillsPath)) {
+    children.push({
+      name: platformConfig.skills,
+      status: "pass",
+      message: "exists"
+    });
+  } else {
+    children.push({
+      name: platformConfig.skills,
+      status: "warn",
+      message: "not found (will be created)"
+    });
+  }
+  const commandsPath = join(cwd, platformConfig.commands);
+  if (existsSync(commandsPath)) {
+    children.push({
+      name: platformConfig.commands,
+      status: "pass",
+      message: "exists"
+    });
+  } else {
+    children.push({
+      name: platformConfig.commands,
+      status: "warn",
+      message: "not found (will be created)"
+    });
+  }
+  const allPass = children.every((c) => c.status === "pass");
+  const hasError = children.some((c) => c.status === "fail");
+  return {
+    name: `Platform: ${platform}`,
+    status: hasError ? "fail" : allPass ? "pass" : "warn",
+    message: "",
+    children
+  };
+}
+async function checkRegistry(registries) {
+  const children = [];
+  for (const [name, registry] of Object.entries(registries)) {
+    const urlTemplate = typeof registry === "string" ? registry : registry.url;
+    const testUrl = urlTemplate.replace("{name}", "index");
+    try {
+      const response = await fetch(testUrl, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (response.ok) {
+        children.push({
+          name,
+          status: "pass",
+          message: "reachable"
+        });
+      } else {
+        children.push({
+          name,
+          status: "fail",
+          message: `HTTP ${response.status}`
+        });
+      }
+    } catch {
+      children.push({
+        name,
+        status: "fail",
+        message: "unreachable"
+      });
+    }
+  }
+  const hasError = children.some((c) => c.status === "fail");
+  return {
+    name: "Registry",
+    status: hasError ? "fail" : "pass",
+    message: "",
+    children
+  };
+}
+function countDirectory(dir) {
+  if (!existsSync(dir)) return 0;
+  try {
+    return readdirSync(dir).filter((item) => {
+      const itemPath = join(dir, item);
+      try {
+        return statSync(itemPath).isDirectory() || item.endsWith(".md");
+      } catch {
+        return false;
+      }
+    }).length;
+  } catch {
+    return 0;
+  }
+}
+function checkInstalled(cwd, platformConfig) {
+  const skillsCount = countDirectory(join(cwd, platformConfig.skills));
+  const commandsCount = countDirectory(join(cwd, platformConfig.commands));
+  const message = `${skillsCount} skills, ${commandsCount} commands`;
+  return {
+    name: "Installed",
+    status: skillsCount > 0 || commandsCount > 0 ? "pass" : "skip",
+    message
+  };
+}
+function getSymbol(status) {
+  const symbols = {
+    pass: kleur5.green("\u25CF"),
+    fail: kleur5.red("\u2716"),
+    warn: kleur5.yellow("\u25D0"),
+    skip: kleur5.gray("\u25CB")
+  };
+  return symbols[status];
+}
+function formatResults(results) {
+  const lines = [];
+  results.forEach((result, index) => {
+    const isLast = index === results.length - 1;
+    const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const extension = isLast ? "    " : "\u2502   ";
+    const symbol = getSymbol(result.status);
+    const message = result.message ? kleur5.dim(` (${result.message})`) : "";
+    lines.push(`${connector}${symbol} ${result.name}${message}`);
+    if (result.children) {
+      result.children.forEach((child, childIndex) => {
+        const childIsLast = childIndex === result.children.length - 1;
+        const childConnector = childIsLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+        const childSymbol = getSymbol(child.status);
+        const childMessage = child.message ? kleur5.dim(` (${child.message})`) : "";
+        lines.push(
+          `${extension}${childConnector}${childSymbol} ${child.name}${childMessage}`
+        );
+      });
+    }
+  });
+  return lines.join("\n");
+}
+var check = new Command9().name("check").description("Check environment and configuration").option("--json", "Output as JSON").option("--cwd <cwd>", "Working directory", process.cwd()).action(async (opts) => {
+  try {
+    const cwd = opts.cwd;
+    logger.break();
+    logger.bold(kleur5.cyan("AICO Environment Check"));
+    logger.break();
+    const results = [];
+    results.push(checkNodeVersion());
+    const configResult = await checkConfig(cwd);
+    results.push(configResult);
+    if (configResult.status === "fail") {
+      results.push({
+        name: "Platform",
+        status: "skip",
+        message: "skipped (no config)"
+      });
+      results.push({
+        name: "Registry",
+        status: "skip",
+        message: "skipped (no config)"
+      });
+      results.push({
+        name: "Installed",
+        status: "skip",
+        message: "skipped (no config)"
+      });
+    } else {
+      const config = await getConfig(cwd);
+      const platformConfig = config.platforms[config.defaultPlatform];
+      if (platformConfig) {
+        results.push(
+          checkPlatformDirs(cwd, config.defaultPlatform, platformConfig)
+        );
+        results.push(await checkRegistry(config.registries));
+        results.push(checkInstalled(cwd, platformConfig));
+      } else {
+        results.push({
+          name: "Platform",
+          status: "fail",
+          message: "default platform not found in config"
+        });
+        results.push({
+          name: "Registry",
+          status: "skip",
+          message: "skipped (platform missing)"
+        });
+        results.push({
+          name: "Installed",
+          status: "skip",
+          message: "skipped (platform missing)"
+        });
+      }
+    }
+    if (opts.json) {
+      logger.log(JSON.stringify(results, null, 2));
+    } else {
+      logger.log(formatResults(results));
+      logger.break();
+      const hasError = results.some((r) => r.status === "fail");
+      const hasWarn = results.some((r) => r.status === "warn");
+      if (hasError) {
+        logger.log(
+          kleur5.red("\u2716 Some checks failed. Run `npx aico init` to fix.")
+        );
+      } else if (hasWarn) {
+        logger.log(
+          kleur5.yellow("\u25D0 Some checks have warnings. AICO should work.")
+        );
+      } else {
+        logger.log(kleur5.green("\u2713 All checks passed! AICO is ready to use."));
+      }
+      logger.break();
+    }
+  } catch (error) {
+    handleError(error);
+  }
+});
+
+// src/index.ts
+var VERSION = "1.0.0";
+var globalVerbose = false;
+async function main() {
+  const program = new Command10().name("aico").description(
+    "AI employee management tool - Build your AI team in seconds, start working immediately"
+  ).version(VERSION).option("-v, --verbose", "Show detailed error information").option("--proxy <url>", "Use HTTP/HTTPS proxy for requests");
+  program.hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    globalVerbose = opts.verbose ?? false;
+  });
+  program.addCommand(init);
+  program.addCommand(add);
+  program.addCommand(remove);
+  program.addCommand(update);
+  program.addCommand(list);
+  program.addCommand(diff);
+  program.addCommand(build);
+  program.addCommand(search);
+  program.addCommand(check);
+  await program.parseAsync(process.argv);
+}
+main().catch((error) => {
+  handleError(error, { verbose: globalVerbose });
+});
+//# sourceMappingURL=index.js.map