ai-ops-cli 1.1.1 → 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,27 +210,146 @@ 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 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 z8 } from "zod";
+var INTEGRATION_ID = {
+  CONTEXT_PROMOTION: "context-promotion",
+  PC: "pc"
+};
+var INTEGRATION_COMPONENT_TYPE = {
+  SKILL: "skill",
+  CODEX_HOOK: "codex-hook",
+  RECEIPT_CONFIG: "receipt-config"
+};
+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 = z8.object({
+  type: z8.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+  id: IntegrationIdSchema,
+  command: z8.string().min(1),
+  owned: z8.boolean()
+}).strict();
+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 = z8.union([
+  IntegrationSkillComponentSchema,
+  IntegrationCodexHookComponentSchema,
+  IntegrationReceiptConfigComponentSchema
+]);
+var InstalledIntegrationSchema = z8.object({
+  id: IntegrationIdSchema,
+  components: z8.array(IntegrationComponentSchema),
+  installedAt: z8.string().min(1),
+  updatedAt: z8.string().min(1)
+}).strict();
+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 z9 } from "zod";
-var SubagentManifestSchema = z9.object({
-  subagents: z9.array(InstalledSubagentSchema),
-  cliVersion: z9.string().optional(),
-  generatedAt: z9.string().datetime({ offset: true })
+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: z9.array(z9.literal("codex")).min(1)
+}).strict();
+var IntegrationCatalogCodexHookComponentSchema = z9.object({
+  type: z9.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+  id: IntegrationIdSchema
 }).strict();
+var IntegrationCatalogReceiptConfigComponentSchema = z9.object({
+  type: z9.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
+  id: ComponentIdSchema,
+  storage_path: z9.string().min(1)
+}).strict();
+var IntegrationCatalogComponentSchema = z9.union([
+  IntegrationCatalogSkillComponentSchema,
+  IntegrationCatalogCodexHookComponentSchema,
+  IntegrationCatalogReceiptConfigComponentSchema
+]);
+var IntegrationCatalogEntrySchema = z9.object({
+  id: IntegrationIdSchema,
+  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);
+  const hasReceiptConfig = entry.components.some(
+    (component) => component.type === INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG
+  );
+  if (!hasSkill) {
+    ctx.addIssue({
+      code: z9.ZodIssueCode.custom,
+      path: ["components"],
+      message: `integration must declare a skill component: ${entry.id}`
+    });
+  }
+  if (!hasCodexHook) {
+    ctx.addIssue({
+      code: z9.ZodIssueCode.custom,
+      path: ["components"],
+      message: `integration must declare a codex-hook component: ${entry.id}`
+    });
+  }
+  if (!hasReceiptConfig) {
+    ctx.addIssue({
+      code: z9.ZodIssueCode.custom,
+      path: ["components"],
+      message: `integration must declare a receipt-config component: ${entry.id}`
+    });
+  }
+});
+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: z9.ZodIssueCode.custom,
+        path: ["integrations", index, "id"],
+        message: `duplicate integration id: ${entry.id}`
+      });
+    }
+    seen.add(entry.id);
+  }
+});
 
 // src/core/schemas/pack.schema.ts
 import { z as z10 } from "zod";
@@ -279,40 +363,6 @@ 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 = z11.object({
-  preset: z11.string().min(1),
-  rules: z11.array(z11.string().min(1))
-}).strict();
-var ManifestSchema = z11.object({
-  tools: z11.array(z11.string().min(1)).min(1),
-  scope: z11.literal("project"),
-  /** 비모노레포 단일 preset */
-  preset: z11.string().min(1).optional(),
-  /** 모노레포: workspace path → { preset, rules } */
-  workspaces: z11.record(z11.string(), WorkspaceEntrySchema).optional(),
-  installed_rules: z11.array(z11.string().min(1)),
-  /** 실제 디스크에 쓰여진 파일 상대 경로 목록 (uninstall용). 기존 manifest 호환성 위해 optional */
-  installed_files: z11.array(z11.string().min(1)).optional(),
-  /** skill 설치 루트 디렉토리 목록 */
-  installed_skills: z11.array(InstalledSkillSchema).optional(),
-  /** non-managed 파일에 섹션을 append한 경우 추적 (uninstall 시 섹션만 제거) */
-  appended_files: z11.array(z11.string().min(1)).optional(),
-  /** init 시 선택된 settings 항목 — update 시 재생성에 사용 */
-  settings: SettingsConfigSchema.optional(),
-  /** init/update 실행 시점의 CLI 패키지 버전 — 버전 변경 감지에 사용 */
-  cliVersion: z11.string().optional(),
-  /** SSOT 데이터 파일들의 deterministic SHA-256 해시 (6자리 hex). diff/update 판단 기준 */
-  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 as join2, resolve } from "path";
@@ -424,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
     };
@@ -444,6 +493,10 @@ var assertSubagentFrontmatterName = (params) => {
   }
 };
 var loadSubagentCatalog = (subagentsDir) => SubagentCatalogSchema.parse(JSON.parse(readFileSync(resolve(subagentsDir, "subagent-registry.json"), "utf-8")));
+var loadIntegrationCatalog = (integrationsDir) => IntegrationCatalogSchema.parse(
+  JSON.parse(readFileSync(resolve(integrationsDir, "integration-registry.json"), "utf-8"))
+);
+var loadAllIntegrations = (integrationsDir) => [...loadIntegrationCatalog(integrationsDir).integrations].sort((a, b) => a.id.localeCompare(b.id));
 var loadAllSubagents = (subagentsDir) => {
   const catalog = loadSubagentCatalog(subagentsDir);
   const entries = [...catalog.subagents].sort((a, b) => a.id.localeCompare(b.id));
@@ -483,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 = () => {
@@ -514,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;
 };
@@ -539,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 {
@@ -583,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) => {
@@ -732,64 +780,97 @@ 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/install-plan.ts
-import { join as join9 } from "path";
+// src/core/integration-manifest-io.ts
+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) => join7(userBasePath, ".ai-ops", INTEGRATION_MANIFEST_FILENAME);
+var readIntegrationManifest = (manifestPath) => {
+  let raw;
+  try {
+    raw = readFileSync5(manifestPath, "utf-8");
+  } catch {
+    return null;
+  }
+  return parseIntegrationManifest(raw);
+};
+var writeIntegrationManifest = (manifestPath, manifest) => {
+  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) => [
+  ...integrations.filter((integration) => integration.id !== nextIntegration.id),
+  nextIntegration
+];
+var removeInstalledIntegration = (integrations, integrationId) => integrations.filter((integration) => integration.id !== integrationId);
+var writeUserIntegrationState = (params) => {
+  const previous = readIntegrationManifest(params.manifestPath);
+  const integrations = params.removeIntegrationId ? removeInstalledIntegration(previous?.integrations ?? [], params.removeIntegrationId) : params.nextIntegration ? upsertInstalledIntegration(previous?.integrations ?? [], params.nextIntegration) : previous?.integrations ?? [];
+  if (integrations.length === 0) {
+    rmSync(params.manifestPath, { force: true });
+    return;
+  }
+  writeIntegrationManifest(params.manifestPath, {
+    schemaVersion: 1,
+    kind: "ai-ops-integrations-manifest",
+    integrations,
+    cliVersion: params.cliVersion,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
 
 // src/core/project-layer.ts
-import { existsSync, 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";
+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 dirname5, resolve as resolve4 } from "path";
@@ -800,7 +881,7 @@ 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 = join10(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 = [
@@ -813,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"
@@ -827,9 +907,9 @@ 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 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)) {
@@ -1441,7 +1521,7 @@ function removeManagedProjectFile(basePath, relativePath) {
   }
   const stripped = stripAiOpsSection(content);
   if (stripped.trim().length === 0) {
-    rmSync(absolutePath);
+    rmSync2(absolutePath);
     return { deleted: [relativePath], cleaned: [], preserved: [], notFound: [] };
   }
   writeFileSync4(absolutePath, stripped, "utf-8");
@@ -1455,7 +1535,7 @@ var removeCreateOnlyProjectFile = (basePath, file) => {
   const content = readFileSync6(absolutePath, "utf-8").trimEnd();
   const currentHash = computeHash([content]);
   if (file.created && currentHash === file.templateHash) {
-    rmSync(absolutePath);
+    rmSync2(absolutePath);
     return { deleted: [file.path], cleaned: [], preserved: [], notFound: [] };
   }
   return { deleted: [], cleaned: [], preserved: [file.path], notFound: [] };
@@ -1467,7 +1547,7 @@ var removePackOwnedFile = (basePath, file) => {
   }
   const currentHash = computeHash([readFileSync6(absolutePath, "utf-8").trimEnd()]);
   if (currentHash === file.sourceHash) {
-    rmSync(absolutePath);
+    rmSync2(absolutePath);
     return { deleted: [file.path], cleaned: [], preserved: [], notFound: [] };
   }
   return { deleted: [], cleaned: [], preserved: [file.path], notFound: [] };
@@ -1487,7 +1567,7 @@ var removeEmptyDirs = (basePath, relativePaths) => {
     if (!existsSync(absoluteDir)) continue;
     try {
       if (readdirSync3(absoluteDir).length === 0) {
-        rmSync(absoluteDir, { recursive: true });
+        rmSync2(absoluteDir, { recursive: true });
       }
     } catch {
     }
@@ -1501,7 +1581,7 @@ var uninstallProjectLayer = (basePath, manifest) => {
   );
   const stateFiles = [PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH, PROJECT_LAYER_MANIFEST_RELATIVE_PATH];
   for (const stateFile of stateFiles) {
-    rmSync(resolveProjectLayerFilePath(basePath, stateFile), { force: true });
+    rmSync2(resolveProjectLayerFilePath(basePath, stateFile), { force: true });
   }
   const result = mergeRemoveResults([...managedResults, ...projectResults, ...packResults]);
   removeEmptyDirs(basePath, [...result.deleted, ...stateFiles]);
@@ -1509,8 +1589,8 @@ var uninstallProjectLayer = (basePath, manifest) => {
 };
 
 // src/core/pack.ts
-import { existsSync as existsSync2, 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";
+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/";
@@ -1518,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 = join11(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(readFileSync7(join11(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}`);
@@ -1529,16 +1609,16 @@ var assertPackInstallPath = (path) => {
 var readPackSourceFiles = (packDir) => {
   const files = [];
   const walk = (relativeDir = "") => {
-    const absoluteDir = relativeDir.length > 0 ? join11(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 ? join11(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 = readFileSync7(join11(packDir, nextRelativePath), "utf-8");
+      const content = readFileSync7(join9(packDir, nextRelativePath), "utf-8");
       files.push({
         path: nextRelativePath,
         content,
@@ -1659,7 +1739,7 @@ var applyPackSourceFiles = (params) => {
       continue;
     }
     if (readProjectFileHash(params.basePath, previous.path) === previous.sourceHash) {
-      rmSync2(absolutePath);
+      rmSync3(absolutePath);
       deleted.push(previous.path);
     } else {
       preserved.push(previous.path);
@@ -1678,7 +1758,7 @@ var removePackFiles = (basePath, record) => {
       continue;
     }
     if (readProjectFileHash(basePath, file.path) === file.sourceHash) {
-      rmSync2(absolutePath);
+      rmSync3(absolutePath);
       deleted.push(file.path);
     } else {
       preserved.push(file.path);
@@ -1697,7 +1777,7 @@ var removeEmptyDirs2 = (basePath, relativePaths) => {
     }
     try {
       if (readdirSync4(absoluteDir).length === 0) {
-        rmSync2(absoluteDir, { recursive: true });
+        rmSync3(absoluteDir, { recursive: true });
       }
     } catch {
     }
@@ -1816,99 +1896,315 @@ var diffProjectLayerPack = (params) => {
   return { issues };
 };
 
-// src/core/uninstall-plan.ts
-import { join as join12 } from "path";
-
 // src/core/context-promotion.ts
 import { createHash as createHash2 } from "crypto";
 import { execFileSync } from "child_process";
 import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, join as join13, resolve as resolve7 } from "path";
+import { dirname as dirname8, join as join10, resolve as resolve7 } from "path";
 import { z as z12 } from "zod";
-var CONTEXT_PROMOTION_DECISION = {
-  PROMOTED: "promoted",
-  NO_PROMOTION: "no-promotion"
-};
-var CONTEXT_PROMOTION_SCOPE = {
-  CORE: "core",
-  PROJECT_LOCAL: "project-local",
-  GLOBAL: "global"
-};
-var ContextPromotionDecisionSchema = z12.union([
-  z12.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
-  z12.literal(CONTEXT_PROMOTION_DECISION.NO_PROMOTION)
-]);
-var ContextPromotionScopeSchema = z12.union([
-  z12.literal(CONTEXT_PROMOTION_SCOPE.CORE),
-  z12.literal(CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL),
-  z12.literal(CONTEXT_PROMOTION_SCOPE.GLOBAL)
+
+// src/core/tool-use-hook.ts
+import { z as z11 } from "zod";
+var HookToolInputSchema = z11.object({
+  command: z11.string().optional()
+}).passthrough();
+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"]);
+var GIT_GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
+  "-C",
+  "-c",
+  "--git-dir",
+  "--work-tree",
+  "--namespace",
+  "--config-env",
+  "--exec-path"
 ]);
-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: z12.array(ContextPromotionScopeSchema),
-  targets: z12.array(z12.string().min(1)),
-  summary: z12.string().min(1),
-  resolvedAt: z12.string().min(1)
-}).strict();
-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;
-var hashHex = (parts, length) => createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, length);
-var buildContextPromotionProjectKey = (gitRoot) => hashHex([resolve7(gitRoot)], 12);
-var runGit = (cwd, args) => execFileSync("git", [...args], {
-  cwd,
-  encoding: "utf-8",
-  maxBuffer: 20 * 1024 * 1024,
-  stdio: ["ignore", "pipe", "ignore"]
-});
-var resolveContextPromotionGitRoot = (cwd) => {
-  try {
-    return runGit(cwd, ["rev-parse", "--show-toplevel"]).trim();
-  } catch {
-    return null;
+var basename = (token) => token.replace(/\\/g, "/").split("/").at(-1) ?? token;
+var isAssignmentToken = (token) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
+var tokenizeShellLike = (command) => {
+  const tokens = [];
+  let current = "";
+  let quote = null;
+  const pushCurrent = () => {
+    if (current.length > 0) {
+      tokens.push(current);
+      current = "";
+    }
+  };
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index];
+    const nextChar = command[index + 1];
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+        continue;
+      }
+      current += char;
+      continue;
+    }
+    if (char === '"' || char === "'") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      pushCurrent();
+      continue;
+    }
+    if (char === "&" && nextChar === "&" || char === "|" && nextChar === "|") {
+      pushCurrent();
+      tokens.push(`${char}${nextChar}`);
+      index += 1;
+      continue;
+    }
+    if (char === ";" || char === "|" || char === "(" || char === ")") {
+      pushCurrent();
+      tokens.push(char);
+      continue;
+    }
+    current += char;
   }
+  pushCurrent();
+  return tokens;
 };
-var readGitHead = (gitRoot) => {
-  try {
-    return runGit(gitRoot, ["rev-parse", "--verify", "HEAD"]).trim();
-  } catch {
-    return "NO_HEAD";
+var splitCommandSegments = (tokens) => {
+  const segments = [];
+  let current = [];
+  for (const token of tokens) {
+    if (SHELL_CONTROL_TOKENS.has(token)) {
+      if (current.length > 0) {
+        segments.push(current);
+        current = [];
+      }
+      continue;
+    }
+    current.push(token);
   }
+  if (current.length > 0) {
+    segments.push(current);
+  }
+  return segments;
 };
-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 = join13(gitRoot, relativePath);
-    try {
-      const stat = statSync(absolutePath);
-      if (!stat.isFile()) {
-        return `${relativePath}:non-file`;
-      }
-      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}`);
+var firstExecutableIndex = (segment) => {
+  let index = 0;
+  while (index < segment.length && isAssignmentToken(segment[index])) {
+    index += 1;
+  }
+  if (segment[index] === "env") {
+    index += 1;
+    while (index < segment.length && isAssignmentToken(segment[index])) {
+      index += 1;
     }
-  });
+  }
+  if (segment[index] === "command" || segment[index] === "sudo") {
+    index += 1;
+  }
+  return index;
 };
-var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
-  const rawDiff = runGit(gitRoot, ["diff", "--raw", "-z"]);
-  const rawNames = runGit(gitRoot, ["diff", "--name-only", "-z"]);
-  const paths = rawNames.split("\0").filter((path) => path.length > 0).sort((a, b) => a.localeCompare(b));
-  return [
-    `raw:${rawDiff}`,
-    ...paths.map((relativePath) => {
-      const absolutePath = join13(gitRoot, relativePath);
-      if (!existsSync3(absolutePath)) {
+var segmentInvokesGitCommit = (segment) => {
+  const executableIndex = firstExecutableIndex(segment);
+  if (executableIndex >= segment.length || basename(segment[executableIndex]) !== "git") {
+    return false;
+  }
+  for (let index = executableIndex + 1; index < segment.length; index += 1) {
+    const token = segment[index];
+    if (GIT_GLOBAL_OPTIONS_WITH_VALUE.has(token)) {
+      index += 1;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return token === "commit";
+  }
+  return false;
+};
+var segmentInvokesShellScriptWithGitCommit = (segment) => {
+  const executableIndex = firstExecutableIndex(segment);
+  const executable = segment[executableIndex];
+  if (!executable || !["bash", "sh", "zsh"].includes(basename(executable))) {
+    return false;
+  }
+  for (let index = executableIndex + 1; index < segment.length - 1; index += 1) {
+    if (SHELL_SCRIPT_FLAGS.has(segment[index]) && isGitCommitCommand(segment[index + 1])) {
+      return true;
+    }
+  }
+  return false;
+};
+var isGitCommitCommand = (command) => {
+  const segments = splitCommandSegments(tokenizeShellLike(command));
+  return segments.some(
+    (segment) => segmentInvokesGitCommit(segment) || segmentInvokesShellScriptWithGitCommit(segment)
+  );
+};
+var isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var numberField = (record, keys) => {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "number") {
+      return value;
+    }
+  }
+  return null;
+};
+var booleanField = (record, keys) => {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "boolean") {
+      return value;
+    }
+  }
+  return null;
+};
+var GIT_COMMIT_FAILURE_OUTPUT_PATTERNS = [
+  /(^|\n)\s*fatal:/i,
+  /(^|\n)\s*error:/i,
+  /(^|\n)\s*nothing to commit\b/i,
+  /(^|\n)\s*no changes added to commit\b/i,
+  /(^|\n).*aborting commit\b/i,
+  /(^|\n).*commit failed\b/i,
+  /(^|\n).*failed to .*commit\b/i,
+  /(^|\n).*command failed\b/i,
+  /(^|\n).*non-zero exit\b/i,
+  /(^|\n).*exit (code|status)\s+[1-9]\d*\b/i,
+  /(^|\n).*exited with code\s+[1-9]\d*\b/i,
+  /(^|\n).*hook.*(failed|declined|error|exit(?:ed)? with code|non-zero)/i
+];
+var GIT_COMMIT_SUCCESS_OUTPUT_PATTERN = /(^|\n)\[[^\]\n]+ [a-f0-9]{7,40}\]/i;
+var stringIndicatesGitCommitSuccess = (output) => GIT_COMMIT_SUCCESS_OUTPUT_PATTERN.test(output);
+var stringIndicatesGitCommitFailureOrSuccess = (output) => stringIndicatesGitCommitSuccess(output) ? false : GIT_COMMIT_FAILURE_OUTPUT_PATTERNS.some((pattern) => pattern.test(output)) ? true : null;
+var recordStringFieldsIndicateGitCommitFailure = (record) => ["message", "output", "stdout", "stderr", "error", "combinedOutput"].some((key) => {
+  const value = record[key];
+  return typeof value === "string" && stringIndicatesGitCommitFailureOrSuccess(value) === true;
+});
+var toolResponseIndicatesFailure = (toolResponse) => {
+  if (typeof toolResponse === "string") {
+    return stringIndicatesGitCommitFailureOrSuccess(toolResponse) === true;
+  }
+  if (!isJsonRecord(toolResponse)) {
+    return false;
+  }
+  const success = booleanField(toolResponse, ["success", "ok"]);
+  if (success === false) {
+    return true;
+  }
+  const exitCode = numberField(toolResponse, ["exit_code", "exitCode", "status", "code"]);
+  if (exitCode !== null && exitCode !== 0) {
+    return true;
+  }
+  return recordStringFieldsIndicateGitCommitFailure(toolResponse);
+};
+var parseSuccessfulGitCommitPostToolUseHook = (hookInput) => {
+  const parsed = ToolUseHookInputSchema.safeParse(hookInput);
+  if (!parsed.success) {
+    return null;
+  }
+  if (parsed.data.hook_event_name !== "PostToolUse" || parsed.data.tool_name !== "Bash") {
+    return null;
+  }
+  const toolInput = HookToolInputSchema.safeParse(parsed.data.tool_input);
+  const command = toolInput.success ? toolInput.data.command ?? "" : "";
+  if (!isGitCommitCommand(command) || toolResponseIndicatesFailure(parsed.data.tool_response)) {
+    return null;
+  }
+  return {
+    cwd: parsed.data.cwd,
+    command
+  };
+};
+
+// src/core/context-promotion.ts
+var CONTEXT_PROMOTION_DECISION = {
+  PROMOTED: "promoted",
+  NO_PROMOTION: "no-promotion"
+};
+var CONTEXT_PROMOTION_SCOPE = {
+  CORE: "core",
+  PROJECT_LOCAL: "project-local",
+  GLOBAL: "global"
+};
+var ContextPromotionDecisionSchema = z12.union([
+  z12.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
+  z12.literal(CONTEXT_PROMOTION_DECISION.NO_PROMOTION)
+]);
+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 = z12.object({
+  fingerprint: z12.string().regex(/^[a-f0-9]{16}$/),
+  commitHash: z12.string().regex(/^(NO_HEAD|[a-f0-9]{40})$/).optional(),
+  decision: ContextPromotionDecisionSchema,
+  scopes: z12.array(ContextPromotionScopeSchema),
+  targets: z12.array(z12.string().min(1)),
+  summary: z12.string().min(1),
+  resolvedAt: z12.string().min(1)
+}).strict();
+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;
+var hashHex = (parts, length) => createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, length);
+var buildContextPromotionProjectKey = (gitRoot) => hashHex([resolve7(gitRoot)], 12);
+var runGit = (cwd, args) => execFileSync("git", [...args], {
+  cwd,
+  encoding: "utf-8",
+  maxBuffer: 20 * 1024 * 1024,
+  stdio: ["ignore", "pipe", "ignore"]
+});
+var resolveContextPromotionGitRoot = (cwd) => {
+  try {
+    return runGit(cwd, ["rev-parse", "--show-toplevel"]).trim();
+  } catch {
+    return null;
+  }
+};
+var readGitHead = (gitRoot) => {
+  try {
+    return runGit(gitRoot, ["rev-parse", "--verify", "HEAD"]).trim();
+  } catch {
+    return "NO_HEAD";
+  }
+};
+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 = join10(gitRoot, relativePath);
+    try {
+      const stat = statSync(absolutePath);
+      if (!stat.isFile()) {
+        return `${relativePath}:non-file`;
+      }
+      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}`);
+    }
+  });
+};
+var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
+  const rawDiff = runGit(gitRoot, ["diff", "--raw", "-z"]);
+  const rawNames = runGit(gitRoot, ["diff", "--name-only", "-z"]);
+  const paths = rawNames.split("\0").filter((path) => path.length > 0).sort((a, b) => a.localeCompare(b));
+  return [
+    `raw:${rawDiff}`,
+    ...paths.map((relativePath) => {
+      const absolutePath = join10(gitRoot, relativePath);
+      if (!existsSync3(absolutePath)) {
         return `${relativePath}:deleted`;
       }
       const stat = statSync(absolutePath);
@@ -1933,14 +2229,7 @@ var computeContextPromotionFingerprint = (gitRoot) => hashHex(
   ],
   16
 );
-var resolveContextPromotionReceiptIndexPath = (params) => join13(
-  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) => {
@@ -2000,7 +2289,7 @@ var pruneContextPromotionReceipts = (params) => {
   writeContextPromotionReceiptIndex(params.indexPath, nextIndex);
   return nextIndex;
 };
-var hasContextPromotionLayer = (gitRoot) => existsSync3(join13(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);
@@ -2087,143 +2376,6 @@ var resolveContextPromotion = (params) => {
   });
   return getContextPromotionStatus({ cwd: params.cwd, userBasePath: params.userBasePath });
 };
-var HookToolInputSchema = z12.object({
-  command: z12.string().optional()
-}).passthrough();
-var ToolUseHookInputSchema = z12.object({
-  hook_event_name: z12.string(),
-  cwd: z12.string(),
-  tool_name: z12.string().optional(),
-  tool_input: z12.unknown().optional(),
-  tool_response: z12.unknown().optional()
-}).passthrough();
-var SHELL_CONTROL_TOKENS = /* @__PURE__ */ new Set(["&&", "||", ";", "|", "(", ")"]);
-var SHELL_SCRIPT_FLAGS = /* @__PURE__ */ new Set(["-c", "-lc"]);
-var GIT_GLOBAL_OPTIONS_WITH_VALUE = /* @__PURE__ */ new Set([
-  "-C",
-  "-c",
-  "--git-dir",
-  "--work-tree",
-  "--namespace",
-  "--config-env",
-  "--exec-path"
-]);
-var basename = (token) => token.replace(/\\/g, "/").split("/").at(-1) ?? token;
-var isAssignmentToken = (token) => /^[A-Za-z_][A-Za-z0-9_]*=/.test(token);
-var tokenizeShellLike = (command) => {
-  const tokens = [];
-  let current = "";
-  let quote = null;
-  const pushCurrent = () => {
-    if (current.length > 0) {
-      tokens.push(current);
-      current = "";
-    }
-  };
-  for (let index = 0; index < command.length; index += 1) {
-    const char = command[index];
-    const nextChar = command[index + 1];
-    if (quote) {
-      if (char === quote) {
-        quote = null;
-        continue;
-      }
-      current += char;
-      continue;
-    }
-    if (char === '"' || char === "'") {
-      quote = char;
-      continue;
-    }
-    if (/\s/.test(char)) {
-      pushCurrent();
-      continue;
-    }
-    if (char === "&" && nextChar === "&" || char === "|" && nextChar === "|") {
-      pushCurrent();
-      tokens.push(`${char}${nextChar}`);
-      index += 1;
-      continue;
-    }
-    if (char === ";" || char === "|" || char === "(" || char === ")") {
-      pushCurrent();
-      tokens.push(char);
-      continue;
-    }
-    current += char;
-  }
-  pushCurrent();
-  return tokens;
-};
-var splitCommandSegments = (tokens) => {
-  const segments = [];
-  let current = [];
-  for (const token of tokens) {
-    if (SHELL_CONTROL_TOKENS.has(token)) {
-      if (current.length > 0) {
-        segments.push(current);
-        current = [];
-      }
-      continue;
-    }
-    current.push(token);
-  }
-  if (current.length > 0) {
-    segments.push(current);
-  }
-  return segments;
-};
-var firstExecutableIndex = (segment) => {
-  let index = 0;
-  while (index < segment.length && isAssignmentToken(segment[index])) {
-    index += 1;
-  }
-  if (segment[index] === "env") {
-    index += 1;
-    while (index < segment.length && isAssignmentToken(segment[index])) {
-      index += 1;
-    }
-  }
-  if (segment[index] === "command" || segment[index] === "sudo") {
-    index += 1;
-  }
-  return index;
-};
-var segmentInvokesGitCommit = (segment) => {
-  const executableIndex = firstExecutableIndex(segment);
-  if (executableIndex >= segment.length || basename(segment[executableIndex]) !== "git") {
-    return false;
-  }
-  for (let index = executableIndex + 1; index < segment.length; index += 1) {
-    const token = segment[index];
-    if (GIT_GLOBAL_OPTIONS_WITH_VALUE.has(token)) {
-      index += 1;
-      continue;
-    }
-    if (token.startsWith("-")) {
-      continue;
-    }
-    return token === "commit";
-  }
-  return false;
-};
-var segmentInvokesShellScriptWithGitCommit = (segment) => {
-  const executableIndex = firstExecutableIndex(segment);
-  const executable = segment[executableIndex];
-  if (!executable || !["bash", "sh", "zsh"].includes(basename(executable))) {
-    return false;
-  }
-  for (let index = executableIndex + 1; index < segment.length - 1; index += 1) {
-    if (SHELL_SCRIPT_FLAGS.has(segment[index]) && isGitCommitCommand(segment[index + 1])) {
-      return true;
-    }
-  }
-  return false;
-};
-var isGitCommitCommand = (command) => {
-  const segments = splitCommandSegments(tokenizeShellLike(command));
-  return segments.some((segment) => segmentInvokesGitCommit(segment) || segmentInvokesShellScriptWithGitCommit(segment));
-};
 var buildContextPromotionReviewPrompt = (status) => {
   const projectRoot = status.gitRoot ?? status.cwd;
   const cdCommand = `cd ${JSON.stringify(projectRoot)}`;
@@ -2279,107 +2431,388 @@ var buildPostToolUseOutput = (prompt) => ({
     additionalContext: prompt
   }
 });
-var isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var numberField = (record, keys) => {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "number") {
+var evaluateContextPromotionPostToolUseHook = (params) => {
+  const hookInput = parseSuccessfulGitCommitPostToolUseHook(params.hookInput);
+  if (!hookInput) {
+    return null;
+  }
+  let status;
+  try {
+    status = getContextPromotionStatus({
+      cwd: hookInput.cwd,
+      userBasePath: params.userBasePath
+    });
+  } catch (error) {
+    return buildPostToolUseOutput(buildContextPromotionStatusFailurePrompt(hookInput.cwd, error));
+  }
+  if (!status.hasContextLayer || status.receipt) {
+    return null;
+  }
+  return buildPostToolUseOutput(buildContextPromotionReviewPrompt(status));
+};
+
+// src/core/pc-integration.ts
+import { execFileSync as execFileSync2 } from "child_process";
+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);
+  const child = normalizePath(childPath);
+  return child === parent || child.startsWith(`${parent}${sep}`);
+};
+var normalizeFieldValue = (value) => {
+  const trimmed = value?.trim() ?? "";
+  if (trimmed.length === 0 || ["none", "null", "-", "<empty>"].includes(trimmed.toLowerCase())) {
+    return null;
+  }
+  return trimmed.replace(/^`|`$/g, "");
+};
+var extractSection = (content, headings) => {
+  const headingPattern = headings.map((heading) => heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+  const match = new RegExp(`^##\\s+(?:${headingPattern})\\s*$`, "mu").exec(content);
+  if (!match) {
+    return "";
+  }
+  const start = match.index + match[0].length;
+  const rest = content.slice(start);
+  const nextHeading = /^##\s+/mu.exec(rest);
+  return nextHeading ? rest.slice(0, nextHeading.index) : rest;
+};
+var parseListField = (content, labels) => {
+  for (const label of labels) {
+    const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = new RegExp(`^-\\s+${escapedLabel}:\\s*(.+)$`, "mu").exec(content);
+    const value = normalizeFieldValue(match?.[1] ?? null);
+    if (value) {
       return value;
     }
   }
-  return null;
+  return null;
+};
+var readTextFileOrNull = (filePath) => {
+  try {
+    return readFileSync9(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+};
+var runGit2 = (cwd, args) => execFileSync2("git", [...args], {
+  cwd,
+  encoding: "utf-8",
+  stdio: ["ignore", "pipe", "ignore"]
+}).trim();
+var resolveGitRoot = (cwd) => {
+  try {
+    return runGit2(cwd, ["rev-parse", "--show-toplevel"]);
+  } catch {
+    return null;
+  }
+};
+var readGitHead2 = (cwd) => {
+  try {
+    return runGit2(cwd, ["rev-parse", "--verify", "HEAD"]);
+  } catch {
+    return null;
+  }
+};
+var listWorkspaceStatePaths = (contextRoot) => {
+  const workspacesDir = join11(contextRoot, "workspaces");
+  if (!existsSync4(workspacesDir)) {
+    return [];
+  }
+  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);
+  if (!content) {
+    return null;
+  }
+  const workspaceRoot = parseListField(content, ["\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 \uB8E8\uD2B8", "Workspace Root"]);
+  if (!workspaceRoot) {
+    return null;
+  }
+  const activeSection = extractSection(content, ["\uD65C\uC131 Workstream", "Active Workstream"]);
+  const activeWorkstreamId = parseListField(activeSection, ["ID", "Workstream ID", "Active Workstream"]);
+  const workspaceDir = resolve8(statePath, "..");
+  const id = parseListField(content, ["\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 ID", "Workspace ID"]) ?? workspaceDir.split(sep).at(-1) ?? "unknown";
+  return {
+    id,
+    statePath,
+    workspaceDir,
+    workspaceRoot,
+    activeWorkstreamId
+  };
+};
+var findMatchingWorkspace = (params) => {
+  const candidates = listWorkspaceStatePaths(params.contextRoot).map(parseWorkspaceCandidate).filter((candidate) => candidate !== null).filter((candidate) => pathContains(candidate.workspaceRoot, params.cwd)).sort((a, b) => normalizePath(b.workspaceRoot).length - normalizePath(a.workspaceRoot).length);
+  return candidates[0] ?? null;
+};
+var parseRepoEntry = (entryPath) => {
+  const content = readTextFileOrNull(entryPath);
+  if (!content) {
+    return null;
+  }
+  const id = parseListField(content, ["\uC5D4\uD2B8\uB9AC ID", "Entry ID"]);
+  if (!id) {
+    return null;
+  }
+  return {
+    id,
+    path: parseListField(content, ["\uACBD\uB85C", "Path"]),
+    gitRoot: parseListField(content, ["Git \uB8E8\uD2B8", "Git Root"])
+  };
+};
+var findCurrentEntry = (params) => {
+  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(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) => {
+    const aLength = Math.max(0, ...[a.path, a.gitRoot].map((path) => path ? normalizePath(path).length : 0));
+    const bLength = Math.max(0, ...[b.path, b.gitRoot].map((path) => path ? normalizePath(path).length : 0));
+    return bLength - aLength;
+  });
+  return entries[0] ?? null;
+};
+var parseWorkstreamScopeEntryIds = (content) => {
+  const scopeSection = extractSection(content, ["\uBC94\uC704", "Scope"]);
+  if (scopeSection.length === 0) {
+    return [];
+  }
+  const lines = scopeSection.split("\n");
+  const ids = [];
+  let inEntryBlock = false;
+  for (const line of lines) {
+    if (/^-\s*(엔트리|Entries|Entry):/.test(line)) {
+      inEntryBlock = true;
+      const inlineValue = normalizeFieldValue(line.split(":").slice(1).join(":"));
+      if (inlineValue && !inlineValue.includes("<")) {
+        ids.push(...inlineValue.split(",").map((value) => value.trim().replace(/^`|`$/g, "")));
+      }
+      continue;
+    }
+    if (inEntryBlock && /^-\s+\S/.test(line)) {
+      inEntryBlock = false;
+    }
+    if (!inEntryBlock) {
+      continue;
+    }
+    const nestedMatch = /^\s+-\s+`?([a-z0-9]+(?:-[a-z0-9]+)*)`?/.exec(line);
+    if (nestedMatch) {
+      ids.push(nestedMatch[1]);
+    }
+  }
+  return [...new Set(ids.filter((id) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)))];
 };
-var booleanField = (record, keys) => {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "boolean") {
-      return value;
-    }
+var parseLastConfirmedCommitHash = (params) => {
+  const section = extractSection(params.content, ["\uB9C8\uC9C0\uB9C9 \uD655\uC778 Commit", "Last Confirmed Commit"]);
+  if (section.length === 0) {
+    return null;
   }
-  return null;
+  const escapedEntryId = params.entryId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = new RegExp(`^-\\s+\`?${escapedEntryId}\`?:\\s*([a-f0-9]{40})\\b`, "imu").exec(section);
+  return match?.[1] ?? null;
 };
-var GIT_COMMIT_FAILURE_OUTPUT_PATTERNS = [
-  /(^|\n)\s*fatal:/i,
-  /(^|\n)\s*error:/i,
-  /(^|\n)\s*nothing to commit\b/i,
-  /(^|\n)\s*no changes added to commit\b/i,
-  /(^|\n).*aborting commit\b/i,
-  /(^|\n).*commit failed\b/i,
-  /(^|\n).*failed to .*commit\b/i,
-  /(^|\n).*command failed\b/i,
-  /(^|\n).*non-zero exit\b/i,
-  /(^|\n).*exit (code|status)\s+[1-9]\d*\b/i,
-  /(^|\n).*exited with code\s+[1-9]\d*\b/i,
-  /(^|\n).*hook.*(failed|declined|error|exit(?:ed)? with code|non-zero)/i
-];
-var GIT_COMMIT_SUCCESS_OUTPUT_PATTERN = /(^|\n)\[[^\]\n]+ [a-f0-9]{7,40}\]/i;
-var stringIndicatesGitCommitSuccess = (output) => GIT_COMMIT_SUCCESS_OUTPUT_PATTERN.test(output);
-var stringIndicatesGitCommitFailureOrSuccess = (output) => stringIndicatesGitCommitSuccess(output) ? false : GIT_COMMIT_FAILURE_OUTPUT_PATTERNS.some((pattern) => pattern.test(output)) ? true : null;
-var recordStringFieldsIndicateGitCommitFailure = (record) => ["message", "output", "stdout", "stderr", "error", "combinedOutput"].some((key) => {
-  const value = record[key];
-  return typeof value === "string" && stringIndicatesGitCommitFailureOrSuccess(value) === true;
-});
-var toolResponseIndicatesFailure = (toolResponse) => {
-  if (typeof toolResponse === "string") {
-    return stringIndicatesGitCommitFailureOrSuccess(toolResponse) === true;
+var getPcHandoffStatus = (params) => {
+  const cwd = normalizePath(params.cwd);
+  const contextRoot = normalizePath(params.contextRoot);
+  if (!existsSync4(contextRoot)) {
+    return {
+      cwd,
+      contextRoot,
+      workspaceId: null,
+      workspaceRoot: null,
+      activeWorkstreamId: null,
+      activeWorkstreamPath: null,
+      currentEntryId: null,
+      lastConfirmedCommitHash: null,
+      ready: false,
+      skipReason: "pc context root not found"
+    };
   }
-  if (!isJsonRecord(toolResponse)) {
-    return false;
+  const workspace = findMatchingWorkspace({ cwd, contextRoot });
+  if (!workspace) {
+    return {
+      cwd,
+      contextRoot,
+      workspaceId: null,
+      workspaceRoot: null,
+      activeWorkstreamId: null,
+      activeWorkstreamPath: null,
+      currentEntryId: null,
+      lastConfirmedCommitHash: null,
+      ready: false,
+      skipReason: "matching pc workspace not found"
+    };
   }
-  const success = booleanField(toolResponse, ["success", "ok"]);
-  if (success === false) {
-    return true;
+  if (!workspace.activeWorkstreamId) {
+    return {
+      cwd,
+      contextRoot,
+      workspaceId: workspace.id,
+      workspaceRoot: workspace.workspaceRoot,
+      activeWorkstreamId: null,
+      activeWorkstreamPath: null,
+      currentEntryId: null,
+      lastConfirmedCommitHash: null,
+      ready: false,
+      skipReason: "active pc workstream not selected"
+    };
   }
-  const exitCode = numberField(toolResponse, ["exit_code", "exitCode", "status", "code"]);
-  if (exitCode !== null && exitCode !== 0) {
-    return true;
+  const activeWorkstreamPath = join11(workspace.workspaceDir, "workstreams", `${workspace.activeWorkstreamId}.md`);
+  const activeWorkstreamContent = readTextFileOrNull(activeWorkstreamPath);
+  if (!activeWorkstreamContent) {
+    return {
+      cwd,
+      contextRoot,
+      workspaceId: workspace.id,
+      workspaceRoot: workspace.workspaceRoot,
+      activeWorkstreamId: workspace.activeWorkstreamId,
+      activeWorkstreamPath,
+      currentEntryId: null,
+      lastConfirmedCommitHash: null,
+      ready: false,
+      skipReason: "active pc workstream file not found"
+    };
   }
-  return recordStringFieldsIndicateGitCommitFailure(toolResponse);
+  const currentEntry = findCurrentEntry({ cwd, workspaceDir: workspace.workspaceDir });
+  if (!currentEntry) {
+    return {
+      cwd,
+      contextRoot,
+      workspaceId: workspace.id,
+      workspaceRoot: workspace.workspaceRoot,
+      activeWorkstreamId: workspace.activeWorkstreamId,
+      activeWorkstreamPath,
+      currentEntryId: null,
+      lastConfirmedCommitHash: null,
+      ready: false,
+      skipReason: "current repo is not registered in pc workspace"
+    };
+  }
+  const lastConfirmedCommitHash = parseLastConfirmedCommitHash({
+    content: activeWorkstreamContent,
+    entryId: currentEntry.id
+  });
+  const scopeEntryIds = parseWorkstreamScopeEntryIds(activeWorkstreamContent);
+  if (scopeEntryIds.length > 0 && !scopeEntryIds.includes(currentEntry.id)) {
+    return {
+      cwd,
+      contextRoot,
+      workspaceId: workspace.id,
+      workspaceRoot: workspace.workspaceRoot,
+      activeWorkstreamId: workspace.activeWorkstreamId,
+      activeWorkstreamPath,
+      currentEntryId: currentEntry.id,
+      lastConfirmedCommitHash,
+      ready: false,
+      skipReason: "current repo is outside the active pc workstream scope"
+    };
+  }
+  return {
+    cwd,
+    contextRoot,
+    workspaceId: workspace.id,
+    workspaceRoot: workspace.workspaceRoot,
+    activeWorkstreamId: workspace.activeWorkstreamId,
+    activeWorkstreamPath,
+    currentEntryId: currentEntry.id,
+    lastConfirmedCommitHash,
+    ready: true,
+    skipReason: null
+  };
 };
-var evaluateContextPromotionPostToolUseHook = (params) => {
-  const hookInput = ToolUseHookInputSchema.safeParse(params.hookInput);
-  if (!hookInput.success) {
+var buildPcDonePrompt = (params) => [
+  "A successful git commit just created a new HEAD commit.",
+  "",
+  "Run `$pc:done` now to record the handoff for the active personal project context.",
+  "",
+  "Important guardrails:",
+  "- Do not create or initialize a new pc context from this hook.",
+  "- If `$pc:done` cannot match the prepared workspace, active workstream, or current repo scope, skip and briefly say why.",
+  "- If the active workstream already records this HEAD as the last confirmed commit, skip without writing another handoff.",
+  "- Do not modify the product repo for this hook; `$pc:done` may only update `~/.personal-project-contexts/` and commit that context repo.",
+  "- Use the just-created HEAD commit as the newest evidence for completed work and the next first action.",
+  "",
+  `Project git root: ${params.gitRoot}`,
+  `HEAD: ${params.head}`,
+  `pc context root: ${params.status.contextRoot}`,
+  `pc workspace: ${params.status.workspaceId ?? "unknown"} (${params.status.workspaceRoot ?? "unknown"})`,
+  `active workstream: ${params.status.activeWorkstreamId ?? "unknown"}`,
+  `current entry: ${params.status.currentEntryId ?? "unknown"}`,
+  `last confirmed commit: ${params.status.lastConfirmedCommitHash ?? "none"}`
+].join("\n");
+var buildPostToolUseOutput2 = (prompt) => ({
+  decision: "block",
+  reason: prompt,
+  hookSpecificOutput: {
+    hookEventName: "PostToolUse",
+    additionalContext: prompt
+  }
+});
+var evaluatePcPostToolUseHook = (params) => {
+  const gitCommitHook = parseSuccessfulGitCommitPostToolUseHook(params.hookInput);
+  if (!gitCommitHook) {
     return null;
   }
-  if (hookInput.data.hook_event_name !== "PostToolUse" || hookInput.data.tool_name !== "Bash") {
+  const gitRoot = resolveGitRoot(gitCommitHook.cwd);
+  if (!gitRoot) {
     return null;
   }
-  const toolInput = HookToolInputSchema.safeParse(hookInput.data.tool_input);
-  const command = toolInput.success ? toolInput.data.command ?? "" : "";
-  if (!isGitCommitCommand(command) || toolResponseIndicatesFailure(hookInput.data.tool_response)) {
+  const head = readGitHead2(gitRoot);
+  if (!head) {
     return null;
   }
-  let status;
-  try {
-    status = getContextPromotionStatus({
-      cwd: hookInput.data.cwd,
-      userBasePath: params.userBasePath
-    });
-  } catch (error) {
-    return buildPostToolUseOutput(buildContextPromotionStatusFailurePrompt(hookInput.data.cwd, error));
+  const status = getPcHandoffStatus({
+    cwd: gitCommitHook.cwd,
+    contextRoot: params.contextRoot
+  });
+  if (!status.ready) {
+    return null;
   }
-  if (!status.hasContextLayer || status.receipt) {
+  if (status.lastConfirmedCommitHash === head) {
     return null;
   }
-  return buildPostToolUseOutput(buildContextPromotionReviewPrompt(status));
+  return buildPostToolUseOutput2(buildPcDonePrompt({ status, head, gitRoot }));
 };
 
 // src/core/codex-hook.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync7, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname9, join as join14 } 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";
 var CONTEXT_PROMOTION_DEFAULT_HOOK_COMMAND = `ai-ops ${CONTEXT_PROMOTION_HOOK_COMMAND_MARKER}`;
+var PC_HOOK_ID = "pc";
+var PC_HOOK_COMMAND_MARKER = "integration hook post-tool-use pc";
+var PC_DEFAULT_HOOK_COMMAND = `ai-ops ${PC_HOOK_COMMAND_MARKER}`;
 var PRE_TOOL_USE_EVENT = "PreToolUse";
 var POST_TOOL_USE_EVENT = "PostToolUse";
 var BASH_MATCHER = "^Bash$";
+var CONTEXT_PROMOTION_CODEX_HOOK = {
+  id: CONTEXT_PROMOTION_HOOK_ID,
+  commandMarker: CONTEXT_PROMOTION_HOOK_COMMAND_MARKER,
+  legacyCommandMarkers: [CONTEXT_PROMOTION_LEGACY_HOOK_COMMAND_MARKER],
+  defaultCommand: CONTEXT_PROMOTION_DEFAULT_HOOK_COMMAND,
+  statusMessage: "Checking context promotion review"
+};
+var PC_CODEX_HOOK = {
+  id: PC_HOOK_ID,
+  commandMarker: PC_HOOK_COMMAND_MARKER,
+  legacyCommandMarkers: [],
+  defaultCommand: PC_DEFAULT_HOOK_COMMAND,
+  statusMessage: "Checking pc handoff"
+};
 var isJsonRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var readJsonRecord = (filePath) => {
-  if (!existsSync4(filePath)) {
+  if (!existsSync5(filePath)) {
     return {};
   }
-  const parsed = JSON.parse(readFileSync9(filePath, "utf-8"));
+  const parsed = JSON.parse(readFileSync10(filePath, "utf-8"));
   if (!isJsonRecord2(parsed)) {
     throw new Error("hooks.json must contain a JSON object");
   }
@@ -2402,34 +2835,34 @@ var getArray = (record, key) => {
   const existing = record[key];
   return Array.isArray(existing) ? existing : [];
 };
-var handlerMatchesContextPromotion = (handler) => isJsonRecord2(handler) && typeof handler.command === "string" && (handler.command.includes(CONTEXT_PROMOTION_HOOK_COMMAND_MARKER) || handler.command.includes(CONTEXT_PROMOTION_LEGACY_HOOK_COMMAND_MARKER));
+var handlerMatchesDefinition = (definition) => (handler) => isJsonRecord2(handler) && typeof handler.command === "string" && [definition.commandMarker, ...definition.legacyCommandMarkers].some((marker) => handler.command.includes(marker));
 var handlerMatchesCommand = (handler, command) => isJsonRecord2(handler) && handler.command === command;
-var groupHasContextPromotionHook = (group) => isJsonRecord2(group) && getArray(group, "hooks").some(handlerMatchesContextPromotion);
-var groupHasCurrentContextPromotionHook = (group, command) => isJsonRecord2(group) && getArray(group, "hooks").some((handler) => handlerMatchesCommand(handler, command));
-var countContextPromotionHandlers = (groups) => groups.reduce((count, group) => {
+var groupHasDefinitionHook = (definition) => (group) => isJsonRecord2(group) && getArray(group, "hooks").some(handlerMatchesDefinition(definition));
+var groupHasCurrentDefinitionHook = (group, command) => isJsonRecord2(group) && getArray(group, "hooks").some((handler) => handlerMatchesCommand(handler, command));
+var countDefinitionHandlers = (groups, definition) => groups.reduce((count, group) => {
   if (!isJsonRecord2(group)) {
     return count;
   }
-  return count + getArray(group, "hooks").filter(handlerMatchesContextPromotion).length;
+  return count + getArray(group, "hooks").filter(handlerMatchesDefinition(definition)).length;
 }, 0);
-var configHasContextPromotionHook = (config) => {
+var configHasDefinitionHook = (config, definition) => {
   const hooks = config.hooks;
   if (!isJsonRecord2(hooks)) {
     return false;
   }
-  return getArray(hooks, POST_TOOL_USE_EVENT).some(groupHasContextPromotionHook);
+  return getArray(hooks, POST_TOOL_USE_EVENT).some(groupHasDefinitionHook(definition));
 };
-var configHasOnlyCurrentContextPromotionHook = (config, command) => {
+var configHasOnlyCurrentDefinitionHook = (config, definition, command) => {
   const hooks = config.hooks;
   if (!isJsonRecord2(hooks)) {
     return false;
   }
-  const hasLegacy = getArray(hooks, PRE_TOOL_USE_EVENT).some(groupHasContextPromotionHook);
+  const hasLegacy = getArray(hooks, PRE_TOOL_USE_EVENT).some(groupHasDefinitionHook(definition));
   const postGroups = getArray(hooks, POST_TOOL_USE_EVENT);
-  const hasCurrent = postGroups.some((group) => groupHasCurrentContextPromotionHook(group, command));
-  return hasCurrent && !hasLegacy && countContextPromotionHandlers(postGroups) === 1;
+  const hasCurrent = postGroups.some((group) => groupHasCurrentDefinitionHook(group, command));
+  return hasCurrent && !hasLegacy && countDefinitionHandlers(postGroups, definition) === 1;
 };
-var removeContextPromotionHooksFromEvent = (hooks, eventName) => {
+var removeDefinitionHooksFromEvent = (hooks, eventName, definition) => {
   const previousGroups = getArray(hooks, eventName);
   let removed = false;
   const nextGroups = previousGroups.map((group) => {
@@ -2438,7 +2871,7 @@ var removeContextPromotionHooksFromEvent = (hooks, eventName) => {
     }
     const previousHandlers = getArray(group, "hooks");
     const nextHandlers = previousHandlers.filter((handler) => {
-      const matches = handlerMatchesContextPromotion(handler);
+      const matches = handlerMatchesDefinition(definition)(handler);
       if (matches) {
         removed = true;
       }
@@ -2462,21 +2895,29 @@ var removeContextPromotionHooksFromEvent = (hooks, eventName) => {
   }
   return true;
 };
-var resolveCodexHooksPath = (codexHomePath) => join14(codexHomePath, "hooks.json");
-var buildContextPromotionHookCommand = (overrideCommand) => {
-  const command = overrideCommand?.trim() ?? CONTEXT_PROMOTION_DEFAULT_HOOK_COMMAND;
-  if (!command.includes(CONTEXT_PROMOTION_HOOK_COMMAND_MARKER)) {
-    throw new Error(`context promotion hook command must include: ${CONTEXT_PROMOTION_HOOK_COMMAND_MARKER}`);
+var resolveCodexHooksPath = (codexHomePath) => join12(codexHomePath, "hooks.json");
+var buildCodexHookCommand = (params) => {
+  const command = params.overrideCommand?.trim() ?? params.definition.defaultCommand;
+  if (!command.includes(params.definition.commandMarker)) {
+    throw new Error(`${params.definition.id} hook command must include: ${params.definition.commandMarker}`);
   }
   return command;
 };
+var buildContextPromotionHookCommand = (overrideCommand) => buildCodexHookCommand({
+  definition: CONTEXT_PROMOTION_CODEX_HOOK,
+  overrideCommand
+});
+var inspectCodexHook = (params) => ({
+  hooksPath: params.hooksPath,
+  installed: configHasDefinitionHook(readJsonRecord(params.hooksPath), params.definition)
+});
 var inspectContextPromotionHook = (hooksPath) => ({
   hooksPath,
-  installed: configHasContextPromotionHook(readJsonRecord(hooksPath))
+  installed: inspectCodexHook({ hooksPath, definition: CONTEXT_PROMOTION_CODEX_HOOK }).installed
 });
-var installContextPromotionHook = (params) => {
+var installCodexHook = (params) => {
   const config = readJsonRecord(params.hooksPath);
-  if (configHasOnlyCurrentContextPromotionHook(config, params.command)) {
+  if (configHasOnlyCurrentDefinitionHook(config, params.definition, params.command)) {
     return {
       hooksPath: params.hooksPath,
       installed: true,
@@ -2484,8 +2925,8 @@ var installContextPromotionHook = (params) => {
     };
   }
   const hooks = getOrCreateRecord(config, "hooks");
-  removeContextPromotionHooksFromEvent(hooks, PRE_TOOL_USE_EVENT);
-  removeContextPromotionHooksFromEvent(hooks, POST_TOOL_USE_EVENT);
+  removeDefinitionHooksFromEvent(hooks, PRE_TOOL_USE_EVENT, params.definition);
+  removeDefinitionHooksFromEvent(hooks, POST_TOOL_USE_EVENT, params.definition);
   const existingGroups = getArray(hooks, POST_TOOL_USE_EVENT);
   const nextGroup = {
     matcher: BASH_MATCHER,
@@ -2494,7 +2935,7 @@ var installContextPromotionHook = (params) => {
         type: "command",
         command: params.command,
         timeout: 30,
-        statusMessage: "Checking context promotion review"
+        statusMessage: params.definition.statusMessage
       }
     ]
   };
@@ -2506,32 +2947,42 @@ var installContextPromotionHook = (params) => {
     changed: true
   };
 };
-var uninstallContextPromotionHook = (hooksPath) => {
-  const config = readJsonRecord(hooksPath);
+var installContextPromotionHook = (params) => installCodexHook({
+  hooksPath: params.hooksPath,
+  definition: CONTEXT_PROMOTION_CODEX_HOOK,
+  command: params.command
+});
+var uninstallCodexHook = (params) => {
+  const config = readJsonRecord(params.hooksPath);
   const hooks = config.hooks;
   if (!isJsonRecord2(hooks)) {
-    return { hooksPath, removed: false, changed: false };
+    return { hooksPath: params.hooksPath, removed: false, changed: false };
   }
-  const removedLegacy = removeContextPromotionHooksFromEvent(hooks, PRE_TOOL_USE_EVENT);
-  const removedCurrent = removeContextPromotionHooksFromEvent(hooks, POST_TOOL_USE_EVENT);
+  const removedLegacy = removeDefinitionHooksFromEvent(hooks, PRE_TOOL_USE_EVENT, params.definition);
+  const removedCurrent = removeDefinitionHooksFromEvent(hooks, POST_TOOL_USE_EVENT, params.definition);
   const removed = removedLegacy || removedCurrent;
   if (!removed) {
-    return { hooksPath, removed: false, changed: false };
+    return { hooksPath: params.hooksPath, removed: false, changed: false };
   }
-  writeJsonRecord(hooksPath, config);
-  return { hooksPath, removed: true, changed: true };
+  writeJsonRecord(params.hooksPath, config);
+  return { hooksPath: params.hooksPath, removed: true, changed: true };
 };
+var uninstallContextPromotionHook = (hooksPath) => uninstallCodexHook({
+  hooksPath,
+  definition: CONTEXT_PROMOTION_CODEX_HOOK
+});
 
 // src/lib/paths.ts
-import { join as join15 } from "path";
-var resolveSkillsDir = () => join15(COMPILER_DATA_DIR, "skills");
-var resolveSubagentsDir = () => join15(COMPILER_DATA_DIR, "subagents");
-var resolvePacksDir = () => join15(COMPILER_DATA_DIR, "packs");
+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;
   if (!userBasePath) {
-    throw new Error("AI_OPS_HOME or HOME is required for global asset commands");
+    throw new Error("AI_OPS_HOME or HOME is required for user/global component commands");
   }
   return userBasePath;
 };
@@ -2776,7 +3227,7 @@ ${result.notFound.map((file) => `  ${file}`).join("\n")}`);
 
 // src/commands/skill.ts
 import * as p7 from "@clack/prompts";
-import { rmSync as rmSync4 } from "fs";
+import { rmSync as rmSync5 } from "fs";
 
 // src/lib/skill-state.ts
 var resolveRequestedTools = (params) => {
@@ -2810,17 +3261,17 @@ var findInstalledSkill = (installedSkills, skillId) => {
 };
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync8, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, resolve as resolve8 } 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) {
-    const absRoot = resolve8(basePath, skillPackage.rootDir);
-    if (existsSync5(absRoot)) {
-      rmSync3(absRoot, { recursive: true, force: true });
+    const absRoot = resolve9(basePath, skillPackage.rootDir);
+    if (existsSync6(absRoot)) {
+      rmSync4(absRoot, { recursive: true, force: true });
     }
     for (const file of skillPackage.files) {
-      const absPath = resolve8(basePath, file.relativePath);
+      const absPath = resolve9(basePath, file.relativePath);
       mkdirSync8(dirname10(absPath), { recursive: true });
       writeFileSync8(absPath, file.content + "\n", "utf-8");
     }
@@ -2831,9 +3282,9 @@ var installSkillPackages = (basePath, packages) => {
 var removeDirectories = (basePath, relativeDirs) => {
   const removed = [];
   for (const relativeDir of relativeDirs) {
-    const absPath = resolve8(basePath, relativeDir);
-    if (!existsSync5(absPath)) continue;
-    rmSync3(absPath, { recursive: true, force: true });
+    const absPath = resolve9(basePath, relativeDir);
+    if (!existsSync6(absPath)) continue;
+    rmSync4(absPath, { recursive: true, force: true });
     removed.push(relativeDir);
   }
   return removed;
@@ -2859,7 +3310,7 @@ var writeUserSkillState = (params) => {
   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) {
-    rmSync4(registryPath, { force: true });
+    rmSync5(registryPath, { force: true });
     return;
   }
   writeSkillRegistry(registryPath, {
@@ -3011,14 +3462,14 @@ var skillUninstallCommand = async (skillId) => {
 
 // src/commands/subagent.ts
 import * as p8 from "@clack/prompts";
-import { existsSync as existsSync7, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync8, rmSync as rmSync7 } from "fs";
 
 // src/lib/subagent-install.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync9, rmSync as rmSync5, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname11, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve9 } 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 = resolve9(basePath);
-  const absPath = resolve9(absBasePath, relativePath);
+  const absBasePath = resolve10(basePath);
+  const absPath = resolve10(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}`);
@@ -3030,8 +3481,8 @@ var installSubagentPackages = (basePath, packages) => {
   for (const subagentPackage of packages) {
     for (const file of subagentPackage.files) {
       const absPath = resolveInsideBasePath(basePath, file.relativePath);
-      if (existsSync6(absPath)) {
-        rmSync5(absPath, { recursive: true, force: true });
+      if (existsSync7(absPath)) {
+        rmSync6(absPath, { recursive: true, force: true });
       }
       mkdirSync9(dirname11(absPath), { recursive: true });
       writeFileSync9(absPath, file.content.trimEnd() + "\n", "utf-8");
@@ -3044,8 +3495,8 @@ var removeSubagentFiles = (basePath, relativePaths) => {
   const removed = [];
   for (const relativePath of relativePaths) {
     const absPath = resolveInsideBasePath(basePath, relativePath);
-    if (!existsSync6(absPath)) continue;
-    rmSync5(absPath, { recursive: true, force: true });
+    if (!existsSync7(absPath)) continue;
+    rmSync6(absPath, { recursive: true, force: true });
     removed.push(relativePath);
   }
   return removed;
@@ -3095,7 +3546,7 @@ var writeUserSubagentState = (params) => {
   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 });
+    rmSync7(manifestPath, { force: true });
     return;
   }
   writeSubagentManifest(manifestPath, {
@@ -3106,7 +3557,7 @@ var writeUserSubagentState = (params) => {
 };
 var readInstalledSubagents = (basePath) => readSubagentManifest(resolveSubagentManifestPath(basePath))?.subagents ?? [];
 var warnMissingSkills = (requiredSkills) => {
-  const missing = requiredSkills.filter((skill) => !existsSync7(skill.path));
+  const missing = requiredSkills.filter((skill) => !existsSync8(skill.path));
   if (missing.length === 0) {
     return;
   }
@@ -3417,13 +3868,13 @@ var parseMax = (max) => {
   }
   return parsed;
 };
-var readStdin = async () => new Promise((resolve10, reject) => {
+var readStdin = async () => new Promise((resolve11, reject) => {
   let raw = "";
   process.stdin.setEncoding("utf-8");
   process.stdin.on("data", (chunk) => {
     raw += chunk;
   });
-  process.stdin.on("end", () => resolve10(raw));
+  process.stdin.on("end", () => resolve11(raw));
   process.stdin.on("error", reject);
 });
 var reportContextPromotionError = (error) => {
@@ -3524,8 +3975,8 @@ var contextPromotionPostToolUseHookCommand = async () => {
 
 // src/commands/codex-hook.ts
 import * as p11 from "@clack/prompts";
-import { existsSync as existsSync8 } from "fs";
-import { join as join16 } from "path";
+import { existsSync as existsSync9 } from "fs";
+import { join as join14 } from "path";
 var CONTEXT_PROMOTION_REVIEW_SKILL_ID = "context-promotion-review";
 var resolveCodexHomePath = () => {
   const codexHome = process.env.CODEX_HOME;
@@ -3563,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 && existsSync8(join16(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();
@@ -3577,7 +4028,7 @@ var ensureContextPromotionReviewSkill = (basePath) => {
     skill,
     requestedTools
   });
-  const alreadyInstalled = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync8(join16(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 };
   }
@@ -3638,6 +4089,386 @@ var codexHookUninstallCommand = async (hookId) => {
   p11.outro("ai-ops codex-hook uninstall \uC644\uB8CC");
 };
 
+// src/commands/integration.ts
+import * as p12 from "@clack/prompts";
+import { existsSync as existsSync10, rmSync as rmSync8 } from "fs";
+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;
+  if (codexHome && codexHome.length > 0) {
+    return codexHome;
+  }
+  const home = process.env.HOME;
+  if (!home) {
+    throw new Error("CODEX_HOME or HOME is required for Codex hook commands");
+  }
+  return `${home}/.codex`;
+};
+var resolvePersonalContextRoot = () => {
+  const home = process.env.HOME;
+  if (!home) {
+    throw new Error("HOME is required for pc integration commands");
+  }
+  return `${home}/.personal-project-contexts`;
+};
+var resolveCodexHookDefinition = (hookId) => {
+  const hookDefinition = CODEX_HOOK_DEFINITIONS.find((definition) => definition.id === hookId);
+  if (!hookDefinition) {
+    throw new Error(`Unknown Codex hook for integration: ${hookId}`);
+  }
+  return hookDefinition;
+};
+var resolveCatalogSkillComponent = (entry) => {
+  const component = entry.components.find((candidate) => candidate.type === INTEGRATION_COMPONENT_TYPE.SKILL);
+  if (!component || component.type !== INTEGRATION_COMPONENT_TYPE.SKILL) {
+    throw new Error(`Integration catalog entry must declare a skill component: ${entry.id}`);
+  }
+  return component;
+};
+var resolveCatalogHookComponent = (entry) => {
+  const component = entry.components.find((candidate) => candidate.type === INTEGRATION_COMPONENT_TYPE.CODEX_HOOK);
+  if (!component || component.type !== INTEGRATION_COMPONENT_TYPE.CODEX_HOOK) {
+    throw new Error(`Integration catalog entry must declare a codex-hook component: ${entry.id}`);
+  }
+  return component;
+};
+var resolveCatalogReceiptConfigComponents = (entry) => entry.components.filter(
+  (component) => component.type === INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG
+);
+var loadIntegrationDefinitions = () => loadAllIntegrations(resolveIntegrationsDir()).map((entry) => {
+  const hookComponent = resolveCatalogHookComponent(entry);
+  return {
+    ...entry,
+    skillComponent: resolveCatalogSkillComponent(entry),
+    hookComponent,
+    receiptConfigComponents: resolveCatalogReceiptConfigComponents(entry),
+    hookDefinition: resolveCodexHookDefinition(hookComponent.id)
+  };
+});
+var parseIntegrationId = (integrationId) => {
+  const definition = loadIntegrationDefinitions().find((candidate) => candidate.id === integrationId);
+  if (!definition) {
+    throw new Error(`Unknown integration: ${integrationId}`);
+  }
+  return definition.id;
+};
+var resolveIntegrationDefinition = (integrationId) => {
+  const definition = loadIntegrationDefinitions().find((candidate) => candidate.id === integrationId);
+  if (!definition) {
+    throw new Error(`Unknown integration: ${integrationId}`);
+  }
+  return definition;
+};
+var reportIntegrationError = (error) => {
+  const message = error instanceof Error ? error.message : "unknown error";
+  p12.log.error(message);
+  process.exitCode = 1;
+};
+var readStdin2 = async () => new Promise((resolve11, reject) => {
+  let raw = "";
+  process.stdin.setEncoding("utf-8");
+  process.stdin.on("data", (chunk) => {
+    raw += chunk;
+  });
+  process.stdin.on("end", () => resolve11(raw));
+  process.stdin.on("error", reject);
+});
+var readInstalledSkills3 = (basePath) => (readSkillRegistry(resolveSkillRegistryPath(basePath))?.skills ?? []).map((installedSkill) => ({
+  ...installedSkill,
+  id: resolveCanonicalSkillId(installedSkill.id)
+}));
+var resolveSkillById2 = (skillId) => {
+  const skill = loadAllSkills(resolveSkillsDir()).find((candidate) => candidate.id === skillId);
+  if (!skill) {
+    throw new Error(`Unknown skill: ${skillId}`);
+  }
+  return skill;
+};
+var hasInstalledCodexSkill = (params) => {
+  const installedSkill = findInstalledSkill(readInstalledSkills3(params.basePath), params.skillId);
+  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);
+  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) {
+    rmSync8(registryPath, { force: true });
+    return;
+  }
+  writeSkillRegistry(registryPath, {
+    skills,
+    cliVersion: params.cliVersion,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+var ensureSkillComponent = (params) => {
+  const skill = resolveSkillById2(params.skillId);
+  const installedSkills = readInstalledSkills3(params.basePath);
+  const existingInstalledSkill = findInstalledSkill(installedSkills, skill.id);
+  const requestedTools = mergeSkillTools({
+    existing: existingInstalledSkill?.tools,
+    requested: [SKILL_TOOL.CODEX]
+  });
+  const { packages, installedSkill } = buildSkillInstallPlan({
+    skill,
+    requestedTools
+  });
+  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,
+      id: params.skillId,
+      tools: [SKILL_TOOL.CODEX],
+      owned: params.previouslyOwned
+    };
+  }
+  installSkillPackages(params.basePath, packages);
+  writeUserSkillState2({
+    basePath: params.basePath,
+    cliVersion: params.cliVersion,
+    nextSkill: installedSkill
+  });
+  return {
+    type: INTEGRATION_COMPONENT_TYPE.SKILL,
+    id: params.skillId,
+    tools: [SKILL_TOOL.CODEX],
+    owned: true
+  };
+};
+var ensureHookComponent = (params) => {
+  const command = buildCodexHookCommand({
+    definition: params.definition,
+    overrideCommand: params.command
+  });
+  const installedBefore = inspectCodexHook({
+    hooksPath: params.hooksPath,
+    definition: params.definition
+  }).installed;
+  const result = installCodexHook({
+    hooksPath: params.hooksPath,
+    definition: params.definition,
+    command
+  });
+  return {
+    type: INTEGRATION_COMPONENT_TYPE.CODEX_HOOK,
+    id: params.hookId,
+    command,
+    owned: params.previouslyOwned || result.changed || !installedBefore
+  };
+};
+var buildReceiptConfigComponents = (components) => components.map((component) => ({
+  type: INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG,
+  id: component.id,
+  storagePath: component.storage_path,
+  owned: false
+}));
+var componentWasOwned = (params) => params.previous?.components.some(
+  (component) => component.type === params.type && component.id === params.id && component.owned
+) ?? false;
+var buildInstalledIntegration = (params) => {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: params.definition.id,
+    components: [...params.components],
+    installedAt: params.previous?.installedAt ?? now,
+    updatedAt: now
+  };
+};
+var removeOwnedSkill = (params) => {
+  const installedSkill = findInstalledSkill(readInstalledSkills3(params.basePath), params.skillId);
+  if (!installedSkill) {
+    return [];
+  }
+  const removed = removeDirectories(params.basePath, installedSkill.installed_paths);
+  writeUserSkillState2({
+    basePath: params.basePath,
+    cliVersion: params.cliVersion,
+    removeSkillId: params.skillId
+  });
+  return removed;
+};
+var formatComponentStatus = (component) => {
+  const owner = component.owned ? "owned" : "pre-existing";
+  if (component.type === INTEGRATION_COMPONENT_TYPE.SKILL) {
+    return `skill:${component.id} (${owner})`;
+  }
+  if (component.type === INTEGRATION_COMPONENT_TYPE.CODEX_HOOK) {
+    return `codex-hook:${component.id} (${owner})`;
+  }
+  return `receipt-config:${component.id} (${owner})`;
+};
+var integrationListCommand = async () => {
+  p12.intro("ai-ops integration list");
+  try {
+    const manifest = readIntegrationManifest(resolveIntegrationManifestPath(resolveUserBasePath()));
+    const installed = new Set((manifest?.integrations ?? []).map((integration) => integration.id));
+    const lines = loadIntegrationDefinitions().map((definition) => {
+      const suffix = installed.has(definition.id) ? "installed" : "not installed";
+      return `- ${definition.id} - ${suffix} - ${definition.description}`;
+    });
+    p12.log.info(lines.join("\n"));
+  } catch (error) {
+    reportIntegrationError(error);
+  }
+  p12.outro("ai-ops integration list \uC644\uB8CC");
+};
+var integrationInstallCommand = async (integrationId, opts = {}) => {
+  p12.intro(`ai-ops integration install ${integrationId}`);
+  try {
+    const definition = resolveIntegrationDefinition(integrationId);
+    const basePath = resolveUserBasePath();
+    const cliVersion = getCliVersion();
+    const manifestPath = resolveIntegrationManifestPath(basePath);
+    const previous = findInstalledIntegration(readIntegrationManifest(manifestPath)?.integrations ?? [], definition.id);
+    const skillComponent = ensureSkillComponent({
+      basePath,
+      cliVersion,
+      skillId: definition.skillComponent.id,
+      previouslyOwned: componentWasOwned({
+        previous,
+        type: INTEGRATION_COMPONENT_TYPE.SKILL,
+        id: definition.skillComponent.id
+      })
+    });
+    const hookComponent = ensureHookComponent({
+      hooksPath: resolveCodexHooksPath(resolveCodexHomePath2()),
+      hookId: definition.hookComponent.id,
+      definition: definition.hookDefinition,
+      command: opts.command,
+      previouslyOwned: componentWasOwned({
+        previous,
+        type: INTEGRATION_COMPONENT_TYPE.CODEX_HOOK,
+        id: definition.hookComponent.id
+      })
+    });
+    const installedIntegration = buildInstalledIntegration({
+      definition,
+      previous,
+      components: [skillComponent, hookComponent, ...buildReceiptConfigComponents(definition.receiptConfigComponents)]
+    });
+    writeUserIntegrationState({
+      manifestPath,
+      cliVersion,
+      nextIntegration: installedIntegration
+    });
+    p12.log.success(`integration \uC124\uCE58 \uC644\uB8CC: ${definition.id}`);
+    p12.log.info(installedIntegration.components.map(formatComponentStatus).join("\n"));
+  } catch (error) {
+    reportIntegrationError(error);
+  }
+  p12.outro("ai-ops integration install \uC644\uB8CC");
+};
+var integrationStatusCommand = async (integrationId) => {
+  p12.intro(`ai-ops integration status ${integrationId}`);
+  try {
+    const definition = resolveIntegrationDefinition(integrationId);
+    const basePath = resolveUserBasePath();
+    const manifest = readIntegrationManifest(resolveIntegrationManifestPath(basePath));
+    const installedIntegration = findInstalledIntegration(manifest?.integrations ?? [], definition.id);
+    const hookStatus = inspectCodexHook({
+      hooksPath: resolveCodexHooksPath(resolveCodexHomePath2()),
+      definition: definition.hookDefinition
+    });
+    const lines = [
+      `integration installed: ${installedIntegration ? "yes" : "no"}`,
+      `skill installed: ${hasInstalledCodexSkill({ basePath, skillId: definition.skillComponent.id }) ? "yes" : "no"}`,
+      `hook installed: ${hookStatus.installed ? "yes" : "no"}`,
+      `hooks file: ${hookStatus.hooksPath}`
+    ];
+    if (definition.id === INTEGRATION_ID.PC) {
+      const pcStatus = getPcHandoffStatus({
+        cwd: resolveBasePath(),
+        contextRoot: resolvePersonalContextRoot()
+      });
+      lines.push(
+        `pc context ready: ${pcStatus.ready ? "yes" : "no"}`,
+        `pc skip reason: ${pcStatus.skipReason ?? "none"}`,
+        `pc workspace: ${pcStatus.workspaceId ?? "not found"}`,
+        `pc active workstream: ${pcStatus.activeWorkstreamId ?? "not found"}`,
+        `pc last confirmed commit: ${pcStatus.lastConfirmedCommitHash ?? "not found"}`
+      );
+    }
+    if (installedIntegration) {
+      lines.push(`owned components: ${installedIntegration.components.map(formatComponentStatus).join(", ")}`);
+    }
+    p12.log.info(lines.join("\n"));
+  } catch (error) {
+    reportIntegrationError(error);
+  }
+  p12.outro("ai-ops integration status \uC644\uB8CC");
+};
+var integrationUninstallCommand = async (integrationId) => {
+  p12.intro(`ai-ops integration uninstall ${integrationId}`);
+  try {
+    const definition = resolveIntegrationDefinition(integrationId);
+    const basePath = resolveUserBasePath();
+    const cliVersion = getCliVersion();
+    const manifestPath = resolveIntegrationManifestPath(basePath);
+    const installedIntegration = findInstalledIntegration(
+      readIntegrationManifest(manifestPath)?.integrations ?? [],
+      definition.id
+    );
+    if (!installedIntegration) {
+      p12.log.warn("\uC124\uCE58\uB41C integration manifest entry\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+      p12.outro("ai-ops integration uninstall \uC644\uB8CC");
+      return;
+    }
+    const removed = [];
+    for (const component of installedIntegration.components) {
+      if (!component.owned) {
+        continue;
+      }
+      if (component.type === INTEGRATION_COMPONENT_TYPE.SKILL) {
+        removed.push(...removeOwnedSkill({ basePath, cliVersion, skillId: component.id }));
+      }
+      if (component.type === INTEGRATION_COMPONENT_TYPE.CODEX_HOOK) {
+        const result = uninstallCodexHook({
+          hooksPath: resolveCodexHooksPath(resolveCodexHomePath2()),
+          definition: definition.hookDefinition
+        });
+        if (result.removed) {
+          removed.push(result.hooksPath);
+        }
+      }
+    }
+    writeUserIntegrationState({
+      manifestPath,
+      cliVersion,
+      removeIntegrationId: definition.id
+    });
+    p12.log.success(removed.length > 0 ? `\uC81C\uAC70 \uC644\uB8CC: ${removed.join(", ")}` : "\uC81C\uAC70\uD560 owned component \uC5C6\uC74C");
+  } catch (error) {
+    reportIntegrationError(error);
+  }
+  p12.outro("ai-ops integration uninstall \uC644\uB8CC");
+};
+var integrationPostToolUseHookCommand = async (integrationId) => {
+  try {
+    const id = parseIntegrationId(integrationId);
+    const raw = await readStdin2();
+    const hookInput = raw.trim().length > 0 ? JSON.parse(raw) : {};
+    if (id !== INTEGRATION_ID.PC) {
+      return;
+    }
+    const output = evaluatePcPostToolUseHook({
+      hookInput,
+      contextRoot: resolvePersonalContextRoot()
+    });
+    if (output) {
+      process.stdout.write(JSON.stringify(output) + "\n");
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "unknown error";
+    process.stdout.write(
+      JSON.stringify({
+        systemMessage: `ai-ops integration hook skipped: ${message}`
+      }) + "\n"
+    );
+  }
+};
+
 // src/bin/index.ts
 var program = new Command();
 program.name("ai-ops").description("AI agent operating layer manager").version(getCliVersion());
@@ -3683,5 +4514,12 @@ var codexHookCommand = program.command("codex-hook").description("Codex hooks \u
 codexHookCommand.command("install <hookId>").description("Codex hook \uC124\uCE58").option("--command <command>", "hook\uC5D0 \uC800\uC7A5\uD560 context-promotion \uC2E4\uD589 \uBA85\uB839").action((hookId, opts) => codexHookInstallCommand(hookId, opts));
 codexHookCommand.command("status <hookId>").description("Codex hook \uC124\uCE58 \uC0C1\uD0DC \uD655\uC778").action((hookId) => codexHookStatusCommand(hookId));
 codexHookCommand.command("uninstall <hookId>").description("Codex hook \uC81C\uAC70").action((hookId) => codexHookUninstallCommand(hookId));
+var integrationCommand = program.command("integration").description("user/global runtime integration \uC124\uCE58/\uC870\uD68C/\uC81C\uAC70");
+integrationCommand.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C integration \uBAA9\uB85D").action(() => integrationListCommand());
+integrationCommand.command("install <integrationId>").description("integration \uC124\uCE58").option("--command <command>", "Codex hook\uC5D0 \uC800\uC7A5\uD560 \uC2E4\uD589 \uBA85\uB839").action((integrationId, opts) => integrationInstallCommand(integrationId, opts));
+integrationCommand.command("status <integrationId>").description("integration \uC124\uCE58 \uC0C1\uD0DC \uD655\uC778").action((integrationId) => integrationStatusCommand(integrationId));
+integrationCommand.command("uninstall <integrationId>").description("integration \uC81C\uAC70").action((integrationId) => integrationUninstallCommand(integrationId));
+var integrationHookCommand = integrationCommand.command("hook").description("integration hook \uB0B4\uBD80 \uBA85\uB839");
+integrationHookCommand.command("post-tool-use <integrationId>").description("Codex PostToolUse integration hook entrypoint").action((integrationId) => integrationPostToolUseHookCommand(integrationId));
 program.parse();
 //# sourceMappingURL=index.js.map