claudekit-cli 3.34.1-dev.5 → 3.34.2

package/dist/index.js

@@ -29190,10 +29190,8 @@ var init_ck_config = __esm(() => {
   CkHooksConfigSchema = exports_external.object({
     "session-init": exports_external.boolean().optional(),
     "subagent-init": exports_external.boolean().optional(),
-    "descriptive-name": exports_external.boolean().optional(),
     "dev-rules-reminder": exports_external.boolean().optional(),
     "usage-context-awareness": exports_external.boolean().optional(),
-    "context-tracking": exports_external.boolean().optional(),
     "scout-block": exports_external.boolean().optional(),
     "privacy-block": exports_external.boolean().optional(),
     "post-edit-simplify-reminder": exports_external.boolean().optional()
@@ -29266,10 +29264,8 @@ var init_ck_config = __esm(() => {
     hooks: {
       "session-init": true,
       "subagent-init": true,
-      "descriptive-name": true,
       "dev-rules-reminder": true,
       "usage-context-awareness": true,
-      "context-tracking": true,
       "scout-block": true,
       "privacy-block": true,
       "post-edit-simplify-reminder": true
@@ -29278,10 +29274,8 @@ var init_ck_config = __esm(() => {
   CK_HOOK_NAMES = [
     "session-init",
     "subagent-init",
-    "descriptive-name",
     "dev-rules-reminder",
     "usage-context-awareness",
-    "context-tracking",
     "scout-block",
     "privacy-block",
     "post-edit-simplify-reminder"
@@ -29562,9 +29556,6 @@ function getNestedValue(obj, path2) {
 }
 function setNestedValue(obj, path2, value) {
   const keys = path2.split(".");
-  if (keys.some((k) => DANGEROUS_KEYS.includes(k))) {
-    throw new Error("Invalid field path: dangerous key detected");
-  }
   let current = obj;
   for (let i = 0;i < keys.length - 1; i++) {
     const key = keys[i];
@@ -29578,8 +29569,6 @@ function setNestedValue(obj, path2, value) {
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
-    if (DANGEROUS_KEYS.includes(key))
-      continue;
     const sourceVal = source[key];
     const targetVal = result[key];
     if (sourceVal !== null && typeof sourceVal === "object" && !Array.isArray(sourceVal) && targetVal !== null && typeof targetVal === "object" && !Array.isArray(targetVal)) {
@@ -29718,10 +29707,6 @@ class CkConfigManager {
       return null;
     return CkConfigManager.loadConfigFile(CkConfigManager.getProjectConfigPath(projectDir));
   }
-  static projectConfigExists(dir, isGlobal) {
-    const configPath = isGlobal ? join3(dir, ".ck.json") : CkConfigManager.getProjectConfigPath(dir);
-    return existsSync3(configPath);
-  }
   static configExists(scope, projectDir) {
     if (scope === "global") {
       return existsSync3(CkConfigManager.getGlobalConfigPath());
@@ -29742,11 +29727,10 @@ class CkConfigManager {
     await CkConfigManager.saveFull(existing, scope, projectDir);
   }
 }
-var CK_CONFIG_FILE = ".ck.json", DANGEROUS_KEYS;
+var CK_CONFIG_FILE = ".ck.json";
 var init_ck_config_manager = __esm(() => {
   init_logger();
   init_types2();
-  DANGEROUS_KEYS = ["__proto__", "constructor", "prototype"];
 });
 
 // src/shared/environment.ts
@@ -38125,12 +38109,17 @@ class FileWatcher {
     if (this.isConfigFile(path2)) {
       try {
         const scope = this.getConfigScope(path2);
-        const ckScope = scope === "global" ? "global" : "project";
-        const projectDir = scope === "global" ? null : process.cwd();
-        const config = await CkConfigManager.loadScope(ckScope, projectDir);
+        let config;
+        if (scope === "global") {
+          ConfigManager.setGlobalFlag(true);
+          config = await ConfigManager.load();
+        } else {
+          const projectConfig = await ConfigManager.loadProjectConfig(process.cwd(), false);
+          config = projectConfig ? { paths: projectConfig } : {};
+        }
         this.wsManager.broadcast({
           type: "config:updated",
-          payload: { scope, config: config ?? {} }
+          payload: { scope, config }
         });
       } catch (error) {
         logger.error(`Failed to reload config: ${error}`);
@@ -38888,9 +38877,6 @@ var init_projects_registry = __esm(() => {
 });
 
 // src/domains/web-server/routes/ck-config-routes.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { readFile as readFile5 } from "node:fs/promises";
-import { join as join9 } from "node:path";
 async function resolveProjectDir(projectId) {
   if (!projectId)
     return null;
@@ -39013,6 +38999,92 @@ function registerCkConfigRoutes(app) {
       res.status(500).json({ error: "Failed to update field" });
     }
   });
+}
+var init_ck_config_routes = __esm(() => {
+  init_config();
+  init_ck_config_schema();
+  init_logger();
+  init_types2();
+});
+
+// src/domains/web-server/routes/config-routes.ts
+import { existsSync as existsSync6 } from "node:fs";
+import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile6 } from "node:fs/promises";
+import { join as join9 } from "node:path";
+function registerConfigRoutes(app) {
+  app.get("/api/config", async (_req, res) => {
+    try {
+      const projectDir = process.cwd();
+      const globalConfigPath = getEngineerKitConfigPath();
+      let globalConfig = {};
+      if (existsSync6(globalConfigPath)) {
+        const content = await readFile5(globalConfigPath, "utf-8");
+        try {
+          globalConfig = JSON.parse(content);
+        } catch {}
+      }
+      const localConfig = await ConfigManager.loadProjectConfig(projectDir, false);
+      const merged = deepMerge2(globalConfig, localConfig ? { paths: localConfig } : {});
+      const response = {
+        global: globalConfig,
+        local: localConfig ? { paths: localConfig } : null,
+        merged
+      };
+      res.json(response);
+    } catch (error) {
+      logger.error(`Failed to load config: ${error}`);
+      res.status(500).json({ error: "Failed to load configuration" });
+    }
+  });
+  app.get("/api/config/global", async (_req, res) => {
+    try {
+      const globalConfigPath = getEngineerKitConfigPath();
+      let config = {};
+      if (existsSync6(globalConfigPath)) {
+        const content = await readFile5(globalConfigPath, "utf-8");
+        try {
+          config = JSON.parse(content);
+        } catch {}
+      }
+      res.json(config);
+    } catch (error) {
+      res.status(500).json({ error: "Failed to load global config" });
+    }
+  });
+  app.get("/api/config/local", async (_req, res) => {
+    try {
+      const projectDir = process.cwd();
+      const config = await ConfigManager.loadProjectConfig(projectDir, false);
+      res.json(config ? { paths: config } : {});
+    } catch (error) {
+      res.status(500).json({ error: "Failed to load local config" });
+    }
+  });
+  app.post("/api/config", async (req, res) => {
+    try {
+      const { scope = "local", config } = req.body;
+      if (!config || typeof config !== "object") {
+        res.status(400).json({ error: "Invalid config payload" });
+        return;
+      }
+      if (scope === "global") {
+        const globalConfigPath = getEngineerKitConfigPath();
+        const globalDir = PathResolver.getGlobalKitDir();
+        if (!existsSync6(globalDir)) {
+          await mkdir4(globalDir, { recursive: true });
+        }
+        await writeFile6(globalConfigPath, JSON.stringify(config, null, 2), "utf-8");
+        logger.debug(`Engineer kit config saved to ${globalConfigPath}`);
+      } else {
+        const projectDir = process.cwd();
+        await ConfigManager.saveProjectConfig(projectDir, config.paths || config, false);
+      }
+      res.json({ success: true, scope });
+    } catch (error) {
+      logger.error(`Failed to save config: ${error}`);
+      res.status(500).json({ error: "Failed to save configuration" });
+    }
+  });
   app.get("/api/metadata/global", async (_req, res) => {
     try {
       const metadataPath = join9(PathResolver.getGlobalKitDir(), "metadata.json");
@@ -39021,9 +39093,7 @@ function registerCkConfigRoutes(app) {
         const content = await readFile5(metadataPath, "utf-8");
         try {
           metadata = JSON.parse(content);
-        } catch (err) {
-          logger.warning(`Invalid JSON in metadata.json: ${err}`);
-        }
+        } catch {}
       }
       res.json(metadata);
     } catch (error) {
@@ -39031,13 +39101,92 @@ function registerCkConfigRoutes(app) {
       res.status(500).json({ error: "Failed to load metadata" });
     }
   });
+  app.get("/api/config/project/:id", async (req, res) => {
+    try {
+      const id = String(req.params.id);
+      let projectDir;
+      if (id.startsWith("discovered-")) {
+        const encodedPath = id.slice("discovered-".length);
+        projectDir = Buffer.from(encodedPath, "base64url").toString("utf-8");
+      } else {
+        const { ProjectsRegistryManager: ProjectsRegistryManager2 } = await Promise.resolve().then(() => (init_projects_registry(), exports_projects_registry));
+        const project = await ProjectsRegistryManager2.getProject(id);
+        if (!project) {
+          res.status(404).json({ error: "Project not found" });
+          return;
+        }
+        projectDir = project.path;
+      }
+      const globalConfigPath = getEngineerKitConfigPath();
+      let globalConfig = {};
+      if (existsSync6(globalConfigPath)) {
+        const content = await readFile5(globalConfigPath, "utf-8");
+        try {
+          globalConfig = JSON.parse(content);
+        } catch {}
+      }
+      const localConfig = await ConfigManager.loadProjectConfig(projectDir, false);
+      const merged = deepMerge2(globalConfig, localConfig ? { paths: localConfig } : {});
+      const response = {
+        global: globalConfig,
+        local: localConfig ? { paths: localConfig } : null,
+        merged
+      };
+      res.json(response);
+    } catch (error) {
+      logger.error(`Failed to load project config: ${error}`);
+      res.status(500).json({ error: "Failed to load project configuration" });
+    }
+  });
+  app.post("/api/config/project/:id", async (req, res) => {
+    try {
+      const id = String(req.params.id);
+      const { config } = req.body;
+      if (!config || typeof config !== "object") {
+        res.status(400).json({ error: "Invalid config payload" });
+        return;
+      }
+      let projectDir;
+      if (id.startsWith("discovered-")) {
+        const encodedPath = id.slice("discovered-".length);
+        projectDir = Buffer.from(encodedPath, "base64url").toString("utf-8");
+      } else {
+        const { ProjectsRegistryManager: ProjectsRegistryManager2 } = await Promise.resolve().then(() => (init_projects_registry(), exports_projects_registry));
+        const project = await ProjectsRegistryManager2.getProject(id);
+        if (!project) {
+          res.status(404).json({ error: "Project not found" });
+          return;
+        }
+        projectDir = project.path;
+      }
+      await ConfigManager.saveProjectConfig(projectDir, config.paths || config, false);
+      res.json({ success: true });
+    } catch (error) {
+      logger.error(`Failed to save project config: ${error}`);
+      res.status(500).json({ error: "Failed to save project configuration" });
+    }
+  });
 }
-var init_ck_config_routes = __esm(() => {
+function deepMerge2(target, source) {
+  const result = { ...target };
+  const dangerousKeys = ["__proto__", "constructor", "prototype"];
+  for (const key of Object.keys(source)) {
+    if (dangerousKeys.includes(key))
+      continue;
+    const sourceVal = source[key];
+    if (sourceVal && typeof sourceVal === "object" && !Array.isArray(sourceVal)) {
+      result[key] = deepMerge2(result[key] || {}, sourceVal);
+    } else {
+      result[key] = sourceVal;
+    }
+  }
+  return result;
+}
+var getEngineerKitConfigPath = () => join9(PathResolver.getGlobalKitDir(), ".ck.json");
+var init_config_routes = __esm(() => {
   init_config();
-  init_ck_config_schema();
   init_logger();
   init_path_resolver();
-  init_types2();
 });
 
 // src/domains/web-server/routes/health-routes.ts
@@ -43459,7 +43608,7 @@ async function buildProjectInfoFromRegistry(registered) {
       } catch {}
     }
   } catch {}
-  const hasLocalConfig = hasClaudeDir && CkConfigManager.projectConfigExists(registered.path, false);
+  const hasLocalConfig = hasClaudeDir && ConfigManager.projectConfigExists(registered.path, false);
   const settings = await readSettings();
   const skills = await scanSkills();
   const settingsPath = join17(homedir10(), ".claude", "settings.json");
@@ -43500,7 +43649,7 @@ async function detectAndBuildProjectInfo(path2, id) {
       } catch {}
     }
   } catch {}
-  const hasLocalConfig = CkConfigManager.projectConfigExists(path2, id === "global");
+  const hasLocalConfig = ConfigManager.projectConfigExists(path2, id === "global");
   const settings = await readSettings();
   const skills = await scanSkills();
   const settingsPath = join17(homedir10(), ".claude", "settings.json");
@@ -43849,7 +43998,7 @@ var init_skills_discovery = __esm(() => {
 
 // src/commands/skills/skills-registry.ts
 import { existsSync as existsSync14 } from "node:fs";
-import { mkdir as mkdir4, readFile as readFile12, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir5, readFile as readFile12, writeFile as writeFile7 } from "node:fs/promises";
 import { homedir as homedir14 } from "node:os";
 import { dirname as dirname6, join as join21 } from "node:path";
 function getCliVersion() {
@@ -43886,9 +44035,9 @@ async function readRegistry() {
 async function writeRegistry(registry) {
   const dir = dirname6(REGISTRY_PATH);
   if (!existsSync14(dir)) {
-    await mkdir4(dir, { recursive: true });
+    await mkdir5(dir, { recursive: true });
   }
-  await writeFile6(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
+  await writeFile7(REGISTRY_PATH, JSON.stringify(registry, null, 2), "utf-8");
 }
 async function addInstallation(skill, agent, global3, path2, sourcePath) {
   const registry = await readRegistry();
@@ -43962,7 +44111,7 @@ var init_skills_registry = __esm(() => {
 
 // src/commands/skills/skills-installer.ts
 import { existsSync as existsSync15 } from "node:fs";
-import { cp, mkdir as mkdir5, stat as stat7 } from "node:fs/promises";
+import { cp, mkdir as mkdir6, stat as stat7 } from "node:fs/promises";
 import { dirname as dirname7, resolve as resolve6 } from "node:path";
 function isSamePath(path1, path2) {
   try {
@@ -44007,7 +44156,7 @@ async function installSkillForAgent(skill, agent, options2) {
   try {
     const parentDir = dirname7(targetPath);
     if (!existsSync15(parentDir)) {
-      await mkdir5(parentDir, { recursive: true });
+      await mkdir6(parentDir, { recursive: true });
     }
     if (existsSync15(targetPath)) {
       const stats = await stat7(targetPath);
@@ -44585,38 +44734,10 @@ var init_pnpm_detector = __esm(() => {
 });
 
 // src/domains/installation/package-managers/detection-core.ts
-import { existsSync as existsSync17, realpathSync } from "node:fs";
-import { chmod as chmod2, mkdir as mkdir6, readFile as readFile13, writeFile as writeFile7 } from "node:fs/promises";
+import { existsSync as existsSync17 } from "node:fs";
+import { chmod as chmod2, mkdir as mkdir7, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
 import { platform as platform4 } from "node:os";
-import { join as join23, sep } from "node:path";
-function detectFromBinaryPath() {
-  try {
-    const scriptPath = process.argv[1];
-    if (!scriptPath)
-      return "unknown";
-    let resolvedPath;
-    try {
-      resolvedPath = realpathSync(scriptPath);
-    } catch {
-      resolvedPath = scriptPath;
-    }
-    const normalized = resolvedPath.split(sep).join("/").toLowerCase();
-    logger.verbose(`Binary path resolved: ${normalized}`);
-    if (normalized.includes("/.bun/install/") || normalized.includes("/bun/install/global/")) {
-      return "bun";
-    }
-    if (normalized.includes("/pnpm/global/") || normalized.includes("/.local/share/pnpm/")) {
-      return "pnpm";
-    }
-    if (normalized.includes("/yarn/global/") || normalized.includes("/.config/yarn/")) {
-      return "yarn";
-    }
-    if (normalized.includes("/npm/node_modules/") || normalized.includes("/usr/local/lib/node_modules/") || normalized.includes("/usr/lib/node_modules/") || normalized.includes("/opt/homebrew/lib/node_modules/") || normalized.includes("/.nvm/versions/node/") || normalized.includes("/n/versions/node/") || normalized.includes("/appdata/roaming/npm/")) {
-      return "npm";
-    }
-  } catch {}
-  return "unknown";
-}
+import { join as join23 } from "node:path";
 function detectFromEnv() {
   const userAgent = process.env.npm_config_user_agent;
   if (userAgent) {
@@ -44633,14 +44754,13 @@ function detectFromEnv() {
   const execPath = process.env.npm_execpath;
   if (execPath) {
     logger.debug(`Detected exec path: ${execPath}`);
-    const normalizedExec = execPath.replace(/\\/g, "/").toLowerCase();
-    if (/\/bun([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("bun"))
+    if (execPath.includes("bun"))
       return "bun";
-    if (/\/yarn([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("yarn"))
+    if (execPath.includes("yarn"))
       return "yarn";
-    if (/\/pnpm([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("pnpm"))
+    if (execPath.includes("pnpm"))
       return "pnpm";
-    if (/\/npm([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("npm"))
+    if (execPath.includes("npm"))
       return "npm";
   }
   return "unknown";
@@ -44658,8 +44778,8 @@ async function readCachedPm() {
       return null;
     }
     const age = Date.now() - data.detectedAt;
-    if (age < 0 || age > CACHE_TTL) {
-      logger.debug(age < 0 ? "Cache timestamp in future, ignoring" : "Cache expired, will re-detect");
+    if (age > CACHE_TTL) {
+      logger.debug("Cache expired, will re-detect");
       return null;
     }
     const validPms = ["npm", "bun", "yarn", "pnpm"];
@@ -44680,7 +44800,7 @@ async function saveCachedPm(pm, getVersion) {
     const configDir = PathResolver.getConfigDir(false);
     const cacheFile = join23(configDir, CACHE_FILE);
     if (!existsSync17(configDir)) {
-      await mkdir6(configDir, { recursive: true });
+      await mkdir7(configDir, { recursive: true });
       if (platform4() !== "win32") {
         await chmod2(configDir, 448);
       }
@@ -44691,7 +44811,7 @@ async function saveCachedPm(pm, getVersion) {
       detectedAt: Date.now(),
       version: version ?? undefined
     };
-    await writeFile7(cacheFile, JSON.stringify(data, null, 2), "utf-8");
+    await writeFile8(cacheFile, JSON.stringify(data, null, 2), "utf-8");
     if (platform4() !== "win32") {
       await chmod2(cacheFile, 384);
     }
@@ -44768,18 +44888,6 @@ var init_package_manager_detector = __esm(() => {
   PackageManagerDetector = class PackageManagerDetector {
     static async detect() {
       logger.verbose("PackageManagerDetector: Starting detection");
-      const binaryPm = detectFromBinaryPath();
-      if (binaryPm !== "unknown") {
-        logger.verbose(`PackageManagerDetector: Detected from binary path: ${binaryPm}`);
-        const cachedPm2 = await readCachedPm();
-        if (cachedPm2 && cachedPm2 !== binaryPm) {
-          logger.verbose(`PackageManagerDetector: Cache says ${cachedPm2}, binary says ${binaryPm} — updating cache`);
-          await saveCachedPm(binaryPm, PackageManagerDetector.getVersion);
-        } else if (!cachedPm2) {
-          await saveCachedPm(binaryPm, PackageManagerDetector.getVersion);
-        }
-        return binaryPm;
-      }
       const envPm = detectFromEnv();
       if (envPm !== "unknown") {
         logger.verbose(`PackageManagerDetector: Detected from env: ${envPm}`);
@@ -45277,7 +45385,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.34.1-dev.5",
+    version: "3.34.2",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -45376,6 +45484,7 @@ var init_package = __esm(() => {
       "@types/tar": "^6.1.13",
       "@types/tmp": "^0.2.6",
       "@types/ws": "^8.18.1",
+      "conventional-changelog-conventionalcommits": "^9.1.0",
       "semantic-release": "^24.2.0",
       typescript: "^5.7.2"
     }
@@ -45592,15 +45701,12 @@ Run 'ck update' to install`, "Update Check");
       s.stop("Update failed");
       const errorMessage = error instanceof Error ? error.message : "Unknown error";
       if (errorMessage.includes("EACCES") || errorMessage.includes("EPERM") || errorMessage.includes("permission") || errorMessage.includes("Access is denied")) {
-        const permHint = pm === "npm" ? `
+        throw new CliUpdateError(`Permission denied. Try: sudo ${updateCmd}
 
-Or fix npm permissions: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally` : "";
-        const isWindows3 = process.platform === "win32";
-        const elevationHint = isWindows3 ? `Run your terminal as Administrator and retry: ${updateCmd}` : `sudo ${updateCmd}`;
-        throw new CliUpdateError(`Permission denied. Try: ${elevationHint}${permHint}`);
+Or fix npm permissions: https://docs.npmjs.com/resolving-eacces-permissions-errors-when-installing-packages-globally`);
       }
       logger.error(`Update failed: ${errorMessage}`);
-      logger.info(`Try running: ${updateCmd}`);
+      logger.info("Try running: npm install -g claudekit-cli@latest");
       throw new CliUpdateError(`Update failed: ${errorMessage}
 
 Manual update: ${updateCmd}`);
@@ -46094,7 +46200,7 @@ var init_error_handler2 = __esm(() => {
 
 // src/domains/versioning/release-cache.ts
 import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir7, readFile as readFile17, unlink as unlink3, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile17, unlink as unlink3, writeFile as writeFile10 } from "node:fs/promises";
 import { join as join27 } from "node:path";
 var ReleaseCacheEntrySchema, ReleaseCache;
 var init_release_cache = __esm(() => {
@@ -46140,12 +46246,12 @@ var init_release_cache = __esm(() => {
     async set(key, releases) {
       const cacheFile = this.getCachePath(key);
       try {
-        await mkdir7(this.cacheDir, { recursive: true, mode: 448 });
+        await mkdir8(this.cacheDir, { recursive: true, mode: 448 });
         const cacheEntry = {
           timestamp: Date.now(),
           releases
         };
-        await writeFile9(cacheFile, JSON.stringify(cacheEntry, null, 2), "utf-8");
+        await writeFile10(cacheFile, JSON.stringify(cacheEntry, null, 2), "utf-8");
         logger.debug(`Release cache set for key: ${key}, cached ${releases.length} releases`);
       } catch (error) {
         logger.debug(`Failed to set release cache for key ${key}: ${error}`);
@@ -46856,7 +46962,7 @@ var init_version_utils = __esm(() => {
 
 // src/domains/versioning/version-cache.ts
 import { existsSync as existsSync19 } from "node:fs";
-import { mkdir as mkdir8, readFile as readFile18, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile18, writeFile as writeFile11 } from "node:fs/promises";
 import { join as join28 } from "node:path";
 var VersionCacheManager;
 var init_version_cache = __esm(() => {
@@ -46894,9 +47000,9 @@ var init_version_cache = __esm(() => {
       const cacheDir = PathResolver.getCacheDir(false);
       try {
         if (!existsSync19(cacheDir)) {
-          await mkdir8(cacheDir, { recursive: true, mode: 448 });
+          await mkdir9(cacheDir, { recursive: true, mode: 448 });
         }
-        await writeFile10(cacheFile, JSON.stringify(cache3, null, 2), "utf-8");
+        await writeFile11(cacheFile, JSON.stringify(cache3, null, 2), "utf-8");
         logger.debug(`Version check cache saved to ${cacheFile}`);
       } catch (error) {
         logger.debug(`Failed to save version check cache: ${error}`);
@@ -47476,6 +47582,7 @@ var init_user_routes = __esm(() => {
 function registerRoutes(app) {
   registerHealthRoutes(app);
   registerActionRoutes(app);
+  registerConfigRoutes(app);
   registerCkConfigRoutes(app);
   registerProjectRoutes(app);
   registerSkillRoutes(app);
@@ -47487,6 +47594,7 @@ function registerRoutes(app) {
 var init_routes = __esm(() => {
   init_action_routes();
   init_ck_config_routes();
+  init_config_routes();
   init_project_routes();
   init_session_routes();
   init_settings_routes();
@@ -52939,7 +53047,7 @@ var init_skills_installer2 = __esm(() => {
 
 // src/services/package-installer/gemini-mcp/config-manager.ts
 import { existsSync as existsSync32 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile26, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile26, writeFile as writeFile16 } from "node:fs/promises";
 import { dirname as dirname11, join as join50 } from "node:path";
 async function readJsonFile(filePath) {
   try {
@@ -52970,7 +53078,7 @@ async function addGeminiToGitignore(projectDir) {
 `) || content === "" ? "" : `
 `;
     const comment = "# Gemini CLI settings (contains user-specific config)";
-    await writeFile15(gitignorePath, `${content}${newLine}${comment}
+    await writeFile16(gitignorePath, `${content}${newLine}${comment}
 ${geminiPattern}
 `, "utf-8");
     logger.debug(`Added ${geminiPattern} to .gitignore`);
@@ -52982,7 +53090,7 @@ ${geminiPattern}
 async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   const linkDir = dirname11(geminiSettingsPath);
   if (!existsSync32(linkDir)) {
-    await mkdir12(linkDir, { recursive: true });
+    await mkdir13(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
   const mcpConfig = await readJsonFile(mcpConfigPath);
@@ -52995,7 +53103,7 @@ async function createNewSettingsWithMerge(geminiSettingsPath, mcpConfigPath) {
   }
   const newSettings = { mcpServers };
   try {
-    await writeFile15(geminiSettingsPath, JSON.stringify(newSettings, null, 2), "utf-8");
+    await writeFile16(geminiSettingsPath, JSON.stringify(newSettings, null, 2), "utf-8");
     logger.debug(`Created new Gemini settings with mcpServers: ${geminiSettingsPath}`);
     return { success: true, method: "merge", targetPath: mcpConfigPath };
   } catch (error) {
@@ -53025,7 +53133,7 @@ async function mergeGeminiSettings(geminiSettingsPath, mcpConfigPath) {
     mcpServers
   };
   try {
-    await writeFile15(geminiSettingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
+    await writeFile16(geminiSettingsPath, JSON.stringify(mergedSettings, null, 2), "utf-8");
     logger.debug(`Merged mcpServers into: ${geminiSettingsPath}`);
     return { success: true, method: "merge", targetPath: mcpConfigPath };
   } catch (error) {
@@ -53098,12 +53206,12 @@ var init_validation = __esm(() => {
 
 // src/services/package-installer/gemini-mcp/linker-core.ts
 import { existsSync as existsSync34 } from "node:fs";
-import { mkdir as mkdir13, symlink as symlink2 } from "node:fs/promises";
+import { mkdir as mkdir14, symlink as symlink2 } from "node:fs/promises";
 import { dirname as dirname12, join as join52 } from "node:path";
 async function createSymlink(targetPath, linkPath, projectDir, isGlobal) {
   const linkDir = dirname12(linkPath);
   if (!existsSync34(linkDir)) {
-    await mkdir13(linkDir, { recursive: true });
+    await mkdir14(linkDir, { recursive: true });
     logger.debug(`Created directory: ${linkDir}`);
   }
   let symlinkTarget;
@@ -60907,7 +61015,7 @@ function checkComponentCounts(setup) {
 // src/domains/health-checks/checkers/permissions-checker.ts
 init_logger();
 init_path_resolver();
-import { constants as constants2, access as access2, unlink as unlink4, writeFile as writeFile11 } from "node:fs/promises";
+import { constants as constants2, access as access2, unlink as unlink4, writeFile as writeFile12 } from "node:fs/promises";
 import { join as join34 } from "node:path";
 
 // src/domains/health-checks/checkers/shared.ts
@@ -60978,7 +61086,7 @@ async function checkGlobalDirWritable() {
   const random = Math.random().toString(36).substring(2);
   const testFile = join34(globalDir, `.ck-write-test-${timestamp}-${random}`);
   try {
-    await writeFile11(testFile, "test", { encoding: "utf-8", flag: "wx" });
+    await writeFile12(testFile, "test", { encoding: "utf-8", flag: "wx" });
   } catch (error) {
     return {
       id: "ck-global-dir-writable",
@@ -62008,7 +62116,7 @@ import { platform as platform6 } from "node:os";
 
 // src/domains/health-checks/platform/environment-checker.ts
 init_path_resolver();
-import { constants as constants3, access as access3, mkdir as mkdir9, readFile as readFile23, unlink as unlink5, writeFile as writeFile12 } from "node:fs/promises";
+import { constants as constants3, access as access3, mkdir as mkdir10, readFile as readFile23, unlink as unlink5, writeFile as writeFile13 } from "node:fs/promises";
 import { arch as arch2, homedir as homedir16, platform as platform5 } from "node:os";
 import { join as join42, normalize as normalize6 } from "node:path";
 var IS_WINDOWS = platform5() === "win32";
@@ -62106,8 +62214,8 @@ async function checkGlobalDirAccess() {
   }
   const testFile = join42(globalDir, ".ck-doctor-access-test");
   try {
-    await mkdir9(globalDir, { recursive: true });
-    await writeFile12(testFile, "test", "utf-8");
+    await mkdir10(globalDir, { recursive: true });
+    await writeFile13(testFile, "test", "utf-8");
     const content = await readFile23(testFile, "utf-8");
     await unlink5(testFile);
     if (content !== "test")
@@ -62181,7 +62289,7 @@ async function checkWSLBoundary() {
 
 // src/domains/health-checks/platform/windows-checker.ts
 init_path_resolver();
-import { mkdir as mkdir10, symlink, unlink as unlink6, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir11, symlink, unlink as unlink6, writeFile as writeFile14 } from "node:fs/promises";
 import { join as join43 } from "node:path";
 async function checkLongPathSupport() {
   if (shouldSkipExpensiveOperations4()) {
@@ -62237,8 +62345,8 @@ async function checkSymlinkSupport() {
   const target = join43(testDir, ".ck-symlink-test-target");
   const link = join43(testDir, ".ck-symlink-test-link");
   try {
-    await mkdir10(testDir, { recursive: true });
-    await writeFile13(target, "test", "utf-8");
+    await mkdir11(testDir, { recursive: true });
+    await writeFile14(target, "test", "utf-8");
     await symlink(target, link);
     await unlink6(link);
     await unlink6(target);
@@ -62992,7 +63100,7 @@ init_github_client();
 init_logger();
 init_path_resolver();
 var import_compare_versions5 = __toESM(require_umd(), 1);
-import { mkdir as mkdir11, readFile as readFile24, unlink as unlink7, writeFile as writeFile14 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile24, unlink as unlink7, writeFile as writeFile15 } from "node:fs/promises";
 import { join as join45 } from "node:path";
 var CACHE_TTL_HOURS = 24;
 var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
@@ -63050,8 +63158,8 @@ class ConfigVersionChecker {
     try {
       const cachePath = ConfigVersionChecker.getCacheFilePath(kitType, global3);
       const cacheDir = PathResolver.getCacheDir(global3);
-      await mkdir11(cacheDir, { recursive: true });
-      await writeFile14(cachePath, JSON.stringify(cache3, null, 2));
+      await mkdir12(cacheDir, { recursive: true });
+      await writeFile15(cachePath, JSON.stringify(cache3, null, 2));
     } catch (error) {
       logger.debug(`Cache write failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
@@ -65712,7 +65820,7 @@ init_logger();
 // src/shared/process-lock.ts
 init_logger();
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
-import { mkdir as mkdir14 } from "node:fs/promises";
+import { mkdir as mkdir15 } from "node:fs/promises";
 import os5 from "node:os";
 import { join as join53 } from "node:path";
 var LOCK_CONFIG = {
@@ -65745,7 +65853,7 @@ function registerCleanupHandlers() {
 }
 async function ensureLocksDir() {
   const lockDir = getLocksDir();
-  await mkdir14(lockDir, { recursive: true });
+  await mkdir15(lockDir, { recursive: true });
 }
 async function withProcessLock(lockName, fn) {
   registerCleanupHandlers();
@@ -65900,7 +66008,7 @@ init_github_client();
 init_environment();
 init_logger();
 init_safe_spinner();
-import { mkdir as mkdir20, stat as stat12 } from "node:fs/promises";
+import { mkdir as mkdir21, stat as stat12 } from "node:fs/promises";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join61 } from "node:path";
 
@@ -65920,7 +66028,7 @@ var import_ignore = __toESM(require_ignore(), 1);
 init_logger();
 init_output_manager();
 import { createWriteStream as createWriteStream2, rmSync } from "node:fs";
-import { mkdir as mkdir15 } from "node:fs/promises";
+import { mkdir as mkdir16 } from "node:fs/promises";
 import { join as join55 } from "node:path";
 
 // src/shared/progress-bar.ts
@@ -66085,7 +66193,7 @@ init_types2();
 
 // src/domains/installation/utils/path-security.ts
 init_types2();
-import { lstatSync as lstatSync2, realpathSync as realpathSync2 } from "node:fs";
+import { lstatSync as lstatSync2, realpathSync } from "node:fs";
 import { relative as relative5, resolve as resolve10 } from "node:path";
 var MAX_EXTRACTION_SIZE = 500 * 1024 * 1024;
 function isPathSafe(basePath, targetPath) {
@@ -66093,7 +66201,7 @@ function isPathSafe(basePath, targetPath) {
   try {
     const stat10 = lstatSync2(targetPath);
     if (stat10.isSymbolicLink()) {
-      const realTarget = realpathSync2(targetPath);
+      const realTarget = realpathSync(targetPath);
       if (!realTarget.startsWith(resolvedBase)) {
         return false;
       }
@@ -66132,7 +66240,7 @@ class FileDownloader {
   async downloadAsset(asset, destDir) {
     try {
       const destPath = join55(destDir, asset.name);
-      await mkdir15(destDir, { recursive: true });
+      await mkdir16(destDir, { recursive: true });
       output.info(`Downloading ${asset.name} (${formatBytes(asset.size)})...`);
       logger.verbose("Download details", {
         url: asset.browser_download_url,
@@ -66217,7 +66325,7 @@ class FileDownloader {
   async downloadFile(params) {
     const { url, name, size, destDir, token } = params;
     const destPath = join55(destDir, name);
-    await mkdir15(destDir, { recursive: true });
+    await mkdir16(destDir, { recursive: true });
     output.info(`Downloading ${name}${size ? ` (${formatBytes(size)})` : ""}...`);
     const headers = {};
     if (token && url.includes("api.github.com")) {
@@ -66335,7 +66443,7 @@ async function validateExtraction(extractDir) {
 
 // src/domains/installation/extraction/tar-extractor.ts
 init_logger();
-import { copyFile as copyFile3, mkdir as mkdir18, readdir as readdir11, rm as rm3, stat as stat10 } from "node:fs/promises";
+import { copyFile as copyFile3, mkdir as mkdir19, readdir as readdir11, rm as rm3, stat as stat10 } from "node:fs/promises";
 import { join as join59 } from "node:path";
 
 // node_modules/@isaacs/fs-minipass/dist/esm/index.js
@@ -71965,7 +72073,7 @@ var checkCwd = (dir, cb) => {
     cb(er);
   });
 };
-var mkdir16 = (dir, opt, cb) => {
+var mkdir17 = (dir, opt, cb) => {
   dir = normalizeWindowsPath(dir);
   const umask = opt.umask ?? 18;
   const mode = opt.mode | 448;
@@ -72488,7 +72596,7 @@ class Unpack extends Parser {
     }
   }
   [MKDIR](dir, mode, cb) {
-    mkdir16(normalizeWindowsPath(dir), {
+    mkdir17(normalizeWindowsPath(dir), {
       uid: this.uid,
       gid: this.gid,
       processUid: this.processUid,
@@ -73204,7 +73312,7 @@ function decodeFilePath(path10) {
 // src/domains/installation/utils/file-utils.ts
 init_logger();
 init_types2();
-import { copyFile as copyFile2, lstat as lstat4, mkdir as mkdir17, readdir as readdir10 } from "node:fs/promises";
+import { copyFile as copyFile2, lstat as lstat4, mkdir as mkdir18, readdir as readdir10 } from "node:fs/promises";
 import { join as join58, relative as relative6 } from "node:path";
 async function withRetry(fn, retries = 3) {
   for (let i = 0;i < retries; i++) {
@@ -73224,7 +73332,7 @@ var isRetryable = (e2) => {
 };
 var delay = (ms) => new Promise((r2) => setTimeout(r2, ms));
 async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTracker) {
-  await mkdir17(destDir, { recursive: true });
+  await mkdir18(destDir, { recursive: true });
   const entries = await readdir10(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
     const sourcePath = join58(sourceDir, entry);
@@ -73252,7 +73360,7 @@ async function moveDirectoryContents(sourceDir, destDir, shouldExclude, sizeTrac
   }
 }
 async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
-  await mkdir17(destDir, { recursive: true });
+  await mkdir18(destDir, { recursive: true });
   const entries = await readdir10(sourceDir, { encoding: "utf8" });
   for (const entry of entries) {
     const sourcePath = join58(sourceDir, entry);
@@ -73284,7 +73392,7 @@ async function copyDirectory(sourceDir, destDir, shouldExclude, sizeTracker) {
 class TarExtractor {
   async extract(archivePath, destDir, shouldExclude, sizeTracker) {
     const tempExtractDir = `${destDir}-temp`;
-    await mkdir18(tempExtractDir, { recursive: true });
+    await mkdir19(tempExtractDir, { recursive: true });
     try {
       await extract({
         file: archivePath,
@@ -73319,7 +73427,7 @@ class TarExtractor {
             await moveDirectoryContents(tempExtractDir, destDir, shouldExclude, sizeTracker);
           }
         } else {
-          await mkdir18(destDir, { recursive: true });
+          await mkdir19(destDir, { recursive: true });
           await copyFile3(rootPath, join59(destDir, rootEntry));
         }
       } else {
@@ -73342,7 +73450,7 @@ init_environment();
 init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
 import { execFile as execFile8 } from "node:child_process";
-import { copyFile as copyFile4, mkdir as mkdir19, readdir as readdir12, rm as rm4, stat as stat11 } from "node:fs/promises";
+import { copyFile as copyFile4, mkdir as mkdir20, readdir as readdir12, rm as rm4, stat as stat11 } from "node:fs/promises";
 import { join as join60 } from "node:path";
 class ZipExtractor {
   async tryNativeUnzip(archivePath, destDir) {
@@ -73350,7 +73458,7 @@ class ZipExtractor {
       return false;
     }
     return new Promise((resolve11) => {
-      mkdir19(destDir, { recursive: true }).then(() => {
+      mkdir20(destDir, { recursive: true }).then(() => {
         execFile8("unzip", ["-o", "-q", archivePath, "-d", destDir], (error, _stdout, stderr) => {
           if (error) {
             logger.debug(`Native unzip failed: ${stderr || error.message}`);
@@ -73368,7 +73476,7 @@ class ZipExtractor {
   }
   async extract(archivePath, destDir, shouldExclude, sizeTracker) {
     const tempExtractDir = `${destDir}-temp`;
-    await mkdir19(tempExtractDir, { recursive: true });
+    await mkdir20(tempExtractDir, { recursive: true });
     try {
       const nativeSuccess = await this.tryNativeUnzip(archivePath, tempExtractDir);
       if (!nativeSuccess) {
@@ -73406,7 +73514,7 @@ class ZipExtractor {
             await moveDirectoryContents(tempExtractDir, destDir, shouldExclude, sizeTracker);
           }
         } else {
-          await mkdir19(destDir, { recursive: true });
+          await mkdir20(destDir, { recursive: true });
           await copyFile4(rootPath, join60(destDir, rootEntry));
         }
       } else {
@@ -73481,7 +73589,7 @@ class DownloadManager {
     try {
       this.sizeTracker.reset();
       const detectedType = archiveType || detectArchiveType(archivePath);
-      await mkdir20(destDir, { recursive: true });
+      await mkdir21(destDir, { recursive: true });
       if (detectedType === "tar.gz") {
         await this.tarExtractor.extract(archivePath, destDir, this.shouldExclude, this.sizeTracker);
       } else if (detectedType === "zip") {
@@ -73508,7 +73616,7 @@ class DownloadManager {
     const counter = DownloadManager.tempDirCounter++;
     const primaryTempDir = join61(tmpdir3(), `claudekit-${timestamp}-${counter}`);
     try {
-      await mkdir20(primaryTempDir, { recursive: true });
+      await mkdir21(primaryTempDir, { recursive: true });
       logger.debug(`Created temp directory: ${primaryTempDir}`);
       registerTempDir(primaryTempDir);
       return primaryTempDir;
@@ -73525,7 +73633,7 @@ Solutions:
       }
       const fallbackTempDir = join61(homeDir, ".claudekit", "tmp", `claudekit-${timestamp}-${counter}`);
       try {
-        await mkdir20(fallbackTempDir, { recursive: true });
+        await mkdir21(fallbackTempDir, { recursive: true });
         logger.debug(`Created temp directory (fallback): ${fallbackTempDir}`);
         logger.warning(`Using fallback temp directory: ${fallbackTempDir}
   (OS temp directory was not accessible)`);
@@ -73876,7 +73984,7 @@ import { join as join77 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync35, lstatSync as lstatSync3, readdirSync as readdirSync2, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname14, join as join64, relative as relative7, resolve as resolve12, sep as sep2 } from "node:path";
+import { dirname as dirname14, join as join64, relative as relative7, resolve as resolve12, sep } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
@@ -74115,7 +74223,7 @@ function cleanupEmptyDirectories(filePath, claudeDir2) {
 function deletePath(fullPath, claudeDir2) {
   const normalizedPath = resolve12(fullPath);
   const normalizedClaudeDir = resolve12(claudeDir2);
-  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep2}`) && normalizedPath !== normalizedClaudeDir) {
+  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep}`) && normalizedPath !== normalizedClaudeDir) {
     throw new Error(`Path traversal detected: ${fullPath}`);
   }
   try {
@@ -74189,7 +74297,7 @@ async function handleDeletions(sourceMetadata, claudeDir2) {
     const fullPath = join64(claudeDir2, path11);
     const normalizedPath = resolve12(fullPath);
     const normalizedClaudeDir = resolve12(claudeDir2);
-    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep2}`)) {
+    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep}`)) {
       logger.warning(`Skipping invalid path: ${path11}`);
       result.errors.push(path11);
       continue;
@@ -75212,8 +75320,8 @@ var path11 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep3 = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
-minimatch.sep = sep3;
+var sep2 = defaultPlatform === "win32" ? path11.win32.sep : path11.posix.sep;
+minimatch.sep = sep2;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
@@ -75894,13 +76002,10 @@ class FileScanner {
   }
 }
 
-// src/domains/installation/merger/settings-processor.ts
-import { execSync as execSync4 } from "node:child_process";
-
 // src/domains/config/installed-settings-tracker.ts
 init_shared();
 import { existsSync as existsSync36 } from "node:fs";
-import { mkdir as mkdir21, readFile as readFile29, writeFile as writeFile17 } from "node:fs/promises";
+import { mkdir as mkdir22, readFile as readFile29, writeFile as writeFile18 } from "node:fs/promises";
 import { dirname as dirname15, join as join66 } from "node:path";
 var CK_JSON_FILE = ".ck.json";
 
@@ -75952,8 +76057,8 @@ class InstalledSettingsTracker {
         data.kits[this.kitName] = {};
       }
       data.kits[this.kitName].installedSettings = settings;
-      await mkdir21(dirname15(ckJsonPath), { recursive: true });
-      await writeFile17(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
+      await mkdir22(dirname15(ckJsonPath), { recursive: true });
+      await writeFile18(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
       logger.debug(`Saved installed settings to ${ckJsonPath}`);
     } catch (error) {
       logger.warning(`Failed to save installed settings: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -75995,17 +76100,14 @@ init_settings_merger();
 init_environment();
 init_logger();
 var import_fs_extra11 = __toESM(require_lib3(), 1);
-var import_semver2 = __toESM(require_semver2(), 1);
 
 class SettingsProcessor {
-  static MIN_TEAM_HOOKS_VERSION = "2.1.33";
   isGlobal = false;
   forceOverwriteSettings = false;
   projectDir = "";
   kitName = "engineer";
   tracker = null;
   installingKit;
-  cachedVersion = undefined;
   setGlobalFlag(isGlobal) {
     this.isGlobal = isGlobal;
   }
@@ -76051,9 +76153,8 @@ class SettingsProcessor {
       } else {
         const formattedContent = this.formatJsonContent(transformedSource);
         await import_fs_extra11.writeFile(destFile, formattedContent, "utf-8");
-        let parsedSettings;
         try {
-          parsedSettings = JSON.parse(formattedContent);
+          const parsedSettings = JSON.parse(formattedContent);
           if (this.forceOverwriteSettings && destExists) {
             logger.debug("Force overwrite enabled, replaced settings.json completely");
             if (this.tracker) {
@@ -76062,7 +76163,6 @@ class SettingsProcessor {
           }
           await this.trackInstalledSettings(parsedSettings);
         } catch {}
-        await this.injectTeamHooksIfSupported(destFile, parsedSettings);
       }
     } catch (error) {
       logger.error(`Failed to process settings.json: ${error}`);
@@ -76090,6 +76190,7 @@ class SettingsProcessor {
       await this.trackInstalledSettings(sourceSettings);
       return;
     }
+    this.migrateDeprecatedMatchers(destSettings, sourceSettings);
     let installedSettings = { hooks: [], mcpServers: [] };
     if (this.tracker) {
       installedSettings = await this.tracker.loadInstalledSettings();
@@ -76123,7 +76224,46 @@ class SettingsProcessor {
     }
     await SettingsMerger.writeSettingsFile(destFile, mergeResult.merged);
     logger.success("Merged settings.json (user customizations preserved)");
-    await this.injectTeamHooksIfSupported(destFile, mergeResult.merged);
+  }
+  migrateDeprecatedMatchers(destSettings, sourceSettings) {
+    if (!destSettings.hooks || !sourceSettings.hooks)
+      return;
+    for (const [eventName, sourceEntries] of Object.entries(sourceSettings.hooks)) {
+      const destEntries = destSettings.hooks[eventName];
+      if (!destEntries)
+        continue;
+      for (const sourceEntry of sourceEntries) {
+        if (!("matcher" in sourceEntry) || !sourceEntry.matcher)
+          continue;
+        if (!("hooks" in sourceEntry) || !sourceEntry.hooks)
+          continue;
+        const sourceCommands = new Set(sourceEntry.hooks.map((h2) => normalizeCommand(h2.command)).filter((c2) => c2.length > 0));
+        if (sourceCommands.size === 0)
+          continue;
+        for (const destEntry of destEntries) {
+          if (!("matcher" in destEntry))
+            continue;
+          if (destEntry.matcher === sourceEntry.matcher)
+            continue;
+          if (!("hooks" in destEntry) || !destEntry.hooks)
+            continue;
+          const destCommands = destEntry.hooks.map((h2) => normalizeCommand(h2.command)).filter((c2) => c2.length > 0);
+          const hasOverlap = destCommands.some((cmd) => sourceCommands.has(cmd));
+          if (!hasOverlap)
+            continue;
+          const oldMatcher = destEntry.matcher;
+          destEntry.matcher = sourceEntry.matcher;
+          for (const destHook of destEntry.hooks) {
+            const normalizedDest = normalizeCommand(destHook.command);
+            const matchingSource = sourceEntry.hooks.find((sh) => normalizeCommand(sh.command) === normalizedDest);
+            if (matchingSource?.timeout !== undefined) {
+              destHook.timeout = matchingSource.timeout;
+            }
+          }
+          logger.info(`Migrated ${eventName} matcher: "${oldMatcher}" -> "${sourceEntry.matcher}"`);
+        }
+      }
+    }
   }
   async trackInstalledSettings(settings) {
     if (!this.tracker)
@@ -76195,80 +76335,6 @@ class SettingsProcessor {
     }
     return transformed;
   }
-  detectClaudeCodeVersion() {
-    if (this.cachedVersion !== undefined)
-      return this.cachedVersion;
-    try {
-      const output2 = execSync4("claude --version", {
-        encoding: "utf-8",
-        timeout: 5000,
-        stdio: ["ignore", "pipe", "ignore"]
-      });
-      const match2 = output2.match(/(\d+\.\d+\.\d+)/);
-      this.cachedVersion = match2 ? match2[1] : null;
-    } catch {
-      this.cachedVersion = null;
-    }
-    return this.cachedVersion;
-  }
-  isVersionAtLeast(version, minimum) {
-    const coerced = import_semver2.default.coerce(version);
-    if (!coerced)
-      return false;
-    return import_semver2.default.gte(coerced, minimum);
-  }
-  async injectTeamHooksIfSupported(destFile, existingSettings) {
-    const version = this.detectClaudeCodeVersion();
-    if (!version) {
-      logger.debug("Claude Code version not detected, skipping team hooks injection");
-      return;
-    }
-    if (!this.isVersionAtLeast(version, SettingsProcessor.MIN_TEAM_HOOKS_VERSION)) {
-      logger.debug(`Claude Code ${version} does not support team hooks (requires >= 2.1.33), skipping injection`);
-      return;
-    }
-    logger.debug(`Claude Code ${version} detected, checking team hooks`);
-    const settings = existingSettings ?? await SettingsMerger.readSettingsFile(destFile);
-    if (!settings) {
-      logger.warning("Failed to read settings file for team hooks injection");
-      return;
-    }
-    const prefix = this.isGlobal ? isWindows() ? "%USERPROFILE%" : "$HOME" : isWindows() ? "%CLAUDE_PROJECT_DIR%" : "$CLAUDE_PROJECT_DIR";
-    if (!settings.hooks) {
-      settings.hooks = {};
-    }
-    let injected = false;
-    const installedSettings = this.tracker ? await this.tracker.loadInstalledSettings() : { hooks: [], mcpServers: [] };
-    const teamHooks = [
-      { event: "TaskCompleted", handler: "task-completed-handler.cjs" },
-      { event: "TeammateIdle", handler: "teammate-idle-handler.cjs" }
-    ];
-    for (const { event, handler } of teamHooks) {
-      const hookCommand = `node ${prefix}/.claude/hooks/${handler}`;
-      const eventHooks = settings.hooks[event];
-      if (eventHooks && eventHooks.length > 0)
-        continue;
-      if (this.tracker?.wasHookInstalled(hookCommand, installedSettings)) {
-        logger.debug(`Skipping ${event} hook injection (previously removed by user)`);
-        continue;
-      }
-      settings.hooks[event] = [{ hooks: [{ type: "command", command: hookCommand }] }];
-      logger.info(`Injected ${event} hook`);
-      injected = true;
-      if (this.tracker) {
-        this.tracker.trackHook(hookCommand, installedSettings);
-      }
-    }
-    if (injected) {
-      await SettingsMerger.writeSettingsFile(destFile, settings);
-      if (this.tracker) {
-        await this.tracker.saveInstalledSettings(installedSettings);
-      }
-      logger.success("Team hooks injected successfully");
-    } else {
-      logger.debug("Team hooks already present, no injection needed");
-    }
-  }
 }
 
 // src/domains/installation/merger/copy-executor.ts
@@ -77205,12 +77271,12 @@ class FileScanner2 {
 // src/services/transformers/commands-prefix/prefix-applier.ts
 init_logger();
 var import_fs_extra17 = __toESM(require_lib3(), 1);
-import { lstat as lstat7, mkdir as mkdir22, readdir as readdir17, stat as stat15 } from "node:fs/promises";
+import { lstat as lstat7, mkdir as mkdir23, readdir as readdir17, stat as stat15 } from "node:fs/promises";
 import { join as join74 } from "node:path";
 
 // src/services/transformers/commands-prefix/content-transformer.ts
 init_logger();
-import { readFile as readFile33, readdir as readdir16, writeFile as writeFile21 } from "node:fs/promises";
+import { readFile as readFile33, readdir as readdir16, writeFile as writeFile22 } from "node:fs/promises";
 import { join as join73 } from "node:path";
 var TRANSFORMABLE_EXTENSIONS = new Set([
   ".md",
@@ -77286,7 +77352,7 @@ async function transformCommandReferences(directory, options2 = {}) {
             if (options2.dryRun) {
               logger.debug(`[dry-run] Would transform ${changes} command ref(s) in ${fullPath}`);
             } else {
-              await writeFile21(fullPath, transformed, "utf-8");
+              await writeFile22(fullPath, transformed, "utf-8");
               if (options2.verbose) {
                 logger.verbose(`Transformed ${changes} command ref(s) in ${fullPath}`);
               }
@@ -77371,9 +77437,9 @@ async function applyPrefix(extractDir) {
     }
     await import_fs_extra17.copy(commandsDir, backupDir);
     logger.verbose("Created backup of commands directory");
-    await mkdir22(tempDir, { recursive: true });
+    await mkdir23(tempDir, { recursive: true });
     const ckDir = join74(tempDir, "ck");
-    await mkdir22(ckDir, { recursive: true });
+    await mkdir23(ckDir, { recursive: true });
     let processedCount = 0;
     for (const entry of entries) {
       const sourcePath = join74(commandsDir, entry);
@@ -77811,7 +77877,7 @@ init_skip_directories();
 init_types2();
 var import_fs_extra21 = __toESM(require_lib3(), 1);
 import { createHash as createHash2 } from "node:crypto";
-import { readFile as readFile35, readdir as readdir20, writeFile as writeFile22 } from "node:fs/promises";
+import { readFile as readFile35, readdir as readdir20, writeFile as writeFile23 } from "node:fs/promises";
 import { join as join78, relative as relative12 } from "node:path";
 
 class SkillsManifestManager {
@@ -77835,7 +77901,7 @@ class SkillsManifestManager {
   }
   static async writeManifest(skillsDir2, manifest) {
     const manifestPath = join78(skillsDir2, SkillsManifestManager.MANIFEST_FILENAME);
-    await writeFile22(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
+    await writeFile23(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
     logger.debug(`Wrote manifest to: ${manifestPath}`);
   }
   static async readManifest(skillsDir2) {
@@ -78228,7 +78294,7 @@ import { join as join84 } from "node:path";
 
 // src/domains/skills/migrator/migration-executor.ts
 init_logger();
-import { copyFile as copyFile5, mkdir as mkdir23, readdir as readdir22, rm as rm5 } from "node:fs/promises";
+import { copyFile as copyFile5, mkdir as mkdir24, readdir as readdir22, rm as rm5 } from "node:fs/promises";
 import { join as join80 } from "node:path";
 var import_fs_extra24 = __toESM(require_lib3(), 1);
 
@@ -78391,7 +78457,7 @@ Detected changes:`;
 
 // src/domains/skills/migrator/migration-executor.ts
 async function copySkillDirectory(sourceDir, destDir) {
-  await mkdir23(destDir, { recursive: true });
+  await mkdir24(destDir, { recursive: true });
   const entries = await readdir22(sourceDir, { withFileTypes: true });
   for (const entry of entries) {
     const sourcePath = join80(sourceDir, entry.name);
@@ -78411,7 +78477,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
   const preserved = [];
   const errors2 = [];
   const tempDir = join80(currentSkillsDir, "..", ".skills-migration-temp");
-  await mkdir23(tempDir, { recursive: true });
+  await mkdir24(tempDir, { recursive: true });
   try {
     for (const mapping of mappings) {
       try {
@@ -78433,7 +78499,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
         const category = mapping.category;
         const targetPath = category ? join80(tempDir, category, skillName) : join80(tempDir, skillName);
         if (category) {
-          await mkdir23(join80(tempDir, category), { recursive: true });
+          await mkdir24(join80(tempDir, category), { recursive: true });
         }
         await copySkillDirectory(currentSkillPath, targetPath);
         migrated.push(skillName);
@@ -78452,7 +78518,7 @@ async function executeInternal(mappings, customizations, currentSkillsDir, inter
       }
     }
     await rm5(currentSkillsDir, { recursive: true, force: true });
-    await mkdir23(currentSkillsDir, { recursive: true });
+    await mkdir24(currentSkillsDir, { recursive: true });
     await copySkillDirectory(tempDir, currentSkillsDir);
     await rm5(tempDir, { recursive: true, force: true });
     return { migrated, preserved, errors: errors2 };
@@ -78499,7 +78565,7 @@ function validateMigrationPath(path12, paramName) {
 init_logger();
 init_types2();
 var import_fs_extra25 = __toESM(require_lib3(), 1);
-import { copyFile as copyFile6, mkdir as mkdir24, readdir as readdir23, rm as rm6, stat as stat16 } from "node:fs/promises";
+import { copyFile as copyFile6, mkdir as mkdir25, readdir as readdir23, rm as rm6, stat as stat16 } from "node:fs/promises";
 import { basename as basename8, join as join81, normalize as normalize8 } from "node:path";
 function validatePath2(path12, paramName) {
   if (!path12 || typeof path12 !== "string") {
@@ -78529,7 +78595,7 @@ class SkillsBackupManager {
     const backupDir = parentDir ? join81(parentDir, backupDirName) : join81(skillsDir2, "..", backupDirName);
     logger.info(`Creating backup at: ${backupDir}`);
     try {
-      await mkdir24(backupDir, { recursive: true });
+      await mkdir25(backupDir, { recursive: true });
       await SkillsBackupManager.copyDirectory(skillsDir2, backupDir);
       logger.success("Backup created successfully");
       return backupDir;
@@ -78551,7 +78617,7 @@ class SkillsBackupManager {
       if (await import_fs_extra25.pathExists(targetDir)) {
         await rm6(targetDir, { recursive: true, force: true });
       }
-      await mkdir24(targetDir, { recursive: true });
+      await mkdir25(targetDir, { recursive: true });
       await SkillsBackupManager.copyDirectory(backupDir, targetDir);
       logger.success("Backup restored successfully");
     } catch (error) {
@@ -78611,7 +78677,7 @@ class SkillsBackupManager {
         continue;
       }
       if (entry.isDirectory()) {
-        await mkdir24(destPath, { recursive: true });
+        await mkdir25(destPath, { recursive: true });
         await SkillsBackupManager.copyDirectory(sourcePath, destPath);
       } else if (entry.isFile()) {
         await copyFile6(sourcePath, destPath);
@@ -79030,7 +79096,7 @@ import { join as join87 } from "node:path";
 
 // src/services/transformers/opencode-path-transformer.ts
 init_logger();
-import { readFile as readFile37, readdir as readdir26, writeFile as writeFile23 } from "node:fs/promises";
+import { readFile as readFile37, readdir as readdir26, writeFile as writeFile24 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
 import { extname as extname3, join as join86 } from "node:path";
 var IS_WINDOWS3 = platform12() === "win32";
@@ -79104,7 +79170,7 @@ async function transformPathsForGlobalOpenCode(directory, options2 = {}) {
           const content = await readFile37(fullPath, "utf-8");
           const { transformed, changes } = transformOpenCodeContent(content);
           if (changes > 0) {
-            await writeFile23(fullPath, transformed, "utf-8");
+            await writeFile24(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options2.verbose) {
@@ -79325,7 +79391,7 @@ async function handlePostInstall(ctx) {
 // src/commands/init/phases/selection-handler.ts
 init_config_manager();
 init_github_client();
-import { mkdir as mkdir25 } from "node:fs/promises";
+import { mkdir as mkdir26 } from "node:fs/promises";
 import { join as join90, resolve as resolve15 } from "node:path";
 
 // src/domains/github/kit-access-checker.ts
@@ -79848,7 +79914,7 @@ async function handleSelection(ctx) {
   }
   if (!await import_fs_extra32.pathExists(resolvedDir)) {
     if (ctx.options.global) {
-      await mkdir25(resolvedDir, { recursive: true });
+      await mkdir26(resolvedDir, { recursive: true });
       logger.info(`Created global directory: ${resolvedDir}`);
     } else {
       logger.error(`Directory does not exist: ${resolvedDir}`);
@@ -79983,7 +80049,7 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile7, mkdir as mkdir26, open as open4, readFile as readFile39, rename as rename3, stat as stat17, unlink as unlink8, writeFile as writeFile25 } from "node:fs/promises";
+import { copyFile as copyFile7, mkdir as mkdir27, open as open4, readFile as readFile39, rename as rename3, stat as stat17, unlink as unlink8, writeFile as writeFile26 } from "node:fs/promises";
 import { dirname as dirname18, join as join91, resolve as resolve16 } from "node:path";
 init_logger();
 init_path_resolver();
@@ -80103,7 +80169,7 @@ async function acquireSyncLock(global3) {
   const lockPath = join91(cacheDir, ".sync-lock");
   const startTime = Date.now();
   const lockTimeout = getLockTimeout();
-  await mkdir26(dirname18(lockPath), { recursive: true });
+  await mkdir27(dirname18(lockPath), { recursive: true });
   while (Date.now() - startTime < lockTimeout) {
     try {
       const handle = await open4(lockPath, "wx");
@@ -80183,7 +80249,7 @@ async function executeSyncMerge(ctx) {
           const targetPath = await validateSyncPath(ctx.claudeDir, file.path);
           const targetDir = join91(targetPath, "..");
           try {
-            await mkdir26(targetDir, { recursive: true });
+            await mkdir27(targetDir, { recursive: true });
           } catch (mkdirError) {
             const errCode = mkdirError.code;
             if (errCode === "ENOSPC") {
@@ -80262,7 +80328,7 @@ async function executeSyncMerge(ctx) {
         try {
           const tempPath = `${currentPath}.tmp.${Date.now()}`;
           try {
-            await writeFile25(tempPath, result.result, "utf-8");
+            await writeFile26(tempPath, result.result, "utf-8");
             await rename3(tempPath, currentPath);
           } catch (atomicError) {
             await unlink8(tempPath).catch(() => {});
@@ -80346,14 +80412,14 @@ function displaySyncPlan(plan) {
   console.log(import_picocolors21.default.dim("─".repeat(40)));
 }
 async function createBackup(claudeDir2, files, backupDir) {
-  await mkdir26(backupDir, { recursive: true });
+  await mkdir27(backupDir, { recursive: true });
   for (const file of files) {
     try {
       const sourcePath = await validateSyncPath(claudeDir2, file.path);
       if (await import_fs_extra33.pathExists(sourcePath)) {
         const targetPath = await validateSyncPath(backupDir, file.path);
         const targetDir = join91(targetPath, "..");
-        await mkdir26(targetDir, { recursive: true });
+        await mkdir27(targetDir, { recursive: true });
         await copyFile7(sourcePath, targetPath);
       }
     } catch (error) {
@@ -80449,7 +80515,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types2();
-import { readFile as readFile40, readdir as readdir28, writeFile as writeFile26 } from "node:fs/promises";
+import { readFile as readFile40, readdir as readdir28, writeFile as writeFile27 } from "node:fs/promises";
 import { join as join93, relative as relative16 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
@@ -80532,7 +80598,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
           if (options2.dryRun) {
             logger.debug(`[dry-run] Would update ${relative16(dir, fullPath)}: ${changeCount} replacement(s)`);
           } else {
-            await writeFile26(fullPath, newContent, "utf-8");
+            await writeFile27(fullPath, newContent, "utf-8");
             logger.debug(`Updated ${relative16(dir, fullPath)}: ${changeCount} replacement(s)`);
           }
           filesChanged++;
@@ -80638,7 +80704,7 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile41, readdir as readdir29, writeFile as writeFile27 } from "node:fs/promises";
+import { readFile as readFile41, readdir as readdir29, writeFile as writeFile28 } from "node:fs/promises";
 import { platform as platform13 } from "node:os";
 import { extname as extname4, join as join94 } from "node:path";
 var IS_WINDOWS4 = platform13() === "win32";
@@ -80761,7 +80827,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
           const content = await readFile41(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
-            await writeFile27(fullPath, transformed, "utf-8");
+            await writeFile28(fullPath, transformed, "utf-8");
             filesTransformed++;
             totalChanges += changes;
             if (options2.verbose) {
@@ -81619,10 +81685,10 @@ init_dist2();
 
 // src/commands/setup/phases/preflight-check.ts
 init_dist2();
-import { execSync as execSync5 } from "node:child_process";
+import { execSync as execSync4 } from "node:child_process";
 function isGhInstalled() {
   try {
-    execSync5("gh --version", { stdio: "pipe" });
+    execSync4("gh --version", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -81630,7 +81696,7 @@ function isGhInstalled() {
 }
 function checkGhAuth() {
   try {
-    execSync5("gh auth status", { stdio: "pipe" });
+    execSync4("gh auth status", { stdio: "pipe" });
     return true;
   } catch {
     return false;
@@ -81647,11 +81713,11 @@ function checkNodeVersion() {
 }
 function checkPython() {
   try {
-    execSync5("python3 --version", { stdio: "pipe" });
+    execSync4("python3 --version", { stdio: "pipe" });
     return true;
   } catch {
     try {
-      execSync5("python --version", { stdio: "pipe" });
+      execSync4("python --version", { stdio: "pipe" });
       return true;
     } catch {
       return false;
@@ -82374,7 +82440,7 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync5, rmSync as rmSync5 } from "node:fs";
-import { join as join99, resolve as resolve19, sep as sep4 } from "node:path";
+import { join as join99, resolve as resolve19, sep as sep3 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
@@ -82517,7 +82583,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
   try {
     const resolvedPath = resolve19(filePath);
     const resolvedBase = resolve19(baseDir);
-    if (!resolvedPath.startsWith(resolvedBase + sep4) && resolvedPath !== resolvedBase) {
+    if (!resolvedPath.startsWith(resolvedBase + sep3) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
@@ -82525,7 +82591,7 @@ async function isPathSafeToRemove(filePath, baseDir) {
     if (stats.isSymbolicLink()) {
       const realPath = await import_fs_extra37.realpath(filePath);
       const resolvedReal = resolve19(realPath);
-      if (!resolvedReal.startsWith(resolvedBase + sep4) && resolvedReal !== resolvedBase) {
+      if (!resolvedReal.startsWith(resolvedBase + sep3) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
       }