claudekit-cli 3.35.0-dev.16 → 3.35.0-dev.18

package/dist/index.js

@@ -1006,6 +1006,13 @@ var init_dist2 = __esm(() => {
 function supportsUnicode() {
   if (process.env.WT_SESSION)
     return true;
+  const ci = (process.env.CI || "").trim().toLowerCase();
+  if (ci === "true" || ci === "1")
+    return true;
+  if (process.env.TERM === "dumb")
+    return false;
+  if (!process.stdout.isTTY)
+    return false;
   if (process.env.TERM_PROGRAM === "iTerm.app")
     return true;
   if (process.env.TERM_PROGRAM === "Apple_Terminal")
@@ -1014,12 +1021,6 @@ function supportsUnicode() {
     return true;
   if (process.env.KONSOLE_VERSION)
     return true;
-  if (process.env.CI)
-    return true;
-  if (process.env.TERM === "dumb")
-    return false;
-  if (!process.stdout.isTTY)
-    return false;
   const locale = process.env.LANG || process.env.LC_ALL || "";
   if (locale.toLowerCase().includes("utf"))
     return true;
@@ -1089,6 +1090,8 @@ class OutputManager {
   shouldShowProgress() {
     if (this.config.json)
       return false;
+    if (this.config.quiet)
+      return false;
     if (!isTTY())
       return false;
     return true;
@@ -38560,11 +38563,40 @@ var init_ck_config_manager = __esm(() => {
 });
 
 // src/shared/environment.ts
+function normalizeEnvValue(value) {
+  return value?.trim().toLowerCase() ?? "";
+}
+function isTruthyEnv(value) {
+  return TRUTHY_ENV_VALUES.has(normalizeEnvValue(value));
+}
+function isTestEnvironment() {
+  return normalizeEnvValue("development") === "test" || isTruthyEnv(process.env.VITEST) || isTruthyEnv(process.env.BUN_TEST);
+}
 function isCIEnvironment() {
-  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+  return isTruthyEnv(process.env.CI) || isTruthyEnv(process.env.CI_SAFE_MODE);
+}
+function isIsolatedTestEnvironment() {
+  const normalizedValue = normalizeEnvValue(process.env.CK_TEST_HOME);
+  if (!normalizedValue) {
+    return false;
+  }
+  return !FALSY_ENV_VALUES.has(normalizedValue);
+}
+function shouldSkipExpensiveOperations() {
+  if (isIsolatedTestEnvironment()) {
+    return false;
+  }
+  return isCIEnvironment();
+}
+function getHomeDirectoryFromEnv(platformName = process.platform) {
+  const value = platformName === "win32" ? process.env.USERPROFILE || process.env.HOME : process.env.HOME || process.env.USERPROFILE;
+  if (!value || value.trim() === "") {
+    return null;
+  }
+  return value.trim();
 }
 function isNonInteractive() {
-  return !process.stdin.isTTY || process.env.CI === "true" || process.env.NON_INTERACTIVE === "true";
+  return !process.stdin.isTTY || isCIEnvironment() || isTruthyEnv(process.env.NON_INTERACTIVE);
 }
 function isMacOS() {
   return process.platform === "darwin";
@@ -38579,13 +38611,34 @@ function getOptimalConcurrency() {
     return PLATFORM_CONCURRENCY.WINDOWS;
   return PLATFORM_CONCURRENCY.LINUX;
 }
-var PLATFORM_CONCURRENCY;
+var PLATFORM_CONCURRENCY, TRUTHY_ENV_VALUES, FALSY_ENV_VALUES;
 var init_environment = __esm(() => {
   PLATFORM_CONCURRENCY = {
     MACOS: 10,
     WINDOWS: 15,
     LINUX: 20
   };
+  TRUTHY_ENV_VALUES = new Set(["1", "true", "yes", "on"]);
+  FALSY_ENV_VALUES = new Set(["0", "false", "no", "off"]);
+});
+
+// src/shared/claudekit-constants.ts
+function getCliVersion2() {
+  return process.env.CLAUDEKIT_CLI_VERSION?.trim() || process.env.npm_package_version?.trim() || "unknown";
+}
+function getCliUserAgent() {
+  return `${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}/${getCliVersion2()}`;
+}
+var CLAUDEKIT_CLI_NPM_PACKAGE_NAME = "claudekit-cli", CLAUDEKIT_CLI_NPM_PACKAGE_URL, CLAUDEKIT_CLI_GLOBAL_INSTALL_COMMAND, CLAUDEKIT_CLI_INSTALL_COMMANDS, DEFAULT_NETWORK_TIMEOUT_MS = 3000;
+var init_claudekit_constants = __esm(() => {
+  CLAUDEKIT_CLI_NPM_PACKAGE_URL = `https://www.npmjs.com/package/${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`;
+  CLAUDEKIT_CLI_GLOBAL_INSTALL_COMMAND = `npm install -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`;
+  CLAUDEKIT_CLI_INSTALL_COMMANDS = [
+    CLAUDEKIT_CLI_GLOBAL_INSTALL_COMMAND,
+    `pnpm add -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`,
+    `yarn global add ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`,
+    `bun add -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`
+  ];
 });
 
 // node_modules/chalk/source/vendor/ansi-styles/index.js
@@ -41758,10 +41811,29 @@ function normalizeCommand(cmd) {
   return normalized;
 }
 
+// src/shared/parse-timeout.ts
+function parseTimeoutMs(rawValue, fallback2, min = 500, max = 60000) {
+  if (!rawValue) {
+    return fallback2;
+  }
+  const parsed = Number.parseInt(rawValue, 10);
+  if (Number.isNaN(parsed)) {
+    return fallback2;
+  }
+  if (parsed < min) {
+    return min;
+  }
+  if (parsed > max) {
+    return max;
+  }
+  return parsed;
+}
+
 // src/shared/index.ts
 var init_shared = __esm(() => {
   init_logger();
   init_environment();
+  init_claudekit_constants();
   init_terminal_utils();
   init_path_resolver();
   init_safe_spinner();
@@ -51522,7 +51594,7 @@ import { existsSync as existsSync25 } from "node:fs";
 import { mkdir as mkdir7, readFile as readFile20, writeFile as writeFile9 } from "node:fs/promises";
 import { homedir as homedir22 } from "node:os";
 import { dirname as dirname9, join as join31 } from "node:path";
-function getCliVersion2() {
+function getCliVersion3() {
   try {
     if (process.env.npm_package_version) {
       return process.env.npm_package_version;
@@ -51570,7 +51642,7 @@ async function addInstallation(skill, agent, global3, path4, sourcePath) {
     path: path4,
     installedAt: new Date().toISOString(),
     sourcePath,
-    cliVersion: getCliVersion2()
+    cliVersion: getCliVersion3()
   });
   await writeRegistry(registry);
 }
@@ -52098,6 +52170,16 @@ var init_npm_registry = __esm(() => {
   init_logger();
 });
 
+// src/domains/installation/package-managers/constants.ts
+function getPmVersionCommandTimeoutMs() {
+  return parseTimeoutMs(process.env.CK_PM_VERSION_TIMEOUT_MS, DEFAULT_PM_VERSION_COMMAND_TIMEOUT_MS);
+}
+function getPmQueryTimeoutMs() {
+  return parseTimeoutMs(process.env.CK_PM_QUERY_TIMEOUT_MS, DEFAULT_PM_QUERY_TIMEOUT_MS);
+}
+var DEFAULT_PM_VERSION_COMMAND_TIMEOUT_MS = 3000, DEFAULT_PM_QUERY_TIMEOUT_MS = 5000;
+var init_constants = () => {};
+
 // src/domains/installation/package-managers/detector-base.ts
 import { exec } from "node:child_process";
 import { promisify as promisify7 } from "node:util";
@@ -52116,13 +52198,13 @@ var init_detector_base = __esm(() => {
 function getNpmQuery() {
   return {
     pm: "npm",
-    cmd: isWindows() ? "npm.cmd ls -g claudekit-cli --depth=0 --json" : "npm ls -g claudekit-cli --depth=0 --json",
+    cmd: isWindows() ? `npm.cmd ls -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME} --depth=0 --json` : `npm ls -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME} --depth=0 --json`,
     checkFn: (stdout) => {
       try {
         const data = JSON.parse(stdout);
-        return !!(data.dependencies?.["claudekit-cli"] || stdout.includes("claudekit-cli"));
+        return !!(data.dependencies?.[CLAUDEKIT_CLI_NPM_PACKAGE_NAME] || stdout.includes(CLAUDEKIT_CLI_NPM_PACKAGE_NAME));
       } catch {
-        return stdout.includes("claudekit-cli");
+        return stdout.includes(CLAUDEKIT_CLI_NPM_PACKAGE_NAME);
       }
     }
   };
@@ -52132,7 +52214,9 @@ function getNpmVersionCommand() {
 }
 async function getNpmVersion() {
   try {
-    const { stdout } = await execAsync(getNpmVersionCommand(), { timeout: 3000 });
+    const { stdout } = await execAsync(getNpmVersionCommand(), {
+      timeout: getPmVersionCommandTimeoutMs()
+    });
     return stdout.trim();
   } catch {
     return null;
@@ -52149,7 +52233,9 @@ function getNpmUpdateCommand(packageName, version) {
   return isWindows() ? `npm.cmd install -g ${packageName}${versionSuffix}` : `npm install -g ${packageName}${versionSuffix}`;
 }
 var init_npm_detector = __esm(() => {
+  init_claudekit_constants();
   init_environment();
+  init_constants();
   init_detector_base();
 });
 
@@ -52158,7 +52244,7 @@ function getBunQuery() {
   return {
     pm: "bun",
     cmd: "bun pm ls -g",
-    checkFn: (stdout) => stdout.includes("claudekit-cli")
+    checkFn: (stdout) => stdout.includes(CLAUDEKIT_CLI_NPM_PACKAGE_NAME)
   };
 }
 function getBunVersionCommand() {
@@ -52166,7 +52252,9 @@ function getBunVersionCommand() {
 }
 async function getBunVersion() {
   try {
-    const { stdout } = await execAsync(getBunVersionCommand(), { timeout: 3000 });
+    const { stdout } = await execAsync(getBunVersionCommand(), {
+      timeout: getPmVersionCommandTimeoutMs()
+    });
     return stdout.trim();
   } catch {
     return null;
@@ -52183,6 +52271,8 @@ function getBunUpdateCommand(packageName, version) {
   return `bun add -g ${packageName}${versionSuffix}`;
 }
 var init_bun_detector = __esm(() => {
+  init_claudekit_constants();
+  init_constants();
   init_detector_base();
 });
 
@@ -52190,8 +52280,8 @@ var init_bun_detector = __esm(() => {
 function getYarnQuery() {
   return {
     pm: "yarn",
-    cmd: isWindows() ? "yarn.cmd global list --pattern claudekit-cli" : "yarn global list --pattern claudekit-cli",
-    checkFn: (stdout) => stdout.includes("claudekit-cli")
+    cmd: isWindows() ? `yarn.cmd global list --pattern ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}` : `yarn global list --pattern ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`,
+    checkFn: (stdout) => stdout.includes(CLAUDEKIT_CLI_NPM_PACKAGE_NAME)
   };
 }
 function getYarnVersionCommand() {
@@ -52199,7 +52289,9 @@ function getYarnVersionCommand() {
 }
 async function getYarnVersion() {
   try {
-    const { stdout } = await execAsync(getYarnVersionCommand(), { timeout: 3000 });
+    const { stdout } = await execAsync(getYarnVersionCommand(), {
+      timeout: getPmVersionCommandTimeoutMs()
+    });
     return stdout.trim();
   } catch {
     return null;
@@ -52216,7 +52308,9 @@ function getYarnUpdateCommand(packageName, version) {
   return isWindows() ? `yarn.cmd global add ${packageName}${versionSuffix}` : `yarn global add ${packageName}${versionSuffix}`;
 }
 var init_yarn_detector = __esm(() => {
+  init_claudekit_constants();
   init_environment();
+  init_constants();
   init_detector_base();
 });
 
@@ -52224,8 +52318,8 @@ var init_yarn_detector = __esm(() => {
 function getPnpmQuery() {
   return {
     pm: "pnpm",
-    cmd: isWindows() ? "pnpm.cmd ls -g claudekit-cli" : "pnpm ls -g claudekit-cli",
-    checkFn: (stdout) => stdout.includes("claudekit-cli")
+    cmd: isWindows() ? `pnpm.cmd ls -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}` : `pnpm ls -g ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`,
+    checkFn: (stdout) => stdout.includes(CLAUDEKIT_CLI_NPM_PACKAGE_NAME)
   };
 }
 function getPnpmVersionCommand() {
@@ -52233,7 +52327,9 @@ function getPnpmVersionCommand() {
 }
 async function getPnpmVersion() {
   try {
-    const { stdout } = await execAsync(getPnpmVersionCommand(), { timeout: 3000 });
+    const { stdout } = await execAsync(getPnpmVersionCommand(), {
+      timeout: getPmVersionCommandTimeoutMs()
+    });
     return stdout.trim();
   } catch {
     return null;
@@ -52250,7 +52346,9 @@ function getPnpmUpdateCommand(packageName, version) {
   return isWindows() ? `pnpm.cmd add -g ${packageName}${versionSuffix}` : `pnpm add -g ${packageName}${versionSuffix}`;
 }
 var init_pnpm_detector = __esm(() => {
+  init_claudekit_constants();
   init_environment();
+  init_constants();
   init_detector_base();
 });
 
@@ -52304,13 +52402,19 @@ function detectFromEnv() {
   if (execPath) {
     logger.debug(`Detected exec path: ${execPath}`);
     const normalizedExec = execPath.replace(/\\/g, "/").toLowerCase();
-    if (/\/bun([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("bun"))
+    const matchesPmExecPath = (pm) => {
+      if (new RegExp(`(?:^|/)${pm}(?:[/.]|$)`).test(normalizedExec)) {
+        return true;
+      }
+      return normalizedExec === pm || normalizedExec === `${pm}.cmd` || normalizedExec === `${pm}.exe` || normalizedExec === `${pm}.js` || normalizedExec === `${pm}.cjs` || normalizedExec === `${pm}.mjs`;
+    };
+    if (matchesPmExecPath("bun"))
       return "bun";
-    if (/\/yarn([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("yarn"))
+    if (matchesPmExecPath("yarn"))
       return "yarn";
-    if (/\/pnpm([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("pnpm"))
+    if (matchesPmExecPath("pnpm"))
       return "pnpm";
-    if (/\/npm([/.]|$)/.test(normalizedExec) || normalizedExec.startsWith("npm"))
+    if (matchesPmExecPath("npm"))
       return "npm";
   }
   return "unknown";
@@ -52373,16 +52477,16 @@ async function saveCachedPm(pm, getVersion) {
 async function findOwningPm() {
   const queries = [getBunQuery(), getNpmQuery(), getPnpmQuery(), getYarnQuery()];
   logger.verbose("PackageManagerDetector: Querying all PMs in parallel");
-  logger.debug("Querying package managers for claudekit-cli ownership...");
+  logger.debug(`Querying package managers for ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME} ownership...`);
   const results = await Promise.allSettled(queries.map(async ({ pm, cmd, checkFn }) => {
     try {
       logger.verbose(`PackageManagerDetector: Querying ${pm}`);
       const { stdout } = await execAsync(cmd, {
-        timeout: QUERY_TIMEOUT
+        timeout: getPmQueryTimeoutMs()
       });
       if (checkFn(stdout)) {
         logger.verbose(`PackageManagerDetector: Found via ${pm}`);
-        logger.debug(`Found claudekit-cli installed via ${pm}`);
+        logger.debug(`Found ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME} installed via ${pm}`);
         return pm;
       }
       logger.verbose(`PackageManagerDetector: Not found via ${pm}`);
@@ -52392,12 +52496,20 @@ async function findOwningPm() {
     return null;
   }));
   logger.verbose("PackageManagerDetector: All PM queries complete");
+  const detectedPms = [];
   for (const result of results) {
-    if (result.status === "fulfilled" && result.value) {
-      return result.value;
+    if (result.status === "fulfilled" && result.value && !detectedPms.includes(result.value)) {
+      detectedPms.push(result.value);
     }
   }
-  logger.debug("Could not determine which package manager installed claudekit-cli");
+  if (detectedPms.length === 1) {
+    return detectedPms[0];
+  }
+  if (detectedPms.length > 1) {
+    logger.warning(`Ambiguous package manager ownership for ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}: ${detectedPms.join(", ")}. Falling back to default detection.`);
+    return null;
+  }
+  logger.debug(`Could not determine which package manager installed ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}`);
   return null;
 }
 async function clearCache() {
@@ -52412,10 +52524,12 @@ async function clearCache() {
     logger.debug(`Failed to clear cache: ${error instanceof Error ? error.message : "Unknown error"}`);
   }
 }
-var CACHE_FILE = "install-info.json", CACHE_TTL, QUERY_TIMEOUT = 5000;
+var CACHE_FILE = "install-info.json", CACHE_TTL;
 var init_detection_core = __esm(() => {
+  init_claudekit_constants();
   init_logger();
   init_path_resolver();
+  init_constants();
   init_package_managers();
   CACHE_TTL = 30 * 24 * 60 * 60 * 1000;
 });
@@ -52433,7 +52547,9 @@ var init_package_managers = __esm(() => {
 // src/domains/installation/package-manager-detector.ts
 var PackageManagerDetector;
 var init_package_manager_detector = __esm(() => {
+  init_claudekit_constants();
   init_logger();
+  init_constants();
   init_package_managers();
   PackageManagerDetector = class PackageManagerDetector {
     static async detect() {
@@ -52469,7 +52585,7 @@ var init_package_manager_detector = __esm(() => {
         return owningPm;
       }
       logger.verbose("PackageManagerDetector: Defaulting to npm");
-      logger.warning("Could not detect package manager that installed claudekit-cli, defaulting to npm");
+      logger.warning(`Could not detect package manager that installed ${CLAUDEKIT_CLI_NPM_PACKAGE_NAME}, defaulting to npm`);
       return "npm";
     }
     static readCachedPm = readCachedPm;
@@ -52481,7 +52597,9 @@ var init_package_manager_detector = __esm(() => {
       if (pm === "unknown")
         return false;
       try {
-        await execAsync(PackageManagerDetector.getVersionCommand(pm), { timeout: 3000 });
+        await execAsync(PackageManagerDetector.getVersionCommand(pm), {
+          timeout: getPmVersionCommandTimeoutMs()
+        });
         return true;
       } catch {
         return false;
@@ -52947,7 +53065,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "3.35.0-dev.16",
+    version: "3.35.0-dev.18",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -53188,7 +53306,7 @@ async function updateCliCommand(options2) {
     s.start("Checking for updates...");
     let targetVersion = null;
     if (opts.release && opts.release !== "latest") {
-      const exists = await NpmRegistryClient.versionExists(PACKAGE_NAME, opts.release, opts.registry);
+      const exists = await NpmRegistryClient.versionExists(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, opts.release, opts.registry);
       if (!exists) {
         s.stop("Version not found");
         throw new CliUpdateError(`Version ${opts.release} does not exist on npm registry. Run 'ck versions' to see available versions.`);
@@ -53196,20 +53314,20 @@ async function updateCliCommand(options2) {
       targetVersion = opts.release;
       s.stop(`Target version: ${targetVersion}`);
     } else if (opts.dev || opts.beta) {
-      targetVersion = await NpmRegistryClient.getDevVersion(PACKAGE_NAME, opts.registry);
+      targetVersion = await NpmRegistryClient.getDevVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, opts.registry);
       if (!targetVersion) {
         s.stop("No dev version available");
         logger.warning("No dev version found. Using latest stable version instead.");
-        targetVersion = await NpmRegistryClient.getLatestVersion(PACKAGE_NAME, opts.registry);
+        targetVersion = await NpmRegistryClient.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, opts.registry);
       } else {
         s.stop(`Latest dev version: ${targetVersion}`);
       }
     } else {
-      targetVersion = await NpmRegistryClient.getLatestVersion(PACKAGE_NAME, opts.registry);
+      targetVersion = await NpmRegistryClient.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, opts.registry);
       s.stop(`Latest version: ${targetVersion || "unknown"}`);
     }
     if (!targetVersion) {
-      throw new CliUpdateError(`Failed to fetch version information from npm registry. Check your internet connection and try again. Manual update: ${PackageManagerDetector.getUpdateCommand(pm, PACKAGE_NAME)}`);
+      throw new CliUpdateError(`Failed to fetch version information from npm registry. Check your internet connection and try again. Manual update: ${PackageManagerDetector.getUpdateCommand(pm, CLAUDEKIT_CLI_NPM_PACKAGE_NAME)}`);
     }
     const comparison = import_compare_versions.compareVersions(currentVersion, targetVersion);
     if (comparison === 0) {
@@ -53242,7 +53360,7 @@ Run 'ck update' to install`, "Update Check");
         return;
       }
     }
-    const updateCmd = PackageManagerDetector.getUpdateCommand(pm, PACKAGE_NAME, targetVersion);
+    const updateCmd = PackageManagerDetector.getUpdateCommand(pm, CLAUDEKIT_CLI_NPM_PACKAGE_NAME, targetVersion);
     logger.info(`Running: ${updateCmd}`);
     s.start("Updating CLI...");
     try {
@@ -53298,12 +53416,13 @@ Manual update: ${updateCmd}`);
     throw new CliUpdateError(errorMessage);
   }
 }
-var import_compare_versions, import_fs_extra5, execAsync2, CliUpdateError, PACKAGE_NAME = "claudekit-cli";
+var import_compare_versions, import_fs_extra5, execAsync2, CliUpdateError;
 var init_update_cli = __esm(() => {
   init_npm_registry();
   init_package_manager_detector();
   init_metadata_migration();
   init_claudekit_scanner();
+  init_claudekit_constants();
   init_logger();
   init_safe_prompts();
   init_types3();
@@ -53519,7 +53638,7 @@ async function getAuthenticatedClient() {
   const { token } = await AuthManager.getToken();
   cachedOctokit = new Octokit({
     auth: token,
-    userAgent: "claudekit-cli",
+    userAgent: getCliUserAgent(),
     request: {
       timeout: 30000
     }
@@ -53533,6 +53652,7 @@ async function invalidateAuth() {
 }
 var cachedOctokit = null;
 var init_auth_api = __esm(() => {
+  init_claudekit_constants();
   init_logger();
   init_github_auth();
 });
@@ -54488,7 +54608,7 @@ function isUpdateCheckDisabled() {
   return process.env.NO_UPDATE_NOTIFIER === "1" || process.env.NO_UPDATE_NOTIFIER === "true" || !process.stdout.isTTY;
 }
 function normalizeVersion(version) {
-  return version.replace(/^v/, "");
+  return version.replace(/^v/i, "");
 }
 function parseVersionParts(version) {
   const normalized = normalizeVersion(version);
@@ -54667,7 +54787,7 @@ class CliVersionChecker {
       return null;
     }
     try {
-      const latestVersion = await NpmRegistryClient.getLatestVersion(PACKAGE_NAME2);
+      const latestVersion = await NpmRegistryClient.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME);
       if (!latestVersion) {
         logger.debug("Failed to fetch latest CLI version from npm");
         return null;
@@ -54684,7 +54804,7 @@ class CliVersionChecker {
         currentVersion: current,
         latestVersion: latest,
         updateAvailable,
-        releaseUrl: `https://www.npmjs.com/package/${PACKAGE_NAME2}`
+        releaseUrl: CLAUDEKIT_CLI_NPM_PACKAGE_URL
       };
     } catch (error) {
       logger.debug(`CLI version check failed: ${error}`);
@@ -54692,9 +54812,10 @@ class CliVersionChecker {
     }
   }
 }
-var import_compare_versions4, PACKAGE_NAME2 = "claudekit-cli";
+var import_compare_versions4;
 var init_cli_version_checker = __esm(() => {
   init_npm_registry();
+  init_claudekit_constants();
   init_logger();
   init_version_utils();
   import_compare_versions4 = __toESM(require_umd(), 1);
@@ -54806,29 +54927,45 @@ import { spawn as spawn2 } from "node:child_process";
 import { existsSync as existsSync31 } from "node:fs";
 import { readFile as readFile27 } from "node:fs/promises";
 import { join as join39 } from "node:path";
+function hasCliUpdate(currentVersion, latestVersion) {
+  if (!latestVersion) {
+    return false;
+  }
+  try {
+    return import_compare_versions5.compareVersions(normalizeVersion(latestVersion), normalizeVersion(currentVersion)) > 0;
+  } catch (error) {
+    logger.debug(`Version comparison failed for "${currentVersion}" vs "${latestVersion}": ${error}`);
+    return latestVersion !== currentVersion;
+  }
+}
 function registerSystemRoutes(app) {
   app.get("/api/system/check-updates", async (req, res) => {
     const { target, kit, channel = "stable" } = req.query;
+    const normalizedChannel = typeof channel === "string" ? channel.toLowerCase() : "stable";
     if (!target || target !== "cli" && target !== "kit") {
       res.status(400).json({ error: "Missing or invalid target param (cli|kit)" });
       return;
     }
+    if (normalizedChannel !== "stable" && normalizedChannel !== "beta") {
+      res.status(400).json({ error: "Invalid channel param (stable|beta)" });
+      return;
+    }
     try {
       if (target === "cli") {
         const packageJson = await getPackageJson();
         const currentVersion = packageJson?.version ?? "0.0.0";
         let latestVersion = null;
-        if (channel === "beta") {
-          latestVersion = await NpmRegistryClient.getDevVersion("claudekit-cli");
+        if (normalizedChannel === "beta") {
+          latestVersion = await NpmRegistryClient.getDevVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME);
         } else {
-          latestVersion = await NpmRegistryClient.getLatestVersion("claudekit-cli");
+          latestVersion = await NpmRegistryClient.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME);
         }
-        const updateAvailable = latestVersion ? latestVersion !== currentVersion : false;
+        const updateAvailable = hasCliUpdate(currentVersion, latestVersion);
         const response = {
           current: currentVersion,
           latest: latestVersion,
           updateAvailable,
-          releaseUrl: updateAvailable ? "https://www.npmjs.com/package/claudekit" : undefined
+          releaseUrl: CLAUDEKIT_CLI_NPM_PACKAGE_URL
         };
         res.json(response);
       } else {
@@ -54840,7 +54977,7 @@ function registerSystemRoutes(app) {
           current: currentVersion,
           latest: result?.latestVersion ?? null,
           updateAvailable: result?.updateAvailable ?? false,
-          releaseUrl: result?.updateAvailable ? `https://github.com/anthropics/claudekit-${kitName}/releases` : undefined
+          releaseUrl: `https://github.com/anthropics/claudekit-${kitName}/releases`
         };
         res.json(response);
       }
@@ -54870,7 +55007,7 @@ function registerSystemRoutes(app) {
       }
       let versions = [];
       if (target === "cli") {
-        const packageInfo = await NpmRegistryClient.getPackageInfo("claudekit-cli");
+        const packageInfo = await NpmRegistryClient.getPackageInfo(CLAUDEKIT_CLI_NPM_PACKAGE_NAME);
         if (packageInfo) {
           const allVersions = Object.keys(packageInfo.versions);
           const latestStable = packageInfo["dist-tags"]?.latest;
@@ -54928,8 +55065,15 @@ function registerSystemRoutes(app) {
       res.status(400).json({ error: "Missing or invalid target param (cli|kit)" });
       return;
     }
-    if (target === "kit" && !kit) {
-      res.status(400).json({ error: "Missing kit param for kit update" });
+    if (target === "kit") {
+      const kitName = kit;
+      if (!kitName || !AVAILABLE_KITS[kitName]) {
+        res.status(400).json({ error: "Missing or invalid kit param" });
+        return;
+      }
+    }
+    if (version && typeof version === "string" && !/^[a-zA-Z0-9._-]+$/.test(version)) {
+      res.status(400).json({ error: "Invalid version format" });
       return;
     }
     res.setHeader("Content-Type", "text/event-stream");
@@ -54939,34 +55083,27 @@ function registerSystemRoutes(app) {
     res.write(`data: ${JSON.stringify({ type: "start", message: "Starting update..." })}
 
 `);
-    let command;
-    let args;
+    let commandLine;
     if (target === "cli") {
       const pm = await PackageManagerDetector.detect();
       const targetVersion = version || "latest";
-      const fullCmd = PackageManagerDetector.getUpdateCommand(pm, "claudekit-cli", targetVersion);
-      const parts = fullCmd.split(" ");
-      command = parts[0];
-      args = parts.slice(1);
+      commandLine = PackageManagerDetector.getUpdateCommand(pm, CLAUDEKIT_CLI_NPM_PACKAGE_NAME, targetVersion);
       res.write(`data: ${JSON.stringify({ type: "phase", name: "downloading" })}
 
 `);
-      logger.debug(`CLI update using ${pm}: ${fullCmd}`);
+      logger.debug(`CLI update using ${pm}: ${commandLine}`);
     } else {
       const kitName = kit;
       const metadata = await getKitMetadata2(kitName);
       const isBeta = isBetaVersion(metadata?.version);
-      const initCmd = buildInitCommand(true, kitName, isBeta);
-      const parts = initCmd.split(" ");
-      command = parts[0];
-      args = parts.slice(1);
-      logger.debug(`Updating kit ${kitName} (beta: ${isBeta}): ${initCmd}`);
+      commandLine = buildInitCommand(true, kitName, isBeta);
+      logger.debug(`Updating kit ${kitName} (beta: ${isBeta}): ${commandLine}`);
       res.write(`data: ${JSON.stringify({ type: "phase", name: "installing" })}
 
 `);
     }
-    logger.debug(`Spawning update command: ${command} ${args.join(" ")}`);
-    const childProcess4 = spawn2(command, args, {
+    logger.debug(`Spawning update command: ${commandLine}`);
+    const childProcess4 = spawn2(commandLine, {
       shell: true,
       env: { ...process.env }
     });
@@ -55048,17 +55185,20 @@ async function getKitMetadata2(kitName) {
     return null;
   }
 }
-var versionCache, CACHE_TTL_MS;
+var import_compare_versions5, versionCache, CACHE_TTL_MS;
 var init_system_routes = __esm(() => {
   init_update_cli();
   init_github_client();
   init_npm_registry();
   init_package_manager_detector();
+  init_version_utils();
   init_version_checker();
+  init_claudekit_constants();
   init_logger();
   init_path_resolver();
   init_kit();
   init_package();
+  import_compare_versions5 = __toESM(require_umd(), 1);
   versionCache = new Map;
   CACHE_TTL_MS = 5 * 60 * 1000;
 });
@@ -60034,35 +60174,46 @@ var init_validators = __esm(() => {
 });
 
 // src/services/package-installer/npm-package-manager.ts
+function getNpmLookupTimeoutMs() {
+  return parseTimeoutMs(process.env.CK_NPM_LOOKUP_TIMEOUT_MS, DEFAULT_NPM_LOOKUP_TIMEOUT_MS, MIN_NPM_TIMEOUT_MS, MAX_NPM_TIMEOUT_MS);
+}
+function getNpmInstallTimeoutMs() {
+  return parseTimeoutMs(process.env.CK_NPM_INSTALL_TIMEOUT_MS, DEFAULT_NPM_INSTALL_TIMEOUT_MS, MIN_NPM_TIMEOUT_MS, MAX_NPM_TIMEOUT_MS);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 async function isPackageInstalled(packageName) {
   validatePackageName(packageName);
-  if (isCIEnvironment()) {
-    logger.info(`CI environment detected: skipping network check for ${packageName}`);
+  if (shouldSkipExpensiveOperations()) {
+    logger.info(`Expensive checks disabled: skipping global package check for ${packageName}`);
     return false;
   }
   if (packageName === "npm") {
     try {
-      await execAsync7(`${getNpmCommand()} --version`, { timeout: 3000 });
+      await execAsync7(`${getNpmCommand()} --version`, { timeout: getNpmLookupTimeoutMs() });
       return true;
     } catch {
       return false;
     }
   }
   try {
-    await execAsync7(`${getNpmCommand()} view ${packageName} version`, { timeout: 3000 });
+    await execAsync7(`${getNpmCommand()} view ${packageName} version`, {
+      timeout: getNpmLookupTimeoutMs()
+    });
     try {
-      const { stdout: stdout2 } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0`, {
-        timeout: 3000
+      const { stdout: jsonOutput } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0 --json`, {
+        timeout: getNpmLookupTimeoutMs()
       });
-      const caseInsensitiveMatch = stdout2.toLowerCase().includes(packageName.toLowerCase());
-      if (caseInsensitiveMatch) {
+      const packageList = JSON.parse(jsonOutput);
+      if (packageList.dependencies?.[packageName]) {
         return true;
       }
-      const { stdout: jsonOutput } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0 --json`, {
-        timeout: 3000
+      const { stdout: stdout2 } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0`, {
+        timeout: getNpmLookupTimeoutMs()
       });
-      const packageList = JSON.parse(jsonOutput);
-      return packageList.dependencies?.[packageName] || false;
+      const exactPattern = new RegExp(`(?:^|\\s|[├└│─]+)${escapeRegex(packageName)}@([^\\s\\n]+)(?:\\s|$)`, "m");
+      return exactPattern.test(stdout2);
     } catch {
       return false;
     }
@@ -60072,26 +60223,30 @@ async function isPackageInstalled(packageName) {
 }
 async function getPackageVersion(packageName) {
   validatePackageName(packageName);
-  if (isCIEnvironment()) {
-    logger.info(`CI environment detected: skipping version check for ${packageName}`);
+  if (shouldSkipExpensiveOperations()) {
+    logger.info(`Expensive checks disabled: skipping package version check for ${packageName}`);
     return null;
   }
   if (packageName === "npm") {
     try {
-      const { stdout: stdout2 } = await execAsync7(`${getNpmCommand()} --version`, { timeout: 3000 });
+      const { stdout: stdout2 } = await execAsync7(`${getNpmCommand()} --version`, {
+        timeout: getNpmLookupTimeoutMs()
+      });
       return stdout2.trim();
     } catch {
       return null;
     }
   }
   try {
-    await execAsync7(`${getNpmCommand()} view ${packageName} version`, { timeout: 3000 });
+    await execAsync7(`${getNpmCommand()} view ${packageName} version`, {
+      timeout: getNpmLookupTimeoutMs()
+    });
   } catch {
     return null;
   }
   try {
     const { stdout: jsonOutput } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0 --json`, {
-      timeout: 3000
+      timeout: getNpmLookupTimeoutMs()
     });
     const packageList = JSON.parse(jsonOutput);
     if (packageList.dependencies?.[packageName]) {
@@ -60100,11 +60255,11 @@ async function getPackageVersion(packageName) {
   } catch {}
   try {
     const { stdout: stdout2 } = await execAsync7(`${getNpmCommand()} list -g ${packageName} --depth=0`, {
-      timeout: 3000
+      timeout: getNpmLookupTimeoutMs()
     });
     const patterns = [
-      new RegExp(`${packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}@([^\\s\\n]+)`),
-      new RegExp(`${packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}@([0-9]+\\.[0-9]+\\.[0-9]+(?:-[\\w.-]+)?)`)
+      new RegExp(`${escapeRegex(packageName)}@([^\\s\\n]+)`),
+      new RegExp(`${escapeRegex(packageName)}@([0-9]+\\.[0-9]+\\.[0-9]+(?:-[\\w.-]+)?)`)
     ];
     for (const pattern of patterns) {
       const match = stdout2.match(pattern);
@@ -60123,8 +60278,15 @@ async function installPackageGlobally(packageName, packageDisplayName) {
   try {
     logger.info(`Installing ${displayName} globally...`);
     await execAsync7(`${getNpmCommand()} install -g ${packageName}`, {
-      timeout: 120000
+      timeout: getNpmInstallTimeoutMs()
     });
+    if (shouldSkipExpensiveOperations()) {
+      logger.info(`Expensive checks disabled: skipping post-install verification for ${displayName}`);
+      return {
+        success: true,
+        package: displayName
+      };
+    }
     const isInstalled = await isPackageInstalled(packageName);
     if (!isInstalled) {
       return {
@@ -60150,6 +60312,7 @@ async function installPackageGlobally(packageName, packageDisplayName) {
     };
   }
 }
+var DEFAULT_NPM_LOOKUP_TIMEOUT_MS = 3000, DEFAULT_NPM_INSTALL_TIMEOUT_MS = 120000, MIN_NPM_TIMEOUT_MS = 500, MAX_NPM_TIMEOUT_MS = 300000;
 var init_npm_package_manager = __esm(() => {
   init_environment();
   init_logger();
@@ -60909,37 +61072,54 @@ __export(exports_package_installer, {
 async function processPackageInstallations(shouldInstallOpenCode, shouldInstallGemini, projectDir) {
   const results = {};
   if (shouldInstallOpenCode) {
-    const alreadyInstalled = await isOpenCodeInstalled();
-    if (alreadyInstalled) {
-      logger.info("OpenCode CLI already installed");
+    if (isTestEnvironment()) {
       results.opencode = {
         success: true,
-        package: "OpenCode CLI"
+        package: "OpenCode CLI",
+        skipped: true
       };
     } else {
-      results.opencode = await installOpenCode();
+      const alreadyInstalled = await isOpenCodeInstalled();
+      if (alreadyInstalled) {
+        logger.info("OpenCode CLI already installed");
+        results.opencode = {
+          success: true,
+          package: "OpenCode CLI"
+        };
+      } else {
+        results.opencode = await installOpenCode();
+      }
     }
   }
   if (shouldInstallGemini) {
-    const alreadyInstalled = await isGeminiInstalled();
-    if (alreadyInstalled) {
-      logger.info("Google Gemini CLI already installed");
+    if (isTestEnvironment()) {
       results.gemini = {
         success: true,
-        package: "Google Gemini CLI"
+        package: "Google Gemini CLI",
+        skipped: true
       };
     } else {
-      results.gemini = await installGemini();
-    }
-    const geminiAvailable = alreadyInstalled || results.gemini?.success;
-    if (projectDir && geminiAvailable) {
-      const { processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
-      await processGeminiMcpLinking2(projectDir);
+      const alreadyInstalled = await isGeminiInstalled();
+      if (alreadyInstalled) {
+        logger.info("Google Gemini CLI already installed");
+        results.gemini = {
+          success: true,
+          package: "Google Gemini CLI"
+        };
+      } else {
+        results.gemini = await installGemini();
+      }
+      const geminiAvailable = alreadyInstalled || results.gemini?.success;
+      if (projectDir && geminiAvailable) {
+        const { processGeminiMcpLinking: processGeminiMcpLinking2 } = await Promise.resolve().then(() => (init_gemini_mcp_linker(), exports_gemini_mcp_linker));
+        await processGeminiMcpLinking2(projectDir);
+      }
     }
   }
   return results;
 }
 var init_package_installer = __esm(() => {
+  init_environment();
   init_logger();
   init_gemini_installer();
   init_opencode_installer();
@@ -66866,11 +67046,12 @@ import { exec as exec6 } from "node:child_process";
 import { promisify as promisify12 } from "node:util";
 
 // src/domains/github/gh-cli-utils.ts
+init_environment();
 init_logger();
 import { readFileSync as readFileSync4 } from "node:fs";
 var MIN_GH_CLI_VERSION = "2.20.0";
 var GH_COMMAND_TIMEOUT_MS = 1e4;
-function compareVersions5(a3, b3) {
+function compareVersions6(a3, b3) {
   const partsA = a3.split(".").map(Number);
   const partsB = b3.split(".").map(Number);
   const maxLen = Math.max(partsA.length, partsB.length);
@@ -66895,11 +67076,8 @@ function isWSL2() {
     return false;
   }
 }
-function shouldSkipExpensiveOperations() {
-  if (process.env.CK_TEST_HOME) {
-    return false;
-  }
-  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+function shouldSkipExpensiveOperations2() {
+  return shouldSkipExpensiveOperations();
 }
 function getGhUpgradeInstructions(currentVersion) {
   const platform5 = process.platform;
@@ -66930,16 +67108,11 @@ function getGhUpgradeInstructions(currentVersion) {
 }
 
 // src/services/package-installer/dependency-checker.ts
+init_environment();
 init_logger();
 import { exec as exec3 } from "node:child_process";
 import { promisify as promisify9 } from "node:util";
 var execAsync3 = promisify9(exec3);
-function shouldSkipExpensiveOperations2() {
-  if (process.env.CK_TEST_HOME) {
-    return false;
-  }
-  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
-}
 function getOSInfo() {
   const platform5 = process.platform;
   const arch2 = process.arch;
@@ -67028,10 +67201,14 @@ var DEPENDENCIES = {
   }
 };
 async function commandExists(command) {
-  if (shouldSkipExpensiveOperations2()) {
+  if (shouldSkipExpensiveOperations()) {
     const supportedCommands = ["node", "python", "python3", "pip", "pip3", "claude"];
     return supportedCommands.includes(command);
   }
+  if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
+    logger.verbose(`Invalid command name rejected: ${command}`);
+    return false;
+  }
   try {
     const whichCmd = process.platform === "win32" ? "where" : "which";
     logger.verbose(`Checking if command exists: ${command}`);
@@ -67044,11 +67221,14 @@ async function commandExists(command) {
   }
 }
 async function getCommandPath(command) {
-  if (shouldSkipExpensiveOperations2()) {
+  if (shouldSkipExpensiveOperations()) {
     const ciPath = getCICommandPath(command);
     if (ciPath)
       return ciPath;
   }
+  if (!/^[a-zA-Z0-9_-]+$/.test(command)) {
+    return null;
+  }
   try {
     const whichCmd = process.platform === "win32" ? "where" : "which";
     logger.verbose(`Getting path for command: ${command}`);
@@ -67063,7 +67243,7 @@ async function getCommandPath(command) {
   }
 }
 async function getCommandVersion(command, versionFlag, versionRegex) {
-  if (shouldSkipExpensiveOperations2()) {
+  if (shouldSkipExpensiveOperations()) {
     const mockVersions = {
       npm: "10.0.0",
       node: "20.0.0",
@@ -67075,6 +67255,9 @@ async function getCommandVersion(command, versionFlag, versionRegex) {
     };
     return mockVersions[command] || null;
   }
+  if (!/^[a-zA-Z0-9_-]+$/.test(command) || !/^--?[a-zA-Z0-9_-]+$/.test(versionFlag)) {
+    return null;
+  }
   try {
     logger.verbose(`Getting version for: ${command} ${versionFlag}`);
     const { stdout, stderr } = await execAsync3(`${command} ${versionFlag}`);
@@ -67089,7 +67272,7 @@ async function getCommandVersion(command, versionFlag, versionRegex) {
     return null;
   }
 }
-function compareVersions6(current, required) {
+function compareVersions7(current, required) {
   const parseCurrent = current.split(".").map((n) => Number.parseInt(n, 10));
   const parseRequired = required.split(".").map((n) => Number.parseInt(n, 10));
   for (let i = 0;i < 3; i++) {
@@ -67113,7 +67296,7 @@ async function checkDependency(config) {
       let meetsRequirements = true;
       let message;
       if (config.minVersion && version) {
-        meetsRequirements = compareVersions6(version, config.minVersion);
+        meetsRequirements = compareVersions7(version, config.minVersion);
         if (!meetsRequirements) {
           message = `Version ${version} is below minimum ${config.minVersion}`;
         }
@@ -67386,7 +67569,7 @@ class SystemChecker {
       logger.verbose(`SystemChecker: Processing ${dep.name}`);
       results.push(await this.mapDependencyToCheck(dep));
     }
-    if (!shouldSkipExpensiveOperations()) {
+    if (!shouldSkipExpensiveOperations2()) {
       logger.verbose("SystemChecker: Checking git");
       results.push(await this.checkGit());
       logger.verbose("SystemChecker: Checking GitHub CLI");
@@ -67508,7 +67691,7 @@ class SystemChecker {
       const { stdout } = await execAsync6("gh --version");
       const match = stdout.match(/(\d+\.\d+\.\d+)/);
       const version = match?.[1];
-      if (version && compareVersions5(version, MIN_GH_CLI_VERSION) < 0) {
+      if (version && compareVersions6(version, MIN_GH_CLI_VERSION) < 0) {
         return {
           id: "gh-cli-version",
           name: "GitHub CLI",
@@ -67630,6 +67813,7 @@ function checkProjectInstall(setup) {
 }
 // src/domains/health-checks/checkers/cli-install-checker.ts
 init_package_manager_detector();
+init_claudekit_constants();
 init_logger();
 async function checkCliInstallMethod() {
   if (false) {}
@@ -67643,7 +67827,7 @@ async function checkCliInstallMethod() {
     priority: "standard",
     status: pm !== "unknown" ? "pass" : "warn",
     message: pmVersion ? `${displayName} (v${pmVersion})` : displayName,
-    suggestion: pm === "unknown" ? "Run: npm install -g claudekit-cli" : undefined,
+    suggestion: pm === "unknown" ? `Install with one of: ${CLAUDEKIT_CLI_INSTALL_COMMANDS.join(" | ")}` : undefined,
     autoFixable: false
   };
 }
@@ -67832,11 +68016,9 @@ import { constants as constants2, access as access2, unlink as unlink6, writeFil
 import { join as join44 } from "node:path";
 
 // src/domains/health-checks/checkers/shared.ts
+init_environment();
 function shouldSkipExpensiveOperations3() {
-  if (process.env.CK_TEST_HOME) {
-    return false;
-  }
-  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+  return shouldSkipExpensiveOperations();
 }
 var HOOK_EXTENSIONS = [".js", ".cjs", ".mjs", ".ts", ".sh", ".ps1"];
 
@@ -68538,6 +68720,7 @@ async function checkEnvKeys(setup) {
   return results;
 }
 // src/domains/health-checks/checkers/hook-health-checker.ts
+init_claudekit_constants();
 init_logger();
 init_path_resolver();
 import { spawnSync as spawnSync2 } from "node:child_process";
@@ -69165,7 +69348,7 @@ async function checkCliVersion() {
         autoFixable: false
       };
     }
-    const npmResult = spawnSync2("npm", ["view", "claudekit-cli", "version"], {
+    const npmResult = spawnSync2("npm", ["view", CLAUDEKIT_CLI_NPM_PACKAGE_NAME, "version"], {
       timeout: HOOK_CHECK_TIMEOUT_MS,
       encoding: "utf-8"
     });
@@ -69730,16 +69913,13 @@ class AuthChecker {
 import { platform as platform6 } from "node:os";
 
 // src/domains/health-checks/platform/environment-checker.ts
+init_environment();
 init_path_resolver();
 import { constants as constants3, access as access3, mkdir as mkdir12, readFile as readFile31, unlink as unlink7, writeFile as writeFile15 } from "node:fs/promises";
 import { arch as arch2, homedir as homedir24, platform as platform5 } from "node:os";
 import { join as join53, normalize as normalize6 } from "node:path";
-var IS_WINDOWS = platform5() === "win32";
 function shouldSkipExpensiveOperations4() {
-  if (process.env.CK_TEST_HOME) {
-    return false;
-  }
-  return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true";
+  return shouldSkipExpensiveOperations();
 }
 async function checkPlatformDetect() {
   const os5 = platform5();
@@ -69760,7 +69940,8 @@ async function checkPlatformDetect() {
 }
 async function checkHomeDirResolution() {
   const nodeHome = normalize6(homedir24());
-  const envHome = normalize6(IS_WINDOWS ? process.env.USERPROFILE || "" : process.env.HOME || "");
+  const rawEnvHome = getHomeDirectoryFromEnv(platform5());
+  const envHome = rawEnvHome ? normalize6(rawEnvHome) : "";
   const match = nodeHome === envHome && envHome !== "";
   return {
     id: "home-dir-resolution",
@@ -69994,7 +70175,7 @@ async function checkSymlinkSupport() {
 }
 
 // src/domains/health-checks/platform-checker.ts
-var IS_WINDOWS2 = platform6() === "win32";
+var IS_WINDOWS = platform6() === "win32";
 
 class PlatformChecker {
   group = "platform";
@@ -70002,7 +70183,7 @@ class PlatformChecker {
     const results = [];
     results.push(await checkPlatformDetect());
     results.push(await checkHomeDirResolution());
-    if (IS_WINDOWS2) {
+    if (IS_WINDOWS) {
       results.push(await checkEnvVarExpansion());
     }
     results.push(await checkGlobalDirAccess());
@@ -70010,7 +70191,7 @@ class PlatformChecker {
     if (this.isWSL()) {
       results.push(await checkWSLBoundary());
     }
-    if (IS_WINDOWS2) {
+    if (IS_WINDOWS) {
       results.push(await checkLongPathSupport());
       results.push(await checkSymlinkSupport());
     }
@@ -70021,13 +70202,21 @@ class PlatformChecker {
   }
 }
 // src/domains/health-checks/network-checker.ts
+init_claudekit_constants();
+init_environment();
 init_logger();
-var NETWORK_TIMEOUT = Number.parseInt(process.env.CLAUDEKIT_NETWORK_TIMEOUT || "3000", 10);
+function getNetworkTimeoutMs() {
+  const raw = process.env.CLAUDEKIT_NETWORK_TIMEOUT;
+  if (raw && Number.isNaN(Number.parseInt(raw, 10))) {
+    logger.warning(`Invalid CLAUDEKIT_NETWORK_TIMEOUT value "${raw}", using default ${DEFAULT_NETWORK_TIMEOUT_MS}ms`);
+  }
+  return parseTimeoutMs(raw, DEFAULT_NETWORK_TIMEOUT_MS);
+}
 
 class NetworkChecker {
   group = "network";
   async run() {
-    if (this.isCI()) {
+    if (this.shouldSkipChecks()) {
       logger.verbose("NetworkChecker: Skipping in CI environment");
       return [];
     }
@@ -70037,8 +70226,8 @@ class NetworkChecker {
     results.push(await this.checkApiGitHub());
     return results;
   }
-  isCI() {
-    return process.env.CI === "true" || process.env.CI_SAFE_MODE === "true" || false || process.env.VITEST === "true" || process.env.JEST_WORKER_ID !== undefined || process.env.TEST === "true";
+  shouldSkipChecks() {
+    return isCIEnvironment() || isTestEnvironment();
   }
   checkProxyDetected() {
     const httpProxy = process.env.HTTP_PROXY || process.env.http_proxy;
@@ -70080,7 +70269,7 @@ class NetworkChecker {
     try {
       const response = await fetch("https://github.com", {
         method: "HEAD",
-        signal: AbortSignal.timeout(NETWORK_TIMEOUT)
+        signal: AbortSignal.timeout(getNetworkTimeoutMs())
       });
       const latency = Date.now() - startTime;
       if (response.ok || response.status === 301 || response.status === 302) {
@@ -70112,7 +70301,7 @@ class NetworkChecker {
         group: "network",
         priority: "standard",
         status: "fail",
-        message: isTimeout ? `Timeout (>${NETWORK_TIMEOUT}ms)` : "Connection failed",
+        message: isTimeout ? `Timeout (>${getNetworkTimeoutMs()}ms)` : "Connection failed",
         suggestion: "Check internet connection or proxy settings",
         autoFixable: false
       };
@@ -70125,9 +70314,9 @@ class NetworkChecker {
         method: "GET",
         headers: {
           Accept: "application/vnd.github.v3+json",
-          "User-Agent": "claudekit-cli"
+          "User-Agent": getCliUserAgent()
         },
-        signal: AbortSignal.timeout(NETWORK_TIMEOUT)
+        signal: AbortSignal.timeout(getNetworkTimeoutMs())
       });
       const latency = Date.now() - startTime;
       if (response.ok) {
@@ -70159,7 +70348,7 @@ class NetworkChecker {
         group: "network",
         priority: "standard",
         status: "fail",
-        message: isTimeout ? `Timeout (>${NETWORK_TIMEOUT}ms)` : "Connection failed",
+        message: isTimeout ? `Timeout (>${getNetworkTimeoutMs()}ms)` : "Connection failed",
         suggestion: "Check internet connection or proxy settings for api.github.com",
         autoFixable: false
       };
@@ -70249,7 +70438,7 @@ import { fileURLToPath as fileURLToPath3 } from "node:url";
 init_environment();
 init_logger();
 init_dist2();
-function getCliVersion3() {
+function getCliVersion4() {
   try {
     const __dirname4 = dirname13(fileURLToPath3(import.meta.url));
     const pkgPath = join55(__dirname4, "../../../package.json");
@@ -70419,7 +70608,7 @@ class ReportGenerator {
       osVersion: osInfo.details,
       node: process.version,
       cwd: this.scrubPath(process.cwd()),
-      cliVersion: getCliVersion3()
+      cliVersion: getCliVersion4()
     };
   }
   scrubPath(path5) {
@@ -70712,9 +70901,10 @@ async function easterEggCommand() {
 init_github_client();
 
 // src/domains/sync/config-version-checker.ts
+init_claudekit_constants();
 init_logger();
 init_path_resolver();
-var import_compare_versions5 = __toESM(require_umd(), 1);
+var import_compare_versions6 = __toESM(require_umd(), 1);
 import { mkdir as mkdir14, readFile as readFile32, unlink as unlink9, writeFile as writeFile17 } from "node:fs/promises";
 import { join as join56 } from "node:path";
 var CACHE_TTL_HOURS = 24;
@@ -70790,7 +70980,7 @@ class ConfigVersionChecker {
       try {
         const headers = {
           Accept: "application/vnd.github.v3+json",
-          "User-Agent": "claudekit-cli"
+          "User-Agent": getCliUserAgent()
         };
         const githubToken = process.env.GITHUB_TOKEN;
         if (githubToken) {
@@ -70850,7 +71040,7 @@ class ConfigVersionChecker {
     const cache3 = await ConfigVersionChecker.loadCache(kitType, global3);
     const now = Date.now();
     if (cache3 && now - cache3.lastCheck < CACHE_TTL_MS2) {
-      const hasUpdates = import_compare_versions5.compareVersions(cache3.latestVersion, normalizedCurrent) > 0;
+      const hasUpdates = import_compare_versions6.compareVersions(cache3.latestVersion, normalizedCurrent) > 0;
       return {
         hasUpdates,
         currentVersion: normalizedCurrent,
@@ -70864,7 +71054,7 @@ class ConfigVersionChecker {
         ...cache3,
         lastCheck: now
       });
-      const hasUpdates = import_compare_versions5.compareVersions(cache3.latestVersion, normalizedCurrent) > 0;
+      const hasUpdates = import_compare_versions6.compareVersions(cache3.latestVersion, normalizedCurrent) > 0;
       return {
         hasUpdates,
         currentVersion: normalizedCurrent,
@@ -70878,7 +71068,7 @@ class ConfigVersionChecker {
         latestVersion: result.version,
         etag: result.etag
       });
-      const hasUpdates = import_compare_versions5.compareVersions(result.version, normalizedCurrent) > 0;
+      const hasUpdates = import_compare_versions6.compareVersions(result.version, normalizedCurrent) > 0;
       return {
         hasUpdates,
         currentVersion: normalizedCurrent,
@@ -70887,7 +71077,7 @@ class ConfigVersionChecker {
       };
     }
     if (cache3) {
-      const hasUpdates = import_compare_versions5.compareVersions(cache3.latestVersion, normalizedCurrent) > 0;
+      const hasUpdates = import_compare_versions6.compareVersions(cache3.latestVersion, normalizedCurrent) > 0;
       return {
         hasUpdates,
         currentVersion: normalizedCurrent,
@@ -86829,7 +87019,7 @@ init_logger();
 import { readFile as readFile45, readdir as readdir30, writeFile as writeFile26 } from "node:fs/promises";
 import { platform as platform12 } from "node:os";
 import { extname as extname4, join as join97 } from "node:path";
-var IS_WINDOWS3 = platform12() === "win32";
+var IS_WINDOWS2 = platform12() === "win32";
 function getOpenCodeGlobalPath() {
   return "$HOME/.config/opencode/";
 }
@@ -87049,16 +87239,7 @@ async function handlePostInstall(ctx) {
     return ctx;
   }
   if (ctx.options.global) {
-    const claudeMdSource = join99(ctx.extractDir, "CLAUDE.md");
-    const claudeMdDest = join99(ctx.resolvedDir, "CLAUDE.md");
-    if (await import_fs_extra30.pathExists(claudeMdSource)) {
-      if (!await import_fs_extra30.pathExists(claudeMdDest)) {
-        await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
-        logger.success("Copied CLAUDE.md to global directory");
-      } else {
-        logger.debug("CLAUDE.md already exists in global directory (preserved)");
-      }
-    }
+    await handleGlobalClaudeMd(ctx);
   }
   let installSkills = ctx.options.installSkills;
   if (!ctx.isNonInteractive && !installSkills) {
@@ -87118,6 +87299,49 @@ async function handlePostInstall(ctx) {
     installSkills
   };
 }
+function normalizeLineEndings(content) {
+  return content.replace(/\r\n/g, `
+`);
+}
+async function handleGlobalClaudeMd(ctx) {
+  if (!ctx.extractDir || !ctx.resolvedDir)
+    return;
+  const claudeMdSource = join99(ctx.extractDir, "CLAUDE.md");
+  const claudeMdDest = join99(ctx.resolvedDir, "CLAUDE.md");
+  if (!await import_fs_extra30.pathExists(claudeMdSource))
+    return;
+  const destExists = await import_fs_extra30.pathExists(claudeMdDest);
+  if (!destExists) {
+    await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
+    logger.success("Copied CLAUDE.md to global directory");
+    return;
+  }
+  if (ctx.options.fresh || ctx.options.forceOverwrite) {
+    await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
+    logger.success("Updated CLAUDE.md in global directory");
+    return;
+  }
+  const [srcContent, destContent] = await Promise.all([
+    import_fs_extra30.readFile(claudeMdSource, "utf-8"),
+    import_fs_extra30.readFile(claudeMdDest, "utf-8")
+  ]);
+  if (normalizeLineEndings(srcContent) === normalizeLineEndings(destContent)) {
+    logger.debug("CLAUDE.md already up to date");
+    return;
+  }
+  if (!ctx.isNonInteractive) {
+    const shouldOverwrite = await ctx.prompts.confirm(`CLAUDE.md has changed in the new version. Update it?
+  (Your customizations will be replaced)`);
+    if (!shouldOverwrite) {
+      logger.info("CLAUDE.md preserved (user chose to keep existing)");
+      return;
+    }
+  } else {
+    logger.warning("Updating CLAUDE.md (content differs from new version)");
+  }
+  await import_fs_extra30.copy(claudeMdSource, claudeMdDest);
+  logger.success("Updated CLAUDE.md (new version detected)");
+}
 // src/commands/init/phases/selection-handler.ts
 init_config_manager();
 init_github_client();
@@ -87175,7 +87399,7 @@ function isTimeoutError(error) {
 }
 async function runPreflightChecks() {
   logger.debug("Running GitHub CLI pre-flight checks");
-  if (shouldSkipExpensiveOperations()) {
+  if (shouldSkipExpensiveOperations2()) {
     logger.debug("Skipping preflight checks in test/CI environment");
     return createSuccessfulPreflightResult();
   }
@@ -87217,7 +87441,7 @@ async function runPreflightChecks() {
     return result;
   }
   if (result.ghVersion) {
-    const comparison = compareVersions5(result.ghVersion, MIN_GH_CLI_VERSION);
+    const comparison = compareVersions6(result.ghVersion, MIN_GH_CLI_VERSION);
     result.ghVersionOk = comparison >= 0;
     if (!result.ghVersionOk) {
       logger.debug(`GitHub CLI version ${result.ghVersion} is below minimum ${MIN_GH_CLI_VERSION}`);
@@ -87779,7 +88003,7 @@ async function handleSelection(ctx) {
   };
 }
 // src/commands/init/phases/sync-handler.ts
-import { copyFile as copyFile7, mkdir as mkdir29, open as open4, readFile as readFile47, rename as rename5, stat as stat17, unlink as unlink10, writeFile as writeFile28 } from "node:fs/promises";
+import { copyFile as copyFile7, mkdir as mkdir29, open as open4, readFile as readFile48, rename as rename5, stat as stat17, unlink as unlink10, writeFile as writeFile28 } from "node:fs/promises";
 import { dirname as dirname21, join as join102, resolve as resolve20 } from "node:path";
 init_logger();
 init_path_resolver();
@@ -87947,7 +88171,7 @@ async function executeSyncMerge(ctx) {
     try {
       const sourceMetadataPath = join102(upstreamDir, "metadata.json");
       if (await import_fs_extra33.pathExists(sourceMetadataPath)) {
-        const content = await readFile47(sourceMetadataPath, "utf-8");
+        const content = await readFile48(sourceMetadataPath, "utf-8");
         const sourceMetadata = JSON.parse(content);
         deletions = sourceMetadata.deletions || [];
       }
@@ -88245,7 +88469,7 @@ async function renameFolders(dirsToRename, extractDir, options2) {
 // src/services/transformers/folder-transform/path-replacer.ts
 init_logger();
 init_types3();
-import { readFile as readFile48, readdir as readdir32, writeFile as writeFile29 } from "node:fs/promises";
+import { readFile as readFile49, readdir as readdir32, writeFile as writeFile29 } from "node:fs/promises";
 import { join as join104, relative as relative18 } from "node:path";
 var TRANSFORMABLE_FILE_PATTERNS = [
   ".md",
@@ -88312,7 +88536,7 @@ async function transformFileContents(dir, compiledReplacements, options2) {
       if (!shouldTransform)
         continue;
       try {
-        const content = await readFile48(fullPath, "utf-8");
+        const content = await readFile49(fullPath, "utf-8");
         let newContent = content;
         let changeCount = 0;
         for (const { regex: regex2, replacement } of compiledReplacements) {
@@ -88434,11 +88658,11 @@ async function transformFolderPaths(extractDir, folders, options2 = {}) {
 
 // src/services/transformers/global-path-transformer.ts
 init_logger();
-import { readFile as readFile49, readdir as readdir33, writeFile as writeFile30 } from "node:fs/promises";
+import { readFile as readFile50, readdir as readdir33, writeFile as writeFile30 } from "node:fs/promises";
 import { platform as platform13 } from "node:os";
 import { extname as extname5, join as join105 } from "node:path";
-var IS_WINDOWS4 = platform13() === "win32";
-var HOME_PREFIX = IS_WINDOWS4 ? "%USERPROFILE%" : "$HOME";
+var IS_WINDOWS3 = platform13() === "win32";
+var HOME_PREFIX = IS_WINDOWS3 ? "%USERPROFILE%" : "$HOME";
 function getHomeDirPrefix() {
   return HOME_PREFIX;
 }
@@ -88459,7 +88683,7 @@ function transformContent(content) {
   let transformed = content;
   const homePrefix = getHomeDirPrefix();
   const claudePath = `${homePrefix}/.claude/`;
-  if (IS_WINDOWS4) {
+  if (IS_WINDOWS3) {
     transformed = transformed.replace(/\$HOME\/\.claude\//g, () => {
       changes++;
       return claudePath;
@@ -88489,7 +88713,7 @@ function transformContent(content) {
     changes++;
     return claudePath;
   });
-  if (IS_WINDOWS4) {
+  if (IS_WINDOWS3) {
     transformed = transformed.replace(/%CLAUDE_PROJECT_DIR%\/\.claude\//g, () => {
       changes++;
       return claudePath;
@@ -88554,7 +88778,7 @@ async function transformPathsForGlobalInstall(directory, options2 = {}) {
         await processDirectory2(fullPath);
       } else if (entry.isFile() && shouldTransformFile3(entry.name)) {
         try {
-          const content = await readFile49(fullPath, "utf-8");
+          const content = await readFile50(fullPath, "utf-8");
           const { transformed, changes } = transformContent(content);
           if (changes > 0) {
             await writeFile30(fullPath, transformed, "utf-8");
@@ -88816,7 +89040,7 @@ init_checksum_utils();
 init_config_discovery();
 var import_picocolors25 = __toESM(require_picocolors(), 1);
 import { existsSync as existsSync50 } from "node:fs";
-import { readFile as readFile50, rm as rm12, unlink as unlink11 } from "node:fs/promises";
+import { readFile as readFile51, rm as rm12, unlink as unlink11 } from "node:fs/promises";
 import { resolve as resolve21 } from "node:path";
 
 // src/commands/portable/conflict-resolver.ts
@@ -89390,7 +89614,7 @@ async function migrateCommand(options2) {
       for (const action of conflictActions) {
         if (!action.diff && action.targetPath && existsSync50(action.targetPath)) {
           try {
-            const targetContent = await readFile50(action.targetPath, "utf-8");
+            const targetContent = await readFile51(action.targetPath, "utf-8");
             const sourceItem = agents2.find((a3) => a3.name === action.item) || commands.find((c2) => c2.name === action.item) || (configItem?.name === action.item ? configItem : null) || ruleItems.find((r2) => r2.name === action.item);
             if (sourceItem) {
               const providerConfig = providers[action.provider];
@@ -89584,7 +89808,7 @@ async function computeTargetStates(selectedProviders, global3) {
       continue;
     try {
       if (existsSync50(entry.path)) {
-        const content = await readFile50(entry.path, "utf-8");
+        const content = await readFile51(entry.path, "utf-8");
         states.set(entry.path, {
           path: entry.path,
           exists: true,
@@ -91888,6 +92112,8 @@ class OutputManager2 {
   shouldShowProgress() {
     if (this.config.json)
       return false;
+    if (this.config.quiet)
+      return false;
     if (!isTTY())
       return false;
     return true;