ai-ops-cli 0.2.6 → 1.0.1

package/dist/bin/index.js

@@ -4,7 +4,7 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import * as p3 from "@clack/prompts";
+import * as p2 from "@clack/prompts";
 
 // src/core/schemas/rule.schema.ts
 import { z } from "zod";
@@ -46,17 +46,12 @@ 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),
@@ -74,7 +69,6 @@ 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();
@@ -87,7 +81,6 @@ 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
@@ -113,43 +106,216 @@ var SkillRegistrySchema = z5.object({
   generatedAt: z5.string().datetime({ offset: true })
 }).strict();
 
-// src/core/schemas/manifest.schema.ts
+// src/core/schemas/subagent.schema.ts
+import { z as z7 } from "zod";
+
+// src/core/schemas/project-layer.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()
+var ProjectLayerToolSchema = z6.enum(["claude-code", "codex", "gemini"]);
+var ProjectLayerDocumentStatusSchema = z6.enum(["Active", "Reserved", "Draft", "Archived"]);
+var ShortHashSchema = z6.string().regex(/^[a-f0-9]{6}$/, "hash must be 6 lowercase hex chars");
+var isSafeProjectLayerPath = (value) => {
+  if (value.length === 0) return false;
+  if (value.includes("\0")) return false;
+  if (value.includes("\\")) return false;
+  if (value.startsWith("/")) return false;
+  if (/^[A-Za-z]:/.test(value)) return false;
+  const segments = value.split("/");
+  return segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+};
+var ProjectLayerPathSchema = z6.string().min(1).refine(isSafeProjectLayerPath, "path must be a safe project-relative path");
+var ProjectLayerFrontmatterSchema = z6.object({
+  status: ProjectLayerDocumentStatusSchema,
+  layer: z6.string().min(1),
+  owner: z6.string().min(1),
+  read_when: z6.array(z6.string().min(1)).min(1),
+  update_when: z6.array(z6.string().min(1)).min(1)
+}).strict();
+var ProjectLayerManagedFileSchema = z6.object({
+  path: ProjectLayerPathSchema,
+  sourceHash: ShortHashSchema
+}).strict();
+var ProjectLayerProjectFileSchema = z6.object({
+  path: ProjectLayerPathSchema,
+  templateHash: ShortHashSchema,
+  created: z6.boolean()
+}).strict();
+var ProjectLayerPackFileRecordSchema = z6.object({
+  path: ProjectLayerPathSchema,
+  sourceHash: ShortHashSchema
+}).strict();
+var ProjectLayerPackRecordSchema = z6.object({
+  id: z6.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+  sourceHash: ShortHashSchema,
+  documents: z6.array(ProjectLayerPackFileRecordSchema),
+  files: z6.array(ProjectLayerPackFileRecordSchema),
+  installedAt: z6.string().datetime({ offset: true })
+}).strict();
+var ProjectLayerManifestSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  kind: z6.literal("project-operating-layer"),
+  tools: z6.array(ProjectLayerToolSchema).min(1),
+  managed_files: z6.array(ProjectLayerManagedFileSchema),
+  project_files: z6.array(ProjectLayerProjectFileSchema),
+  packs: z6.array(ProjectLayerPackRecordSchema).default([]),
+  settings: z6.record(z6.unknown()),
+  sourceHash: ShortHashSchema,
+  cliVersion: z6.string().min(1),
+  generatedAt: z6.string().datetime({ offset: true })
+}).strict();
+var ProjectLayerContextDocumentSchema = ProjectLayerFrontmatterSchema.extend({
+  path: ProjectLayerPathSchema,
+  contentHash: ShortHashSchema
+}).strict();
+var ProjectLayerContextIndexSchema = z6.object({
+  schemaVersion: z6.literal(1),
+  kind: z6.literal("context-layer-index"),
+  documents: z6.array(ProjectLayerContextDocumentSchema),
+  generatedAt: z6.string().datetime({ offset: true })
+}).strict();
+
+// src/core/subagent-paths.ts
+import { join } from "path";
+var SUBAGENT_TOOL_OUTPUTS = {
+  "claude-code": {
+    dir: ".claude/agents",
+    extension: ".md"
+  },
+  codex: {
+    dir: ".codex/agents",
+    extension: ".toml"
+  },
+  gemini: {
+    dir: ".gemini/agents",
+    extension: ".md"
+  }
+};
+var buildSubagentRelativePath = (subagentId, toolId) => {
+  const output = SUBAGENT_TOOL_OUTPUTS[toolId];
+  return join(output.dir, `${subagentId}${output.extension}`);
+};
+
+// src/core/schemas/subagent.schema.ts
+var SubagentIdSchema = z7.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
+var SubagentMarkdownFrontmatterSchema = z7.object({
+  name: SubagentIdSchema,
+  description: z7.string().min(1)
+}).passthrough();
+var TomlValueSchema = z7.union([z7.string(), z7.number(), z7.boolean(), z7.array(z7.string())]);
+var SubagentInstalledPathSchema = z7.string().min(1).refine(isSafeProjectLayerPath, "installed path must be safe relative path");
+var CodexSubagentFrontmatterSchema = z7.object({
+  name: SubagentIdSchema,
+  description: z7.string().min(1),
+  skill_names: z7.array(SubagentIdSchema).optional()
+}).catchall(TomlValueSchema);
+var InstalledSubagentSchema = z7.object({
+  id: SubagentIdSchema,
+  tools: z7.array(SkillToolSchema).min(1),
+  installed_paths: z7.array(SubagentInstalledPathSchema).min(1),
+  sourceHash: z7.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars")
+}).strip().superRefine((subagent, ctx) => {
+  const expectedPaths = new Set(subagent.tools.map((tool) => buildSubagentRelativePath(subagent.id, tool)));
+  const installedPaths = new Set(subagent.installed_paths);
+  if (installedPaths.size !== subagent.installed_paths.length) {
+    ctx.addIssue({
+      code: z7.ZodIssueCode.custom,
+      path: ["installed_paths"],
+      message: "installed_paths must not contain duplicates"
+    });
+    return;
+  }
+  if (installedPaths.size !== expectedPaths.size) {
+    ctx.addIssue({
+      code: z7.ZodIssueCode.custom,
+      path: ["installed_paths"],
+      message: "installed_paths must match id and tools"
+    });
+    return;
+  }
+  for (const installedPath of installedPaths) {
+    if (!expectedPaths.has(installedPath)) {
+      ctx.addIssue({
+        code: z7.ZodIssueCode.custom,
+        path: ["installed_paths"],
+        message: "installed_paths must match id and tools"
+      });
+      return;
+    }
+  }
+});
+
+// src/core/schemas/subagent-catalog.schema.ts
+import { z as z8 } from "zod";
+var SubagentCatalogPathSchema = z8.string().regex(
+  /^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/,
+  "source_path must be relative kebab-case path"
+);
+var SubagentCatalogEntrySchema = z8.object({
+  id: SubagentIdSchema,
+  supported_tools: z8.array(SkillToolSchema).min(1),
+  source_path: SubagentCatalogPathSchema
+}).strict();
+var SubagentCatalogSchema = z8.object({
+  subagents: z8.array(SubagentCatalogEntrySchema)
+}).strict();
+
+// src/core/schemas/subagent-manifest.schema.ts
+import { z as z9 } from "zod";
+var SubagentManifestSchema = z9.object({
+  subagents: z9.array(InstalledSubagentSchema),
+  cliVersion: z9.string().optional(),
+  generatedAt: z9.string().datetime({ offset: true })
+}).strict();
+
+// src/core/schemas/pack.schema.ts
+import { z as z10 } from "zod";
+var PackIdSchema = z10.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
+var PackSourcePathSchema = z10.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/, "source_path must be relative kebab-case path");
+var PackCatalogEntrySchema = z10.object({
+  id: PackIdSchema,
+  source_path: PackSourcePathSchema
+}).strict();
+var PackCatalogSchema = z10.object({
+  packs: z10.array(PackCatalogEntrySchema)
+}).strict();
+
+// src/core/schemas/manifest.schema.ts
+import { z as z11 } from "zod";
+var SettingsConfigSchema = z11.object({
+  claude: z11.array(z11.string().min(1)).optional(),
+  gemini: z11.array(z11.string().min(1)).optional(),
+  prettierignore: z11.boolean().optional()
 }).strict();
-var WorkspaceEntrySchema = z6.object({
-  preset: z6.string().min(1),
-  rules: z6.array(z6.string().min(1))
+var WorkspaceEntrySchema = z11.object({
+  preset: z11.string().min(1),
+  rules: z11.array(z11.string().min(1))
 }).strict();
-var ManifestSchema = z6.object({
-  tools: z6.array(z6.string().min(1)).min(1),
-  scope: z6.literal("project"),
+var ManifestSchema = z11.object({
+  tools: z11.array(z11.string().min(1)).min(1),
+  scope: z11.literal("project"),
   /** 비모노레포 단일 preset */
-  preset: z6.string().min(1).optional(),
+  preset: z11.string().min(1).optional(),
   /** 모노레포: workspace path → { preset, rules } */
-  workspaces: z6.record(z6.string(), WorkspaceEntrySchema).optional(),
-  installed_rules: z6.array(z6.string().min(1)),
+  workspaces: z11.record(z11.string(), WorkspaceEntrySchema).optional(),
+  installed_rules: z11.array(z11.string().min(1)),
   /** 실제 디스크에 쓰여진 파일 상대 경로 목록 (uninstall용). 기존 manifest 호환성 위해 optional */
-  installed_files: z6.array(z6.string().min(1)).optional(),
+  installed_files: z11.array(z11.string().min(1)).optional(),
   /** skill 설치 루트 디렉토리 목록 */
-  installed_skills: z6.array(InstalledSkillSchema).optional(),
+  installed_skills: z11.array(InstalledSkillSchema).optional(),
   /** non-managed 파일에 섹션을 append한 경우 추적 (uninstall 시 섹션만 제거) */
-  appended_files: z6.array(z6.string().min(1)).optional(),
+  appended_files: z11.array(z11.string().min(1)).optional(),
   /** init 시 선택된 settings 항목 — update 시 재생성에 사용 */
   settings: SettingsConfigSchema.optional(),
   /** init/update 실행 시점의 CLI 패키지 버전 — 버전 변경 감지에 사용 */
-  cliVersion: z6.string().optional(),
+  cliVersion: z11.string().optional(),
   /** SSOT 데이터 파일들의 deterministic SHA-256 해시 (6자리 hex). diff/update 판단 기준 */
-  sourceHash: z6.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
-  generatedAt: z6.string().datetime({ offset: true })
+  sourceHash: z11.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
+  generatedAt: z11.string().datetime({ offset: true })
 }).strict();
 
 // src/core/loader.ts
 import { readFileSync, readdirSync } from "fs";
-import { join, resolve } from "path";
+import { join as join2, resolve } from "path";
 import { parse as parse2 } from "yaml";
 
 // src/core/frontmatter.ts
@@ -165,68 +331,83 @@ var parseMarkdownFrontmatter = (content) => {
   };
 };
 
-// src/core/loader.ts
-var sortRulesByPriority = (rules) => [...rules].sort((a, b) => b.priority - a.priority);
-var deduplicateRulesById = (rules) => {
-  const seen = /* @__PURE__ */ new Set();
-  return rules.filter((rule) => {
-    if (seen.has(rule.id)) return false;
-    seen.add(rule.id);
-    return true;
-  });
-};
-var resolveRuleById = (ruleId, allRules, context) => {
-  const found = allRules.find((rule) => rule.id === ruleId);
-  if (!found) {
-    const suffix = context ? ` (from ${context})` : "";
-    throw new Error(`Rule not found: ${ruleId}${suffix}`);
+// src/core/subagent-toml.ts
+var parseTomlValue = (value) => {
+  const trimmed = value.trim();
+  if (trimmed.startsWith('"') || trimmed.startsWith("[")) {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed === "string") {
+      return parsed;
+    }
+    if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) {
+      return parsed;
+    }
+    throw new Error(`Unsupported TOML value: ${value}`);
   }
-  return found;
-};
-var parseRawPresets = (raw) => Object.entries(raw).map(([id, value]) => PresetSchema.parse({ id, ...value }));
-var resolvePresetRules = (preset, allRules) => {
-  const resolved = preset.rules.map((ruleId) => resolveRuleById(ruleId, allRules, preset.id));
-  return sortRulesByPriority(deduplicateRulesById(resolved));
+  if (trimmed === "true") return true;
+  if (trimmed === "false") return false;
+  const numericValue = Number(trimmed);
+  if (Number.isFinite(numericValue)) {
+    return numericValue;
+  }
+  throw new Error(`Unsupported TOML value: ${value}`);
 };
-var resolvePresetSkills = (preset, allSkills) => {
-  return allSkills.filter((skill) => skill.included_in_presets.includes(preset.id)).sort((a, b) => a.id.localeCompare(b.id));
+var parseFlatToml = (content) => {
+  const result = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#")) {
+      continue;
+    }
+    const match = trimmed.match(/^([A-Za-z0-9_-]+)\s*=\s*(.+)$/);
+    if (!match) {
+      throw new Error(`Unsupported TOML line: ${line}`);
+    }
+    const [, key, value] = match;
+    result[key] = parseTomlValue(value);
+  }
+  return result;
 };
-var loadRuleFile = (filePath) => {
-  const raw = readFileSync(filePath, "utf-8");
-  return RuleSchema.parse(parse2(raw));
+var renderTomlValue = (value) => {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
 };
+var renderFlatToml = (entries) => entries.map(([key, value]) => `${key} = ${renderTomlValue(value)}`).join("\n");
+
+// src/core/loader.ts
 var loadSkillDirectoryFiles = (skillDir) => {
   const files = [];
   const walk = (relativeDir = "") => {
-    const absDir = relativeDir.length > 0 ? join(skillDir, relativeDir) : skillDir;
+    const absDir = relativeDir.length > 0 ? join2(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;
+      const nextRelativePath = relativeDir.length > 0 ? join2(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         walk(nextRelativePath);
         continue;
       }
       files.push({
         path: nextRelativePath,
-        content: readFileSync(join(skillDir, nextRelativePath), "utf-8")
+        content: readFileSync(join2(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 skillMdPath = join2(directory, "SKILL.md");
     const rawSkillMd = readFileSync(skillMdPath, "utf-8");
     const { frontmatter } = parseMarkdownFrontmatter(rawSkillMd);
     const parsed = SkillFrontmatterSchema.parse(frontmatter);
@@ -242,7 +423,6 @@ var loadAllSkills = (skillsDir) => {
       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,
@@ -250,191 +430,69 @@ var loadAllSkills = (skillsDir) => {
     };
   });
 };
-var loadPresets = (presetsPath) => {
-  const raw = readFileSync(presetsPath, "utf-8");
-  const data = parse2(raw);
-  return parseRawPresets(data);
-};
-
-// src/core/renderer.ts
-import { join as join2 } from "path";
-
-// src/core/tool-output.ts
-var GLOBAL_CATEGORIES = ["persona", "communication", "philosophy", "convention", "standard"];
-var CLAUDE_CODE_PATH_GLOBS = {
-  typescript: ["**/*.ts", "**/*.tsx"],
-  "react-typescript": ["**/*.tsx", "**/*.jsx"],
-  nextjs: ["**/app/**", "next.config.*", "**/middleware.ts"],
-  nestjs: ["**/*.module.ts", "**/*.controller.ts", "**/*.service.ts"],
-  "nestjs-graphql": ["**/*.resolver.ts"],
-  "graphql-core": ["**/*.graphql", "**/*.gql"],
-  "graphql-client-web": ["**/*.graphql", "**/*.gql", "**/*.tsx", "**/*.ts"],
-  "graphql-client-app": ["**/*.graphql", "**/*.gql", "lib/**/*.dart"],
-  "graphql-server": ["**/*.graphql", "**/*.gql", "**/*.resolver.ts"],
-  "prisma-postgresql": ["prisma/**", "**/*.prisma"],
-  "shadcn-ui": ["**/components/ui/**"],
-  flutter: ["lib/**/*.dart"],
-  python: ["**/*.py"],
-  fastapi: ["**/routers/**", "**/main.py"],
-  sqlalchemy: ["**/models/**/*.py", "alembic/**"],
-  "data-pipeline-python": ["**/pipelines/**", "**/etl/**"],
-  "ai-llm-python": ["**/agents/**", "**/chains/**"],
-  "libs-frontend-web": ["**/*.tsx", "**/*.ts"],
-  "libs-frontend-app": ["lib/**/*.dart"],
-  "libs-backend-ts": ["**/*.ts"],
-  "libs-backend-python": ["**/*.py"]
-};
-var TOOL_OUTPUT_MAP = {
-  "claude-code": {
-    mode: "multi-file",
-    rulesDir: ".claude/rules",
-    fileExtension: ".md",
-    // single: path-scoped (paths: frontmatter) / monorepo: hierarchical ({workspace}/CLAUDE.md)
-    contextStrategy: "hybrid"
-  },
-  codex: {
-    mode: "multi-file",
-    dir: "",
-    rootFileName: "AGENTS.md",
-    // global 룰
-    domainFileName: "AGENTS.override.md",
-    // domain 룰 (하위 폴더)
-    contextStrategy: "hierarchical"
-    // 루트 + 하위 폴더 JIT
-  },
-  gemini: {
-    mode: "multi-file",
-    dir: "",
-    rootFileName: "GEMINI.md",
-    // global 룰 (루트)
-    domainFileName: "GEMINI.md",
-    // domain 룰 (하위 폴더)
-    contextStrategy: "hierarchical"
-    // 루트 + 하위 폴더 JIT
+var readRequiredTextFile = (filePath) => {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch (error) {
+    const cause = error instanceof Error ? `: ${error.message}` : "";
+    throw new Error(`Required subagent source file is missing: ${filePath}${cause}`);
   }
 };
-
-// src/core/renderer.ts
-var ruleIdToTitle = (id) => id.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-var renderDecisionTable = (entries) => {
-  const escape = (s) => s.replace(/\|/g, "|");
-  const hasAvoid = entries.some((e) => e.avoid !== void 0);
-  const header = hasAvoid ? "| When | Then | Avoid |\n|------|------|-------|" : "| When | Then |\n|------|------|";
-  const rows = entries.map((e) => {
-    const when = escape(e.when);
-    const then = escape(e.then);
-    if (hasAvoid) {
-      const avoid = e.avoid ? escape(e.avoid) : "";
-      return `| ${when} | ${then} | ${avoid} |`;
-    }
-    return `| ${when} | ${then} |`;
-  });
-  return [header, ...rows].join("\n");
-};
-var renderRuleToMarkdown = (rule) => {
-  const sections = [`# ${ruleIdToTitle(rule.id)}`];
-  if (rule.content.constraints.length > 0) {
-    sections.push("## Constraints");
-    sections.push(rule.content.constraints.map((c) => `- ${c}`).join("\n"));
-  }
-  if (rule.content.guidelines.length > 0) {
-    sections.push("## Guidelines");
-    sections.push(rule.content.guidelines.map((g) => `- ${g}`).join("\n"));
-  }
-  if (rule.content.decision_table && rule.content.decision_table.length > 0) {
-    sections.push("## Decision Table");
-    sections.push(renderDecisionTable(rule.content.decision_table));
-  }
-  return sections.join("\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 = [];
-  const domain = [];
-  for (const rule of rules) {
-    if (isGlobalRule(rule)) {
-      global.push(rule);
-    } else {
-      domain.push(rule);
-    }
+var assertSubagentFrontmatterName = (params) => {
+  if (params.name !== params.id) {
+    throw new Error(`Subagent ${params.tool} frontmatter name mismatch: ${params.id} != ${params.name}`);
   }
-  return { global, domain };
 };
-var renderFrontmatter = (paths) => {
-  const lines = paths.map((p9) => `  - "${p9}"`).join("\n");
-  return `---
-paths:
-${lines}
----`;
+var loadSubagentCatalog = (subagentsDir) => SubagentCatalogSchema.parse(JSON.parse(readFileSync(resolve(subagentsDir, "subagent-registry.json"), "utf-8")));
+var loadAllSubagents = (subagentsDir) => {
+  const catalog = loadSubagentCatalog(subagentsDir);
+  const entries = [...catalog.subagents].sort((a, b) => a.id.localeCompare(b.id));
+  return entries.map((entry) => {
+    const directory = resolve(subagentsDir, entry.source_path);
+    const prompt = readRequiredTextFile(join2(directory, "PROMPT.md"));
+    const claudeRaw = readRequiredTextFile(join2(directory, "claude.frontmatter.yaml"));
+    const codexRaw = readRequiredTextFile(join2(directory, "codex.frontmatter.toml"));
+    const geminiRaw = readRequiredTextFile(join2(directory, "gemini.frontmatter.yaml"));
+    const claude = SubagentMarkdownFrontmatterSchema.parse(parse2(claudeRaw));
+    const codex = CodexSubagentFrontmatterSchema.parse(parseFlatToml(codexRaw));
+    const gemini = SubagentMarkdownFrontmatterSchema.parse(parse2(geminiRaw));
+    assertSubagentFrontmatterName({ id: entry.id, tool: "claude", name: claude.name });
+    assertSubagentFrontmatterName({ id: entry.id, tool: "codex", name: codex.name });
+    assertSubagentFrontmatterName({ id: entry.id, tool: "gemini", name: gemini.name });
+    return {
+      id: entry.id,
+      supported_tools: [...entry.supported_tools],
+      source_path: entry.source_path,
+      directory,
+      prompt,
+      frontmatter: {
+        claude: {
+          raw: claudeRaw,
+          parsed: claude
+        },
+        codex: {
+          raw: codexRaw,
+          parsed: codex
+        },
+        gemini: {
+          raw: geminiRaw,
+          parsed: gemini
+        }
+      }
+    };
+  });
 };
-var renderClaudeCodeRule = (rule) => {
-  const globs = CLAUDE_CODE_PATH_GLOBS[rule.id];
-  if (!isGlobalRule(rule) && globs !== void 0) {
-    return `${renderFrontmatter(globs)}
 
-${renderRuleToMarkdown(rule)}`;
-  }
-  return renderRuleToMarkdown(rule);
-};
-var renderForTool = (toolId, rules, workspaceMappings) => {
-  const config = TOOL_OUTPUT_MAP[toolId];
-  if (toolId === "claude-code") {
-    const { rulesDir, fileExtension } = config;
-    if (!workspaceMappings || workspaceMappings.length === 0) {
-      const files = rules.map((rule) => ({
-        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: join2(rulesDir, `${rule.id}${fileExtension}`),
-      content: renderRuleToMarkdown(rule)
-      // global은 frontmatter 불필요
-    }));
-    const workspaceFiles = [];
-    for (const ws of workspaceMappings) {
-      const wsRules = domain2.filter((r) => ws.ruleIds.includes(r.id));
-      if (wsRules.length === 0) continue;
-      workspaceFiles.push({
-        relativePath: join2(ws.path, "CLAUDE.md"),
-        content: renderRulesToMarkdown(wsRules)
-      });
-    }
-    return { tool: "claude-code", files: [...globalFiles, ...workspaceFiles] };
-  }
-  if (!workspaceMappings || workspaceMappings.length === 0) {
-    const rootContent2 = renderRulesToMarkdown(rules);
-    const domainFiles2 = [];
-    if (toolId === "codex") return { tool: "codex", rootContent: rootContent2, domainFiles: domainFiles2 };
-    return { tool: "gemini", rootContent: rootContent2, domainFiles: domainFiles2 };
-  }
-  const { global, domain } = partitionRules(rules);
-  const rootContent = renderRulesToMarkdown(global);
-  const domainFiles = [];
-  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)
-    });
-  }
-  if (toolId === "codex") {
-    return { tool: "codex", rootContent, domainFiles };
-  }
-  return { tool: "gemini", rootContent, domainFiles };
-};
+// src/core/renderer.ts
+import { join as join3 } from "path";
 
 // src/core/skill-renderer.ts
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/core/source-hash.ts
 import { createHash } from "crypto";
 import { existsSync, readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { dirname, join as join3, resolve as resolve2 } from "path";
+import { dirname, join as join4, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var getCliVersion = () => {
@@ -447,68 +505,8 @@ var getCliVersion = () => {
   }
 };
 var computeHash = (contents) => createHash("sha256").update(contents.join("")).digest("hex").slice(0, 6);
-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,
-  preset: params.preset,
-  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,
-    prettierignore: params.settings.prettierignore
-  } : void 0,
-  cliVersion: params.cliVersion,
-  sourceHash: params.sourceHash,
-  generatedAt: (/* @__PURE__ */ new Date()).toISOString()
-});
+var computeInstalledSubagentHash = (params) => computeHash([params.id, params.prompt, ...[...params.tools].sort(), ...[...params.metadataFiles].sort()]);
 
 // src/core/skill-renderer.ts
 var AGENT_SKILLS_DIR = ".agents/skills";
@@ -516,10 +514,10 @@ 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));
+    dirs.push(join5(AGENT_SKILLS_DIR, skillId));
   }
   if (toolIds.includes("claude-code")) {
-    dirs.push(join4(CLAUDE_SKILLS_DIR, skillId));
+    dirs.push(join5(CLAUDE_SKILLS_DIR, skillId));
   }
   return dirs;
 };
@@ -541,7 +539,7 @@ var buildSkillInstallPlan = (params) => {
   });
   const packages = rootDirs.map((rootDir) => {
     const files = params.skill.files.map((file) => ({
-      relativePath: join4(rootDir, file.path),
+      relativePath: join5(rootDir, file.path),
       content: file.content
     }));
     return {
@@ -556,15 +554,137 @@ var buildSkillInstallPlan = (params) => {
       id: params.skill.id,
       kind: params.skill.kind,
       tools: selectedTools,
-      scope: params.scope,
       installed_paths: rootDirs,
       sourceHash: skillHash
     }
   };
 };
 
+// src/core/subagent-renderer.ts
+import { resolve as resolve3 } from "path";
+var normalizeSelectedTools2 = (subagent, requestedTools) => {
+  const supportedToolSet = new Set(subagent.supported_tools);
+  return requestedTools.filter((toolId) => supportedToolSet.has(toolId));
+};
+var renderMarkdownSubagent = (params) => `---
+${params.rawFrontmatter.trimEnd()}
+---
+
+${params.prompt.trimEnd()}
+`;
+var getCodexTomlEntries = (frontmatter) => Object.entries(frontmatter).filter(
+  (entry) => entry[0] !== "skill_names" && (typeof entry[1] === "string" || typeof entry[1] === "number" || typeof entry[1] === "boolean" || Array.isArray(entry[1]) && entry[1].every((item) => typeof item === "string"))
+);
+var renderCodexSubagent = (params) => {
+  const metadata = renderFlatToml(getCodexTomlEntries(params.frontmatter));
+  const skills = (params.frontmatter.skill_names ?? []).map((skillName) => {
+    const skillPath = resolve3(params.userBasePath, ".agents", "skills", skillName, "SKILL.md");
+    return `[[skills.config]]
+path = ${JSON.stringify(skillPath)}
+enabled = true`;
+  });
+  const sections = [
+    metadata,
+    `developer_instructions = ${JSON.stringify(params.prompt.trimEnd())}`,
+    ...skills
+  ].filter((section) => section.length > 0);
+  return sections.join("\n\n") + "\n";
+};
+var renderSubagentForTool = (params) => {
+  if (params.toolId === "claude-code") {
+    return renderMarkdownSubagent({
+      rawFrontmatter: params.subagent.frontmatter.claude.raw,
+      prompt: params.subagent.prompt
+    });
+  }
+  if (params.toolId === "gemini") {
+    return renderMarkdownSubagent({
+      rawFrontmatter: params.subagent.frontmatter.gemini.raw,
+      prompt: params.subagent.prompt
+    });
+  }
+  return renderCodexSubagent({
+    frontmatter: params.subagent.frontmatter.codex.parsed,
+    prompt: params.subagent.prompt,
+    userBasePath: params.userBasePath
+  });
+};
+var getSelectedMetadataFiles = (subagent, selectedTools) => selectedTools.map((toolId) => {
+  if (toolId === "claude-code") return `claude:${subagent.frontmatter.claude.raw}`;
+  if (toolId === "gemini") return `gemini:${subagent.frontmatter.gemini.raw}`;
+  return `codex:${subagent.frontmatter.codex.raw}`;
+});
+var getStringArray = (value) => {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.filter((item) => typeof item === "string");
+};
+var buildRequiredSubagentSkills = (params) => {
+  const required = [];
+  if (params.selectedTools.includes("codex")) {
+    for (const skillName of params.subagent.frontmatter.codex.parsed.skill_names ?? []) {
+      required.push({
+        tool: "codex",
+        skillName,
+        path: resolve3(params.userBasePath, ".agents", "skills", skillName, "SKILL.md")
+      });
+    }
+  }
+  if (params.selectedTools.includes("claude-code")) {
+    for (const skillName of getStringArray(params.subagent.frontmatter.claude.parsed["skills"])) {
+      required.push({
+        tool: "claude-code",
+        skillName,
+        path: resolve3(params.userBasePath, ".claude", "skills", skillName, "SKILL.md")
+      });
+    }
+  }
+  return required;
+};
+var buildSubagentInstallPlan = (params) => {
+  const selectedTools = normalizeSelectedTools2(params.subagent, params.requestedTools);
+  if (selectedTools.length === 0) {
+    throw new Error(`Subagent ${params.subagent.id} does not support the requested tools`);
+  }
+  const files = selectedTools.map((toolId) => ({
+    relativePath: buildSubagentRelativePath(params.subagent.id, toolId),
+    content: renderSubagentForTool({
+      subagent: params.subagent,
+      toolId,
+      userBasePath: params.userBasePath
+    })
+  }));
+  const subagentHash = computeInstalledSubagentHash({
+    id: params.subagent.id,
+    tools: selectedTools,
+    prompt: params.subagent.prompt,
+    metadataFiles: getSelectedMetadataFiles(params.subagent, selectedTools)
+  });
+  return {
+    packages: [
+      {
+        subagentId: params.subagent.id,
+        files
+      }
+    ],
+    installedSubagent: {
+      id: params.subagent.id,
+      tools: selectedTools,
+      installed_paths: files.map((file) => file.relativePath),
+      sourceHash: subagentHash
+    },
+    requiredSkills: buildRequiredSubagentSkills({
+      subagent: params.subagent,
+      selectedTools,
+      userBasePath: params.userBasePath
+    })
+  };
+};
+
 // src/core/managed-header.ts
 var MANAGED_MARKER = "<!-- managed by ai-ops -->";
+var META_PATTERN = /^<!-- sourceHash: ([a-f0-9]{6}) \| generatedAt: (.+) -->$/;
 var SECTION_START = "<!-- ai-ops:start -->";
 var SECTION_END = "<!-- ai-ops:end -->";
 var hasLegacyHeader = (content) => content.includes(MANAGED_MARKER);
@@ -585,6 +705,15 @@ var stripAiOpsSection = (content) => {
   const after = content.slice(endIdx + SECTION_END.length).trimStart();
   return before + (after ? "\n\n" + after : "") + "\n";
 };
+var extractAiOpsSectionContent = (content) => {
+  const startIdx = content.indexOf(SECTION_START);
+  const endIdx = content.indexOf(SECTION_END);
+  if (startIdx === -1 || endIdx === -1) return null;
+  const section = content.slice(startIdx + SECTION_START.length, endIdx).trim();
+  const lines = section.split("\n");
+  const [, ...contentLines] = lines;
+  return contentLines.join("\n").trimStart();
+};
 var replaceAiOpsSection = (existing, newSection) => {
   const startIdx = existing.indexOf(SECTION_START);
   const endIdx = existing.indexOf(SECTION_END);
@@ -593,152 +722,33 @@ var replaceAiOpsSection = (existing, newSection) => {
   const after = existing.slice(endIdx + SECTION_END.length).trimStart();
   return [before, newSection, after].filter(Boolean).join("\n\n") + "\n";
 };
+var parseAiOpsMeta = (content) => {
+  const startIdx = content.indexOf(SECTION_START);
+  if (startIdx === -1) return null;
+  const lines = content.slice(startIdx).split("\n");
+  const metaLine = lines[1] ?? "";
+  const match = META_PATTERN.exec(metaLine);
+  if (!match) return null;
+  return { sourceHash: match[1], generatedAt: match[2] };
+};
 
 // src/core/manifest-io.ts
 import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-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) => join5(basePath, MANIFEST_FILENAME);
-var readManifest = (manifestPath) => {
-  let raw;
-  try {
-    raw = readFileSync3(manifestPath, "utf-8");
-  } catch {
-    return null;
-  }
-  return parseManifest(raw);
-};
-var writeManifest = (manifestPath, manifest) => {
-  mkdirSync(dirname2(manifestPath), { recursive: true });
-  writeFileSync(manifestPath, serializeManifest(manifest), "utf-8");
-};
+import { dirname as dirname2, join as join6 } from "path";
 
 // 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";
+import { dirname as dirname3, join as join7 } 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 resolveSkillRegistryPath = (userBasePath) => join7(userBasePath, ".ai-ops", SKILL_REGISTRY_FILENAME);
 var readSkillRegistry = (registryPath) => {
   let raw;
   try {
@@ -753,1245 +763,1356 @@ var writeSkillRegistry = (registryPath, registry) => {
   writeFileSync2(registryPath, serializeSkillRegistry(registry), "utf-8");
 };
 
-// src/core/diff.ts
-var computeDiff = (params) => {
-  const { previous, currentRules, currentSourceHash, currentCliVersion } = params;
-  const previousSet = new Set(previous.installed_rules);
-  const currentSet = new Set(currentRules);
-  const added = currentRules.filter((id) => !previousSet.has(id));
-  const removed = previous.installed_rules.filter((id) => !currentSet.has(id));
-  const sourceChanged = previous.sourceHash !== currentSourceHash;
-  const versionChanged = previous.cliVersion !== void 0 && currentCliVersion !== void 0 && previous.cliVersion !== currentCliVersion;
-  const status = added.length > 0 || removed.length > 0 || sourceChanged || versionChanged ? "changed" : "up-to-date";
-  return { status, added, removed, sourceChanged, versionChanged };
-};
-
-// src/core/install-plan.ts
-import { join as join7 } from "path";
-var CODEX_PLAN_BODY = "## Plan Snapshot (Plan mode only)\n\n- This rule applies only when Codex is running in `collaboration_mode=Plan`.\n- Before implementation (file edits/creates, installs, commits) and before leaving Plan mode, 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;
-  if (toolId === "claude-code" && renderResult.tool === "claude-code") {
-    return renderResult.files.map(({ relativePath, content }) => ({
-      relativePath,
-      content: wrapWithSection(content, meta)
-    }));
-  }
-  if (toolId === "codex" && renderResult.tool === "codex") {
-    const config = TOOL_OUTPUT_MAP["codex"];
-    const actions = [];
-    const rootContent = renderResult.rootContent ? renderResult.rootContent + "\n\n---\n\n" + CODEX_PLAN_BODY : CODEX_PLAN_BODY;
-    actions.push({
-      relativePath: join7(config.dir, config.rootFileName),
-      content: wrapWithSection(rootContent, meta)
-    });
-    for (const df of renderResult.domainFiles) {
-      actions.push({
-        relativePath: join7(df.workspacePath, config.domainFileName),
-        content: wrapWithSection(df.content, meta)
-      });
-    }
-    return actions;
-  }
-  if (toolId === "gemini" && renderResult.tool === "gemini") {
-    const config = TOOL_OUTPUT_MAP["gemini"];
-    const actions = [];
-    if (renderResult.rootContent) {
-      actions.push({
-        relativePath: join7(config.dir, config.rootFileName),
-        content: wrapWithSection(renderResult.rootContent, meta)
-      });
-    }
-    for (const df of renderResult.domainFiles) {
-      actions.push({
-        relativePath: join7(df.workspacePath, config.domainFileName),
-        content: wrapWithSection(df.content, meta)
-      });
-    }
-    return actions;
+// src/core/subagent-manifest-io.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join8 } from "path";
+var SUBAGENT_MANIFEST_FILENAME = "subagents-manifest.json";
+var parseSubagentManifest = (json) => SubagentManifestSchema.parse(JSON.parse(json));
+var serializeSubagentManifest = (manifest) => JSON.stringify(manifest, null, 2) + "\n";
+var resolveSubagentManifestPath = (userBasePath) => join8(userBasePath, ".ai-ops", SUBAGENT_MANIFEST_FILENAME);
+var readSubagentManifest = (manifestPath) => {
+  let raw;
+  try {
+    raw = readFileSync5(manifestPath, "utf-8");
+  } catch {
+    return null;
   }
-  return [];
+  return parseSubagentManifest(raw);
+};
+var writeSubagentManifest = (manifestPath, manifest) => {
+  mkdirSync3(dirname4(manifestPath), { recursive: true });
+  writeFileSync3(manifestPath, serializeSubagentManifest(manifest), "utf-8");
 };
 
-// src/data/spec-readme.ts
-var SPEC_README_TEMPLATE = `# Specs
-
-\uC774 \uB514\uB809\uD1A0\uB9AC\uB294 AI \uD611\uC5C5 \uAE30\uBC18 spec \uD30C\uC774\uD504\uB77C\uC778\uC744 \uAD00\uB9AC\uD569\uB2C8\uB2E4.
-
-## \uB514\uB809\uD1A0\uB9AC \uAD6C\uC870
-
-\`\`\`
-specs/
-\u251C\u2500\u2500 baseline/   # \uAE30\uC900 spec \uBB38\uC11C (\uCD08\uAE30 \uC694\uAD6C\uC0AC\uD56D, \uD655\uC815\uB41C \uC2A4\uD399)
-\u2514\u2500\u2500 initial-build/      # \uCD08\uAE30 \uAD6C\uCD95 spec \uBB38\uC11C
-\`\`\`
-
-## \uC0AC\uC6A9 \uBC29\uBC95
-
-### baseline
-
-\uD504\uB85C\uC81D\uD2B8\uC758 \uCD08\uAE30 \uB610\uB294 \uD655\uC815\uB41C \uC2A4\uD399 \uBB38\uC11C\uB97C \`baseline/\` \uB514\uB809\uD1A0\uB9AC\uC5D0 \uC800\uC7A5\uD569\uB2C8\uB2E4.
-
-- \uD30C\uC77C\uBA85: \`<feature-name>.md\` (kebab-case)
-- \uB0B4\uC6A9: \uC694\uAD6C\uC0AC\uD56D, \uB3C4\uBA54\uC778 \uC6A9\uC5B4, \uC81C\uC57D \uC870\uAC74 \uB4F1
-
-### initial-build
-
-\uCD08\uAE30 \uAD6C\uCD95 \uBC94\uC704\uC640 \uAD6C\uD604 \uACC4\uD68D\uC744 \`initial-build/\` \uB514\uB809\uD1A0\uB9AC\uC5D0 \uC800\uC7A5\uD569\uB2C8\uB2E4.
-
-- \uD30C\uC77C\uBA85: \`<YYYYMMDD>-<feature-name>.md\`
-- \uB0B4\uC6A9: \uCD08\uAE30 \uAD6C\uD604 \uBC94\uC704, \uC0AC\uC6A9\uC790 \uD750\uB984, \uB370\uC774\uD130 \uBAA8\uB378, API \uACC4\uC57D, \uAC80\uC99D \uAE30\uC900 \uB4F1
-`;
-
-// src/core/spec-plan.ts
-var buildSpecInitPlan = () => [
-  { relativePath: "specs/README.md", content: SPEC_README_TEMPLATE },
-  { relativePath: "specs/baseline/.gitkeep", content: "" },
-  { relativePath: "specs/initial-build/.gitkeep", content: "" }
-];
+// src/core/install-plan.ts
+import { join as join9 } from "path";
 
-// src/core/uninstall-plan.ts
-import { join as join8 } from "path";
-var inferInstalledFiles = (manifest) => {
-  const files = [];
-  const isMonorepo = manifest.workspaces !== void 0;
-  for (const toolId of manifest.tools) {
-    if (toolId === "claude-code") {
-      const config = TOOL_OUTPUT_MAP["claude-code"];
-      for (const ruleId of manifest.installed_rules) {
-        files.push(join8(config.rulesDir, `${ruleId}${config.fileExtension}`));
-      }
-    } else if (toolId === "codex") {
-      const config = TOOL_OUTPUT_MAP["codex"];
-      if (!isMonorepo) {
-        files.push(join8(config.dir, config.rootFileName));
-        files.push(join8(config.dir, config.domainFileName));
-      } else {
-        files.push(join8(config.dir, config.rootFileName));
-        for (const ws of Object.keys(manifest.workspaces ?? {})) {
-          files.push(join8(ws, config.domainFileName));
-        }
-      }
-    } else if (toolId === "gemini") {
-      const config = TOOL_OUTPUT_MAP["gemini"];
-      if (!isMonorepo) {
-        files.push(join8(config.dir, config.rootFileName));
-      } else {
-        files.push(join8(config.dir, config.rootFileName));
-        for (const ws of Object.keys(manifest.workspaces ?? {})) {
-          files.push(join8(ws, config.domainFileName));
-        }
-      }
-    }
-  }
-  return [...new Set(files)];
-};
+// src/core/project-layer.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync3, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, isAbsolute, join as join10, relative, resolve as resolve5 } from "path";
 
 // src/core/paths.ts
-import { dirname as dirname4, resolve as resolve3 } from "path";
+import { dirname as dirname5, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = dirname4(fileURLToPath2(import.meta.url));
-var COMPILER_DATA_DIR = resolve3(__dirname2, "..", "..", "data");
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+var COMPILER_DATA_DIR = resolve4(__dirname2, "..", "..", "data");
 
-// src/lib/paths.ts
-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 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;
-  return statSync(resolve4(basePath, name)).isDirectory();
-};
-var PROJECT_MANIFESTS = [
-  "package.json",
-  // Node.js / JS / TS
-  "pubspec.yaml",
-  // Flutter / Dart
-  "pyproject.toml",
-  // Python (modern)
-  "setup.py",
-  // Python (legacy)
-  "Cargo.toml",
-  // Rust
-  "go.mod"
-  // Go
+// src/core/project-layer.ts
+var PROJECT_LAYER_MANIFEST_RELATIVE_PATH = ".ai-ops/manifest.json";
+var PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH = ".ai-ops/context-layer.json";
+var CONTEXT_LAYER_DATA_DIR = join10(COMPILER_DATA_DIR, "context-layer");
+var TOOL_ORDER = ["codex", "gemini", "claude-code"];
+var DEFAULT_TOOLS = TOOL_ORDER;
+var TEMPLATE_PATHS = [
+  "AGENTS.md",
+  "GEMINI.md",
+  "CLAUDE.md",
+  "docs/agent/workflow.md",
+  "docs/agent/rules/routing-rules.md",
+  "docs/agent/rules/doc-update-rules.md",
+  "docs/agent/rules/stop-rules.md",
+  "docs/agent/checks/impact-checklist.md",
+  "docs/agent/checks/review-checklist.md",
+  "docs/agent/maps/codebase-map.md",
+  "docs/business/business-rules.md",
+  "docs/docs-status.md"
 ];
-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 = [];
-  for (const dir of topLevel) {
-    const subPath = resolve4(basePath, dir);
-    if (isWorkspaceRoot(subPath)) {
-      candidates.push(dir);
-    } else {
-      const children = readdirSync3(subPath).filter((name) => isVisibleDir(subPath, name));
-      const wsChildren = children.filter((name) => isWorkspaceRoot(resolve4(subPath, name)));
-      if (wsChildren.length > 0) {
-        for (const child of wsChildren) {
-          candidates.push(join10(dir, child));
-        }
-      } else {
-        candidates.push(dir);
-      }
-    }
-  }
-  return candidates.sort();
+var PROJECT_OWNED_PATHS = /* @__PURE__ */ new Set([
+  "docs/docs-status.md",
+  "docs/agent/maps/codebase-map.md",
+  "docs/business/business-rules.md"
+]);
+var RESERVED_DOCUMENT_WARNINGS = [
+  "\uD310\uB2E8 \uADFC\uAC70\uB85C \uC0AC\uC6A9\uD558\uC9C0 \uB9C8\uC138\uC694",
+  "Do not use this document as current decision-making evidence"
+];
+var resolveProjectLayerManifestPath = (basePath) => join10(basePath, PROJECT_LAYER_MANIFEST_RELATIVE_PATH);
+var resolveProjectLayerContextIndexPath = (basePath) => join10(basePath, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH);
+var resolveTemplatePath = (relativePath) => join10(CONTEXT_LAYER_DATA_DIR, relativePath);
+var toRelativeDir = (relativePath) => dirname6(relativePath);
+var resolveProjectLayerFilePath = (basePath, relativePath) => {
+  if (!isSafeProjectLayerPath(relativePath)) {
+    throw new Error(`Unsafe project layer path: ${relativePath}`);
+  }
+  const absoluteBasePath = resolve5(basePath);
+  const absolutePath = resolve5(absoluteBasePath, relativePath);
+  const relativeFromBase = relative(absoluteBasePath, absolutePath);
+  if (relativeFromBase === "" || relativeFromBase.startsWith("..") || isAbsolute(relativeFromBase)) {
+    throw new Error(`Unsafe project layer path: ${relativePath}`);
+  }
+  return absolutePath;
+};
+var parseProjectLayerManifest = (json) => ProjectLayerManifestSchema.parse(JSON.parse(json));
+var serializeProjectLayerManifest = (manifest) => JSON.stringify(manifest, null, 2) + "\n";
+var parseProjectLayerContextIndex = (json) => ProjectLayerContextIndexSchema.parse(JSON.parse(json));
+var serializeProjectLayerContextIndex = (contextIndex) => JSON.stringify(contextIndex, null, 2) + "\n";
+var parseProjectLayerFrontmatter = (content) => {
+  const { frontmatter } = parseMarkdownFrontmatter(content);
+  return ProjectLayerFrontmatterSchema.parse(frontmatter);
+};
+var parseProjectLayerDocument = (path, rawContent) => {
+  const managedContent = extractAiOpsSectionContent(rawContent);
+  const content = managedContent ?? rawContent;
+  const frontmatter = parseProjectLayerFrontmatter(content);
+  return {
+    path,
+    status: frontmatter.status,
+    layer: frontmatter.layer,
+    owner: frontmatter.owner,
+    read_when: frontmatter.read_when,
+    update_when: frontmatter.update_when,
+    contentHash: computeHash([content.trimEnd()]),
+    content
+  };
 };
-
-// src/lib/install.ts
-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 (!existsSync3(absPath)) {
-      mkdirSync3(dirname5(absPath), { recursive: true });
-      writeFileSync3(absPath, action.content + "\n", "utf-8");
-      written.push(action.relativePath);
-    } else {
-      const existing = readFileSync5(absPath, "utf-8");
-      if (hasAiOpsSection(existing)) {
-        const updated = replaceAiOpsSection(existing, action.content);
-        writeFileSync3(absPath, updated, "utf-8");
-        const stripped = stripAiOpsSection(existing);
-        (stripped.trim().length > 0 ? appended : written).push(action.relativePath);
-      } else if (hasLegacyHeader(existing)) {
-        writeFileSync3(absPath, action.content + "\n", "utf-8");
-        written.push(action.relativePath);
-      } else {
-        const updated = existing.trimEnd() + "\n\n" + action.content + "\n";
-        writeFileSync3(absPath, updated, "utf-8");
-        appended.push(action.relativePath);
+var parseDocsStatusEntries = (content) => {
+  const document = parseProjectLayerDocument("docs/docs-status.md", content);
+  const rows = document.content.split("\n").filter((line) => line.trim().startsWith("|")).map((line) => line.trim());
+  return rows.flatMap((line) => {
+    const cells = line.split("|").map((cell) => cell.trim()).filter((cell) => cell.length > 0);
+    if (cells.length < 3) return [];
+    if (cells[0] === "path") return [];
+    if (cells[0].startsWith("---")) return [];
+    return [
+      {
+        path: cells[0],
+        status: cells[1],
+        owner: cells[2]
       }
-    }
+    ];
+  });
+};
+var resolveProjectLayerTools = (requestedTools) => {
+  if (requestedTools === void 0 || requestedTools.length === 0) {
+    return [...DEFAULT_TOOLS];
   }
-  return { written, appended, skipped };
+  const parsedTools = requestedTools.map((tool) => ProjectLayerToolSchema.parse(tool));
+  const toolSet = new Set(parsedTools);
+  return TOOL_ORDER.filter((tool) => toolSet.has(tool));
 };
-
-// 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);
+var shouldIncludeTemplate = (relativePath, tools) => {
+  if (relativePath === "GEMINI.md") return tools.includes("gemini");
+  if (relativePath === "CLAUDE.md") return tools.includes("claude-code");
+  return true;
+};
+var buildDocsStatusRows = (specs) => specs.map((spec) => `| ${spec.path} | ${spec.frontmatter.status} | ${spec.frontmatter.owner} |`).join("\n");
+var includesReservedDocumentWarning = (content) => RESERVED_DOCUMENT_WARNINGS.some((warning) => content.includes(warning));
+var loadTemplateSpec = (relativePath, content) => {
+  const frontmatter = parseProjectLayerFrontmatter(content);
+  const ownership = PROJECT_OWNED_PATHS.has(relativePath) ? "project" : "managed";
+  if (frontmatter.status === "Reserved" && !includesReservedDocumentWarning(content)) {
+    throw new Error(`Reserved template must include warning text: ${relativePath}`);
   }
-  return writtenRoots;
+  return {
+    path: relativePath,
+    content,
+    ownership,
+    frontmatter,
+    contentHash: computeHash([content.trimEnd()])
+  };
 };
-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);
+var loadProjectLayerTemplateSpecs = (tools) => {
+  const selectedPaths = TEMPLATE_PATHS.filter((relativePath) => shouldIncludeTemplate(relativePath, tools));
+  const nonStatusSpecs = selectedPaths.filter((relativePath) => relativePath !== "docs/docs-status.md").map((relativePath) => loadTemplateSpec(relativePath, readFileSync6(resolveTemplatePath(relativePath), "utf-8")));
+  const statusTemplate = readFileSync6(resolveTemplatePath("docs/docs-status.md"), "utf-8");
+  const statusPlaceholderSpec = loadTemplateSpec("docs/docs-status.md", statusTemplate);
+  const specsForStatus = [...nonStatusSpecs, statusPlaceholderSpec].sort((a, b) => a.path.localeCompare(b.path));
+  const statusContent = statusTemplate.replace("{{documents_table}}", buildDocsStatusRows(specsForStatus));
+  const statusSpec = loadTemplateSpec("docs/docs-status.md", statusContent);
+  return [...nonStatusSpecs, statusSpec].sort((a, b) => a.path.localeCompare(b.path));
+};
+var computeProjectLayerSourceHash = (specs) => computeHash(specs.map((spec) => `${spec.path}:${spec.content}`));
+var readProjectLayerManifest = (basePath) => {
+  try {
+    return parseProjectLayerManifest(readFileSync6(resolveProjectLayerManifestPath(basePath), "utf-8"));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
   }
-  return removed;
 };
-
-// src/lib/tool-settings.ts
-import * as p from "@clack/prompts";
-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) => {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
-      result[key] = deepMerge(result[key], value);
-    } else {
-      result[key] = value;
+var writeProjectLayerManifest = (basePath, manifest) => {
+  const manifestPath = resolveProjectLayerManifestPath(basePath);
+  mkdirSync4(dirname6(manifestPath), { recursive: true });
+  writeFileSync4(manifestPath, serializeProjectLayerManifest(manifest), "utf-8");
+};
+var readProjectLayerContextIndex = (basePath) => {
+  try {
+    return parseProjectLayerContextIndex(readFileSync6(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return null;
     }
+    throw error;
   }
-  return result;
 };
-var deepRemoveKeys = (base, patch) => {
-  const result = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (!(key in result)) continue;
-    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
-      const nested = deepRemoveKeys(result[key], value);
-      if (Object.keys(nested).length === 0) {
-        delete result[key];
+var writeProjectLayerContextIndex = (basePath, contextIndex) => {
+  const contextIndexPath = resolveProjectLayerContextIndexPath(basePath);
+  mkdirSync4(dirname6(contextIndexPath), { recursive: true });
+  writeFileSync4(contextIndexPath, serializeProjectLayerContextIndex(contextIndex), "utf-8");
+};
+var installManagedFiles = (basePath, specs, meta) => {
+  const written = [];
+  const appended = [];
+  for (const spec of specs) {
+    const absolutePath = resolveProjectLayerFilePath(basePath, spec.path);
+    const wrappedContent = wrapWithSection(spec.content, meta);
+    if (!existsSync2(absolutePath)) {
+      mkdirSync4(dirname6(absolutePath), { recursive: true });
+      writeFileSync4(absolutePath, wrappedContent + "\n", "utf-8");
+      written.push(spec.path);
+      continue;
+    }
+    const existing = readFileSync6(absolutePath, "utf-8");
+    if (hasAiOpsSection(existing)) {
+      writeFileSync4(absolutePath, replaceAiOpsSection(existing, wrappedContent), "utf-8");
+      const stripped = stripAiOpsSection(existing);
+      (stripped.trim().length > 0 ? appended : written).push(spec.path);
+      continue;
+    }
+    if (hasLegacyHeader(existing)) {
+      writeFileSync4(absolutePath, wrappedContent + "\n", "utf-8");
+      written.push(spec.path);
+      continue;
+    }
+    writeFileSync4(absolutePath, existing.trimEnd() + "\n\n" + wrappedContent + "\n", "utf-8");
+    appended.push(spec.path);
+  }
+  return { written, appended };
+};
+var installProjectFiles = (params) => {
+  const records = [];
+  const created = [];
+  const refreshed = [];
+  const preserved = [];
+  const previousByPath = new Map((params.previousProjectFiles ?? []).map((file) => [file.path, file]));
+  for (const spec of params.specs) {
+    const absolutePath = resolveProjectLayerFilePath(params.basePath, spec.path);
+    const previous = previousByPath.get(spec.path);
+    if (!existsSync2(absolutePath)) {
+      mkdirSync4(dirname6(absolutePath), { recursive: true });
+      writeFileSync4(absolutePath, spec.content + "\n", "utf-8");
+      created.push(spec.path);
+      records.push({
+        path: spec.path,
+        templateHash: spec.contentHash,
+        created: true
+      });
+      continue;
+    }
+    const existingContent = readFileSync6(absolutePath, "utf-8").trimEnd();
+    const existingHash = computeHash([existingContent]);
+    if (previous?.created === true && existingHash === previous.templateHash) {
+      if (existingHash !== spec.contentHash) {
+        writeFileSync4(absolutePath, spec.content + "\n", "utf-8");
+        refreshed.push(spec.path);
       } else {
-        result[key] = nested;
+        preserved.push(spec.path);
       }
-    } else {
-      delete result[key];
+      records.push({
+        path: spec.path,
+        templateHash: spec.contentHash,
+        created: true
+      });
+      continue;
     }
+    preserved.push(spec.path);
+    records.push({
+      path: spec.path,
+      templateHash: previous?.templateHash ?? spec.contentHash,
+      created: previous?.created ?? false
+    });
   }
-  return result;
+  return { records, created, refreshed, preserved };
+};
+var buildContextIndexFromDisk = (params) => {
+  const documents = params.documentPaths.map(
+    (path) => parseProjectLayerDocument(path, readFileSync6(resolveProjectLayerFilePath(params.basePath, path), "utf-8"))
+  );
+  return ProjectLayerContextIndexSchema.parse({
+    schemaVersion: 1,
+    kind: "context-layer-index",
+    documents: documents.map(({ content: _content, ...document }) => document),
+    generatedAt: params.generatedAt
+  });
 };
-
-// src/lib/prompt-control.ts
-var PROMPT_CANCELLED = /* @__PURE__ */ Symbol("prompt-cancelled");
-var isPromptCancelled = (value) => value === PROMPT_CANCELLED;
-
-// src/lib/tool-settings.ts
-var promptToolSettings = async (config) => {
-  const want = await p.confirm({ message: config.promptMessage, initialValue: true });
-  if (p.isCancel(want)) return PROMPT_CANCELLED;
-  if (!want) 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: config.groups.map((g) => ({ value: g.value, label: g.label, hint: g.hint })),
-    initialValues: config.groups.map((g) => g.value),
-    required: false
+var computeProjectFileHash = (basePath, relativePath) => computeHash([readFileSync6(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
+var collectDocumentPathsFromManifest = (manifest) => [
+  ...manifest.managed_files.map((file) => file.path),
+  ...manifest.project_files.map((file) => file.path),
+  ...manifest.packs.flatMap((pack) => pack.documents.map((file) => file.path))
+].sort();
+var buildDocsStatusRowsFromDisk = (params) => params.documentPaths.map((path) => {
+  const document = parseProjectLayerDocument(path, readFileSync6(resolveProjectLayerFilePath(params.basePath, path), "utf-8"));
+  return `| ${document.path} | ${document.status} | ${document.owner} |`;
+});
+var replaceDocsStatusRows = (content, rows) => {
+  const lines = content.trimEnd().split("\n");
+  const headerIndex = lines.findIndex((line) => line.trim() === "| path | status | owner |");
+  const dividerIndex = headerIndex + 1;
+  if (headerIndex < 0 || !lines[dividerIndex]?.trim().startsWith("| ---")) {
+    throw new Error("docs/docs-status.md table header not found");
+  }
+  let tableEndIndex = dividerIndex + 1;
+  while (tableEndIndex < lines.length && lines[tableEndIndex]?.trim().startsWith("|")) {
+    tableEndIndex += 1;
+  }
+  return [...lines.slice(0, dividerIndex + 1), ...rows, ...lines.slice(tableEndIndex)].join("\n") + "\n";
+};
+var updateDocsStatusTable = (basePath, documentPaths) => {
+  const docsStatusPath = "docs/docs-status.md";
+  const absolutePath = resolveProjectLayerFilePath(basePath, docsStatusPath);
+  const beforeHash = computeProjectFileHash(basePath, docsStatusPath);
+  const rows = buildDocsStatusRowsFromDisk({ basePath, documentPaths });
+  const nextContent = replaceDocsStatusRows(readFileSync6(absolutePath, "utf-8"), rows);
+  writeFileSync4(absolutePath, nextContent, "utf-8");
+  return {
+    beforeHash,
+    afterHash: computeProjectFileHash(basePath, docsStatusPath)
+  };
+};
+var updateDocsStatusProjectFileRecord = (params) => ProjectLayerManifestSchema.parse({
+  ...params.manifest,
+  project_files: params.manifest.project_files.map((file) => {
+    if (file.path !== "docs/docs-status.md" || !file.created || file.templateHash !== params.beforeHash) {
+      return file;
+    }
+    return {
+      ...file,
+      templateHash: params.afterHash
+    };
+  })
+});
+var refreshProjectLayerDerivedState = (params) => {
+  const documentPaths = collectDocumentPathsFromManifest(params.manifest);
+  const docsStatusHashes = updateDocsStatusTable(params.basePath, documentPaths);
+  const manifest = updateDocsStatusProjectFileRecord({
+    manifest: params.manifest,
+    beforeHash: docsStatusHashes.beforeHash,
+    afterHash: docsStatusHashes.afterHash
   });
-  if (p.isCancel(selected)) return PROMPT_CANCELLED;
-  return selected;
-};
-var installToolSettings = (basePath, selectedValues, config) => {
-  if (selectedValues.length === 0) return;
-  const settingsDir = join11(basePath, config.dirName);
-  const settingsPath = join11(settingsDir, config.fileName);
-  let existing = {};
-  if (existsSync5(settingsPath)) {
-    try {
-      existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
-    } catch {
+  const contextIndex = buildContextIndexFromDisk({
+    basePath: params.basePath,
+    documentPaths,
+    generatedAt: params.generatedAt
+  });
+  writeProjectLayerContextIndex(params.basePath, contextIndex);
+  return {
+    manifest,
+    contextIndex
+  };
+};
+var buildProjectLayerManifest = (params) => ProjectLayerManifestSchema.parse({
+  schemaVersion: 1,
+  kind: "project-operating-layer",
+  tools: [...params.tools],
+  managed_files: params.managedFiles.map((path) => ({
+    path,
+    sourceHash: params.sourceHash
+  })),
+  project_files: [...params.projectFiles],
+  packs: [...params.packs],
+  settings: params.settings ?? {},
+  sourceHash: params.sourceHash,
+  cliVersion: params.cliVersion,
+  generatedAt: params.generatedAt
+});
+var retireUnselectedManagedFiles = (params) => {
+  if (!params.previousManifest) return;
+  const nextManagedPathSet = new Set(params.nextManagedPaths);
+  for (const file of params.previousManifest.managed_files) {
+    if (!nextManagedPathSet.has(file.path)) {
+      removeManagedProjectFile(params.basePath, file.path);
     }
   }
-  let merged = existing;
-  for (const val of selectedValues) {
-    const group = config.groups.find((g) => g.value === val);
-    if (!group) continue;
-    merged = deepMerge(merged, group.patch);
-  }
-  mkdirSync5(settingsDir, { recursive: true });
-  writeFileSync5(settingsPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
 };
-var uninstallToolSettings = (basePath, selectedValues, config) => {
-  const settingsPath = join11(basePath, config.dirName, config.fileName);
-  if (!existsSync5(settingsPath)) return "notFound";
-  let existing = {};
+var installProjectLayer = (params) => {
+  const previousManifest = params.previousManifest === void 0 ? readProjectLayerManifest(params.basePath) : params.previousManifest;
+  const specs = loadProjectLayerTemplateSpecs(params.tools);
+  const sourceHash = computeProjectLayerSourceHash(specs);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const managedSpecs = specs.filter((spec) => spec.ownership === "managed");
+  const projectSpecs = specs.filter((spec) => spec.ownership === "project");
+  const managedPaths = managedSpecs.map((spec) => spec.path);
+  retireUnselectedManagedFiles({
+    basePath: params.basePath,
+    previousManifest,
+    nextManagedPaths: managedPaths
+  });
+  const managedResult = installManagedFiles(params.basePath, managedSpecs, { sourceHash, generatedAt });
+  const projectResult = installProjectFiles({
+    basePath: params.basePath,
+    specs: projectSpecs,
+    previousProjectFiles: previousManifest?.project_files
+  });
+  const provisionalManifest = buildProjectLayerManifest({
+    tools: params.tools,
+    managedFiles: managedPaths,
+    projectFiles: projectResult.records,
+    packs: previousManifest?.packs ?? [],
+    sourceHash,
+    cliVersion: getCliVersion(),
+    generatedAt,
+    settings: previousManifest?.settings
+  });
+  const { manifest, contextIndex } = refreshProjectLayerDerivedState({
+    basePath: params.basePath,
+    manifest: provisionalManifest,
+    generatedAt
+  });
+  writeProjectLayerManifest(params.basePath, manifest);
+  return {
+    manifest,
+    contextIndex,
+    written: managedResult.written,
+    appended: managedResult.appended,
+    createdProjectFiles: projectResult.created,
+    refreshedProjectFiles: projectResult.refreshed,
+    preservedProjectFiles: projectResult.preserved
+  };
+};
+var updateProjectLayer = (params) => {
+  const specs = loadProjectLayerTemplateSpecs(params.manifest.tools);
+  const sourceHash = computeProjectLayerSourceHash(specs);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const managedSpecs = specs.filter((spec) => spec.ownership === "managed");
+  const projectSpecs = specs.filter((spec) => spec.ownership === "project");
+  const managedResult = installManagedFiles(params.basePath, managedSpecs, { sourceHash, generatedAt });
+  const projectResult = installProjectFiles({
+    basePath: params.basePath,
+    specs: projectSpecs,
+    previousProjectFiles: params.manifest.project_files
+  });
+  const provisionalManifest = buildProjectLayerManifest({
+    tools: params.manifest.tools,
+    managedFiles: managedSpecs.map((spec) => spec.path),
+    projectFiles: projectResult.records,
+    packs: params.manifest.packs,
+    sourceHash,
+    cliVersion: getCliVersion(),
+    generatedAt,
+    settings: params.manifest.settings
+  });
+  const { manifest, contextIndex } = refreshProjectLayerDerivedState({
+    basePath: params.basePath,
+    manifest: provisionalManifest,
+    generatedAt
+  });
+  writeProjectLayerManifest(params.basePath, manifest);
+  return {
+    manifest,
+    contextIndex,
+    written: managedResult.written,
+    appended: managedResult.appended,
+    createdProjectFiles: projectResult.created,
+    refreshedProjectFiles: projectResult.refreshed,
+    preservedProjectFiles: projectResult.preserved
+  };
+};
+var issue = (level, code, message) => ({
+  level,
+  code,
+  message
+});
+var readDocumentSafely = (basePath, path) => {
   try {
-    existing = JSON.parse(readFileSync6(settingsPath, "utf-8"));
-  } catch {
-    rmSync2(settingsPath, { force: true });
-    return "deleted";
+    const absolutePath = resolveProjectLayerFilePath(basePath, path);
+    if (!existsSync2(absolutePath)) {
+      return issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${path}`);
+    }
+    return parseProjectLayerDocument(path, readFileSync6(absolutePath, "utf-8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown error";
+    return issue("error", "invalid-frontmatter", `${path} frontmatter \uD30C\uC2F1 \uC2E4\uD328: ${reason}`);
+  }
+};
+var buildContextIndexMap = (contextIndex) => new Map((contextIndex?.documents ?? []).map((document) => [document.path, document]));
+var compareArray = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+var compareContextDocument = (params) => {
+  const indexed = params.indexed;
+  if (indexed === void 0) {
+    return [issue("error", "context-missing-document", `context-layer \uB204\uB77D: ${params.expected.path}`)];
+  }
+  const issues = [];
+  const scalarKeys = ["status", "layer", "owner", "contentHash"];
+  for (const key of scalarKeys) {
+    if (params.expected[key] !== indexed[key]) {
+      issues.push(
+        issue("error", "context-document-mismatch", `${params.expected.path} context ${key} \uBD88\uC77C\uCE58`)
+      );
+    }
   }
-  let result = existing;
-  for (const val of selectedValues) {
-    const group = config.groups.find((g) => g.value === val);
-    if (!group) continue;
-    result = deepRemoveKeys(result, group.patch);
+  if (!compareArray(params.expected.read_when, indexed.read_when)) {
+    issues.push(issue("error", "context-document-mismatch", `${params.expected.path} context read_when \uBD88\uC77C\uCE58`));
   }
-  if (Object.keys(result).length === 0) {
-    rmSync2(settingsPath, { force: true });
-    return "deleted";
+  if (!compareArray(params.expected.update_when, indexed.update_when)) {
+    issues.push(issue("error", "context-document-mismatch", `${params.expected.path} context update_when \uBD88\uC77C\uCE58`));
   }
-  writeFileSync5(settingsPath, JSON.stringify(result, null, 2) + "\n", "utf-8");
-  return "cleaned";
+  return issues;
 };
-
-// src/lib/gemini-settings.ts
-var SETTING_GROUPS = [
-  {
-    value: "ui",
-    label: "UI \u2014 \uC904 \uBC88\uD638 \uC228\uAE30\uAE30",
-    hint: "ui.showLineNumbers: false \u2014 \uCF54\uB4DC \uBCF5\uC0AC \uC2DC \uC904 \uBC88\uD638\uAC00 \uD3EC\uD568\uB418\uC9C0 \uC54A\uB3C4\uB85D \uBE44\uD65C\uC131\uD654",
-    patch: { ui: { showLineNumbers: false } }
-  },
-  {
-    value: "plan",
-    label: "Plan \u2014 \uACC4\uD68D \uD30C\uC77C \uC800\uC7A5 \uBC0F \uBAA8\uB378 \uB77C\uC6B0\uD305",
-    hint: "general.plan.directory: .gemini/plans, modelRouting: true \u2014 AI \uACC4\uD68D\uC744 \uD30C\uC77C\uB85C \uC800\uC7A5\uD558\uACE0 \uD0DC\uC2A4\uD06C\uBCC4 \uCD5C\uC801 \uBAA8\uB378 \uC790\uB3D9 \uC120\uD0DD",
-    patch: { general: { plan: { directory: ".gemini/plans", modelRouting: true } } }
-  },
-  {
-    value: "sessionRetention",
-    label: "Session Retention \u2014 \uC138\uC158 30\uC77C \uBCF4\uC874",
-    hint: "general.sessionRetention.maxAge: 30d \u2014 \uC774\uC804 \uB300\uD654 \uCEE8\uD14D\uC2A4\uD2B8\uB97C 30\uC77C\uAC04 \uC720\uC9C0",
-    patch: { general: { sessionRetention: { maxAge: "30d" } } }
-  },
-  {
-    value: "experimental",
-    label: "Experimental \u2014 JIT \uCEE8\uD14D\uC2A4\uD2B8 + Plan \uAE30\uB2A5",
-    hint: "experimental.jitContext: true, plan: true \u2014 \uC11C\uBE0C\uB514\uB809\uD1A0\uB9AC \uCEE8\uD14D\uC2A4\uD2B8 \uC9C0\uC5F0 \uB85C\uB529 \uBC0F \uACC4\uD68D \uAE30\uB2A5 \uC2E4\uD5D8\uC801 \uD65C\uC131\uD654",
-    patch: { experimental: { jitContext: true, plan: true } }
+var compareDocsStatusEntry = (params) => {
+  const entry = params.entry;
+  if (entry === void 0) {
+    return [issue("error", "docs-status-missing-document", `docs-status \uB204\uB77D: ${params.expected.path}`)];
   }
-];
-var CONFIG = {
-  dirName: ".gemini",
-  fileName: "settings.json",
-  promptMessage: "Gemini CLI \uC124\uC815 \uD30C\uC77C(.gemini/settings.json)\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
-  groups: SETTING_GROUPS
-};
-var promptGeminiSettings = () => promptToolSettings(CONFIG);
-var installGeminiSettings = (basePath, selectedValues) => installToolSettings(basePath, selectedValues, CONFIG);
-var uninstallGeminiSettings = (basePath, selectedValues) => uninstallToolSettings(basePath, selectedValues, CONFIG);
-
-// src/lib/claude-settings.ts
-var SETTING_GROUPS2 = [
-  {
-    value: "model",
-    label: "Model \u2014 Plan \uBAA8\uB4DC \uBAA8\uB378",
-    hint: "model: opusplan \u2014 Plan \uBAA8\uB4DC\uC5D0\uC11C Opus \uBAA8\uB378 \uC0AC\uC6A9",
-    patch: { model: "opusplan" }
-  },
-  {
-    value: "plansDirectory",
-    label: "Plans Directory \u2014 \uACC4\uD68D \uD30C\uC77C \uC800\uC7A5 \uACBD\uB85C",
-    hint: "plansDirectory: ./.claude/plans \u2014 \uACC4\uD68D \uD30C\uC77C\uC744 .claude/plans\uC5D0 \uC800\uC7A5",
-    patch: { plansDirectory: "./.claude/plans" }
+  const issues = [];
+  if (entry.status !== params.expected.status) {
+    issues.push(issue("error", "docs-status-mismatch", `${params.expected.path} docs-status status \uBD88\uC77C\uCE58`));
   }
-];
-var CONFIG2 = {
-  dirName: ".claude",
-  fileName: "settings.local.json",
-  promptMessage: "Claude Code \uC124\uC815 \uD30C\uC77C(.claude/settings.local.json)\uC744 \uC124\uCE58\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
-  groups: SETTING_GROUPS2
-};
-var promptClaudeSettings = () => promptToolSettings(CONFIG2);
-var installClaudeSettings = (basePath, selectedValues) => installToolSettings(basePath, selectedValues, CONFIG2);
-var uninstallClaudeSettings = (basePath, selectedValues) => uninstallToolSettings(basePath, selectedValues, CONFIG2);
-
-// src/lib/prettier-ignore.ts
-import * as p2 from "@clack/prompts";
-import { existsSync as existsSync6, readFileSync as readFileSync7, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
-import { join as join12 } from "path";
-var PRETTIER_IGNORE_CONTENT = `# CLAUDE
-.claude/rules/
-**/CLAUDE.md
-
-# GEMINI
-**/GEMINI.md
-
-# CODEX
-**/AGENTS.md
-**/AGENTS.override.md
-
-.ai-ops-manifest.json`;
-var SECTION_START2 = "# ai-ops:start";
-var SECTION_END2 = "# ai-ops:end";
-var wrapSection = (content) => `${SECTION_START2}
-${content}
-${SECTION_END2}`;
-var hasAiOpsSection2 = (content) => content.includes(SECTION_START2) && content.includes(SECTION_END2);
-var replaceSection = (content, newContent) => {
-  const lines = content.split("\n");
-  const result = [];
-  let inside = false;
-  let replaced = false;
-  for (const line of lines) {
-    if (line.trim() === SECTION_START2) {
-      inside = true;
-      result.push(wrapSection(newContent));
-      replaced = true;
+  if (entry.owner !== params.expected.owner) {
+    issues.push(issue("error", "docs-status-mismatch", `${params.expected.path} docs-status owner \uBD88\uC77C\uCE58`));
+  }
+  return issues;
+};
+var diffProjectLayer = (basePath) => {
+  let manifest;
+  try {
+    manifest = readProjectLayerManifest(basePath);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown error";
+    return {
+      currentSourceHash: null,
+      issues: [issue("error", "invalid-manifest", `${PROJECT_LAYER_MANIFEST_RELATIVE_PATH} \uD30C\uC2F1 \uC2E4\uD328: ${reason}`)]
+    };
+  }
+  if (!manifest) {
+    return {
+      currentSourceHash: null,
+      issues: [issue("error", "missing-manifest", `${PROJECT_LAYER_MANIFEST_RELATIVE_PATH}\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.`)]
+    };
+  }
+  const specs = loadProjectLayerTemplateSpecs(manifest.tools);
+  const currentSourceHash = computeProjectLayerSourceHash(specs);
+  let contextIndex = null;
+  const issues = [];
+  try {
+    contextIndex = readProjectLayerContextIndex(basePath);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown error";
+    issues.push(
+      issue("error", "invalid-context-index", `${PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH} \uD30C\uC2F1 \uC2E4\uD328: ${reason}`)
+    );
+  }
+  const contextMap = buildContextIndexMap(contextIndex);
+  const expectedManagedPaths = new Set(specs.filter((spec) => spec.ownership === "managed").map((spec) => spec.path));
+  const manifestManagedPaths = new Set(manifest.managed_files.map((file) => file.path));
+  if (manifest.sourceHash !== currentSourceHash) {
+    issues.push(
+      issue("warning", "source-hash-drift", `template sourceHash \uBCC0\uACBD: ${manifest.sourceHash} -> ${currentSourceHash}`)
+    );
+  }
+  if (contextIndex === null) {
+    issues.push(issue("error", "missing-context-index", `${PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH}\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.`));
+  }
+  for (const expectedPath of expectedManagedPaths) {
+    if (!manifestManagedPaths.has(expectedPath)) {
+      issues.push(issue("error", "manifest-missing-managed-file", `manifest managed_files \uB204\uB77D: ${expectedPath}`));
+    }
+  }
+  for (const file of manifest.managed_files) {
+    const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+    if (!existsSync2(absolutePath)) {
+      issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       continue;
     }
-    if (line.trim() === SECTION_END2) {
-      inside = false;
+    const content = readFileSync6(absolutePath, "utf-8");
+    const meta = parseAiOpsMeta(content);
+    if (!meta) {
+      issues.push(issue("error", "missing-managed-section", `managed section \uBA54\uD0C0 \uC5C6\uC74C: ${file.path}`));
       continue;
     }
-    if (!inside) result.push(line);
+    if (meta.sourceHash !== currentSourceHash) {
+      issues.push(
+        issue("warning", "managed-source-hash-drift", `${file.path} sourceHash \uBCC0\uACBD: ${meta.sourceHash} -> ${currentSourceHash}`)
+      );
+    }
   }
-  if (!replaced) result.push(wrapSection(newContent));
-  return result.join("\n");
-};
-var stripAiOpsSection2 = (content) => {
-  const lines = content.split("\n");
-  const result = [];
-  let inside = false;
-  for (const line of lines) {
-    if (line.trim() === SECTION_START2) {
-      inside = true;
-      continue;
+  for (const file of manifest.project_files) {
+    if (!existsSync2(resolveProjectLayerFilePath(basePath, file.path))) {
+      issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
+    }
+  }
+  for (const pack of manifest.packs) {
+    for (const file of [...pack.documents, ...pack.files]) {
+      if (!existsSync2(resolveProjectLayerFilePath(basePath, file.path))) {
+        issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
+      }
     }
-    if (line.trim() === SECTION_END2) {
-      inside = false;
+  }
+  for (const path of collectDocumentPathsFromManifest(manifest)) {
+    const document = readDocumentSafely(basePath, path);
+    if ("code" in document) {
+      issues.push(document);
       continue;
     }
-    if (!inside) result.push(line);
+    issues.push(...compareContextDocument({ expected: document, indexed: contextMap.get(path) }));
   }
-  return result.join("\n");
+  return { currentSourceHash, issues };
 };
-var promptPrettierIgnore = async () => {
-  const want = await p2.confirm({
-    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 (p2.isCancel(want)) return PROMPT_CANCELLED;
-  return want;
-};
-var installPrettierIgnore = (basePath) => {
-  const filePath = join12(basePath, ".prettierignore");
-  const section = wrapSection(PRETTIER_IGNORE_CONTENT);
-  if (!existsSync6(filePath)) {
-    writeFileSync6(filePath, section + "\n", "utf-8");
-    return;
+var auditProjectLayer = (basePath) => {
+  const diffReport = diffProjectLayer(basePath);
+  let manifest;
+  try {
+    manifest = readProjectLayerManifest(basePath);
+  } catch {
+    return diffReport;
   }
-  const existing = readFileSync7(filePath, "utf-8");
-  if (hasAiOpsSection2(existing)) {
-    writeFileSync6(filePath, replaceSection(existing, PRETTIER_IGNORE_CONTENT), "utf-8");
-    return;
+  if (!manifest) {
+    return diffReport;
   }
-  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-  writeFileSync6(filePath, existing + separator + section + "\n", "utf-8");
-};
-var uninstallPrettierIgnore = (basePath) => {
-  const filePath = join12(basePath, ".prettierignore");
-  if (!existsSync6(filePath)) return "notFound";
-  const existing = readFileSync7(filePath, "utf-8");
-  if (!hasAiOpsSection2(existing)) return "notFound";
-  const stripped = stripAiOpsSection2(existing).trim();
-  if (stripped.length === 0) {
-    rmSync3(filePath, { force: true });
-    return "deleted";
+  let contextIndex = null;
+  try {
+    contextIndex = readProjectLayerContextIndex(basePath);
+  } catch {
+    contextIndex = null;
+  }
+  const documentPaths = collectDocumentPathsFromManifest(manifest);
+  const documentPathSet = new Set(documentPaths);
+  const contextPathSet = new Set(contextIndex?.documents.map((document) => document.path) ?? []);
+  const issues = [...diffReport.issues];
+  const docsStatusPath = resolveProjectLayerFilePath(basePath, "docs/docs-status.md");
+  if (!existsSync2(docsStatusPath)) {
+    issues.push(issue("error", "missing-docs-status", "docs/docs-status.md\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
+    return { currentSourceHash: diffReport.currentSourceHash, issues };
+  }
+  let docsStatusEntries = [];
+  try {
+    docsStatusEntries = parseDocsStatusEntries(readFileSync6(docsStatusPath, "utf-8"));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown error";
+    issues.push(issue("error", "invalid-docs-status", `docs/docs-status.md \uD30C\uC2F1 \uC2E4\uD328: ${reason}`));
+  }
+  const docsStatusMap = new Map(docsStatusEntries.map((entry) => [entry.path, entry]));
+  for (const path of documentPaths) {
+    const document = readDocumentSafely(basePath, path);
+    if ("code" in document) {
+      continue;
+    }
+    issues.push(...compareDocsStatusEntry({ expected: document, entry: docsStatusMap.get(path) }));
   }
-  writeFileSync6(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}`);
+  for (const entry of docsStatusEntries) {
+    if (!documentPathSet.has(entry.path)) {
+      issues.push(issue("warning", "docs-status-extra-document", `docs-status\uC5D0 manifest \uC678 \uBB38\uC11C\uAC00 \uC788\uC2B5\uB2C8\uB2E4: ${entry.path}`));
+    }
   }
-  if (params.project) return "project";
-  return "user";
-};
-var resolveRequestedTools = (params) => {
-  if (params.requested === void 0 || params.requested.length === 0) {
-    return [...params.supported];
+  for (const contextPath of contextPathSet) {
+    if (!documentPathSet.has(contextPath)) {
+      issues.push(issue("warning", "context-extra-document", `context-layer\uC5D0 manifest \uC678 \uBB38\uC11C\uAC00 \uC788\uC2B5\uB2C8\uB2E4: ${contextPath}`));
+    }
   }
-  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 { currentSourceHash: diffReport.currentSourceHash, issues };
+};
+function removeManagedProjectFile(basePath, relativePath) {
+  const absolutePath = resolveProjectLayerFilePath(basePath, relativePath);
+  if (!existsSync2(absolutePath)) {
+    return { deleted: [], cleaned: [], preserved: [], notFound: [relativePath] };
+  }
+  const content = readFileSync6(absolutePath, "utf-8");
+  if (!hasAiOpsSection(content)) {
+    return { deleted: [], cleaned: [], preserved: [relativePath], notFound: [] };
+  }
+  const stripped = stripAiOpsSection(content);
+  if (stripped.trim().length === 0) {
+    rmSync(absolutePath);
+    return { deleted: [relativePath], cleaned: [], preserved: [], notFound: [] };
+  }
+  writeFileSync4(absolutePath, stripped, "utf-8");
+  return { deleted: [], cleaned: [relativePath], preserved: [], notFound: [] };
+}
+var removeCreateOnlyProjectFile = (basePath, file) => {
+  const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+  if (!existsSync2(absolutePath)) {
+    return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
+  }
+  const content = readFileSync6(absolutePath, "utf-8").trimEnd();
+  const currentHash = computeHash([content]);
+  if (file.created && currentHash === file.templateHash) {
+    rmSync(absolutePath);
+    return { deleted: [file.path], cleaned: [], preserved: [], notFound: [] };
+  }
+  return { deleted: [], cleaned: [], preserved: [file.path], notFound: [] };
+};
+var removePackOwnedFile = (basePath, file) => {
+  const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+  if (!existsSync2(absolutePath)) {
+    return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
+  }
+  const currentHash = computeHash([readFileSync6(absolutePath, "utf-8").trimEnd()]);
+  if (currentHash === file.sourceHash) {
+    rmSync(absolutePath);
+    return { deleted: [file.path], cleaned: [], preserved: [], notFound: [] };
+  }
+  return { deleted: [], cleaned: [], preserved: [file.path], notFound: [] };
+};
+var mergeRemoveResults = (results) => ({
+  deleted: results.flatMap((result) => result.deleted),
+  cleaned: results.flatMap((result) => result.cleaned),
+  preserved: results.flatMap((result) => result.preserved),
+  notFound: results.flatMap((result) => result.notFound)
+});
+var removeEmptyDirs = (basePath, relativePaths) => {
+  const dirs = [...new Set(relativePaths.map(toRelativeDir).filter((dir) => dir !== "."))].sort(
+    (a, b) => b.length - a.length
+  );
+  for (const dir of [...dirs, ".ai-ops"]) {
+    const absoluteDir = resolveProjectLayerFilePath(basePath, dir);
+    if (!existsSync2(absoluteDir)) continue;
+    try {
+      if (readdirSync3(absoluteDir).length === 0) {
+        rmSync(absoluteDir, { recursive: true });
+      }
+    } catch {
+    }
   }
-  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);
+var uninstallProjectLayer = (basePath, manifest) => {
+  const managedResults = manifest.managed_files.map((file) => removeManagedProjectFile(basePath, file.path));
+  const projectResults = manifest.project_files.map((file) => removeCreateOnlyProjectFile(basePath, file));
+  const packResults = manifest.packs.flatMap(
+    (pack) => [...pack.documents, ...pack.files].map((file) => removePackOwnedFile(basePath, file))
+  );
+  const stateFiles = [PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH, PROJECT_LAYER_MANIFEST_RELATIVE_PATH];
+  for (const stateFile of stateFiles) {
+    rmSync(resolveProjectLayerFilePath(basePath, stateFile), { force: true });
+  }
+  const result = mergeRemoveResults([...managedResults, ...projectResults, ...packResults]);
+  removeEmptyDirs(basePath, [...result.deleted, ...stateFiles]);
+  return result;
 };
 
-// src/commands/init.ts
-var TOOL_OPTIONS = [
-  { value: "claude-code", label: "Claude Code" },
-  { value: "codex", label: "Codex" },
-  { value: "gemini", label: "Gemini CLI" }
+// src/core/pack.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join as join11, relative as relative2, resolve as resolve6 } from "path";
+var PACK_REGISTRY_FILENAME = "pack-registry.json";
+var SPEC_LIFECYCLE_PACK_ID = "spec-lifecycle";
+var PACK_INSTALL_ROOT = "docs/specs/";
+var RESERVED_DOCUMENT_WARNINGS2 = [
+  "\uD310\uB2E8 \uADFC\uAC70\uB85C \uC0AC\uC6A9\uD558\uC9C0 \uB9C8\uC138\uC694",
+  "Do not use this document as current decision-making evidence"
 ];
-var deduplicateRules = (rules) => {
-  const seen = /* @__PURE__ */ new Set();
-  return rules.filter((rule) => {
-    if (seen.has(rule.id)) return false;
-    seen.add(rule.id);
-    return true;
-  });
+var DEFAULT_PACKS_DIR = join11(COMPILER_DATA_DIR, "packs");
+var includesReservedDocumentWarning2 = (content) => RESERVED_DOCUMENT_WARNINGS2.some((warning) => content.includes(warning));
+var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync7(join11(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
+var assertPackInstallPath = (path) => {
+  if (!isSafeProjectLayerPath(path) || !path.startsWith(PACK_INSTALL_ROOT)) {
+    throw new Error(`Unsafe pack path: ${path}`);
+  }
 };
-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]
+var readPackSourceFiles = (packDir) => {
+  const files = [];
+  const walk = (relativeDir = "") => {
+    const absoluteDir = relativeDir.length > 0 ? join11(packDir, relativeDir) : packDir;
+    const entries = readdirSync4(absoluteDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const nextRelativePath = relativeDir.length > 0 ? join11(relativeDir, entry.name) : entry.name;
+      if (entry.isDirectory()) {
+        walk(nextRelativePath);
+        continue;
+      }
+      assertPackInstallPath(nextRelativePath);
+      const content = readFileSync7(join11(packDir, nextRelativePath), "utf-8");
+      files.push({
+        path: nextRelativePath,
+        content,
+        sourceHash: computeHash([content.trimEnd()])
       });
-      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));
+  };
+  walk();
+  return files;
 };
-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) {
+var splitPackSourceFiles = (files) => {
+  const documents = [];
+  const regularFiles = [];
+  for (const file of files) {
+    if (!file.path.endsWith(".md")) {
+      regularFiles.push(file);
       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;
+    const { frontmatter } = parseMarkdownFrontmatter(file.content);
+    const parsed = ProjectLayerFrontmatterSchema.parse(frontmatter);
+    if (parsed.status === "Reserved" && !includesReservedDocumentWarning2(file.content)) {
+      throw new Error(`Reserved pack document must include warning text: ${file.path}`);
     }
-    installableSkills.push({
-      skill,
-      requestedTools,
-      globalTools: availableTools
-    });
+    documents.push(file);
   }
-  return {
-    globalSkills,
-    installableSkills
-  };
+  return { documents, files: regularFiles };
 };
-var selectPresetAndFineTune = async (workspaceName, presets, allRules, allSkills, selectedTools, globalInstalledSkills) => {
-  const preset = await p3.select({
-    message: `[${workspaceName}] \uD504\uB9AC\uC14B\uC744 \uC120\uD0DD\uD558\uC138\uC694`,
-    options: presets.map((candidate) => ({
-      value: candidate,
-      label: candidate.id,
-      hint: candidate.description
-    }))
-  });
-  if (p3.isCancel(preset)) return null;
-  const finalRules = resolvePresetRules(preset, allRules);
-  if (finalRules.length > 0) {
-    p3.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)})`
-    );
-    p3.note(globalLines.join("\n"), `[${workspaceName}] already available globally`);
-  }
-  if (installableSkills.length === 0) {
-    p3.note("  \uC0C8\uB85C \uC124\uCE58\uD560 reference skill\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.", `[${workspaceName}] installable reference skills`);
+var loadAllPacks = (packsDir) => {
+  const catalog = readPackCatalog(packsDir);
+  const entries = [...catalog.packs].sort((a, b) => a.id.localeCompare(b.id));
+  return entries.map((entry) => {
+    if (entry.id !== SPEC_LIFECYCLE_PACK_ID) {
+      throw new Error(`Unsupported pack id: ${entry.id}`);
+    }
+    const packDir = resolve6(packsDir, entry.source_path);
+    const relativeFromPacks = relative2(resolve6(packsDir), packDir);
+    if (relativeFromPacks.length === 0 || relativeFromPacks.startsWith("..") || isAbsolute2(relativeFromPacks)) {
+      throw new Error(`Pack source path escapes packs dir: ${entry.source_path}`);
+    }
+    const files = readPackSourceFiles(packDir);
+    const split = splitPackSourceFiles(files);
     return {
-      workspace: workspaceName,
-      preset,
-      finalRules,
-      finalSkillTargets: []
+      id: entry.id,
+      sourceHash: computeHash(files.map((file) => `${file.path}:${file.content}`).sort()),
+      documents: split.documents,
+      files: split.files
     };
-  }
-  const selectedSkillIds = await p3.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 (p3.isCancel(selectedSkillIds)) return null;
-  const selectedSkillSet = new Set(selectedSkillIds);
-  return {
-    workspace: workspaceName,
-    preset,
-    finalRules,
-    finalSkillTargets: installableSkills.filter(({ skill }) => selectedSkillSet.has(skill.id)).map(({ skill, requestedTools }) => ({
-      skill,
-      requestedTools
-    }))
-  };
 };
-var selectInitSkillScope = async () => {
-  const scope = await p3.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 p3.isCancel(scope) ? null : scope;
-};
-var initCommand = async () => {
-  const basePath = resolveBasePath();
-  const userBasePath = resolveUserBasePath();
-  const rulesDir = resolveRulesDir();
-  const skillsDir = resolveSkillsDir();
-  const spinner3 = p3.spinner();
-  let spinnerStarted = false;
-  const cancelInit = (params) => {
-    if (spinnerStarted) {
-      spinner3.stop("\uC124\uCE58 \uC911\uB2E8\uB428");
-      spinnerStarted = false;
-    }
-    p3.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 {
-    p3.intro("ai-ops init");
-    const selectedTools = await p3.multiselect({
-      message: "AI \uB3C4\uAD6C\uB97C \uC120\uD0DD\uD558\uC138\uC694",
-      options: TOOL_OPTIONS,
-      required: true
-    });
-    if (p3.isCancel(selectedTools)) {
-      cancelInit();
+var resolvePackById = (packsDir, packId) => {
+  const pack = loadAllPacks(packsDir).find((candidate) => candidate.id === packId);
+  if (!pack) {
+    throw new Error(`Unknown pack: ${packId}`);
+  }
+  return pack;
+};
+var serializePackFileContent = (content) => content.length === 0 ? "" : content.trimEnd() + "\n";
+var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync7(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
+var writePackFile = (basePath, file) => {
+  const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+  mkdirSync5(dirname7(absolutePath), { recursive: true });
+  writeFileSync5(absolutePath, serializePackFileContent(file.content), "utf-8");
+};
+var buildPackFileRecords = (files) => files.map((file) => ({
+  path: file.path,
+  sourceHash: file.sourceHash
+}));
+var buildPackRecord = (params) => ({
+  id: params.pack.id,
+  sourceHash: params.pack.sourceHash,
+  documents: buildPackFileRecords(params.pack.documents),
+  files: buildPackFileRecords(params.pack.files),
+  installedAt: params.installedAt
+});
+var applyPackSourceFiles = (params) => {
+  const written = [];
+  const refreshed = [];
+  const preserved = [];
+  const deleted = [];
+  const notFound = [];
+  const sourceFiles = [...params.pack.documents, ...params.pack.files];
+  const sourceByPath = new Map(sourceFiles.map((file) => [file.path, file]));
+  const previousByPath = new Map(
+    [...params.previousRecord?.documents ?? [], ...params.previousRecord?.files ?? []].map((file) => [
+      file.path,
+      file
+    ])
+  );
+  for (const file of sourceFiles) {
+    const absolutePath = resolveProjectLayerFilePath(params.basePath, file.path);
+    const previous = previousByPath.get(file.path);
+    if (!existsSync3(absolutePath)) {
+      writePackFile(params.basePath, file);
+      written.push(file.path);
+      continue;
     }
-    const isMonorepo = await p3.confirm({
-      message: "\uBAA8\uB178\uB808\uD3EC \uD504\uB85C\uC81D\uD2B8\uC785\uB2C8\uAE4C?",
-      initialValue: false
-    });
-    if (p3.isCancel(isMonorepo)) {
-      cancelInit();
-    }
-    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 candidates = listWorkspaceCandidates(basePath);
-      const selectedWorkspaces = await p3.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 (p3.isCancel(selectedWorkspaces)) {
-        cancelInit();
-      }
-      for (const workspace of selectedWorkspaces) {
-        const mapping = await selectPresetAndFineTune(
-          workspace,
-          presets,
-          allRules,
-          allSkills,
-          selectedTools,
-          globalInstalledSkills
-        ) ?? cancelInit();
-        mappings.push(mapping);
-      }
+    if (previous === void 0) {
+      preserved.push(file.path);
+      continue;
     }
-    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()
-        });
-      }
+    const currentHash = readProjectFileHash(params.basePath, file.path);
+    if (currentHash !== previous.sourceHash) {
+      preserved.push(file.path);
+      continue;
     }
-    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 (currentHash !== file.sourceHash) {
+      writePackFile(params.basePath, file);
+      refreshed.push(file.path);
     }
-    if (resolvedGeminiSettingValues && resolvedGeminiSettingValues.length > 0) {
-      installGeminiSettings(basePath, resolvedGeminiSettingValues);
+  }
+  for (const previous of previousByPath.values()) {
+    if (sourceByPath.has(previous.path)) {
+      continue;
     }
-    if (resolvedClaudeSettingValues && resolvedClaudeSettingValues.length > 0) {
-      installClaudeSettings(basePath, resolvedClaudeSettingValues);
+    const absolutePath = resolveProjectLayerFilePath(params.basePath, previous.path);
+    if (!existsSync3(absolutePath)) {
+      notFound.push(previous.path);
+      continue;
     }
-    if (resolvedWantPrettierIgnore) {
-      installPrettierIgnore(basePath);
+    if (readProjectFileHash(params.basePath, previous.path) === previous.sourceHash) {
+      rmSync2(absolutePath);
+      deleted.push(previous.path);
+    } else {
+      preserved.push(previous.path);
     }
-    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) {
-      p3.log.info(`\uAE30\uC874 \uD30C\uC77C\uC5D0 \uC139\uC158 \uCD94\uAC00\uB428 (\uB0B4\uC6A9 \uBCF4\uC874):
-${allAppended.map((file) => `  ${file}`).join("\n")}`);
+  }
+  return { written, refreshed, preserved, deleted, notFound };
+};
+var removePackFiles = (basePath, record) => {
+  const deleted = [];
+  const preserved = [];
+  const notFound = [];
+  for (const file of [...record.documents, ...record.files]) {
+    const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+    if (!existsSync3(absolutePath)) {
+      notFound.push(file.path);
+      continue;
     }
-    p3.log.success(`\uC124\uCE58\uB41C core rules: ${selectedRuleIds.length}\uAC1C`);
-    p3.log.success(`\uC124\uCE58\uB41C skills: ${selectedSkillTargets.length}\uAC1C${skillScope ? ` (${skillScope})` : ""}`);
-    if (selectedSkillTargets.length > 0 && skillScope === "user") {
-      p3.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.");
+    if (readProjectFileHash(basePath, file.path) === file.sourceHash) {
+      rmSync2(absolutePath);
+      deleted.push(file.path);
+    } else {
+      preserved.push(file.path);
     }
-    p3.outro("ai-ops init \uC644\uB8CC");
-  } finally {
-    process.off("SIGINT", handleSigint);
   }
+  return { written: [], refreshed: [], preserved, deleted, notFound };
 };
-
-// src/commands/update.ts
-import * as p4 from "@clack/prompts";
-var updateCommand = async (opts) => {
-  const basePath = resolveBasePath();
-  const manifestPath = resolveManifestPath(basePath);
-  p4.intro("ai-ops update");
-  const manifest = readManifest(manifestPath);
+var removeEmptyDirs2 = (basePath, relativePaths) => {
+  const dirs = [...new Set(relativePaths.map((path) => dirname7(path)).filter((dir) => dir !== "."))].sort(
+    (a, b) => b.length - a.length
+  );
+  for (const dir of dirs) {
+    const absoluteDir = resolveProjectLayerFilePath(basePath, dir);
+    if (!existsSync3(absoluteDir)) {
+      continue;
+    }
+    try {
+      if (readdirSync4(absoluteDir).length === 0) {
+        rmSync2(absoluteDir, { recursive: true });
+      }
+    } catch {
+    }
+  }
+};
+var requireProjectLayerManifest = (basePath) => {
+  const manifest = readProjectLayerManifest(basePath);
   if (!manifest) {
-    p4.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
-    process.exit(1);
+    throw new Error(".ai-ops/manifest.json\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
   }
-  const rulesDir = resolveRulesDir();
-  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
+  return manifest;
+};
+var upsertPackRecord = (manifest, record, generatedAt) => ProjectLayerManifestSchema.parse({
+  ...manifest,
+  packs: [...manifest.packs.filter((pack) => pack.id !== record.id), record],
+  cliVersion: getCliVersion(),
+  generatedAt
+});
+var removePackRecord = (manifest, packId, generatedAt) => ProjectLayerManifestSchema.parse({
+  ...manifest,
+  packs: manifest.packs.filter((pack) => pack.id !== packId),
+  cliVersion: getCliVersion(),
+  generatedAt
+});
+var writeManifestWithDerivedState = (params) => {
+  const derived = refreshProjectLayerDerivedState({
+    basePath: params.basePath,
+    manifest: params.manifest,
+    generatedAt: params.generatedAt
+  });
+  writeProjectLayerManifest(params.basePath, derived.manifest);
+  return derived;
+};
+var installProjectLayerPack = (params) => {
+  const manifest = requireProjectLayerManifest(params.basePath);
+  const previousRecord = manifest.packs.find((pack2) => pack2.id === params.packId);
+  if (previousRecord) {
+    return updateProjectLayerPack(params);
+  }
+  const pack = resolvePackById(params.packsDir ?? DEFAULT_PACKS_DIR, params.packId);
+  const installedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const applyResult = applyPackSourceFiles({ basePath: params.basePath, pack, previousRecord: null });
+  const nextManifest = upsertPackRecord(manifest, buildPackRecord({ pack, installedAt }), installedAt);
+  const derived = writeManifestWithDerivedState({
+    basePath: params.basePath,
+    manifest: nextManifest,
+    generatedAt: installedAt
   });
-  const resolvedSkills = resolveManifestProjectSkills({
+  return { ...applyResult, manifest: derived.manifest, contextIndex: derived.contextIndex };
+};
+var updateProjectLayerPack = (params) => {
+  const manifest = requireProjectLayerManifest(params.basePath);
+  const previousRecord = manifest.packs.find((pack2) => pack2.id === params.packId);
+  if (!previousRecord) {
+    throw new Error(`\uC124\uCE58\uB41C pack\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${params.packId}`);
+  }
+  const pack = resolvePackById(params.packsDir ?? DEFAULT_PACKS_DIR, params.packId);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const applyResult = applyPackSourceFiles({ basePath: params.basePath, pack, previousRecord });
+  const nextManifest = upsertPackRecord(
     manifest,
-    allSkills
+    buildPackRecord({ pack, installedAt: previousRecord.installedAt }),
+    generatedAt
+  );
+  const derived = writeManifestWithDerivedState({
+    basePath: params.basePath,
+    manifest: nextManifest,
+    generatedAt
   });
-  const diffResult = computeDiff({
-    previous: manifest,
-    currentRules: resolvedRules.installedRules.map((rule) => rule.id),
-    currentSourceHash: sourceHash,
-    currentCliVersion: cliVersion
+  removeEmptyDirs2(params.basePath, applyResult.deleted);
+  return { ...applyResult, manifest: derived.manifest, contextIndex: derived.contextIndex };
+};
+var uninstallProjectLayerPack = (params) => {
+  const manifest = requireProjectLayerManifest(params.basePath);
+  const previousRecord = manifest.packs.find((pack) => pack.id === params.packId);
+  if (!previousRecord) {
+    throw new Error(`\uC124\uCE58\uB41C pack\uC744 \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4: ${params.packId}`);
+  }
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const applyResult = removePackFiles(params.basePath, previousRecord);
+  const nextManifest = removePackRecord(manifest, params.packId, generatedAt);
+  const derived = writeManifestWithDerivedState({
+    basePath: params.basePath,
+    manifest: nextManifest,
+    generatedAt
+  });
+  removeEmptyDirs2(params.basePath, applyResult.deleted);
+  return { ...applyResult, manifest: derived.manifest, contextIndex: derived.contextIndex };
+};
+var packIssue = (level, code, message) => ({
+  level,
+  code,
+  message
+});
+var diffProjectLayerPack = (params) => {
+  const manifest = requireProjectLayerManifest(params.basePath);
+  const targets = params.packId ? manifest.packs.filter((pack) => pack.id === params.packId) : manifest.packs;
+  const issues = [];
+  if (targets.length === 0) {
+    return { issues: [packIssue("warning", "missing-pack", "\uBE44\uAD50\uD560 \uC124\uCE58\uB41C pack\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.")] };
+  }
+  for (const record of targets) {
+    const pack = resolvePackById(params.packsDir ?? DEFAULT_PACKS_DIR, record.id);
+    if (record.sourceHash !== pack.sourceHash) {
+      issues.push(
+        packIssue("warning", "pack-source-hash-drift", `${record.id} sourceHash \uBCC0\uACBD: ${record.sourceHash} -> ${pack.sourceHash}`)
+      );
+    }
+    for (const file of [...record.documents, ...record.files]) {
+      const absolutePath = resolveProjectLayerFilePath(params.basePath, file.path);
+      if (!existsSync3(absolutePath)) {
+        issues.push(packIssue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
+      }
+    }
+  }
+  return { issues };
+};
+
+// src/core/uninstall-plan.ts
+import { join as join12 } from "path";
+
+// src/lib/paths.ts
+import { join as join13 } from "path";
+var resolveSkillsDir = () => join13(COMPILER_DATA_DIR, "skills");
+var resolveSubagentsDir = () => join13(COMPILER_DATA_DIR, "subagents");
+var resolvePacksDir = () => join13(COMPILER_DATA_DIR, "packs");
+var resolveBasePath = () => process.cwd();
+var resolveUserBasePath = () => {
+  const userBasePath = process.env.AI_OPS_HOME ?? process.env.HOME;
+  if (!userBasePath) {
+    throw new Error("AI_OPS_HOME or HOME is required for global asset commands");
+  }
+  return userBasePath;
+};
+
+// src/commands/project-layer-errors.ts
+import * as p from "@clack/prompts";
+import { ZodError } from "zod";
+var formatProjectLayerCommandError = (error) => {
+  if (error instanceof ZodError) {
+    return error.issues.map((issue2) => {
+      const path = issue2.path.length > 0 ? issue2.path.join(".") : "manifest";
+      return `${path}: ${issue2.message}`;
+    }).join("; ");
+  }
+  return error instanceof Error ? error.message : "unknown error";
+};
+var reportInvalidProjectLayerManifest = (params) => {
+  const reason = formatProjectLayerCommandError(params.error);
+  p.log.error(`[invalid-manifest] .ai-ops/manifest.json \uD30C\uC2F1 \uC2E4\uD328: ${reason}`);
+  process.exitCode = 1;
+  p.outro(params.outro);
+};
+var reportProjectLayerApplyError = (params) => {
+  const reason = formatProjectLayerCommandError(params.error);
+  p.log.error(`[project-layer-apply] project operating layer \uC801\uC6A9 \uC2E4\uD328: ${reason}`);
+  process.exitCode = 1;
+  p.outro(params.outro);
+};
+
+// src/commands/init.ts
+var TOOL_OPTIONS = [
+  { value: "codex", label: "Codex" },
+  { value: "gemini", label: "Gemini CLI" },
+  { value: "claude-code", label: "Claude Code" }
+];
+var promptTools = async () => {
+  const selectedTools = await p2.multiselect({
+    message: "AI \uB3C4\uAD6C adapter\uB97C \uC120\uD0DD\uD558\uC138\uC694",
+    options: TOOL_OPTIONS,
+    initialValues: TOOL_OPTIONS.map((option) => option.value),
+    required: true
   });
-  if (diffResult.status === "up-to-date" && !opts.force) {
-    p4.log.info("\uBCC0\uACBD \uC0AC\uD56D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
-    p4.outro("ai-ops update \uC644\uB8CC");
+  return p2.isCancel(selectedTools) ? null : resolveProjectLayerTools(selectedTools);
+};
+var initCommand = async (opts = {}) => {
+  p2.intro("ai-ops init");
+  const basePath = resolveBasePath();
+  const tools = opts.tool && opts.tool.length > 0 ? resolveProjectLayerTools(opts.tool) : await promptTools();
+  if (tools === null) {
+    p2.cancel("\uCDE8\uC18C\uB428");
+    process.exit(0);
+  }
+  let previousManifest;
+  try {
+    previousManifest = readProjectLayerManifest(basePath);
+  } catch (error) {
+    reportInvalidProjectLayerManifest({ error, outro: "ai-ops init \uC2E4\uD328" });
     return;
   }
-  const s = p4.spinner();
-  s.start("\uADDC\uCE59 \uAC31\uC2E0 \uC911...");
-  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"
+  let result;
+  try {
+    result = installProjectLayer({
+      basePath,
+      tools,
+      previousManifest
     });
-    installSkillPackages(basePath, packages);
-    return installedSkill;
-  });
-  if (manifest.workspaces) {
-    const workspaceEntries = Object.entries(resolvedRules.workspaces ?? {});
-    for (const toolIdStr of manifest.tools) {
-      const toolId = toolIdStr;
-      const rulesToInstall = resolvedRules.installedRules;
-      const workspaceMappings = workspaceEntries.map(([path, entry]) => ({
-        path,
-        ruleIds: entry.rules
-      }));
-      const renderResult = renderForTool(toolId, rulesToInstall, workspaceMappings);
-      const actions = buildInstallPlan({ toolId, renderResult, meta });
-      const r = installFiles(basePath, actions, meta);
-      allInstalledFiles.push(...r.written);
-      allAppended.push(...r.appended);
-    }
-  } else {
-    const rulesToInstall = resolvedRules.installedRules;
-    for (const toolIdStr of manifest.tools) {
-      const toolId = toolIdStr;
-      const renderResult = renderForTool(toolId, rulesToInstall);
-      const actions = buildInstallPlan({ toolId, renderResult, meta });
-      const r = installFiles(basePath, actions, meta);
-      allInstalledFiles.push(...r.written);
-      allAppended.push(...r.appended);
-    }
-  }
-  if (manifest.settings?.claude) {
-    installClaudeSettings(basePath, manifest.settings.claude);
-  }
-  if (manifest.settings?.gemini) {
-    installGeminiSettings(basePath, manifest.settings.gemini);
-  }
-  if (manifest.settings?.prettierignore) {
-    installPrettierIgnore(basePath);
-  }
-  const newManifest = buildManifest({
-    tools: manifest.tools,
-    scope: manifest.scope,
-    preset: manifest.preset,
-    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,
-      gemini: manifest.settings.gemini,
-      prettierignore: manifest.settings.prettierignore
-    } : void 0,
-    cliVersion,
-    sourceHash
-  });
-  writeManifest(manifestPath, newManifest);
-  s.stop("\uADDC\uCE59 \uAC31\uC2E0 \uC644\uB8CC");
-  p4.outro("ai-ops update \uC644\uB8CC");
+  } catch (error) {
+    reportProjectLayerApplyError({ error, outro: "ai-ops init \uC2E4\uD328" });
+    return;
+  }
+  p2.log.success(`project operating layer \uC124\uCE58 \uC644\uB8CC: ${result.manifest.managed_files.length + result.manifest.project_files.length}\uAC1C \uD30C\uC77C`);
+  p2.log.info(`\uB3C4\uAD6C adapter: ${result.manifest.tools.join(", ")}`);
+  if (result.appended.length > 0) {
+    p2.log.info(`\uAE30\uC874 \uD30C\uC77C\uC5D0 managed section \uCD94\uAC00:
+${result.appended.map((file) => `  ${file}`).join("\n")}`);
+  }
+  if (result.refreshedProjectFiles.length > 0) {
+    p2.log.info(`unmodified project-owned \uD30C\uC77C \uAC31\uC2E0:
+${result.refreshedProjectFiles.map((file) => `  ${file}`).join("\n")}`);
+  }
+  if (result.preservedProjectFiles.length > 0) {
+    p2.log.info(`\uAE30\uC874 project-owned \uD30C\uC77C \uBCF4\uC874:
+${result.preservedProjectFiles.map((file) => `  ${file}`).join("\n")}`);
+  }
+  p2.outro("ai-ops init \uC644\uB8CC");
 };
 
-// src/commands/diff.ts
-import * as p5 from "@clack/prompts";
-var diffCommand = async () => {
+// src/commands/update.ts
+import * as p3 from "@clack/prompts";
+var updateCommand = async (opts) => {
   const basePath = resolveBasePath();
-  p5.intro("ai-ops diff");
-  const manifest = readManifest(resolveManifestPath(basePath));
+  p3.intro("ai-ops update");
+  let manifest;
+  try {
+    manifest = readProjectLayerManifest(basePath);
+  } catch (error) {
+    reportInvalidProjectLayerManifest({ error, outro: "ai-ops update \uC2E4\uD328" });
+    return;
+  }
   if (!manifest) {
-    p5.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+    p3.log.error(".ai-ops/manifest.json\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
     process.exit(1);
   }
-  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: 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") {
-    p5.log.success("\uBCC0\uACBD \uC0AC\uD56D \uC5C6\uC74C. \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4.");
-  } else {
-    if (result.sourceChanged) {
-      p5.log.warn(`\uC18C\uC2A4 \uBCC0\uACBD \uAC10\uC9C0: ${manifest.sourceHash} \u2192 ${sourceHash}`);
-    }
-    if (result.added.length > 0) {
-      p5.log.info(`\uCD94\uAC00\uB41C \uADDC\uCE59: ${result.added.join(", ")}`);
-    }
-    if (result.removed.length > 0) {
-      p5.log.info(`\uC81C\uAC70\uB41C \uADDC\uCE59: ${result.removed.join(", ")}`);
-    }
+  const diffReport = diffProjectLayer(basePath);
+  if (diffReport.issues.length === 0 && !opts.force) {
+    p3.log.info("\uBCC0\uACBD \uC0AC\uD56D\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p3.outro("ai-ops update \uC644\uB8CC");
+    return;
   }
-  if (skillLines.length > 0) {
-    p5.log.info(`project skills:
-${skillLines.map((line) => `  ${line}`).join("\n")}`);
+  let result;
+  try {
+    result = updateProjectLayer({ basePath, manifest });
+  } catch (error) {
+    reportProjectLayerApplyError({ error, outro: "ai-ops update \uC2E4\uD328" });
+    return;
+  }
+  p3.log.success(`managed \uD30C\uC77C \uAC31\uC2E0: ${result.manifest.managed_files.length}\uAC1C`);
+  if (result.createdProjectFiles.length > 0) {
+    p3.log.info(`\uB204\uB77D\uB41C project-owned \uD30C\uC77C \uBCF5\uAD6C:
+${result.createdProjectFiles.map((file) => `  ${file}`).join("\n")}`);
+  }
+  if (result.refreshedProjectFiles.length > 0) {
+    p3.log.info(`unmodified project-owned \uD30C\uC77C \uAC31\uC2E0:
+${result.refreshedProjectFiles.map((file) => `  ${file}`).join("\n")}`);
   }
-  p5.outro("ai-ops diff \uC644\uB8CC");
+  if (result.preservedProjectFiles.length > 0) {
+    p3.log.info(`project-owned \uD30C\uC77C \uBCF4\uC874:
+${result.preservedProjectFiles.map((file) => `  ${file}`).join("\n")}`);
+  }
+  p3.outro("ai-ops update \uC644\uB8CC");
 };
 
-// src/commands/uninstall.ts
-import * as p6 from "@clack/prompts";
-import { rmSync as rmSync5 } from "fs";
-
-// src/lib/uninstall.ts
-import { existsSync as existsSync7, readFileSync as readFileSync8, rmSync as rmSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync7 } 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 = resolve7(basePath, rel);
-    if (!existsSync7(absPath)) {
-      notFound.push(rel);
-      continue;
-    }
-    const content = readFileSync8(absPath, "utf-8");
-    if (hasAiOpsSection(content)) {
-      const stripped = stripAiOpsSection(content);
-      if (stripped.trim().length === 0) {
-        rmSync4(absPath);
-        deleted.push(rel);
-      } else {
-        writeFileSync7(absPath, stripped, "utf-8");
-        cleaned.push(rel);
-      }
-    } else if (hasLegacyHeader(content)) {
-      rmSync4(absPath);
-      deleted.push(rel);
+// src/commands/diff.ts
+import * as p4 from "@clack/prompts";
+var diffCommand = async () => {
+  p4.intro("ai-ops diff");
+  const report = diffProjectLayer(resolveBasePath());
+  if (report.issues.length === 0) {
+    p4.log.success("\uBCC0\uACBD \uC0AC\uD56D \uC5C6\uC74C. \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4.");
+    p4.outro("ai-ops diff \uC644\uB8CC");
+    return;
+  }
+  for (const item of report.issues) {
+    const line = `[${item.code}] ${item.message}`;
+    if (item.level === "error") {
+      p4.log.error(line);
     } else {
-      skipped.push(rel);
+      p4.log.warn(line);
     }
   }
-  return { deleted, cleaned, skipped, notFound };
-};
-var cleanEmptyDirs = (basePath, dirs) => {
-  const removed = [];
-  for (const dir of dirs) {
-    const absDir = resolve7(basePath, dir);
-    if (!existsSync7(absDir)) continue;
-    try {
-      const entries = readdirSync4(absDir);
-      if (entries.length === 0) {
-        rmSync4(absDir, { recursive: true });
-        removed.push(dir);
-      }
-    } catch {
-    }
+  if (report.issues.some((item) => item.level === "error")) {
+    process.exitCode = 1;
   }
-  return removed;
+  p4.outro("ai-ops diff \uC644\uB8CC");
 };
-var collectManagedDirs = (relativePaths) => {
-  const dirs = /* @__PURE__ */ new Set();
-  for (const rel of relativePaths) {
-    const dir = dirname7(rel);
-    if (dir !== ".") {
-      dirs.add(dir);
+
+// src/commands/audit.ts
+import * as p5 from "@clack/prompts";
+var auditCommand = async () => {
+  p5.intro("ai-ops audit");
+  const report = auditProjectLayer(resolveBasePath());
+  if (report.issues.length === 0) {
+    p5.log.success("audit \uD1B5\uACFC. manifest, context-layer, frontmatter, docs-status\uAC00 \uC77C\uCE58\uD569\uB2C8\uB2E4.");
+    p5.outro("ai-ops audit \uC644\uB8CC");
+    return;
+  }
+  for (const item of report.issues) {
+    const line = `[${item.code}] ${item.message}`;
+    if (item.level === "error") {
+      p5.log.error(line);
+    } else {
+      p5.log.warn(line);
     }
   }
-  return [...dirs];
+  if (report.issues.some((item) => item.level === "error")) {
+    process.exitCode = 1;
+  }
+  p5.outro("ai-ops audit \uC644\uB8CC");
 };
 
 // src/commands/uninstall.ts
-var SETTINGS_PATHS = /* @__PURE__ */ new Set([".claude/settings.local.json", ".gemini/settings.json"]);
-var uninstallCommand = async () => {
+import * as p6 from "@clack/prompts";
+var uninstallCommand = async (opts = {}) => {
   const basePath = resolveBasePath();
-  const manifestPath = resolveManifestPath(basePath);
   p6.intro("ai-ops uninstall");
-  const manifest = readManifest(manifestPath);
-  if (!manifest) {
-    p6.log.error("manifest\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
-    process.exit(1);
-  }
-  const targetFiles = [
-    ...manifest.installed_files ?? inferInstalledFiles(manifest),
-    ...manifest.appended_files ?? []
-  ].filter((f) => !SETTINGS_PATHS.has(f));
-  const targetSkillDirs = (manifest.installed_skills ?? []).flatMap((skill) => skill.installed_paths);
-  if (targetFiles.length === 0 && targetSkillDirs.length === 0) {
-    p6.log.warn("\uC0AD\uC81C\uD560 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
-    p6.outro("ai-ops uninstall \uC644\uB8CC");
+  let manifest;
+  try {
+    manifest = readProjectLayerManifest(basePath);
+  } catch (error) {
+    reportInvalidProjectLayerManifest({ error, outro: "ai-ops uninstall \uC2E4\uD328" });
     return;
   }
-  if (targetFiles.length > 0) {
-    p6.log.info(`\uC0AD\uC81C \uB300\uC0C1 \uD30C\uC77C (${targetFiles.length}\uAC1C):
-${targetFiles.map((f) => `  ${f}`).join("\n")}`);
+  if (!manifest) {
+    p6.log.error(".ai-ops/manifest.json\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. project operating layer\uAC00 \uC124\uCE58\uB418\uC5B4 \uC788\uC9C0 \uC54A\uC2B5\uB2C8\uB2E4.");
+    process.exitCode = 1;
+    p6.outro("ai-ops uninstall \uC2E4\uD328");
+    return;
   }
-  if (targetSkillDirs.length > 0) {
-    p6.log.info(
-      `\uC0AD\uC81C \uB300\uC0C1 skill \uB514\uB809\uD1A0\uB9AC (${targetSkillDirs.length}\uAC1C):
-${targetSkillDirs.map((f) => `  ${f}`).join("\n")}`
-    );
+  const targetFiles = [
+    ...manifest.managed_files.map((file) => file.path),
+    ...manifest.project_files.map((file) => file.path),
+    ".ai-ops/context-layer.json",
+    ".ai-ops/manifest.json"
+  ];
+  p6.log.info(`\uCC98\uB9AC \uB300\uC0C1 (${targetFiles.length}\uAC1C):
+${targetFiles.map((file) => `  ${file}`).join("\n")}`);
+  if (!opts.yes) {
+    const confirmed = await p6.confirm({
+      message: "project operating layer\uB97C \uC81C\uAC70\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
+      initialValue: false
+    });
+    if (p6.isCancel(confirmed) || !confirmed) {
+      p6.cancel("\uCDE8\uC18C\uB428");
+      process.exit(0);
+    }
   }
-  const confirmed = await p6.confirm({
-    message: "\uC704 \uD30C\uC77C\uACFC manifest\uB97C \uBAA8\uB450 \uC0AD\uC81C\uD558\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?",
-    initialValue: false
-  });
-  if (p6.isCancel(confirmed) || !confirmed) {
-    p6.cancel("\uCDE8\uC18C\uB428");
-    process.exit(0);
+  let result;
+  try {
+    result = uninstallProjectLayer(basePath, manifest);
+  } catch (error) {
+    reportProjectLayerApplyError({ error, outro: "ai-ops uninstall \uC2E4\uD328" });
+    return;
   }
-  const settingsMessages = [];
-  if (manifest.settings?.claude) {
-    const status = uninstallClaudeSettings(basePath, manifest.settings.claude);
-    if (status === "deleted") settingsMessages.push("\uC0AD\uC81C: .claude/settings.local.json");
-    else if (status === "cleaned")
-      settingsMessages.push("ai-ops \uD0A4 \uC81C\uAC70 (\uC0AC\uC6A9\uC790 \uC124\uC815 \uBCF4\uC874): .claude/settings.local.json");
-  }
-  if (manifest.settings?.gemini) {
-    const status = uninstallGeminiSettings(basePath, manifest.settings.gemini);
-    if (status === "deleted") settingsMessages.push("\uC0AD\uC81C: .gemini/settings.json");
-    else if (status === "cleaned") settingsMessages.push("ai-ops \uD0A4 \uC81C\uAC70 (\uC0AC\uC6A9\uC790 \uC124\uC815 \uBCF4\uC874): .gemini/settings.json");
-  }
-  const prettierStatus = uninstallPrettierIgnore(basePath);
-  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 });
   if (result.deleted.length > 0) {
-    p6.log.success(`\uC0AD\uC81C \uC644\uB8CC (${result.deleted.length}\uAC1C):
-${result.deleted.map((f) => `  ${f}`).join("\n")}`);
+    p6.log.success(`\uC0AD\uC81C \uC644\uB8CC:
+${result.deleted.map((file) => `  ${file}`).join("\n")}`);
   }
   if (result.cleaned.length > 0) {
-    p6.log.success(
-      `\uC139\uC158 \uC81C\uAC70 \uC644\uB8CC (\uC0AC\uC6A9\uC790 \uB0B4\uC6A9 \uBCF4\uC874, ${result.cleaned.length}\uAC1C):
-${result.cleaned.map((f) => `  ${f}`).join("\n")}`
-    );
+    p6.log.success(`managed section \uC81C\uAC70, \uC0AC\uC6A9\uC790 \uB0B4\uC6A9 \uBCF4\uC874:
+${result.cleaned.map((file) => `  ${file}`).join("\n")}`);
   }
-  if (result.skipped.length > 0) {
-    p6.log.warn(
-      `\uAC74\uB108\uB700 (non-managed \uD30C\uC77C \uBCF4\uD638, ${result.skipped.length}\uAC1C):
-${result.skipped.map((f) => `  ${f}`).join("\n")}`
-    );
+  if (result.preserved.length > 0) {
+    p6.log.info(`\uC218\uC815\uB418\uC5C8\uAC70\uB098 \uAE30\uC874\uC5D0 \uC788\uB358 project-owned \uD30C\uC77C \uBCF4\uC874:
+${result.preserved.map((file) => `  ${file}`).join("\n")}`);
   }
   if (result.notFound.length > 0) {
-    p6.log.info(`\uC774\uBBF8 \uC5C6\uC74C (${result.notFound.length}\uAC1C):
-${result.notFound.map((f) => `  ${f}`).join("\n")}`);
-  }
-  if (removedDirs.length > 0) {
-    p6.log.info(`\uBE48 \uB514\uB809\uD1A0\uB9AC \uC815\uB9AC (${removedDirs.length}\uAC1C):
-${removedDirs.map((d) => `  ${d}`).join("\n")}`);
-  }
-  if (removedSkillDirs.length > 0) {
-    p6.log.success(
-      `skill \uB514\uB809\uD1A0\uB9AC \uC0AD\uC81C (${removedSkillDirs.length}\uAC1C):
-${removedSkillDirs.map((d) => `  ${d}`).join("\n")}`
-    );
-  }
-  if (settingsMessages.length > 0) {
-    p6.log.success(`\uC124\uC815 \uD30C\uC77C \uCC98\uB9AC:
-${settingsMessages.map((m) => `  ${m}`).join("\n")}`);
+    p6.log.info(`\uC774\uBBF8 \uC5C6\uC74C:
+${result.notFound.map((file) => `  ${file}`).join("\n")}`);
   }
-  p6.log.success(`manifest \uC0AD\uC81C: ${MANIFEST_FILENAME}`);
   p6.outro("ai-ops uninstall \uC644\uB8CC");
 };
 
 // src/commands/skill.ts
 import * as p7 from "@clack/prompts";
-import { rmSync as rmSync6 } from "fs";
-var resolveScopeContext = (opts) => {
-  const scope = resolveSkillScope(opts);
-  return {
-    scope,
-    basePath: scope === "project" ? resolveBasePath() : resolveUserBasePath()
-  };
+import { rmSync as rmSync4 } from "fs";
+
+// src/lib/skill-state.ts
+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_ORDER2 = [SKILL_TOOL.CLAUDE_CODE, SKILL_TOOL.CODEX, SKILL_TOOL.GEMINI];
+var mergeSkillTools = (params) => {
+  const merged = /* @__PURE__ */ new Set([...params.existing ?? [], ...params.requested]);
+  return TOOL_ORDER2.filter((tool) => merged.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/lib/skill-install.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, resolve as resolve7 } from "path";
+var installSkillPackages = (basePath, packages) => {
+  const writtenRoots = [];
+  for (const skillPackage of packages) {
+    const absRoot = resolve7(basePath, skillPackage.rootDir);
+    if (existsSync4(absRoot)) {
+      rmSync3(absRoot, { recursive: true, force: true });
+    }
+    for (const file of skillPackage.files) {
+      const absPath = resolve7(basePath, file.relativePath);
+      mkdirSync6(dirname8(absPath), { recursive: true });
+      writeFileSync6(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 = resolve7(basePath, relativeDir);
+    if (!existsSync4(absPath)) continue;
+    rmSync3(absPath, { recursive: true, force: true });
+    removed.push(relativeDir);
+  }
+  return removed;
 };
+
+// src/commands/skill.ts
 var loadCompilerInputs = () => {
-  const compilerDataDir = resolveCompilerDataDir();
   return {
     allSkills: loadAllSkills(resolveSkillsDir()),
-    sourceHash: computeSourceHash(compilerDataDir),
     cliVersion: getCliVersion()
   };
 };
@@ -2003,42 +2124,12 @@ var resolveSkillById = (skills, 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) {
-    rmSync6(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) {
-    rmSync6(registryPath, { force: true });
+    rmSync4(registryPath, { force: true });
     return;
   }
   writeSkillRegistry(registryPath, {
@@ -2047,20 +2138,14 @@ var writeUserSkillState = (params) => {
     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)
-    }));
-  }
+var readInstalledSkills = (basePath) => {
   return (readSkillRegistry(resolveSkillRegistryPath(basePath))?.skills ?? []).map((installedSkill) => ({
     ...installedSkill,
     id: resolveCanonicalSkillId(installedSkill.id)
   }));
 };
 var installSkill = (params) => {
-  const installedSkills = readInstalledSkills(params.scope, params.basePath);
+  const installedSkills = readInstalledSkills(params.basePath);
   const existingInstalledSkill = findInstalledSkill(installedSkills, params.skill.id);
   const nextRequestedTools = mergeSkillTools({
     existing: existingInstalledSkill?.tools,
@@ -2068,31 +2153,21 @@ var installSkill = (params) => {
   });
   const { packages, installedSkill } = buildSkillInstallPlan({
     skill: params.skill,
-    requestedTools: nextRequestedTools,
-    scope: params.scope
+    requestedTools: nextRequestedTools
   });
   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
-    });
-  }
+  writeUserSkillState({
+    basePath: params.basePath,
+    cliVersion: params.cliVersion,
+    nextSkill: installedSkill
+  });
   return installedSkill;
 };
-var skillListCommand = async (opts) => {
-  const { scope, basePath } = resolveScopeContext(opts);
+var skillListCommand = async () => {
+  const basePath = resolveUserBasePath();
   const { allSkills } = loadCompilerInputs();
-  const installedSkills = readInstalledSkills(scope, basePath);
-  p7.intro(`ai-ops skill list (${scope})`);
+  const installedSkills = readInstalledSkills(basePath);
+  p7.intro("ai-ops skill list");
   const sections = [
     { kind: "reference", title: "reference skills" },
     { kind: "task", title: "task skills" }
@@ -2100,7 +2175,7 @@ var skillListCommand = async (opts) => {
     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}`;
+      return `- ${skill.id} - ${suffix}`;
     });
     if (lines.length === 0) {
       return null;
@@ -2112,29 +2187,26 @@ ${lines.join("\n")}`;
   p7.outro("ai-ops skill list \uC644\uB8CC");
 };
 var skillInstallCommand = async (skillId, opts) => {
-  const { scope, basePath } = resolveScopeContext(opts);
-  const { allSkills, sourceHash, cliVersion } = loadCompilerInputs();
+  const basePath = resolveUserBasePath();
+  const { allSkills, cliVersion } = loadCompilerInputs();
   const skill = resolveSkillById(allSkills, skillId);
-  assertScopeAllowed(skill, scope);
   const requestedTools = resolveRequestedTools({ requested: opts.tool, supported: skill.supported_tools });
   p7.intro(`ai-ops skill install ${skillId}`);
   const installedSkill = installSkill({
     skill,
     requestedTools,
-    scope,
     basePath,
-    cliVersion,
-    sourceHash
+    cliVersion
   });
   p7.log.success(`\uC124\uCE58 \uC644\uB8CC: ${installedSkill.id} (${installedSkill.installed_paths.join(", ")})`);
   p7.outro("ai-ops skill install \uC644\uB8CC");
 };
-var skillDiffCommand = async (skillId, opts) => {
-  const { scope, basePath } = resolveScopeContext(opts);
+var skillDiffCommand = async (skillId) => {
+  const basePath = resolveUserBasePath();
   const { allSkills } = loadCompilerInputs();
-  const installedSkills = readInstalledSkills(scope, basePath);
+  const installedSkills = readInstalledSkills(basePath);
   const targets = skillId ? installedSkills.filter((skill) => skill.id === skillId) : installedSkills;
-  p7.intro(`ai-ops skill diff (${scope})`);
+  p7.intro("ai-ops skill diff");
   if (targets.length === 0) {
     p7.log.warn("\uBE44\uAD50\uD560 \uC124\uCE58\uB41C skill\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
     p7.outro("ai-ops skill diff \uC644\uB8CC");
@@ -2144,8 +2216,7 @@ var skillDiffCommand = async (skillId, opts) => {
     const skill = resolveSkillById(allSkills, installedSkill.id);
     const { installedSkill: next } = buildSkillInstallPlan({
       skill,
-      requestedTools: installedSkill.tools,
-      scope
+      requestedTools: installedSkill.tools
     });
     const changed = next.sourceHash !== installedSkill.sourceHash;
     return `- ${installedSkill.id}: ${changed ? "changed" : "up-to-date"} (${installedSkill.sourceHash} -> ${next.sourceHash})`;
@@ -2153,12 +2224,12 @@ var skillDiffCommand = async (skillId, opts) => {
   p7.log.info(lines.join("\n"));
   p7.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);
+var skillUpdateCommand = async (skillId) => {
+  const basePath = resolveUserBasePath();
+  const { allSkills, cliVersion } = loadCompilerInputs();
+  const installedSkills = readInstalledSkills(basePath);
   const targets = skillId ? installedSkills.filter((skill) => skill.id === skillId) : installedSkills;
-  p7.intro(`ai-ops skill update (${scope})`);
+  p7.intro("ai-ops skill update");
   if (targets.length === 0) {
     p7.log.warn("\uAC31\uC2E0\uD560 \uC124\uCE58\uB41C skill\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
     p7.outro("ai-ops skill update \uC644\uB8CC");
@@ -2168,57 +2239,29 @@ var skillUpdateCommand = async (skillId, opts) => {
     const skill = resolveSkillById(allSkills, installedSkill.id);
     const { packages, installedSkill: next } = buildSkillInstallPlan({
       skill,
-      requestedTools: installedSkill.tools,
-      scope
+      requestedTools: installedSkill.tools
     });
     installSkillPackages(basePath, packages);
     return next;
   });
-  if (scope === "project") {
-    const manifestPath = resolveManifestPath(basePath);
-    const previous = readManifest(manifestPath);
-    if (!previous) {
-      p7.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()
-    });
-  }
+  const registryPath = resolveSkillRegistryPath(basePath);
+  const previous = readSkillRegistry(registryPath);
+  const nextSkillIds = new Set(nextInstalledSkills.map((skill) => skill.id));
+  const untouched = (previous?.skills ?? []).filter(
+    (installedSkill) => !nextSkillIds.has(resolveCanonicalSkillId(installedSkill.id))
+  );
+  writeSkillRegistry(registryPath, {
+    skills: [...untouched, ...nextInstalledSkills],
+    cliVersion,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
   p7.log.success(`\uAC31\uC2E0 \uC644\uB8CC: ${nextInstalledSkills.map((skill) => skill.id).join(", ")}`);
   p7.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);
+var skillUninstallCommand = async (skillId) => {
+  const basePath = resolveUserBasePath();
+  const { cliVersion } = loadCompilerInputs();
+  const installedSkills = readInstalledSkills(basePath);
   const installedSkill = findInstalledSkill(installedSkills, skillId);
   p7.intro(`ai-ops skill uninstall ${skillId}`);
   if (!installedSkill) {
@@ -2227,70 +2270,416 @@ var skillUninstallCommand = async (skillId, opts) => {
     return;
   }
   const removed = removeDirectories(basePath, installedSkill.installed_paths);
-  if (scope === "project") {
-    writeProjectSkillState({
-      basePath,
-      sourceHash,
-      cliVersion,
-      removeSkillId: skillId
-    });
-  } else {
-    writeUserSkillState({
-      basePath,
-      cliVersion,
-      removeSkillId: skillId
-    });
-  }
+  writeUserSkillState({
+    basePath,
+    cliVersion,
+    removeSkillId: skillId
+  });
   p7.log.success(`\uC81C\uAC70 \uC644\uB8CC: ${removed.join(", ")}`);
   p7.outro("ai-ops skill uninstall \uC644\uB8CC");
 };
 
-// src/commands/spec.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync6, writeFileSync as writeFileSync8 } from "fs";
-import { join as join13, dirname as dirname8 } from "path";
+// src/commands/subagent.ts
 import * as p8 from "@clack/prompts";
-var specInitCommand = async (opts) => {
-  p8.intro("ai-ops spec init");
-  const specsDir = join13(process.cwd(), "specs");
-  if (existsSync8(specsDir) && !opts.force) {
-    p8.log.error("specs/ \uB514\uB809\uD1A0\uB9AC\uAC00 \uC774\uBBF8 \uC874\uC7AC\uD569\uB2C8\uB2E4. \uB36E\uC5B4\uC4F0\uB824\uBA74 --force \uC635\uC158\uC744 \uC0AC\uC6A9\uD558\uC138\uC694.");
-    process.exit(1);
+import { existsSync as existsSync6, rmSync as rmSync6 } from "fs";
+
+// src/lib/subagent-install.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname9, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve8 } from "path";
+var resolveInsideBasePath = (basePath, relativePath) => {
+  const absBasePath = resolve8(basePath);
+  const absPath = resolve8(absBasePath, relativePath);
+  const fromBase = relative3(absBasePath, absPath);
+  if (fromBase.length === 0 || fromBase.startsWith("..") || isAbsolute3(fromBase)) {
+    throw new Error(`Subagent path escapes AI_OPS_HOME: ${relativePath}`);
+  }
+  return absPath;
+};
+var installSubagentPackages = (basePath, packages) => {
+  const written = [];
+  for (const subagentPackage of packages) {
+    for (const file of subagentPackage.files) {
+      const absPath = resolveInsideBasePath(basePath, file.relativePath);
+      if (existsSync5(absPath)) {
+        rmSync5(absPath, { recursive: true, force: true });
+      }
+      mkdirSync7(dirname9(absPath), { recursive: true });
+      writeFileSync7(absPath, file.content.trimEnd() + "\n", "utf-8");
+      written.push(file.relativePath);
+    }
+  }
+  return written;
+};
+var removeSubagentFiles = (basePath, relativePaths) => {
+  const removed = [];
+  for (const relativePath of relativePaths) {
+    const absPath = resolveInsideBasePath(basePath, relativePath);
+    if (!existsSync5(absPath)) continue;
+    rmSync5(absPath, { recursive: true, force: true });
+    removed.push(relativePath);
+  }
+  return removed;
+};
+
+// src/lib/subagent-state.ts
+var resolveRequestedSubagentTools = (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_ORDER3 = [SKILL_TOOL.CLAUDE_CODE, SKILL_TOOL.CODEX, SKILL_TOOL.GEMINI];
+var mergeSubagentTools = (params) => {
+  const merged = /* @__PURE__ */ new Set([...params.existing ?? [], ...params.requested]);
+  return TOOL_ORDER3.filter((tool) => merged.has(tool));
+};
+var upsertInstalledSubagent = (installedSubagents, nextSubagent) => {
+  const remaining = installedSubagents.filter((subagent) => subagent.id !== nextSubagent.id);
+  return [...remaining, nextSubagent];
+};
+var removeInstalledSubagent = (installedSubagents, subagentId) => installedSubagents.filter((subagent) => subagent.id !== subagentId);
+var findInstalledSubagent = (installedSubagents, subagentId) => installedSubagents.find((subagent) => subagent.id === subagentId);
+var resolveInstalledSubagentPaths = (installedSubagent) => installedSubagent.tools.map((tool) => buildSubagentRelativePath(installedSubagent.id, tool));
+
+// src/commands/subagent.ts
+var loadCompilerInputs2 = () => {
+  return {
+    allSubagents: loadAllSubagents(resolveSubagentsDir()),
+    cliVersion: getCliVersion()
+  };
+};
+var resolveSubagentById = (subagents, subagentId) => {
+  const subagent = subagents.find((candidate) => candidate.id === subagentId);
+  if (!subagent) {
+    throw new Error(`Unknown subagent: ${subagentId}`);
+  }
+  return subagent;
+};
+var writeUserSubagentState = (params) => {
+  const manifestPath = resolveSubagentManifestPath(params.basePath);
+  const previous = readSubagentManifest(manifestPath);
+  const subagents = params.removeSubagentId ? removeInstalledSubagent(previous?.subagents ?? [], params.removeSubagentId) : params.nextSubagent ? upsertInstalledSubagent(previous?.subagents ?? [], params.nextSubagent) : previous?.subagents ?? [];
+  if (subagents.length === 0) {
+    rmSync6(manifestPath, { force: true });
+    return;
+  }
+  writeSubagentManifest(manifestPath, {
+    subagents,
+    cliVersion: params.cliVersion,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+var readInstalledSubagents = (basePath) => readSubagentManifest(resolveSubagentManifestPath(basePath))?.subagents ?? [];
+var warnMissingSkills = (requiredSkills) => {
+  const missing = requiredSkills.filter((skill) => !existsSync6(skill.path));
+  if (missing.length === 0) {
+    return;
+  }
+  p8.log.warn(
+    [
+      "\uD544\uC694\uD55C skill\uC774 \uC544\uC9C1 \uC124\uCE58\uB418\uC9C0 \uC54A\uC558\uC2B5\uB2C8\uB2E4. subagent \uC124\uCE58\uB294 \uACC4\uC18D \uC9C4\uD589\uD569\uB2C8\uB2E4.",
+      ...missing.map((skill) => `- ${skill.tool}:${skill.skillName} (${skill.path})`)
+    ].join("\n")
+  );
+};
+var installSubagent = (params) => {
+  const installedSubagents = readInstalledSubagents(params.basePath);
+  const existingInstalledSubagent = findInstalledSubagent(installedSubagents, params.subagent.id);
+  const nextRequestedTools = mergeSubagentTools({
+    existing: existingInstalledSubagent?.tools,
+    requested: params.requestedTools
+  });
+  const { packages, installedSubagent, requiredSkills } = buildSubagentInstallPlan({
+    subagent: params.subagent,
+    requestedTools: nextRequestedTools,
+    userBasePath: params.basePath
+  });
+  installSubagentPackages(params.basePath, packages);
+  warnMissingSkills(requiredSkills);
+  writeUserSubagentState({
+    basePath: params.basePath,
+    cliVersion: params.cliVersion,
+    nextSubagent: installedSubagent
+  });
+  return installedSubagent;
+};
+var subagentListCommand = async () => {
+  const basePath = resolveUserBasePath();
+  const { allSubagents } = loadCompilerInputs2();
+  const installedSubagents = readInstalledSubagents(basePath);
+  p8.intro("ai-ops subagent list");
+  const lines = allSubagents.map((subagent) => {
+    const installed = findInstalledSubagent(installedSubagents, subagent.id);
+    const suffix = installed ? `installed for ${installed.tools.join(", ")}` : "not installed";
+    return `- ${subagent.id} - ${suffix}`;
+  });
+  p8.log.info(lines.join("\n"));
+  p8.outro("ai-ops subagent list \uC644\uB8CC");
+};
+var subagentInstallCommand = async (subagentId, opts) => {
+  const basePath = resolveUserBasePath();
+  const { allSubagents, cliVersion } = loadCompilerInputs2();
+  const subagent = resolveSubagentById(allSubagents, subagentId);
+  const requestedTools = resolveRequestedSubagentTools({ requested: opts.tool, supported: subagent.supported_tools });
+  p8.intro(`ai-ops subagent install ${subagentId}`);
+  const installedSubagent = installSubagent({
+    subagent,
+    requestedTools,
+    basePath,
+    cliVersion
+  });
+  p8.log.success(`\uC124\uCE58 \uC644\uB8CC: ${installedSubagent.id} (${installedSubagent.installed_paths.join(", ")})`);
+  p8.outro("ai-ops subagent install \uC644\uB8CC");
+};
+var subagentDiffCommand = async (subagentId) => {
+  const basePath = resolveUserBasePath();
+  const { allSubagents } = loadCompilerInputs2();
+  const installedSubagents = readInstalledSubagents(basePath);
+  const targets = subagentId ? installedSubagents.filter((subagent) => subagent.id === subagentId) : installedSubagents;
+  p8.intro("ai-ops subagent diff");
+  if (targets.length === 0) {
+    p8.log.warn("\uBE44\uAD50\uD560 \uC124\uCE58\uB41C subagent\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p8.outro("ai-ops subagent diff \uC644\uB8CC");
+    return;
+  }
+  const lines = targets.map((installedSubagent) => {
+    const subagent = resolveSubagentById(allSubagents, installedSubagent.id);
+    const { installedSubagent: next } = buildSubagentInstallPlan({
+      subagent,
+      requestedTools: installedSubagent.tools,
+      userBasePath: basePath
+    });
+    const changed = next.sourceHash !== installedSubagent.sourceHash;
+    return `- ${installedSubagent.id}: ${changed ? "changed" : "up-to-date"} (${installedSubagent.sourceHash} -> ${next.sourceHash})`;
+  });
+  p8.log.info(lines.join("\n"));
+  p8.outro("ai-ops subagent diff \uC644\uB8CC");
+};
+var subagentUpdateCommand = async (subagentId) => {
+  const basePath = resolveUserBasePath();
+  const { allSubagents, cliVersion } = loadCompilerInputs2();
+  const installedSubagents = readInstalledSubagents(basePath);
+  const targets = subagentId ? installedSubagents.filter((subagent) => subagent.id === subagentId) : installedSubagents;
+  p8.intro("ai-ops subagent update");
+  if (targets.length === 0) {
+    p8.log.warn("\uAC31\uC2E0\uD560 \uC124\uCE58\uB41C subagent\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.");
+    p8.outro("ai-ops subagent update \uC644\uB8CC");
+    return;
+  }
+  const nextInstalledSubagents = targets.map((installedSubagent) => {
+    const subagent = resolveSubagentById(allSubagents, installedSubagent.id);
+    const { packages, installedSubagent: next, requiredSkills } = buildSubagentInstallPlan({
+      subagent,
+      requestedTools: installedSubagent.tools,
+      userBasePath: basePath
+    });
+    installSubagentPackages(basePath, packages);
+    warnMissingSkills(requiredSkills);
+    return next;
+  });
+  const manifestPath = resolveSubagentManifestPath(basePath);
+  const previous = readSubagentManifest(manifestPath);
+  const nextSubagentIds = new Set(nextInstalledSubagents.map((subagent) => subagent.id));
+  const untouched = (previous?.subagents ?? []).filter((subagent) => !nextSubagentIds.has(subagent.id));
+  writeSubagentManifest(manifestPath, {
+    subagents: [...untouched, ...nextInstalledSubagents],
+    cliVersion,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  p8.log.success(`\uAC31\uC2E0 \uC644\uB8CC: ${nextInstalledSubagents.map((subagent) => subagent.id).join(", ")}`);
+  p8.outro("ai-ops subagent update \uC644\uB8CC");
+};
+var subagentUninstallCommand = async (subagentId) => {
+  const basePath = resolveUserBasePath();
+  const cliVersion = getCliVersion();
+  const installedSubagents = readInstalledSubagents(basePath);
+  const installedSubagent = findInstalledSubagent(installedSubagents, subagentId);
+  p8.intro(`ai-ops subagent uninstall ${subagentId}`);
+  if (!installedSubagent) {
+    p8.log.warn("\uC124\uCE58\uB41C subagent\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+    p8.outro("ai-ops subagent uninstall \uC644\uB8CC");
+    return;
+  }
+  const removed = removeSubagentFiles(basePath, resolveInstalledSubagentPaths(installedSubagent));
+  writeUserSubagentState({
+    basePath,
+    cliVersion,
+    removeSubagentId: subagentId
+  });
+  p8.log.success(`\uC81C\uAC70 \uC644\uB8CC: ${removed.join(", ")}`);
+  p8.outro("ai-ops subagent uninstall \uC644\uB8CC");
+};
+
+// src/commands/pack.ts
+import * as p9 from "@clack/prompts";
+var readManifestForPackCommand = (basePath) => {
+  try {
+    return readProjectLayerManifest(basePath);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown error";
+    p9.log.error(`.ai-ops/manifest.json \uD30C\uC2F1 \uC2E4\uD328: ${message}`);
+    process.exitCode = 1;
+    return null;
+  }
+};
+var reportPackError = (error) => {
+  const message = error instanceof Error ? error.message : "unknown error";
+  p9.log.error(message);
+  process.exitCode = 1;
+};
+var packListCommand = async () => {
+  const basePath = resolveBasePath();
+  const packs = loadAllPacks(resolvePacksDir());
+  const manifest = readManifestForPackCommand(basePath);
+  const installedPackIds = new Set(manifest?.packs.map((pack) => pack.id) ?? []);
+  p9.intro("ai-ops pack list");
+  p9.log.info(
+    packs.map((pack) => {
+      const suffix = installedPackIds.has(pack.id) ? "installed" : "not installed";
+      return `- ${pack.id} - ${suffix}`;
+    }).join("\n")
+  );
+  p9.outro("ai-ops pack list \uC644\uB8CC");
+};
+var packInstallCommand = async (packId) => {
+  const basePath = resolveBasePath();
+  p9.intro(`ai-ops pack install ${packId}`);
+  try {
+    const result = installProjectLayerPack({ basePath, packId, packsDir: resolvePacksDir() });
+    p9.log.success(`pack \uC124\uCE58 \uC644\uB8CC: ${packId}`);
+    if (result.written.length > 0) {
+      p9.log.info(`\uC0DD\uC131:
+${result.written.map((file) => `  ${file}`).join("\n")}`);
+    }
+    if (result.refreshed.length > 0) {
+      p9.log.info(`\uAC31\uC2E0:
+${result.refreshed.map((file) => `  ${file}`).join("\n")}`);
+    }
+    if (result.preserved.length > 0) {
+      p9.log.info(`\uBCF4\uC874:
+${result.preserved.map((file) => `  ${file}`).join("\n")}`);
+    }
+  } catch (error) {
+    reportPackError(error);
+  }
+  p9.outro("ai-ops pack install \uC644\uB8CC");
+};
+var packDiffCommand = async (packId) => {
+  const basePath = resolveBasePath();
+  p9.intro("ai-ops pack diff");
+  try {
+    const report = diffProjectLayerPack({ basePath, packId, packsDir: resolvePacksDir() });
+    if (report.issues.length === 0) {
+      p9.log.success("\uBCC0\uACBD \uC0AC\uD56D \uC5C6\uC74C. pack\uC774 \uCD5C\uC2E0 \uC0C1\uD0DC\uC785\uB2C8\uB2E4.");
+      p9.outro("ai-ops pack diff \uC644\uB8CC");
+      return;
+    }
+    for (const item of report.issues) {
+      const line = `[${item.code}] ${item.message}`;
+      if (item.level === "error") {
+        p9.log.error(line);
+      } else {
+        p9.log.warn(line);
+      }
+    }
+    if (report.issues.some((item) => item.level === "error")) {
+      process.exitCode = 1;
+    }
+  } catch (error) {
+    reportPackError(error);
+  }
+  p9.outro("ai-ops pack diff \uC644\uB8CC");
+};
+var packUpdateCommand = async (packId) => {
+  const basePath = resolveBasePath();
+  p9.intro("ai-ops pack update");
+  try {
+    const manifest = readManifestForPackCommand(basePath);
+    if (!manifest) {
+      p9.log.error(".ai-ops/manifest.json\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 ai-ops init\uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+      process.exitCode = 1;
+      p9.outro("ai-ops pack update \uC644\uB8CC");
+      return;
+    }
+    const targetPackIds = packId ? [packId] : manifest.packs.map((pack) => pack.id);
+    if (targetPackIds.length === 0) {
+      p9.log.warn("\uAC31\uC2E0\uD560 \uC124\uCE58\uB41C pack\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+      p9.outro("ai-ops pack update \uC644\uB8CC");
+      return;
+    }
+    for (const targetPackId of targetPackIds) {
+      const result = updateProjectLayerPack({ basePath, packId: targetPackId, packsDir: resolvePacksDir() });
+      p9.log.success(`pack \uAC31\uC2E0 \uC644\uB8CC: ${targetPackId}`);
+      if (result.refreshed.length > 0) {
+        p9.log.info(`\uAC31\uC2E0:
+${result.refreshed.map((file) => `  ${file}`).join("\n")}`);
+      }
+      if (result.preserved.length > 0) {
+        p9.log.info(`\uBCF4\uC874:
+${result.preserved.map((file) => `  ${file}`).join("\n")}`);
+      }
+    }
+  } catch (error) {
+    reportPackError(error);
   }
-  const actions = buildSpecInitPlan();
-  for (const action of actions) {
-    const dest = join13(process.cwd(), action.relativePath);
-    mkdirSync6(dirname8(dest), { recursive: true });
-    writeFileSync8(dest, action.content, "utf-8");
-    p8.log.success(`\uC0DD\uC131: ${action.relativePath}`);
+  p9.outro("ai-ops pack update \uC644\uB8CC");
+};
+var packUninstallCommand = async (packId) => {
+  const basePath = resolveBasePath();
+  p9.intro(`ai-ops pack uninstall ${packId}`);
+  try {
+    const result = uninstallProjectLayerPack({ basePath, packId });
+    p9.log.success(`pack \uC81C\uAC70 \uC644\uB8CC: ${packId}`);
+    if (result.deleted.length > 0) {
+      p9.log.info(`\uC0AD\uC81C:
+${result.deleted.map((file) => `  ${file}`).join("\n")}`);
+    }
+    if (result.preserved.length > 0) {
+      p9.log.info(`\uBCF4\uC874:
+${result.preserved.map((file) => `  ${file}`).join("\n")}`);
+    }
+  } catch (error) {
+    reportPackError(error);
   }
-  p8.outro("ai-ops spec init \uC644\uB8CC");
+  p9.outro("ai-ops pack 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());
+program.name("ai-ops").description("AI agent operating layer manager").version("0.1.0");
+program.command("init").description("project operating layer \uCD08\uAE30 \uC124\uCE58").option("--tool <tool...>", "\uB300\uC0C1 \uB3C4\uAD6C adapter \uC9C0\uC815 (codex|gemini|claude-code)").action((opts) => initCommand(opts));
+program.command("update").description("project operating layer \uAC31\uC2E0").option("--force", "\uBCC0\uACBD \uC5C6\uC5B4\uB3C4 \uAC15\uC81C \uC7AC\uC124\uCE58", false).action((opts) => updateCommand(opts));
+program.command("diff").description("project operating layer drift \uBE44\uAD50").action(() => diffCommand());
+program.command("audit").description("project operating layer \uC0C1\uD0DC \uAC80\uC0AC").action(() => auditCommand());
+program.command("uninstall").description("project operating layer \uC81C\uAC70").option("--yes", "\uD655\uC778 \uD504\uB86C\uD504\uD2B8 \uC5C6\uC774 \uC81C\uAC70", false).action((opts) => uninstallCommand(opts));
 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(
+var applySkillInstallOptions = (command) => command.option("--tool <tool...>", "\uB300\uC0C1 \uB3C4\uAD6C \uC9C0\uC815");
+skillCommand.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C skill \uBAA9\uB85D").action(() => skillListCommand());
+applySkillInstallOptions(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)
+skillCommand.command("diff [skillId]").description("skill \uBCC0\uACBD \uBE44\uAD50").action((skillId) => skillDiffCommand(skillId));
+skillCommand.command("update [skillId]").description("skill \uAC31\uC2E0").action((skillId) => skillUpdateCommand(skillId));
+skillCommand.command("uninstall <skillId>").description("skill \uC81C\uAC70").action((skillId) => skillUninstallCommand(skillId));
+var subagentCommand = program.command("subagent").description("\uC5D0\uC774\uC804\uD2B8 subagent \uC124\uCE58/\uC870\uD68C/\uAC31\uC2E0");
+var applySubagentInstallOptions = (command) => command.option("--tool <tool...>", "\uB300\uC0C1 \uB3C4\uAD6C \uC9C0\uC815");
+subagentCommand.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C subagent \uBAA9\uB85D").action(() => subagentListCommand());
+applySubagentInstallOptions(subagentCommand.command("install <subagentId>").description("subagent \uC124\uCE58")).action(
+  (subagentId, opts) => subagentInstallCommand(subagentId, opts)
 );
-var specCommand = program.command("spec").description("spec \uD30C\uC774\uD504\uB77C\uC778 \uAD00\uB9AC");
-specCommand.command("init").description("specs/ \uB514\uB809\uD1A0\uB9AC \uAD6C\uC870 \uCD08\uAE30\uD654").option("--force", "\uC774\uBBF8 \uC874\uC7AC\uD574\uB3C4 \uAC15\uC81C \uC7AC\uC0DD\uC131", false).action((opts) => specInitCommand(opts));
+subagentCommand.command("diff [subagentId]").description("subagent \uBCC0\uACBD \uBE44\uAD50").action((subagentId) => subagentDiffCommand(subagentId));
+subagentCommand.command("update [subagentId]").description("subagent \uAC31\uC2E0").action((subagentId) => subagentUpdateCommand(subagentId));
+subagentCommand.command("uninstall <subagentId>").description("subagent \uC81C\uAC70").action((subagentId) => subagentUninstallCommand(subagentId));
+var packCommand = program.command("pack").description("optional project operating layer pack \uC124\uCE58/\uC870\uD68C/\uAC31\uC2E0");
+packCommand.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C pack \uBAA9\uB85D").action(() => packListCommand());
+packCommand.command("install <packId>").description("pack \uC124\uCE58").action((packId) => packInstallCommand(packId));
+packCommand.command("diff [packId]").description("pack \uBCC0\uACBD \uBE44\uAD50").action((packId) => packDiffCommand(packId));
+packCommand.command("update [packId]").description("pack \uAC31\uC2E0").action((packId) => packUpdateCommand(packId));
+packCommand.command("uninstall <packId>").description("pack \uC81C\uAC70").action((packId) => packUninstallCommand(packId));
 program.parse();
 //# sourceMappingURL=index.js.map