ai-ops-cli 1.4.1 → 1.5.0

package/dist/bin/index.js

@@ -1409,12 +1409,12 @@ var buildPermissionProfileBlock = (paths, includeDefaultPermissions) => [
   `${quoteTomlString(paths.personalContextRoot)} = "write"`,
   `${quoteTomlString(join10(paths.userBasePath, ".ai-ops", "context-promotion"))} = "write"`,
   "",
-  `[permissions.${SAFE_LOCAL_CODEX_PERMISSION_NAME}.filesystem.":workspace_roots"]`,
+  `[permissions.${SAFE_LOCAL_CODEX_PERMISSION_NAME}.filesystem.":project_roots"]`,
   '"." = "write"',
   '".git" = "read"',
   '".codex" = "read"',
   '".codex/plans" = "write"',
-  '"**/*.env" = "deny"',
+  '"**/*.env" = "none"',
   "",
   `[permissions.${SAFE_LOCAL_CODEX_PERMISSION_NAME}.network]`,
   "enabled = false",
@@ -2082,13 +2082,14 @@ var pruneContextPromotionReceipts = (params) => {
 };
 
 // src/features/context-promotion/status.ts
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 import { join as join16, resolve as resolve8 } from "path";
 
 // src/features/project-layer/constants.ts
 import { join as join13 } from "path";
 var PROJECT_LAYER_MANIFEST_RELATIVE_PATH = ".ai-ops/manifest.json";
 var PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH = ".ai-ops/context-layer.json";
+var CUSTOM_PROJECT_RULES_DIR = "docs/agent/project-rules";
 var CONTEXT_LAYER_DATA_DIR = join13(COMPILER_DATA_DIR, "context-layer");
 var TOOL_ORDER2 = ["codex", "gemini", "claude-code"];
 var DEFAULT_TOOLS = TOOL_ORDER2;
@@ -2125,7 +2126,7 @@ var resolveProjectLayerManifestPath = (basePath) => join14(basePath, PROJECT_LAY
 var resolveProjectLayerContextIndexPath = (basePath) => join14(basePath, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH);
 var resolveTemplatePath = (relativePath) => join14(CONTEXT_LAYER_DATA_DIR, relativePath);
 var toRelativeDir = (relativePath) => dirname8(relativePath);
-var resolveProjectLayerFilePath2 = (basePath, relativePath) => {
+var resolveProjectLayerFilePath = (basePath, relativePath) => {
   if (!isSafeProjectLayerPath(relativePath)) {
     throw new Error(`Unsafe project layer path: ${relativePath}`);
   }
@@ -2258,18 +2259,86 @@ var loadProjectLayerTemplateSpecs = (tools) => {
 };
 var computeProjectLayerSourceHash = (specs) => computeHash(specs.map((spec) => `${spec.path}:${spec.content}`));
 
+// src/features/project-layer/custom-project-rules.ts
+import { existsSync as existsSync5, readdirSync as readdirSync3, readFileSync as readFileSync9 } from "fs";
+var isMarkdownPath = (path) => path.endsWith(".md");
+var hasMarkdownFrontmatter = (content) => content.startsWith("---\n");
+var assertCustomProjectRuleContract = (params) => {
+  if (params.owner !== "project") {
+    throw new Error(`${params.path} owner\uB294 project\uC5EC\uC57C \uD569\uB2C8\uB2E4. \uD604\uC7AC \uAC12: ${params.owner}`);
+  }
+  if (params.layer !== "agent") {
+    throw new Error(`${params.path} layer\uB294 agent\uC5EC\uC57C \uD569\uB2C8\uB2E4. \uD604\uC7AC \uAC12: ${params.layer}`);
+  }
+};
+var isCustomProjectRulePath = (path) => path.startsWith(`${CUSTOM_PROJECT_RULES_DIR}/`) && isMarkdownPath(path);
+var collectMarkdownPaths = (params) => {
+  const absoluteDir = resolveProjectLayerFilePath(params.basePath, params.relativeDir);
+  if (!existsSync5(absoluteDir)) {
+    return [];
+  }
+  return readdirSync3(absoluteDir, { withFileTypes: true }).flatMap((entry) => {
+    const relativePath = `${params.relativeDir}/${entry.name}`;
+    if (entry.isDirectory()) {
+      return collectMarkdownPaths({ basePath: params.basePath, relativeDir: relativePath });
+    }
+    return entry.isFile() && isMarkdownPath(relativePath) ? [relativePath] : [];
+  });
+};
+var discoverCustomProjectRuleFiles = (basePath) => collectMarkdownPaths({ basePath, relativeDir: CUSTOM_PROJECT_RULES_DIR }).sort((left, right) => left.localeCompare(right)).flatMap((path) => {
+  const content = readFileSync9(resolveProjectLayerFilePath(basePath, path), "utf-8");
+  if (!hasMarkdownFrontmatter(content)) {
+    return [];
+  }
+  try {
+    const document = parseProjectLayerDocument(path, content);
+    assertCustomProjectRuleContract({
+      path,
+      owner: document.owner,
+      layer: document.layer
+    });
+    return [
+      {
+        path,
+        templateHash: document.contentHash,
+        created: false
+      }
+    ];
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown error";
+    throw new Error(`${path} frontmatter \uD30C\uC2F1 \uC2E4\uD328: ${reason}`);
+  }
+});
+var syncCustomProjectRuleFiles = (params) => {
+  const customFiles = discoverCustomProjectRuleFiles(params.basePath);
+  const customPathSet = new Set(customFiles.map((file) => file.path));
+  const projectFilesByPath = /* @__PURE__ */ new Map();
+  for (const file of params.manifest.project_files) {
+    if (!isCustomProjectRulePath(file.path) || customPathSet.has(file.path)) {
+      projectFilesByPath.set(file.path, file);
+    }
+  }
+  for (const file of customFiles) {
+    projectFilesByPath.set(file.path, file);
+  }
+  return ProjectLayerManifestSchema.parse({
+    ...params.manifest,
+    project_files: [...projectFilesByPath.values()].sort((left, right) => left.path.localeCompare(right.path))
+  });
+};
+
 // src/features/project-layer/state-io.ts
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "fs";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
 import { dirname as dirname9 } from "path";
 
 // src/features/project-layer/docs-status.logic.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync6 } from "fs";
 var docsStatusIssue = (code, message) => ({
   level: "error",
   code,
   message
 });
-var computeDocsStatusFileHash = (basePath, relativePath) => computeHash([readFileSync9(resolveProjectLayerFilePath2(basePath, relativePath), "utf-8").trimEnd()]);
+var computeDocsStatusFileHash = (basePath, relativePath) => computeHash([readFileSync10(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
 var parseMarkdownTableCells = (line) => {
   const trimmed = line.trim();
   if (!trimmed.startsWith("|") || !trimmed.endsWith("|")) {
@@ -2319,7 +2388,7 @@ var parseDocsStatusEntries = (content) => {
   });
 };
 var buildDocsStatusRowsFromDisk = (params) => params.documentPaths.map((path) => {
-  const document = parseProjectLayerDocument(path, readFileSync9(resolveProjectLayerFilePath2(params.basePath, path), "utf-8"));
+  const document = parseProjectLayerDocument(path, readFileSync10(resolveProjectLayerFilePath(params.basePath, path), "utf-8"));
   return `| ${document.path} | ${document.status} | ${document.owner} |`;
 });
 var replaceDocsStatusRows = (content, rows) => {
@@ -2332,10 +2401,10 @@ var replaceDocsStatusRows = (content, rows) => {
 };
 var updateDocsStatusTable = (basePath, documentPaths) => {
   const docsStatusPath = "docs/docs-status.md";
-  const absolutePath = resolveProjectLayerFilePath2(basePath, docsStatusPath);
+  const absolutePath = resolveProjectLayerFilePath(basePath, docsStatusPath);
   const beforeHash = computeDocsStatusFileHash(basePath, docsStatusPath);
   const rows = buildDocsStatusRowsFromDisk({ basePath, documentPaths });
-  const nextContent = replaceDocsStatusRows(readFileSync9(absolutePath, "utf-8"), rows);
+  const nextContent = replaceDocsStatusRows(readFileSync10(absolutePath, "utf-8"), rows);
   writeFileSync6(absolutePath, nextContent, "utf-8");
   return {
     beforeHash,
@@ -2372,7 +2441,7 @@ var compareDocsStatusEntry = (params) => {
 // src/features/project-layer/state-io.ts
 var readProjectLayerManifest = (basePath) => {
   try {
-    return parseProjectLayerManifest(readFileSync10(resolveProjectLayerManifestPath(basePath), "utf-8"));
+    return parseProjectLayerManifest(readFileSync11(resolveProjectLayerManifestPath(basePath), "utf-8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -2387,7 +2456,7 @@ var writeProjectLayerManifest = (basePath, manifest) => {
 };
 var readProjectLayerContextIndex = (basePath) => {
   try {
-    return parseProjectLayerContextIndex(readFileSync10(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
+    return parseProjectLayerContextIndex(readFileSync11(resolveProjectLayerContextIndexPath(basePath), "utf-8"));
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT") {
       return null;
@@ -2402,7 +2471,7 @@ var writeProjectLayerContextIndex = (basePath, contextIndex) => {
 };
 var buildContextIndexFromDisk = (params) => {
   const documents = params.documentPaths.map(
-    (path) => parseProjectLayerDocument(path, readFileSync10(resolveProjectLayerFilePath2(params.basePath, path), "utf-8"))
+    (path) => parseProjectLayerDocument(path, readFileSync11(resolveProjectLayerFilePath(params.basePath, path), "utf-8"))
   );
   return ProjectLayerContextIndexSchema.parse({
     schemaVersion: 1,
@@ -2417,10 +2486,14 @@ var collectDocumentPathsFromManifest = (manifest) => [
   ...manifest.packs.flatMap((pack) => pack.documents.map((file) => file.path))
 ].sort();
 var refreshProjectLayerDerivedState = (params) => {
-  const documentPaths = collectDocumentPathsFromManifest(params.manifest);
+  const manifestWithCustomRules = syncCustomProjectRuleFiles({
+    basePath: params.basePath,
+    manifest: params.manifest
+  });
+  const documentPaths = collectDocumentPathsFromManifest(manifestWithCustomRules);
   const docsStatusHashes = updateDocsStatusTable(params.basePath, documentPaths);
   const manifest = updateDocsStatusProjectFileRecord({
-    manifest: params.manifest,
+    manifest: manifestWithCustomRules,
     beforeHash: docsStatusHashes.beforeHash,
     afterHash: docsStatusHashes.afterHash
   });
@@ -2437,17 +2510,17 @@ var refreshProjectLayerDerivedState = (params) => {
 };
 
 // src/features/project-layer/lifecycle.logic.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync7, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "fs";
 import { dirname as dirname10 } from "path";
 
 // src/features/project-layer/uninstall.logic.ts
-import { existsSync as existsSync5, readFileSync as readFileSync11, readdirSync as readdirSync3, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "fs";
+import { existsSync as existsSync6, readFileSync as readFileSync12, readdirSync as readdirSync4, rmSync as rmSync2, writeFileSync as writeFileSync8 } from "fs";
 function removeManagedProjectFile(basePath, relativePath) {
-  const absolutePath = resolveProjectLayerFilePath2(basePath, relativePath);
-  if (!existsSync5(absolutePath)) {
+  const absolutePath = resolveProjectLayerFilePath(basePath, relativePath);
+  if (!existsSync6(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [relativePath] };
   }
-  const content = readFileSync11(absolutePath, "utf-8");
+  const content = readFileSync12(absolutePath, "utf-8");
   if (!hasAiOpsSection(content)) {
     return { deleted: [], cleaned: [], preserved: [relativePath], notFound: [] };
   }
@@ -2460,11 +2533,11 @@ function removeManagedProjectFile(basePath, relativePath) {
   return { deleted: [], cleaned: [relativePath], preserved: [], notFound: [] };
 }
 var removeCreateOnlyProjectFile = (basePath, file) => {
-  const absolutePath = resolveProjectLayerFilePath2(basePath, file.path);
-  if (!existsSync5(absolutePath)) {
+  const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+  if (!existsSync6(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
   }
-  const content = readFileSync11(absolutePath, "utf-8").trimEnd();
+  const content = readFileSync12(absolutePath, "utf-8").trimEnd();
   const currentHash = computeHash([content]);
   if (file.created && currentHash === file.templateHash) {
     rmSync2(absolutePath);
@@ -2473,11 +2546,11 @@ var removeCreateOnlyProjectFile = (basePath, file) => {
   return { deleted: [], cleaned: [], preserved: [file.path], notFound: [] };
 };
 var removePackOwnedFile = (basePath, file) => {
-  const absolutePath = resolveProjectLayerFilePath2(basePath, file.path);
-  if (!existsSync5(absolutePath)) {
+  const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+  if (!existsSync6(absolutePath)) {
     return { deleted: [], cleaned: [], preserved: [], notFound: [file.path] };
   }
-  const currentHash = computeHash([readFileSync11(absolutePath, "utf-8").trimEnd()]);
+  const currentHash = computeHash([readFileSync12(absolutePath, "utf-8").trimEnd()]);
   if (currentHash === file.sourceHash) {
     rmSync2(absolutePath);
     return { deleted: [file.path], cleaned: [], preserved: [], notFound: [] };
@@ -2495,10 +2568,10 @@ var removeEmptyDirs = (basePath, relativePaths) => {
     (a, b) => b.length - a.length
   );
   for (const dir of [...dirs, ".ai-ops"]) {
-    const absoluteDir = resolveProjectLayerFilePath2(basePath, dir);
-    if (!existsSync5(absoluteDir)) continue;
+    const absoluteDir = resolveProjectLayerFilePath(basePath, dir);
+    if (!existsSync6(absoluteDir)) continue;
     try {
-      if (readdirSync3(absoluteDir).length === 0) {
+      if (readdirSync4(absoluteDir).length === 0) {
         rmSync2(absoluteDir, { recursive: true });
       }
     } catch {
@@ -2513,7 +2586,7 @@ var uninstallProjectLayer = (basePath, manifest) => {
   );
   const stateFiles = [PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH, PROJECT_LAYER_MANIFEST_RELATIVE_PATH];
   for (const stateFile of stateFiles) {
-    rmSync2(resolveProjectLayerFilePath2(basePath, stateFile), { force: true });
+    rmSync2(resolveProjectLayerFilePath(basePath, stateFile), { force: true });
   }
   const result = mergeRemoveResults([...managedResults, ...projectResults, ...packResults]);
   removeEmptyDirs(basePath, [...result.deleted, ...stateFiles]);
@@ -2525,15 +2598,15 @@ var installManagedFiles = (basePath, specs, meta) => {
   const written = [];
   const appended = [];
   for (const spec of specs) {
-    const absolutePath = resolveProjectLayerFilePath2(basePath, spec.path);
+    const absolutePath = resolveProjectLayerFilePath(basePath, spec.path);
     const wrappedContent = wrapWithSection(spec.content, meta);
-    if (!existsSync6(absolutePath)) {
+    if (!existsSync7(absolutePath)) {
       mkdirSync7(dirname10(absolutePath), { recursive: true });
       writeFileSync9(absolutePath, wrappedContent + "\n", "utf-8");
       written.push(spec.path);
       continue;
     }
-    const existing = readFileSync12(absolutePath, "utf-8");
+    const existing = readFileSync13(absolutePath, "utf-8");
     if (hasAiOpsSection(existing)) {
       writeFileSync9(absolutePath, replaceAiOpsSection(existing, wrappedContent), "utf-8");
       const stripped = stripAiOpsSection(existing);
@@ -2557,9 +2630,9 @@ var installProjectFiles = (params) => {
   const preserved = [];
   const previousByPath = new Map((params.previousProjectFiles ?? []).map((file) => [file.path, file]));
   for (const spec of params.specs) {
-    const absolutePath = resolveProjectLayerFilePath2(params.basePath, spec.path);
+    const absolutePath = resolveProjectLayerFilePath(params.basePath, spec.path);
     const previous = previousByPath.get(spec.path);
-    if (!existsSync6(absolutePath)) {
+    if (!existsSync7(absolutePath)) {
       mkdirSync7(dirname10(absolutePath), { recursive: true });
       writeFileSync9(absolutePath, spec.content + "\n", "utf-8");
       created.push(spec.path);
@@ -2570,7 +2643,7 @@ var installProjectFiles = (params) => {
       });
       continue;
     }
-    const existingContent = readFileSync12(absolutePath, "utf-8").trimEnd();
+    const existingContent = readFileSync13(absolutePath, "utf-8").trimEnd();
     const existingHash = computeHash([existingContent]);
     if (previous?.created === true && existingHash === previous.templateHash) {
       if (existingHash !== spec.contentHash) {
@@ -2704,7 +2777,7 @@ var updateProjectLayer = (params) => {
 };
 
 // src/features/project-layer/audit.logic.ts
-import { existsSync as existsSync7, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync14 } from "fs";
 var issue = (level, code, message) => ({
   level,
   code,
@@ -2712,11 +2785,11 @@ var issue = (level, code, message) => ({
 });
 var readDocumentSafely = (basePath, path) => {
   try {
-    const absolutePath = resolveProjectLayerFilePath2(basePath, path);
-    if (!existsSync7(absolutePath)) {
+    const absolutePath = resolveProjectLayerFilePath(basePath, path);
+    if (!existsSync8(absolutePath)) {
       return issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${path}`);
     }
-    return parseProjectLayerDocument(path, readFileSync13(absolutePath, "utf-8"));
+    return parseProjectLayerDocument(path, readFileSync14(absolutePath, "utf-8"));
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown error";
     return issue("error", "invalid-frontmatter", `${path} frontmatter \uD30C\uC2F1 \uC2E4\uD328: ${reason}`);
@@ -2724,6 +2797,10 @@ var readDocumentSafely = (basePath, path) => {
 };
 var buildContextIndexMap = (contextIndex) => new Map((contextIndex?.documents ?? []).map((document) => [document.path, document]));
 var compareArray = (left, right) => left.length === right.length && left.every((value, index) => value === right[index]);
+var compareProjectFileRecords = (left, right) => left.length === right.length && left.every((file, index) => {
+  const other = right[index];
+  return other !== void 0 && file.path === other.path && file.templateHash === other.templateHash && file.created === other.created;
+});
 var compareContextDocument = (params) => {
   const indexed = params.indexed;
   if (indexed === void 0) {
@@ -2767,6 +2844,13 @@ var diffProjectLayer = (basePath) => {
   const currentSourceHash = computeProjectLayerSourceHash(specs);
   let contextIndex = null;
   const issues = [];
+  let syncedManifest = manifest;
+  try {
+    syncedManifest = syncCustomProjectRuleFiles({ basePath, manifest });
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : "unknown error";
+    issues.push(issue("error", "invalid-custom-project-rule", reason));
+  }
   try {
     contextIndex = readProjectLayerContextIndex(basePath);
   } catch (error) {
@@ -2786,18 +2870,27 @@ var diffProjectLayer = (basePath) => {
   if (contextIndex === null) {
     issues.push(issue("error", "missing-context-index", `${PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH}\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4.`));
   }
+  if (!compareProjectFileRecords(manifest.project_files, syncedManifest.project_files)) {
+    issues.push(
+      issue(
+        "warning",
+        "custom-project-rules-drift",
+        "`docs/agent/project-rules/**/*.md` discovery \uACB0\uACFC\uAC00 manifest\uC640 \uB2E4\uB985\uB2C8\uB2E4. `ai-ops update`\uB85C \uB3D9\uAE30\uD654\uD558\uC138\uC694."
+      )
+    );
+  }
   for (const expectedPath of expectedManagedPaths) {
     if (!manifestManagedPaths.has(expectedPath)) {
       issues.push(issue("error", "manifest-missing-managed-file", `manifest managed_files \uB204\uB77D: ${expectedPath}`));
     }
   }
   for (const file of manifest.managed_files) {
-    const absolutePath = resolveProjectLayerFilePath2(basePath, file.path);
-    if (!existsSync7(absolutePath)) {
+    const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+    if (!existsSync8(absolutePath)) {
       issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       continue;
     }
-    const content = readFileSync13(absolutePath, "utf-8");
+    const content = readFileSync14(absolutePath, "utf-8");
     const meta = parseAiOpsMeta(content);
     if (!meta) {
       issues.push(issue("error", "missing-managed-section", `managed section \uBA54\uD0C0 \uC5C6\uC74C: ${file.path}`));
@@ -2809,19 +2902,19 @@ var diffProjectLayer = (basePath) => {
       );
     }
   }
-  for (const file of manifest.project_files) {
-    if (!existsSync7(resolveProjectLayerFilePath2(basePath, file.path))) {
+  for (const file of syncedManifest.project_files) {
+    if (!existsSync8(resolveProjectLayerFilePath(basePath, file.path))) {
       issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
     }
   }
-  for (const pack of manifest.packs) {
+  for (const pack of syncedManifest.packs) {
     for (const file of [...pack.documents, ...pack.files]) {
-      if (!existsSync7(resolveProjectLayerFilePath2(basePath, file.path))) {
+      if (!existsSync8(resolveProjectLayerFilePath(basePath, file.path))) {
         issues.push(issue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       }
     }
   }
-  for (const path of collectDocumentPathsFromManifest(manifest)) {
+  for (const path of collectDocumentPathsFromManifest(syncedManifest)) {
     const document = readDocumentSafely(basePath, path);
     if ("code" in document) {
       issues.push(document);
@@ -2848,18 +2941,24 @@ var auditProjectLayer = (basePath) => {
   } catch {
     contextIndex = null;
   }
-  const documentPaths = collectDocumentPathsFromManifest(manifest);
+  let syncedManifest = manifest;
+  try {
+    syncedManifest = syncCustomProjectRuleFiles({ basePath, manifest });
+  } catch {
+    return diffReport;
+  }
+  const documentPaths = collectDocumentPathsFromManifest(syncedManifest);
   const documentPathSet = new Set(documentPaths);
   const contextPathSet = new Set(contextIndex?.documents.map((document) => document.path) ?? []);
   const issues = [...diffReport.issues];
-  const docsStatusPath = resolveProjectLayerFilePath2(basePath, "docs/docs-status.md");
-  if (!existsSync7(docsStatusPath)) {
+  const docsStatusPath = resolveProjectLayerFilePath(basePath, "docs/docs-status.md");
+  if (!existsSync8(docsStatusPath)) {
     issues.push(issue("error", "missing-docs-status", "docs/docs-status.md\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4."));
     return { currentSourceHash: diffReport.currentSourceHash, issues };
   }
   let docsStatusEntries = [];
   try {
-    docsStatusEntries = parseDocsStatusEntries(readFileSync13(docsStatusPath, "utf-8"));
+    docsStatusEntries = parseDocsStatusEntries(readFileSync14(docsStatusPath, "utf-8"));
   } catch (error) {
     const reason = error instanceof Error ? error.message : "unknown error";
     issues.push(issue("error", "invalid-docs-status", `docs/docs-status.md \uD30C\uC2F1 \uC2E4\uD328: ${reason}`));
@@ -2886,11 +2985,11 @@ var auditProjectLayer = (basePath) => {
 };
 
 // src/features/project-layer/pack.logic.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync8, readFileSync as readFileSync15, readdirSync as readdirSync5, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync8, readFileSync as readFileSync16, readdirSync as readdirSync6, rmSync as rmSync3, writeFileSync as writeFileSync10 } from "fs";
 import { dirname as dirname11 } from "path";
 
 // src/features/project-layer/pack-source.logic.ts
-import { readFileSync as readFileSync14, readdirSync as readdirSync4 } from "fs";
+import { readFileSync as readFileSync15, readdirSync as readdirSync5 } from "fs";
 import { isAbsolute as isAbsolute2, join as join15, relative as relative2, resolve as resolve7 } from "path";
 var PACK_REGISTRY_FILENAME = "pack-registry.json";
 var SPEC_LIFECYCLE_PACK_ID = "spec-lifecycle";
@@ -2901,7 +3000,7 @@ var RESERVED_DOCUMENT_WARNINGS2 = [
 ];
 var DEFAULT_PACKS_DIR = join15(COMPILER_DATA_DIR, "packs");
 var includesReservedDocumentWarning2 = (content) => RESERVED_DOCUMENT_WARNINGS2.some((warning) => content.includes(warning));
-var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync14(join15(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
+var readPackCatalog = (packsDir) => PackCatalogSchema.parse(JSON.parse(readFileSync15(join15(packsDir, PACK_REGISTRY_FILENAME), "utf-8")));
 var assertPackInstallPath = (path) => {
   if (!isSafeProjectLayerPath(path) || !path.startsWith(PACK_INSTALL_ROOT)) {
     throw new Error(`Unsafe pack path: ${path}`);
@@ -2911,7 +3010,7 @@ var readPackSourceFiles = (packDir) => {
   const files = [];
   const walk = (relativeDir = "") => {
     const absoluteDir = relativeDir.length > 0 ? join15(packDir, relativeDir) : packDir;
-    const entries = readdirSync4(absoluteDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    const entries = readdirSync5(absoluteDir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       const nextRelativePath = relativeDir.length > 0 ? join15(relativeDir, entry.name) : entry.name;
       if (entry.isDirectory()) {
@@ -2919,7 +3018,7 @@ var readPackSourceFiles = (packDir) => {
         continue;
       }
       assertPackInstallPath(nextRelativePath);
-      const content = readFileSync14(join15(packDir, nextRelativePath), "utf-8");
+      const content = readFileSync15(join15(packDir, nextRelativePath), "utf-8");
       files.push({
         path: nextRelativePath,
         content,
@@ -2979,9 +3078,9 @@ var resolvePackById = (packsDir, packId) => {
 
 // src/features/project-layer/pack.logic.ts
 var serializePackFileContent = (content) => content.length === 0 ? "" : content.trimEnd() + "\n";
-var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync15(resolveProjectLayerFilePath2(basePath, relativePath), "utf-8").trimEnd()]);
+var readProjectFileHash = (basePath, relativePath) => computeHash([readFileSync16(resolveProjectLayerFilePath(basePath, relativePath), "utf-8").trimEnd()]);
 var writePackFile = (basePath, file) => {
-  const absolutePath = resolveProjectLayerFilePath2(basePath, file.path);
+  const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
   mkdirSync8(dirname11(absolutePath), { recursive: true });
   writeFileSync10(absolutePath, serializePackFileContent(file.content), "utf-8");
 };
@@ -3011,9 +3110,9 @@ var applyPackSourceFiles = (params) => {
     ])
   );
   for (const file of sourceFiles) {
-    const absolutePath = resolveProjectLayerFilePath2(params.basePath, file.path);
+    const absolutePath = resolveProjectLayerFilePath(params.basePath, file.path);
     const previous = previousByPath.get(file.path);
-    if (!existsSync8(absolutePath)) {
+    if (!existsSync9(absolutePath)) {
       writePackFile(params.basePath, file);
       written.push(file.path);
       continue;
@@ -3036,8 +3135,8 @@ var applyPackSourceFiles = (params) => {
     if (sourceByPath.has(previous.path)) {
       continue;
     }
-    const absolutePath = resolveProjectLayerFilePath2(params.basePath, previous.path);
-    if (!existsSync8(absolutePath)) {
+    const absolutePath = resolveProjectLayerFilePath(params.basePath, previous.path);
+    if (!existsSync9(absolutePath)) {
       notFound.push(previous.path);
       continue;
     }
@@ -3055,8 +3154,8 @@ var removePackFiles = (basePath, record) => {
   const preserved = [];
   const notFound = [];
   for (const file of [...record.documents, ...record.files]) {
-    const absolutePath = resolveProjectLayerFilePath2(basePath, file.path);
-    if (!existsSync8(absolutePath)) {
+    const absolutePath = resolveProjectLayerFilePath(basePath, file.path);
+    if (!existsSync9(absolutePath)) {
       notFound.push(file.path);
       continue;
     }
@@ -3074,12 +3173,12 @@ var removeEmptyDirs2 = (basePath, relativePaths) => {
     (a, b) => b.length - a.length
   );
   for (const dir of dirs) {
-    const absoluteDir = resolveProjectLayerFilePath2(basePath, dir);
-    if (!existsSync8(absoluteDir)) {
+    const absoluteDir = resolveProjectLayerFilePath(basePath, dir);
+    if (!existsSync9(absoluteDir)) {
       continue;
     }
     try {
-      if (readdirSync5(absoluteDir).length === 0) {
+      if (readdirSync6(absoluteDir).length === 0) {
         rmSync3(absoluteDir, { recursive: true });
       }
     } catch {
@@ -3190,8 +3289,8 @@ var diffProjectLayerPack = (params) => {
       );
     }
     for (const file of [...record.documents, ...record.files]) {
-      const absolutePath = resolveProjectLayerFilePath2(params.basePath, file.path);
-      if (!existsSync8(absolutePath)) {
+      const absolutePath = resolveProjectLayerFilePath(params.basePath, file.path);
+      if (!existsSync9(absolutePath)) {
         issues.push(packIssue("error", "missing-file", `\uD30C\uC77C \uC5C6\uC74C: ${file.path}`));
       }
     }
@@ -3200,7 +3299,7 @@ var diffProjectLayerPack = (params) => {
 };
 
 // src/features/context-promotion/status.ts
-var hasContextPromotionLayer = (gitRoot) => existsSync9(join16(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
+var hasContextPromotionLayer = (gitRoot) => existsSync10(join16(gitRoot, PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH));
 var getContextPromotionStatus = (params) => {
   const cwd = resolve8(params.cwd);
   const gitRoot = resolveContextPromotionGitRoot(cwd);
@@ -3528,11 +3627,11 @@ import * as p5 from "@clack/prompts";
 
 // src/features/pc/status.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync10, readdirSync as readdirSync6 } from "fs";
+import { existsSync as existsSync11, readdirSync as readdirSync7 } from "fs";
 import { join as join17, resolve as resolve10, sep as sep2 } from "path";
 
 // src/features/pc/markdown.ts
-import { readFileSync as readFileSync16 } from "fs";
+import { readFileSync as readFileSync17 } from "fs";
 import { resolve as resolve9, sep } from "path";
 var normalizePath = (path) => resolve9(path.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"));
 var pathContains = (parentPath, childPath) => {
@@ -3571,7 +3670,7 @@ var parseListField = (content, labels) => {
 };
 var readTextFileOrNull = (filePath) => {
   try {
-    return readFileSync16(filePath, "utf-8");
+    return readFileSync17(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -3599,10 +3698,10 @@ var readGitHead2 = (cwd) => {
 };
 var listWorkspaceStatePaths = (contextRoot) => {
   const workspacesDir = join17(contextRoot, "workspaces");
-  if (!existsSync10(workspacesDir)) {
+  if (!existsSync11(workspacesDir)) {
     return [];
   }
-  return readdirSync6(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join17(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync10(statePath)).sort((a, b) => a.localeCompare(b));
+  return readdirSync7(workspacesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => join17(workspacesDir, entry.name, "workspace-state.md")).filter((statePath) => existsSync11(statePath)).sort((a, b) => a.localeCompare(b));
 };
 var parseWorkspaceCandidate = (statePath) => {
   const content = readTextFileOrNull(statePath);
@@ -3646,10 +3745,10 @@ var parseRepoEntry = (entryPath) => {
 };
 var findCurrentEntry = (params) => {
   const reposDir = join17(params.workspaceDir, "repos");
-  if (!existsSync10(reposDir)) {
+  if (!existsSync11(reposDir)) {
     return null;
   }
-  const entries = readdirSync6(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join17(reposDir, entry.name))).filter((entry) => entry !== null).filter((entry) => {
+  const entries = readdirSync7(reposDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".md")).map((entry) => parseRepoEntry(join17(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) => {
@@ -3701,7 +3800,7 @@ var parseLastConfirmedCommitHash = (params) => {
 var getPcHandoffStatus = (params) => {
   const cwd = normalizePath(params.cwd);
   const contextRoot = normalizePath(params.contextRoot);
-  if (!existsSync10(contextRoot)) {
+  if (!existsSync11(contextRoot)) {
     return {
       cwd,
       contextRoot,
@@ -3864,7 +3963,7 @@ var evaluatePcPostToolUseHook = (params) => {
 };
 
 // src/features/integrations/manifest-io.ts
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync17, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync18, rmSync as rmSync4, writeFileSync as writeFileSync11 } from "fs";
 import { dirname as dirname12, join as join18 } from "path";
 var INTEGRATION_MANIFEST_FILENAME = "integrations-manifest.json";
 var parseIntegrationManifest = (json) => IntegrationManifestSchema.parse(JSON.parse(json));
@@ -3873,7 +3972,7 @@ var resolveIntegrationManifestPath = (userBasePath) => join18(userBasePath, ".ai
 var readIntegrationManifest = (manifestPath) => {
   let raw;
   try {
-    raw = readFileSync17(manifestPath, "utf-8");
+    raw = readFileSync18(manifestPath, "utf-8");
   } catch {
     return null;
   }
@@ -3906,7 +4005,7 @@ var writeUserIntegrationState = (params) => {
 };
 
 // src/features/integrations/components.ts
-import { existsSync as existsSync11, rmSync as rmSync5 } from "fs";
+import { existsSync as existsSync12, rmSync as rmSync5 } from "fs";
 import { join as join19 } from "path";
 var readInstalledSkills2 = (basePath) => (readSkillRegistry(resolveSkillRegistryPath(basePath))?.skills ?? []).map((installedSkill) => ({
   ...installedSkill,
@@ -3921,7 +4020,7 @@ var resolveSkillById = (skillId) => {
 };
 var hasInstalledCodexSkill = (params) => {
   const installedSkill = findInstalledSkill(readInstalledSkills2(params.basePath), params.skillId);
-  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync11(join19(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
+  return installedSkill?.tools.includes(SKILL_TOOL.CODEX) === true && existsSync12(join19(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
 };
 var writeUserSkillState = (params) => {
   const registryPath = resolveSkillRegistryPath(params.basePath);
@@ -3949,7 +4048,7 @@ var ensureSkillComponent = (params) => {
     skill,
     requestedTools
   });
-  const alreadyCurrent = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync11(join19(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
+  const alreadyCurrent = existingInstalledSkill?.sourceHash === installedSkill.sourceHash && existingInstalledSkill.tools.includes(SKILL_TOOL.CODEX) && existsSync12(join19(params.basePath, ".agents/skills", params.skillId, "SKILL.md"));
   if (alreadyCurrent) {
     return {
       type: INTEGRATION_COMPONENT_TYPE.SKILL,
@@ -4884,7 +4983,7 @@ var registerSkillCommands = (program) => {
 import { join as join23 } from "path";
 
 // src/features/studio/project-snapshot.ts
-import { existsSync as existsSync12, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync13, readFileSync as readFileSync19 } from "fs";
 import { resolve as resolve11 } from "path";
 import { z as z14 } from "zod";
 
@@ -4951,7 +5050,9 @@ var AUDIT_ISSUE_SOURCES_BY_CODE = {
   "invalid-frontmatter": "frontmatter",
   "missing-managed-section": "managed-section",
   "source-hash-drift": "source-hash",
-  "managed-source-hash-drift": "source-hash"
+  "managed-source-hash-drift": "source-hash",
+  "invalid-custom-project-rule": "frontmatter",
+  "custom-project-rules-drift": "manifest"
 };
 var AUDIT_ISSUE_ACTION_LABELS_BY_SOURCE = {
   manifest: "Review manifest record",
@@ -4998,6 +5099,10 @@ var extractTrailingIssuePath = (message) => {
   const [firstToken] = trailingSegment.trim().split(/\s+/);
   return firstToken === void 0 ? null : parsePathLikeToken(firstToken);
 };
+var extractLeadingIssuePath = (message) => {
+  const [firstToken] = message.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") {
@@ -5012,6 +5117,9 @@ var resolveIssueAffectedPath = (params) => {
   if (params.issue.code === "source-hash-drift") {
     return null;
   }
+  if (params.issue.code === "invalid-custom-project-rule") {
+    return extractLeadingIssuePath(params.issue.message);
+  }
   const knownPath = findKnownPathInMessage(params.issue.message, params.knownPaths);
   if (knownPath !== null) {
     return knownPath;
@@ -5051,7 +5159,7 @@ var RecoverableContextIndexSchema = z14.object({
 });
 var readProjectManifestSnapshot = (basePath) => {
   const manifestPath = resolveProjectLayerManifestPath(basePath);
-  if (!existsSync12(manifestPath)) {
+  if (!existsSync13(manifestPath)) {
     return {
       source: createMissingSourceState(PROJECT_LAYER_MANIFEST_RELATIVE_PATH),
       manifest: null
@@ -5082,14 +5190,14 @@ var readProjectManifestSnapshot = (basePath) => {
 };
 var readProjectContextIndexSnapshot = (basePath) => {
   const contextIndexPath = resolveProjectLayerContextIndexPath(basePath);
-  if (!existsSync12(contextIndexPath)) {
+  if (!existsSync13(contextIndexPath)) {
     return {
       source: createMissingSourceState(PROJECT_LAYER_CONTEXT_INDEX_RELATIVE_PATH),
       contextIndex: null
     };
   }
   try {
-    const parsedJson = JSON.parse(readFileSync18(contextIndexPath, "utf-8"));
+    const parsedJson = JSON.parse(readFileSync19(contextIndexPath, "utf-8"));
     const strictContextIndex = ProjectLayerContextIndexSchema.safeParse(parsedJson);
     if (strictContextIndex.success) {
       return {
@@ -5146,12 +5254,12 @@ var readProjectContextIndexSnapshot = (basePath) => {
   }
 };
 var readDocsStatusSourceState = (basePath) => {
-  const docsStatusPath = resolveProjectLayerFilePath2(basePath, DOCS_STATUS_RELATIVE_PATH);
-  if (!existsSync12(docsStatusPath)) {
+  const docsStatusPath = resolveProjectLayerFilePath(basePath, DOCS_STATUS_RELATIVE_PATH);
+  if (!existsSync13(docsStatusPath)) {
     return createMissingSourceState(DOCS_STATUS_RELATIVE_PATH);
   }
   try {
-    parseProjectLayerDocument(DOCS_STATUS_RELATIVE_PATH, readFileSync18(docsStatusPath, "utf-8"));
+    parseProjectLayerDocument(DOCS_STATUS_RELATIVE_PATH, readFileSync19(docsStatusPath, "utf-8"));
     return buildSourceState({
       path: DOCS_STATUS_RELATIVE_PATH,
       exists: true,
@@ -5182,7 +5290,7 @@ var buildDocumentReadError = (code, message) => `${code}: ${message}`;
 var buildProjectDocumentSnapshot = (params) => {
   let absolutePath;
   try {
-    absolutePath = resolveProjectLayerFilePath2(params.basePath, params.indexed.path);
+    absolutePath = resolveProjectLayerFilePath(params.basePath, params.indexed.path);
   } catch (error) {
     return {
       path: params.indexed.path,
@@ -5200,7 +5308,7 @@ var buildProjectDocumentSnapshot = (params) => {
       readError: buildDocumentReadError("unsafe-path", getErrorMessage(error))
     };
   }
-  if (!existsSync12(absolutePath)) {
+  if (!existsSync13(absolutePath)) {
     return {
       path: params.indexed.path,
       status: params.indexed.status,
@@ -5218,7 +5326,7 @@ var buildProjectDocumentSnapshot = (params) => {
     };
   }
   try {
-    const document = parseProjectLayerDocument(params.indexed.path, readFileSync18(absolutePath, "utf-8"));
+    const document = parseProjectLayerDocument(params.indexed.path, readFileSync19(absolutePath, "utf-8"));
     return {
       path: params.indexed.path,
       status: params.indexed.status,
@@ -5309,11 +5417,11 @@ var buildProjectSnapshot = (basePath) => {
 };
 
 // src/features/studio/runtime-snapshot.ts
-import { existsSync as existsSync13, readFileSync as readFileSync20 } from "fs";
+import { existsSync as existsSync14, readFileSync as readFileSync21 } from "fs";
 import { join as join22 } from "path";
 
 // src/features/subagents/manifest-io.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync19, writeFileSync as writeFileSync12 } from "fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync20, writeFileSync as writeFileSync12 } from "fs";
 import { dirname as dirname13, join as join21 } from "path";
 var SUBAGENT_MANIFEST_FILENAME = "subagents-manifest.json";
 var parseSubagentManifest = (json) => SubagentManifestSchema.parse(JSON.parse(json));
@@ -5322,7 +5430,7 @@ var resolveSubagentManifestPath = (userBasePath) => join21(userBasePath, ".ai-op
 var readSubagentManifest = (manifestPath) => {
   let raw;
   try {
-    raw = readFileSync19(manifestPath, "utf-8");
+    raw = readFileSync20(manifestPath, "utf-8");
   } catch {
     return null;
   }
@@ -5352,7 +5460,7 @@ var readRuntimeManifest = (params) => {
       value: null
     };
   }
-  if (!existsSync13(params.manifestPath)) {
+  if (!existsSync14(params.manifestPath)) {
     return {
       source: createMissingSourceState(params.manifestPath),
       value: null
@@ -5390,11 +5498,11 @@ var readHooksSourceState = (codexHomePath, unavailableReason) => {
     });
   }
   const hooksPath = resolveCodexHooksPath(codexHomePath);
-  if (!existsSync13(hooksPath)) {
+  if (!existsSync14(hooksPath)) {
     return createMissingSourceState(hooksPath);
   }
   try {
-    const parsed = JSON.parse(readFileSync20(hooksPath, "utf-8"));
+    const parsed = JSON.parse(readFileSync21(hooksPath, "utf-8"));
     if (!isJsonRecord4(parsed)) {
       return buildSourceState({
         path: hooksPath,
@@ -5455,7 +5563,7 @@ var buildInstalledPathStates = (params) => {
   }
   return params.installedPaths.map((path) => ({
     path,
-    exists: existsSync13(join22(params.userBasePath ?? "", path))
+    exists: existsSync14(join22(params.userBasePath ?? "", path))
   }));
 };
 var buildInstalledSkillMap = (installedSkills) => new Map(
@@ -5659,7 +5767,7 @@ var registerStudioCommands = (program) => {
 
 // src/features/subagents/commands.ts
 import * as p14 from "@clack/prompts";
-import { existsSync as existsSync15, rmSync as rmSync8 } from "fs";
+import { existsSync as existsSync16, rmSync as rmSync8 } from "fs";
 
 // src/features/subagents/renderer.ts
 import { resolve as resolve12 } from "path";
@@ -5782,7 +5890,7 @@ var buildSubagentInstallPlan = (params) => {
 };
 
 // src/features/subagents/install-files.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync11, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync11, rmSync as rmSync7, writeFileSync as writeFileSync13 } from "fs";
 import { dirname as dirname14, isAbsolute as isAbsolute3, relative as relative3, resolve as resolve13 } from "path";
 var resolveInsideBasePath = (basePath, relativePath) => {
   const absBasePath = resolve13(basePath);
@@ -5798,7 +5906,7 @@ var installSubagentPackages = (basePath, packages) => {
   for (const subagentPackage of packages) {
     for (const file of subagentPackage.files) {
       const absPath = resolveInsideBasePath(basePath, file.relativePath);
-      if (existsSync14(absPath)) {
+      if (existsSync15(absPath)) {
         rmSync7(absPath, { recursive: true, force: true });
       }
       mkdirSync11(dirname14(absPath), { recursive: true });
@@ -5812,7 +5920,7 @@ var removeSubagentFiles = (basePath, relativePaths) => {
   const removed = [];
   for (const relativePath of relativePaths) {
     const absPath = resolveInsideBasePath(basePath, relativePath);
-    if (!existsSync14(absPath)) continue;
+    if (!existsSync15(absPath)) continue;
     rmSync7(absPath, { recursive: true, force: true });
     removed.push(relativePath);
   }
@@ -5874,7 +5982,7 @@ var writeUserSubagentState = (params) => {
 };
 var readInstalledSubagents = (basePath) => readSubagentManifest(resolveSubagentManifestPath(basePath))?.subagents ?? [];
 var warnMissingSkills = (requiredSkills) => {
-  const missing = requiredSkills.filter((skill) => !existsSync15(skill.path));
+  const missing = requiredSkills.filter((skill) => !existsSync16(skill.path));
   if (missing.length === 0) {
     return;
   }