ai-ops-cli 1.0.3 → 1.1.0

package/dist/bin/index.js

@@ -1819,11 +1819,714 @@ var diffProjectLayerPack = (params) => {
 // src/core/uninstall-plan.ts
 import { join as join12 } from "path";
 
+// src/core/context-promotion.ts
+import { createHash as createHash2 } from "crypto";
+import { execFileSync } from "child_process";
+import { existsSync as existsSync3, mkdirSync as mkdirSync6, readFileSync as readFileSync8, statSync, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, join as join13, resolve as resolve7 } from "path";
+import { z as z12 } from "zod";
+var CONTEXT_PROMOTION_DECISION = {
+  PROMOTED: "promoted",
+  NO_PROMOTION: "no-promotion"
+};
+var CONTEXT_PROMOTION_SCOPE = {
+  CORE: "core",
+  PROJECT_LOCAL: "project-local",
+  GLOBAL: "global"
+};
+var ContextPromotionDecisionSchema = z12.union([
+  z12.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
+  z12.literal(CONTEXT_PROMOTION_DECISION.NO_PROMOTION)
+]);
+var ContextPromotionScopeSchema = z12.union([
+  z12.literal(CONTEXT_PROMOTION_SCOPE.CORE),
+  z12.literal(CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL),
+  z12.literal(CONTEXT_PROMOTION_SCOPE.GLOBAL)
+]);
+var ContextPromotionReceiptSchema = z12.object({
+  fingerprint: z12.string().regex(/^[a-f0-9]{16}$/),
+  commitHash: z12.string().regex(/^(NO_HEAD|[a-f0-9]{40})$/).optional(),
+  decision: ContextPromotionDecisionSchema,
+  scopes: z12.array(ContextPromotionScopeSchema),
+  targets: z12.array(z12.string().min(1)),
+  summary: z12.string().min(1),
+  resolvedAt: z12.string().min(1)
+}).strict();
+var ContextPromotionReceiptIndexSchema = z12.object({
+  schemaVersion: z12.literal(1),
+  kind: z12.literal("context-promotion-receipts"),
+  projectKey: z12.string().regex(/^[a-f0-9]{12}$/),
+  projectRoot: z12.string().min(1),
+  receipts: z12.array(ContextPromotionReceiptSchema)
+}).strict();
+var RECEIPT_INDEX_FILENAME = "receipts-index.json";
+var DEFAULT_PRUNE_MAX = 50;
+var hashHex = (parts, length) => createHash2("sha256").update(parts.join("\0")).digest("hex").slice(0, length);
+var buildContextPromotionProjectKey = (gitRoot) => hashHex([resolve7(gitRoot)], 12);
+var runGit = (cwd, args) => execFileSync("git", [...args], {
+  cwd,
+  encoding: "utf-8",
+  maxBuffer: 20 * 1024 * 1024,
+  stdio: ["ignore", "pipe", "ignore"]
+});
+var resolveContextPromotionGitRoot = (cwd) => {
+  try {
+    return runGit(cwd, ["rev-parse", "--show-toplevel"]).trim();
+  } catch {
+    return null;
+  }
+};
+var readGitHead = (gitRoot) => {
+  try {
+    return runGit(gitRoot, ["rev-parse", "--verify", "HEAD"]).trim();
+  } catch {
+    return "NO_HEAD";
+  }
+};
+var readUntrackedFingerprintParts = (gitRoot) => {
+  const raw = runGit(gitRoot, ["ls-files", "--others", "--exclude-standard", "-z"]);
+  const paths = raw.split("\0").filter((path) => path.length > 0).sort((a, b) => a.localeCompare(b));
+  return paths.map((relativePath) => {
+    const absolutePath = join13(gitRoot, relativePath);
+    try {
+      const stat = statSync(absolutePath);
+      if (!stat.isFile()) {
+        return `${relativePath}:non-file`;
+      }
+      const content = readFileSync8(absolutePath);
+      return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
+    } catch {
+      throw new Error(`Unable to read untracked path for context promotion fingerprint: ${relativePath}`);
+    }
+  });
+};
+var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
+  const rawDiff = runGit(gitRoot, ["diff", "--raw", "-z"]);
+  const rawNames = runGit(gitRoot, ["diff", "--name-only", "-z"]);
+  const paths = rawNames.split("\0").filter((path) => path.length > 0).sort((a, b) => a.localeCompare(b));
+  return [
+    `raw:${rawDiff}`,
+    ...paths.map((relativePath) => {
+      const absolutePath = join13(gitRoot, relativePath);
+      if (!existsSync3(absolutePath)) {
+        return `${relativePath}:deleted`;
+      }
+      const stat = statSync(absolutePath);
+      if (!stat.isFile()) {
+        return `${relativePath}:non-file`;
+      }
+      const content = readFileSync8(absolutePath);
+      return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
+    })
+  ];
+};
+var readGitIndexFingerprintParts = (gitRoot) => [
+  `index:${runGit(gitRoot, ["ls-files", "-s", "-z"])}`,
+  `staged-raw:${runGit(gitRoot, ["diff", "--cached", "--raw", "-z"])}`
+];
+var computeContextPromotionFingerprint = (gitRoot) => hashHex(
+  [
+    `head:${readGitHead(gitRoot)}`,
+    ...readGitIndexFingerprintParts(gitRoot),
+    ...readTrackedWorkingTreeFingerprintParts(gitRoot).map((part) => `tracked-working-tree:${part}`),
+    ...readUntrackedFingerprintParts(gitRoot).map((part) => `untracked:${part}`)
+  ],
+  16
+);
+var resolveContextPromotionReceiptIndexPath = (params) => join13(
+  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"));
+  } catch {
+    return null;
+  }
+};
+var writeContextPromotionReceiptIndex = (indexPath, index) => {
+  mkdirSync6(dirname8(indexPath), { recursive: true });
+  writeFileSync6(indexPath, serializeContextPromotionReceiptIndex(index), "utf-8");
+};
+var buildEmptyReceiptIndex = (params) => ({
+  schemaVersion: 1,
+  kind: "context-promotion-receipts",
+  projectKey: params.projectKey,
+  projectRoot: params.projectRoot,
+  receipts: []
+});
+var sortReceiptsByResolvedAtDesc = (receipts) => [...receipts].sort((a, b) => b.resolvedAt.localeCompare(a.resolvedAt));
+var findContextPromotionReceipt = (params) => {
+  const receipts = params.index?.receipts ?? [];
+  return receipts.find((receipt) => receipt.commitHash === params.commitHash) ?? receipts.find((receipt) => receipt.fingerprint === params.fingerprint) ?? null;
+};
+var upsertContextPromotionReceipt = (params) => {
+  const previous = readContextPromotionReceiptIndex(params.indexPath);
+  const index = previous?.projectKey === params.projectKey ? previous : buildEmptyReceiptIndex({ projectKey: params.projectKey, projectRoot: params.projectRoot });
+  const remaining = index.receipts.filter((receipt) => {
+    if (receipt.fingerprint === params.receipt.fingerprint) {
+      return false;
+    }
+    if (params.receipt.commitHash && receipt.commitHash === params.receipt.commitHash) {
+      return false;
+    }
+    return true;
+  });
+  const maxReceipts = params.maxReceipts ?? DEFAULT_PRUNE_MAX;
+  const receipts = sortReceiptsByResolvedAtDesc([params.receipt, ...remaining]).slice(0, maxReceipts);
+  const nextIndex = {
+    ...index,
+    projectRoot: params.projectRoot,
+    receipts
+  };
+  writeContextPromotionReceiptIndex(params.indexPath, nextIndex);
+  return nextIndex;
+};
+var pruneContextPromotionReceipts = (params) => {
+  const index = readContextPromotionReceiptIndex(params.indexPath);
+  if (!index) {
+    return null;
+  }
+  const nextIndex = {
+    ...index,
+    receipts: sortReceiptsByResolvedAtDesc(index.receipts).slice(0, params.maxReceipts)
+  };
+  writeContextPromotionReceiptIndex(params.indexPath, nextIndex);
+  return nextIndex;
+};
+var hasContextPromotionLayer = (gitRoot) => existsSync3(join13(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
+var getContextPromotionStatus = (params) => {
+  const cwd = resolve7(params.cwd);
+  const gitRoot = resolveContextPromotionGitRoot(cwd);
+  if (!gitRoot) {
+    return {
+      cwd,
+      gitRoot: null,
+      hasContextLayer: false,
+      projectKey: null,
+      commitHash: null,
+      fingerprint: null,
+      receipt: null,
+      receiptIndexPath: null
+    };
+  }
+  const hasContextLayer = hasContextPromotionLayer(gitRoot);
+  const projectKey = buildContextPromotionProjectKey(gitRoot);
+  const commitHash = readGitHead(gitRoot);
+  const receiptIndexPath = resolveContextPromotionReceiptIndexPath({
+    userBasePath: params.userBasePath,
+    projectKey
+  });
+  if (!hasContextLayer) {
+    return {
+      cwd,
+      gitRoot,
+      hasContextLayer,
+      projectKey,
+      commitHash,
+      fingerprint: null,
+      receipt: null,
+      receiptIndexPath
+    };
+  }
+  const fingerprint = computeContextPromotionFingerprint(gitRoot);
+  const index = readContextPromotionReceiptIndex(receiptIndexPath);
+  return {
+    cwd,
+    gitRoot,
+    hasContextLayer,
+    projectKey,
+    commitHash,
+    fingerprint,
+    receipt: findContextPromotionReceipt({ index, fingerprint, commitHash }),
+    receiptIndexPath
+  };
+};
+var buildContextPromotionReceipt = (params) => {
+  const summary = params.input.summary.trim();
+  if (summary.length === 0) {
+    throw new Error("summary is required");
+  }
+  if (params.input.decision === CONTEXT_PROMOTION_DECISION.PROMOTED && params.input.scopes.length === 0) {
+    throw new Error("at least one scope is required for promoted decisions");
+  }
+  return ContextPromotionReceiptSchema.parse({
+    fingerprint: params.fingerprint,
+    commitHash: params.commitHash,
+    decision: params.input.decision,
+    scopes: [...params.input.scopes],
+    targets: [...params.input.targets],
+    summary,
+    resolvedAt: params.resolvedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+  });
+};
+var resolveContextPromotion = (params) => {
+  const status = getContextPromotionStatus({ cwd: params.cwd, userBasePath: params.userBasePath });
+  if (!status.gitRoot || !status.projectKey || !status.commitHash || !status.fingerprint || !status.receiptIndexPath) {
+    throw new Error("git repository is required for context promotion receipts");
+  }
+  if (!status.hasContextLayer) {
+    throw new Error("ai-ops context layer is required for context promotion receipts");
+  }
+  const receipt = buildContextPromotionReceipt({
+    fingerprint: status.fingerprint,
+    commitHash: status.commitHash,
+    input: params.input
+  });
+  upsertContextPromotionReceipt({
+    indexPath: status.receiptIndexPath,
+    projectKey: status.projectKey,
+    projectRoot: status.gitRoot,
+    receipt
+  });
+  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)}`;
+  return [
+    "Context Promotion Review should run for the completed work commit.",
+    "",
+    `Project root: ${projectRoot}`,
+    "This project root is authoritative for this review.",
+    "",
+    "Use the `context-promotion-review` skill to review the just-created HEAD commit for reusable operating knowledge.",
+    "",
+    "Scope boundary:",
+    `- Before inspecting files, anchor shell work in the project root above. If needed, run \`${cdCommand}\` first.`,
+    "- Do not inspect other repositories, parent directories, or earlier conversation workspaces.",
+    "- Do not search the web or external documentation for this review.",
+    "- If `AGENTS.md`, `docs/agent/*`, `docs/docs-status.md`, or other context-layer files are absent, report them as absent; do not substitute files from another repo.",
+    "- Use only the just-created `HEAD` commit, this conversation, and files under the project root.",
+    "",
+    "Review requirements:",
+    "- Do not amend, rewrite, or mix changes into the work commit.",
+    "- Inspect the completed commit before deciding: run `git show --stat HEAD`, `git show --name-only HEAD`, and `git show HEAD` when detail is needed.",
+    "- Cross-check existing `AGENTS.md`, `docs/agent/*`, `docs/docs-status.md`, and `.ai-ops/context-layer.json` first.",
+    "- Classify candidates as `core`, `project-local`, `global`, `already-covered`, or `no-promotion`.",
+    "- Ask the user before editing any file.",
+    "- If promotion is approved, edit only the approved context/global files, then stop for user inspection without committing.",
+    '- After approved updates or a no-promotion/already-covered decision, run `ai-ops context-promotion resolve --decision <promoted|no-promotion> --summary "<summary>"` with any approved `--scope` and `--target` values.',
+    "- Re-run `ai-ops context-promotion status` and confirm a receipt exists for the current HEAD.",
+    "",
+    `Project: ${projectRoot}`,
+    `HEAD: ${status.commitHash ?? "unknown"}`,
+    `Fingerprint: ${status.fingerprint ?? "unknown"}`
+  ].join("\n");
+};
+var buildContextPromotionStatusFailurePrompt = (cwd, error) => {
+  const message = error instanceof Error ? error.message : "unknown error";
+  return [
+    "Context Promotion Review could not inspect the completed work commit.",
+    "",
+    "The work command has already finished; do not amend or rewrite it for this hook.",
+    "Do not search the web or inspect another repository to repair this hook review.",
+    "",
+    "Run `ai-ops context-promotion status` to inspect the failure, then decide whether a manual promotion review is needed.",
+    "",
+    `Project cwd: ${cwd}`,
+    `Error: ${message}`
+  ].join("\n");
+};
+var buildPostToolUseOutput = (prompt) => ({
+  decision: "block",
+  reason: prompt,
+  hookSpecificOutput: {
+    hookEventName: "PostToolUse",
+    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") {
+      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 evaluateContextPromotionPostToolUseHook = (params) => {
+  const hookInput = ToolUseHookInputSchema.safeParse(params.hookInput);
+  if (!hookInput.success) {
+    return null;
+  }
+  if (hookInput.data.hook_event_name !== "PostToolUse" || hookInput.data.tool_name !== "Bash") {
+    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)) {
+    return null;
+  }
+  let status;
+  try {
+    status = getContextPromotionStatus({
+      cwd: hookInput.data.cwd,
+      userBasePath: params.userBasePath
+    });
+  } catch (error) {
+    return buildPostToolUseOutput(buildContextPromotionStatusFailurePrompt(hookInput.data.cwd, error));
+  }
+  if (!status.hasContextLayer || status.receipt) {
+    return null;
+  }
+  return buildPostToolUseOutput(buildContextPromotionReviewPrompt(status));
+};
+
+// 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";
+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 PRE_TOOL_USE_EVENT = "PreToolUse";
+var POST_TOOL_USE_EVENT = "PostToolUse";
+var BASH_MATCHER = "^Bash$";
+var isJsonRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJsonRecord = (filePath) => {
+  if (!existsSync4(filePath)) {
+    return {};
+  }
+  const parsed = JSON.parse(readFileSync9(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");
+};
+var getOrCreateRecord = (record, key) => {
+  const existing = record[key];
+  if (isJsonRecord2(existing)) {
+    return existing;
+  }
+  const next = {};
+  record[key] = next;
+  return next;
+};
+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 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) => {
+  if (!isJsonRecord2(group)) {
+    return count;
+  }
+  return count + getArray(group, "hooks").filter(handlerMatchesContextPromotion).length;
+}, 0);
+var configHasContextPromotionHook = (config) => {
+  const hooks = config.hooks;
+  if (!isJsonRecord2(hooks)) {
+    return false;
+  }
+  return getArray(hooks, POST_TOOL_USE_EVENT).some(groupHasContextPromotionHook);
+};
+var configHasOnlyCurrentContextPromotionHook = (config, command) => {
+  const hooks = config.hooks;
+  if (!isJsonRecord2(hooks)) {
+    return false;
+  }
+  const hasLegacy = getArray(hooks, PRE_TOOL_USE_EVENT).some(groupHasContextPromotionHook);
+  const postGroups = getArray(hooks, POST_TOOL_USE_EVENT);
+  const hasCurrent = postGroups.some((group) => groupHasCurrentContextPromotionHook(group, command));
+  return hasCurrent && !hasLegacy && countContextPromotionHandlers(postGroups) === 1;
+};
+var removeContextPromotionHooksFromEvent = (hooks, eventName) => {
+  const previousGroups = getArray(hooks, eventName);
+  let removed = false;
+  const nextGroups = previousGroups.map((group) => {
+    if (!isJsonRecord2(group)) {
+      return group;
+    }
+    const previousHandlers = getArray(group, "hooks");
+    const nextHandlers = previousHandlers.filter((handler) => {
+      const matches = handlerMatchesContextPromotion(handler);
+      if (matches) {
+        removed = true;
+      }
+      return !matches;
+    });
+    if (nextHandlers.length === 0) {
+      return null;
+    }
+    return {
+      ...group,
+      hooks: nextHandlers
+    };
+  }).filter((group) => group !== null);
+  if (!removed) {
+    return false;
+  }
+  if (nextGroups.length > 0) {
+    hooks[eventName] = nextGroups;
+  } else {
+    delete 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}`);
+  }
+  return command;
+};
+var inspectContextPromotionHook = (hooksPath) => ({
+  hooksPath,
+  installed: configHasContextPromotionHook(readJsonRecord(hooksPath))
+});
+var installContextPromotionHook = (params) => {
+  const config = readJsonRecord(params.hooksPath);
+  if (configHasOnlyCurrentContextPromotionHook(config, params.command)) {
+    return {
+      hooksPath: params.hooksPath,
+      installed: true,
+      changed: false
+    };
+  }
+  const hooks = getOrCreateRecord(config, "hooks");
+  removeContextPromotionHooksFromEvent(hooks, PRE_TOOL_USE_EVENT);
+  removeContextPromotionHooksFromEvent(hooks, POST_TOOL_USE_EVENT);
+  const existingGroups = getArray(hooks, POST_TOOL_USE_EVENT);
+  const nextGroup = {
+    matcher: BASH_MATCHER,
+    hooks: [
+      {
+        type: "command",
+        command: params.command,
+        timeout: 30,
+        statusMessage: "Checking context promotion review"
+      }
+    ]
+  };
+  hooks[POST_TOOL_USE_EVENT] = [...existingGroups, nextGroup];
+  writeJsonRecord(params.hooksPath, config);
+  return {
+    hooksPath: params.hooksPath,
+    installed: true,
+    changed: true
+  };
+};
+var uninstallContextPromotionHook = (hooksPath) => {
+  const config = readJsonRecord(hooksPath);
+  const hooks = config.hooks;
+  if (!isJsonRecord2(hooks)) {
+    return { hooksPath, removed: false, changed: false };
+  }
+  const removedLegacy = removeContextPromotionHooksFromEvent(hooks, PRE_TOOL_USE_EVENT);
+  const removedCurrent = removeContextPromotionHooksFromEvent(hooks, POST_TOOL_USE_EVENT);
+  const removed = removedLegacy || removedCurrent;
+  if (!removed) {
+    return { hooksPath, removed: false, changed: false };
+  }
+  writeJsonRecord(hooksPath, config);
+  return { hooksPath, removed: true, changed: true };
+};
+
 // src/lib/paths.ts
-import { join as join13 } from "path";
-var resolveSkillsDir = () => join13(COMPILER_DATA_DIR, "skills");
-var resolveSubagentsDir = () => join13(COMPILER_DATA_DIR, "subagents");
-var resolvePacksDir = () => join13(COMPILER_DATA_DIR, "packs");
+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");
 var resolveBasePath = () => process.cwd();
 var resolveUserBasePath = () => {
   const userBasePath = process.env.AI_OPS_HOME ?? process.env.HOME;
@@ -2107,19 +2810,19 @@ var findInstalledSkill = (installedSkills, skillId) => {
 };
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname8, resolve as resolve7 } from "path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync8, rmSync as rmSync3, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10, resolve as resolve8 } from "path";
 var installSkillPackages = (basePath, packages) => {
   const writtenRoots = [];
   for (const skillPackage of packages) {
-    const absRoot = resolve7(basePath, skillPackage.rootDir);
-    if (existsSync3(absRoot)) {
+    const absRoot = resolve8(basePath, skillPackage.rootDir);
+    if (existsSync5(absRoot)) {
       rmSync3(absRoot, { recursive: true, force: true });
     }
     for (const file of skillPackage.files) {
-      const absPath = resolve7(basePath, file.relativePath);
-      mkdirSync6(dirname8(absPath), { recursive: true });
-      writeFileSync6(absPath, file.content + "\n", "utf-8");
+      const absPath = resolve8(basePath, file.relativePath);
+      mkdirSync8(dirname10(absPath), { recursive: true });
+      writeFileSync8(absPath, file.content + "\n", "utf-8");
     }
     writtenRoots.push(skillPackage.rootDir);
   }
@@ -2128,8 +2831,8 @@ var installSkillPackages = (basePath, packages) => {
 var removeDirectories = (basePath, relativeDirs) => {
   const removed = [];
   for (const relativeDir of relativeDirs) {
-    const absPath = resolve7(basePath, relativeDir);
-    if (!existsSync3(absPath)) continue;
+    const absPath = resolve8(basePath, relativeDir);
+    if (!existsSync5(absPath)) continue;
     rmSync3(absPath, { recursive: true, force: true });
     removed.push(relativeDir);
   }
@@ -2308,14 +3011,14 @@ var skillUninstallCommand = async (skillId) => {
 
 // src/commands/subagent.ts
 import * as p8 from "@clack/prompts";
-import { existsSync as existsSync5, rmSync as rmSync6 } from "fs";
+import { existsSync as existsSync7, rmSync as rmSync6 } from "fs";
 
 // src/lib/subagent-install.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync7, rmSync as rmSync5, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname9, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve8 } from "path";
+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";
 var resolveInsideBasePath = (basePath, relativePath) => {
-  const absBasePath = resolve8(basePath);
-  const absPath = resolve8(absBasePath, relativePath);
+  const absBasePath = resolve9(basePath);
+  const absPath = resolve9(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}`);
@@ -2327,11 +3030,11 @@ var installSubagentPackages = (basePath, packages) => {
   for (const subagentPackage of packages) {
     for (const file of subagentPackage.files) {
       const absPath = resolveInsideBasePath(basePath, file.relativePath);
-      if (existsSync4(absPath)) {
+      if (existsSync6(absPath)) {
         rmSync5(absPath, { recursive: true, force: true });
       }
-      mkdirSync7(dirname9(absPath), { recursive: true });
-      writeFileSync7(absPath, file.content.trimEnd() + "\n", "utf-8");
+      mkdirSync9(dirname11(absPath), { recursive: true });
+      writeFileSync9(absPath, file.content.trimEnd() + "\n", "utf-8");
       written.push(file.relativePath);
     }
   }
@@ -2341,7 +3044,7 @@ var removeSubagentFiles = (basePath, relativePaths) => {
   const removed = [];
   for (const relativePath of relativePaths) {
     const absPath = resolveInsideBasePath(basePath, relativePath);
-    if (!existsSync4(absPath)) continue;
+    if (!existsSync6(absPath)) continue;
     rmSync5(absPath, { recursive: true, force: true });
     removed.push(relativePath);
   }
@@ -2403,7 +3106,7 @@ var writeUserSubagentState = (params) => {
 };
 var readInstalledSubagents = (basePath) => readSubagentManifest(resolveSubagentManifestPath(basePath))?.subagents ?? [];
 var warnMissingSkills = (requiredSkills) => {
-  const missing = requiredSkills.filter((skill) => !existsSync5(skill.path));
+  const missing = requiredSkills.filter((skill) => !existsSync7(skill.path));
   if (missing.length === 0) {
     return;
   }
@@ -2676,6 +3379,265 @@ ${result.preserved.map((file) => `  ${file}`).join("\n")}`);
   p9.outro("ai-ops pack uninstall \uC644\uB8CC");
 };
 
+// src/commands/context-promotion.ts
+import * as p10 from "@clack/prompts";
+var VALID_DECISIONS = [
+  CONTEXT_PROMOTION_DECISION.PROMOTED,
+  CONTEXT_PROMOTION_DECISION.NO_PROMOTION
+];
+var VALID_SCOPES = [
+  CONTEXT_PROMOTION_SCOPE.CORE,
+  CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL,
+  CONTEXT_PROMOTION_SCOPE.GLOBAL
+];
+var parseDecision = (decision) => {
+  const parsed = VALID_DECISIONS.find((candidate) => candidate === decision);
+  if (parsed) {
+    return parsed;
+  }
+  throw new Error(`decision must be one of: ${VALID_DECISIONS.join(", ")}`);
+};
+var parseScopes = (scopes) => {
+  const requestedScopes = scopes ?? [];
+  return requestedScopes.map((scope) => {
+    const parsed = VALID_SCOPES.find((candidate) => candidate === scope);
+    if (!parsed) {
+      throw new Error(`scope must be one of: ${VALID_SCOPES.join(", ")}`);
+    }
+    return parsed;
+  });
+};
+var parseMax = (max) => {
+  if (max === void 0) {
+    return 50;
+  }
+  const parsed = Number.parseInt(max, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    throw new Error("max must be a positive integer");
+  }
+  return parsed;
+};
+var readStdin = async () => new Promise((resolve10, reject) => {
+  let raw = "";
+  process.stdin.setEncoding("utf-8");
+  process.stdin.on("data", (chunk) => {
+    raw += chunk;
+  });
+  process.stdin.on("end", () => resolve10(raw));
+  process.stdin.on("error", reject);
+});
+var reportContextPromotionError = (error) => {
+  const message = error instanceof Error ? error.message : "unknown error";
+  p10.log.error(message);
+  process.exitCode = 1;
+};
+var contextPromotionStatusCommand = async (opts) => {
+  try {
+    const status = getContextPromotionStatus({
+      cwd: resolveBasePath(),
+      userBasePath: resolveUserBasePath()
+    });
+    if (opts.json) {
+      process.stdout.write(JSON.stringify(status, null, 2) + "\n");
+      return;
+    }
+    p10.intro("ai-ops context-promotion status");
+    p10.log.info(
+      [
+        `git root: ${status.gitRoot ?? "not found"}`,
+        `context layer: ${status.hasContextLayer ? "found" : "not found"}`,
+        `HEAD: ${status.commitHash ?? "not available"}`,
+        `fingerprint: ${status.fingerprint ?? "not available"}`,
+        `receipt: ${status.receipt ? "found" : "missing"}`,
+        `receipt store: ${status.receiptIndexPath ?? "not available"}`
+      ].join("\n")
+    );
+    p10.outro("ai-ops context-promotion status \uC644\uB8CC");
+  } catch (error) {
+    reportContextPromotionError(error);
+  }
+};
+var contextPromotionResolveCommand = async (opts) => {
+  p10.intro("ai-ops context-promotion resolve");
+  try {
+    const nextStatus = resolveContextPromotion({
+      cwd: resolveBasePath(),
+      userBasePath: resolveUserBasePath(),
+      input: {
+        decision: parseDecision(opts.decision),
+        summary: opts.summary ?? "",
+        scopes: parseScopes(opts.scope),
+        targets: opts.target ?? []
+      }
+    });
+    p10.log.success(`receipt \uAE30\uB85D \uC644\uB8CC: ${nextStatus.commitHash ?? nextStatus.fingerprint ?? "unknown"}`);
+  } catch (error) {
+    reportContextPromotionError(error);
+  }
+  p10.outro("ai-ops context-promotion resolve \uC644\uB8CC");
+};
+var contextPromotionPruneCommand = async (opts) => {
+  p10.intro("ai-ops context-promotion prune");
+  try {
+    const status = getContextPromotionStatus({
+      cwd: resolveBasePath(),
+      userBasePath: resolveUserBasePath()
+    });
+    if (!status.receiptIndexPath) {
+      p10.log.warn("prune\uD560 receipt store\uB97C \uCC3E\uC9C0 \uBABB\uD588\uC2B5\uB2C8\uB2E4.");
+      p10.outro("ai-ops context-promotion prune \uC644\uB8CC");
+      return;
+    }
+    const maxReceipts = parseMax(opts.max);
+    const before = readContextPromotionReceiptIndex(status.receiptIndexPath)?.receipts.length ?? 0;
+    const next = pruneContextPromotionReceipts({ indexPath: status.receiptIndexPath, maxReceipts });
+    const after = next?.receipts.length ?? 0;
+    p10.log.success(`receipt prune \uC644\uB8CC: ${before} -> ${after}`);
+  } catch (error) {
+    reportContextPromotionError(error);
+  }
+  p10.outro("ai-ops context-promotion prune \uC644\uB8CC");
+};
+var contextPromotionPreToolUseHookCommand = async () => {
+  await readStdin();
+};
+var contextPromotionPostToolUseHookCommand = async () => {
+  try {
+    const raw = await readStdin();
+    const hookInput = raw.trim().length > 0 ? JSON.parse(raw) : {};
+    const output = evaluateContextPromotionPostToolUseHook({
+      hookInput,
+      userBasePath: resolveUserBasePath()
+    });
+    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 context promotion hook skipped: ${message}`
+      }) + "\n"
+    );
+  }
+};
+
+// src/commands/codex-hook.ts
+import * as p11 from "@clack/prompts";
+import { existsSync as existsSync8 } from "fs";
+import { join as join16 } from "path";
+var CONTEXT_PROMOTION_REVIEW_SKILL_ID = "context-promotion-review";
+var resolveCodexHomePath = () => {
+  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 assertContextPromotionHookId = (hookId) => {
+  if (hookId !== CONTEXT_PROMOTION_HOOK_ID) {
+    throw new Error(`Unknown Codex hook: ${hookId}`);
+  }
+};
+var reportCodexHookError = (error) => {
+  const message = error instanceof Error ? error.message : "unknown error";
+  p11.log.error(message);
+  process.exitCode = 1;
+};
+var readInstalledSkills2 = (basePath) => (readSkillRegistry(resolveSkillRegistryPath(basePath))?.skills ?? []).map((installedSkill) => ({
+  ...installedSkill,
+  id: resolveCanonicalSkillId(installedSkill.id)
+}));
+var resolveContextPromotionReviewSkill = () => {
+  const skill = loadAllSkills(resolveSkillsDir()).find(
+    (candidate) => candidate.id === CONTEXT_PROMOTION_REVIEW_SKILL_ID
+  );
+  if (!skill) {
+    throw new Error(`Unknown skill: ${CONTEXT_PROMOTION_REVIEW_SKILL_ID}`);
+  }
+  return skill;
+};
+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"));
+};
+var ensureContextPromotionReviewSkill = (basePath) => {
+  const skill = resolveContextPromotionReviewSkill();
+  const installedSkills = readInstalledSkills2(basePath);
+  const existingInstalledSkill = findInstalledSkill(installedSkills, skill.id);
+  const requestedTools = mergeSkillTools({
+    existing: existingInstalledSkill?.tools,
+    requested: [SKILL_TOOL.CODEX]
+  });
+  const { packages, installedSkill } = buildSkillInstallPlan({
+    skill,
+    requestedTools
+  });
+  const alreadyInstalled = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync8(join16(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
+  if (alreadyInstalled) {
+    return { changed: false, installedSkill };
+  }
+  installSkillPackages(basePath, packages);
+  writeSkillRegistry(resolveSkillRegistryPath(basePath), {
+    skills: upsertInstalledSkill(installedSkills, installedSkill),
+    cliVersion: getCliVersion(),
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  return { changed: true, installedSkill };
+};
+var codexHookInstallCommand = async (hookId, opts = {}) => {
+  p11.intro(`ai-ops codex-hook install ${hookId}`);
+  try {
+    assertContextPromotionHookId(hookId);
+    const skillResult = ensureContextPromotionReviewSkill(resolveUserBasePath());
+    const hooksPath = resolveCodexHooksPath(resolveCodexHomePath());
+    const result = installContextPromotionHook({
+      hooksPath,
+      command: buildContextPromotionHookCommand(opts.command)
+    });
+    p11.log.success(
+      skillResult.changed ? `skill \uC124\uCE58 \uC644\uB8CC: ${skillResult.installedSkill.id}` : `skill \uC774\uBBF8 \uC124\uCE58\uB428: ${skillResult.installedSkill.id}`
+    );
+    p11.log.success(result.changed ? `hook \uC124\uCE58 \uC644\uB8CC: ${result.hooksPath}` : `hook \uC774\uBBF8 \uC124\uCE58\uB428: ${result.hooksPath}`);
+  } catch (error) {
+    reportCodexHookError(error);
+  }
+  p11.outro("ai-ops codex-hook install \uC644\uB8CC");
+};
+var codexHookStatusCommand = async (hookId) => {
+  p11.intro(`ai-ops codex-hook status ${hookId}`);
+  try {
+    assertContextPromotionHookId(hookId);
+    const result = inspectContextPromotionHook(resolveCodexHooksPath(resolveCodexHomePath()));
+    const skillInstalled = hasInstalledContextPromotionReviewSkill(resolveUserBasePath());
+    p11.log.info(
+      [
+        `hooks file: ${result.hooksPath}`,
+        `hook installed: ${result.installed ? "yes" : "no"}`,
+        `skill installed: ${skillInstalled ? "yes" : "no"}`
+      ].join("\n")
+    );
+  } catch (error) {
+    reportCodexHookError(error);
+  }
+  p11.outro("ai-ops codex-hook status \uC644\uB8CC");
+};
+var codexHookUninstallCommand = async (hookId) => {
+  p11.intro(`ai-ops codex-hook uninstall ${hookId}`);
+  try {
+    assertContextPromotionHookId(hookId);
+    const result = uninstallContextPromotionHook(resolveCodexHooksPath(resolveCodexHomePath()));
+    p11.log.success(result.removed ? `hook \uC81C\uAC70 \uC644\uB8CC: ${result.hooksPath}` : `\uC124\uCE58\uB41C hook \uC5C6\uC74C: ${result.hooksPath}`);
+  } catch (error) {
+    reportCodexHookError(error);
+  }
+  p11.outro("ai-ops codex-hook uninstall \uC644\uB8CC");
+};
+
 // src/bin/index.ts
 var program = new Command();
 program.name("ai-ops").description("AI agent operating layer manager").version("0.1.0");
@@ -2708,5 +3670,18 @@ packCommand.command("install <packId>").description("pack \uC124\uCE58").action(
 packCommand.command("diff [packId]").description("pack \uBCC0\uACBD \uBE44\uAD50").action((packId) => packDiffCommand(packId));
 packCommand.command("update [packId]").description("pack \uAC31\uC2E0").action((packId) => packUpdateCommand(packId));
 packCommand.command("uninstall <packId>").description("pack \uC81C\uAC70").action((packId) => packUninstallCommand(packId));
+var contextPromotionCommand = program.command("context-promotion").description("context promotion review receipt \uAD00\uB9AC");
+contextPromotionCommand.command("status").description("\uD604\uC7AC context promotion receipt \uC0C1\uD0DC \uD655\uC778").option("--json", "JSON\uC73C\uB85C \uCD9C\uB825", false).action((opts) => contextPromotionStatusCommand(opts));
+contextPromotionCommand.command("resolve").description("\uD604\uC7AC HEAD \uCEE4\uBC0B\uC5D0 \uB300\uD55C context promotion review receipt \uAE30\uB85D").requiredOption("--decision <decision>", "promoted|no-promotion").requiredOption("--summary <summary>", "review \uACB0\uC815 \uC694\uC57D").option("--scope <scope...>", "\uC2B9\uACA9 scope (core|project-local|global)").option("--target <path...>", "\uC2B9\uACA9 \uB300\uC0C1 \uD30C\uC77C \uB610\uB294 \uC790\uC0B0").action(
+  (opts) => contextPromotionResolveCommand(opts)
+);
+contextPromotionCommand.command("prune").description("user-local context promotion receipts \uC815\uB9AC").option("--max <number>", "\uC720\uC9C0\uD560 receipt \uC218", "50").action((opts) => contextPromotionPruneCommand(opts));
+var contextPromotionHookCommand = contextPromotionCommand.command("hook").description("Codex hook \uB0B4\uBD80 \uBA85\uB839");
+contextPromotionHookCommand.command("pre-tool-use").description("Deprecated no-op Codex PreToolUse hook entrypoint").action(() => contextPromotionPreToolUseHookCommand());
+contextPromotionHookCommand.command("post-tool-use").description("Codex PostToolUse hook entrypoint").action(() => contextPromotionPostToolUseHookCommand());
+var codexHookCommand = program.command("codex-hook").description("Codex hooks \uC124\uC815 \uAD00\uB9AC");
+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));
 program.parse();
 //# sourceMappingURL=index.js.map