ai-ops-cli 1.2.0 → 1.3.0

package/dist/bin/index.js

@@ -6,42 +6,8 @@ import { Command } from "commander";
 // src/commands/init.ts
 import * as p2 from "@clack/prompts";
 
-// src/core/schemas/rule.schema.ts
-import { z } from "zod";
-var DecisionTableEntrySchema = z.object({
-  when: z.string().min(1),
-  then: z.string().min(1),
-  /** 조건부 규칙에서 회피해야 할 패턴 */
-  avoid: z.string().min(1).optional()
-}).strict();
-var RuleContentSchema = z.object({
-  /** Anti-pattern 규칙 ('하지 마라'). guidelines보다 항상 상단 렌더링 */
-  constraints: z.array(z.string().min(1)).default([]),
-  /** Positive 규칙 ('해라') */
-  guidelines: z.array(z.string().min(1)),
-  /** 조건부 규칙. when→then→avoid 구조 */
-  decision_table: z.array(DecisionTableEntrySchema).optional()
-}).strict();
-var RuleSchema = z.object({
-  id: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
-  category: z.string().min(1),
-  tags: z.array(z.string().min(1)),
-  /** 0-100. 높을수록 생성 파일 상단 배치 (U-shaped attention 최적화) */
-  priority: z.number().int().min(0).max(100),
-  supported_tools: z.array(z.string().min(1)).min(1).default(["claude-code", "codex", "gemini"]),
-  content: RuleContentSchema
-}).strict();
-
-// src/core/schemas/preset.schema.ts
-import { z as z2 } from "zod";
-var PresetSchema = z2.object({
-  id: z2.string().regex(/^[a-z][a-z0-9-]*$/).min(1),
-  description: z2.string().min(1),
-  rules: z2.array(z2.string().min(1)).min(1)
-}).strict();
-
 // src/core/schemas/skill.schema.ts
-import { z as z3 } from "zod";
+import { z } from "zod";
 var SKILL_KIND = {
   REFERENCE: "reference",
   TASK: "task"
@@ -51,69 +17,68 @@ var SKILL_TOOL = {
   CODEX: "codex",
   GEMINI: "gemini"
 };
-var SkillKindSchema = z3.union([z3.literal(SKILL_KIND.REFERENCE), z3.literal(SKILL_KIND.TASK)]);
-var SkillToolSchema = z3.union([
-  z3.literal(SKILL_TOOL.CLAUDE_CODE),
-  z3.literal(SKILL_TOOL.CODEX),
-  z3.literal(SKILL_TOOL.GEMINI)
+var SkillKindSchema = z.union([z.literal(SKILL_KIND.REFERENCE), z.literal(SKILL_KIND.TASK)]);
+var SkillToolSchema = z.union([
+  z.literal(SKILL_TOOL.CLAUDE_CODE),
+  z.literal(SKILL_TOOL.CODEX),
+  z.literal(SKILL_TOOL.GEMINI)
 ]);
-var SkillFileSchema = z3.object({
-  path: z3.string().min(1),
-  content: z3.string()
+var SkillFileSchema = z.object({
+  path: z.string().min(1),
+  content: z.string()
 }).strict();
-var SkillFrontmatterSchema = z3.object({
-  name: z3.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "name must be kebab-case"),
-  description: z3.string().min(1)
+var SkillFrontmatterSchema = z.object({
+  name: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "name must be kebab-case"),
+  description: z.string().min(1)
 }).passthrough();
-var InstalledSkillSchema = z3.object({
-  id: z3.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
+var InstalledSkillSchema = z.object({
+  id: z.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case"),
   kind: SkillKindSchema,
-  tools: z3.array(SkillToolSchema).min(1),
-  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")
+  tools: z.array(SkillToolSchema).min(1),
+  installed_paths: z.array(z.string().min(1)).min(1),
+  sourceHash: z.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars")
 }).strip();
 
 // src/core/schemas/skill-catalog.schema.ts
-import { z as z4 } from "zod";
-var SkillIdSchema = z4.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
-var SkillCatalogPathSchema = z4.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)+$/, "source_path must be relative kebab-case path");
-var SkillCatalogEntrySchema = z4.object({
+import { z as z2 } from "zod";
+var SkillIdSchema = z2.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
+var SkillCatalogPathSchema = z2.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)+$/, "source_path must be relative kebab-case path");
+var SkillCatalogEntrySchema = z2.object({
   id: SkillIdSchema,
   kind: SkillKindSchema,
-  supported_tools: z4.array(SkillToolSchema).min(1),
-  groups: z4.array(z4.string().min(1)),
-  included_in_presets: z4.array(z4.string().min(1)),
+  supported_tools: z2.array(SkillToolSchema).min(1),
+  groups: z2.array(z2.string().min(1)),
   source_path: SkillCatalogPathSchema
 }).strict().superRefine((entry, ctx) => {
   const expectedPrefix = entry.kind === "reference" ? "reference-skills/" : "task-skills/";
   if (!entry.source_path.startsWith(expectedPrefix)) {
     ctx.addIssue({
-      code: z4.ZodIssueCode.custom,
+      code: z2.ZodIssueCode.custom,
       path: ["source_path"],
       message: `source_path must start with ${expectedPrefix}`
     });
   }
 });
-var SkillCatalogSchema = z4.object({
-  skills: z4.array(SkillCatalogEntrySchema)
+var SkillCatalogSchema = z2.object({
+  skills: z2.array(SkillCatalogEntrySchema)
 }).strict();
 
 // src/core/schemas/skill-registry.schema.ts
-import { z as z5 } from "zod";
-var SkillRegistrySchema = z5.object({
-  skills: z5.array(InstalledSkillSchema),
-  cliVersion: z5.string().optional(),
-  generatedAt: z5.string().datetime({ offset: true })
+import { z as z3 } from "zod";
+var SkillRegistrySchema = z3.object({
+  skills: z3.array(InstalledSkillSchema),
+  cliVersion: z3.string().optional(),
+  generatedAt: z3.string().datetime({ offset: true })
 }).strict();
 
 // src/core/schemas/subagent.schema.ts
-import { z as z7 } from "zod";
+import { z as z5 } from "zod";
 
 // src/core/schemas/project-layer.schema.ts
-import { z as z6 } from "zod";
-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");
+import { z as z4 } from "zod";
+var ProjectLayerToolSchema = z4.enum(["claude-code", "codex", "gemini"]);
+var ProjectLayerDocumentStatusSchema = z4.enum(["Active", "Reserved", "Draft", "Archived"]);
+var ShortHashSchema = z4.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;
@@ -123,55 +88,55 @@ var isSafeProjectLayerPath = (value) => {
   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({
+var ProjectLayerPathSchema = z4.string().min(1).refine(isSafeProjectLayerPath, "path must be a safe project-relative path");
+var ProjectLayerFrontmatterSchema = z4.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)
+  layer: z4.string().min(1),
+  owner: z4.string().min(1),
+  read_when: z4.array(z4.string().min(1)).min(1),
+  update_when: z4.array(z4.string().min(1)).min(1)
 }).strict();
-var ProjectLayerManagedFileSchema = z6.object({
+var ProjectLayerManagedFileSchema = z4.object({
   path: ProjectLayerPathSchema,
   sourceHash: ShortHashSchema
 }).strict();
-var ProjectLayerProjectFileSchema = z6.object({
+var ProjectLayerProjectFileSchema = z4.object({
   path: ProjectLayerPathSchema,
   templateHash: ShortHashSchema,
-  created: z6.boolean()
+  created: z4.boolean()
 }).strict();
-var ProjectLayerPackFileRecordSchema = z6.object({
+var ProjectLayerPackFileRecordSchema = z4.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"),
+var ProjectLayerPackRecordSchema = z4.object({
+  id: z4.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 })
+  documents: z4.array(ProjectLayerPackFileRecordSchema),
+  files: z4.array(ProjectLayerPackFileRecordSchema),
+  installedAt: z4.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()),
+var ProjectLayerManifestSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  kind: z4.literal("project-operating-layer"),
+  tools: z4.array(ProjectLayerToolSchema).min(1),
+  managed_files: z4.array(ProjectLayerManagedFileSchema),
+  project_files: z4.array(ProjectLayerProjectFileSchema),
+  packs: z4.array(ProjectLayerPackRecordSchema).default([]),
+  settings: z4.record(z4.unknown()),
   sourceHash: ShortHashSchema,
-  cliVersion: z6.string().min(1),
-  generatedAt: z6.string().datetime({ offset: true })
+  cliVersion: z4.string().min(1),
+  generatedAt: z4.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 })
+var ProjectLayerContextIndexSchema = z4.object({
+  schemaVersion: z4.literal(1),
+  kind: z4.literal("context-layer-index"),
+  documents: z4.array(ProjectLayerContextDocumentSchema),
+  generatedAt: z4.string().datetime({ offset: true })
 }).strict();
 
 // src/core/subagent-paths.ts
@@ -196,29 +161,29 @@ var buildSubagentRelativePath = (subagentId, toolId) => {
 };
 
 // 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({
+var SubagentIdSchema = z5.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
+var SubagentMarkdownFrontmatterSchema = z5.object({
   name: SubagentIdSchema,
-  description: z7.string().min(1)
+  description: z5.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({
+var TomlValueSchema = z5.union([z5.string(), z5.number(), z5.boolean(), z5.array(z5.string())]);
+var SubagentInstalledPathSchema = z5.string().min(1).refine(isSafeProjectLayerPath, "installed path must be safe relative path");
+var CodexSubagentFrontmatterSchema = z5.object({
   name: SubagentIdSchema,
-  description: z7.string().min(1),
-  skill_names: z7.array(SubagentIdSchema).optional()
+  description: z5.string().min(1),
+  skill_names: z5.array(SubagentIdSchema).optional()
 }).catchall(TomlValueSchema);
-var InstalledSubagentSchema = z7.object({
+var InstalledSubagentSchema = z5.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")
+  tools: z5.array(SkillToolSchema).min(1),
+  installed_paths: z5.array(SubagentInstalledPathSchema).min(1),
+  sourceHash: z5.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,
+      code: z5.ZodIssueCode.custom,
       path: ["installed_paths"],
       message: "installed_paths must not contain duplicates"
     });
@@ -226,7 +191,7 @@ var InstalledSubagentSchema = z7.object({
   }
   if (installedPaths.size !== expectedPaths.size) {
     ctx.addIssue({
-      code: z7.ZodIssueCode.custom,
+      code: z5.ZodIssueCode.custom,
       path: ["installed_paths"],
       message: "installed_paths must match id and tools"
     });
@@ -235,7 +200,7 @@ var InstalledSubagentSchema = z7.object({
   for (const installedPath of installedPaths) {
     if (!expectedPaths.has(installedPath)) {
       ctx.addIssue({
-        code: z7.ZodIssueCode.custom,
+        code: z5.ZodIssueCode.custom,
         path: ["installed_paths"],
         message: "installed_paths must match id and tools"
       });
@@ -245,30 +210,30 @@ var InstalledSubagentSchema = z7.object({
 });
 
 // src/core/schemas/subagent-catalog.schema.ts
-import { z as z8 } from "zod";
-var SubagentCatalogPathSchema = z8.string().regex(
+import { z as z6 } from "zod";
+var SubagentCatalogPathSchema = z6.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({
+var SubagentCatalogEntrySchema = z6.object({
   id: SubagentIdSchema,
-  supported_tools: z8.array(SkillToolSchema).min(1),
+  supported_tools: z6.array(SkillToolSchema).min(1),
   source_path: SubagentCatalogPathSchema
 }).strict();
-var SubagentCatalogSchema = z8.object({
-  subagents: z8.array(SubagentCatalogEntrySchema)
+var SubagentCatalogSchema = z6.object({
+  subagents: z6.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 })
+import { z as z7 } from "zod";
+var SubagentManifestSchema = z7.object({
+  subagents: z7.array(InstalledSubagentSchema),
+  cliVersion: z7.string().optional(),
+  generatedAt: z7.string().datetime({ offset: true })
 }).strict();
 
 // src/core/schemas/integration.schema.ts
-import { z as z10 } from "zod";
+import { z as z8 } from "zod";
 var INTEGRATION_ID = {
   CONTEXT_PROMOTION: "context-promotion",
   PC: "pc"
@@ -278,70 +243,70 @@ var INTEGRATION_COMPONENT_TYPE = {
   CODEX_HOOK: "codex-hook",
   RECEIPT_CONFIG: "receipt-config"
 };
-var IntegrationIdSchema = z10.union([z10.literal(INTEGRATION_ID.CONTEXT_PROMOTION), z10.literal(INTEGRATION_ID.PC)]);
-var IntegrationSkillComponentSchema = z10.object({
-  type: z10.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
-  id: z10.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
-  tools: z10.array(SkillToolSchema).min(1),
-  owned: z10.boolean()
+var IntegrationIdSchema = z8.union([z8.literal(INTEGRATION_ID.CONTEXT_PROMOTION), z8.literal(INTEGRATION_ID.PC)]);
+var IntegrationSkillComponentSchema = z8.object({
+  type: z8.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
+  id: z8.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  tools: z8.array(SkillToolSchema).min(1),
+  owned: z8.boolean()
 }).strict();
-var IntegrationCodexHookComponentSchema = z10.object({
-  type: z10.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+var IntegrationCodexHookComponentSchema = z8.object({
+  type: z8.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
   id: IntegrationIdSchema,
-  command: z10.string().min(1),
-  owned: z10.boolean()
+  command: z8.string().min(1),
+  owned: z8.boolean()
 }).strict();
-var IntegrationReceiptConfigComponentSchema = z10.object({
-  type: z10.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
-  id: z10.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
-  storagePath: z10.string().min(1),
-  owned: z10.boolean()
+var IntegrationReceiptConfigComponentSchema = z8.object({
+  type: z8.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
+  id: z8.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  storagePath: z8.string().min(1),
+  owned: z8.boolean()
 }).strict();
-var IntegrationComponentSchema = z10.union([
+var IntegrationComponentSchema = z8.union([
   IntegrationSkillComponentSchema,
   IntegrationCodexHookComponentSchema,
   IntegrationReceiptConfigComponentSchema
 ]);
-var InstalledIntegrationSchema = z10.object({
+var InstalledIntegrationSchema = z8.object({
   id: IntegrationIdSchema,
-  components: z10.array(IntegrationComponentSchema),
-  installedAt: z10.string().min(1),
-  updatedAt: z10.string().min(1)
+  components: z8.array(IntegrationComponentSchema),
+  installedAt: z8.string().min(1),
+  updatedAt: z8.string().min(1)
 }).strict();
-var IntegrationManifestSchema = z10.object({
-  schemaVersion: z10.literal(1),
-  kind: z10.literal("ai-ops-integrations-manifest"),
-  integrations: z10.array(InstalledIntegrationSchema),
-  cliVersion: z10.string().min(1),
-  generatedAt: z10.string().min(1)
+var IntegrationManifestSchema = z8.object({
+  schemaVersion: z8.literal(1),
+  kind: z8.literal("ai-ops-integrations-manifest"),
+  integrations: z8.array(InstalledIntegrationSchema),
+  cliVersion: z8.string().min(1),
+  generatedAt: z8.string().min(1)
 }).strict();
 
 // src/core/schemas/integration-catalog.schema.ts
-import { z as z11 } from "zod";
-var ComponentIdSchema = z11.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "component id must be kebab-case");
-var IntegrationCatalogSkillComponentSchema = z11.object({
-  type: z11.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
+import { z as z9 } from "zod";
+var ComponentIdSchema = z9.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "component id must be kebab-case");
+var IntegrationCatalogSkillComponentSchema = z9.object({
+  type: z9.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
   id: ComponentIdSchema,
-  tools: z11.array(z11.literal("codex")).min(1)
+  tools: z9.array(z9.literal("codex")).min(1)
 }).strict();
-var IntegrationCatalogCodexHookComponentSchema = z11.object({
-  type: z11.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+var IntegrationCatalogCodexHookComponentSchema = z9.object({
+  type: z9.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
   id: IntegrationIdSchema
 }).strict();
-var IntegrationCatalogReceiptConfigComponentSchema = z11.object({
-  type: z11.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
+var IntegrationCatalogReceiptConfigComponentSchema = z9.object({
+  type: z9.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
   id: ComponentIdSchema,
-  storage_path: z11.string().min(1)
+  storage_path: z9.string().min(1)
 }).strict();
-var IntegrationCatalogComponentSchema = z11.union([
+var IntegrationCatalogComponentSchema = z9.union([
   IntegrationCatalogSkillComponentSchema,
   IntegrationCatalogCodexHookComponentSchema,
   IntegrationCatalogReceiptConfigComponentSchema
 ]);
-var IntegrationCatalogEntrySchema = z11.object({
+var IntegrationCatalogEntrySchema = z9.object({
   id: IntegrationIdSchema,
-  description: z11.string().min(1),
-  components: z11.array(IntegrationCatalogComponentSchema).min(1)
+  description: z9.string().min(1),
+  components: z9.array(IntegrationCatalogComponentSchema).min(1)
 }).strict().superRefine((entry, ctx) => {
   const hasSkill = entry.components.some((component) => component.type === INTEGRATION_COMPONENT_TYPE.SKILL);
   const hasCodexHook = entry.components.some((component) => component.type === INTEGRATION_COMPONENT_TYPE.CODEX_HOOK);
@@ -350,34 +315,34 @@ var IntegrationCatalogEntrySchema = z11.object({
   );
   if (!hasSkill) {
     ctx.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["components"],
       message: `integration must declare a skill component: ${entry.id}`
     });
   }
   if (!hasCodexHook) {
     ctx.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["components"],
       message: `integration must declare a codex-hook component: ${entry.id}`
     });
   }
   if (!hasReceiptConfig) {
     ctx.addIssue({
-      code: z11.ZodIssueCode.custom,
+      code: z9.ZodIssueCode.custom,
       path: ["components"],
       message: `integration must declare a receipt-config component: ${entry.id}`
     });
   }
 });
-var IntegrationCatalogSchema = z11.object({
-  integrations: z11.array(IntegrationCatalogEntrySchema)
+var IntegrationCatalogSchema = z9.object({
+  integrations: z9.array(IntegrationCatalogEntrySchema)
 }).strict().superRefine((catalog, ctx) => {
   const seen = /* @__PURE__ */ new Set();
   for (const [index, entry] of catalog.integrations.entries()) {
     if (seen.has(entry.id)) {
       ctx.addIssue({
-        code: z11.ZodIssueCode.custom,
+        code: z9.ZodIssueCode.custom,
         path: ["integrations", index, "id"],
         message: `duplicate integration id: ${entry.id}`
       });
@@ -387,49 +352,15 @@ var IntegrationCatalogSchema = z11.object({
 });
 
 // src/core/schemas/pack.schema.ts
-import { z as z12 } from "zod";
-var PackIdSchema = z12.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
-var PackSourcePathSchema = z12.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/, "source_path must be relative kebab-case path");
-var PackCatalogEntrySchema = z12.object({
+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 = z12.object({
-  packs: z12.array(PackCatalogEntrySchema)
-}).strict();
-
-// src/core/schemas/manifest.schema.ts
-import { z as z13 } from "zod";
-var SettingsConfigSchema = z13.object({
-  claude: z13.array(z13.string().min(1)).optional(),
-  gemini: z13.array(z13.string().min(1)).optional(),
-  prettierignore: z13.boolean().optional()
-}).strict();
-var WorkspaceEntrySchema = z13.object({
-  preset: z13.string().min(1),
-  rules: z13.array(z13.string().min(1))
-}).strict();
-var ManifestSchema = z13.object({
-  tools: z13.array(z13.string().min(1)).min(1),
-  scope: z13.literal("project"),
-  /** 비모노레포 단일 preset */
-  preset: z13.string().min(1).optional(),
-  /** 모노레포: workspace path → { preset, rules } */
-  workspaces: z13.record(z13.string(), WorkspaceEntrySchema).optional(),
-  installed_rules: z13.array(z13.string().min(1)),
-  /** 실제 디스크에 쓰여진 파일 상대 경로 목록 (uninstall용). 기존 manifest 호환성 위해 optional */
-  installed_files: z13.array(z13.string().min(1)).optional(),
-  /** skill 설치 루트 디렉토리 목록 */
-  installed_skills: z13.array(InstalledSkillSchema).optional(),
-  /** non-managed 파일에 섹션을 append한 경우 추적 (uninstall 시 섹션만 제거) */
-  appended_files: z13.array(z13.string().min(1)).optional(),
-  /** init 시 선택된 settings 항목 — update 시 재생성에 사용 */
-  settings: SettingsConfigSchema.optional(),
-  /** init/update 실행 시점의 CLI 패키지 버전 — 버전 변경 감지에 사용 */
-  cliVersion: z13.string().optional(),
-  /** SSOT 데이터 파일들의 deterministic SHA-256 해시 (6자리 hex). diff/update 판단 기준 */
-  sourceHash: z13.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
-  generatedAt: z13.string().datetime({ offset: true })
+var PackCatalogSchema = z10.object({
+  packs: z10.array(PackCatalogEntrySchema)
 }).strict();
 
 // src/core/loader.ts
@@ -543,7 +474,6 @@ var loadAllSkills = (skillsDir) => {
       description: parsed.description,
       supported_tools: [...entry.supported_tools],
       groups: [...entry.groups],
-      included_in_presets: [...entry.included_in_presets],
       directory,
       files
     };
@@ -606,16 +536,13 @@ var loadAllSubagents = (subagentsDir) => {
   });
 };
 
-// src/core/renderer.ts
-import { join as join3 } from "path";
-
 // src/core/skill-renderer.ts
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 
 // src/core/source-hash.ts
 import { createHash } from "crypto";
 import { readFileSync as readFileSync2, readdirSync as readdirSync2 } from "fs";
-import { dirname, join as join4, resolve as resolve2 } from "path";
+import { dirname, join as join3, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var __dirname = dirname(fileURLToPath(import.meta.url));
 var getCliVersion = () => {
@@ -637,10 +564,10 @@ var CLAUDE_SKILLS_DIR = ".claude/skills";
 var buildRootDirs = (skillId, toolIds) => {
   const dirs = [];
   if (toolIds.some((toolId) => toolId === "codex" || toolId === "gemini")) {
-    dirs.push(join5(AGENT_SKILLS_DIR, skillId));
+    dirs.push(join4(AGENT_SKILLS_DIR, skillId));
   }
   if (toolIds.includes("claude-code")) {
-    dirs.push(join5(CLAUDE_SKILLS_DIR, skillId));
+    dirs.push(join4(CLAUDE_SKILLS_DIR, skillId));
   }
   return dirs;
 };
@@ -662,7 +589,7 @@ var buildSkillInstallPlan = (params) => {
   });
   const packages = rootDirs.map((rootDir) => {
     const files = params.skill.files.map((file) => ({
-      relativePath: join5(rootDir, file.path),
+      relativePath: join4(rootDir, file.path),
       content: file.content
     }));
     return {
@@ -706,11 +633,9 @@ var renderCodexSubagent = (params) => {
 path = ${JSON.stringify(skillPath)}
 enabled = true`;
   });
-  const sections = [
-    metadata,
-    `developer_instructions = ${JSON.stringify(params.prompt.trimEnd())}`,
-    ...skills
-  ].filter((section) => section.length > 0);
+  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) => {
@@ -855,77 +780,71 @@ var parseAiOpsMeta = (content) => {
   return { sourceHash: match[1], generatedAt: match[2] };
 };
 
-// src/core/manifest-io.ts
+// src/core/skill-registry-io.ts
 import { mkdirSync, readFileSync as readFileSync3, writeFileSync } from "fs";
-import { dirname as dirname2, join as join6 } from "path";
-
-// src/core/manifest-resolution.ts
+import { dirname as dirname2, join as join5 } from "path";
+var SKILL_REGISTRY_FILENAME = "skills-manifest.json";
 var LEGACY_SKILL_ID_MAP = {
   "engineering-standards-pack": "backend-service-standards"
 };
 var resolveCanonicalSkillId = (skillId) => LEGACY_SKILL_ID_MAP[skillId] ?? skillId;
-
-// src/core/skill-registry-io.ts
-import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
-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) => join7(userBasePath, ".ai-ops", SKILL_REGISTRY_FILENAME);
+var resolveSkillRegistryPath = (userBasePath) => join5(userBasePath, ".ai-ops", SKILL_REGISTRY_FILENAME);
 var readSkillRegistry = (registryPath) => {
   let raw;
   try {
-    raw = readFileSync4(registryPath, "utf-8");
+    raw = readFileSync3(registryPath, "utf-8");
   } catch {
     return null;
   }
   return parseSkillRegistry(raw);
 };
 var writeSkillRegistry = (registryPath, registry) => {
-  mkdirSync2(dirname3(registryPath), { recursive: true });
-  writeFileSync2(registryPath, serializeSkillRegistry(registry), "utf-8");
+  mkdirSync(dirname2(registryPath), { recursive: true });
+  writeFileSync(registryPath, serializeSkillRegistry(registry), "utf-8");
 };
 
 // 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";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname3, join as join6 } 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 resolveSubagentManifestPath = (userBasePath) => join6(userBasePath, ".ai-ops", SUBAGENT_MANIFEST_FILENAME);
 var readSubagentManifest = (manifestPath) => {
   let raw;
   try {
-    raw = readFileSync5(manifestPath, "utf-8");
+    raw = readFileSync4(manifestPath, "utf-8");
   } catch {
     return null;
   }
   return parseSubagentManifest(raw);
 };
 var writeSubagentManifest = (manifestPath, manifest) => {
-  mkdirSync3(dirname4(manifestPath), { recursive: true });
-  writeFileSync3(manifestPath, serializeSubagentManifest(manifest), "utf-8");
+  mkdirSync2(dirname3(manifestPath), { recursive: true });
+  writeFileSync2(manifestPath, serializeSubagentManifest(manifest), "utf-8");
 };
 
 // src/core/integration-manifest-io.ts
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname5, join as join9 } from "path";
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync5, rmSync, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname4, join as join7 } from "path";
 var INTEGRATION_MANIFEST_FILENAME = "integrations-manifest.json";
 var parseIntegrationManifest = (json) => IntegrationManifestSchema.parse(JSON.parse(json));
 var serializeIntegrationManifest = (manifest) => JSON.stringify(manifest, null, 2) + "\n";
-var resolveIntegrationManifestPath = (userBasePath) => join9(userBasePath, ".ai-ops", INTEGRATION_MANIFEST_FILENAME);
+var resolveIntegrationManifestPath = (userBasePath) => join7(userBasePath, ".ai-ops", INTEGRATION_MANIFEST_FILENAME);
 var readIntegrationManifest = (manifestPath) => {
   let raw;
   try {
-    raw = readFileSync6(manifestPath, "utf-8");
+    raw = readFileSync5(manifestPath, "utf-8");
   } catch {
     return null;
   }
   return parseIntegrationManifest(raw);
 };
 var writeIntegrationManifest = (manifestPath, manifest) => {
-  mkdirSync4(dirname5(manifestPath), { recursive: true });
-  writeFileSync4(manifestPath, serializeIntegrationManifest(manifest), "utf-8");
+  mkdirSync3(dirname4(manifestPath), { recursive: true });
+  writeFileSync3(manifestPath, serializeIntegrationManifest(manifest), "utf-8");
 };
 var findInstalledIntegration = (integrations, integrationId) => integrations.find((integration) => integration.id === integrationId);
 var upsertInstalledIntegration = (integrations, nextIntegration) => [
@@ -949,23 +868,20 @@ var writeUserIntegrationState = (params) => {
   });
 };
 
-// src/core/install-plan.ts
-import { join as join10 } from "path";
-
 // src/core/project-layer.ts
-import { existsSync, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname7, isAbsolute, join as join11, relative, resolve as resolve5 } from "path";
+import { existsSync, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname6, isAbsolute, join as join8, relative, resolve as resolve5 } from "path";
 
 // src/core/paths.ts
-import { dirname as dirname6, resolve as resolve4 } from "path";
+import { dirname as dirname5, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
 var COMPILER_DATA_DIR = resolve4(__dirname2, "..", "..", "data");
 
 // 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 = join11(COMPILER_DATA_DIR, "context-layer");
+var CONTEXT_LAYER_DATA_DIR = join8(COMPILER_DATA_DIR, "context-layer");
 var TOOL_ORDER = ["codex", "gemini", "claude-code"];
 var DEFAULT_TOOLS = TOOL_ORDER;
 var TEMPLATE_PATHS = [
@@ -978,7 +894,6 @@ var TEMPLATE_PATHS = [
   "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"
@@ -992,10 +907,10 @@ 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) => join11(basePath, PROJECT_LAYER_MANIFEST_RELATIVE_PATH);
-var resolveProjectLayerContextIndexPath = (basePath) => join11(basePath, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH);
-var resolveTemplatePath = (relativePath) => join11(CONTEXT_LAYER_DATA_DIR, relativePath);
-var toRelativeDir = (relativePath) => dirname7(relativePath);
+var resolveProjectLayerManifestPath = (basePath) => join8(basePath, PROJECT_LAYER_MANIFEST_RELATIVE_PATH);
+var resolveProjectLayerContextIndexPath = (basePath) => join8(basePath, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH);
+var resolveTemplatePath = (relativePath) => join8(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}`);
@@ -1110,8 +1025,8 @@ var loadTemplateSpec = (relativePath, content) => {
 };
 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, readFileSync7(resolveTemplatePath(relativePath), "utf-8")));
-  const statusTemplate = readFileSync7(resolveTemplatePath("docs/docs-status.md"), "utf-8");
+  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));
@@ -1121,7 +1036,7 @@ var loadProjectLayerTemplateSpecs = (tools) => {
 var computeProjectLayerSourceHash = (specs) => computeHash(specs.map((spec) => `${spec.path}:${spec.content}`));
 var readProjectLayerManifest = (basePath) => {
   try {
-    return parseProjectLayerManifest(readFileSync7(resolveProjectLayerManifestPath(basePath), "utf-8"));
+    return parseProjectLayerManifest(readFileSync6(resolveProjectLayerManifestPath(basePath), "utf-8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -1131,12 +1046,12 @@ var readProjectLayerManifest = (basePath) => {
 };
 var writeProjectLayerManifest = (basePath, manifest) => {
   const manifestPath = resolveProjectLayerManifestPath(basePath);
-  mkdirSync5(dirname7(manifestPath), { recursive: true });
-  writeFileSync5(manifestPath, serializeProjectLayerManifest(manifest), "utf-8");
+  mkdirSync4(dirname6(manifestPath), { recursive: true });
+  writeFileSync4(manifestPath, serializeProjectLayerManifest(manifest), "utf-8");
 };
 var readProjectLayerContextIndex = (basePath) => {
   try {
-    return parseProjectLayerContextIndex(readFileSync7(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
+    return parseProjectLayerContextIndex(readFileSync6(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -1146,8 +1061,8 @@ var readProjectLayerContextIndex = (basePath) => {
 };
 var writeProjectLayerContextIndex = (basePath, contextIndex) => {
   const contextIndexPath = resolveProjectLayerContextIndexPath(basePath);
-  mkdirSync5(dirname7(contextIndexPath), { recursive: true });
-  writeFileSync5(contextIndexPath, serializeProjectLayerContextIndex(contextIndex), "utf-8");
+  mkdirSync4(dirname6(contextIndexPath), { recursive: true });
+  writeFileSync4(contextIndexPath, serializeProjectLayerContextIndex(contextIndex), "utf-8");
 };
 var installManagedFiles = (basePath, specs, meta) => {
   const written = [];
@@ -1156,24 +1071,24 @@ var installManagedFiles = (basePath, specs, meta) => {
     const absolutePath = resolveProjectLayerFilePath(basePath, spec.path);
     const wrappedContent = wrapWithSection(spec.content, meta);
     if (!existsSync(absolutePath)) {
-      mkdirSync5(dirname7(absolutePath), { recursive: true });
-      writeFileSync5(absolutePath, wrappedContent + "\n", "utf-8");
+      mkdirSync4(dirname6(absolutePath), { recursive: true });
+      writeFileSync4(absolutePath, wrappedContent + "\n", "utf-8");
       written.push(spec.path);
       continue;
     }
-    const existing = readFileSync7(absolutePath, "utf-8");
+    const existing = readFileSync6(absolutePath, "utf-8");
     if (hasAiOpsSection(existing)) {
-      writeFileSync5(absolutePath, replaceAiOpsSection(existing, wrappedContent), "utf-8");
+      writeFileSync4(absolutePath, replaceAiOpsSection(existing, wrappedContent), "utf-8");
       const stripped = stripAiOpsSection(existing);
       (stripped.trim().length > 0 ? appended : written).push(spec.path);
       continue;
     }
     if (hasLegacyHeader(existing)) {
-      writeFileSync5(absolutePath, wrappedContent + "\n", "utf-8");
+      writeFileSync4(absolutePath, wrappedContent + "\n", "utf-8");
       written.push(spec.path);
       continue;
     }
-    writeFileSync5(absolutePath, existing.trimEnd() + "\n\n" + wrappedContent + "\n", "utf-8");
+    writeFileSync4(absolutePath, existing.trimEnd() + "\n\n" + wrappedContent + "\n", "utf-8");
     appended.push(spec.path);
   }
   return { written, appended };
@@ -1188,8 +1103,8 @@ var installProjectFiles = (params) => {
     const absolutePath = resolveProjectLayerFilePath(params.basePath, spec.path);
     const previous = previousByPath.get(spec.path);
     if (!existsSync(absolutePath)) {
-      mkdirSync5(dirname7(absolutePath), { recursive: true });
-      writeFileSync5(absolutePath, spec.content + "\n", "utf-8");
+      mkdirSync4(dirname6(absolutePath), { recursive: true });
+      writeFileSync4(absolutePath, spec.content + "\n", "utf-8");
       created.push(spec.path);
       records.push({
         path: spec.path,
@@ -1198,11 +1113,11 @@ var installProjectFiles = (params) => {
       });
       continue;
     }
-    const existingContent = readFileSync7(absolutePath, "utf-8").trimEnd();
+    const existingContent = readFileSync6(absolutePath, "utf-8").trimEnd();
     const existingHash = computeHash([existingContent]);
     if (previous?.created === true && existingHash === previous.templateHash) {
       if (existingHash !== spec.contentHash) {
-        writeFileSync5(absolutePath, spec.content + "\n", "utf-8");
+        writeFileSync4(absolutePath, spec.content + "\n", "utf-8");
         refreshed.push(spec.path);
       } else {
         preserved.push(spec.path);
@@ -1225,7 +1140,7 @@ var installProjectFiles = (params) => {
 };
 var buildContextIndexFromDisk = (params) => {
   const documents = params.documentPaths.map(
-    (path) => parseProjectLayerDocument(path, readFileSync7(resolveProjectLayerFilePath(params.basePath, path), "utf-8"))
+    (path) => parseProjectLayerDocument(path, readFileSync6(resolveProjectLayerFilePath(params.basePath, path), "utf-8"))
   );
   return ProjectLayerContextIndexSchema.parse({
     schemaVersion: 1,
@@ -1234,14 +1149,14 @@ var buildContextIndexFromDisk = (params) => {
     generatedAt: params.generatedAt
   });
 };
-var computeProjectFileHash = (basePath, relativePath) => computeHash([readFileSync7(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
+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, readFileSync7(resolveProjectLayerFilePath(params.basePath, path), "utf-8"));
+  const document = parseProjectLayerDocument(path, readFileSync6(resolveProjectLayerFilePath(params.basePath, path), "utf-8"));
   return `| ${document.path} | ${document.status} | ${document.owner} |`;
 });
 var replaceDocsStatusRows = (content, rows) => {
@@ -1257,8 +1172,8 @@ var updateDocsStatusTable = (basePath, documentPaths) => {
   const absolutePath = resolveProjectLayerFilePath(basePath, docsStatusPath);
   const beforeHash = computeProjectFileHash(basePath, docsStatusPath);
   const rows = buildDocsStatusRowsFromDisk({ basePath, documentPaths });
-  const nextContent = replaceDocsStatusRows(readFileSync7(absolutePath, "utf-8"), rows);
-  writeFileSync5(absolutePath, nextContent, "utf-8");
+  const nextContent = replaceDocsStatusRows(readFileSync6(absolutePath, "utf-8"), rows);
+  writeFileSync4(absolutePath, nextContent, "utf-8");
   return {
     beforeHash,
     afterHash: computeProjectFileHash(basePath, docsStatusPath)
@@ -1413,7 +1328,7 @@ var readDocumentSafely = (basePath, path) => {
     if (!existsSync(absolutePath)) {
       return issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${path}`);
     }
-    return parseProjectLayerDocument(path, readFileSync7(absolutePath, "utf-8"));
+    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}`);
@@ -1508,7 +1423,7 @@ var diffProjectLayer = (basePath) => {
       issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       continue;
     }
-    const content = readFileSync7(absolutePath, "utf-8");
+    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}`));
@@ -1570,7 +1485,7 @@ var auditProjectLayer = (basePath) => {
   }
   let docsStatusEntries = [];
   try {
-    docsStatusEntries = parseDocsStatusEntries(readFileSync7(docsStatusPath, "utf-8"));
+    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}`));
@@ -1600,7 +1515,7 @@ function removeManagedProjectFile(basePath, relativePath) {
   if (!existsSync(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [relativePath] };
   }
-  const content = readFileSync7(absolutePath, "utf-8");
+  const content = readFileSync6(absolutePath, "utf-8");
   if (!hasAiOpsSection(content)) {
     return { deleted: [], cleaned: [], preserved: [relativePath], notFound: [] };
   }
@@ -1609,7 +1524,7 @@ function removeManagedProjectFile(basePath, relativePath) {
     rmSync2(absolutePath);
     return { deleted: [relativePath], cleaned: [], preserved: [], notFound: [] };
   }
-  writeFileSync5(absolutePath, stripped, "utf-8");
+  writeFileSync4(absolutePath, stripped, "utf-8");
   return { deleted: [], cleaned: [relativePath], preserved: [], notFound: [] };
 }
 var removeCreateOnlyProjectFile = (basePath, file) => {
@@ -1617,7 +1532,7 @@ var removeCreateOnlyProjectFile = (basePath, file) => {
   if (!existsSync(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
   }
-  const content = readFileSync7(absolutePath, "utf-8").trimEnd();
+  const content = readFileSync6(absolutePath, "utf-8").trimEnd();
   const currentHash = computeHash([content]);
   if (file.created && currentHash === file.templateHash) {
     rmSync2(absolutePath);
@@ -1630,7 +1545,7 @@ var removePackOwnedFile = (basePath, file) => {
   if (!existsSync(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
   }
-  const currentHash = computeHash([readFileSync7(absolutePath, "utf-8").trimEnd()]);
+  const currentHash = computeHash([readFileSync6(absolutePath, "utf-8").trimEnd()]);
   if (currentHash === file.sourceHash) {
     rmSync2(absolutePath);
     return { deleted: [file.path], cleaned: [], preserved: [], notFound: [] };
@@ -1674,8 +1589,8 @@ var uninstallProjectLayer = (basePath, manifest) => {
 };
 
 // src/core/pack.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync6, readFileSync as readFileSync8, readdirSync as readdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve6 } from "path";
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, isAbsolute as isAbsolute2, join as join9, 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/";
@@ -1683,9 +1598,9 @@ 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 DEFAULT_PACKS_DIR = join12(COMPILER_DATA_DIR, "packs");
+var DEFAULT_PACKS_DIR = join9(COMPILER_DATA_DIR, "packs");
 var includesReservedDocumentWarning2 = (content) => RESERVED_DOCUMENT_WARNINGS2.some((warning) => content.includes(warning));
-var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync8(join12(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
+var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync7(join9(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
 var assertPackInstallPath = (path) => {
   if (!isSafeProjectLayerPath(path) || !path.startsWith(PACK_INSTALL_ROOT)) {
     throw new Error(`Unsafe pack path: ${path}`);
@@ -1694,16 +1609,16 @@ var assertPackInstallPath = (path) => {
 var readPackSourceFiles = (packDir) => {
   const files = [];
   const walk = (relativeDir = "") => {
-    const absoluteDir = relativeDir.length > 0 ? join12(packDir, relativeDir) : packDir;
+    const absoluteDir = relativeDir.length > 0 ? join9(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 ? join12(relativeDir, entry.name) : entry.name;
+      const nextRelativePath = relativeDir.length > 0 ? join9(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         walk(nextRelativePath);
         continue;
       }
       assertPackInstallPath(nextRelativePath);
-      const content = readFileSync8(join12(packDir, nextRelativePath), "utf-8");
+      const content = readFileSync7(join9(packDir, nextRelativePath), "utf-8");
       files.push({
         path: nextRelativePath,
         content,
@@ -1761,11 +1676,11 @@ var resolvePackById = (packsDir, packId) => {
   return pack;
 };
 var serializePackFileContent = (content) => content.length === 0 ? "" : content.trimEnd() + "\n";
-var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync8(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
+var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync7(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
 var writePackFile = (basePath, file) => {
   const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
-  mkdirSync6(dirname8(absolutePath), { recursive: true });
-  writeFileSync6(absolutePath, serializePackFileContent(file.content), "utf-8");
+  mkdirSync5(dirname7(absolutePath), { recursive: true });
+  writeFileSync5(absolutePath, serializePackFileContent(file.content), "utf-8");
 };
 var buildPackFileRecords = (files) => files.map((file) => ({
   path: file.path,
@@ -1852,7 +1767,7 @@ var removePackFiles = (basePath, record) => {
   return { written: [], refreshed: [], preserved, deleted, notFound };
 };
 var removeEmptyDirs2 = (basePath, relativePaths) => {
-  const dirs = [...new Set(relativePaths.map((path) => dirname8(path)).filter((dir) => dir !== "."))].sort(
+  const dirs = [...new Set(relativePaths.map((path) => dirname7(path)).filter((dir) => dir !== "."))].sort(
     (a, b) => b.length - a.length
   );
   for (const dir of dirs) {
@@ -1981,27 +1896,24 @@ var diffProjectLayerPack = (params) => {
   return { issues };
 };
 
-// src/core/uninstall-plan.ts
-import { join as join13 } from "path";
-
 // src/core/context-promotion.ts
 import { createHash as createHash2 } from "crypto";
 import { execFileSync } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync7, readFileSync as readFileSync9, statSync, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname9, join as join14, resolve as resolve7 } from "path";
-import { z as z15 } from "zod";
+import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, join as join10, resolve as resolve7 } from "path";
+import { z as z12 } from "zod";
 
 // src/core/tool-use-hook.ts
-import { z as z14 } from "zod";
-var HookToolInputSchema = z14.object({
-  command: z14.string().optional()
+import { z as z11 } from "zod";
+var HookToolInputSchema = z11.object({
+  command: z11.string().optional()
 }).passthrough();
-var ToolUseHookInputSchema = z14.object({
-  hook_event_name: z14.string(),
-  cwd: z14.string(),
-  tool_name: z14.string().optional(),
-  tool_input: z14.unknown().optional(),
-  tool_response: z14.unknown().optional()
+var ToolUseHookInputSchema = z11.object({
+  hook_event_name: z11.string(),
+  cwd: z11.string(),
+  tool_name: z11.string().optional(),
+  tool_input: z11.unknown().optional(),
+  tool_response: z11.unknown().optional()
 }).passthrough();
 var SHELL_CONTROL_TOKENS = /* @__PURE__ */ new Set(["&&", "||", ";", "|", "(", ")"]);
 var SHELL_SCRIPT_FLAGS = /* @__PURE__ */ new Set(["-c", "-lc"]);
@@ -2218,30 +2130,30 @@ var CONTEXT_PROMOTION_SCOPE = {
   PROJECT_LOCAL: "project-local",
   GLOBAL: "global"
 };
-var ContextPromotionDecisionSchema = z15.union([
-  z15.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
-  z15.literal(CONTEXT_PROMOTION_DECISION.NO_PROMOTION)
+var ContextPromotionDecisionSchema = z12.union([
+  z12.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
+  z12.literal(CONTEXT_PROMOTION_DECISION.NO_PROMOTION)
 ]);
-var ContextPromotionScopeSchema = z15.union([
-  z15.literal(CONTEXT_PROMOTION_SCOPE.CORE),
-  z15.literal(CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL),
-  z15.literal(CONTEXT_PROMOTION_SCOPE.GLOBAL)
+var ContextPromotionScopeSchema = z12.union([
+  z12.literal(CONTEXT_PROMOTION_SCOPE.CORE),
+  z12.literal(CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL),
+  z12.literal(CONTEXT_PROMOTION_SCOPE.GLOBAL)
 ]);
-var ContextPromotionReceiptSchema = z15.object({
-  fingerprint: z15.string().regex(/^[a-f0-9]{16}$/),
-  commitHash: z15.string().regex(/^(NO_HEAD|[a-f0-9]{40})$/).optional(),
+var ContextPromotionReceiptSchema = z12.object({
+  fingerprint: z12.string().regex(/^[a-f0-9]{16}$/),
+  commitHash: z12.string().regex(/^(NO_HEAD|[a-f0-9]{40})$/).optional(),
   decision: ContextPromotionDecisionSchema,
-  scopes: z15.array(ContextPromotionScopeSchema),
-  targets: z15.array(z15.string().min(1)),
-  summary: z15.string().min(1),
-  resolvedAt: z15.string().min(1)
+  scopes: z12.array(ContextPromotionScopeSchema),
+  targets: z12.array(z12.string().min(1)),
+  summary: z12.string().min(1),
+  resolvedAt: z12.string().min(1)
 }).strict();
-var ContextPromotionReceiptIndexSchema = z15.object({
-  schemaVersion: z15.literal(1),
-  kind: z15.literal("context-promotion-receipts"),
-  projectKey: z15.string().regex(/^[a-f0-9]{12}$/),
-  projectRoot: z15.string().min(1),
-  receipts: z15.array(ContextPromotionReceiptSchema)
+var ContextPromotionReceiptIndexSchema = z12.object({
+  schemaVersion: z12.literal(1),
+  kind: z12.literal("context-promotion-receipts"),
+  projectKey: z12.string().regex(/^[a-f0-9]{12}$/),
+  projectRoot: z12.string().min(1),
+  receipts: z12.array(ContextPromotionReceiptSchema)
 }).strict();
 var RECEIPT_INDEX_FILENAME = "receipts-index.json";
 var DEFAULT_PRUNE_MAX = 50;
@@ -2271,13 +2183,13 @@ var readUntrackedFingerprintParts = (gitRoot) => {
   const raw = runGit(gitRoot, ["ls-files", "--others", "--exclude-standard", "-z"]);
   const paths = raw.split("\0").filter((path) => path.length > 0).sort((a, b) => a.localeCompare(b));
   return paths.map((relativePath) => {
-    const absolutePath = join14(gitRoot, relativePath);
+    const absolutePath = join10(gitRoot, relativePath);
     try {
       const stat = statSync(absolutePath);
       if (!stat.isFile()) {
         return `${relativePath}:non-file`;
       }
-      const content = readFileSync9(absolutePath);
+      const content = readFileSync8(absolutePath);
       return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
     } catch {
       throw new Error(`Unable to read untracked path for context promotion fingerprint: ${relativePath}`);
@@ -2291,7 +2203,7 @@ var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
   return [
     `raw:${rawDiff}`,
     ...paths.map((relativePath) => {
-      const absolutePath = join14(gitRoot, relativePath);
+      const absolutePath = join10(gitRoot, relativePath);
       if (!existsSync3(absolutePath)) {
         return `${relativePath}:deleted`;
       }
@@ -2299,7 +2211,7 @@ var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
       if (!stat.isFile()) {
         return `${relativePath}:non-file`;
       }
-      const content = readFileSync9(absolutePath);
+      const content = readFileSync8(absolutePath);
       return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
     })
   ];
@@ -2317,19 +2229,19 @@ var computeContextPromotionFingerprint = (gitRoot) => hashHex(
   ],
   16
 );
-var resolveContextPromotionReceiptIndexPath = (params) => join14(params.userBasePath, ".ai-ops", "context-promotion", "projects", params.projectKey, RECEIPT_INDEX_FILENAME);
+var resolveContextPromotionReceiptIndexPath = (params) => join10(params.userBasePath, ".ai-ops", "context-promotion", "projects", params.projectKey, RECEIPT_INDEX_FILENAME);
 var parseContextPromotionReceiptIndex = (json) => ContextPromotionReceiptIndexSchema.parse(JSON.parse(json));
 var serializeContextPromotionReceiptIndex = (index) => JSON.stringify(index, null, 2) + "\n";
 var readContextPromotionReceiptIndex = (indexPath) => {
   try {
-    return parseContextPromotionReceiptIndex(readFileSync9(indexPath, "utf-8"));
+    return parseContextPromotionReceiptIndex(readFileSync8(indexPath, "utf-8"));
   } catch {
     return null;
   }
 };
 var writeContextPromotionReceiptIndex = (indexPath, index) => {
-  mkdirSync7(dirname9(indexPath), { recursive: true });
-  writeFileSync7(indexPath, serializeContextPromotionReceiptIndex(index), "utf-8");
+  mkdirSync6(dirname8(indexPath), { recursive: true });
+  writeFileSync6(indexPath, serializeContextPromotionReceiptIndex(index), "utf-8");
 };
 var buildEmptyReceiptIndex = (params) => ({
   schemaVersion: 1,
@@ -2377,7 +2289,7 @@ var pruneContextPromotionReceipts = (params) => {
   writeContextPromotionReceiptIndex(params.indexPath, nextIndex);
   return nextIndex;
 };
-var hasContextPromotionLayer = (gitRoot) => existsSync3(join14(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
+var hasContextPromotionLayer = (gitRoot) => existsSync3(join10(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
 var getContextPromotionStatus = (params) => {
   const cwd = resolve7(params.cwd);
   const gitRoot = resolveContextPromotionGitRoot(cwd);
@@ -2541,8 +2453,8 @@ var evaluateContextPromotionPostToolUseHook = (params) => {
 
 // src/core/pc-integration.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync10, readdirSync as readdirSync5 } from "fs";
-import { join as join15, resolve as resolve8, sep } from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync9, readdirSync as readdirSync5 } from "fs";
+import { join as join11, resolve as resolve8, sep } from "path";
 var normalizePath = (path) => resolve8(path.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"));
 var pathContains = (parentPath, childPath) => {
   const parent = normalizePath(parentPath);
@@ -2580,7 +2492,7 @@ var parseListField = (content, labels) => {
 };
 var readTextFileOrNull = (filePath) => {
   try {
-    return readFileSync10(filePath, "utf-8");
+    return readFileSync9(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -2605,11 +2517,11 @@ var readGitHead2 = (cwd) => {
   }
 };
 var listWorkspaceStatePaths = (contextRoot) => {
-  const workspacesDir = join15(contextRoot, "workspaces");
+  const workspacesDir = join11(contextRoot, "workspaces");
   if (!existsSync4(workspacesDir)) {
     return [];
   }
-  return readdirSync5(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join15(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync4(statePath)).sort((a, b) => a.localeCompare(b));
+  return readdirSync5(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join11(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync4(statePath)).sort((a, b) => a.localeCompare(b));
 };
 var parseWorkspaceCandidate = (statePath) => {
   const content = readTextFileOrNull(statePath);
@@ -2652,11 +2564,11 @@ var parseRepoEntry = (entryPath) => {
   };
 };
 var findCurrentEntry = (params) => {
-  const reposDir = join15(params.workspaceDir, "repos");
+  const reposDir = join11(params.workspaceDir, "repos");
   if (!existsSync4(reposDir)) {
     return null;
   }
-  const entries = readdirSync5(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join15(reposDir, entry.name))).filter((entry) => entry !== null).filter((entry) => {
+  const entries = readdirSync5(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join11(reposDir, entry.name))).filter((entry) => entry !== null).filter((entry) => {
     const paths = [entry.path, entry.gitRoot].filter((path) => path !== null);
     return paths.some((path) => pathContains(path, params.cwd));
   }).sort((a, b) => {
@@ -2751,7 +2663,7 @@ var getPcHandoffStatus = (params) => {
       skipReason: "active pc workstream not selected"
     };
   }
-  const activeWorkstreamPath = join15(workspace.workspaceDir, "workstreams", `${workspace.activeWorkstreamId}.md`);
+  const activeWorkstreamPath = join11(workspace.workspaceDir, "workstreams", `${workspace.activeWorkstreamId}.md`);
   const activeWorkstreamContent = readTextFileOrNull(activeWorkstreamPath);
   if (!activeWorkstreamContent) {
     return {
@@ -2869,8 +2781,8 @@ var evaluatePcPostToolUseHook = (params) => {
 };
 
 // src/core/codex-hook.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, join as join16 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname9, join as join12 } from "path";
 var CONTEXT_PROMOTION_HOOK_ID = "context-promotion";
 var CONTEXT_PROMOTION_HOOK_COMMAND_MARKER = "context-promotion hook post-tool-use";
 var CONTEXT_PROMOTION_LEGACY_HOOK_COMMAND_MARKER = "context-promotion hook pre-tool-use";
@@ -2900,15 +2812,15 @@ var readJsonRecord = (filePath) => {
   if (!existsSync5(filePath)) {
     return {};
   }
-  const parsed = JSON.parse(readFileSync11(filePath, "utf-8"));
+  const parsed = JSON.parse(readFileSync10(filePath, "utf-8"));
   if (!isJsonRecord2(parsed)) {
     throw new Error("hooks.json must contain a JSON object");
   }
   return parsed;
 };
 var writeJsonRecord = (filePath, value) => {
-  mkdirSync8(dirname10(filePath), { recursive: true });
-  writeFileSync8(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  mkdirSync7(dirname9(filePath), { recursive: true });
+  writeFileSync7(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 };
 var getOrCreateRecord = (record, key) => {
   const existing = record[key];
@@ -2983,7 +2895,7 @@ var removeDefinitionHooksFromEvent = (hooks, eventName, definition) => {
   }
   return true;
 };
-var resolveCodexHooksPath = (codexHomePath) => join16(codexHomePath, "hooks.json");
+var resolveCodexHooksPath = (codexHomePath) => join12(codexHomePath, "hooks.json");
 var buildCodexHookCommand = (params) => {
   const command = params.overrideCommand?.trim() ?? params.definition.defaultCommand;
   if (!command.includes(params.definition.commandMarker)) {
@@ -3061,11 +2973,11 @@ var uninstallContextPromotionHook = (hooksPath) => uninstallCodexHook({
 });
 
 // src/lib/paths.ts
-import { join as join17 } from "path";
-var resolveSkillsDir = () => join17(COMPILER_DATA_DIR, "skills");
-var resolveSubagentsDir = () => join17(COMPILER_DATA_DIR, "subagents");
-var resolvePacksDir = () => join17(COMPILER_DATA_DIR, "packs");
-var resolveIntegrationsDir = () => join17(COMPILER_DATA_DIR, "integrations");
+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 resolveIntegrationsDir = () => join13(COMPILER_DATA_DIR, "integrations");
 var resolveBasePath = () => process.cwd();
 var resolveUserBasePath = () => {
   const userBasePath = process.env.AI_OPS_HOME ?? process.env.HOME;
@@ -3349,8 +3261,8 @@ var findInstalledSkill = (installedSkills, skillId) => {
 };
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync9, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname11, resolve as resolve9 } from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10, resolve as resolve9 } from "path";
 var installSkillPackages = (basePath, packages) => {
   const writtenRoots = [];
   for (const skillPackage of packages) {
@@ -3360,8 +3272,8 @@ var installSkillPackages = (basePath, packages) => {
     }
     for (const file of skillPackage.files) {
       const absPath = resolve9(basePath, file.relativePath);
-      mkdirSync9(dirname11(absPath), { recursive: true });
-      writeFileSync9(absPath, file.content + "\n", "utf-8");
+      mkdirSync8(dirname10(absPath), { recursive: true });
+      writeFileSync8(absPath, file.content + "\n", "utf-8");
     }
     writtenRoots.push(skillPackage.rootDir);
   }
@@ -3553,8 +3465,8 @@ import * as p8 from "@clack/prompts";
 import { existsSync as existsSync8, rmSync as rmSync7 } from "fs";
 
 // src/lib/subagent-install.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync10, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname12, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve10 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync9, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve10 } from "path";
 var resolveInsideBasePath = (basePath, relativePath) => {
   const absBasePath = resolve10(basePath);
   const absPath = resolve10(absBasePath, relativePath);
@@ -3572,8 +3484,8 @@ var installSubagentPackages = (basePath, packages) => {
       if (existsSync7(absPath)) {
         rmSync6(absPath, { recursive: true, force: true });
       }
-      mkdirSync10(dirname12(absPath), { recursive: true });
-      writeFileSync10(absPath, file.content.trimEnd() + "\n", "utf-8");
+      mkdirSync9(dirname11(absPath), { recursive: true });
+      writeFileSync9(absPath, file.content.trimEnd() + "\n", "utf-8");
       written.push(file.relativePath);
     }
   }
@@ -4064,7 +3976,7 @@ var contextPromotionPostToolUseHookCommand = async () => {
 // src/commands/codex-hook.ts
 import * as p11 from "@clack/prompts";
 import { existsSync as existsSync9 } from "fs";
-import { join as join18 } from "path";
+import { join as join14 } from "path";
 var CONTEXT_PROMOTION_REVIEW_SKILL_ID = "context-promotion-review";
 var resolveCodexHomePath = () => {
   const codexHome = process.env.CODEX_HOME;
@@ -4102,7 +4014,7 @@ var resolveContextPromotionReviewSkill = () => {
 };
 var hasInstalledContextPromotionReviewSkill = (basePath) => {
   const installedSkill = findInstalledSkill(readInstalledSkills2(basePath), CONTEXT_PROMOTION_REVIEW_SKILL_ID);
-  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync9(join18(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
+  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync9(join14(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
 };
 var ensureContextPromotionReviewSkill = (basePath) => {
   const skill = resolveContextPromotionReviewSkill();
@@ -4116,7 +4028,7 @@ var ensureContextPromotionReviewSkill = (basePath) => {
     skill,
     requestedTools
   });
-  const alreadyInstalled = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync9(join18(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
+  const alreadyInstalled = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync9(join14(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
   if (alreadyInstalled) {
     return { changed: false, installedSkill };
   }
@@ -4180,7 +4092,7 @@ var codexHookUninstallCommand = async (hookId) => {
 // src/commands/integration.ts
 import * as p12 from "@clack/prompts";
 import { existsSync as existsSync10, rmSync as rmSync8 } from "fs";
-import { join as join19 } from "path";
+import { join as join15 } from "path";
 var CODEX_HOOK_DEFINITIONS = [CONTEXT_PROMOTION_CODEX_HOOK, PC_CODEX_HOOK];
 var resolveCodexHomePath2 = () => {
   const codexHome = process.env.CODEX_HOME;
@@ -4275,7 +4187,7 @@ var resolveSkillById2 = (skillId) => {
 };
 var hasInstalledCodexSkill = (params) => {
   const installedSkill = findInstalledSkill(readInstalledSkills3(params.basePath), params.skillId);
-  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync10(join19(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
+  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync10(join15(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
 };
 var writeUserSkillState2 = (params) => {
   const registryPath = resolveSkillRegistryPath(params.basePath);
@@ -4303,7 +4215,7 @@ var ensureSkillComponent = (params) => {
     skill,
     requestedTools
   });
-  const alreadyCurrent = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync10(join19(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
+  const alreadyCurrent = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync10(join15(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
   if (alreadyCurrent) {
     return {
       type: INTEGRATION_COMPONENT_TYPE.SKILL,