ai-ops-cli 1.3.1 → 1.4.0

package/dist/bin/index.js

@@ -363,6 +363,156 @@ var PackCatalogSchema = z10.object({
   packs: z10.array(PackCatalogEntrySchema)
 }).strict();
 
+// src/core/schemas/studio-snapshot.schema.ts
+import { z as z11 } from "zod";
+var nullableString = z11.string().nullable();
+var StudioProjectStateSchema = z11.union([
+  z11.literal("ready"),
+  z11.literal("uninitialized"),
+  z11.literal("degraded")
+]);
+var StudioProjectDocumentProvenanceSchema = z11.union([
+  z11.literal("ai-ops-managed"),
+  z11.literal("project-owned"),
+  z11.literal("pack-document"),
+  z11.literal("context-only")
+]);
+var StudioRuntimeFileStateSchema = z11.object({
+  path: z11.string().min(1),
+  exists: z11.boolean()
+}).strict();
+var StudioSourceStateSchema = z11.object({
+  path: z11.string().min(1),
+  exists: z11.boolean(),
+  parsed: z11.boolean(),
+  generatedAt: nullableString,
+  error: nullableString
+}).strict();
+var StudioProjectIssueSourceSchema = z11.union([
+  z11.literal("manifest"),
+  z11.literal("context-layer"),
+  z11.literal("docs-status"),
+  z11.literal("frontmatter"),
+  z11.literal("managed-section"),
+  z11.literal("file-system"),
+  z11.literal("source-hash"),
+  z11.literal("unknown")
+]);
+var StudioProjectIssueSchema = z11.object({
+  level: z11.union([z11.literal("error"), z11.literal("warning")]),
+  code: z11.string().min(1),
+  message: z11.string().min(1),
+  source: StudioProjectIssueSourceSchema,
+  affectedPath: nullableString,
+  suggestedActionLabel: nullableString
+}).strict();
+var StudioProjectDocumentSchema = z11.object({
+  path: z11.string().min(1),
+  status: ProjectLayerDocumentStatusSchema,
+  layer: z11.string().min(1),
+  owner: z11.string().min(1),
+  read_when: z11.array(z11.string().min(1)),
+  update_when: z11.array(z11.string().min(1)),
+  indexedContentHash: z11.string().min(1),
+  currentContentHash: nullableString,
+  contentHashMatches: z11.boolean().nullable(),
+  provenance: StudioProjectDocumentProvenanceSchema,
+  content: nullableString,
+  trustWarning: nullableString,
+  readError: nullableString
+}).strict();
+var StudioProjectSnapshotSchema = z11.object({
+  root: z11.string().min(1),
+  state: StudioProjectStateSchema,
+  files: z11.object({
+    manifest: StudioSourceStateSchema,
+    contextIndex: StudioSourceStateSchema,
+    docsStatus: StudioSourceStateSchema
+  }).strict(),
+  audit: z11.object({
+    currentSourceHash: nullableString,
+    hasErrors: z11.boolean(),
+    hasWarnings: z11.boolean(),
+    issues: z11.array(StudioProjectIssueSchema)
+  }).strict(),
+  documents: z11.array(StudioProjectDocumentSchema)
+}).strict();
+var StudioIntegrationComponentStatusSchema = z11.object({
+  type: z11.union([
+    z11.literal(INTEGRATION_COMPONENT_TYPE.SKILL),
+    z11.literal(INTEGRATION_COMPONENT_TYPE.CODEX_HOOK),
+    z11.literal(INTEGRATION_COMPONENT_TYPE.RECEIPT_CONFIG)
+  ]),
+  id: z11.string().min(1),
+  installed: z11.boolean(),
+  owned: z11.boolean().nullable(),
+  catalog: IntegrationCatalogComponentSchema,
+  installedComponent: IntegrationComponentSchema.nullable()
+}).strict();
+var StudioIntegrationSnapshotSchema = z11.object({
+  id: IntegrationIdSchema,
+  description: z11.string().min(1),
+  installed: z11.boolean(),
+  installedAt: nullableString,
+  updatedAt: nullableString,
+  components: z11.array(StudioIntegrationComponentStatusSchema)
+}).strict();
+var StudioInstalledPathStateSchema = z11.object({
+  path: z11.string().min(1),
+  exists: z11.boolean()
+}).strict();
+var StudioSkillSnapshotSchema = z11.object({
+  id: z11.string().min(1),
+  kind: SkillKindSchema,
+  description: z11.string().min(1),
+  supported_tools: z11.array(SkillToolSchema),
+  groups: z11.array(z11.string().min(1)),
+  installed: z11.boolean(),
+  installedTools: z11.array(SkillToolSchema),
+  installedPaths: z11.array(StudioInstalledPathStateSchema),
+  sourceHash: nullableString
+}).strict();
+var StudioSubagentSnapshotSchema = z11.object({
+  id: SubagentIdSchema,
+  description: z11.string().min(1),
+  supported_tools: z11.array(SkillToolSchema),
+  installed: z11.boolean(),
+  installedTools: z11.array(SkillToolSchema),
+  installedPaths: z11.array(StudioInstalledPathStateSchema),
+  sourceHash: nullableString
+}).strict();
+var StudioHookSnapshotSchema = z11.object({
+  id: z11.string().min(1),
+  statusMessage: z11.string().min(1),
+  hooksPath: nullableString,
+  installed: z11.boolean(),
+  error: nullableString
+}).strict();
+var StudioRuntimeSnapshotSchema = z11.object({
+  available: z11.boolean(),
+  unavailableReason: nullableString,
+  userBasePath: nullableString,
+  codexHomePath: nullableString,
+  manifests: z11.object({
+    integrations: StudioSourceStateSchema,
+    skills: StudioSourceStateSchema,
+    subagents: StudioSourceStateSchema,
+    hooks: StudioSourceStateSchema
+  }).strict(),
+  integrations: z11.array(StudioIntegrationSnapshotSchema),
+  skills: z11.array(StudioSkillSnapshotSchema),
+  subagents: z11.array(StudioSubagentSnapshotSchema),
+  hooks: z11.array(StudioHookSnapshotSchema)
+}).strict();
+var StudioSnapshotSchema = z11.object({
+  schemaVersion: z11.literal(1),
+  kind: z11.literal("ai-ops-studio-snapshot"),
+  generatedAt: z11.string().datetime({ offset: true }),
+  cliVersion: z11.string().min(1),
+  project: StudioProjectSnapshotSchema,
+  runtime: StudioRuntimeSnapshotSchema
+}).strict();
+
 // src/core/loader.ts
 import { readFileSync, readdirSync } from "fs";
 import { join as join2, resolve } from "path";
@@ -1576,24 +1726,914 @@ var removeEmptyDirs = (basePath, relativePaths) => {
     }
   }
 };
-var uninstallProjectLayer = (basePath, manifest) => {
-  const managedResults = manifest.managed_files.map((file) => removeManagedProjectFile(basePath, file.path));
-  const projectResults = manifest.project_files.map((file) => removeCreateOnlyProjectFile(basePath, file));
-  const packResults = manifest.packs.flatMap(
-    (pack) => [...pack.documents, ...pack.files].map((file) => removePackOwnedFile(basePath, file))
-  );
-  const stateFiles = [PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH, PROJECT_LAYER_MANIFEST_RELATIVE_PATH];
-  for (const stateFile of stateFiles) {
-    rmSync2(resolveProjectLayerFilePath(basePath, stateFile), { force: true });
+var uninstallProjectLayer = (basePath, manifest) => {
+  const managedResults = manifest.managed_files.map((file) => removeManagedProjectFile(basePath, file.path));
+  const projectResults = manifest.project_files.map((file) => removeCreateOnlyProjectFile(basePath, file));
+  const packResults = manifest.packs.flatMap(
+    (pack) => [...pack.documents, ...pack.files].map((file) => removePackOwnedFile(basePath, file))
+  );
+  const stateFiles = [PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH, PROJECT_LAYER_MANIFEST_RELATIVE_PATH];
+  for (const stateFile of stateFiles) {
+    rmSync2(resolveProjectLayerFilePath(basePath, stateFile), { force: true });
+  }
+  const result = mergeRemoveResults([...managedResults, ...projectResults, ...packResults]);
+  removeEmptyDirs(basePath, [...result.deleted, ...stateFiles]);
+  return result;
+};
+
+// src/core/studio-snapshot.ts
+import { existsSync as existsSync3, readFileSync as readFileSync8 } from "fs";
+import { join as join10, resolve as resolve6 } from "path";
+import { z as z12 } from "zod";
+
+// src/core/codex-hook.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5 } from "fs";
+import { dirname as dirname7, join as join9 } 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 isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readJsonRecord = (filePath) => {
+  if (!existsSync2(filePath)) {
+    return {};
+  }
+  const parsed = JSON.parse(readFileSync7(filePath, "utf-8"));
+  if (!isJsonRecord(parsed)) {
+    throw new Error("hooks.json must contain a JSON object");
+  }
+  return parsed;
+};
+var writeJsonRecord = (filePath, value) => {
+  mkdirSync5(dirname7(filePath), { recursive: true });
+  writeFileSync5(filePath, JSON.stringify(value, null, 2) + "\n", "utf-8");
+};
+var getOrCreateRecord = (record, key) => {
+  const existing = record[key];
+  if (isJsonRecord(existing)) {
+    return existing;
+  }
+  const next = {};
+  record[key] = next;
+  return next;
+};
+var getArray = (record, key) => {
+  const existing = record[key];
+  return Array.isArray(existing) ? existing : [];
+};
+var handlerMatchesDefinition = (definition) => (handler) => isJsonRecord(handler) && typeof handler.command === "string" && [definition.commandMarker, ...definition.legacyCommandMarkers].some((marker) => handler.command.includes(marker));
+var handlerMatchesCommand = (handler, command) => isJsonRecord(handler) && handler.command === command;
+var groupHasDefinitionHook = (definition) => (group) => isJsonRecord(group) && getArray(group, "hooks").some(handlerMatchesDefinition(definition));
+var groupHasCurrentDefinitionHook = (group, command) => isJsonRecord(group) && getArray(group, "hooks").some((handler) => handlerMatchesCommand(handler, command));
+var countDefinitionHandlers = (groups, definition) => groups.reduce((count, group) => {
+  if (!isJsonRecord(group)) {
+    return count;
+  }
+  return count + getArray(group, "hooks").filter(handlerMatchesDefinition(definition)).length;
+}, 0);
+var configHasDefinitionHook = (config, definition) => {
+  const hooks = config.hooks;
+  if (!isJsonRecord(hooks)) {
+    return false;
+  }
+  return getArray(hooks, POST_TOOL_USE_EVENT).some(groupHasDefinitionHook(definition));
+};
+var configHasOnlyCurrentDefinitionHook = (config, definition, command) => {
+  const hooks = config.hooks;
+  if (!isJsonRecord(hooks)) {
+    return false;
+  }
+  const hasLegacy = getArray(hooks, PRE_TOOL_USE_EVENT).some(groupHasDefinitionHook(definition));
+  const postGroups = getArray(hooks, POST_TOOL_USE_EVENT);
+  const hasCurrent = postGroups.some((group) => groupHasCurrentDefinitionHook(group, command));
+  return hasCurrent && !hasLegacy && countDefinitionHandlers(postGroups, definition) === 1;
+};
+var removeDefinitionHooksFromEvent = (hooks, eventName, definition) => {
+  const previousGroups = getArray(hooks, eventName);
+  let removed = false;
+  const nextGroups = previousGroups.map((group) => {
+    if (!isJsonRecord(group)) {
+      return group;
+    }
+    const previousHandlers = getArray(group, "hooks");
+    const nextHandlers = previousHandlers.filter((handler) => {
+      const matches = handlerMatchesDefinition(definition)(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) => join9(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: inspectCodexHook({ hooksPath, definition: CONTEXT_PROMOTION_CODEX_HOOK }).installed
+});
+var installCodexHook = (params) => {
+  const config = readJsonRecord(params.hooksPath);
+  if (configHasOnlyCurrentDefinitionHook(config, params.definition, params.command)) {
+    return {
+      hooksPath: params.hooksPath,
+      installed: true,
+      changed: false
+    };
+  }
+  const hooks = getOrCreateRecord(config, "hooks");
+  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,
+    hooks: [
+      {
+        type: "command",
+        command: params.command,
+        timeout: 30,
+        statusMessage: params.definition.statusMessage
+      }
+    ]
+  };
+  hooks[POST_TOOL_USE_EVENT] = [...existingGroups, nextGroup];
+  writeJsonRecord(params.hooksPath, config);
+  return {
+    hooksPath: params.hooksPath,
+    installed: true,
+    changed: true
+  };
+};
+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 (!isJsonRecord(hooks)) {
+    return { hooksPath: params.hooksPath, removed: false, changed: false };
+  }
+  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: params.hooksPath, removed: false, changed: false };
+  }
+  writeJsonRecord(params.hooksPath, config);
+  return { hooksPath: params.hooksPath, removed: true, changed: true };
+};
+var uninstallContextPromotionHook = (hooksPath) => uninstallCodexHook({
+  hooksPath,
+  definition: CONTEXT_PROMOTION_CODEX_HOOK
+});
+
+// src/core/studio-snapshot.ts
+var INTEGRATIONS_DATA_DIR = join10(COMPILER_DATA_DIR, "integrations");
+var SKILLS_DATA_DIR = join10(COMPILER_DATA_DIR, "skills");
+var SUBAGENTS_DATA_DIR = join10(COMPILER_DATA_DIR, "subagents");
+var DOCS_STATUS_RELATIVE_PATH = "docs/docs-status.md";
+var INTEGRATIONS_MANIFEST_FALLBACK_PATH = ".ai-ops/integrations-manifest.json";
+var SKILLS_MANIFEST_FALLBACK_PATH = ".ai-ops/skills-manifest.json";
+var SUBAGENTS_MANIFEST_FALLBACK_PATH = ".ai-ops/subagents-manifest.json";
+var HOOKS_FALLBACK_PATH = ".codex/hooks.json";
+var KNOWN_CODEX_HOOK_DEFINITIONS = [CONTEXT_PROMOTION_CODEX_HOOK, PC_CODEX_HOOK];
+var AUDIT_ISSUE_SOURCES_BY_CODE = {
+  "missing-manifest": "manifest",
+  "invalid-manifest": "manifest",
+  "manifest-missing-managed-file": "manifest",
+  "missing-context-index": "context-layer",
+  "invalid-context-index": "context-layer",
+  "context-missing-document": "context-layer",
+  "context-document-mismatch": "context-layer",
+  "context-extra-document": "context-layer",
+  "missing-docs-status": "docs-status",
+  "invalid-docs-status": "docs-status",
+  "docs-status-missing-document": "docs-status",
+  "docs-status-mismatch": "docs-status",
+  "docs-status-extra-document": "docs-status",
+  "missing-file": "file-system",
+  "invalid-frontmatter": "frontmatter",
+  "missing-managed-section": "managed-section",
+  "source-hash-drift": "source-hash",
+  "managed-source-hash-drift": "source-hash"
+};
+var AUDIT_ISSUE_ACTION_LABELS_BY_SOURCE = {
+  manifest: "Review manifest record",
+  "context-layer": "Review context index",
+  "docs-status": "Review docs status",
+  frontmatter: "Review frontmatter",
+  "managed-section": "Review managed section",
+  "file-system": "Review missing file",
+  "source-hash": "Review source hash",
+  unknown: null
+};
+var RecoverableContextDocumentSchema = z12.object({
+  status: ProjectLayerDocumentStatusSchema,
+  layer: z12.string().min(1),
+  owner: z12.string().min(1),
+  read_when: z12.array(z12.string().min(1)),
+  update_when: z12.array(z12.string().min(1)),
+  path: z12.string().min(1),
+  contentHash: z12.string().min(1)
+});
+var RecoverableContextIndexSchema = z12.object({
+  schemaVersion: z12.literal(1),
+  kind: z12.literal("context-layer-index"),
+  documents: z12.array(z12.unknown()),
+  generatedAt: z12.string().min(1)
+});
+var getErrorMessage = (error) => error instanceof Error ? error.message : "unknown error";
+var resolveDefaultUserBasePath = () => process.env.AI_OPS_HOME ?? process.env.HOME ?? null;
+var resolveDefaultCodexHomePath = () => {
+  if (process.env.CODEX_HOME && process.env.CODEX_HOME.length > 0) {
+    return process.env.CODEX_HOME;
+  }
+  if (process.env.HOME && process.env.HOME.length > 0) {
+    return join10(process.env.HOME, ".codex");
+  }
+  return null;
+};
+var buildSourceState = (params) => ({
+  path: params.path,
+  exists: params.exists,
+  parsed: params.parsed,
+  generatedAt: params.generatedAt ?? null,
+  error: params.error ?? null
+});
+var createMissingSourceState = (path) => buildSourceState({ path, exists: false, parsed: false });
+var createUnavailableSourceState = (params) => buildSourceState({
+  path: params.path,
+  exists: false,
+  parsed: false,
+  error: params.reason
+});
+var hasErrors = (issues) => issues.some((issue2) => issue2.level === "error");
+var hasWarnings = (issues) => issues.some((issue2) => issue2.level === "warning");
+var getTrustWarning = (status) => {
+  if (status === "Reserved") {
+    return "Reserved document is not current decision-making evidence.";
+  }
+  if (status === "Draft") {
+    return "Draft document requires review before use as decision-making evidence.";
+  }
+  if (status === "Archived") {
+    return "Archived document is historical record and should not guide current operation.";
+  }
+  return null;
+};
+var uniqueStrings = (values) => [...new Set(values.filter((value) => value.length > 0))];
+var getManifestDocumentPaths = (manifest) => manifest === null ? [] : [
+  ...manifest.managed_files.map((file) => file.path),
+  ...manifest.project_files.map((file) => file.path),
+  ...manifest.packs.flatMap((pack) => pack.documents.map((file) => file.path)),
+  ...manifest.packs.flatMap((pack) => pack.files.map((file) => file.path))
+];
+var buildKnownAuditPaths = (params) => uniqueStrings([
+  PROJECT_LAYER_MANIFEST_RELATIVE_PATH,
+  PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH,
+  DOCS_STATUS_RELATIVE_PATH,
+  ...getManifestDocumentPaths(params.manifest),
+  ...params.contextIndex?.documents.map((document) => document.path) ?? [],
+  ...params.documents.map((document) => document.path)
+]).sort((left, right) => right.length - left.length || left.localeCompare(right));
+var findKnownPathInMessage = (message, knownPaths) => knownPaths.find((path) => message.includes(path)) ?? null;
+var parsePathLikeToken = (value) => {
+  const trimmed = value.trim().replace(/[.,;)]$/, "");
+  if (trimmed.length === 0) {
+    return null;
+  }
+  try {
+    resolveProjectLayerFilePath("/", trimmed);
+    return trimmed;
+  } catch {
+    return null;
+  }
+};
+var extractTrailingIssuePath = (message) => {
+  const trailingSegment = message.split(":").at(-1);
+  if (trailingSegment === void 0) {
+    return null;
+  }
+  const [firstToken] = trailingSegment.trim().split(/\s+/);
+  return firstToken === void 0 ? null : parsePathLikeToken(firstToken);
+};
+var resolveIssueSource = (issue2) => AUDIT_ISSUE_SOURCES_BY_CODE[issue2.code] ?? "unknown";
+var resolveIssueAffectedPath = (params) => {
+  if (params.issue.code === "missing-manifest" || params.issue.code === "invalid-manifest") {
+    return PROJECT_LAYER_MANIFEST_RELATIVE_PATH;
+  }
+  if (params.issue.code === "missing-context-index" || params.issue.code === "invalid-context-index") {
+    return PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH;
+  }
+  if (params.issue.code === "missing-docs-status" || params.issue.code === "invalid-docs-status") {
+    return DOCS_STATUS_RELATIVE_PATH;
+  }
+  if (params.issue.code === "source-hash-drift") {
+    return null;
+  }
+  const knownPath = findKnownPathInMessage(params.issue.message, params.knownPaths);
+  if (knownPath !== null) {
+    return knownPath;
+  }
+  if (params.source === "unknown") {
+    return null;
+  }
+  return extractTrailingIssuePath(params.issue.message);
+};
+var normalizeStudioProjectIssue = (issue2, knownPaths = []) => {
+  const source = resolveIssueSource(issue2);
+  return {
+    level: issue2.level,
+    code: issue2.code,
+    message: issue2.message,
+    source,
+    affectedPath: resolveIssueAffectedPath({ issue: issue2, source, knownPaths }),
+    suggestedActionLabel: AUDIT_ISSUE_ACTION_LABELS_BY_SOURCE[source]
+  };
+};
+var readProjectManifestSnapshot = (basePath) => {
+  const manifestPath = resolveProjectLayerManifestPath(basePath);
+  if (!existsSync3(manifestPath)) {
+    return {
+      source: createMissingSourceState(PROJECT_LAYER_MANIFEST_RELATIVE_PATH),
+      manifest: null
+    };
+  }
+  try {
+    const manifest = readProjectLayerManifest(basePath);
+    return {
+      source: buildSourceState({
+        path: PROJECT_LAYER_MANIFEST_RELATIVE_PATH,
+        exists: true,
+        parsed: manifest !== null,
+        generatedAt: manifest?.generatedAt ?? null
+      }),
+      manifest
+    };
+  } catch (error) {
+    return {
+      source: buildSourceState({
+        path: PROJECT_LAYER_MANIFEST_RELATIVE_PATH,
+        exists: true,
+        parsed: false,
+        error: getErrorMessage(error)
+      }),
+      manifest: null
+    };
+  }
+};
+var readProjectContextIndexSnapshot = (basePath) => {
+  const contextIndexPath = resolveProjectLayerContextIndexPath(basePath);
+  if (!existsSync3(contextIndexPath)) {
+    return {
+      source: createMissingSourceState(PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH),
+      contextIndex: null
+    };
+  }
+  try {
+    const parsedJson = JSON.parse(readFileSync8(contextIndexPath, "utf-8"));
+    const strictContextIndex = ProjectLayerContextIndexSchema.safeParse(parsedJson);
+    if (strictContextIndex.success) {
+      return {
+        source: buildSourceState({
+          path: PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH,
+          exists: true,
+          parsed: true,
+          generatedAt: strictContextIndex.data.generatedAt
+        }),
+        contextIndex: strictContextIndex.data
+      };
+    }
+    const recoverableContextIndex = RecoverableContextIndexSchema.safeParse(parsedJson);
+    if (!recoverableContextIndex.success) {
+      return {
+        source: buildSourceState({
+          path: PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH,
+          exists: true,
+          parsed: false,
+          error: strictContextIndex.error.message
+        }),
+        contextIndex: null
+      };
+    }
+    const documents = recoverableContextIndex.data.documents.flatMap((document) => {
+      const parsedDocument = RecoverableContextDocumentSchema.safeParse(document);
+      return parsedDocument.success ? [parsedDocument.data] : [];
+    });
+    return {
+      source: buildSourceState({
+        path: PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH,
+        exists: true,
+        parsed: false,
+        generatedAt: recoverableContextIndex.data.generatedAt,
+        error: strictContextIndex.error.message
+      }),
+      contextIndex: {
+        schemaVersion: 1,
+        kind: "context-layer-index",
+        documents,
+        generatedAt: recoverableContextIndex.data.generatedAt
+      }
+    };
+  } catch (error) {
+    return {
+      source: buildSourceState({
+        path: PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH,
+        exists: true,
+        parsed: false,
+        error: getErrorMessage(error)
+      }),
+      contextIndex: null
+    };
+  }
+};
+var readDocsStatusSourceState = (basePath) => {
+  const docsStatusPath = resolveProjectLayerFilePath(basePath, DOCS_STATUS_RELATIVE_PATH);
+  if (!existsSync3(docsStatusPath)) {
+    return createMissingSourceState(DOCS_STATUS_RELATIVE_PATH);
+  }
+  try {
+    parseProjectLayerDocument(DOCS_STATUS_RELATIVE_PATH, readFileSync8(docsStatusPath, "utf-8"));
+    return buildSourceState({
+      path: DOCS_STATUS_RELATIVE_PATH,
+      exists: true,
+      parsed: true
+    });
+  } catch (error) {
+    return buildSourceState({
+      path: DOCS_STATUS_RELATIVE_PATH,
+      exists: true,
+      parsed: false,
+      error: getErrorMessage(error)
+    });
+  }
+};
+var buildDocumentProvenance = (manifest, path) => {
+  if (manifest?.managed_files.some((file) => file.path === path) === true) {
+    return "ai-ops-managed";
+  }
+  if (manifest?.project_files.some((file) => file.path === path) === true) {
+    return "project-owned";
+  }
+  if (manifest?.packs.some((pack) => pack.documents.some((document) => document.path === path)) === true) {
+    return "pack-document";
+  }
+  return "context-only";
+};
+var buildDocumentReadError = (code, message) => `${code}: ${message}`;
+var buildProjectDocumentSnapshot = (params) => {
+  let absolutePath;
+  try {
+    absolutePath = resolveProjectLayerFilePath(params.basePath, params.indexed.path);
+  } catch (error) {
+    return {
+      path: params.indexed.path,
+      status: params.indexed.status,
+      layer: params.indexed.layer,
+      owner: params.indexed.owner,
+      read_when: params.indexed.read_when,
+      update_when: params.indexed.update_when,
+      indexedContentHash: params.indexed.contentHash,
+      currentContentHash: null,
+      contentHashMatches: null,
+      provenance: params.provenance,
+      content: null,
+      trustWarning: getTrustWarning(params.indexed.status),
+      readError: buildDocumentReadError("unsafe-path", getErrorMessage(error))
+    };
+  }
+  if (!existsSync3(absolutePath)) {
+    return {
+      path: params.indexed.path,
+      status: params.indexed.status,
+      layer: params.indexed.layer,
+      owner: params.indexed.owner,
+      read_when: params.indexed.read_when,
+      update_when: params.indexed.update_when,
+      indexedContentHash: params.indexed.contentHash,
+      currentContentHash: null,
+      contentHashMatches: null,
+      provenance: params.provenance,
+      content: null,
+      trustWarning: getTrustWarning(params.indexed.status),
+      readError: buildDocumentReadError("missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${params.indexed.path}`)
+    };
+  }
+  try {
+    const document = parseProjectLayerDocument(params.indexed.path, readFileSync8(absolutePath, "utf-8"));
+    return {
+      path: params.indexed.path,
+      status: params.indexed.status,
+      layer: params.indexed.layer,
+      owner: params.indexed.owner,
+      read_when: params.indexed.read_when,
+      update_when: params.indexed.update_when,
+      indexedContentHash: params.indexed.contentHash,
+      currentContentHash: document.contentHash,
+      contentHashMatches: document.contentHash === params.indexed.contentHash,
+      provenance: params.provenance,
+      content: document.content,
+      trustWarning: getTrustWarning(params.indexed.status),
+      readError: null
+    };
+  } catch (error) {
+    return {
+      path: params.indexed.path,
+      status: params.indexed.status,
+      layer: params.indexed.layer,
+      owner: params.indexed.owner,
+      read_when: params.indexed.read_when,
+      update_when: params.indexed.update_when,
+      indexedContentHash: params.indexed.contentHash,
+      currentContentHash: null,
+      contentHashMatches: null,
+      provenance: params.provenance,
+      content: null,
+      trustWarning: getTrustWarning(params.indexed.status),
+      readError: buildDocumentReadError("invalid-frontmatter", getErrorMessage(error))
+    };
+  }
+};
+var resolveProjectState = (params) => {
+  const isUninitialized = !params.manifest.source.exists && !params.contextIndex.source.exists;
+  if (isUninitialized) {
+    return "uninitialized";
+  }
+  const hasParseError = params.manifest.source.exists && !params.manifest.source.parsed || params.contextIndex.source.exists && !params.contextIndex.source.parsed || params.docsStatus.exists && !params.docsStatus.parsed;
+  const hasDocumentReadError = params.documents.some((document) => document.readError !== null);
+  if (hasParseError || params.hasAuditErrors || hasDocumentReadError) {
+    return "degraded";
+  }
+  return "ready";
+};
+var buildProjectSnapshot = (basePath) => {
+  const root = resolve6(basePath);
+  const manifest = readProjectManifestSnapshot(root);
+  const contextIndex = readProjectContextIndexSnapshot(root);
+  const docsStatus = readDocsStatusSourceState(root);
+  const auditReport = auditProjectLayer(root);
+  const documents = contextIndex.contextIndex?.documents.map(
+    (indexed) => buildProjectDocumentSnapshot({
+      basePath: root,
+      indexed,
+      provenance: buildDocumentProvenance(manifest.manifest, indexed.path)
+    })
+  ) ?? [];
+  const auditHasErrors = hasErrors(auditReport.issues);
+  const knownAuditPaths = buildKnownAuditPaths({
+    manifest: manifest.manifest,
+    contextIndex: contextIndex.contextIndex,
+    documents
+  });
+  const auditIssues = auditReport.issues.map((issue2) => normalizeStudioProjectIssue(issue2, knownAuditPaths));
+  return {
+    root,
+    state: resolveProjectState({
+      manifest,
+      contextIndex,
+      docsStatus,
+      documents,
+      hasAuditErrors: auditHasErrors
+    }),
+    files: {
+      manifest: manifest.source,
+      contextIndex: contextIndex.source,
+      docsStatus
+    },
+    audit: {
+      currentSourceHash: auditReport.currentSourceHash,
+      hasErrors: auditHasErrors,
+      hasWarnings: hasWarnings(auditIssues),
+      issues: auditIssues
+    },
+    documents
+  };
+};
+var readRuntimeManifest = (params) => {
+  if (params.manifestPath === null) {
+    return {
+      source: createUnavailableSourceState({
+        path: params.fallbackPath,
+        reason: params.unavailableReason ?? "Runtime home is unavailable."
+      }),
+      value: null
+    };
+  }
+  if (!existsSync3(params.manifestPath)) {
+    return {
+      source: createMissingSourceState(params.manifestPath),
+      value: null
+    };
+  }
+  try {
+    const value = params.read(params.manifestPath);
+    return {
+      source: buildSourceState({
+        path: params.manifestPath,
+        exists: true,
+        parsed: value !== null,
+        generatedAt: value === null ? null : params.getGeneratedAt(value)
+      }),
+      value
+    };
+  } catch (error) {
+    return {
+      source: buildSourceState({
+        path: params.manifestPath,
+        exists: true,
+        parsed: false,
+        error: getErrorMessage(error)
+      }),
+      value: null
+    };
+  }
+};
+var isJsonRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var readHooksSourceState = (codexHomePath, unavailableReason) => {
+  if (codexHomePath === null) {
+    return createUnavailableSourceState({
+      path: HOOKS_FALLBACK_PATH,
+      reason: unavailableReason ?? "CODEX_HOME or HOME is required for Codex hooks."
+    });
+  }
+  const hooksPath = resolveCodexHooksPath(codexHomePath);
+  if (!existsSync3(hooksPath)) {
+    return createMissingSourceState(hooksPath);
+  }
+  try {
+    const parsed = JSON.parse(readFileSync8(hooksPath, "utf-8"));
+    if (!isJsonRecord2(parsed)) {
+      return buildSourceState({
+        path: hooksPath,
+        exists: true,
+        parsed: false,
+        error: "hooks.json must contain a JSON object"
+      });
+    }
+    return buildSourceState({
+      path: hooksPath,
+      exists: true,
+      parsed: true
+    });
+  } catch (error) {
+    return buildSourceState({
+      path: hooksPath,
+      exists: true,
+      parsed: false,
+      error: getErrorMessage(error)
+    });
+  }
+};
+var getCatalogComponentId = (component) => component.id;
+var getInstalledComponentId = (component) => component.id;
+var findInstalledComponent = (integration, catalogComponent) => integration?.components.find(
+  (component) => component.type === catalogComponent.type && getInstalledComponentId(component) === getCatalogComponentId(catalogComponent)
+) ?? null;
+var buildIntegrationComponentStatus = (params) => ({
+  type: params.catalogComponent.type,
+  id: getCatalogComponentId(params.catalogComponent),
+  installed: params.installedComponent !== null,
+  owned: params.installedComponent?.owned ?? null,
+  catalog: params.catalogComponent,
+  installedComponent: params.installedComponent
+});
+var buildIntegrationSnapshots = (installedIntegrations) => {
+  const catalog = loadAllIntegrations(INTEGRATIONS_DATA_DIR);
+  return catalog.map((entry) => {
+    const installedIntegration = findInstalledIntegration(installedIntegrations, entry.id);
+    return {
+      id: entry.id,
+      description: entry.description,
+      installed: installedIntegration !== void 0,
+      installedAt: installedIntegration?.installedAt ?? null,
+      updatedAt: installedIntegration?.updatedAt ?? null,
+      components: entry.components.map(
+        (catalogComponent) => buildIntegrationComponentStatus({
+          catalogComponent,
+          installedComponent: findInstalledComponent(installedIntegration, catalogComponent)
+        })
+      )
+    };
+  });
+};
+var buildInstalledPathStates = (params) => {
+  if (params.userBasePath === null) {
+    return params.installedPaths.map((path) => ({ path, exists: false }));
+  }
+  return params.installedPaths.map((path) => ({
+    path,
+    exists: existsSync3(join10(params.userBasePath ?? "", path))
+  }));
+};
+var buildInstalledSkillMap = (installedSkills) => new Map(
+  installedSkills.map((skill) => [
+    resolveCanonicalSkillId(skill.id),
+    {
+      ...skill,
+      id: resolveCanonicalSkillId(skill.id)
+    }
+  ])
+);
+var buildSkillSnapshots = (params) => {
+  const installed = buildInstalledSkillMap(params.installedSkills);
+  return loadAllSkills(SKILLS_DATA_DIR).map((skill) => {
+    const installedSkill = installed.get(skill.id);
+    return {
+      id: skill.id,
+      kind: skill.kind,
+      description: skill.description,
+      supported_tools: skill.supported_tools,
+      groups: skill.groups,
+      installed: installedSkill !== void 0,
+      installedTools: installedSkill?.tools ?? [],
+      installedPaths: buildInstalledPathStates({
+        userBasePath: params.userBasePath,
+        installedPaths: installedSkill?.installed_paths ?? []
+      }),
+      sourceHash: installedSkill?.sourceHash ?? null
+    };
+  });
+};
+var buildInstalledSubagentMap = (installedSubagents) => new Map(installedSubagents.map((subagent) => [subagent.id, subagent]));
+var buildSubagentSnapshots = (params) => {
+  const installed = buildInstalledSubagentMap(params.installedSubagents);
+  return loadAllSubagents(SUBAGENTS_DATA_DIR).map((subagent) => {
+    const installedSubagent = installed.get(subagent.id);
+    return {
+      id: subagent.id,
+      description: subagent.frontmatter.codex.parsed.description,
+      supported_tools: subagent.supported_tools,
+      installed: installedSubagent !== void 0,
+      installedTools: installedSubagent?.tools ?? [],
+      installedPaths: buildInstalledPathStates({
+        userBasePath: params.userBasePath,
+        installedPaths: installedSubagent?.installed_paths ?? []
+      }),
+      sourceHash: installedSubagent?.sourceHash ?? null
+    };
+  });
+};
+var buildHookSnapshot = (params) => {
+  if (params.codexHomePath === null) {
+    return {
+      id: params.definition.id,
+      statusMessage: params.definition.statusMessage,
+      hooksPath: null,
+      installed: false,
+      error: params.unavailableReason ?? "CODEX_HOME or HOME is required for Codex hooks."
+    };
   }
-  const result = mergeRemoveResults([...managedResults, ...projectResults, ...packResults]);
-  removeEmptyDirs(basePath, [...result.deleted, ...stateFiles]);
-  return result;
+  const hooksPath = resolveCodexHooksPath(params.codexHomePath);
+  try {
+    const status = inspectCodexHook({
+      hooksPath,
+      definition: params.definition
+    });
+    return {
+      id: params.definition.id,
+      statusMessage: params.definition.statusMessage,
+      hooksPath: status.hooksPath,
+      installed: status.installed,
+      error: null
+    };
+  } catch (error) {
+    return {
+      id: params.definition.id,
+      statusMessage: params.definition.statusMessage,
+      hooksPath,
+      installed: false,
+      error: getErrorMessage(error)
+    };
+  }
+};
+var buildRuntimeSnapshot = (params) => {
+  const userUnavailableReason = params.userBasePath === null ? "AI_OPS_HOME or HOME is required for user/global runtime manifests." : null;
+  const codexUnavailableReason = params.codexHomePath === null ? "CODEX_HOME or HOME is required for Codex hooks." : null;
+  const integrationManifest = readRuntimeManifest({
+    manifestPath: params.userBasePath === null ? null : resolveIntegrationManifestPath(params.userBasePath),
+    fallbackPath: INTEGRATIONS_MANIFEST_FALLBACK_PATH,
+    unavailableReason: userUnavailableReason,
+    read: readIntegrationManifest,
+    getGeneratedAt: (manifest) => manifest.generatedAt
+  });
+  const skillRegistry = readRuntimeManifest({
+    manifestPath: params.userBasePath === null ? null : resolveSkillRegistryPath(params.userBasePath),
+    fallbackPath: SKILLS_MANIFEST_FALLBACK_PATH,
+    unavailableReason: userUnavailableReason,
+    read: readSkillRegistry,
+    getGeneratedAt: (registry) => registry.generatedAt
+  });
+  const subagentManifest = readRuntimeManifest({
+    manifestPath: params.userBasePath === null ? null : resolveSubagentManifestPath(params.userBasePath),
+    fallbackPath: SUBAGENTS_MANIFEST_FALLBACK_PATH,
+    unavailableReason: userUnavailableReason,
+    read: readSubagentManifest,
+    getGeneratedAt: (manifest) => manifest.generatedAt
+  });
+  const hooks = readHooksSourceState(params.codexHomePath, codexUnavailableReason);
+  const installedIntegrations = integrationManifest.value?.integrations ?? [];
+  const installedSkills = skillRegistry.value?.skills ?? [];
+  const installedSubagents = subagentManifest.value?.subagents ?? [];
+  return {
+    available: params.userBasePath !== null,
+    unavailableReason: userUnavailableReason,
+    userBasePath: params.userBasePath,
+    codexHomePath: params.codexHomePath,
+    manifests: {
+      integrations: integrationManifest.source,
+      skills: skillRegistry.source,
+      subagents: subagentManifest.source,
+      hooks
+    },
+    integrations: buildIntegrationSnapshots(installedIntegrations),
+    skills: buildSkillSnapshots({
+      userBasePath: params.userBasePath,
+      installedSkills
+    }),
+    subagents: buildSubagentSnapshots({
+      userBasePath: params.userBasePath,
+      installedSubagents
+    }),
+    hooks: KNOWN_CODEX_HOOK_DEFINITIONS.map(
+      (definition) => buildHookSnapshot({
+        codexHomePath: params.codexHomePath,
+        definition,
+        unavailableReason: codexUnavailableReason
+      })
+    )
+  };
+};
+var buildStudioSnapshot = (params) => {
+  const generatedAt = params.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const userBasePath = params.userBasePath === void 0 ? resolveDefaultUserBasePath() : params.userBasePath;
+  const codexHomePath = params.codexHomePath === void 0 ? resolveDefaultCodexHomePath() : params.codexHomePath;
+  return StudioSnapshotSchema.parse({
+    schemaVersion: 1,
+    kind: "ai-ops-studio-snapshot",
+    generatedAt,
+    cliVersion: params.cliVersion ?? getCliVersion(),
+    project: buildProjectSnapshot(params.basePath),
+    runtime: buildRuntimeSnapshot({
+      userBasePath,
+      codexHomePath
+    })
+  });
 };
 
 // src/core/pack.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync5, readFileSync as readFileSync7, readdirSync as readdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync5 } from "fs";
-import { dirname as dirname7, isAbsolute as isAbsolute2, join as join9, relative as relative2, resolve as resolve6 } from "path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync6, readFileSync as readFileSync9, readdirSync as readdirSync4, rmSync as rmSync3, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname8, isAbsolute as isAbsolute2, join as join11, relative as relative2, resolve as resolve7 } from "path";
 var PACK_REGISTRY_FILENAME = "pack-registry.json";
 var SPEC_LIFECYCLE_PACK_ID = "spec-lifecycle";
 var PACK_INSTALL_ROOT = "docs/specs/";
@@ -1601,9 +2641,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 = join9(COMPILER_DATA_DIR, "packs");
+var DEFAULT_PACKS_DIR = join11(COMPILER_DATA_DIR, "packs");
 var includesReservedDocumentWarning2 = (content) => RESERVED_DOCUMENT_WARNINGS2.some((warning) => content.includes(warning));
-var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync7(join9(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
+var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync9(join11(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
 var assertPackInstallPath = (path) => {
   if (!isSafeProjectLayerPath(path) || !path.startsWith(PACK_INSTALL_ROOT)) {
     throw new Error(`Unsafe pack path: ${path}`);
@@ -1612,16 +2652,16 @@ var assertPackInstallPath = (path) => {
 var readPackSourceFiles = (packDir) => {
   const files = [];
   const walk = (relativeDir = "") => {
-    const absoluteDir = relativeDir.length > 0 ? join9(packDir, relativeDir) : packDir;
+    const absoluteDir = relativeDir.length > 0 ? join11(packDir, relativeDir) : packDir;
     const entries = readdirSync4(absoluteDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const nextRelativePath = relativeDir.length > 0 ? join9(relativeDir, entry.name) : entry.name;
+      const nextRelativePath = relativeDir.length > 0 ? join11(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
         walk(nextRelativePath);
         continue;
       }
       assertPackInstallPath(nextRelativePath);
-      const content = readFileSync7(join9(packDir, nextRelativePath), "utf-8");
+      const content = readFileSync9(join11(packDir, nextRelativePath), "utf-8");
       files.push({
         path: nextRelativePath,
         content,
@@ -1656,8 +2696,8 @@ var loadAllPacks = (packsDir) => {
     if (entry.id !== SPEC_LIFECYCLE_PACK_ID) {
       throw new Error(`Unsupported pack id: ${entry.id}`);
     }
-    const packDir = resolve6(packsDir, entry.source_path);
-    const relativeFromPacks = relative2(resolve6(packsDir), packDir);
+    const packDir = resolve7(packsDir, entry.source_path);
+    const relativeFromPacks = relative2(resolve7(packsDir), packDir);
     if (relativeFromPacks.length === 0 || relativeFromPacks.startsWith("..") || isAbsolute2(relativeFromPacks)) {
       throw new Error(`Pack source path escapes packs dir: ${entry.source_path}`);
     }
@@ -1679,11 +2719,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([readFileSync9(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,
@@ -1713,7 +2753,7 @@ var applyPackSourceFiles = (params) => {
   for (const file of sourceFiles) {
     const absolutePath = resolveProjectLayerFilePath(params.basePath, file.path);
     const previous = previousByPath.get(file.path);
-    if (!existsSync2(absolutePath)) {
+    if (!existsSync4(absolutePath)) {
       writePackFile(params.basePath, file);
       written.push(file.path);
       continue;
@@ -1737,7 +2777,7 @@ var applyPackSourceFiles = (params) => {
       continue;
     }
     const absolutePath = resolveProjectLayerFilePath(params.basePath, previous.path);
-    if (!existsSync2(absolutePath)) {
+    if (!existsSync4(absolutePath)) {
       notFound.push(previous.path);
       continue;
     }
@@ -1756,7 +2796,7 @@ var removePackFiles = (basePath, record) => {
   const notFound = [];
   for (const file of [...record.documents, ...record.files]) {
     const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
-    if (!existsSync2(absolutePath)) {
+    if (!existsSync4(absolutePath)) {
       notFound.push(file.path);
       continue;
     }
@@ -1770,12 +2810,12 @@ 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) {
     const absoluteDir = resolveProjectLayerFilePath(basePath, dir);
-    if (!existsSync2(absoluteDir)) {
+    if (!existsSync4(absoluteDir)) {
       continue;
     }
     try {
@@ -1891,7 +2931,7 @@ var diffProjectLayerPack = (params) => {
     }
     for (const file of [...record.documents, ...record.files]) {
       const absolutePath = resolveProjectLayerFilePath(params.basePath, file.path);
-      if (!existsSync2(absolutePath)) {
+      if (!existsSync4(absolutePath)) {
         issues.push(packIssue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       }
     }
@@ -1902,21 +2942,21 @@ var diffProjectLayerPack = (params) => {
 // 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 join10, resolve as resolve7 } from "path";
-import { z as z12 } from "zod";
+import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync10, statSync, writeFileSync as writeFileSync7 } from "fs";
+import { dirname as dirname9, join as join12, resolve as resolve8 } from "path";
+import { z as z14 } from "zod";
 
 // src/core/tool-use-hook.ts
-import { z as z11 } from "zod";
-var HookToolInputSchema = z11.object({
-  command: z11.string().optional()
+import { z as z13 } from "zod";
+var HookToolInputSchema = z13.object({
+  command: z13.string().optional()
 }).passthrough();
-var ToolUseHookInputSchema = z11.object({
-  hook_event_name: z11.string(),
-  cwd: z11.string(),
-  tool_name: z11.string().optional(),
-  tool_input: z11.unknown().optional(),
-  tool_response: z11.unknown().optional()
+var ToolUseHookInputSchema = z13.object({
+  hook_event_name: z13.string(),
+  cwd: z13.string(),
+  tool_name: z13.string().optional(),
+  tool_input: z13.unknown().optional(),
+  tool_response: z13.unknown().optional()
 }).passthrough();
 var SHELL_CONTROL_TOKENS = /* @__PURE__ */ new Set(["&&", "||", ";", "|", "(", ")"]);
 var SHELL_SCRIPT_FLAGS = /* @__PURE__ */ new Set(["-c", "-lc"]);
@@ -2047,7 +3087,7 @@ var isGitCommitCommand = (command) => {
     (segment) => segmentInvokesGitCommit(segment) || segmentInvokesShellScriptWithGitCommit(segment)
   );
 };
-var isJsonRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isJsonRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var numberField = (record, keys) => {
   for (const key of keys) {
     const value = record[key];
@@ -2091,7 +3131,7 @@ var toolResponseIndicatesFailure = (toolResponse) => {
   if (typeof toolResponse === "string") {
     return stringIndicatesGitCommitFailureOrSuccess(toolResponse) === true;
   }
-  if (!isJsonRecord(toolResponse)) {
+  if (!isJsonRecord3(toolResponse)) {
     return false;
   }
   const success = booleanField(toolResponse, ["success", "ok"]);
@@ -2133,35 +3173,35 @@ 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 = z14.union([
+  z14.literal(CONTEXT_PROMOTION_DECISION.PROMOTED),
+  z14.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 = z14.union([
+  z14.literal(CONTEXT_PROMOTION_SCOPE.CORE),
+  z14.literal(CONTEXT_PROMOTION_SCOPE.PROJECT_LOCAL),
+  z14.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 = z14.object({
+  fingerprint: z14.string().regex(/^[a-f0-9]{16}$/),
+  commitHash: z14.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: z14.array(ContextPromotionScopeSchema),
+  targets: z14.array(z14.string().min(1)),
+  summary: z14.string().min(1),
+  resolvedAt: z14.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 = z14.object({
+  schemaVersion: z14.literal(1),
+  kind: z14.literal("context-promotion-receipts"),
+  projectKey: z14.string().regex(/^[a-f0-9]{12}$/),
+  projectRoot: z14.string().min(1),
+  receipts: z14.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 buildContextPromotionProjectKey = (gitRoot) => hashHex([resolve8(gitRoot)], 12);
 var runGit = (cwd, args) => execFileSync("git", [...args], {
   cwd,
   encoding: "utf-8",
@@ -2186,13 +3226,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 = join10(gitRoot, relativePath);
+    const absolutePath = join12(gitRoot, relativePath);
     try {
       const stat = statSync(absolutePath);
       if (!stat.isFile()) {
         return `${relativePath}:non-file`;
       }
-      const content = readFileSync8(absolutePath);
+      const content = readFileSync10(absolutePath);
       return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
     } catch {
       throw new Error(`Unable to read untracked path for context promotion fingerprint: ${relativePath}`);
@@ -2206,15 +3246,15 @@ var readTrackedWorkingTreeFingerprintParts = (gitRoot) => {
   return [
     `raw:${rawDiff}`,
     ...paths.map((relativePath) => {
-      const absolutePath = join10(gitRoot, relativePath);
-      if (!existsSync3(absolutePath)) {
+      const absolutePath = join12(gitRoot, relativePath);
+      if (!existsSync5(absolutePath)) {
         return `${relativePath}:deleted`;
       }
       const stat = statSync(absolutePath);
       if (!stat.isFile()) {
         return `${relativePath}:non-file`;
       }
-      const content = readFileSync8(absolutePath);
+      const content = readFileSync10(absolutePath);
       return `${relativePath}:${createHash2("sha256").update(content).digest("hex")}`;
     })
   ];
@@ -2232,19 +3272,19 @@ var computeContextPromotionFingerprint = (gitRoot) => hashHex(
   ],
   16
 );
-var resolveContextPromotionReceiptIndexPath = (params) => join10(params.userBasePath, ".ai-ops", "context-promotion", "projects", params.projectKey, RECEIPT_INDEX_FILENAME);
+var resolveContextPromotionReceiptIndexPath = (params) => join12(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(readFileSync10(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,
@@ -2292,9 +3332,9 @@ var pruneContextPromotionReceipts = (params) => {
   writeContextPromotionReceiptIndex(params.indexPath, nextIndex);
   return nextIndex;
 };
-var hasContextPromotionLayer = (gitRoot) => existsSync3(join10(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
+var hasContextPromotionLayer = (gitRoot) => existsSync5(join12(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
 var getContextPromotionStatus = (params) => {
-  const cwd = resolve7(params.cwd);
+  const cwd = resolve8(params.cwd);
   const gitRoot = resolveContextPromotionGitRoot(cwd);
   if (!gitRoot) {
     return {
@@ -2383,24 +3423,28 @@ 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.",
+    "Context Promotion Review should run for the completed work commit and review-loop learnings.",
     "",
     `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.",
+    "Use the `context-promotion-review` skill to review the just-created HEAD commit plus current conversation/review-loop learnings 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.",
+    "- Use only the just-created `HEAD` commit, current conversation/review-loop learnings, post-commit worktree state, and files under the project root.",
     "",
     "Review requirements:",
     "- Do not amend, rewrite, or mix changes into the work commit.",
+    "- Inspect the post-commit worktree state before deciding: run `git status --short`, `git diff --name-only`, `git diff --cached --name-only`, and `git ls-files --others --exclude-standard`.",
     "- 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.",
+    "- Treat `already-covered` as valid only when the Active context layer already has the same agent behavior rule; plans, tests, README, runbooks, and operator docs are evidence, not automatic coverage.",
+    "- Check whether user corrections, repeated review findings, command routines, dirty worktree, untracked files, changeset pollution, or staging-scope hygiene produced a reusable `project-local` candidate.",
+    "- Before `no-promotion`, briefly report near-miss or discarded candidates with reasons.",
     "- 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.",
@@ -2456,9 +3500,9 @@ var evaluateContextPromotionPostToolUseHook = (params) => {
 
 // src/core/pc-integration.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync4, readFileSync as readFileSync9, readdirSync as readdirSync5 } from "fs";
-import { join as join11, resolve as resolve8, sep } from "path";
-var normalizePath = (path) => resolve8(path.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"));
+import { existsSync as existsSync6, readFileSync as readFileSync11, readdirSync as readdirSync5 } from "fs";
+import { join as join13, resolve as resolve9, sep } from "path";
+var normalizePath = (path) => resolve9(path.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"));
 var pathContains = (parentPath, childPath) => {
   const parent = normalizePath(parentPath);
   const child = normalizePath(childPath);
@@ -2495,7 +3539,7 @@ var parseListField = (content, labels) => {
 };
 var readTextFileOrNull = (filePath) => {
   try {
-    return readFileSync9(filePath, "utf-8");
+    return readFileSync11(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -2520,11 +3564,11 @@ var readGitHead2 = (cwd) => {
   }
 };
 var listWorkspaceStatePaths = (contextRoot) => {
-  const workspacesDir = join11(contextRoot, "workspaces");
-  if (!existsSync4(workspacesDir)) {
+  const workspacesDir = join13(contextRoot, "workspaces");
+  if (!existsSync6(workspacesDir)) {
     return [];
   }
-  return readdirSync5(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join11(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync4(statePath)).sort((a, b) => a.localeCompare(b));
+  return readdirSync5(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join13(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync6(statePath)).sort((a, b) => a.localeCompare(b));
 };
 var parseWorkspaceCandidate = (statePath) => {
   const content = readTextFileOrNull(statePath);
@@ -2537,7 +3581,7 @@ var parseWorkspaceCandidate = (statePath) => {
   }
   const activeSection = extractSection(content, ["\uD65C\uC131 Workstream", "Active Workstream"]);
   const activeWorkstreamId = parseListField(activeSection, ["ID", "Workstream ID", "Active Workstream"]);
-  const workspaceDir = resolve8(statePath, "..");
+  const workspaceDir = resolve9(statePath, "..");
   const id = parseListField(content, ["\uC6CC\uD06C\uC2A4\uD398\uC774\uC2A4 ID", "Workspace ID"]) ?? workspaceDir.split(sep).at(-1) ?? "unknown";
   return {
     id,
@@ -2567,11 +3611,11 @@ var parseRepoEntry = (entryPath) => {
   };
 };
 var findCurrentEntry = (params) => {
-  const reposDir = join11(params.workspaceDir, "repos");
-  if (!existsSync4(reposDir)) {
+  const reposDir = join13(params.workspaceDir, "repos");
+  if (!existsSync6(reposDir)) {
     return null;
   }
-  const entries = readdirSync5(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join11(reposDir, entry.name))).filter((entry) => entry !== null).filter((entry) => {
+  const entries = readdirSync5(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join13(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) => {
@@ -2623,7 +3667,7 @@ var parseLastConfirmedCommitHash = (params) => {
 var getPcHandoffStatus = (params) => {
   const cwd = normalizePath(params.cwd);
   const contextRoot = normalizePath(params.contextRoot);
-  if (!existsSync4(contextRoot)) {
+  if (!existsSync6(contextRoot)) {
     return {
       cwd,
       contextRoot,
@@ -2666,7 +3710,7 @@ var getPcHandoffStatus = (params) => {
       skipReason: "active pc workstream not selected"
     };
   }
-  const activeWorkstreamPath = join11(workspace.workspaceDir, "workstreams", `${workspace.activeWorkstreamId}.md`);
+  const activeWorkstreamPath = join13(workspace.workspaceDir, "workstreams", `${workspace.activeWorkstreamId}.md`);
   const activeWorkstreamContent = readTextFileOrNull(activeWorkstreamPath);
   if (!activeWorkstreamContent) {
     return {
@@ -2783,204 +3827,12 @@ var evaluatePcPostToolUseHook = (params) => {
   return buildPostToolUseOutput2(buildPcDonePrompt({ status, head, gitRoot }));
 };
 
-// src/core/codex-hook.ts
-import { existsSync as existsSync5, mkdirSync as mkdirSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
-import { dirname as dirname9, join as join12 } from "path";
-var CONTEXT_PROMOTION_HOOK_ID = "context-promotion";
-var CONTEXT_PROMOTION_HOOK_COMMAND_MARKER = "context-promotion hook post-tool-use";
-var CONTEXT_PROMOTION_LEGACY_HOOK_COMMAND_MARKER = "context-promotion hook pre-tool-use";
-var CONTEXT_PROMOTION_DEFAULT_HOOK_COMMAND = `ai-ops ${CONTEXT_PROMOTION_HOOK_COMMAND_MARKER}`;
-var PC_HOOK_ID = "pc";
-var PC_HOOK_COMMAND_MARKER = "integration hook post-tool-use pc";
-var PC_DEFAULT_HOOK_COMMAND = `ai-ops ${PC_HOOK_COMMAND_MARKER}`;
-var PRE_TOOL_USE_EVENT = "PreToolUse";
-var POST_TOOL_USE_EVENT = "PostToolUse";
-var BASH_MATCHER = "^Bash$";
-var CONTEXT_PROMOTION_CODEX_HOOK = {
-  id: CONTEXT_PROMOTION_HOOK_ID,
-  commandMarker: CONTEXT_PROMOTION_HOOK_COMMAND_MARKER,
-  legacyCommandMarkers: [CONTEXT_PROMOTION_LEGACY_HOOK_COMMAND_MARKER],
-  defaultCommand: CONTEXT_PROMOTION_DEFAULT_HOOK_COMMAND,
-  statusMessage: "Checking context promotion review"
-};
-var PC_CODEX_HOOK = {
-  id: PC_HOOK_ID,
-  commandMarker: PC_HOOK_COMMAND_MARKER,
-  legacyCommandMarkers: [],
-  defaultCommand: PC_DEFAULT_HOOK_COMMAND,
-  statusMessage: "Checking pc handoff"
-};
-var isJsonRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var readJsonRecord = (filePath) => {
-  if (!existsSync5(filePath)) {
-    return {};
-  }
-  const parsed = JSON.parse(readFileSync10(filePath, "utf-8"));
-  if (!isJsonRecord2(parsed)) {
-    throw new Error("hooks.json must contain a JSON object");
-  }
-  return parsed;
-};
-var writeJsonRecord = (filePath, value) => {
-  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 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 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(handlerMatchesDefinition(definition)).length;
-}, 0);
-var configHasDefinitionHook = (config, definition) => {
-  const hooks = config.hooks;
-  if (!isJsonRecord2(hooks)) {
-    return false;
-  }
-  return getArray(hooks, POST_TOOL_USE_EVENT).some(groupHasDefinitionHook(definition));
-};
-var configHasOnlyCurrentDefinitionHook = (config, definition, command) => {
-  const hooks = config.hooks;
-  if (!isJsonRecord2(hooks)) {
-    return false;
-  }
-  const hasLegacy = getArray(hooks, PRE_TOOL_USE_EVENT).some(groupHasDefinitionHook(definition));
-  const postGroups = getArray(hooks, POST_TOOL_USE_EVENT);
-  const hasCurrent = postGroups.some((group) => groupHasCurrentDefinitionHook(group, command));
-  return hasCurrent && !hasLegacy && countDefinitionHandlers(postGroups, definition) === 1;
-};
-var removeDefinitionHooksFromEvent = (hooks, eventName, definition) => {
-  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 = handlerMatchesDefinition(definition)(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) => join12(codexHomePath, "hooks.json");
-var buildCodexHookCommand = (params) => {
-  const command = params.overrideCommand?.trim() ?? params.definition.defaultCommand;
-  if (!command.includes(params.definition.commandMarker)) {
-    throw new Error(`${params.definition.id} hook command must include: ${params.definition.commandMarker}`);
-  }
-  return command;
-};
-var buildContextPromotionHookCommand = (overrideCommand) => buildCodexHookCommand({
-  definition: CONTEXT_PROMOTION_CODEX_HOOK,
-  overrideCommand
-});
-var inspectCodexHook = (params) => ({
-  hooksPath: params.hooksPath,
-  installed: configHasDefinitionHook(readJsonRecord(params.hooksPath), params.definition)
-});
-var inspectContextPromotionHook = (hooksPath) => ({
-  hooksPath,
-  installed: inspectCodexHook({ hooksPath, definition: CONTEXT_PROMOTION_CODEX_HOOK }).installed
-});
-var installCodexHook = (params) => {
-  const config = readJsonRecord(params.hooksPath);
-  if (configHasOnlyCurrentDefinitionHook(config, params.definition, params.command)) {
-    return {
-      hooksPath: params.hooksPath,
-      installed: true,
-      changed: false
-    };
-  }
-  const hooks = getOrCreateRecord(config, "hooks");
-  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,
-    hooks: [
-      {
-        type: "command",
-        command: params.command,
-        timeout: 30,
-        statusMessage: params.definition.statusMessage
-      }
-    ]
-  };
-  hooks[POST_TOOL_USE_EVENT] = [...existingGroups, nextGroup];
-  writeJsonRecord(params.hooksPath, config);
-  return {
-    hooksPath: params.hooksPath,
-    installed: true,
-    changed: true
-  };
-};
-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: params.hooksPath, removed: false, changed: false };
-  }
-  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: params.hooksPath, removed: false, changed: false };
-  }
-  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 join13 } from "path";
-var resolveSkillsDir = () => join13(COMPILER_DATA_DIR, "skills");
-var resolveSubagentsDir = () => join13(COMPILER_DATA_DIR, "subagents");
-var resolvePacksDir = () => join13(COMPILER_DATA_DIR, "packs");
-var resolveIntegrationsDir = () => join13(COMPILER_DATA_DIR, "integrations");
+import { join as join14 } from "path";
+var resolveSkillsDir = () => join14(COMPILER_DATA_DIR, "skills");
+var resolveSubagentsDir = () => join14(COMPILER_DATA_DIR, "subagents");
+var resolvePacksDir = () => join14(COMPILER_DATA_DIR, "packs");
+var resolveIntegrationsDir = () => join14(COMPILER_DATA_DIR, "integrations");
 var resolveBasePath = () => process.cwd();
 var resolveUserBasePath = () => {
   const userBasePath = process.env.AI_OPS_HOME ?? process.env.HOME;
@@ -3228,6 +4080,43 @@ ${result.notFound.map((file) => `  ${file}`).join("\n")}`);
   p6.outro("ai-ops uninstall \uC644\uB8CC");
 };
 
+// src/commands/studio.ts
+import { join as join15 } from "path";
+var resolveOptionalUserBasePath = () => process.env.AI_OPS_HOME ?? process.env.HOME ?? null;
+var resolveOptionalCodexHomePath = () => {
+  if (process.env.CODEX_HOME && process.env.CODEX_HOME.length > 0) {
+    return process.env.CODEX_HOME;
+  }
+  if (process.env.HOME && process.env.HOME.length > 0) {
+    return join15(process.env.HOME, ".codex");
+  }
+  return null;
+};
+var reportStudioSnapshotError = (error) => {
+  const message = error instanceof Error ? error.message : "unknown error";
+  process.stderr.write(`[studio-snapshot] ${message}
+`);
+  process.exitCode = 1;
+};
+var studioSnapshotCommand = async (opts) => {
+  if (opts.json !== true) {
+    process.stderr.write("[studio-snapshot] --json is required\n");
+    process.exitCode = 1;
+    return;
+  }
+  try {
+    const snapshot = buildStudioSnapshot({
+      basePath: resolveBasePath(),
+      userBasePath: resolveOptionalUserBasePath(),
+      codexHomePath: resolveOptionalCodexHomePath()
+    });
+    process.stdout.write(`${JSON.stringify(snapshot, null, 2)}
+`);
+  } catch (error) {
+    reportStudioSnapshotError(error);
+  }
+};
+
 // src/commands/skill.ts
 import * as p7 from "@clack/prompts";
 import { rmSync as rmSync5 } from "fs";
@@ -3264,17 +4153,17 @@ var findInstalledSkill = (installedSkills, skillId) => {
 };
 
 // src/lib/skill-install.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname10, resolve as resolve9 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync8, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname10, resolve as resolve10 } from "path";
 var installSkillPackages = (basePath, packages) => {
   const writtenRoots = [];
   for (const skillPackage of packages) {
-    const absRoot = resolve9(basePath, skillPackage.rootDir);
-    if (existsSync6(absRoot)) {
+    const absRoot = resolve10(basePath, skillPackage.rootDir);
+    if (existsSync7(absRoot)) {
       rmSync4(absRoot, { recursive: true, force: true });
     }
     for (const file of skillPackage.files) {
-      const absPath = resolve9(basePath, file.relativePath);
+      const absPath = resolve10(basePath, file.relativePath);
       mkdirSync8(dirname10(absPath), { recursive: true });
       writeFileSync8(absPath, file.content + "\n", "utf-8");
     }
@@ -3285,8 +4174,8 @@ var installSkillPackages = (basePath, packages) => {
 var removeDirectories = (basePath, relativeDirs) => {
   const removed = [];
   for (const relativeDir of relativeDirs) {
-    const absPath = resolve9(basePath, relativeDir);
-    if (!existsSync6(absPath)) continue;
+    const absPath = resolve10(basePath, relativeDir);
+    if (!existsSync7(absPath)) continue;
     rmSync4(absPath, { recursive: true, force: true });
     removed.push(relativeDir);
   }
@@ -3465,14 +4354,14 @@ var skillUninstallCommand = async (skillId) => {
 
 // src/commands/subagent.ts
 import * as p8 from "@clack/prompts";
-import { existsSync as existsSync8, rmSync as rmSync7 } from "fs";
+import { existsSync as existsSync9, rmSync as rmSync7 } from "fs";
 
 // src/lib/subagent-install.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync9, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname11, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve10 } from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync9, rmSync as rmSync6, writeFileSync as writeFileSync9 } from "fs";
+import { dirname as dirname11, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve11 } from "path";
 var resolveInsideBasePath = (basePath, relativePath) => {
-  const absBasePath = resolve10(basePath);
-  const absPath = resolve10(absBasePath, relativePath);
+  const absBasePath = resolve11(basePath);
+  const absPath = resolve11(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}`);
@@ -3484,7 +4373,7 @@ var installSubagentPackages = (basePath, packages) => {
   for (const subagentPackage of packages) {
     for (const file of subagentPackage.files) {
       const absPath = resolveInsideBasePath(basePath, file.relativePath);
-      if (existsSync7(absPath)) {
+      if (existsSync8(absPath)) {
         rmSync6(absPath, { recursive: true, force: true });
       }
       mkdirSync9(dirname11(absPath), { recursive: true });
@@ -3498,7 +4387,7 @@ var removeSubagentFiles = (basePath, relativePaths) => {
   const removed = [];
   for (const relativePath of relativePaths) {
     const absPath = resolveInsideBasePath(basePath, relativePath);
-    if (!existsSync7(absPath)) continue;
+    if (!existsSync8(absPath)) continue;
     rmSync6(absPath, { recursive: true, force: true });
     removed.push(relativePath);
   }
@@ -3560,7 +4449,7 @@ var writeUserSubagentState = (params) => {
 };
 var readInstalledSubagents = (basePath) => readSubagentManifest(resolveSubagentManifestPath(basePath))?.subagents ?? [];
 var warnMissingSkills = (requiredSkills) => {
-  const missing = requiredSkills.filter((skill) => !existsSync8(skill.path));
+  const missing = requiredSkills.filter((skill) => !existsSync9(skill.path));
   if (missing.length === 0) {
     return;
   }
@@ -3871,13 +4760,13 @@ var parseMax = (max) => {
   }
   return parsed;
 };
-var readStdin = async () => new Promise((resolve11, reject) => {
+var readStdin = async () => new Promise((resolve12, reject) => {
   let raw = "";
   process.stdin.setEncoding("utf-8");
   process.stdin.on("data", (chunk) => {
     raw += chunk;
   });
-  process.stdin.on("end", () => resolve11(raw));
+  process.stdin.on("end", () => resolve12(raw));
   process.stdin.on("error", reject);
 });
 var reportContextPromotionError = (error) => {
@@ -3978,8 +4867,8 @@ var contextPromotionPostToolUseHookCommand = async () => {
 
 // src/commands/codex-hook.ts
 import * as p11 from "@clack/prompts";
-import { existsSync as existsSync9 } from "fs";
-import { join as join14 } from "path";
+import { existsSync as existsSync10 } 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;
@@ -4017,7 +4906,7 @@ var resolveContextPromotionReviewSkill = () => {
 };
 var hasInstalledContextPromotionReviewSkill = (basePath) => {
   const installedSkill = findInstalledSkill(readInstalledSkills2(basePath), CONTEXT_PROMOTION_REVIEW_SKILL_ID);
-  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync9(join14(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
+  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync10(join16(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
 };
 var ensureContextPromotionReviewSkill = (basePath) => {
   const skill = resolveContextPromotionReviewSkill();
@@ -4031,7 +4920,7 @@ var ensureContextPromotionReviewSkill = (basePath) => {
     skill,
     requestedTools
   });
-  const alreadyInstalled = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync9(join14(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
+  const alreadyInstalled = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync10(join16(basePath, ".agents/skills/context-promotion-review/SKILL.md"));
   if (alreadyInstalled) {
     return { changed: false, installedSkill };
   }
@@ -4094,8 +4983,8 @@ var codexHookUninstallCommand = async (hookId) => {
 
 // src/commands/integration.ts
 import * as p12 from "@clack/prompts";
-import { existsSync as existsSync10, rmSync as rmSync8 } from "fs";
-import { join as join15 } from "path";
+import { existsSync as existsSync11, rmSync as rmSync8 } from "fs";
+import { join as join17 } from "path";
 var CODEX_HOOK_DEFINITIONS = [CONTEXT_PROMOTION_CODEX_HOOK, PC_CODEX_HOOK];
 var resolveCodexHomePath2 = () => {
   const codexHome = process.env.CODEX_HOME;
@@ -4168,13 +5057,13 @@ var reportIntegrationError = (error) => {
   p12.log.error(message);
   process.exitCode = 1;
 };
-var readStdin2 = async () => new Promise((resolve11, reject) => {
+var readStdin2 = async () => new Promise((resolve12, reject) => {
   let raw = "";
   process.stdin.setEncoding("utf-8");
   process.stdin.on("data", (chunk) => {
     raw += chunk;
   });
-  process.stdin.on("end", () => resolve11(raw));
+  process.stdin.on("end", () => resolve12(raw));
   process.stdin.on("error", reject);
 });
 var readInstalledSkills3 = (basePath) => (readSkillRegistry(resolveSkillRegistryPath(basePath))?.skills ?? []).map((installedSkill) => ({
@@ -4190,7 +5079,7 @@ var resolveSkillById2 = (skillId) => {
 };
 var hasInstalledCodexSkill = (params) => {
   const installedSkill = findInstalledSkill(readInstalledSkills3(params.basePath), params.skillId);
-  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync10(join15(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
+  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync11(join17(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
 };
 var writeUserSkillState2 = (params) => {
   const registryPath = resolveSkillRegistryPath(params.basePath);
@@ -4218,7 +5107,7 @@ var ensureSkillComponent = (params) => {
     skill,
     requestedTools
   });
-  const alreadyCurrent = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync10(join15(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
+  const alreadyCurrent = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync11(join17(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
   if (alreadyCurrent) {
     return {
       type: INTEGRATION_COMPONENT_TYPE.SKILL,
@@ -4480,6 +5369,8 @@ program.command("update").description("project operating layer \uAC31\uC2E0").op
 program.command("diff").description("project operating layer drift \uBE44\uAD50").action(() => diffCommand());
 program.command("audit").description("project operating layer \uC0C1\uD0DC \uAC80\uC0AC").action(() => auditCommand());
 program.command("uninstall").description("project operating layer \uC81C\uAC70").option("--yes", "\uD655\uC778 \uD504\uB86C\uD504\uD2B8 \uC5C6\uC774 \uC81C\uAC70", false).action((opts) => uninstallCommand(opts));
+var studioCommand = program.command("studio").description("ai-ops Studio read-only helpers");
+studioCommand.command("snapshot").description("Studio read-only snapshot JSON \uC0DD\uC131").requiredOption("--json", "JSON\uC73C\uB85C \uCD9C\uB825").action((opts) => studioSnapshotCommand(opts));
 var skillCommand = program.command("skill").description("\uC5D0\uC774\uC804\uD2B8 skill \uC124\uCE58/\uC870\uD68C/\uAC31\uC2E0");
 var applySkillInstallOptions = (command) => command.option("--tool <tool...>", "\uB300\uC0C1 \uB3C4\uAD6C \uC9C0\uC815");
 skillCommand.command("list").description("\uC0AC\uC6A9 \uAC00\uB2A5\uD55C skill \uBAA9\uB85D").action(() => skillListCommand());