ai-ops-cli 1.1.0 → 1.2.0

package/dist/bin/index.js

@@ -267,50 +267,169 @@ var SubagentManifestSchema = z9.object({
   generatedAt: z9.string().datetime({ offset: true })
 }).strict();
 
-// src/core/schemas/pack.schema.ts
+// src/core/schemas/integration.schema.ts
 import { z as z10 } from "zod";
-var PackIdSchema = z10.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
-var PackSourcePathSchema = z10.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/, "source_path must be relative kebab-case path");
-var PackCatalogEntrySchema = z10.object({
+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 = z10.union([z10.literal(INTEGRATION_ID.CONTEXT_PROMOTION), z10.literal(INTEGRATION_ID.PC)]);
+var IntegrationSkillComponentSchema = z10.object({
+  type: z10.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
+  id: z10.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  tools: z10.array(SkillToolSchema).min(1),
+  owned: z10.boolean()
+}).strict();
+var IntegrationCodexHookComponentSchema = z10.object({
+  type: z10.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+  id: IntegrationIdSchema,
+  command: z10.string().min(1),
+  owned: z10.boolean()
+}).strict();
+var IntegrationReceiptConfigComponentSchema = z10.object({
+  type: z10.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
+  id: z10.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/),
+  storagePath: z10.string().min(1),
+  owned: z10.boolean()
+}).strict();
+var IntegrationComponentSchema = z10.union([
+  IntegrationSkillComponentSchema,
+  IntegrationCodexHookComponentSchema,
+  IntegrationReceiptConfigComponentSchema
+]);
+var InstalledIntegrationSchema = z10.object({
+  id: IntegrationIdSchema,
+  components: z10.array(IntegrationComponentSchema),
+  installedAt: z10.string().min(1),
+  updatedAt: z10.string().min(1)
+}).strict();
+var IntegrationManifestSchema = z10.object({
+  schemaVersion: z10.literal(1),
+  kind: z10.literal("ai-ops-integrations-manifest"),
+  integrations: z10.array(InstalledIntegrationSchema),
+  cliVersion: z10.string().min(1),
+  generatedAt: z10.string().min(1)
+}).strict();
+
+// src/core/schemas/integration-catalog.schema.ts
+import { z as z11 } from "zod";
+var ComponentIdSchema = z11.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "component id must be kebab-case");
+var IntegrationCatalogSkillComponentSchema = z11.object({
+  type: z11.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
+  id: ComponentIdSchema,
+  tools: z11.array(z11.literal("codex")).min(1)
+}).strict();
+var IntegrationCatalogCodexHookComponentSchema = z11.object({
+  type: z11.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+  id: IntegrationIdSchema
+}).strict();
+var IntegrationCatalogReceiptConfigComponentSchema = z11.object({
+  type: z11.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG),
+  id: ComponentIdSchema,
+  storage_path: z11.string().min(1)
+}).strict();
+var IntegrationCatalogComponentSchema = z11.union([
+  IntegrationCatalogSkillComponentSchema,
+  IntegrationCatalogCodexHookComponentSchema,
+  IntegrationCatalogReceiptConfigComponentSchema
+]);
+var IntegrationCatalogEntrySchema = z11.object({
+  id: IntegrationIdSchema,
+  description: z11.string().min(1),
+  components: z11.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: z11.ZodIssueCode.custom,
+      path: ["components"],
+      message: `integration must declare a skill component: ${entry.id}`
+    });
+  }
+  if (!hasCodexHook) {
+    ctx.addIssue({
+      code: z11.ZodIssueCode.custom,
+      path: ["components"],
+      message: `integration must declare a codex-hook component: ${entry.id}`
+    });
+  }
+  if (!hasReceiptConfig) {
+    ctx.addIssue({
+      code: z11.ZodIssueCode.custom,
+      path: ["components"],
+      message: `integration must declare a receipt-config component: ${entry.id}`
+    });
+  }
+});
+var IntegrationCatalogSchema = z11.object({
+  integrations: z11.array(IntegrationCatalogEntrySchema)
+}).strict().superRefine((catalog, ctx) => {
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, entry] of catalog.integrations.entries()) {
+    if (seen.has(entry.id)) {
+      ctx.addIssue({
+        code: z11.ZodIssueCode.custom,
+        path: ["integrations", index, "id"],
+        message: `duplicate integration id: ${entry.id}`
+      });
+    }
+    seen.add(entry.id);
+  }
+});
+
+// src/core/schemas/pack.schema.ts
+import { z as z12 } from "zod";
+var PackIdSchema = z12.string().regex(/^[a-z0-9]+(-[a-z0-9]+)*$/, "id must be kebab-case");
+var PackSourcePathSchema = z12.string().regex(/^[a-z0-9]+(?:-[a-z0-9]+)*(?:\/[a-z0-9]+(?:-[a-z0-9]+)*)*$/, "source_path must be relative kebab-case path");
+var PackCatalogEntrySchema = z12.object({
   id: PackIdSchema,
   source_path: PackSourcePathSchema
 }).strict();
-var PackCatalogSchema = z10.object({
-  packs: z10.array(PackCatalogEntrySchema)
+var PackCatalogSchema = z12.object({
+  packs: z12.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()
+import { z as z13 } from "zod";
+var SettingsConfigSchema = z13.object({
+  claude: z13.array(z13.string().min(1)).optional(),
+  gemini: z13.array(z13.string().min(1)).optional(),
+  prettierignore: z13.boolean().optional()
 }).strict();
-var WorkspaceEntrySchema = z11.object({
-  preset: z11.string().min(1),
-  rules: z11.array(z11.string().min(1))
+var WorkspaceEntrySchema = z13.object({
+  preset: z13.string().min(1),
+  rules: z13.array(z13.string().min(1))
 }).strict();
-var ManifestSchema = z11.object({
-  tools: z11.array(z11.string().min(1)).min(1),
-  scope: z11.literal("project"),
+var ManifestSchema = z13.object({
+  tools: z13.array(z13.string().min(1)).min(1),
+  scope: z13.literal("project"),
   /** 비모노레포 단일 preset */
-  preset: z11.string().min(1).optional(),
+  preset: z13.string().min(1).optional(),
   /** 모노레포: workspace path → { preset, rules } */
-  workspaces: z11.record(z11.string(), WorkspaceEntrySchema).optional(),
-  installed_rules: z11.array(z11.string().min(1)),
+  workspaces: z13.record(z13.string(), WorkspaceEntrySchema).optional(),
+  installed_rules: z13.array(z13.string().min(1)),
   /** 실제 디스크에 쓰여진 파일 상대 경로 목록 (uninstall용). 기존 manifest 호환성 위해 optional */
-  installed_files: z11.array(z11.string().min(1)).optional(),
+  installed_files: z13.array(z13.string().min(1)).optional(),
   /** skill 설치 루트 디렉토리 목록 */
-  installed_skills: z11.array(InstalledSkillSchema).optional(),
+  installed_skills: z13.array(InstalledSkillSchema).optional(),
   /** non-managed 파일에 섹션을 append한 경우 추적 (uninstall 시 섹션만 제거) */
-  appended_files: z11.array(z11.string().min(1)).optional(),
+  appended_files: z13.array(z13.string().min(1)).optional(),
   /** init 시 선택된 settings 항목 — update 시 재생성에 사용 */
   settings: SettingsConfigSchema.optional(),
   /** init/update 실행 시점의 CLI 패키지 버전 — 버전 변경 감지에 사용 */
-  cliVersion: z11.string().optional(),
+  cliVersion: z13.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 })
+  sourceHash: z13.string().regex(/^[a-f0-9]{6}$/, "sourceHash must be 6 lowercase hex chars"),
+  generatedAt: z13.string().datetime({ offset: true })
 }).strict();
 
 // src/core/loader.ts
@@ -444,6 +563,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));
@@ -784,23 +907,65 @@ var writeSubagentManifest = (manifestPath, manifest) => {
   writeFileSync3(manifestPath, serializeSubagentManifest(manifest), "utf-8");
 };
 
+// src/core/integration-manifest-io.ts
+import { mkdirSync as mkdirSync4, readFileSync as readFileSync6, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname5, join as join9 } from "path";
+var INTEGRATION_MANIFEST_FILENAME = "integrations-manifest.json";
+var parseIntegrationManifest = (json) => IntegrationManifestSchema.parse(JSON.parse(json));
+var serializeIntegrationManifest = (manifest) => JSON.stringify(manifest, null, 2) + "\n";
+var resolveIntegrationManifestPath = (userBasePath) => join9(userBasePath, ".ai-ops", INTEGRATION_MANIFEST_FILENAME);
+var readIntegrationManifest = (manifestPath) => {
+  let raw;
+  try {
+    raw = readFileSync6(manifestPath, "utf-8");
+  } catch {
+    return null;
+  }
+  return parseIntegrationManifest(raw);
+};
+var writeIntegrationManifest = (manifestPath, manifest) => {
+  mkdirSync4(dirname5(manifestPath), { recursive: true });
+  writeFileSync4(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/install-plan.ts
-import { join as join9 } from "path";
+import { join as join10 } from "path";
 
 // 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 mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, isAbsolute, join as join11, relative, resolve as resolve5 } from "path";
 
 // src/core/paths.ts
-import { dirname as dirname5, resolve as resolve4 } from "path";
+import { dirname as dirname6, resolve as resolve4 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var __dirname2 = dirname5(fileURLToPath2(import.meta.url));
+var __dirname2 = dirname6(fileURLToPath2(import.meta.url));
 var COMPILER_DATA_DIR = resolve4(__dirname2, "..", "..", "data");
 
 // src/core/project-layer.ts
 var PROJECT_LAYER_MANIFEST_RELATIVE_PATH = ".ai-ops/manifest.json";
 var PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH = ".ai-ops/context-layer.json";
-var CONTEXT_LAYER_DATA_DIR = join10(COMPILER_DATA_DIR, "context-layer");
+var CONTEXT_LAYER_DATA_DIR = join11(COMPILER_DATA_DIR, "context-layer");
 var TOOL_ORDER = ["codex", "gemini", "claude-code"];
 var DEFAULT_TOOLS = TOOL_ORDER;
 var TEMPLATE_PATHS = [
@@ -827,10 +992,10 @@ var RESERVED_DOCUMENT_WARNINGS = [
   "\uD310\uB2E8 \uADFC\uAC70\uB85C \uC0AC\uC6A9\uD558\uC9C0 \uB9C8\uC138\uC694",
   "Do not use this document as current decision-making evidence"
 ];
-var resolveProjectLayerManifestPath = (basePath) => join10(basePath, PROJECT_LAYER_MANIFEST_RELATIVE_PATH);
-var resolveProjectLayerContextIndexPath = (basePath) => join10(basePath, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH);
-var resolveTemplatePath = (relativePath) => join10(CONTEXT_LAYER_DATA_DIR, relativePath);
-var toRelativeDir = (relativePath) => dirname6(relativePath);
+var resolveProjectLayerManifestPath = (basePath) => join11(basePath, PROJECT_LAYER_MANIFEST_RELATIVE_PATH);
+var resolveProjectLayerContextIndexPath = (basePath) => join11(basePath, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH);
+var resolveTemplatePath = (relativePath) => join11(CONTEXT_LAYER_DATA_DIR, relativePath);
+var toRelativeDir = (relativePath) => dirname7(relativePath);
 var resolveProjectLayerFilePath = (basePath, relativePath) => {
   if (!isSafeProjectLayerPath(relativePath)) {
     throw new Error(`Unsafe project layer path: ${relativePath}`);
@@ -945,8 +1110,8 @@ var loadTemplateSpec = (relativePath, content) => {
 };
 var loadProjectLayerTemplateSpecs = (tools) => {
   const selectedPaths = TEMPLATE_PATHS.filter((relativePath) => shouldIncludeTemplate(relativePath, tools));
-  const nonStatusSpecs = selectedPaths.filter((relativePath) => relativePath !== "docs/docs-status.md").map((relativePath) => loadTemplateSpec(relativePath, readFileSync6(resolveTemplatePath(relativePath), "utf-8")));
-  const statusTemplate = readFileSync6(resolveTemplatePath("docs/docs-status.md"), "utf-8");
+  const nonStatusSpecs = selectedPaths.filter((relativePath) => relativePath !== "docs/docs-status.md").map((relativePath) => loadTemplateSpec(relativePath, readFileSync7(resolveTemplatePath(relativePath), "utf-8")));
+  const statusTemplate = readFileSync7(resolveTemplatePath("docs/docs-status.md"), "utf-8");
   const statusPlaceholderSpec = loadTemplateSpec("docs/docs-status.md", statusTemplate);
   const specsForStatus = [...nonStatusSpecs, statusPlaceholderSpec].sort((a, b) => a.path.localeCompare(b.path));
   const statusContent = statusTemplate.replace("{{documents_table}}", buildDocsStatusRows(specsForStatus));
@@ -956,7 +1121,7 @@ var loadProjectLayerTemplateSpecs = (tools) => {
 var computeProjectLayerSourceHash = (specs) => computeHash(specs.map((spec) => `${spec.path}:${spec.content}`));
 var readProjectLayerManifest = (basePath) => {
   try {
-    return parseProjectLayerManifest(readFileSync6(resolveProjectLayerManifestPath(basePath), "utf-8"));
+    return parseProjectLayerManifest(readFileSync7(resolveProjectLayerManifestPath(basePath), "utf-8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -966,12 +1131,12 @@ var readProjectLayerManifest = (basePath) => {
 };
 var writeProjectLayerManifest = (basePath, manifest) => {
   const manifestPath = resolveProjectLayerManifestPath(basePath);
-  mkdirSync4(dirname6(manifestPath), { recursive: true });
-  writeFileSync4(manifestPath, serializeProjectLayerManifest(manifest), "utf-8");
+  mkdirSync5(dirname7(manifestPath), { recursive: true });
+  writeFileSync5(manifestPath, serializeProjectLayerManifest(manifest), "utf-8");
 };
 var readProjectLayerContextIndex = (basePath) => {
   try {
-    return parseProjectLayerContextIndex(readFileSync6(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
+    return parseProjectLayerContextIndex(readFileSync7(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -981,8 +1146,8 @@ var readProjectLayerContextIndex = (basePath) => {
 };
 var writeProjectLayerContextIndex = (basePath, contextIndex) => {
   const contextIndexPath = resolveProjectLayerContextIndexPath(basePath);
-  mkdirSync4(dirname6(contextIndexPath), { recursive: true });
-  writeFileSync4(contextIndexPath, serializeProjectLayerContextIndex(contextIndex), "utf-8");
+  mkdirSync5(dirname7(contextIndexPath), { recursive: true });
+  writeFileSync5(contextIndexPath, serializeProjectLayerContextIndex(contextIndex), "utf-8");
 };
 var installManagedFiles = (basePath, specs, meta) => {
   const written = [];
@@ -991,24 +1156,24 @@ var installManagedFiles = (basePath, specs, meta) => {
     const absolutePath = resolveProjectLayerFilePath(basePath, spec.path);
     const wrappedContent = wrapWithSection(spec.content, meta);
     if (!existsSync(absolutePath)) {
-      mkdirSync4(dirname6(absolutePath), { recursive: true });
-      writeFileSync4(absolutePath, wrappedContent + "\n", "utf-8");
+      mkdirSync5(dirname7(absolutePath), { recursive: true });
+      writeFileSync5(absolutePath, wrappedContent + "\n", "utf-8");
       written.push(spec.path);
       continue;
     }
-    const existing = readFileSync6(absolutePath, "utf-8");
+    const existing = readFileSync7(absolutePath, "utf-8");
     if (hasAiOpsSection(existing)) {
-      writeFileSync4(absolutePath, replaceAiOpsSection(existing, wrappedContent), "utf-8");
+      writeFileSync5(absolutePath, replaceAiOpsSection(existing, wrappedContent), "utf-8");
       const stripped = stripAiOpsSection(existing);
       (stripped.trim().length > 0 ? appended : written).push(spec.path);
       continue;
     }
     if (hasLegacyHeader(existing)) {
-      writeFileSync4(absolutePath, wrappedContent + "\n", "utf-8");
+      writeFileSync5(absolutePath, wrappedContent + "\n", "utf-8");
       written.push(spec.path);
       continue;
     }
-    writeFileSync4(absolutePath, existing.trimEnd() + "\n\n" + wrappedContent + "\n", "utf-8");
+    writeFileSync5(absolutePath, existing.trimEnd() + "\n\n" + wrappedContent + "\n", "utf-8");
     appended.push(spec.path);
   }
   return { written, appended };
@@ -1023,8 +1188,8 @@ var installProjectFiles = (params) => {
     const absolutePath = resolveProjectLayerFilePath(params.basePath, spec.path);
     const previous = previousByPath.get(spec.path);
     if (!existsSync(absolutePath)) {
-      mkdirSync4(dirname6(absolutePath), { recursive: true });
-      writeFileSync4(absolutePath, spec.content + "\n", "utf-8");
+      mkdirSync5(dirname7(absolutePath), { recursive: true });
+      writeFileSync5(absolutePath, spec.content + "\n", "utf-8");
       created.push(spec.path);
       records.push({
         path: spec.path,
@@ -1033,11 +1198,11 @@ var installProjectFiles = (params) => {
       });
       continue;
     }
-    const existingContent = readFileSync6(absolutePath, "utf-8").trimEnd();
+    const existingContent = readFileSync7(absolutePath, "utf-8").trimEnd();
     const existingHash = computeHash([existingContent]);
     if (previous?.created === true && existingHash === previous.templateHash) {
       if (existingHash !== spec.contentHash) {
-        writeFileSync4(absolutePath, spec.content + "\n", "utf-8");
+        writeFileSync5(absolutePath, spec.content + "\n", "utf-8");
         refreshed.push(spec.path);
       } else {
         preserved.push(spec.path);
@@ -1060,7 +1225,7 @@ var installProjectFiles = (params) => {
 };
 var buildContextIndexFromDisk = (params) => {
   const documents = params.documentPaths.map(
-    (path) => parseProjectLayerDocument(path, readFileSync6(resolveProjectLayerFilePath(params.basePath, path), "utf-8"))
+    (path) => parseProjectLayerDocument(path, readFileSync7(resolveProjectLayerFilePath(params.basePath, path), "utf-8"))
   );
   return ProjectLayerContextIndexSchema.parse({
     schemaVersion: 1,
@@ -1069,14 +1234,14 @@ var buildContextIndexFromDisk = (params) => {
     generatedAt: params.generatedAt
   });
 };
-var computeProjectFileHash = (basePath, relativePath) => computeHash([readFileSync6(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
+var computeProjectFileHash = (basePath, relativePath) => computeHash([readFileSync7(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
 var collectDocumentPathsFromManifest = (manifest) => [
   ...manifest.managed_files.map((file) => file.path),
   ...manifest.project_files.map((file) => file.path),
   ...manifest.packs.flatMap((pack) => pack.documents.map((file) => file.path))
 ].sort();
 var buildDocsStatusRowsFromDisk = (params) => params.documentPaths.map((path) => {
-  const document = parseProjectLayerDocument(path, readFileSync6(resolveProjectLayerFilePath(params.basePath, path), "utf-8"));
+  const document = parseProjectLayerDocument(path, readFileSync7(resolveProjectLayerFilePath(params.basePath, path), "utf-8"));
   return `| ${document.path} | ${document.status} | ${document.owner} |`;
 });
 var replaceDocsStatusRows = (content, rows) => {
@@ -1092,8 +1257,8 @@ var updateDocsStatusTable = (basePath, documentPaths) => {
   const absolutePath = resolveProjectLayerFilePath(basePath, docsStatusPath);
   const beforeHash = computeProjectFileHash(basePath, docsStatusPath);
   const rows = buildDocsStatusRowsFromDisk({ basePath, documentPaths });
-  const nextContent = replaceDocsStatusRows(readFileSync6(absolutePath, "utf-8"), rows);
-  writeFileSync4(absolutePath, nextContent, "utf-8");
+  const nextContent = replaceDocsStatusRows(readFileSync7(absolutePath, "utf-8"), rows);
+  writeFileSync5(absolutePath, nextContent, "utf-8");
   return {
     beforeHash,
     afterHash: computeProjectFileHash(basePath, docsStatusPath)
@@ -1248,7 +1413,7 @@ var readDocumentSafely = (basePath, path) => {
     if (!existsSync(absolutePath)) {
       return issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${path}`);
     }
-    return parseProjectLayerDocument(path, readFileSync6(absolutePath, "utf-8"));
+    return parseProjectLayerDocument(path, readFileSync7(absolutePath, "utf-8"));
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown error";
     return issue("error", "invalid-frontmatter", `${path} frontmatter \uD30C\uC2F1 \uC2E4\uD328: ${reason}`);
@@ -1343,7 +1508,7 @@ var diffProjectLayer = (basePath) => {
       issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       continue;
     }
-    const content = readFileSync6(absolutePath, "utf-8");
+    const content = readFileSync7(absolutePath, "utf-8");
     const meta = parseAiOpsMeta(content);
     if (!meta) {
       issues.push(issue("error", "missing-managed-section", `managed section \uBA54\uD0C0 \uC5C6\uC74C: ${file.path}`));
@@ -1405,7 +1570,7 @@ var auditProjectLayer = (basePath) => {
   }
   let docsStatusEntries = [];
   try {
-    docsStatusEntries = parseDocsStatusEntries(readFileSync6(docsStatusPath, "utf-8"));
+    docsStatusEntries = parseDocsStatusEntries(readFileSync7(docsStatusPath, "utf-8"));
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown error";
     issues.push(issue("error", "invalid-docs-status", `docs/docs-status.md \uD30C\uC2F1 \uC2E4\uD328: ${reason}`));
@@ -1435,16 +1600,16 @@ function removeManagedProjectFile(basePath, relativePath) {
   if (!existsSync(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [relativePath] };
   }
-  const content = readFileSync6(absolutePath, "utf-8");
+  const content = readFileSync7(absolutePath, "utf-8");
   if (!hasAiOpsSection(content)) {
     return { deleted: [], cleaned: [], preserved: [relativePath], notFound: [] };
   }
   const stripped = stripAiOpsSection(content);
   if (stripped.trim().length === 0) {
-    rmSync(absolutePath);
+    rmSync2(absolutePath);
     return { deleted: [relativePath], cleaned: [], preserved: [], notFound: [] };
   }
-  writeFileSync4(absolutePath, stripped, "utf-8");
+  writeFileSync5(absolutePath, stripped, "utf-8");
   return { deleted: [], cleaned: [relativePath], preserved: [], notFound: [] };
 }
 var removeCreateOnlyProjectFile = (basePath, file) => {
@@ -1452,10 +1617,10 @@ var removeCreateOnlyProjectFile = (basePath, file) => {
   if (!existsSync(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
   }
-  const content = readFileSync6(absolutePath, "utf-8").trimEnd();
+  const content = readFileSync7(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: [] };
@@ -1465,9 +1630,9 @@ var removePackOwnedFile = (basePath, file) => {
   if (!existsSync(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
   }
-  const currentHash = computeHash([readFileSync6(absolutePath, "utf-8").trimEnd()]);
+  const currentHash = computeHash([readFileSync7(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 +1652,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 +1666,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 +1674,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 mkdirSync6, readFileSync as readFileSync8, readdirSync as readdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join12, relative as relative2, resolve as resolve6 } from "path";
 var PACK_REGISTRY_FILENAME = "pack-registry.json";
 var SPEC_LIFECYCLE_PACK_ID = "spec-lifecycle";
 var PACK_INSTALL_ROOT = "docs/specs/";
@@ -1518,9 +1683,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 = join12(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(readFileSync8(join12(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 +1694,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 ? join12(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 ? join12(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         walk(nextRelativePath);
         continue;
       }
       assertPackInstallPath(nextRelativePath);
-      const content = readFileSync7(join11(packDir, nextRelativePath), "utf-8");
+      const content = readFileSync8(join12(packDir, nextRelativePath), "utf-8");
       files.push({
         path: nextRelativePath,
         content,
@@ -1596,11 +1761,11 @@ var resolvePackById = (packsDir, packId) => {
   return pack;
 };
 var serializePackFileContent = (content) => content.length === 0 ? "" : content.trimEnd() + "\n";
-var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync7(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
+var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync8(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
 var writePackFile = (basePath, file) => {
   const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
-  mkdirSync5(dirname7(absolutePath), { recursive: true });
-  writeFileSync5(absolutePath, serializePackFileContent(file.content), "utf-8");
+  mkdirSync6(dirname8(absolutePath), { recursive: true });
+  writeFileSync6(absolutePath, serializePackFileContent(file.content), "utf-8");
 };
 var buildPackFileRecords = (files) => files.map((file) => ({
   path: file.path,
@@ -1659,7 +1824,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 +1843,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);
@@ -1687,7 +1852,7 @@ var removePackFiles = (basePath, record) => {
   return { written: [], refreshed: [], preserved, deleted, notFound };
 };
 var removeEmptyDirs2 = (basePath, relativePaths) => {
-  const dirs = [...new Set(relativePaths.map((path) => dirname7(path)).filter((dir) => dir !== "."))].sort(
+  const dirs = [...new Set(relativePaths.map((path) => dirname8(path)).filter((dir) => dir !== "."))].sort(
     (a, b) => b.length - a.length
   );
   for (const dir of dirs) {
@@ -1697,7 +1862,7 @@ var removeEmptyDirs2 = (basePath, relativePaths) => {
     }
     try {
       if (readdirSync4(absoluteDir).length === 0) {
-        rmSync2(absoluteDir, { recursive: true });
+        rmSync3(absoluteDir, { recursive: true });
       }
     } catch {
     }
@@ -1817,14 +1982,233 @@ var diffProjectLayerPack = (params) => {
 };
 
 // src/core/uninstall-plan.ts
-import { join as join12 } from "path";
+import { join as join13 } from "path";
 
 // src/core/context-promotion.ts
 import { createHash as createHash2 } from "crypto";
 import { execFileSync } from "child_process";
-import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, join as join13, resolve as resolve7 } from "path";
-import { z as z12 } from "zod";
+import { existsSync as existsSync3, mkdirSync as mkdirSync7, readFileSync as readFileSync9, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname9, join as join14, resolve as resolve7 } from "path";
+import { z as z15 } from "zod";
+
+// src/core/tool-use-hook.ts
+import { z as z14 } from "zod";
+var HookToolInputSchema = z14.object({
+  command: z14.string().optional()
+}).passthrough();
+var ToolUseHookInputSchema = z14.object({
+  hook_event_name: z14.string(),
+  cwd: z14.string(),
+  tool_name: z14.string().optional(),
+  tool_input: z14.unknown().optional(),
+  tool_response: z14.unknown().optional()
+}).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 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"
@@ -1834,30 +2218,30 @@ var CONTEXT_PROMOTION_SCOPE = {
   PROJECT_LOCAL: "project-local",
   GLOBAL: "global"
 };
-var ContextPromotionDecisionSchema = z12.union([
-  z12.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
-  z12.literal(CONTEXT_PROMOTION_DECISION.NO_PROMOTION)
+var ContextPromotionDecisionSchema = z15.union([
+  z15.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
+  z15.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 ContextPromotionScopeSchema = z15.union([
+  z15.literal(CONTEXT_PROMOTION_SCOPE.CORE),
+  z15.literal(CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL),
+  z15.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(),
+var ContextPromotionReceiptSchema = z15.object({
+  fingerprint: z15.string().regex(/^[a-f0-9]{16}$/),
+  commitHash: z15.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)
+  scopes: z15.array(ContextPromotionScopeSchema),
+  targets: z15.array(z15.string().min(1)),
+  summary: z15.string().min(1),
+  resolvedAt: z15.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)
+var ContextPromotionReceiptIndexSchema = z15.object({
+  schemaVersion: z15.literal(1),
+  kind: z15.literal("context-promotion-receipts"),
+  projectKey: z15.string().regex(/^[a-f0-9]{12}$/),
+  projectRoot: z15.string().min(1),
+  receipts: z15.array(ContextPromotionReceiptSchema)
 }).strict();
 var RECEIPT_INDEX_FILENAME = "receipts-index.json";
 var DEFAULT_PRUNE_MAX = 50;
@@ -1887,13 +2271,13 @@ var readUntrackedFingerprintParts = (gitRoot) => {
   const raw = runGit(gitRoot, ["ls-files", "--others", "--exclude-standard", "-z"]);
   const paths = raw.split("\0").filter((path) => path.length > 0).sort((a, b) => a.localeCompare(b));
   return paths.map((relativePath) => {
-    const absolutePath = join13(gitRoot, relativePath);
+    const absolutePath = join14(gitRoot, relativePath);
     try {
       const stat = statSync(absolutePath);
       if (!stat.isFile()) {
         return `${relativePath}:non-file`;
       }
-      const content = readFileSync8(absolutePath);
+      const content = readFileSync9(absolutePath);
       return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
     } catch {
       throw new Error(`Unable to read untracked path for context promotion fingerprint: ${relativePath}`);
@@ -1907,7 +2291,7 @@ var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
   return [
     `raw:${rawDiff}`,
     ...paths.map((relativePath) => {
-      const absolutePath = join13(gitRoot, relativePath);
+      const absolutePath = join14(gitRoot, relativePath);
       if (!existsSync3(absolutePath)) {
         return `${relativePath}:deleted`;
       }
@@ -1915,7 +2299,7 @@ var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
       if (!stat.isFile()) {
         return `${relativePath}:non-file`;
       }
-      const content = readFileSync8(absolutePath);
+      const content = readFileSync9(absolutePath);
       return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
     })
   ];
@@ -1933,26 +2317,19 @@ var computeContextPromotionFingerprint = (gitRoot) => hashHex(
   ],
   16
 );
-var resolveContextPromotionReceiptIndexPath = (params) => join13(
-  params.userBasePath,
-  ".ai-ops",
-  "context-promotion",
-  "projects",
-  params.projectKey,
-  RECEIPT_INDEX_FILENAME
-);
+var resolveContextPromotionReceiptIndexPath = (params) => join14(params.userBasePath, ".ai-ops", "context-promotion", "projects", params.projectKey, RECEIPT_INDEX_FILENAME);
 var parseContextPromotionReceiptIndex = (json) => ContextPromotionReceiptIndexSchema.parse(JSON.parse(json));
 var serializeContextPromotionReceiptIndex = (index) => JSON.stringify(index, null, 2) + "\n";
 var readContextPromotionReceiptIndex = (indexPath) => {
   try {
-    return parseContextPromotionReceiptIndex(readFileSync8(indexPath, "utf-8"));
+    return parseContextPromotionReceiptIndex(readFileSync9(indexPath, "utf-8"));
   } catch {
     return null;
   }
 };
 var writeContextPromotionReceiptIndex = (indexPath, index) => {
-  mkdirSync6(dirname8(indexPath), { recursive: true });
-  writeFileSync6(indexPath, serializeContextPromotionReceiptIndex(index), "utf-8");
+  mkdirSync7(dirname9(indexPath), { recursive: true });
+  writeFileSync7(indexPath, serializeContextPromotionReceiptIndex(index), "utf-8");
 };
 var buildEmptyReceiptIndex = (params) => ({
   schemaVersion: 1,
@@ -2000,7 +2377,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(join14(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
 var getContextPromotionStatus = (params) => {
   const cwd = resolve7(params.cwd);
   const gitRoot = resolveContextPromotionGitRoot(cwd);
@@ -2087,143 +2464,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,115 +2519,396 @@ 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 readFileSync10, readdirSync as readdirSync5 } from "fs";
+import { join as join15, 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;
 };
-var booleanField = (record, keys) => {
-  for (const key of keys) {
-    const value = record[key];
-    if (typeof value === "boolean") {
-      return value;
+var readTextFileOrNull = (filePath) => {
+  try {
+    return readFileSync10(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 = join15(contextRoot, "workspaces");
+  if (!existsSync4(workspacesDir)) {
+    return [];
+  }
+  return readdirSync5(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join15(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync4(statePath)).sort((a, b) => a.localeCompare(b));
+};
+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 = join15(params.workspaceDir, "repos");
+  if (!existsSync4(reposDir)) {
+    return null;
+  }
+  const entries = readdirSync5(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join15(reposDir, entry.name))).filter((entry) => entry !== null).filter((entry) => {
+    const 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 null;
+  return [...new Set(ids.filter((id) => /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id)))];
 };
-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 parseLastConfirmedCommitHash = (params) => {
+  const section = extractSection(params.content, ["\uB9C8\uC9C0\uB9C9 \uD655\uC778 Commit", "Last Confirmed Commit"]);
+  if (section.length === 0) {
+    return null;
   }
-  if (!isJsonRecord(toolResponse)) {
-    return false;
+  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 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"
+    };
   }
-  const success = booleanField(toolResponse, ["success", "ok"]);
-  if (success === false) {
-    return true;
+  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 exitCode = numberField(toolResponse, ["exit_code", "exitCode", "status", "code"]);
-  if (exitCode !== null && exitCode !== 0) {
-    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"
+    };
   }
-  return recordStringFieldsIndicateGitCommitFailure(toolResponse);
+  const activeWorkstreamPath = join15(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"
+    };
+  }
+  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 mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10, join as join16 } 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(readFileSync11(filePath, "utf-8"));
   if (!isJsonRecord2(parsed)) {
     throw new Error("hooks.json must contain a JSON object");
   }
   return parsed;
 };
 var writeJsonRecord = (filePath, value) => {
-  mkdirSync7(dirname9(filePath), { recursive: true });
-  writeFileSync7(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+  mkdirSync8(dirname10(filePath), { recursive: true });
+  writeFileSync8(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
 };
 var getOrCreateRecord = (record, key) => {
   const existing = record[key];
@@ -2402,34 +2923,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 +2959,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 +2983,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) => join16(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 +3013,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 +3023,7 @@ var installContextPromotionHook = (params) => {
         type: "command",
         command: params.command,
         timeout: 30,
-        statusMessage: "Checking context promotion review"
+        statusMessage: params.definition.statusMessage
       }
     ]
   };
@@ -2506,32 +3035,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 join17 } from "path";
+var resolveSkillsDir = () => join17(COMPILER_DATA_DIR, "skills");
+var resolveSubagentsDir = () => join17(COMPILER_DATA_DIR, "subagents");
+var resolvePacksDir = () => join17(COMPILER_DATA_DIR, "packs");
+var resolveIntegrationsDir = () => join17(COMPILER_DATA_DIR, "integrations");
 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 +3315,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,19 +3349,19 @@ 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 mkdirSync9, rmSync as rmSync4, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname11, 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);
-      mkdirSync8(dirname10(absPath), { recursive: true });
-      writeFileSync8(absPath, file.content + "\n", "utf-8");
+      const absPath = resolve9(basePath, file.relativePath);
+      mkdirSync9(dirname11(absPath), { recursive: true });
+      writeFileSync9(absPath, file.content + "\n", "utf-8");
     }
     writtenRoots.push(skillPackage.rootDir);
   }
@@ -2831,9 +3370,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 +3398,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 +3550,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 mkdirSync10, rmSync as rmSync6, writeFileSync as writeFileSync10 } from "fs";
+import { dirname as dirname12, 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,11 +3569,11 @@ 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");
+      mkdirSync10(dirname12(absPath), { recursive: true });
+      writeFileSync10(absPath, file.content.trimEnd() + "\n", "utf-8");
       written.push(file.relativePath);
     }
   }
@@ -3044,8 +3583,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 +3634,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 +3645,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 +3956,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 +4063,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 join18 } from "path";
 var CONTEXT_PROMOTION_REVIEW_SKILL_ID = "context-promotion-review";
 var resolveCodexHomePath = () => {
   const codexHome = process.env.CODEX_HOME;
@@ -3563,7 +4102,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(join18(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
 };
 var ensureContextPromotionReviewSkill = (basePath) => {
   const skill = resolveContextPromotionReviewSkill();
@@ -3577,7 +4116,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(join18(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
   if (alreadyInstalled) {
     return { changed: false, installedSkill };
   }
@@ -3638,9 +4177,389 @@ 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 join19 } 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(join19(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(join19(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("0.1.0");
+program.name("ai-ops").description("AI agent operating layer manager").version(getCliVersion());
 program.command("init").description("project operating layer \uCD08\uAE30 \uC124\uCE58").option("--tool <tool...>", "\uB300\uC0C1 \uB3C4\uAD6C adapter \uC9C0\uC815 (codex|gemini|claude-code)").action((opts) => initCommand(opts));
 program.command("update").description("project operating layer \uAC31\uC2E0").option("--force", "\uBCC0\uACBD \uC5C6\uC5B4\uB3C4 \uAC15\uC81C \uC7AC\uC124\uCE58", false).action((opts) => updateCommand(opts));
 program.command("diff").description("project operating layer drift \uBE44\uAD50").action(() => diffCommand());
@@ -3683,5 +4602,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