ai-ops-cli 0.1.23 → 0.2.0

package/dist/bin/index.js

@@ -16,7 +16,7 @@ var DecisionTableEntrySchema = z.object({
 }).strict();
 var RuleContentSchema = z.object({
   /** Anti-pattern 규칙 ('하지 마라'). guidelines보다 항상 상단 렌더링 */
-  constraints: z.array(z.string().min(1)),
+  constraints: z.array(z.string().min(1)).default([]),
   /** Positive 규칙 ('해라') */
   guidelines: z.array(z.string().min(1)),
   /** 조건부 규칙. when→then→avoid 구조 */
@@ -28,6 +28,7 @@ var RuleSchema = z.object({
   tags: z.array(z.string().min(1)),
   /** 0-100. 높을수록 생성 파일 상단 배치 (U-shaped attention 최적화) */
   priority: z.number().int().min(0).max(100),
+  supported_tools: z.array(z.string().min(1)).min(1).default(["claude-code", "codex", "gemini"]),
   content: RuleContentSchema
 }).strict();
 
@@ -39,53 +40,132 @@ var PresetSchema = z2.object({
   rules: z2.array(z2.string().min(1)).min(1)
 }).strict();
 
-// src/core/schemas/manifest.schema.ts
+// src/core/schemas/skill.schema.ts
 import { z as z3 } from "zod";
-var SettingsConfigSchema = z3.object({
-  claude: z3.array(z3.string().min(1)).optional(),
-  gemini: z3.array(z3.string().min(1)).optional(),
-  prettierignore: z3.boolean().optional()
+var SKILL_KIND = {
+  REFERENCE: "reference",
+  TASK: "task"
+};
+var SKILL_SCOPE = {
+  PROJECT: "project",
+  USER: "user"
+};
+var SKILL_TOOL = {
+  CLAUDE_CODE: "claude-code",
+  CODEX: "codex",
+  GEMINI: "gemini"
+};
+var SkillKindSchema = z3.union([z3.literal(SKILL_KIND.REFERENCE), z3.literal(SKILL_KIND.TASK)]);
+var SkillScopeSchema = z3.union([z3.literal(SKILL_SCOPE.PROJECT), z3.literal(SKILL_SCOPE.USER)]);
+var SkillToolSchema = z3.union([
+  z3.literal(SKILL_TOOL.CLAUDE_CODE),
+  z3.literal(SKILL_TOOL.CODEX),
+  z3.literal(SKILL_TOOL.GEMINI)
+]);
+var SkillFileSchema = z3.object({
+  path: z3.string().min(1),
+  content: z3.string()
+}).strict();
+var SkillFrontmatterSchema = z3.object({
+  name: z3.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "name must be kebab-case"),
+  description: z3.string().min(1)
+}).passthrough();
+var InstalledSkillSchema = z3.object({
+  id: z3.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+  kind: SkillKindSchema,
+  tools: z3.array(SkillToolSchema).min(1),
+  scope: SkillScopeSchema,
+  installed_paths: z3.array(z3.string().min(1)).min(1),
+  sourceHash: z3.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars")
+}).strip();
+
+// src/core/schemas/skill-catalog.schema.ts
+import { z as z4 } from "zod";
+var SkillIdSchema = z4.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
+var SkillCatalogPathSchema = z4.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)+$/, "source_path must be relative kebab-case path");
+var SkillCatalogEntrySchema = z4.object({
+  id: SkillIdSchema,
+  kind: SkillKindSchema,
+  supported_tools: z4.array(SkillToolSchema).min(1),
+  install_scopes: z4.array(SkillScopeSchema).min(1),
+  groups: z4.array(z4.string().min(1)),
+  included_in_presets: z4.array(z4.string().min(1)),
+  source_path: SkillCatalogPathSchema
+}).strict().superRefine((entry, ctx) => {
+  const expectedPrefix = entry.kind === "reference" ? "reference-skills/" : "task-skills/";
+  if (!entry.source_path.startsWith(expectedPrefix)) {
+    ctx.addIssue({
+      code: z4.ZodIssueCode.custom,
+      path: ["source_path"],
+      message: `source_path must start with ${expectedPrefix}`
+    });
+  }
+});
+var SkillCatalogSchema = z4.object({
+  skills: z4.array(SkillCatalogEntrySchema)
 }).strict();
-var WorkspaceEntrySchema = z3.object({
-  preset: z3.string().min(1),
-  rules: z3.array(z3.string().min(1))
+
+// src/core/schemas/skill-registry.schema.ts
+import { z as z5 } from "zod";
+var SkillRegistrySchema = z5.object({
+  skills: z5.array(InstalledSkillSchema),
+  cliVersion: z5.string().optional(),
+  generatedAt: z5.string().datetime({ offset: true })
 }).strict();
-var ManifestSchema = z3.object({
-  tools: z3.array(z3.string().min(1)).min(1),
-  scope: z3.literal("project"),
+
+// src/core/schemas/manifest.schema.ts
+import { z as z6 } from "zod";
+var SettingsConfigSchema = z6.object({
+  claude: z6.array(z6.string().min(1)).optional(),
+  gemini: z6.array(z6.string().min(1)).optional(),
+  prettierignore: z6.boolean().optional()
+}).strict();
+var WorkspaceEntrySchema = z6.object({
+  preset: z6.string().min(1),
+  rules: z6.array(z6.string().min(1))
+}).strict();
+var ManifestSchema = z6.object({
+  tools: z6.array(z6.string().min(1)).min(1),
+  scope: z6.literal("project"),
   /** 비모노레포 단일 preset */
-  preset: z3.string().min(1).optional(),
+  preset: z6.string().min(1).optional(),
   /** 모노레포: workspace path → { preset, rules } */
-  workspaces: z3.record(z3.string(), WorkspaceEntrySchema).optional(),
-  installed_rules: z3.array(z3.string().min(1)),
+  workspaces: z6.record(z6.string(), WorkspaceEntrySchema).optional(),
+  installed_rules: z6.array(z6.string().min(1)),
   /** 실제 디스크에 쓰여진 파일 상대 경로 목록 (uninstall용). 기존 manifest 호환성 위해 optional */
-  installed_files: z3.array(z3.string().min(1)).optional(),
+  installed_files: z6.array(z6.string().min(1)).optional(),
+  /** skill 설치 루트 디렉토리 목록 */
+  installed_skills: z6.array(InstalledSkillSchema).optional(),
   /** non-managed 파일에 섹션을 append한 경우 추적 (uninstall 시 섹션만 제거) */
-  appended_files: z3.array(z3.string().min(1)).optional(),
+  appended_files: z6.array(z6.string().min(1)).optional(),
   /** init 시 선택된 settings 항목 — update 시 재생성에 사용 */
   settings: SettingsConfigSchema.optional(),
   /** init/update 실행 시점의 CLI 패키지 버전 — 버전 변경 감지에 사용 */
-  cliVersion: z3.string().optional(),
+  cliVersion: z6.string().optional(),
   /** SSOT 데이터 파일들의 deterministic SHA-256 해시 (6자리 hex). diff/update 판단 기준 */
-  sourceHash: z3.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
-  generatedAt: z3.string().datetime({ offset: true })
+  sourceHash: z6.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
+  generatedAt: z6.string().datetime({ offset: true })
 }).strict();
 
 // src/core/loader.ts
 import { readFileSync, readdirSync } from "fs";
-import { resolve } from "path";
+import { join, resolve } from "path";
+import { parse as parse2 } from "yaml";
+
+// src/core/frontmatter.ts
 import { parse } from "yaml";
-var PRESET_RULE_BUNDLES = {
-  "frontend-web": {
-    graphql: ["graphql-core", "graphql-client-web"]
-  },
-  "frontend-app": {
-    graphql: ["graphql-core", "graphql-client-app"]
-  },
-  "backend-ts": {
-    graphql: ["graphql-core", "graphql-server"]
+var parseMarkdownFrontmatter = (content) => {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!match) {
+    throw new Error("Missing YAML frontmatter");
   }
+  return {
+    frontmatter: parse(match[1]),
+    body: content.slice(match[0].length)
+  };
 };
+
+// src/core/loader.ts
 var sortRulesByPriority = (rules) => [...rules].sort((a, b) => b.priority - a.priority);
 var deduplicateRulesById = (rules) => {
   const seen = /* @__PURE__ */ new Set();
@@ -95,11 +175,6 @@ var deduplicateRulesById = (rules) => {
     return true;
   });
 };
-var resolveBundledRuleIds = (presetId, logicalRuleId) => {
-  const presetBundles = PRESET_RULE_BUNDLES[presetId];
-  if (!presetBundles) return [logicalRuleId];
-  return presetBundles[logicalRuleId] ?? [logicalRuleId];
-};
 var resolveRuleById = (ruleId, allRules, context) => {
   const found = allRules.find((rule) => rule.id === ruleId);
   if (!found) {
@@ -109,33 +184,80 @@ var resolveRuleById = (ruleId, allRules, context) => {
   return found;
 };
 var parseRawPresets = (raw) => Object.entries(raw).map(([id, value]) => PresetSchema.parse({ id, ...value }));
-var resolvePresetRuleGroups = (preset, allRules) => preset.rules.map((logicalRuleId) => {
-  const bundledRuleIds = resolveBundledRuleIds(preset.id, logicalRuleId);
-  const rules = bundledRuleIds.map((ruleId) => resolveRuleById(ruleId, allRules, `${preset.id}:${logicalRuleId}`));
-  return { id: logicalRuleId, rules };
-});
 var resolvePresetRules = (preset, allRules) => {
-  const groups = resolvePresetRuleGroups(preset, allRules);
-  const resolved = deduplicateRulesById(groups.flatMap((group) => group.rules));
-  return sortRulesByPriority(resolved);
+  const resolved = preset.rules.map((ruleId) => resolveRuleById(ruleId, allRules, preset.id));
+  return sortRulesByPriority(deduplicateRulesById(resolved));
+};
+var resolvePresetSkills = (preset, allSkills) => {
+  return allSkills.filter((skill) => skill.included_in_presets.includes(preset.id)).sort((a, b) => a.id.localeCompare(b.id));
 };
 var loadRuleFile = (filePath) => {
   const raw = readFileSync(filePath, "utf-8");
-  return RuleSchema.parse(parse(raw));
+  return RuleSchema.parse(parse2(raw));
+};
+var loadSkillDirectoryFiles = (skillDir) => {
+  const files = [];
+  const walk = (relativeDir = "") => {
+    const absDir = relativeDir.length > 0 ? join(skillDir, relativeDir) : skillDir;
+    const entries = readdirSync(absDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const nextRelativePath = relativeDir.length > 0 ? join(relativeDir, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        walk(nextRelativePath);
+        continue;
+      }
+      files.push({
+        path: nextRelativePath,
+        content: readFileSync(join(skillDir, nextRelativePath), "utf-8")
+      });
+    }
+  };
+  walk();
+  return files;
 };
 var loadAllRules = (rulesDir) => {
   const files = readdirSync(rulesDir).filter((f) => f.endsWith(".yaml")).sort();
   const rules = files.map((f) => loadRuleFile(resolve(rulesDir, f)));
   return sortRulesByPriority(rules);
 };
+var loadSkillCatalog = (skillsDir) => SkillCatalogSchema.parse(JSON.parse(readFileSync(resolve(skillsDir, "skill-registry.json"), "utf-8")));
+var loadAllSkills = (skillsDir) => {
+  const catalog = loadSkillCatalog(skillsDir);
+  const entries = [...catalog.skills].sort((a, b) => a.id.localeCompare(b.id));
+  return entries.map((entry) => {
+    const directory = resolve(skillsDir, entry.source_path);
+    const skillMdPath = join(directory, "SKILL.md");
+    const rawSkillMd = readFileSync(skillMdPath, "utf-8");
+    const { frontmatter } = parseMarkdownFrontmatter(rawSkillMd);
+    const parsed = SkillFrontmatterSchema.parse(frontmatter);
+    if (parsed.name !== entry.id) {
+      throw new Error(`Skill directory and frontmatter name mismatch: ${entry.id} != ${parsed.name}`);
+    }
+    const files = loadSkillDirectoryFiles(directory);
+    if (entry.kind === "reference" && !files.some((file) => file.path === "references/reference.md")) {
+      throw new Error(`Reference skill must include references/reference.md: ${parsed.name}`);
+    }
+    return {
+      id: entry.id,
+      kind: entry.kind,
+      description: parsed.description,
+      supported_tools: [...entry.supported_tools],
+      install_scopes: [...entry.install_scopes],
+      groups: [...entry.groups],
+      included_in_presets: [...entry.included_in_presets],
+      directory,
+      files
+    };
+  });
+};
 var loadPresets = (presetsPath) => {
   const raw = readFileSync(presetsPath, "utf-8");
-  const data = parse(raw);
+  const data = parse2(raw);
   return parseRawPresets(data);
 };
 
 // src/core/renderer.ts
-import { join } from "path";
+import { join as join2 } from "path";
 
 // src/core/tool-output.ts
 var GLOBAL_CATEGORIES = ["persona", "communication", "philosophy", "convention", "standard"];
@@ -225,7 +347,7 @@ var renderRuleToMarkdown = (rule) => {
   }
   return sections.join("\n\n");
 };
-var renderRulesToMarkdown = (rules) => rules.map(renderRuleToMarkdown).join("\n\n---\n\n");
+var renderRulesToMarkdown = (rules) => rules.map((rule) => renderRuleToMarkdown(rule)).join("\n\n---\n\n");
 var isGlobalRule = (rule) => GLOBAL_CATEGORIES.includes(rule.category);
 var partitionRules = (rules) => {
   const global = [];
@@ -240,7 +362,7 @@ var partitionRules = (rules) => {
   return { global, domain };
 };
 var renderFrontmatter = (paths) => {
-  const lines = paths.map((p8) => `  - "${p8}"`).join("\n");
+  const lines = paths.map((p9) => `  - "${p9}"`).join("\n");
   return `---
 paths:
 ${lines}
@@ -261,14 +383,14 @@ var renderForTool = (toolId, rules, workspaceMappings) => {
     const { rulesDir, fileExtension } = config;
     if (!workspaceMappings || workspaceMappings.length === 0) {
       const files = rules.map((rule) => ({
-        relativePath: join(rulesDir, `${rule.id}${fileExtension}`),
+        relativePath: join2(rulesDir, `${rule.id}${fileExtension}`),
         content: renderClaudeCodeRule(rule)
       }));
       return { tool: "claude-code", files };
     }
     const { global: global2, domain: domain2 } = partitionRules(rules);
     const globalFiles = global2.map((rule) => ({
-      relativePath: join(rulesDir, `${rule.id}${fileExtension}`),
+      relativePath: join2(rulesDir, `${rule.id}${fileExtension}`),
       content: renderRuleToMarkdown(rule)
       // global은 frontmatter 불필요
     }));
@@ -277,7 +399,7 @@ var renderForTool = (toolId, rules, workspaceMappings) => {
       const wsRules = domain2.filter((r) => ws.ruleIds.includes(r.id));
       if (wsRules.length === 0) continue;
       workspaceFiles.push({
-        relativePath: join(ws.path, "CLAUDE.md"),
+        relativePath: join2(ws.path, "CLAUDE.md"),
         content: renderRulesToMarkdown(wsRules)
       });
     }
@@ -295,7 +417,10 @@ var renderForTool = (toolId, rules, workspaceMappings) => {
   for (const ws of workspaceMappings) {
     const wsRules = domain.filter((r) => ws.ruleIds.includes(r.id));
     if (wsRules.length === 0) continue;
-    domainFiles.push({ workspacePath: ws.path, content: renderRulesToMarkdown(wsRules) });
+    domainFiles.push({
+      workspacePath: ws.path,
+      content: renderRulesToMarkdown(wsRules)
+    });
   }
   if (toolId === "codex") {
     return { tool: "codex", rootContent, domainFiles };
@@ -303,10 +428,13 @@ var renderForTool = (toolId, rules, workspaceMappings) => {
   return { tool: "gemini", rootContent, domainFiles };
 };
 
+// src/core/skill-renderer.ts
+import { join as join4 } from "path";
+
 // src/core/source-hash.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { dirname, resolve as resolve2 } from "path";
+import { existsSync, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
+import { dirname, join as join3, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var getCliVersion = () => {
@@ -319,11 +447,50 @@ var getCliVersion = () => {
   }
 };
 var computeHash = (contents) => createHash("sha256").update(contents.join("")).digest("hex").slice(0, 6);
-var computeSourceHash = (rulesDir) => {
-  const files = readdirSync2(rulesDir).filter((f) => f.endsWith(".yaml")).sort();
-  const contents = files.map((f) => readFileSync2(resolve2(rulesDir, f), "utf-8"));
-  return computeHash(contents);
+var loadSortedFileContents = (dirPath) => {
+  const files = readdirSync2(dirPath).filter((f) => f.endsWith(".yaml")).sort();
+  return files.map((f) => readFileSync2(resolve2(dirPath, f), "utf-8"));
 };
+var loadDirectoryContents = (baseDir) => {
+  const contents = [];
+  const walk = (relativeDir = "") => {
+    const absDir = relativeDir.length > 0 ? join3(baseDir, relativeDir) : baseDir;
+    const entries = readdirSync2(absDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const nextRelativePath = relativeDir.length > 0 ? join3(relativeDir, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        walk(nextRelativePath);
+        continue;
+      }
+      contents.push(`${nextRelativePath}:${readFileSync2(join3(baseDir, nextRelativePath), "utf-8")}`);
+    }
+  };
+  walk();
+  return contents;
+};
+var loadSkillTreeContents = (skillsDir) => {
+  const contents = [];
+  const registryPath = resolve2(skillsDir, "skill-registry.json");
+  if (existsSync(registryPath)) {
+    contents.push(`skill-registry.json:${readFileSync2(registryPath, "utf-8")}`);
+  }
+  for (const directoryName of ["reference-skills", "task-skills"]) {
+    const directoryPath = resolve2(skillsDir, directoryName);
+    if (!existsSync(directoryPath)) {
+      continue;
+    }
+    const directoryContents = loadDirectoryContents(directoryPath).map((content) => `${directoryName}/${content}`);
+    contents.push(...directoryContents);
+  }
+  return contents;
+};
+var computeSourceHash = (dataDir) => {
+  const ruleContents = loadSortedFileContents(resolve2(dataDir, "rules"));
+  const skillContents = loadSkillTreeContents(resolve2(dataDir, "skills"));
+  const presetsContent = readFileSync2(resolve2(dataDir, "presets.yaml"), "utf-8");
+  return computeHash([...ruleContents, ...skillContents, presetsContent]);
+};
+var computeInstalledSkillHash = (params) => computeHash([params.kind, params.description, ...[...params.tools].sort(), ...[...params.files].sort()]);
 var buildManifest = (params) => ManifestSchema.parse({
   tools: [...params.tools],
   scope: params.scope,
@@ -331,16 +498,71 @@ var buildManifest = (params) => ManifestSchema.parse({
   workspaces: params.workspaces,
   installed_rules: [...params.installedRules],
   installed_files: params.installedFiles ? [...params.installedFiles] : void 0,
+  installed_skills: params.installedSkills ? [...params.installedSkills] : void 0,
   appended_files: params.appendedFiles && params.appendedFiles.length > 0 ? [...params.appendedFiles] : void 0,
   settings: params.settings ? {
     claude: params.settings.claude ? [...params.settings.claude] : void 0,
-    gemini: params.settings.gemini ? [...params.settings.gemini] : void 0
+    gemini: params.settings.gemini ? [...params.settings.gemini] : void 0,
+    prettierignore: params.settings.prettierignore
   } : void 0,
   cliVersion: params.cliVersion,
   sourceHash: params.sourceHash,
   generatedAt: (/* @__PURE__ */ new Date()).toISOString()
 });
 
+// src/core/skill-renderer.ts
+var AGENT_SKILLS_DIR = ".agents/skills";
+var CLAUDE_SKILLS_DIR = ".claude/skills";
+var buildRootDirs = (skillId, toolIds) => {
+  const dirs = [];
+  if (toolIds.some((toolId) => toolId === "codex" || toolId === "gemini")) {
+    dirs.push(join4(AGENT_SKILLS_DIR, skillId));
+  }
+  if (toolIds.includes("claude-code")) {
+    dirs.push(join4(CLAUDE_SKILLS_DIR, skillId));
+  }
+  return dirs;
+};
+var normalizeSelectedTools = (skill, requestedTools) => {
+  const supportedToolSet = new Set(skill.supported_tools);
+  return requestedTools.filter((toolId) => supportedToolSet.has(toolId));
+};
+var buildSkillInstallPlan = (params) => {
+  const selectedTools = normalizeSelectedTools(params.skill, params.requestedTools);
+  if (selectedTools.length === 0) {
+    throw new Error(`Skill ${params.skill.id} does not support the requested tools`);
+  }
+  const rootDirs = buildRootDirs(params.skill.id, selectedTools);
+  const skillHash = computeInstalledSkillHash({
+    kind: params.skill.kind,
+    description: params.skill.description,
+    tools: selectedTools,
+    files: params.skill.files.map((file) => `${file.path}:${file.content}`)
+  });
+  const packages = rootDirs.map((rootDir) => {
+    const files = params.skill.files.map((file) => ({
+      relativePath: join4(rootDir, file.path),
+      content: file.content
+    }));
+    return {
+      skillId: params.skill.id,
+      rootDir,
+      files
+    };
+  });
+  return {
+    packages,
+    installedSkill: {
+      id: params.skill.id,
+      kind: params.skill.kind,
+      tools: selectedTools,
+      scope: params.scope,
+      installed_paths: rootDirs,
+      sourceHash: skillHash
+    }
+  };
+};
+
 // src/core/managed-header.ts
 var MANAGED_MARKER = "<!-- managed by ai-ops -->";
 var SECTION_START = "<!-- ai-ops:start -->";
@@ -374,11 +596,11 @@ var replaceAiOpsSection = (existing, newSection) => {
 
 // src/core/manifest-io.ts
 import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname as dirname2, join as join5 } from "path";
 var MANIFEST_FILENAME = ".ai-ops-manifest.json";
 var parseManifest = (json) => ManifestSchema.parse(JSON.parse(json));
 var serializeManifest = (manifest) => JSON.stringify(manifest, null, 2) + "\n";
-var resolveManifestPath = (basePath) => join2(basePath, MANIFEST_FILENAME);
+var resolveManifestPath = (basePath) => join5(basePath, MANIFEST_FILENAME);
 var readManifest = (manifestPath) => {
   let raw;
   try {
@@ -393,6 +615,144 @@ var writeManifest = (manifestPath, manifest) => {
   writeFileSync(manifestPath, serializeManifest(manifest), "utf-8");
 };
 
+// src/core/manifest-resolution.ts
+var LEGACY_SKILL_ID_MAP = {
+  "engineering-standards-pack": "backend-service-standards"
+};
+var LEGACY_EXTERNALIZED_RULE_SKILL_MAP = {
+  "engineering-standards": "backend-service-standards",
+  typescript: "typescript-language",
+  python: "python-language",
+  "react-typescript": "frontend-web-react-next-runtime",
+  nextjs: "frontend-web-react-next-runtime",
+  "libs-frontend-web": "frontend-web-react-next-runtime",
+  "shadcn-ui": "frontend-web-shadcn-ui",
+  flutter: "frontend-app-flutter-runtime",
+  "libs-frontend-app": "frontend-app-flutter-runtime",
+  nestjs: "backend-ts-nestjs-runtime",
+  "libs-backend-ts": "backend-ts-nestjs-runtime",
+  fastapi: "backend-python-fastapi-runtime",
+  "libs-backend-python": "backend-python-fastapi-runtime",
+  "graphql-core": "graphql-contract",
+  "graphql-client-web": "graphql-client-integration",
+  "graphql-client-app": "graphql-client-integration",
+  "graphql-server": "graphql-server-runtime",
+  "nestjs-graphql": "graphql-server-runtime",
+  "prisma-postgresql": "db-prisma-postgresql",
+  sqlalchemy: "db-sqlalchemy-postgresql",
+  "ai-llm-python": "ai-llm-python-runtime",
+  "data-pipeline-python": "data-pipeline-python-performance"
+};
+var resolveCanonicalSkillId = (skillId) => LEGACY_SKILL_ID_MAP[skillId] ?? skillId;
+var resolveRulesFromIds = (ruleIds, allRules) => {
+  const ruleMap = new Map(allRules.map((rule) => [rule.id, rule]));
+  const seen = /* @__PURE__ */ new Set();
+  const resolved = ruleIds.flatMap((ruleId) => {
+    const rule = ruleMap.get(ruleId);
+    if (!rule || seen.has(rule.id)) {
+      return [];
+    }
+    seen.add(rule.id);
+    return [rule];
+  });
+  return [...resolved].sort((a, b) => b.priority - a.priority);
+};
+var resolvePresetById = (presetId, presets) => {
+  if (presetId === void 0) {
+    return void 0;
+  }
+  return presets.find((preset) => preset.id === presetId);
+};
+var resolveManifestRules = (params) => {
+  const { manifest, allRules, presets } = params;
+  if (manifest.workspaces) {
+    const resolvedWorkspaces = Object.fromEntries(
+      Object.entries(manifest.workspaces).map(([workspacePath, entry]) => {
+        const preset2 = resolvePresetById(entry.preset, presets);
+        const rules = preset2 ? resolvePresetRules(preset2, allRules) : resolveRulesFromIds(entry.rules, allRules);
+        return [
+          workspacePath,
+          {
+            preset: entry.preset,
+            rules: rules.map((rule) => rule.id)
+          }
+        ];
+      })
+    );
+    const installedRules2 = resolveRulesFromIds(
+      Object.values(resolvedWorkspaces).flatMap((entry) => entry.rules),
+      allRules
+    );
+    return {
+      installedRules: installedRules2,
+      workspaces: resolvedWorkspaces
+    };
+  }
+  const preset = resolvePresetById(manifest.preset, presets);
+  const installedRules = preset ? resolvePresetRules(preset, allRules) : resolveRulesFromIds(manifest.installed_rules, allRules);
+  return {
+    installedRules
+  };
+};
+var resolveManifestProjectSkills = (params) => {
+  const { manifest, allSkills } = params;
+  const skillMap = new Map(allSkills.map((skill) => [skill.id, skill]));
+  const targets = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const installedSkill of manifest.installed_skills ?? []) {
+    const canonicalSkillId = resolveCanonicalSkillId(installedSkill.id);
+    const skill = skillMap.get(canonicalSkillId);
+    if (!skill) {
+      throw new Error(`Skill not found during manifest resolution: ${installedSkill.id}`);
+    }
+    if (seen.has(skill.id)) {
+      continue;
+    }
+    seen.add(skill.id);
+    targets.push({
+      skill,
+      requestedTools: [...installedSkill.tools]
+    });
+  }
+  for (const ruleId of manifest.installed_rules) {
+    const mappedSkillId = LEGACY_EXTERNALIZED_RULE_SKILL_MAP[ruleId];
+    if (!mappedSkillId || seen.has(mappedSkillId)) {
+      continue;
+    }
+    const skill = skillMap.get(mappedSkillId);
+    if (!skill) {
+      throw new Error(`Skill not found during legacy rule migration: ${mappedSkillId}`);
+    }
+    seen.add(mappedSkillId);
+    targets.push({
+      skill,
+      requestedTools: [...manifest.tools]
+    });
+  }
+  return targets;
+};
+
+// src/core/skill-registry-io.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join6 } from "path";
+var SKILL_REGISTRY_FILENAME = "skills-manifest.json";
+var parseSkillRegistry = (json) => SkillRegistrySchema.parse(JSON.parse(json));
+var serializeSkillRegistry = (registry) => JSON.stringify(registry, null, 2) + "\n";
+var resolveSkillRegistryPath = (userBasePath) => join6(userBasePath, ".ai-ops", SKILL_REGISTRY_FILENAME);
+var readSkillRegistry = (registryPath) => {
+  let raw;
+  try {
+    raw = readFileSync4(registryPath, "utf-8");
+  } catch {
+    return null;
+  }
+  return parseSkillRegistry(raw);
+};
+var writeSkillRegistry = (registryPath, registry) => {
+  mkdirSync2(dirname3(registryPath), { recursive: true });
+  writeFileSync2(registryPath, serializeSkillRegistry(registry), "utf-8");
+};
+
 // src/core/diff.ts
 var computeDiff = (params) => {
   const { previous, currentRules, currentSourceHash, currentCliVersion } = params;
@@ -407,7 +767,7 @@ var computeDiff = (params) => {
 };
 
 // src/core/install-plan.ts
-import { join as join3 } from "path";
+import { join as join7 } from "path";
 var CODEX_PLAN_BODY = "## Plan Snapshot (Plan mode only)\n\n- This rule applies only when `collaboration_mode=Plan`.\n- Before implementation (file edits/creates, installs, commits), save the latest plan content to `.codex/plans/YYYYMMDD_<topic>.md`.\n- In `Default` mode, do not automatically create or update plan files.";
 var buildInstallPlan = (params) => {
   const { toolId, renderResult, meta } = params;
@@ -422,12 +782,12 @@ var buildInstallPlan = (params) => {
     const actions = [];
     const rootContent = renderResult.rootContent ? renderResult.rootContent + "\n\n---\n\n" + CODEX_PLAN_BODY : CODEX_PLAN_BODY;
     actions.push({
-      relativePath: join3(config.dir, config.rootFileName),
+      relativePath: join7(config.dir, config.rootFileName),
       content: wrapWithSection(rootContent, meta)
     });
     for (const df of renderResult.domainFiles) {
       actions.push({
-        relativePath: join3(df.workspacePath, config.domainFileName),
+        relativePath: join7(df.workspacePath, config.domainFileName),
         content: wrapWithSection(df.content, meta)
       });
     }
@@ -438,13 +798,13 @@ var buildInstallPlan = (params) => {
     const actions = [];
     if (renderResult.rootContent) {
       actions.push({
-        relativePath: join3(config.dir, config.rootFileName),
+        relativePath: join7(config.dir, config.rootFileName),
         content: wrapWithSection(renderResult.rootContent, meta)
       });
     }
     for (const df of renderResult.domainFiles) {
       actions.push({
-        relativePath: join3(df.workspacePath, config.domainFileName),
+        relativePath: join7(df.workspacePath, config.domainFileName),
         content: wrapWithSection(df.content, meta)
       });
     }
@@ -454,7 +814,7 @@ var buildInstallPlan = (params) => {
 };
 
 // src/core/uninstall-plan.ts
-import { join as join4 } from "path";
+import { join as join8 } from "path";
 var inferInstalledFiles = (manifest) => {
   const files = [];
   const isMonorepo = manifest.workspaces !== void 0;
@@ -462,27 +822,27 @@ var inferInstalledFiles = (manifest) => {
     if (toolId === "claude-code") {
       const config = TOOL_OUTPUT_MAP["claude-code"];
       for (const ruleId of manifest.installed_rules) {
-        files.push(join4(config.rulesDir, `${ruleId}${config.fileExtension}`));
+        files.push(join8(config.rulesDir, `${ruleId}${config.fileExtension}`));
       }
     } else if (toolId === "codex") {
       const config = TOOL_OUTPUT_MAP["codex"];
       if (!isMonorepo) {
-        files.push(join4(config.dir, config.rootFileName));
-        files.push(join4(config.dir, config.domainFileName));
+        files.push(join8(config.dir, config.rootFileName));
+        files.push(join8(config.dir, config.domainFileName));
       } else {
-        files.push(join4(config.dir, config.rootFileName));
+        files.push(join8(config.dir, config.rootFileName));
         for (const ws of Object.keys(manifest.workspaces ?? {})) {
-          files.push(join4(ws, config.domainFileName));
+          files.push(join8(ws, config.domainFileName));
         }
       }
     } else if (toolId === "gemini") {
       const config = TOOL_OUTPUT_MAP["gemini"];
       if (!isMonorepo) {
-        files.push(join4(config.dir, config.rootFileName));
+        files.push(join8(config.dir, config.rootFileName));
       } else {
-        files.push(join4(config.dir, config.rootFileName));
+        files.push(join8(config.dir, config.rootFileName));
         for (const ws of Object.keys(manifest.workspaces ?? {})) {
-          files.push(join4(ws, config.domainFileName));
+          files.push(join8(ws, config.domainFileName));
         }
       }
     }
@@ -491,20 +851,23 @@ var inferInstalledFiles = (manifest) => {
 };
 
 // src/core/paths.ts
-import { dirname as dirname3, resolve as resolve3 } from "path";
+import { dirname as dirname4, resolve as resolve3 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = dirname3(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
 var COMPILER_DATA_DIR = resolve3(__dirname2, "..", "..", "data");
 
 // src/lib/paths.ts
-import { join as join5 } from "path";
-var resolveRulesDir = () => join5(COMPILER_DATA_DIR, "rules");
-var resolvePresetsPath = () => join5(COMPILER_DATA_DIR, "presets.yaml");
+import { join as join9 } from "path";
+var resolveCompilerDataDir = () => COMPILER_DATA_DIR;
+var resolveRulesDir = () => join9(COMPILER_DATA_DIR, "rules");
+var resolveSkillsDir = () => join9(COMPILER_DATA_DIR, "skills");
+var resolvePresetsPath = () => join9(COMPILER_DATA_DIR, "presets.yaml");
 var resolveBasePath = () => process.cwd();
+var resolveUserBasePath = () => process.env.AI_OPS_HOME ?? process.env.HOME ?? process.cwd();
 
 // src/lib/workspace.ts
-import { existsSync, readdirSync as readdirSync3, statSync } from "fs";
-import { join as join6, resolve as resolve4 } from "path";
+import { existsSync as existsSync2, readdirSync as readdirSync3, statSync } from "fs";
+import { join as join10, resolve as resolve4 } from "path";
 var EXCLUDE_DIRS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist", "build", ".next", ".turbo", ".cache", "coverage"]);
 var isVisibleDir = (basePath, name) => {
   if (name.startsWith(".") || EXCLUDE_DIRS.has(name)) return false;
@@ -524,7 +887,7 @@ var PROJECT_MANIFESTS = [
   "go.mod"
   // Go
 ];
-var isWorkspaceRoot = (dirPath) => PROJECT_MANIFESTS.some((f) => existsSync(join6(dirPath, f)));
+var isWorkspaceRoot = (dirPath) => PROJECT_MANIFESTS.some((f) => existsSync2(join10(dirPath, f)));
 var listWorkspaceCandidates = (basePath) => {
   const topLevel = readdirSync3(basePath).filter((name) => isVisibleDir(basePath, name));
   const candidates = [];
@@ -537,7 +900,7 @@ var listWorkspaceCandidates = (basePath) => {
       const wsChildren = children.filter((name) => isWorkspaceRoot(resolve4(subPath, name)));
       if (wsChildren.length > 0) {
         for (const child of wsChildren) {
-          candidates.push(join6(dir, child));
+          candidates.push(join10(dir, child));
         }
       } else {
         candidates.push(dir);
@@ -548,31 +911,31 @@ var listWorkspaceCandidates = (basePath) => {
 };
 
 // src/lib/install.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname4, resolve as resolve5 } from "path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname5, resolve as resolve5 } from "path";
 var installFiles = (basePath, actions, _meta) => {
   const written = [];
   const appended = [];
   const skipped = [];
   for (const action of actions) {
     const absPath = resolve5(basePath, action.relativePath);
-    if (!existsSync2(absPath)) {
-      mkdirSync2(dirname4(absPath), { recursive: true });
-      writeFileSync2(absPath, action.content + "\n", "utf-8");
+    if (!existsSync3(absPath)) {
+      mkdirSync3(dirname5(absPath), { recursive: true });
+      writeFileSync3(absPath, action.content + "\n", "utf-8");
       written.push(action.relativePath);
     } else {
-      const existing = readFileSync4(absPath, "utf-8");
+      const existing = readFileSync5(absPath, "utf-8");
       if (hasAiOpsSection(existing)) {
         const updated = replaceAiOpsSection(existing, action.content);
-        writeFileSync2(absPath, updated, "utf-8");
+        writeFileSync3(absPath, updated, "utf-8");
         const stripped = stripAiOpsSection(existing);
         (stripped.trim().length > 0 ? appended : written).push(action.relativePath);
       } else if (hasLegacyHeader(existing)) {
-        writeFileSync2(absPath, action.content + "\n", "utf-8");
+        writeFileSync3(absPath, action.content + "\n", "utf-8");
         written.push(action.relativePath);
       } else {
         const updated = existing.trimEnd() + "\n\n" + action.content + "\n";
-        writeFileSync2(absPath, updated, "utf-8");
+        writeFileSync3(absPath, updated, "utf-8");
         appended.push(action.relativePath);
       }
     }
@@ -580,10 +943,40 @@ var installFiles = (basePath, actions, _meta) => {
   return { written, appended, skipped };
 };
 
+// src/lib/skill-install.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, resolve as resolve6 } from "path";
+var installSkillPackages = (basePath, packages) => {
+  const writtenRoots = [];
+  for (const skillPackage of packages) {
+    const absRoot = resolve6(basePath, skillPackage.rootDir);
+    if (existsSync4(absRoot)) {
+      rmSync(absRoot, { recursive: true, force: true });
+    }
+    for (const file of skillPackage.files) {
+      const absPath = resolve6(basePath, file.relativePath);
+      mkdirSync4(dirname6(absPath), { recursive: true });
+      writeFileSync4(absPath, file.content + "\n", "utf-8");
+    }
+    writtenRoots.push(skillPackage.rootDir);
+  }
+  return writtenRoots;
+};
+var removeDirectories = (basePath, relativeDirs) => {
+  const removed = [];
+  for (const relativeDir of relativeDirs) {
+    const absPath = resolve6(basePath, relativeDir);
+    if (!existsSync4(absPath)) continue;
+    rmSync(absPath, { recursive: true, force: true });
+    removed.push(relativeDir);
+  }
+  return removed;
+};
+
 // src/lib/gemini-settings.ts
 import * as p from "@clack/prompts";
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join11 } from "path";
 
 // src/lib/deep-merge.util.ts
 var deepMerge = (base, patch) => {
@@ -615,6 +1008,10 @@ var deepRemoveKeys = (base, patch) => {
   return result;
 };
 
+// src/lib/prompt-control.ts
+var PROMPT_CANCELLED = /* @__PURE__ */ Symbol("prompt-cancelled");
+var isPromptCancelled = (value) => value === PROMPT_CANCELLED;
+
 // src/lib/gemini-settings.ts
 var SETTING_GROUPS = [
   {
@@ -647,7 +1044,8 @@ var promptGeminiSettings = async () => {
     message: "Gemini CLI \uC124\uC815 \uD30C\uC77C(.gemini/settings.json)\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
     initialValue: true
   });
-  if (p.isCancel(wantSettings) || !wantSettings) return null;
+  if (p.isCancel(wantSettings)) return PROMPT_CANCELLED;
+  if (!wantSettings) return null;
   const selected = await p.multiselect({
     message: "\uC124\uCE58\uD560 \uC124\uC815 \uD56D\uBAA9\uC744 \uC120\uD0DD\uD558\uC138\uC694 (\uC2A4\uD398\uC774\uC2A4\uB85C \uD1A0\uAE00)",
     options: SETTING_GROUPS.map((g) => ({
@@ -658,17 +1056,17 @@ var promptGeminiSettings = async () => {
     initialValues: SETTING_GROUPS.map((g) => g.value),
     required: false
   });
-  if (p.isCancel(selected)) return null;
+  if (p.isCancel(selected)) return PROMPT_CANCELLED;
   return selected;
 };
 var installGeminiSettings = (basePath, selectedValues) => {
   if (selectedValues.length === 0) return;
-  const settingsDir = join7(basePath, ".gemini");
-  const settingsPath = join7(settingsDir, "settings.json");
+  const settingsDir = join11(basePath, ".gemini");
+  const settingsPath = join11(settingsDir, "settings.json");
   let existing = {};
-  if (existsSync3(settingsPath)) {
+  if (existsSync5(settingsPath)) {
     try {
-      existing = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+      existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
     } catch {
     }
   }
@@ -678,37 +1076,40 @@ var installGeminiSettings = (basePath, selectedValues) => {
     if (!group) continue;
     merged = deepMerge(merged, group.patch);
   }
-  mkdirSync3(settingsDir, { recursive: true });
-  writeFileSync3(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  mkdirSync5(settingsDir, { recursive: true });
+  writeFileSync5(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 };
 var uninstallGeminiSettings = (basePath, selectedValues) => {
-  const settingsPath = join7(basePath, ".gemini", "settings.json");
-  if (!existsSync3(settingsPath)) return "notFound";
+  const settingsPath = join11(basePath, ".gemini", "settings.json");
+  if (!existsSync5(settingsPath)) return "notFound";
   let existing = {};
   try {
-    existing = JSON.parse(readFileSync5(settingsPath, "utf-8"));
+    existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
   } catch {
-    rmSync(settingsPath, { force: true });
+    rmSync2(settingsPath, { force: true });
     return "deleted";
   }
   let result = existing;
   for (const val of selectedValues) {
     const group = SETTING_GROUPS.find((g) => g.value === val);
     if (!group) continue;
-    result = deepRemoveKeys(result, group.patch);
+    result = deepRemoveKeys(
+      result,
+      group.patch
+    );
   }
   if (Object.keys(result).length === 0) {
-    rmSync(settingsPath, { force: true });
+    rmSync2(settingsPath, { force: true });
     return "deleted";
   }
-  writeFileSync3(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
+  writeFileSync5(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
   return "cleaned";
 };
 
 // src/lib/claude-settings.ts
 import * as p2 from "@clack/prompts";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync6, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join8 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync6, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { join as join12 } from "path";
 var SETTING_GROUPS2 = [
   {
     value: "model",
@@ -728,7 +1129,8 @@ var promptClaudeSettings = async () => {
     message: "Claude Code \uC124\uC815 \uD30C\uC77C(.claude/settings.local.json)\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
     initialValue: true
   });
-  if (p2.isCancel(wantSettings) || !wantSettings) return null;
+  if (p2.isCancel(wantSettings)) return PROMPT_CANCELLED;
+  if (!wantSettings) return null;
   const selected = await p2.multiselect({
     message: "\uC124\uCE58\uD560 \uC124\uC815 \uD56D\uBAA9\uC744 \uC120\uD0DD\uD558\uC138\uC694 (\uC2A4\uD398\uC774\uC2A4\uB85C \uD1A0\uAE00)",
     options: SETTING_GROUPS2.map((g) => ({
@@ -739,17 +1141,17 @@ var promptClaudeSettings = async () => {
     initialValues: SETTING_GROUPS2.map((g) => g.value),
     required: false
   });
-  if (p2.isCancel(selected)) return null;
+  if (p2.isCancel(selected)) return PROMPT_CANCELLED;
   return selected;
 };
 var installClaudeSettings = (basePath, selectedValues) => {
   if (selectedValues.length === 0) return;
-  const settingsDir = join8(basePath, ".claude");
-  const settingsPath = join8(settingsDir, "settings.local.json");
+  const settingsDir = join12(basePath, ".claude");
+  const settingsPath = join12(settingsDir, "settings.local.json");
   let existing = {};
-  if (existsSync4(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
-      existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+      existing = JSON.parse(readFileSync7(settingsPath, "utf-8"));
     } catch {
     }
   }
@@ -759,37 +1161,40 @@ var installClaudeSettings = (basePath, selectedValues) => {
     if (!group) continue;
     merged = deepMerge(merged, group.patch);
   }
-  mkdirSync4(settingsDir, { recursive: true });
-  writeFileSync4(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+  mkdirSync6(settingsDir, { recursive: true });
+  writeFileSync6(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 };
 var uninstallClaudeSettings = (basePath, selectedValues) => {
-  const settingsPath = join8(basePath, ".claude", "settings.local.json");
-  if (!existsSync4(settingsPath)) return "notFound";
+  const settingsPath = join12(basePath, ".claude", "settings.local.json");
+  if (!existsSync6(settingsPath)) return "notFound";
   let existing = {};
   try {
-    existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
+    existing = JSON.parse(readFileSync7(settingsPath, "utf-8"));
   } catch {
-    rmSync2(settingsPath, { force: true });
+    rmSync3(settingsPath, { force: true });
     return "deleted";
   }
   let result = existing;
   for (const val of selectedValues) {
     const group = SETTING_GROUPS2.find((g) => g.value === val);
     if (!group) continue;
-    result = deepRemoveKeys(result, group.patch);
+    result = deepRemoveKeys(
+      result,
+      group.patch
+    );
   }
   if (Object.keys(result).length === 0) {
-    rmSync2(settingsPath, { force: true });
+    rmSync3(settingsPath, { force: true });
     return "deleted";
   }
-  writeFileSync4(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
+  writeFileSync6(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
   return "cleaned";
 };
 
 // src/lib/prettier-ignore.ts
 import * as p3 from "@clack/prompts";
-import { existsSync as existsSync5, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync8, rmSync as rmSync4, writeFileSync as writeFileSync7 } from "fs";
+import { join as join13 } from "path";
 var PRETTIER_IGNORE_CONTENT = `# CLAUDE
 .claude/rules/
 **/CLAUDE.md
@@ -851,38 +1256,82 @@ var promptPrettierIgnore = async () => {
     message: ".prettierignore\uB97C \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C? (VSCode Prettier \uC790\uB3D9 \uD3EC\uB9F7\uC73C\uB85C\uBD80\uD130 AI \uADDC\uCE59 \uD30C\uC77C \uBCF4\uD638)",
     initialValue: false
   });
-  if (p3.isCancel(want)) return false;
+  if (p3.isCancel(want)) return PROMPT_CANCELLED;
   return want;
 };
 var installPrettierIgnore = (basePath) => {
-  const filePath = join9(basePath, ".prettierignore");
+  const filePath = join13(basePath, ".prettierignore");
   const section = wrapSection(PRETTIER_IGNORE_CONTENT);
-  if (!existsSync5(filePath)) {
-    writeFileSync5(filePath, section + "\n", "utf-8");
+  if (!existsSync7(filePath)) {
+    writeFileSync7(filePath, section + "\n", "utf-8");
     return;
   }
-  const existing = readFileSync7(filePath, "utf-8");
+  const existing = readFileSync8(filePath, "utf-8");
   if (hasAiOpsSection2(existing)) {
-    writeFileSync5(filePath, replaceSection(existing, PRETTIER_IGNORE_CONTENT), "utf-8");
+    writeFileSync7(filePath, replaceSection(existing, PRETTIER_IGNORE_CONTENT), "utf-8");
     return;
   }
   const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-  writeFileSync5(filePath, existing + separator + section + "\n", "utf-8");
+  writeFileSync7(filePath, existing + separator + section + "\n", "utf-8");
 };
 var uninstallPrettierIgnore = (basePath) => {
-  const filePath = join9(basePath, ".prettierignore");
-  if (!existsSync5(filePath)) return "notFound";
-  const existing = readFileSync7(filePath, "utf-8");
+  const filePath = join13(basePath, ".prettierignore");
+  if (!existsSync7(filePath)) return "notFound";
+  const existing = readFileSync8(filePath, "utf-8");
   if (!hasAiOpsSection2(existing)) return "notFound";
   const stripped = stripAiOpsSection2(existing).trim();
   if (stripped.length === 0) {
-    rmSync3(filePath, { force: true });
+    rmSync4(filePath, { force: true });
     return "deleted";
   }
-  writeFileSync5(filePath, stripped + "\n", "utf-8");
+  writeFileSync7(filePath, stripped + "\n", "utf-8");
   return "cleaned";
 };
 
+// src/lib/skill-state.ts
+var resolveSkillScope = (params) => {
+  if (params.scope !== void 0) {
+    if (params.scope === "user") return "user";
+    if (params.scope === "project") return "project";
+    throw new Error(`Unsupported scope: ${params.scope}`);
+  }
+  if (params.project) return "project";
+  return "user";
+};
+var resolveRequestedTools = (params) => {
+  if (params.requested === void 0 || params.requested.length === 0) {
+    return [...params.supported];
+  }
+  const supportedSet = new Set(params.supported);
+  const invalid = params.requested.filter((tool) => !supportedSet.has(tool));
+  if (invalid.length > 0) {
+    throw new Error(`Unsupported tools requested: ${invalid.join(", ")}`);
+  }
+  return [...params.requested];
+};
+var TOOL_ORDER = [SKILL_TOOL.CLAUDE_CODE, SKILL_TOOL.CODEX, SKILL_TOOL.GEMINI];
+var mergeSkillTools = (params) => {
+  const merged = /* @__PURE__ */ new Set([...params.existing ?? [], ...params.requested]);
+  return TOOL_ORDER.filter((tool) => merged.has(tool));
+};
+var subtractSkillTools = (params) => {
+  const installed = new Set(params.installed ?? []);
+  return params.requested.filter((tool) => !installed.has(tool));
+};
+var upsertInstalledSkill = (installedSkills, nextSkill) => {
+  const nextSkillId = resolveCanonicalSkillId(nextSkill.id);
+  const remaining = installedSkills.filter((skill) => resolveCanonicalSkillId(skill.id) !== nextSkillId);
+  return [...remaining, nextSkill];
+};
+var removeInstalledSkill = (installedSkills, skillId) => {
+  const targetSkillId = resolveCanonicalSkillId(skillId);
+  return installedSkills.filter((skill) => resolveCanonicalSkillId(skill.id) !== targetSkillId);
+};
+var findInstalledSkill = (installedSkills, skillId) => {
+  const targetSkillId = resolveCanonicalSkillId(skillId);
+  return installedSkills.find((skill) => resolveCanonicalSkillId(skill.id) === targetSkillId);
+};
+
 // src/commands/init.ts
 var TOOL_OPTIONS = [
   { value: "claude-code", label: "Claude Code" },
@@ -891,164 +1340,333 @@ var TOOL_OPTIONS = [
 ];
 var deduplicateRules = (rules) => {
   const seen = /* @__PURE__ */ new Set();
-  return rules.filter((r) => {
-    if (seen.has(r.id)) return false;
-    seen.add(r.id);
+  return rules.filter((rule) => {
+    if (seen.has(rule.id)) return false;
+    seen.add(rule.id);
     return true;
   });
 };
-var selectPresetAndFineTune = async (workspaceName, presets, allRules) => {
+var formatToolList = (toolIds) => toolIds.join(", ");
+var deduplicateSkillTargets = (targets) => {
+  const merged = /* @__PURE__ */ new Map();
+  for (const target of targets) {
+    const previous = merged.get(target.skill.id);
+    if (!previous) {
+      merged.set(target.skill.id, {
+        skill: target.skill,
+        requestedTools: [...target.requestedTools]
+      });
+      continue;
+    }
+    merged.set(target.skill.id, {
+      skill: target.skill,
+      requestedTools: mergeSkillTools({
+        existing: previous.requestedTools,
+        requested: target.requestedTools
+      })
+    });
+  }
+  return [...merged.values()].sort((a, b) => a.skill.id.localeCompare(b.skill.id));
+};
+var resolveSupportedRequestedTools = (skill, selectedTools) => selectedTools.filter((toolId) => skill.supported_tools.includes(toolId));
+var partitionPresetSkills = (params) => {
+  const globalSkills = [];
+  const installableSkills = [];
+  for (const skill of resolvePresetSkills(params.preset, params.allSkills)) {
+    if (skill.kind !== "reference") {
+      continue;
+    }
+    const supportedRequestedTools = resolveSupportedRequestedTools(skill, params.selectedTools);
+    if (supportedRequestedTools.length === 0) {
+      continue;
+    }
+    const installedGlobalSkill = findInstalledSkill(params.globalInstalledSkills, skill.id);
+    const availableTools = installedGlobalSkill ? supportedRequestedTools.filter((toolId) => installedGlobalSkill.tools.includes(toolId)) : [];
+    const requestedTools = subtractSkillTools({
+      requested: supportedRequestedTools,
+      installed: availableTools
+    });
+    if (requestedTools.length === 0) {
+      globalSkills.push({
+        skill,
+        availableTools
+      });
+      continue;
+    }
+    installableSkills.push({
+      skill,
+      requestedTools,
+      globalTools: availableTools
+    });
+  }
+  return {
+    globalSkills,
+    installableSkills
+  };
+};
+var selectPresetAndFineTune = async (workspaceName, presets, allRules, allSkills, selectedTools, globalInstalledSkills) => {
   const preset = await p4.select({
     message: `[${workspaceName}] \uD504\uB9AC\uC14B\uC744 \uC120\uD0DD\uD558\uC138\uC694`,
-    options: presets.map((pr) => ({
-      value: pr,
-      label: pr.id,
-      hint: pr.description
+    options: presets.map((candidate) => ({
+      value: candidate,
+      label: candidate.id,
+      hint: candidate.description
     }))
   });
   if (p4.isCancel(preset)) return null;
-  const presetRuleGroups = resolvePresetRuleGroups(preset, allRules);
-  const globalGroups = presetRuleGroups.filter((group) => group.rules.every(isGlobalRule));
-  const domainGroups = presetRuleGroups.filter((group) => !group.rules.every(isGlobalRule));
-  const globalGroupIds = globalGroups.map((group) => group.id);
-  const globalRules = globalGroupIds.length > 0 ? resolvePresetRules({ ...preset, rules: globalGroupIds }, allRules) : [];
-  if (globalRules.length > 0) {
-    p4.note(globalRules.map((r) => `  \u2713 ${r.id}`).join("\n"), `[${workspaceName}] \uAE30\uBCF8 \uADDC\uCE59 (\uC7A0\uAE08)`);
-  }
-  if (domainGroups.length === 0) {
-    return { workspace: workspaceName, preset, finalRules: resolvePresetRules(preset, allRules) };
-  }
-  const selectedDomain = await p4.multiselect({
-    message: `[${workspaceName}] \uB3C4\uBA54\uC778 \uADDC\uCE59 \uC120\uD0DD (\uD574\uC81C\uD558\uC5EC \uC81C\uC678)`,
-    options: domainGroups.map((group) => ({ value: group.id, label: group.id })),
-    initialValues: domainGroups.map((group) => group.id),
+  const finalRules = resolvePresetRules(preset, allRules);
+  if (finalRules.length > 0) {
+    p4.note(finalRules.map((rule) => `  \u2713 ${rule.id}`).join("\n"), `[${workspaceName}] core rules (\uC7A0\uAE08)`);
+  }
+  const { globalSkills, installableSkills } = partitionPresetSkills({
+    preset,
+    allSkills,
+    selectedTools,
+    globalInstalledSkills
+  });
+  if (globalSkills.length > 0) {
+    const globalLines = globalSkills.map(
+      ({ skill, availableTools }) => `  \u2713 ${skill.id} (${formatToolList(availableTools)})`
+    );
+    p4.note(globalLines.join("\n"), `[${workspaceName}] already available globally`);
+  }
+  if (installableSkills.length === 0) {
+    p4.note("  \uC0C8\uB85C \uC124\uCE58\uD560 reference skill\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", `[${workspaceName}] installable reference skills`);
+    return {
+      workspace: workspaceName,
+      preset,
+      finalRules,
+      finalSkillTargets: []
+    };
+  }
+  const selectedSkillIds = await p4.multiselect({
+    message: `[${workspaceName}] installable reference skills \uC120\uD0DD`,
+    options: installableSkills.map(({ skill, requestedTools, globalTools }) => ({
+      value: skill.id,
+      label: skill.id,
+      hint: globalTools.length > 0 ? `global: ${formatToolList(globalTools)} / install: ${formatToolList(requestedTools)}` : `${skill.description} / install: ${formatToolList(requestedTools)}`
+    })),
+    initialValues: installableSkills.map(({ skill }) => skill.id),
     required: false
   });
-  if (p4.isCancel(selectedDomain)) return null;
-  const selectedLogicalRuleIds = [...globalGroupIds, ...selectedDomain];
+  if (p4.isCancel(selectedSkillIds)) return null;
+  const selectedSkillSet = new Set(selectedSkillIds);
   return {
     workspace: workspaceName,
     preset,
-    finalRules: resolvePresetRules({ ...preset, rules: selectedLogicalRuleIds }, allRules)
+    finalRules,
+    finalSkillTargets: installableSkills.filter(({ skill }) => selectedSkillSet.has(skill.id)).map(({ skill, requestedTools }) => ({
+      skill,
+      requestedTools
+    }))
   };
 };
+var selectInitSkillScope = async () => {
+  const scope = await p4.select({
+    message: "\uC120\uD0DD\uB41C skills\uB97C \uC5B4\uB514\uC5D0 \uC124\uCE58\uD560\uAE4C\uC694?",
+    options: [
+      { value: "user", label: "user (global)", hint: "\uAE30\uBCF8\uAC12. \uC5EC\uB7EC \uD504\uB85C\uC81D\uD2B8\uC5D0\uC11C \uC7AC\uC0AC\uC6A9" },
+      { value: "project", label: "project", hint: "\uD604\uC7AC \uD504\uB85C\uC81D\uD2B8\uC5D0\uB9CC \uC124\uCE58" }
+    ]
+  });
+  return p4.isCancel(scope) ? null : scope;
+};
 var initCommand = async () => {
   const basePath = resolveBasePath();
+  const userBasePath = resolveUserBasePath();
   const rulesDir = resolveRulesDir();
-  p4.intro("ai-ops init");
-  const selectedTools = await p4.multiselect({
-    message: "AI \uB3C4\uAD6C\uB97C \uC120\uD0DD\uD558\uC138\uC694",
-    options: TOOL_OPTIONS,
-    required: true
-  });
-  if (p4.isCancel(selectedTools)) {
-    p4.cancel("\uCDE8\uC18C\uB428");
-    process.exit(0);
-  }
-  const isMonorepo = await p4.confirm({
-    message: "\uBAA8\uB178\uB808\uD3EC \uD504\uB85C\uC81D\uD2B8\uC785\uB2C8\uAE4C?",
-    initialValue: false
-  });
-  if (p4.isCancel(isMonorepo)) {
-    p4.cancel("\uCDE8\uC18C\uB428");
-    process.exit(0);
-  }
-  const allRules = loadAllRules(rulesDir);
-  const presets = loadPresets(resolvePresetsPath());
-  const sourceHash = computeSourceHash(rulesDir);
-  const mappings = [];
-  if (!isMonorepo) {
-    const mapping = await selectPresetAndFineTune(".", presets, allRules);
-    if (!mapping) {
-      p4.cancel("\uCDE8\uC18C\uB428");
-      process.exit(0);
+  const skillsDir = resolveSkillsDir();
+  const spinner3 = p4.spinner();
+  let spinnerStarted = false;
+  const cancelInit = (params) => {
+    if (spinnerStarted) {
+      spinner3.stop("\uC124\uCE58 \uC911\uB2E8\uB428");
+      spinnerStarted = false;
     }
-    mappings.push(mapping);
-  } else {
-    const candidates = listWorkspaceCandidates(basePath);
-    const selectedWorkspaces = await p4.multiselect({
-      message: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uB97C \uC120\uD0DD\uD558\uC138\uC694",
-      options: candidates.map((c) => ({ value: c, label: c })),
+    p4.cancel(params?.message ?? "\uCDE8\uC18C\uB428");
+    process.exit(params?.exitCode ?? 0);
+  };
+  const handleSigint = () => cancelInit({
+    message: "\uC0AC\uC6A9\uC790 \uC694\uCCAD\uC73C\uB85C init\uC774 \uC911\uB2E8\uB418\uC5C8\uC2B5\uB2C8\uB2E4.",
+    exitCode: 130
+  });
+  process.once("SIGINT", handleSigint);
+  try {
+    p4.intro("ai-ops init");
+    const selectedTools = await p4.multiselect({
+      message: "AI \uB3C4\uAD6C\uB97C \uC120\uD0DD\uD558\uC138\uC694",
+      options: TOOL_OPTIONS,
       required: true
     });
-    if (p4.isCancel(selectedWorkspaces)) {
-      p4.cancel("\uCDE8\uC18C\uB428");
-      process.exit(0);
+    if (p4.isCancel(selectedTools)) {
+      cancelInit();
     }
-    for (const ws of selectedWorkspaces) {
-      const mapping = await selectPresetAndFineTune(ws, presets, allRules);
-      if (!mapping) {
-        p4.cancel("\uCDE8\uC18C\uB428");
-        process.exit(0);
-      }
-      mappings.push(mapping);
+    const isMonorepo = await p4.confirm({
+      message: "\uBAA8\uB178\uB808\uD3EC \uD504\uB85C\uC81D\uD2B8\uC785\uB2C8\uAE4C?",
+      initialValue: false
+    });
+    if (p4.isCancel(isMonorepo)) {
+      cancelInit();
     }
-  }
-  const geminiSettingValues = selectedTools.includes("gemini") ? await promptGeminiSettings() : null;
-  const claudeSettingValues = selectedTools.includes("claude-code") ? await promptClaudeSettings() : null;
-  const wantPrettierIgnore = await promptPrettierIgnore();
-  const s = p4.spinner();
-  s.start("\uADDC\uCE59 \uC124\uCE58 \uC911...");
-  const meta = { sourceHash, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  const allInstalledFiles = [];
-  const allAppended = [];
-  for (const toolId of selectedTools) {
-    if (isMonorepo) {
-      const allRules2 = deduplicateRules(mappings.flatMap((m) => m.finalRules));
-      const workspaceMappings = mappings.map((m) => ({
-        path: m.workspace,
-        ruleIds: m.finalRules.map((r) => r.id)
-      }));
-      const renderResult = renderForTool(toolId, allRules2, workspaceMappings);
-      const actions = buildInstallPlan({ toolId, renderResult, meta });
-      const result = installFiles(basePath, actions, meta);
-      allInstalledFiles.push(...result.written);
-      allAppended.push(...result.appended);
+    const allRules = loadAllRules(rulesDir);
+    const allSkills = loadAllSkills(skillsDir);
+    const presets = loadPresets(resolvePresetsPath());
+    const sourceHash = computeSourceHash(resolveCompilerDataDir());
+    const globalInstalledSkills = readSkillRegistry(resolveSkillRegistryPath(userBasePath))?.skills ?? [];
+    const mappings = [];
+    if (!isMonorepo) {
+      const mapping = await selectPresetAndFineTune(
+        ".",
+        presets,
+        allRules,
+        allSkills,
+        selectedTools,
+        globalInstalledSkills
+      ) ?? cancelInit();
+      mappings.push(mapping);
     } else {
-      const renderResult = renderForTool(toolId, mappings[0].finalRules);
-      const actions = buildInstallPlan({ toolId, renderResult, meta });
-      const result = installFiles(basePath, actions, meta);
-      allInstalledFiles.push(...result.written);
-      allAppended.push(...result.appended);
+      const candidates = listWorkspaceCandidates(basePath);
+      const selectedWorkspaces = await p4.multiselect({
+        message: "\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4\uB97C \uC120\uD0DD\uD558\uC138\uC694",
+        options: candidates.map((candidate) => ({ value: candidate, label: candidate })),
+        required: true
+      });
+      if (p4.isCancel(selectedWorkspaces)) {
+        cancelInit();
+      }
+      for (const workspace of selectedWorkspaces) {
+        const mapping = await selectPresetAndFineTune(
+          workspace,
+          presets,
+          allRules,
+          allSkills,
+          selectedTools,
+          globalInstalledSkills
+        ) ?? cancelInit();
+        mappings.push(mapping);
+      }
     }
+    const selectedSkillTargets = deduplicateSkillTargets(mappings.flatMap((mapping) => mapping.finalSkillTargets));
+    const skillScope = selectedSkillTargets.length > 0 ? await selectInitSkillScope() : null;
+    if (selectedSkillTargets.length > 0 && skillScope === null) {
+      cancelInit();
+    }
+    const geminiSettingValues = selectedTools.includes("gemini") ? await promptGeminiSettings() : null;
+    const resolvedGeminiSettingValues = isPromptCancelled(geminiSettingValues) ? cancelInit() : geminiSettingValues;
+    const claudeSettingValues = selectedTools.includes("claude-code") ? await promptClaudeSettings() : null;
+    const resolvedClaudeSettingValues = isPromptCancelled(claudeSettingValues) ? cancelInit() : claudeSettingValues;
+    const wantPrettierIgnore = await promptPrettierIgnore();
+    const resolvedWantPrettierIgnore = isPromptCancelled(wantPrettierIgnore) ? cancelInit() : wantPrettierIgnore;
+    spinner3.start("\uADDC\uCE59 \uC124\uCE58 \uC911...");
+    spinnerStarted = true;
+    const meta = { sourceHash, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    const allInstalledFiles = [];
+    const allAppended = [];
+    const selectedRuleIds = deduplicateRules(mappings.flatMap((mapping) => mapping.finalRules)).map((rule) => rule.id);
+    let projectInstalledSkills = [];
+    if (selectedSkillTargets.length > 0 && skillScope !== null) {
+      const skillBasePath = skillScope === "project" ? basePath : userBasePath;
+      const installedSkills = selectedSkillTargets.map(({ skill, requestedTools }) => {
+        const existingUserSkill = skillScope === "user" ? findInstalledSkill(globalInstalledSkills, skill.id) : void 0;
+        const nextRequestedTools = skillScope === "user" ? mergeSkillTools({
+          existing: existingUserSkill?.tools,
+          requested: requestedTools
+        }) : requestedTools;
+        const { packages, installedSkill } = buildSkillInstallPlan({
+          skill,
+          requestedTools: nextRequestedTools,
+          scope: skillScope
+        });
+        installSkillPackages(skillBasePath, packages);
+        return installedSkill;
+      });
+      if (skillScope === "project") {
+        projectInstalledSkills = installedSkills;
+      } else {
+        const registryPath = resolveSkillRegistryPath(skillBasePath);
+        const previous = readSkillRegistry(registryPath);
+        const nextSkills = installedSkills.reduce(
+          (acc, installedSkill) => upsertInstalledSkill(acc, installedSkill),
+          previous?.skills ?? []
+        );
+        writeSkillRegistry(registryPath, {
+          skills: nextSkills,
+          cliVersion: getCliVersion(),
+          generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+      }
+    }
+    for (const toolId of selectedTools) {
+      if (isMonorepo) {
+        const allWorkspaceRules = deduplicateRules(mappings.flatMap((mapping) => mapping.finalRules));
+        const workspaceMappings = mappings.map((mapping) => ({
+          path: mapping.workspace,
+          ruleIds: mapping.finalRules.map((rule) => rule.id)
+        }));
+        const renderResult = renderForTool(toolId, allWorkspaceRules, workspaceMappings);
+        const actions = buildInstallPlan({ toolId, renderResult, meta });
+        const result = installFiles(basePath, actions, meta);
+        allInstalledFiles.push(...result.written);
+        allAppended.push(...result.appended);
+      } else {
+        const renderResult = renderForTool(toolId, mappings[0].finalRules);
+        const actions = buildInstallPlan({ toolId, renderResult, meta });
+        const result = installFiles(basePath, actions, meta);
+        allInstalledFiles.push(...result.written);
+        allAppended.push(...result.appended);
+      }
+    }
+    if (resolvedGeminiSettingValues && resolvedGeminiSettingValues.length > 0) {
+      installGeminiSettings(basePath, resolvedGeminiSettingValues);
+    }
+    if (resolvedClaudeSettingValues && resolvedClaudeSettingValues.length > 0) {
+      installClaudeSettings(basePath, resolvedClaudeSettingValues);
+    }
+    if (resolvedWantPrettierIgnore) {
+      installPrettierIgnore(basePath);
+    }
+    spinner3.stop("\uADDC\uCE59 \uC124\uCE58 \uC644\uB8CC");
+    spinnerStarted = false;
+    const workspacesRecord = isMonorepo ? Object.fromEntries(
+      mappings.map((mapping) => [
+        mapping.workspace,
+        {
+          preset: mapping.preset.id,
+          rules: mapping.finalRules.map((rule) => rule.id)
+        }
+      ])
+    ) : void 0;
+    const manifest = buildManifest({
+      tools: selectedTools,
+      scope: "project",
+      preset: !isMonorepo ? mappings[0].preset.id : void 0,
+      workspaces: workspacesRecord,
+      installedRules: selectedRuleIds,
+      installedFiles: allInstalledFiles,
+      installedSkills: projectInstalledSkills,
+      appendedFiles: allAppended,
+      settings: resolvedClaudeSettingValues || resolvedGeminiSettingValues || resolvedWantPrettierIgnore ? {
+        claude: resolvedClaudeSettingValues ? [...resolvedClaudeSettingValues] : void 0,
+        gemini: resolvedGeminiSettingValues ? [...resolvedGeminiSettingValues] : void 0,
+        prettierignore: resolvedWantPrettierIgnore || void 0
+      } : void 0,
+      cliVersion: getCliVersion(),
+      sourceHash
+    });
+    writeManifest(resolveManifestPath(basePath), manifest);
+    if (allAppended.length > 0) {
+      p4.log.info(`\uAE30\uC874 \uD30C\uC77C\uC5D0 \uC139\uC158 \uCD94\uAC00\uB428 (\uB0B4\uC6A9 \uBCF4\uC874):
+${allAppended.map((file) => `  ${file}`).join("\n")}`);
+    }
+    p4.log.success(`\uC124\uCE58\uB41C core rules: ${selectedRuleIds.length}\uAC1C`);
+    p4.log.success(`\uC124\uCE58\uB41C skills: ${selectedSkillTargets.length}\uAC1C${skillScope ? ` (${skillScope})` : ""}`);
+    if (selectedSkillTargets.length > 0 && skillScope === "user") {
+      p4.log.info("global skill\uC740 ai-ops uninstall \uB300\uC0C1\uC774 \uC544\uB2D9\uB2C8\uB2E4. ai-ops skill uninstall\uC73C\uB85C \uC81C\uAC70\uD558\uC138\uC694.");
+    }
+    p4.outro("ai-ops init \uC644\uB8CC");
+  } finally {
+    process.off("SIGINT", handleSigint);
   }
-  if (geminiSettingValues && geminiSettingValues.length > 0) {
-    installGeminiSettings(basePath, geminiSettingValues);
-  }
-  if (claudeSettingValues && claudeSettingValues.length > 0) {
-    installClaudeSettings(basePath, claudeSettingValues);
-  }
-  if (wantPrettierIgnore) {
-    installPrettierIgnore(basePath);
-  }
-  s.stop("\uADDC\uCE59 \uC124\uCE58 \uC644\uB8CC");
-  const allInstalledRuleIds = deduplicateRules(mappings.flatMap((m) => m.finalRules)).map((r) => r.id);
-  const workspacesRecord = isMonorepo ? Object.fromEntries(
-    mappings.map((m) => [m.workspace, { preset: m.preset.id, rules: m.finalRules.map((r) => r.id) }])
-  ) : void 0;
-  const manifest = buildManifest({
-    tools: selectedTools,
-    scope: "project",
-    preset: !isMonorepo ? mappings[0].preset.id : void 0,
-    workspaces: workspacesRecord,
-    installedRules: allInstalledRuleIds,
-    installedFiles: allInstalledFiles,
-    appendedFiles: allAppended,
-    settings: claudeSettingValues || geminiSettingValues || wantPrettierIgnore ? {
-      claude: claudeSettingValues ? [...claudeSettingValues] : void 0,
-      gemini: geminiSettingValues ? [...geminiSettingValues] : void 0,
-      prettierignore: wantPrettierIgnore || void 0
-    } : void 0,
-    cliVersion: getCliVersion(),
-    sourceHash
-  });
-  writeManifest(resolveManifestPath(basePath), manifest);
-  if (allAppended.length > 0) {
-    p4.log.info(`\uAE30\uC874 \uD30C\uC77C\uC5D0 \uC139\uC158 \uCD94\uAC00\uB428 (\uB0B4\uC6A9 \uBCF4\uC874):
-${allAppended.map((f) => `  ${f}`).join("\n")}`);
-  }
-  p4.log.success(`\uC124\uCE58\uB41C \uADDC\uCE59: ${allInstalledRuleIds.length}\uAC1C`);
-  p4.outro("ai-ops init \uC644\uB8CC");
 };
 
 // src/commands/update.ts
@@ -1063,11 +1681,25 @@ var updateCommand = async (opts) => {
     process.exit(1);
   }
   const rulesDir = resolveRulesDir();
-  const sourceHash = computeSourceHash(rulesDir);
+  const skillsDir = resolveSkillsDir();
+  const presetsPath = resolvePresetsPath();
+  const sourceHash = computeSourceHash(resolveCompilerDataDir());
   const cliVersion = getCliVersion();
+  const allRules = loadAllRules(rulesDir);
+  const allSkills = loadAllSkills(skillsDir);
+  const presets = loadPresets(presetsPath);
+  const resolvedRules = resolveManifestRules({
+    manifest,
+    allRules,
+    presets
+  });
+  const resolvedSkills = resolveManifestProjectSkills({
+    manifest,
+    allSkills
+  });
   const diffResult = computeDiff({
     previous: manifest,
-    currentRules: manifest.installed_rules,
+    currentRules: resolvedRules.installedRules.map((rule) => rule.id),
     currentSourceHash: sourceHash,
     currentCliVersion: cliVersion
   });
@@ -1078,16 +1710,23 @@ var updateCommand = async (opts) => {
   }
   const s = p5.spinner();
   s.start("\uADDC\uCE59 \uAC31\uC2E0 \uC911...");
-  const allRules = loadAllRules(rulesDir);
   const meta = { sourceHash, generatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   const allInstalledFiles = [];
   const allAppended = [];
+  const installedSkills = resolvedSkills.map(({ skill, requestedTools }) => {
+    const { packages, installedSkill } = buildSkillInstallPlan({
+      skill,
+      requestedTools,
+      scope: "project"
+    });
+    installSkillPackages(basePath, packages);
+    return installedSkill;
+  });
   if (manifest.workspaces) {
-    const workspaceEntries = Object.entries(manifest.workspaces);
+    const workspaceEntries = Object.entries(resolvedRules.workspaces ?? {});
     for (const toolIdStr of manifest.tools) {
       const toolId = toolIdStr;
-      const allInstalledRuleSet = new Set(manifest.installed_rules);
-      const rulesToInstall = allRules.filter((r2) => allInstalledRuleSet.has(r2.id));
+      const rulesToInstall = resolvedRules.installedRules;
       const workspaceMappings = workspaceEntries.map(([path, entry]) => ({
         path,
         ruleIds: entry.rules
@@ -1099,8 +1738,7 @@ var updateCommand = async (opts) => {
       allAppended.push(...r.appended);
     }
   } else {
-    const installedRuleSet = new Set(manifest.installed_rules);
-    const rulesToInstall = allRules.filter((r) => installedRuleSet.has(r.id));
+    const rulesToInstall = resolvedRules.installedRules;
     for (const toolIdStr of manifest.tools) {
       const toolId = toolIdStr;
       const renderResult = renderForTool(toolId, rulesToInstall);
@@ -1123,9 +1761,10 @@ var updateCommand = async (opts) => {
     tools: manifest.tools,
     scope: manifest.scope,
     preset: manifest.preset,
-    workspaces: manifest.workspaces,
-    installedRules: manifest.installed_rules,
+    workspaces: resolvedRules.workspaces,
+    installedRules: resolvedRules.installedRules.map((rule) => rule.id),
     installedFiles: allInstalledFiles.length > 0 ? allInstalledFiles : manifest.installed_files,
+    installedSkills,
     appendedFiles: allAppended.length > 0 ? allAppended : manifest.appended_files,
     settings: manifest.settings ? {
       claude: manifest.settings.claude,
@@ -1150,12 +1789,35 @@ var diffCommand = async () => {
     p6.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);
   }
-  const sourceHash = computeSourceHash(resolveRulesDir());
+  const sourceHash = computeSourceHash(resolveCompilerDataDir());
+  const allRules = loadAllRules(resolveRulesDir());
+  const allSkills = loadAllSkills(resolveSkillsDir());
+  const presets = loadPresets(resolvePresetsPath());
+  const resolvedRules = resolveManifestRules({
+    manifest,
+    allRules,
+    presets
+  });
+  const resolvedSkills = resolveManifestProjectSkills({
+    manifest,
+    allSkills
+  });
   const result = computeDiff({
     previous: manifest,
-    currentRules: manifest.installed_rules,
+    currentRules: resolvedRules.installedRules.map((rule) => rule.id),
     currentSourceHash: sourceHash
   });
+  const skillLines = resolvedSkills.map(({ skill, requestedTools }) => {
+    const { installedSkill: next } = buildSkillInstallPlan({
+      skill,
+      requestedTools,
+      scope: "project"
+    });
+    const previous = (manifest.installed_skills ?? []).find((installedSkill) => installedSkill.id === skill.id);
+    const previousHash = previous?.sourceHash ?? "legacy";
+    const changed = previousHash !== next.sourceHash;
+    return `- ${skill.id}: ${changed ? "changed" : "up-to-date"} (${previousHash} -> ${next.sourceHash})`;
+  });
   if (result.status === "up-to-date") {
     p6.log.success("\uBCC0\uACBD \uC0AC\uD56D \uC5C6\uC74C. \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4.");
   } else {
@@ -1169,39 +1831,43 @@ var diffCommand = async () => {
       p6.log.info(`\uC81C\uAC70\uB41C \uADDC\uCE59: ${result.removed.join(", ")}`);
     }
   }
+  if (skillLines.length > 0) {
+    p6.log.info(`project skills:
+${skillLines.map((line) => `  ${line}`).join("\n")}`);
+  }
   p6.outro("ai-ops diff \uC644\uB8CC");
 };
 
 // src/commands/uninstall.ts
 import * as p7 from "@clack/prompts";
-import { rmSync as rmSync5 } from "fs";
+import { rmSync as rmSync6 } from "fs";
 
 // src/lib/uninstall.ts
-import { existsSync as existsSync6, readFileSync as readFileSync8, rmSync as rmSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync6 } from "fs";
-import { resolve as resolve6, dirname as dirname5 } from "path";
+import { existsSync as existsSync8, readFileSync as readFileSync9, rmSync as rmSync5, readdirSync as readdirSync4, writeFileSync as writeFileSync8 } from "fs";
+import { resolve as resolve7, dirname as dirname7 } from "path";
 var removeFiles = (basePath, relativePaths) => {
   const deleted = [];
   const cleaned = [];
   const skipped = [];
   const notFound = [];
   for (const rel of relativePaths) {
-    const absPath = resolve6(basePath, rel);
-    if (!existsSync6(absPath)) {
+    const absPath = resolve7(basePath, rel);
+    if (!existsSync8(absPath)) {
       notFound.push(rel);
       continue;
     }
-    const content = readFileSync8(absPath, "utf-8");
+    const content = readFileSync9(absPath, "utf-8");
     if (hasAiOpsSection(content)) {
       const stripped = stripAiOpsSection(content);
       if (stripped.trim().length === 0) {
-        rmSync4(absPath);
+        rmSync5(absPath);
         deleted.push(rel);
       } else {
-        writeFileSync6(absPath, stripped, "utf-8");
+        writeFileSync8(absPath, stripped, "utf-8");
         cleaned.push(rel);
       }
     } else if (hasLegacyHeader(content)) {
-      rmSync4(absPath);
+      rmSync5(absPath);
       deleted.push(rel);
     } else {
       skipped.push(rel);
@@ -1212,12 +1878,12 @@ var removeFiles = (basePath, relativePaths) => {
 var cleanEmptyDirs = (basePath, dirs) => {
   const removed = [];
   for (const dir of dirs) {
-    const absDir = resolve6(basePath, dir);
-    if (!existsSync6(absDir)) continue;
+    const absDir = resolve7(basePath, dir);
+    if (!existsSync8(absDir)) continue;
     try {
       const entries = readdirSync4(absDir);
       if (entries.length === 0) {
-        rmSync4(absDir, { recursive: true });
+        rmSync5(absDir, { recursive: true });
         removed.push(dir);
       }
     } catch {
@@ -1228,7 +1894,7 @@ var cleanEmptyDirs = (basePath, dirs) => {
 var collectManagedDirs = (relativePaths) => {
   const dirs = /* @__PURE__ */ new Set();
   for (const rel of relativePaths) {
-    const dir = dirname5(rel);
+    const dir = dirname7(rel);
     if (dir !== ".") {
       dirs.add(dir);
     }
@@ -1251,13 +1917,20 @@ var uninstallCommand = async () => {
     ...manifest.installed_files ?? inferInstalledFiles(manifest),
     ...manifest.appended_files ?? []
   ].filter((f) => !SETTINGS_PATHS.has(f));
-  if (targetFiles.length === 0) {
+  const targetSkillDirs = (manifest.installed_skills ?? []).flatMap((skill) => skill.installed_paths);
+  if (targetFiles.length === 0 && targetSkillDirs.length === 0) {
     p7.log.warn("\uC0AD\uC81C\uD560 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
     p7.outro("ai-ops uninstall \uC644\uB8CC");
     return;
   }
-  p7.log.info(`\uC0AD\uC81C \uB300\uC0C1 \uD30C\uC77C (${targetFiles.length}\uAC1C):
+  if (targetFiles.length > 0) {
+    p7.log.info(`\uC0AD\uC81C \uB300\uC0C1 \uD30C\uC77C (${targetFiles.length}\uAC1C):
 ${targetFiles.map((f) => `  ${f}`).join("\n")}`);
+  }
+  if (targetSkillDirs.length > 0) {
+    p7.log.info(`\uC0AD\uC81C \uB300\uC0C1 skill \uB514\uB809\uD1A0\uB9AC (${targetSkillDirs.length}\uAC1C):
+${targetSkillDirs.map((f) => `  ${f}`).join("\n")}`);
+  }
   const confirmed = await p7.confirm({
     message: "\uC704 \uD30C\uC77C\uACFC manifest\uB97C \uBAA8\uB450 \uC0AD\uC81C\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
     initialValue: false
@@ -1281,9 +1954,10 @@ ${targetFiles.map((f) => `  ${f}`).join("\n")}`);
   if (prettierStatus === "deleted") settingsMessages.push("\uC0AD\uC81C: .prettierignore");
   else if (prettierStatus === "cleaned") settingsMessages.push("ai-ops \uC139\uC158 \uC81C\uAC70 (\uC0AC\uC6A9\uC790 \uB0B4\uC6A9 \uBCF4\uC874): .prettierignore");
   const result = removeFiles(basePath, targetFiles);
+  const removedSkillDirs = removeDirectories(basePath, targetSkillDirs);
   const dirs = collectManagedDirs(targetFiles);
   const removedDirs = cleanEmptyDirs(basePath, dirs);
-  rmSync5(manifestPath, { force: true });
+  rmSync6(manifestPath, { force: true });
   if (result.deleted.length > 0) {
     p7.log.success(`\uC0AD\uC81C \uC644\uB8CC (${result.deleted.length}\uAC1C):
 ${result.deleted.map((f) => `  ${f}`).join("\n")}`);
@@ -1307,6 +1981,10 @@ ${result.notFound.map((f) => `  ${f}`).join("\n")}`);
   if (removedDirs.length > 0) {
     p7.log.info(`\uBE48 \uB514\uB809\uD1A0\uB9AC \uC815\uB9AC (${removedDirs.length}\uAC1C):
 ${removedDirs.map((d) => `  ${d}`).join("\n")}`);
+  }
+  if (removedSkillDirs.length > 0) {
+    p7.log.success(`skill \uB514\uB809\uD1A0\uB9AC \uC0AD\uC81C (${removedSkillDirs.length}\uAC1C):
+${removedSkillDirs.map((d) => `  ${d}`).join("\n")}`);
   }
   if (settingsMessages.length > 0) {
     p7.log.success(`\uC124\uC815 \uD30C\uC77C \uCC98\uB9AC:
@@ -1316,19 +1994,297 @@ ${settingsMessages.map((m) => `  ${m}`).join("\n")}`);
   p7.outro("ai-ops uninstall \uC644\uB8CC");
 };
 
-// src/bin/index.ts
-var program = new Command();
-var ensureNoDeprecatedScopeFlag = (argv) => {
-  if (argv.some((arg) => arg === "--scope" || arg.startsWith("--scope="))) {
-    console.error("`--scope` is no longer supported. ai-ops is now project-only.");
-    process.exit(1);
+// src/commands/skill.ts
+import * as p8 from "@clack/prompts";
+import { rmSync as rmSync7 } from "fs";
+var resolveScopeContext = (opts) => {
+  const scope = resolveSkillScope(opts);
+  return {
+    scope,
+    basePath: scope === "project" ? resolveBasePath() : resolveUserBasePath()
+  };
+};
+var loadCompilerInputs = () => {
+  const compilerDataDir = resolveCompilerDataDir();
+  return {
+    allSkills: loadAllSkills(resolveSkillsDir()),
+    sourceHash: computeSourceHash(compilerDataDir),
+    cliVersion: getCliVersion()
+  };
+};
+var resolveSkillById = (skills, skillId) => {
+  const canonicalSkillId = resolveCanonicalSkillId(skillId);
+  const skill = skills.find((candidate) => candidate.id === canonicalSkillId);
+  if (!skill) {
+    throw new Error(`Unknown skill: ${skillId}`);
+  }
+  return skill;
+};
+var assertScopeAllowed = (skill, scope) => {
+  if (!skill.install_scopes.includes(scope)) {
+    throw new Error(`Skill ${skill.id} does not support ${scope} scope`);
   }
 };
+var writeProjectSkillState = (params) => {
+  const manifestPath = resolveManifestPath(params.basePath);
+  const previous = readManifest(manifestPath);
+  const installedSkills = params.removeSkillId ? removeInstalledSkill(previous?.installed_skills ?? [], params.removeSkillId) : params.nextSkill ? upsertInstalledSkill(previous?.installed_skills ?? [], params.nextSkill) : previous?.installed_skills ?? [];
+  const nextTools = params.nextSkill !== void 0 ? [.../* @__PURE__ */ new Set([...previous?.tools ?? [], ...params.nextSkill.tools])] : previous?.tools ?? [];
+  const hasProjectState = (previous?.installed_rules.length ?? 0) > 0 || (previous?.installed_files?.length ?? 0) > 0 || (previous?.appended_files?.length ?? 0) > 0 || installedSkills.length > 0 || previous?.settings !== void 0;
+  if (!hasProjectState) {
+    rmSync7(manifestPath, { force: true });
+    return;
+  }
+  const manifest = buildManifest({
+    tools: nextTools.length > 0 ? nextTools : params.nextSkill?.tools ?? ["codex"],
+    scope: "project",
+    preset: previous?.preset,
+    workspaces: previous?.workspaces,
+    installedRules: previous?.installed_rules ?? [],
+    installedFiles: previous?.installed_files,
+    installedSkills,
+    appendedFiles: previous?.appended_files,
+    settings: previous?.settings,
+    cliVersion: params.cliVersion,
+    sourceHash: params.sourceHash
+  });
+  writeManifest(manifestPath, manifest);
+};
+var writeUserSkillState = (params) => {
+  const registryPath = resolveSkillRegistryPath(params.basePath);
+  const previous = readSkillRegistry(registryPath);
+  const skills = params.removeSkillId ? removeInstalledSkill(previous?.skills ?? [], params.removeSkillId) : params.nextSkill ? upsertInstalledSkill(previous?.skills ?? [], params.nextSkill) : previous?.skills ?? [];
+  if (skills.length === 0) {
+    rmSync7(registryPath, { force: true });
+    return;
+  }
+  writeSkillRegistry(registryPath, {
+    skills,
+    cliVersion: params.cliVersion,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+var readInstalledSkills = (scope, basePath) => {
+  if (scope === "project") {
+    return (readManifest(resolveManifestPath(basePath))?.installed_skills ?? []).map((installedSkill) => ({
+      ...installedSkill,
+      id: resolveCanonicalSkillId(installedSkill.id)
+    }));
+  }
+  return (readSkillRegistry(resolveSkillRegistryPath(basePath))?.skills ?? []).map((installedSkill) => ({
+    ...installedSkill,
+    id: resolveCanonicalSkillId(installedSkill.id)
+  }));
+};
+var installSkill = (params) => {
+  const installedSkills = readInstalledSkills(params.scope, params.basePath);
+  const existingInstalledSkill = findInstalledSkill(installedSkills, params.skill.id);
+  const nextRequestedTools = mergeSkillTools({
+    existing: existingInstalledSkill?.tools,
+    requested: params.requestedTools
+  });
+  const { packages, installedSkill } = buildSkillInstallPlan({
+    skill: params.skill,
+    requestedTools: nextRequestedTools,
+    scope: params.scope
+  });
+  installSkillPackages(params.basePath, packages);
+  if (params.scope === "project") {
+    writeProjectSkillState({
+      basePath: params.basePath,
+      sourceHash: params.sourceHash,
+      cliVersion: params.cliVersion,
+      nextSkill: installedSkill
+    });
+  } else {
+    writeUserSkillState({
+      basePath: params.basePath,
+      cliVersion: params.cliVersion,
+      nextSkill: installedSkill
+    });
+  }
+  return installedSkill;
+};
+var skillListCommand = async (opts) => {
+  const { scope, basePath } = resolveScopeContext(opts);
+  const { allSkills } = loadCompilerInputs();
+  const installedSkills = readInstalledSkills(scope, basePath);
+  p8.intro(`ai-ops skill list (${scope})`);
+  const sections = [
+    { kind: "reference", title: "reference skills" },
+    { kind: "task", title: "task skills" }
+  ].map(({ kind, title }) => {
+    const lines = allSkills.filter((skill) => skill.kind === kind).map((skill) => {
+      const installed = findInstalledSkill(installedSkills, skill.id);
+      const suffix = installed ? `installed for ${installed.tools.join(", ")}` : "not installed";
+      return `- ${skill.id} (${skill.install_scopes.join(", ")}) - ${suffix}`;
+    });
+    if (lines.length === 0) {
+      return null;
+    }
+    return `${title}
+${lines.join("\n")}`;
+  }).filter((section) => section !== null);
+  p8.log.info(sections.join("\n\n"));
+  p8.outro("ai-ops skill list \uC644\uB8CC");
+};
+var skillInstallCommand = async (skillId, opts) => {
+  const { scope, basePath } = resolveScopeContext(opts);
+  const { allSkills, sourceHash, cliVersion } = loadCompilerInputs();
+  const skill = resolveSkillById(allSkills, skillId);
+  assertScopeAllowed(skill, scope);
+  const requestedTools = resolveRequestedTools({ requested: opts.tool, supported: skill.supported_tools });
+  p8.intro(`ai-ops skill install ${skillId}`);
+  const installedSkill = installSkill({
+    skill,
+    requestedTools,
+    scope,
+    basePath,
+    cliVersion,
+    sourceHash
+  });
+  p8.log.success(`\uC124\uCE58 \uC644\uB8CC: ${installedSkill.id} (${installedSkill.installed_paths.join(", ")})`);
+  p8.outro("ai-ops skill install \uC644\uB8CC");
+};
+var skillDiffCommand = async (skillId, opts) => {
+  const { scope, basePath } = resolveScopeContext(opts);
+  const { allSkills } = loadCompilerInputs();
+  const installedSkills = readInstalledSkills(scope, basePath);
+  const targets = skillId ? installedSkills.filter((skill) => skill.id === skillId) : installedSkills;
+  p8.intro(`ai-ops skill diff (${scope})`);
+  if (targets.length === 0) {
+    p8.log.warn("\uBE44\uAD50\uD560 \uC124\uCE58\uB41C skill\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p8.outro("ai-ops skill diff \uC644\uB8CC");
+    return;
+  }
+  const lines = targets.map((installedSkill) => {
+    const skill = resolveSkillById(allSkills, installedSkill.id);
+    const { installedSkill: next } = buildSkillInstallPlan({
+      skill,
+      requestedTools: installedSkill.tools,
+      scope
+    });
+    const changed = next.sourceHash !== installedSkill.sourceHash;
+    return `- ${installedSkill.id}: ${changed ? "changed" : "up-to-date"} (${installedSkill.sourceHash} -> ${next.sourceHash})`;
+  });
+  p8.log.info(lines.join("\n"));
+  p8.outro("ai-ops skill diff \uC644\uB8CC");
+};
+var skillUpdateCommand = async (skillId, opts) => {
+  const { scope, basePath } = resolveScopeContext(opts);
+  const { allSkills, sourceHash, cliVersion } = loadCompilerInputs();
+  const installedSkills = readInstalledSkills(scope, basePath);
+  const targets = skillId ? installedSkills.filter((skill) => skill.id === skillId) : installedSkills;
+  p8.intro(`ai-ops skill update (${scope})`);
+  if (targets.length === 0) {
+    p8.log.warn("\uAC31\uC2E0\uD560 \uC124\uCE58\uB41C skill\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p8.outro("ai-ops skill update \uC644\uB8CC");
+    return;
+  }
+  const nextInstalledSkills = targets.map((installedSkill) => {
+    const skill = resolveSkillById(allSkills, installedSkill.id);
+    const { packages, installedSkill: next } = buildSkillInstallPlan({
+      skill,
+      requestedTools: installedSkill.tools,
+      scope
+    });
+    installSkillPackages(basePath, packages);
+    return next;
+  });
+  if (scope === "project") {
+    const manifestPath = resolveManifestPath(basePath);
+    const previous = readManifest(manifestPath);
+    if (!previous) {
+      p8.log.error("project manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+      process.exit(1);
+    }
+    const untouched = (previous.installed_skills ?? []).filter(
+      (installedSkill) => !nextInstalledSkills.some((next) => next.id === installedSkill.id)
+    );
+    writeManifest(
+      manifestPath,
+      buildManifest({
+        tools: previous.tools,
+        scope: previous.scope,
+        preset: previous.preset,
+        workspaces: previous.workspaces,
+        installedRules: previous.installed_rules,
+        installedFiles: previous.installed_files,
+        installedSkills: [...untouched, ...nextInstalledSkills],
+        appendedFiles: previous.appended_files,
+        settings: previous.settings,
+        cliVersion,
+        sourceHash
+      })
+    );
+  } else {
+    const registryPath = resolveSkillRegistryPath(basePath);
+    const previous = readSkillRegistry(registryPath);
+    const untouched = (previous?.skills ?? []).filter(
+      (installedSkill) => !nextInstalledSkills.some((next) => next.id === installedSkill.id)
+    );
+    writeSkillRegistry(registryPath, {
+      skills: [...untouched, ...nextInstalledSkills],
+      cliVersion,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  p8.log.success(`\uAC31\uC2E0 \uC644\uB8CC: ${nextInstalledSkills.map((skill) => skill.id).join(", ")}`);
+  p8.outro("ai-ops skill update \uC644\uB8CC");
+};
+var skillUninstallCommand = async (skillId, opts) => {
+  const { scope, basePath } = resolveScopeContext(opts);
+  const { sourceHash, cliVersion } = loadCompilerInputs();
+  const installedSkills = readInstalledSkills(scope, basePath);
+  const installedSkill = findInstalledSkill(installedSkills, skillId);
+  p8.intro(`ai-ops skill uninstall ${skillId}`);
+  if (!installedSkill) {
+    p8.log.warn("\uC124\uCE58\uB41C skill\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+    p8.outro("ai-ops skill uninstall \uC644\uB8CC");
+    return;
+  }
+  const removed = removeDirectories(basePath, installedSkill.installed_paths);
+  if (scope === "project") {
+    writeProjectSkillState({
+      basePath,
+      sourceHash,
+      cliVersion,
+      removeSkillId: skillId
+    });
+  } else {
+    writeUserSkillState({
+      basePath,
+      cliVersion,
+      removeSkillId: skillId
+    });
+  }
+  p8.log.success(`\uC81C\uAC70 \uC644\uB8CC: ${removed.join(", ")}`);
+  p8.outro("ai-ops skill uninstall \uC644\uB8CC");
+};
+
+// src/bin/index.ts
+var program = new Command();
 program.name("ai-ops").description("AI \uC5D0\uC774\uC804\uD2B8 \uADDC\uCE59 \uC2A4\uCE90\uD3F4\uB354").version("0.1.0");
 program.command("init").description("AI \uADDC\uCE59 \uCD08\uAE30 \uC124\uCE58").action(() => initCommand());
 program.command("update").description("\uAE30\uC874 manifest \uAE30\uBC18 \uADDC\uCE59 \uAC31\uC2E0").option("--force", "\uBCC0\uACBD \uC5C6\uC5B4\uB3C4 \uAC15\uC81C \uC7AC\uC124\uCE58", false).action((opts) => updateCommand(opts));
 program.command("diff").description("\uC124\uCE58\uB41C \uADDC\uCE59\uACFC \uCD5C\uC2E0 \uC18C\uC2A4 \uBE44\uAD50").action(() => diffCommand());
 program.command("uninstall").description("\uC124\uCE58\uB41C \uADDC\uCE59 \uD30C\uC77C \uBC0F manifest \uC81C\uAC70").action(() => uninstallCommand());
-ensureNoDeprecatedScopeFlag(process.argv);
+var skillCommand = program.command("skill").description("\uC5D0\uC774\uC804\uD2B8 skill \uC124\uCE58/\uC870\uD68C/\uAC31\uC2E0");
+var applySkillScopeOptions = (command) => command.option("-g, --global", "user scope\uC5D0 \uC124\uCE58/\uC870\uD68C").option("--project", "project scope\uC5D0 \uC124\uCE58/\uC870\uD68C").option("--scope <scope>", "explicit scope (user|project)").option("--tool <tool...>", "\uB300\uC0C1 \uB3C4\uAD6C \uC9C0\uC815");
+applySkillScopeOptions(skillCommand.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C skill \uBAA9\uB85D")).action(
+  (opts) => skillListCommand(opts)
+);
+applySkillScopeOptions(skillCommand.command("install <skillId>").description("skill \uC124\uCE58")).action(
+  (skillId, opts) => skillInstallCommand(skillId, opts)
+);
+applySkillScopeOptions(skillCommand.command("diff [skillId]").description("skill \uBCC0\uACBD \uBE44\uAD50")).action(
+  (skillId, opts) => skillDiffCommand(skillId, opts)
+);
+applySkillScopeOptions(skillCommand.command("update [skillId]").description("skill \uAC31\uC2E0")).action(
+  (skillId, opts) => skillUpdateCommand(skillId, opts)
+);
+applySkillScopeOptions(skillCommand.command("uninstall <skillId>").description("skill \uC81C\uAC70")).action(
+  (skillId, opts) => skillUninstallCommand(skillId, opts)
+);
 program.parse();
 //# sourceMappingURL=index.js.map