claudekit-cli 3.41.1 → 3.41.2-dev.1

package/dist/index.js

@@ -14880,7 +14880,7 @@ var init_ck_config = __esm(() => {
     "gemini-3-flash": "gemini-3-flash-preview",
     "gemini-3-pro": "gemini-3-pro-preview"
   };
-  GeminiModelSchema = exports_external.enum(GEMINI_MODEL_VALUES);
+  GeminiModelSchema = exports_external.string().default("gemini-3-flash-preview");
   StatuslineModeSchema = exports_external.enum(["full", "compact", "minimal", "none"]);
   StatuslineSectionIdSchema = exports_external.enum([
     "model",
@@ -15193,6 +15193,7 @@ __export(exports_types, {
   GitHubReleaseAssetSchema: () => GitHubReleaseAssetSchema,
   GitHubError: () => GitHubError,
   GeminiModelSchema: () => GeminiModelSchema,
+  GEMINI_MODEL_VALUES: () => GEMINI_MODEL_VALUES,
   FrameworkSchema: () => FrameworkSchema,
   FoldersConfigSchema: () => FoldersConfigSchema,
   ExtractionError: () => ExtractionError,
@@ -47783,6 +47784,14 @@ async function isActionPathAllowed(dirPath, projectId) {
       return false;
     return resolve6(project.path) === dirPath;
   }
+  if (projectId?.startsWith("discovered-")) {
+    try {
+      const encodedPath = projectId.slice("discovered-".length);
+      const discoveredPath = Buffer.from(encodedPath, "base64url").toString("utf-8");
+      if (resolve6(discoveredPath) === dirPath)
+        return true;
+    } catch {}
+  }
   const registeredProjects = await ProjectsRegistryManager.listProjects();
   if (registeredProjects.some((project) => resolve6(project.path) === dirPath)) {
     return true;
@@ -56492,6 +56501,11 @@ var init_skill_routes = __esm(() => {
 });
 
 // src/domains/github/npm-registry.ts
+var exports_npm_registry = {};
+__export(exports_npm_registry, {
+  redactRegistryUrlForLog: () => redactRegistryUrlForLog,
+  NpmRegistryClient: () => NpmRegistryClient
+});
 function redactRegistryUrlForLog(url) {
   if (!url)
     return url;
@@ -57188,170 +57202,120 @@ var init_package_manager_detector = __esm(() => {
   };
 });
 
-// src/domains/migration/metadata-migration.ts
-import { join as join45 } from "node:path";
-async function detectMetadataFormat(claudeDir2) {
-  const metadataPath = join45(claudeDir2, "metadata.json");
-  if (!await import_fs_extra3.pathExists(metadataPath)) {
-    return { format: "none", metadata: null, detectedKit: null };
-  }
-  try {
-    const content = await import_fs_extra3.readFile(metadataPath, "utf-8");
-    const parsed = JSON.parse(content);
-    if (parsed.kits && Object.keys(parsed.kits).length > 0) {
-      const installedKits = Object.keys(parsed.kits);
-      return {
-        format: "multi-kit",
-        metadata: parsed,
-        detectedKit: installedKits[0] || null
-      };
-    }
-    if (parsed.name || parsed.version || parsed.files) {
-      let detectedKit = null;
-      const nameToCheck = parsed.name || "";
-      if (/\bengineer\b/i.test(nameToCheck)) {
-        detectedKit = "engineer";
-      } else if (/\bmarketing\b/i.test(nameToCheck)) {
-        detectedKit = "marketing";
-      } else {
-        detectedKit = "engineer";
-      }
-      return { format: "legacy", metadata: parsed, detectedKit };
-    }
-    logger.warning("Metadata file exists but has unrecognized format (missing kits, name, version, or files)");
-    return { format: "none", metadata: null, detectedKit: null };
-  } catch (error) {
-    logger.warning(`Failed to read metadata file (may be corrupted): ${error}`);
-    return { format: "none", metadata: null, detectedKit: null };
-  }
-}
-async function migrateToMultiKit(claudeDir2) {
-  const detection = await detectMetadataFormat(claudeDir2);
-  if (detection.format === "multi-kit") {
-    return {
-      success: true,
-      migrated: false,
-      fromFormat: "multi-kit",
-      toFormat: "multi-kit"
-    };
-  }
-  if (detection.format === "none") {
-    return {
-      success: true,
-      migrated: false,
-      fromFormat: "none",
-      toFormat: "multi-kit"
-    };
-  }
-  const metadataPath = join45(claudeDir2, "metadata.json");
-  const legacy = detection.metadata;
-  if (!legacy) {
-    return {
-      success: false,
-      migrated: false,
-      fromFormat: "legacy",
-      toFormat: "multi-kit",
-      error: "Metadata exists but could not be read"
-    };
-  }
-  const legacyKit = detection.detectedKit || "engineer";
-  try {
-    const kitMetadata = {
-      version: legacy.version || "unknown",
-      installedAt: legacy.installedAt || new Date().toISOString(),
-      files: legacy.files || []
-    };
-    const multiKit = {
-      kits: {
-        [legacyKit]: kitMetadata
-      },
-      scope: legacy.scope,
-      name: legacy.name,
-      version: legacy.version,
-      installedAt: legacy.installedAt,
-      installedFiles: legacy.installedFiles,
-      userConfigFiles: legacy.userConfigFiles,
-      files: legacy.files
-    };
-    await import_fs_extra3.writeFile(metadataPath, JSON.stringify(multiKit, null, 2), "utf-8");
-    logger.info(`Migrated metadata from legacy format to multi-kit (detected: ${legacyKit})`);
-    return {
-      success: true,
-      migrated: true,
-      fromFormat: "legacy",
-      toFormat: "multi-kit"
-    };
-  } catch (error) {
-    const errorMsg = error instanceof Error ? error.message : "Unknown error";
-    logger.error(`Metadata migration failed: ${errorMsg}`);
-    return {
-      success: false,
-      migrated: false,
-      fromFormat: "legacy",
-      toFormat: "multi-kit",
-      error: errorMsg
-    };
-  }
-}
-function getKitMetadata(metadata, kit) {
-  if (metadata.kits?.[kit]) {
-    return metadata.kits[kit];
-  }
-  if (!metadata.kits && metadata.version) {
-    return {
-      version: metadata.version,
-      installedAt: metadata.installedAt || "",
-      files: metadata.files
-    };
-  }
-  return null;
-}
-function getAllTrackedFiles(metadata) {
-  if (metadata.kits) {
-    const allFiles = [];
-    for (const kit of Object.values(metadata.kits)) {
-      if (kit.files) {
-        allFiles.push(...kit.files);
-      }
+// package.json
+var package_default;
+var init_package = __esm(() => {
+  package_default = {
+    name: "claudekit-cli",
+    version: "3.41.2-dev.1",
+    description: "CLI tool for bootstrapping and updating ClaudeKit projects",
+    type: "module",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/mrgoonie/claudekit-cli.git"
+    },
+    publishConfig: {
+      access: "public",
+      registry: "https://registry.npmjs.org"
+    },
+    bin: {
+      ck: "bin/ck.js"
+    },
+    files: [
+      "bin/ck.js",
+      "dist/index.js",
+      "dist/ui/"
+    ],
+    scripts: {
+      tauri: "tauri",
+      "tauri:dev": "tauri dev",
+      "tauri:build": "tauri build",
+      dev: "bun run src/index.ts",
+      "dashboard:dev": "cd src/ui && bun install --silent && cd ../.. && bun run src/index.ts config ui --dev",
+      "dashboard:tauri": "cd src/ui && bun install --silent && cd ../.. && bun run src/index.ts config ui --dev --no-open --port 3456",
+      "ui:build": "cd src/ui && bun install --silent && bun run build",
+      "ui:dev": "cd src/ui && bun run dev",
+      build: `bun build src/index.ts --outdir dist --target node --external @octokit/rest --external better-sqlite3 && node -e "const fs=require('fs'),f='dist/index.js',c=fs.readFileSync(f,'utf-8');fs.writeFileSync(f,c.replace(/^#!.*\\n\\/\\/ @bun\\n/,''))"`,
+      "verify:package": "node scripts/prepublish-check.js",
+      test: "bun test",
+      "test:integration": "CK_RUN_CLI_INTEGRATION=1 bun test tests/integration/cli.test.ts",
+      "test:watch": "bun test --watch",
+      "test:quick": "./scripts/dev-quick-start.sh test",
+      lint: "biome check .",
+      "lint:fix": "biome check --fix .",
+      "lint:fix-unsafe": "biome check --fix --unsafe .",
+      format: "biome format --write .",
+      typecheck: "tsc --noEmit",
+      "dev:quick": "./scripts/dev-quick-start.sh",
+      "dev:all": "./scripts/dev-quick-start.sh all",
+      metrics: "bun run scripts/workflow-metrics.ts",
+      validate: "bun run typecheck && bun run lint && bun test && bun run build",
+      "install:hooks": "./.githooks/install.sh",
+      prepare: `node -e "try{require('child_process').execSync('git rev-parse --git-dir',{stdio:'ignore'});require('child_process').execSync('bash .githooks/install.sh',{stdio:'inherit'})}catch(e){console.warn('[i] Hook install skipped:',e.message)}"`
+    },
+    keywords: [
+      "cli",
+      "claudekit",
+      "boilerplate",
+      "bootstrap",
+      "template"
+    ],
+    author: "ClaudeKit",
+    license: "MIT",
+    engines: {
+      node: ">=18.0.0"
+    },
+    dependencies: {
+      "@clack/prompts": "^0.7.0",
+      "@octokit/rest": "^22.0.0",
+      "better-sqlite3": "^12.6.2",
+      cac: "^6.7.14",
+      chokidar: "^5.0.0",
+      "cli-progress": "^3.12.0",
+      "compare-versions": "^6.1.1",
+      diff: "^8.0.3",
+      express: "^5.2.1",
+      "extract-zip": "^2.0.1",
+      "fs-extra": "^11.2.0",
+      "get-port": "^7.1.0",
+      "gray-matter": "^4.0.3",
+      ignore: "^5.3.2",
+      minimatch: "^10.1.1",
+      open: "^11.0.0",
+      ora: "^8.0.0",
+      "p-limit": "^7.2.0",
+      picocolors: "^1.1.1",
+      picomatch: "^4.0.3",
+      "proper-lockfile": "^4.1.2",
+      semver: "^7.7.3",
+      tar: "^7.4.3",
+      tmp: "^0.2.3",
+      ws: "^8.19.0",
+      zod: "^3.23.8"
+    },
+    devDependencies: {
+      "@biomejs/biome": "^1.9.4",
+      "@semantic-release/changelog": "^6.0.3",
+      "@semantic-release/git": "^10.0.1",
+      "@tauri-apps/cli": "^2",
+      "@types/better-sqlite3": "^7.6.13",
+      "@types/bun": "latest",
+      "@types/cli-progress": "^3.11.6",
+      "@types/diff": "^8.0.0",
+      "@types/express": "^5.0.6",
+      "@types/fs-extra": "^11.0.4",
+      "@types/node": "^22.19.7",
+      "@types/picomatch": "^4.0.2",
+      "@types/proper-lockfile": "^4.1.4",
+      "@types/semver": "^7.7.1",
+      "@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"
     }
-    return allFiles;
-  }
-  return metadata.files || [];
-}
-function getTrackedFilesForKit(metadata, kitType) {
-  if (metadata.kits?.[kitType]) {
-    return metadata.kits[kitType].files || [];
-  }
-  const detectedKits = getInstalledKits(metadata);
-  if (detectedKits.includes(kitType)) {
-    return metadata.files || [];
-  }
-  return [];
-}
-function getInstalledKits(metadata) {
-  if (metadata.kits) {
-    return Object.keys(metadata.kits);
-  }
-  const nameToCheck = metadata.name || "";
-  const kits = [];
-  if (/\bengineer\b/i.test(nameToCheck)) {
-    kits.push("engineer");
-  }
-  if (/\bmarketing\b/i.test(nameToCheck)) {
-    kits.push("marketing");
-  }
-  if (kits.length > 0) {
-    return kits;
-  }
-  if (metadata.version) {
-    return ["engineer"];
-  }
-  return [];
-}
-var import_fs_extra3;
-var init_metadata_migration = __esm(() => {
-  init_logger();
-  import_fs_extra3 = __toESM(require_lib3(), 1);
+  };
 });
 
 // node_modules/compare-versions/lib/umd/index.js
@@ -57525,6 +57489,362 @@ var init_version_utils = __esm(() => {
   import_compare_versions = __toESM(require_umd(), 1);
 });
 
+// src/commands/update/error.ts
+var CliUpdateError;
+var init_error = __esm(() => {
+  init_types3();
+  CliUpdateError = class CliUpdateError extends ClaudeKitError {
+    constructor(message) {
+      super(message, "CLI_UPDATE_ERROR");
+      this.name = "CliUpdateError";
+    }
+  };
+});
+
+// src/commands/update/channel-resolver.ts
+async function resolveTargetVersion(opts, deps) {
+  const client = deps.npmRegistryClient ?? NpmRegistryClient;
+  const registryUrl = deps.registryUrl ?? undefined;
+  const { spinnerStop } = deps;
+  if (opts.release && opts.release !== "latest") {
+    let exists;
+    try {
+      exists = await client.versionExists(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, opts.release, registryUrl);
+    } catch (error) {
+      spinnerStop("Version check failed");
+      const message = error instanceof Error ? error.message : "Unknown error";
+      logger.verbose(`Release check failed for ${opts.release}: ${message}`);
+      const registryHint = registryUrl ? ` (${redactRegistryUrlForLog(registryUrl)})` : " (default registry)";
+      throw new CliUpdateError(`Failed to verify version ${opts.release} on npm registry${registryHint}. Check registry settings/network connectivity and try again.`);
+    }
+    if (!exists) {
+      spinnerStop("Version not found");
+      throw new CliUpdateError(`Version ${opts.release} does not exist on npm registry. Run 'ck versions' to see available versions.`);
+    }
+    const targetVersion2 = opts.release;
+    spinnerStop(`Target version: ${targetVersion2}`);
+    return { targetVersion: targetVersion2, targetIsPrerelease: isPrereleaseVersion(targetVersion2) };
+  }
+  const usePrereleaseChannel = opts.dev || opts.beta;
+  if (usePrereleaseChannel) {
+    let targetVersion2 = await client.getDevVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, registryUrl);
+    if (!targetVersion2) {
+      spinnerStop("No dev version available");
+      logger.warning("No dev version found. Using latest stable version instead.");
+      targetVersion2 = await client.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, registryUrl);
+    } else {
+      spinnerStop(`Latest dev version: ${targetVersion2}`);
+      return { targetVersion: targetVersion2, targetIsPrerelease: isPrereleaseVersion(targetVersion2) };
+    }
+    if (!targetVersion2) {
+      throw new CliUpdateError("Failed to fetch version information from npm registry. Check your internet connection and try again.");
+    }
+    spinnerStop(`Latest version: ${targetVersion2}`);
+    return { targetVersion: targetVersion2, targetIsPrerelease: isPrereleaseVersion(targetVersion2) };
+  }
+  const targetVersion = await client.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, registryUrl);
+  spinnerStop(`Latest version: ${targetVersion || "unknown"}`);
+  if (!targetVersion) {
+    throw new CliUpdateError("Failed to fetch version information from npm registry. Check your internet connection and try again.");
+  }
+  return { targetVersion, targetIsPrerelease: isPrereleaseVersion(targetVersion) };
+}
+var init_channel_resolver = __esm(() => {
+  init_npm_registry();
+  init_version_utils();
+  init_claudekit_constants();
+  init_logger();
+  init_error();
+});
+
+// src/commands/update/registry-client.ts
+function redactCommandForLog(command) {
+  if (!command)
+    return command;
+  const redactedRegistryFlags = command.replace(/(--registry(?:=|\s+))(['"]?)(\S+?)(\2)(?=\s|$)/g, (_match, prefix, quote, url) => `${prefix}${quote}${redactRegistryUrlForLog(url)}${quote}`);
+  return redactedRegistryFlags.replace(/https?:\/\/[^\s"']+/g, (url) => redactRegistryUrlForLog(url));
+}
+var init_registry_client = __esm(() => {
+  init_npm_registry();
+});
+
+// src/commands/update/version-comparator.ts
+function compareCliVersions(currentVersion, targetVersion, opts) {
+  const comparison = import_compare_versions2.compareVersions(currentVersion, targetVersion);
+  if (comparison === 0) {
+    return { status: "up-to-date" };
+  }
+  const isDevChannelSwitch = (opts.dev || opts.beta) && isPrereleaseVersion(targetVersion) && !isPrereleaseVersion(currentVersion);
+  if (isDevChannelSwitch) {
+    return { status: "dev-channel-switch", changeType: "upgrade" };
+  }
+  if (comparison > 0 && !opts.release) {
+    return { status: "newer", changeType: "downgrade" };
+  }
+  return { status: "older", changeType: comparison < 0 ? "upgrade" : "downgrade" };
+}
+function isBetaVersion(version) {
+  return isPrereleaseVersion(version);
+}
+function parseCliVersionFromOutput(output2) {
+  if (!output2)
+    return null;
+  const match = output2.match(/CLI Version:\s*(\S+)/);
+  return match ? match[1] : null;
+}
+var import_compare_versions2;
+var init_version_comparator = __esm(() => {
+  init_version_utils();
+  import_compare_versions2 = __toESM(require_umd(), 1);
+});
+
+// src/commands/update/package-manager-runner.ts
+function extractCommandStdout(result) {
+  if (typeof result === "string")
+    return result;
+  if (result && typeof result.stdout === "string")
+    return result.stdout;
+  return "";
+}
+async function runPackageManagerUpdate(updateCmd, pm, deps) {
+  const { execAsyncFn, spinnerStart, spinnerStop } = deps;
+  spinnerStart("Updating CLI...");
+  try {
+    await execAsyncFn(updateCmd, { timeout: 120000 });
+    spinnerStop("Update completed");
+  } catch (error) {
+    spinnerStop("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" ? `
+
+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}`);
+    }
+    logger.error(`Update failed: ${errorMessage}`);
+    logger.info(`Try running: ${updateCmd}`);
+    throw new CliUpdateError(`Update failed: ${errorMessage}
+
+Manual update: ${updateCmd}`);
+  }
+}
+async function verifyInstalledVersion(targetVersion, updateCmd, deps) {
+  const { execAsyncFn, spinnerStart, spinnerStop } = deps;
+  spinnerStart("Verifying installation...");
+  try {
+    const versionResult = await execAsyncFn("ck --version", { timeout: 5000 });
+    const stdout = extractCommandStdout(versionResult);
+    const activeVersion = parseCliVersionFromOutput(stdout);
+    if (!activeVersion) {
+      spinnerStop("Verification failed");
+      const message = `Update completed but could not parse 'ck --version' output.
+Please restart your terminal and run 'ck --version'. Expected: ${targetVersion}
+
+Manual update: ${redactCommandForLog(updateCmd)}`;
+      logger.error(message);
+      throw new CliUpdateError(message);
+    }
+    spinnerStop(`Installed version: ${activeVersion}`);
+    if (activeVersion !== targetVersion) {
+      const mismatchMessage = `Update did not activate the requested version.
+Expected: ${targetVersion}
+Active ck: ${activeVersion}
+
+Likely causes: multiple global installations (npm/bun/pnpm/yarn) or stale shell shim/cache (common on Windows).
+Run '${redactCommandForLog(updateCmd)}' manually, restart terminal, then check command resolution:
+- Windows: where ck
+- macOS/Linux: which -a ck`;
+      logger.error(mismatchMessage);
+      throw new CliUpdateError(mismatchMessage);
+    }
+    return activeVersion;
+  } catch (error) {
+    if (error instanceof CliUpdateError)
+      throw error;
+    spinnerStop("Verification failed");
+    const message = `Update completed but automatic verification failed.
+Please restart your terminal and run 'ck --version'. Expected: ${targetVersion}
+
+Manual update: ${redactCommandForLog(updateCmd)}`;
+    logger.error(message);
+    throw new CliUpdateError(message);
+  }
+}
+var init_package_manager_runner = __esm(() => {
+  init_logger();
+  init_error();
+  init_registry_client();
+  init_version_comparator();
+});
+
+// src/domains/migration/metadata-migration.ts
+import { join as join45 } from "node:path";
+async function detectMetadataFormat(claudeDir2) {
+  const metadataPath = join45(claudeDir2, "metadata.json");
+  if (!await import_fs_extra3.pathExists(metadataPath)) {
+    return { format: "none", metadata: null, detectedKit: null };
+  }
+  try {
+    const content = await import_fs_extra3.readFile(metadataPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (parsed.kits && Object.keys(parsed.kits).length > 0) {
+      const installedKits = Object.keys(parsed.kits);
+      return {
+        format: "multi-kit",
+        metadata: parsed,
+        detectedKit: installedKits[0] || null
+      };
+    }
+    if (parsed.name || parsed.version || parsed.files) {
+      let detectedKit = null;
+      const nameToCheck = parsed.name || "";
+      if (/\bengineer\b/i.test(nameToCheck)) {
+        detectedKit = "engineer";
+      } else if (/\bmarketing\b/i.test(nameToCheck)) {
+        detectedKit = "marketing";
+      } else {
+        detectedKit = "engineer";
+      }
+      return { format: "legacy", metadata: parsed, detectedKit };
+    }
+    logger.warning("Metadata file exists but has unrecognized format (missing kits, name, version, or files)");
+    return { format: "none", metadata: null, detectedKit: null };
+  } catch (error) {
+    logger.warning(`Failed to read metadata file (may be corrupted): ${error}`);
+    return { format: "none", metadata: null, detectedKit: null };
+  }
+}
+async function migrateToMultiKit(claudeDir2) {
+  const detection = await detectMetadataFormat(claudeDir2);
+  if (detection.format === "multi-kit") {
+    return {
+      success: true,
+      migrated: false,
+      fromFormat: "multi-kit",
+      toFormat: "multi-kit"
+    };
+  }
+  if (detection.format === "none") {
+    return {
+      success: true,
+      migrated: false,
+      fromFormat: "none",
+      toFormat: "multi-kit"
+    };
+  }
+  const metadataPath = join45(claudeDir2, "metadata.json");
+  const legacy = detection.metadata;
+  if (!legacy) {
+    return {
+      success: false,
+      migrated: false,
+      fromFormat: "legacy",
+      toFormat: "multi-kit",
+      error: "Metadata exists but could not be read"
+    };
+  }
+  const legacyKit = detection.detectedKit || "engineer";
+  try {
+    const kitMetadata = {
+      version: legacy.version || "unknown",
+      installedAt: legacy.installedAt || new Date().toISOString(),
+      files: legacy.files || []
+    };
+    const multiKit = {
+      kits: {
+        [legacyKit]: kitMetadata
+      },
+      scope: legacy.scope,
+      name: legacy.name,
+      version: legacy.version,
+      installedAt: legacy.installedAt,
+      installedFiles: legacy.installedFiles,
+      userConfigFiles: legacy.userConfigFiles,
+      files: legacy.files
+    };
+    await import_fs_extra3.writeFile(metadataPath, JSON.stringify(multiKit, null, 2), "utf-8");
+    logger.info(`Migrated metadata from legacy format to multi-kit (detected: ${legacyKit})`);
+    return {
+      success: true,
+      migrated: true,
+      fromFormat: "legacy",
+      toFormat: "multi-kit"
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : "Unknown error";
+    logger.error(`Metadata migration failed: ${errorMsg}`);
+    return {
+      success: false,
+      migrated: false,
+      fromFormat: "legacy",
+      toFormat: "multi-kit",
+      error: errorMsg
+    };
+  }
+}
+function getKitMetadata(metadata, kit) {
+  if (metadata.kits?.[kit]) {
+    return metadata.kits[kit];
+  }
+  if (!metadata.kits && metadata.version) {
+    return {
+      version: metadata.version,
+      installedAt: metadata.installedAt || "",
+      files: metadata.files
+    };
+  }
+  return null;
+}
+function getAllTrackedFiles(metadata) {
+  if (metadata.kits) {
+    const allFiles = [];
+    for (const kit of Object.values(metadata.kits)) {
+      if (kit.files) {
+        allFiles.push(...kit.files);
+      }
+    }
+    return allFiles;
+  }
+  return metadata.files || [];
+}
+function getTrackedFilesForKit(metadata, kitType) {
+  if (metadata.kits?.[kitType]) {
+    return metadata.kits[kitType].files || [];
+  }
+  const detectedKits = getInstalledKits(metadata);
+  if (detectedKits.includes(kitType)) {
+    return metadata.files || [];
+  }
+  return [];
+}
+function getInstalledKits(metadata) {
+  if (metadata.kits) {
+    return Object.keys(metadata.kits);
+  }
+  const nameToCheck = metadata.name || "";
+  const kits = [];
+  if (/\bengineer\b/i.test(nameToCheck)) {
+    kits.push("engineer");
+  }
+  if (/\bmarketing\b/i.test(nameToCheck)) {
+    kits.push("marketing");
+  }
+  if (kits.length > 0) {
+    return kits;
+  }
+  if (metadata.version) {
+    return ["engineer"];
+  }
+  return [];
+}
+var import_fs_extra3;
+var init_metadata_migration = __esm(() => {
+  init_logger();
+  import_fs_extra3 = __toESM(require_lib3(), 1);
+});
+
 // src/services/file-operations/claudekit-scanner.ts
 import { join as join46 } from "node:path";
 async function scanClaudeKitDirectory(directoryPath) {
@@ -57627,117 +57947,6 @@ var init_claudekit_scanner = __esm(() => {
   import_fs_extra4 = __toESM(require_lib3(), 1);
 });
 
-// package.json
-var package_default;
-var init_package = __esm(() => {
-  package_default = {
-    name: "claudekit-cli",
-    version: "3.41.1",
-    description: "CLI tool for bootstrapping and updating ClaudeKit projects",
-    type: "module",
-    repository: {
-      type: "git",
-      url: "git+https://github.com/mrgoonie/claudekit-cli.git"
-    },
-    publishConfig: {
-      access: "public",
-      registry: "https://registry.npmjs.org"
-    },
-    bin: {
-      ck: "bin/ck.js"
-    },
-    files: [
-      "bin/ck.js",
-      "dist/index.js",
-      "dist/ui/"
-    ],
-    scripts: {
-      dev: "bun run src/index.ts",
-      "dashboard:dev": "cd src/ui && bun install --silent && cd ../.. && bun run src/index.ts config ui --dev",
-      "ui:build": "cd src/ui && bun install --silent && bun run build",
-      "ui:dev": "cd src/ui && bun run dev",
-      build: `bun build src/index.ts --outdir dist --target node --external @octokit/rest --external better-sqlite3 && node -e "const fs=require('fs'),f='dist/index.js',c=fs.readFileSync(f,'utf-8');fs.writeFileSync(f,c.replace(/^#!.*\\n\\/\\/ @bun\\n/,''))"`,
-      "verify:package": "node scripts/prepublish-check.js",
-      test: "bun test",
-      "test:integration": "CK_RUN_CLI_INTEGRATION=1 bun test tests/integration/cli.test.ts",
-      "test:watch": "bun test --watch",
-      "test:quick": "./scripts/dev-quick-start.sh test",
-      lint: "biome check .",
-      "lint:fix": "biome check --fix .",
-      "lint:fix-unsafe": "biome check --fix --unsafe .",
-      format: "biome format --write .",
-      typecheck: "tsc --noEmit",
-      "dev:quick": "./scripts/dev-quick-start.sh",
-      "dev:all": "./scripts/dev-quick-start.sh all",
-      metrics: "bun run scripts/workflow-metrics.ts",
-      validate: "bun run typecheck && bun run lint && bun test && bun run build",
-      "install:hooks": "./.githooks/install.sh",
-      prepare: `node -e "try{require('child_process').execSync('git rev-parse --git-dir',{stdio:'ignore'});require('child_process').execSync('bash .githooks/install.sh',{stdio:'inherit'})}catch(e){console.warn('[i] Hook install skipped:',e.message)}"`
-    },
-    keywords: [
-      "cli",
-      "claudekit",
-      "boilerplate",
-      "bootstrap",
-      "template"
-    ],
-    author: "ClaudeKit",
-    license: "MIT",
-    engines: {
-      node: ">=18.0.0"
-    },
-    dependencies: {
-      "@clack/prompts": "^0.7.0",
-      "@octokit/rest": "^22.0.0",
-      "better-sqlite3": "^12.6.2",
-      cac: "^6.7.14",
-      chokidar: "^5.0.0",
-      "cli-progress": "^3.12.0",
-      "compare-versions": "^6.1.1",
-      diff: "^8.0.3",
-      express: "^5.2.1",
-      "extract-zip": "^2.0.1",
-      "fs-extra": "^11.2.0",
-      "get-port": "^7.1.0",
-      "gray-matter": "^4.0.3",
-      ignore: "^5.3.2",
-      minimatch: "^10.1.1",
-      open: "^11.0.0",
-      ora: "^8.0.0",
-      "p-limit": "^7.2.0",
-      picocolors: "^1.1.1",
-      picomatch: "^4.0.3",
-      "proper-lockfile": "^4.1.2",
-      semver: "^7.7.3",
-      tar: "^7.4.3",
-      tmp: "^0.2.3",
-      ws: "^8.19.0",
-      zod: "^3.23.8"
-    },
-    devDependencies: {
-      "@biomejs/biome": "^1.9.4",
-      "@semantic-release/changelog": "^6.0.3",
-      "@semantic-release/git": "^10.0.1",
-      "@types/better-sqlite3": "^7.6.13",
-      "@types/bun": "latest",
-      "@types/cli-progress": "^3.11.6",
-      "@types/diff": "^8.0.0",
-      "@types/express": "^5.0.6",
-      "@types/fs-extra": "^11.0.4",
-      "@types/node": "^22.19.7",
-      "@types/picomatch": "^4.0.2",
-      "@types/proper-lockfile": "^4.1.4",
-      "@types/semver": "^7.7.1",
-      "@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"
-    }
-  };
-});
-
 // src/domains/github/github-auth.ts
 import { execSync } from "node:child_process";
 
@@ -58145,7 +58354,7 @@ ${action.title}:`);
 }
 
 // src/domains/error/index.ts
-var init_error = () => {};
+var init_error2 = () => {};
 
 // src/domains/github/client/error-handler.ts
 async function handleHttpError(error, context) {
@@ -58176,7 +58385,7 @@ Need help? Run with: ${verboseFlag}`);
 `), classified.httpStatus);
 }
 var init_error_handler2 = __esm(() => {
-  init_error();
+  init_error2();
   init_types3();
   init_auth_api();
 });
@@ -58297,7 +58506,7 @@ class VersionFormatter {
   static compare(v1, v2) {
     const normV1 = VersionFormatter.normalize(v1);
     const normV2 = VersionFormatter.normalize(v2);
-    return import_compare_versions2.compareVersions(normV1, normV2);
+    return import_compare_versions3.compareVersions(normV1, normV2);
   }
   static formatRelativeTime(dateString) {
     if (!dateString)
@@ -58385,20 +58594,20 @@ class VersionFormatter {
       const majorA = Number.parseInt(normA.split(".")[0], 10);
       const majorB = Number.parseInt(normB.split(".")[0], 10);
       if (majorA === 0 && majorB === 0) {
-        return import_compare_versions2.compareVersions(normB, normA);
+        return import_compare_versions3.compareVersions(normB, normA);
       }
       if (majorA === 0)
         return 1;
       if (majorB === 0)
         return -1;
-      return import_compare_versions2.compareVersions(normB, normA);
+      return import_compare_versions3.compareVersions(normB, normA);
     });
   }
 }
-var import_compare_versions2;
+var import_compare_versions3;
 var init_version_formatter = __esm(() => {
   init_logger();
-  import_compare_versions2 = __toESM(require_umd(), 1);
+  import_compare_versions3 = __toESM(require_umd(), 1);
 });
 
 // src/domains/versioning/release-filter.ts
@@ -58907,64 +59116,16 @@ var init_github_client = __esm(() => {
   init_client();
 });
 
-// src/commands/update-cli.ts
+// src/commands/update/post-update-handler.ts
 import { exec as exec2, spawn as spawn2 } from "node:child_process";
 import { join as join48 } from "node:path";
 import { promisify as promisify8 } from "node:util";
-function getDefaultUpdateCliCommandDeps() {
-  return {
-    currentVersion: package_default.version,
-    execAsyncFn: execAsync2,
-    packageManagerDetector: PackageManagerDetector,
-    npmRegistryClient: NpmRegistryClient,
-    promptKitUpdateFn: promptKitUpdate,
-    promptMigrateUpdateFn: promptMigrateUpdate
-  };
-}
-function extractCommandStdout(result) {
-  if (typeof result === "string") {
-    return result;
-  }
-  if (result && typeof result.stdout === "string") {
-    return result.stdout;
-  }
-  return "";
-}
-function redactCommandForLog(command) {
-  if (!command)
-    return command;
-  const redactedRegistryFlags = command.replace(/(--registry(?:=|\s+))(['"]?)(\S+?)(\2)(?=\s|$)/g, (_match, prefix, quote, url) => `${prefix}${quote}${redactRegistryUrlForLog(url)}${quote}`);
-  return redactedRegistryFlags.replace(/https?:\/\/[^\s"']+/g, (url) => redactRegistryUrlForLog(url));
-}
-function buildInitCommand(isGlobal, kit, beta, yes) {
-  const parts = ["ck init"];
-  if (isGlobal)
-    parts.push("-g");
-  if (kit)
-    parts.push(`--kit ${kit}`);
-  if (yes)
-    parts.push("--yes");
-  parts.push("--install-skills");
-  if (beta)
-    parts.push("--beta");
-  return parts.join(" ");
-}
-function isBetaVersion(version) {
-  return isPrereleaseVersion(version);
-}
-function parseCliVersionFromOutput(output2) {
-  if (!output2)
-    return null;
-  const match = output2.match(/CLI Version:\s*(\S+)/);
-  return match ? match[1] : null;
-}
 function selectKitForUpdate(params) {
   const { hasLocal, hasGlobal, localKits, globalKits } = params;
   const hasLocalKit = localKits.length > 0 || hasLocal;
   const hasGlobalKit = globalKits.length > 0 || hasGlobal;
-  if (!hasLocalKit && !hasGlobalKit) {
+  if (!hasLocalKit && !hasGlobalKit)
     return null;
-  }
   if (hasGlobalKit && !hasLocalKit) {
     const kit2 = globalKits[0] || localKits[0];
     return {
@@ -58991,9 +59152,8 @@ function selectKitForUpdate(params) {
 async function readMetadataFile(claudeDir2) {
   const metadataPath = join48(claudeDir2, "metadata.json");
   try {
-    if (!await import_fs_extra5.pathExists(metadataPath)) {
+    if (!await import_fs_extra5.pathExists(metadataPath))
       return null;
-    }
     const content = await import_fs_extra5.readFile(metadataPath, "utf-8");
     const parsed = JSON.parse(content);
     const validated = MetadataSchema.safeParse(parsed);
@@ -59007,6 +59167,19 @@ async function readMetadataFile(claudeDir2) {
     return null;
   }
 }
+function buildInitCommand(isGlobal, kit, beta, yes) {
+  const parts = ["ck init"];
+  if (isGlobal)
+    parts.push("-g");
+  if (kit)
+    parts.push(`--kit ${kit}`);
+  if (yes)
+    parts.push("--yes");
+  parts.push("--install-skills");
+  if (beta)
+    parts.push("--beta");
+  return parts.join(" ");
+}
 async function fetchLatestReleaseTag(kit, beta) {
   try {
     const { GitHubClient: GitHubClient2 } = await Promise.resolve().then(() => (init_github_client(), exports_github_client));
@@ -59060,14 +59233,11 @@ async function promptKitUpdate(beta, yes, deps) {
       const ckConfig = await loadFullConfigFn(null);
       autoInit = ckConfig.config.updatePipeline?.autoInitAfterUpdate ?? false;
     } catch {}
-    if (alreadyAtLatest && !autoInit) {
+    if (alreadyAtLatest && !autoInit)
       return;
-    }
     if (!yes && !autoInit) {
       logger.info("");
-      const shouldUpdate = await confirmFn({
-        message: promptMessage
-      });
+      const shouldUpdate = await confirmFn({ message: promptMessage });
       if (isCancelFn(shouldUpdate) || !shouldUpdate) {
         log.info("Skipped kit content update");
         return;
@@ -59205,6 +59375,37 @@ async function promptMigrateUpdate(deps) {
     logger.verbose(`Migrate step skipped: ${error instanceof Error ? error.message : "unknown"}`);
   }
 }
+var import_fs_extra5, execAsync2, SAFE_PROVIDER_NAME;
+var init_post_update_handler = __esm(() => {
+  init_ck_config_manager();
+  init_metadata_migration();
+  init_version_utils();
+  init_claudekit_scanner();
+  init_logger();
+  init_safe_prompts();
+  init_types3();
+  init_version_comparator();
+  import_fs_extra5 = __toESM(require_lib3(), 1);
+  execAsync2 = promisify8(exec2);
+  SAFE_PROVIDER_NAME = /^[a-z0-9-]+$/;
+});
+
+// src/commands/update-cli.ts
+function getDefaultUpdateCliCommandDeps() {
+  return {
+    currentVersion: package_default.version,
+    execAsyncFn: async (cmd, opts) => {
+      const { exec: exec3 } = await import("node:child_process");
+      const { promisify: promisify9 } = await import("node:util");
+      const result = await promisify9(exec3)(cmd, opts);
+      return { stdout: String(result.stdout ?? ""), stderr: String(result.stderr ?? "") };
+    },
+    packageManagerDetector: PackageManagerDetector,
+    npmRegistryClient: NpmRegistryClient,
+    promptKitUpdateFn: promptKitUpdate,
+    promptMigrateUpdateFn: promptMigrateUpdate
+  };
+}
 async function updateCliCommand(options2, deps = getDefaultUpdateCliCommandDeps()) {
   const s = de();
   intro("[>] ClaudeKit CLI - Update");
@@ -59229,64 +59430,31 @@ async function updateCliCommand(options2, deps = getDefaultUpdateCliCommandDeps(
       const userRegistry = await packageManagerDetector.getNpmRegistryUrl();
       if (userRegistry) {
         registryUrl = userRegistry;
-        logger.verbose(`Using npm configured registry: ${redactRegistryUrlForLog(registryUrl)}`);
+        const { redactRegistryUrlForLog: redactRegistryUrlForLog2 } = await Promise.resolve().then(() => (init_npm_registry(), exports_npm_registry));
+        logger.verbose(`Using npm configured registry: ${redactRegistryUrlForLog2(registryUrl)}`);
       }
     }
     s.start("Checking for updates...");
-    let targetVersion = null;
-    const usePrereleaseChannel = opts.dev || opts.beta;
-    if (opts.release && opts.release !== "latest") {
-      try {
-        const exists = await npmRegistryClient.versionExists(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, opts.release, registryUrl);
-        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.`);
-        }
-      } catch (error) {
-        if (error instanceof CliUpdateError) {
-          throw error;
-        }
-        s.stop("Version check failed");
-        const message = error instanceof Error ? error.message : "Unknown error";
-        logger.verbose(`Release check failed for ${opts.release}: ${message}`);
-        const registryHint = registryUrl ? ` (${redactRegistryUrlForLog(registryUrl)})` : " (default registry)";
-        throw new CliUpdateError(`Failed to verify version ${opts.release} on npm registry${registryHint}. Check registry settings/network connectivity and try again.`);
-      }
-      targetVersion = opts.release;
-      s.stop(`Target version: ${targetVersion}`);
-    } else if (usePrereleaseChannel) {
-      targetVersion = await npmRegistryClient.getDevVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, registryUrl);
-      if (!targetVersion) {
-        s.stop("No dev version available");
-        logger.warning("No dev version found. Using latest stable version instead.");
-        targetVersion = await npmRegistryClient.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, registryUrl);
-      } else {
-        s.stop(`Latest dev version: ${targetVersion}`);
-      }
-    } else {
-      targetVersion = await npmRegistryClient.getLatestVersion(CLAUDEKIT_CLI_NPM_PACKAGE_NAME, registryUrl);
-      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, CLAUDEKIT_CLI_NPM_PACKAGE_NAME, undefined, registryUrl)}`);
-    }
-    const comparison = import_compare_versions3.compareVersions(currentVersion, targetVersion);
-    const targetIsPrerelease = isPrereleaseVersion(targetVersion);
-    if (comparison === 0) {
+    const { targetVersion, targetIsPrerelease } = await resolveTargetVersion(opts, {
+      npmRegistryClient,
+      registryUrl,
+      spinnerStop: (msg) => s.stop(msg)
+    });
+    const outcome = compareCliVersions(currentVersion, targetVersion, opts);
+    if (outcome.status === "up-to-date") {
       outro(`[+] Already on the latest CLI version (${currentVersion})`);
       await promptKitUpdateFn(targetIsPrerelease, opts.yes);
       await promptMigrateUpdateFn();
       return;
     }
-    const isDevChannelSwitch = (opts.dev || opts.beta) && isBetaVersion(targetVersion) && !isBetaVersion(currentVersion);
-    if (comparison > 0 && !opts.release && !isDevChannelSwitch) {
+    if (outcome.status === "newer") {
       outro(`[+] Current version (${currentVersion}) is newer than latest (${targetVersion})`);
       await promptKitUpdateFn(targetIsPrerelease, opts.yes);
       await promptMigrateUpdateFn();
       return;
     }
-    const isUpgrade = comparison < 0 || isDevChannelSwitch;
-    const changeType = isUpgrade ? "upgrade" : "downgrade";
+    const isUpgrade = outcome.changeType === "upgrade";
+    const changeType = outcome.changeType;
     logger.info(`${isUpgrade ? "[^]" : "[v]"}  ${changeType}: ${currentVersion} -> ${targetVersion}`);
     if (opts.check) {
       note(`CLI update available: ${currentVersion} -> ${targetVersion}
@@ -59308,71 +59476,19 @@ Run 'ck update' to install`, "Update Check");
     }
     const updateCmd = packageManagerDetector.getUpdateCommand(pm, CLAUDEKIT_CLI_NPM_PACKAGE_NAME, targetVersion, registryUrl);
     logger.info(`Running: ${redactCommandForLog(updateCmd)}`);
-    s.start("Updating CLI...");
-    try {
-      await execAsyncFn(updateCmd, {
-        timeout: 120000
-      });
-      s.stop("Update completed");
-    } catch (error) {
-      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" ? `
-
-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}`);
-      }
-      logger.error(`Update failed: ${errorMessage}`);
-      logger.info(`Try running: ${redactCommandForLog(updateCmd)}`);
-      throw new CliUpdateError(`Update failed: ${errorMessage}
-
-Manual update: ${updateCmd}`);
-    }
-    s.start("Verifying installation...");
-    try {
-      const versionResult = await execAsyncFn("ck --version", { timeout: 5000 });
-      const stdout = extractCommandStdout(versionResult);
-      const activeVersion = parseCliVersionFromOutput(stdout);
-      if (!activeVersion) {
-        s.stop("Verification failed");
-        const message = `Update completed but could not parse 'ck --version' output.
-Please restart your terminal and run 'ck --version'. Expected: ${targetVersion}
-
-Manual update: ${redactCommandForLog(updateCmd)}`;
-        logger.error(message);
-        throw new CliUpdateError(message);
-      }
-      s.stop(`Installed version: ${activeVersion}`);
-      if (activeVersion !== targetVersion) {
-        const mismatchMessage = `Update did not activate the requested version.
-Expected: ${targetVersion}
-Active ck: ${activeVersion}
-
-Likely causes: multiple global installations (npm/bun/pnpm/yarn) or stale shell shim/cache (common on Windows).
-Run '${redactCommandForLog(updateCmd)}' manually, restart terminal, then check command resolution:
-- Windows: where ck
-- macOS/Linux: which -a ck`;
-        logger.error(mismatchMessage);
-        throw new CliUpdateError(mismatchMessage);
-      }
-      outro(`[+] Successfully updated ClaudeKit CLI to ${activeVersion}`);
-      await promptKitUpdateFn(targetIsPrerelease, opts.yes);
-      await promptMigrateUpdateFn();
-    } catch (error) {
-      if (error instanceof CliUpdateError) {
-        throw error;
-      }
-      s.stop("Verification failed");
-      const message = `Update completed but automatic verification failed.
-Please restart your terminal and run 'ck --version'. Expected: ${targetVersion}
-
-Manual update: ${redactCommandForLog(updateCmd)}`;
-      logger.error(message);
-      throw new CliUpdateError(message);
-    }
+    await runPackageManagerUpdate(updateCmd, pm, {
+      execAsyncFn,
+      spinnerStart: (msg) => s.start(msg),
+      spinnerStop: (msg) => s.stop(msg)
+    });
+    const activeVersion = await verifyInstalledVersion(targetVersion, updateCmd, {
+      execAsyncFn,
+      spinnerStart: (msg) => s.start(msg),
+      spinnerStop: (msg) => s.stop(msg)
+    });
+    outro(`[+] Successfully updated ClaudeKit CLI to ${activeVersion}`);
+    await promptKitUpdateFn(targetIsPrerelease, opts.yes);
+    await promptMigrateUpdateFn();
   } catch (error) {
     if (error instanceof CliUpdateError) {
       throw error;
@@ -59382,30 +59498,24 @@ Manual update: ${redactCommandForLog(updateCmd)}`;
     throw new CliUpdateError(errorMessage);
   }
 }
-var import_compare_versions3, import_fs_extra5, execAsync2, CliUpdateError, SAFE_PROVIDER_NAME;
 var init_update_cli = __esm(() => {
-  init_ck_config_manager();
   init_npm_registry();
   init_package_manager_detector();
-  init_metadata_migration();
-  init_version_utils();
-  init_claudekit_scanner();
   init_claudekit_constants();
   init_logger();
   init_safe_prompts();
   init_types3();
-  init_types3();
   init_package();
-  import_compare_versions3 = __toESM(require_umd(), 1);
-  import_fs_extra5 = __toESM(require_lib3(), 1);
-  execAsync2 = promisify8(exec2);
-  CliUpdateError = class CliUpdateError extends ClaudeKitError {
-    constructor(message) {
-      super(message, "CLI_UPDATE_ERROR");
-      this.name = "CliUpdateError";
-    }
-  };
-  SAFE_PROVIDER_NAME = /^[a-z0-9-]+$/;
+  init_channel_resolver();
+  init_error();
+  init_package_manager_runner();
+  init_post_update_handler();
+  init_registry_client();
+  init_version_comparator();
+  init_error();
+  init_version_comparator();
+  init_post_update_handler();
+  init_registry_client();
 });
 
 // src/domains/versioning/version-cache.ts
@@ -68343,7 +68453,7 @@ var init_content_validator = __esm(() => {
 import { createHash as createHash6 } from "node:crypto";
 import { existsSync as existsSync66, mkdirSync as mkdirSync4, readFileSync as readFileSync15, readdirSync as readdirSync8, statSync as statSync10 } from "node:fs";
 import { rename as rename9, writeFile as writeFile35 } from "node:fs/promises";
-import { homedir as homedir34 } from "node:os";
+import { homedir as homedir33 } from "node:os";
 import { basename as basename19, join as join132 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
@@ -68418,7 +68528,7 @@ function getCacheFilePath(repoPath) {
 }
 var CACHE_DIR, CACHE_TTL_MS4;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join132(homedir34(), ".claudekit", "cache");
+  CACHE_DIR = join132(homedir33(), ".claudekit", "cache");
   CACHE_TTL_MS4 = 24 * 60 * 60 * 1000;
 });
 
@@ -68872,10 +68982,10 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 // src/commands/content/phases/photo-generator.ts
 import { execSync as execSync7 } from "node:child_process";
 import { existsSync as existsSync68, mkdirSync as mkdirSync5, readdirSync as readdirSync10 } from "node:fs";
-import { homedir as homedir35 } from "node:os";
+import { homedir as homedir34 } from "node:os";
 import { join as join134 } from "node:path";
 async function generatePhoto(_content, context, config, platform14, contentId, contentLogger) {
-  const mediaDir = join134(config.contentDir.replace(/^~/, homedir35()), "media", String(contentId));
+  const mediaDir = join134(config.contentDir.replace(/^~/, homedir34()), "media", String(contentId));
   if (!existsSync68(mediaDir)) {
     mkdirSync5(mediaDir, { recursive: true });
   }
@@ -68989,7 +69099,7 @@ var init_content_creator = __esm(() => {
 
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream4, existsSync as existsSync69, mkdirSync as mkdirSync6, statSync as statSync11 } from "node:fs";
-import { homedir as homedir36 } from "node:os";
+import { homedir as homedir35 } from "node:os";
 import { join as join135 } from "node:path";
 
 class ContentLogger {
@@ -68998,7 +69108,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join135(homedir36(), ".claudekit", "logs");
+    this.logDir = join135(homedir35(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -70597,11 +70707,11 @@ var init_setup_wizard = __esm(() => {
 
 // src/commands/content/content-review-commands.ts
 import { existsSync as existsSync73 } from "node:fs";
-import { homedir as homedir37 } from "node:os";
+import { homedir as homedir36 } from "node:os";
 async function queueContent() {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir37());
+  const dbPath = config.dbPath.replace(/^~/, homedir36());
   if (!existsSync73(dbPath)) {
     logger.info("No content database found. Run 'ck content setup' first.");
     return;
@@ -70628,7 +70738,7 @@ async function queueContent() {
 async function approveContentCmd(id) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir37());
+  const dbPath = config.dbPath.replace(/^~/, homedir36());
   const db = initDatabase(dbPath);
   try {
     approveContent(db, Number.parseInt(id, 10));
@@ -70640,7 +70750,7 @@ async function approveContentCmd(id) {
 async function rejectContentCmd(id, reason) {
   const cwd2 = process.cwd();
   const config = await loadContentConfig(cwd2);
-  const dbPath = config.dbPath.replace(/^~/, homedir37());
+  const dbPath = config.dbPath.replace(/^~/, homedir36());
   const db = initDatabase(dbPath);
   try {
     rejectContent(db, Number.parseInt(id, 10), reason);
@@ -70671,7 +70781,7 @@ __export(exports_content_subcommands, {
   approveContentCmd: () => approveContentCmd
 });
 import { existsSync as existsSync74, readFileSync as readFileSync18, unlinkSync as unlinkSync5 } from "node:fs";
-import { homedir as homedir38 } from "node:os";
+import { homedir as homedir37 } from "node:os";
 import { join as join140 } from "node:path";
 function isDaemonRunning() {
   const lockFile = join140(LOCK_DIR, `${LOCK_NAME2}.lock`);
@@ -70745,7 +70855,7 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join140(homedir38(), ".claudekit", "logs");
+  const logDir = join140(homedir37(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
   const logPath = join140(logDir, `content-${dateStr}.log`);
   if (!existsSync74(logPath)) {
@@ -70779,12 +70889,12 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join140(homedir38(), ".claudekit", "locks");
+  LOCK_DIR = join140(homedir37(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync75, mkdirSync as mkdirSync8, unlinkSync as unlinkSync6, writeFileSync as writeFileSync6 } from "node:fs";
-import { homedir as homedir39 } from "node:os";
+import { homedir as homedir38 } from "node:os";
 import { join as join141 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
@@ -70817,7 +70927,7 @@ async function contentCommand(options2) {
     if (!existsSync75(LOCK_DIR2))
       mkdirSync8(LOCK_DIR2, { recursive: true });
     writeFileSync6(LOCK_FILE, String(process.pid), "utf-8");
-    const dbPath = config.dbPath.replace(/^~/, homedir39());
+    const dbPath = config.dbPath.replace(/^~/, homedir38());
     const db = initDatabase(dbPath);
     contentLogger.info(`Database initialised at ${dbPath}`);
     const adapters = initializeAdapters(config);
@@ -70963,7 +71073,7 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join141(homedir39(), ".claudekit", "locks");
+  LOCK_DIR2 = join141(homedir38(), ".claudekit", "locks");
   LOCK_FILE = join141(LOCK_DIR2, "ck-content.lock");
 });
 
@@ -81798,16 +81908,53 @@ class SyncEngine {
     }
   }
 }
+// src/shared/deletion-pattern-expander.ts
+var LEGACY_COMMAND_PREFIX_BY_KIT = {
+  engineer: "ck",
+  marketing: "mkt"
+};
+function getLegacyCommandPrefix(kitType) {
+  if (!kitType)
+    return null;
+  return LEGACY_COMMAND_PREFIX_BY_KIT[kitType] ?? null;
+}
+function canExpandLegacyCommandPattern(pattern, prefix) {
+  if (!pattern.startsWith("commands/"))
+    return false;
+  if (pattern.startsWith(`commands/${prefix}/`))
+    return false;
+  const allPrefixes = Object.values(LEGACY_COMMAND_PREFIX_BY_KIT);
+  if (allPrefixes.some((candidate) => candidate && pattern.startsWith(`commands/${candidate}/`))) {
+    return false;
+  }
+  return true;
+}
+function expandDeletionPatterns(patterns, kitType) {
+  const prefix = getLegacyCommandPrefix(kitType);
+  if (!prefix || patterns.length === 0) {
+    return [...patterns];
+  }
+  const expanded = new Set;
+  for (const pattern of patterns) {
+    expanded.add(pattern);
+    if (canExpandLegacyCommandPattern(pattern, prefix)) {
+      expanded.add(`commands/${prefix}/${pattern.slice("commands/".length)}`);
+    }
+  }
+  return [...expanded];
+}
+
 // src/domains/sync/deletion-path-filter.ts
 init_path_resolver();
 var import_picomatch = __toESM(require_picomatch2(), 1);
-function filterDeletionPaths(trackedFiles, deletions) {
+function filterDeletionPaths(trackedFiles, deletions, kitType) {
   if (!deletions || deletions.length === 0) {
     return trackedFiles;
   }
+  const expandedDeletions = expandDeletionPatterns(deletions, kitType);
   const exactPaths = new Set;
   const globMatchers = [];
-  for (const pattern of deletions) {
+  for (const pattern of expandedDeletions) {
     if (PathResolver.isGlobPattern(pattern)) {
       globMatchers.push(import_picomatch.default(pattern));
     } else {
@@ -82792,9 +82939,9 @@ var import_proper_lockfile4 = __toESM(require_proper_lockfile(), 1);
 import { mkdir as mkdir19 } from "node:fs/promises";
 import os5 from "node:os";
 import { join as join75 } from "node:path";
-var LOCK_CONFIG = {
-  stale: 60000,
-  retries: 0
+var LOCK_CONFIGS = {
+  short: { stale: 60000, retries: 0 },
+  long: { stale: 300000, retries: 0 }
 };
 var activeLocks = new Set;
 var cleanupRegistered = false;
@@ -82804,8 +82951,7 @@ function getLocksDir() {
 function cleanupLocks() {
   for (const name of activeLocks) {
     try {
-      const lockPath = join75(getLocksDir(), `${name}.lock`);
-      import_proper_lockfile4.default.unlockSync(lockPath, { realpath: false });
+      import_proper_lockfile4.default.unlockSync(getLockPaths(name).resource, { realpath: false });
     } catch {
       try {
         logger.verbose(`Failed to cleanup lock: ${name}`);
@@ -82824,13 +82970,24 @@ async function ensureLocksDir() {
   const lockDir = getLocksDir();
   await mkdir19(lockDir, { recursive: true });
 }
-async function withProcessLock(lockName, fn) {
+function getLockPaths(lockName) {
+  const resource = join75(getLocksDir(), `${lockName}.lock`);
+  return { resource, lockfile: `${resource}.lock` };
+}
+async function withProcessLock(lockName, fn, duration = "short") {
   registerCleanupHandlers();
   await ensureLocksDir();
-  const lockPath = join75(getLocksDir(), `${lockName}.lock`);
+  const { resource: lockPath } = getLockPaths(lockName);
+  const config = LOCK_CONFIGS[duration];
   let release;
   try {
-    release = await import_proper_lockfile4.default.lock(lockPath, { ...LOCK_CONFIG, realpath: false });
+    release = await import_proper_lockfile4.default.lock(lockPath, {
+      ...config,
+      realpath: false,
+      onCompromised: duration === "long" ? (err) => {
+        logger.warning(`Lock "${lockName}" compromised: ${err.message}. Continuing...`);
+      } : undefined
+    });
     activeLocks.add(lockName);
     return await fn();
   } catch (e2) {
@@ -82840,11 +82997,24 @@ async function withProcessLock(lockName, fn) {
 
 Operation: ${lockName}
 Wait for it to complete or remove lock: ${lockPath}`);
+    }
+    if (error.code === "ECOMPROMISED") {
+      throw new Error(`Lock was compromised (stale or externally removed).
+
+Operation: ${lockName}
+Use --force to clear and restart.`);
     }
     throw e2;
   } finally {
     if (release) {
-      await release();
+      try {
+        await release();
+      } catch (releaseErr) {
+        const code = releaseErr.code;
+        if (code !== "ERELEASED") {
+          logger.warning(`Failed to release lock "${lockName}": ${releaseErr.message}`);
+        }
+      }
     }
     activeLocks.delete(lockName);
   }
@@ -91199,8 +91369,15 @@ function findFileInMetadata(metadata, path14) {
   }
   return null;
 }
-function shouldDeletePath(path14, metadata) {
-  const tracked = findFileInMetadata(metadata, path14);
+function findFileInMetadataForKit(metadata, path14, kitType) {
+  if (!metadata)
+    return null;
+  if (!kitType)
+    return findFileInMetadata(metadata, path14);
+  return metadata.kits?.[kitType]?.files?.find((file) => file.path === path14) ?? null;
+}
+function shouldDeletePath(path14, metadata, kitType) {
+  const tracked = findFileInMetadataForKit(metadata, path14, kitType);
   if (!tracked)
     return true;
   return tracked.ownership !== "user";
@@ -91326,8 +91503,8 @@ async function updateMetadataAfterDeletion(claudeDir2, deletedPaths) {
     logger.debug("Failed to write updated metadata.json");
   }
 }
-async function handleDeletions(sourceMetadata, claudeDir2) {
-  const deletionPatterns = sourceMetadata.deletions || [];
+async function handleDeletions(sourceMetadata, claudeDir2, kitType) {
+  const deletionPatterns = expandDeletionPatterns(sourceMetadata.deletions || [], kitType);
   if (deletionPatterns.length === 0) {
     return { deletedPaths: [], preservedPaths: [], errors: [] };
   }
@@ -91343,7 +91520,7 @@ async function handleDeletions(sourceMetadata, claudeDir2) {
       result.errors.push(path14);
       continue;
     }
-    if (!shouldDeletePath(path14, userMetadata)) {
+    if (!shouldDeletePath(path14, userMetadata, kitType)) {
       result.preservedPaths.push(path14);
       logger.verbose(`Preserved user file: ${path14}`);
       continue;
@@ -95116,7 +95293,7 @@ async function handleMerge(ctx) {
   }
   try {
     if (sourceMetadata?.deletions && sourceMetadata.deletions.length > 0) {
-      const deletionResult = await handleDeletions(sourceMetadata, ctx.claudeDir);
+      const deletionResult = await handleDeletions(sourceMetadata, ctx.claudeDir, ctx.kitType);
       if (deletionResult.deletedPaths.length > 0) {
         logger.info(`Removed ${deletionResult.deletedPaths.length} deprecated file(s)`);
         for (const path15 of deletionResult.deletedPaths) {
@@ -97538,7 +97715,7 @@ async function executeSyncMerge(ctx) {
     } catch (error) {
       logger.debug(`Failed to load source metadata for deletion filtering: ${error}`);
     }
-    const filteredTrackedFiles = filterDeletionPaths(trackedFiles, deletions);
+    const filteredTrackedFiles = filterDeletionPaths(trackedFiles, deletions, ctx.kitType);
     if (deletions.length > 0) {
       const filtered = trackedFiles.length - filteredTrackedFiles.length;
       logger.debug(`Filtered ${filtered} files matching ${deletions.length} deletion patterns`);
@@ -98842,7 +99019,7 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
   if (!existsSync56(claudeDir2))
     return;
   try {
-    const result = await handleDeletions(sourceMetadata, claudeDir2);
+    const result = await handleDeletions(sourceMetadata, claudeDir2, inferKitTypeFromSourceMetadata(sourceMetadata));
     if (result.deletedPaths.length > 0) {
       logger.verbose(`[migrate] Cleaned up ${result.deletedPaths.length} deprecated path(s): ${result.deletedPaths.join(", ")}`);
     }
@@ -98850,6 +99027,13 @@ async function processMetadataDeletions(skillSourcePath, installGlobally) {
     logger.warning(`[migrate] Deletion cleanup failed: ${error}`);
   }
 }
+function inferKitTypeFromSourceMetadata(sourceMetadata) {
+  if (sourceMetadata.name?.includes("marketing"))
+    return "marketing";
+  if (sourceMetadata.name?.includes("engineer"))
+    return "engineer";
+  return;
+}
 async function migrateCommand(options2) {
   console.log();
   oe(import_picocolors28.default.bgMagenta(import_picocolors28.default.black(" ck migrate ")));
@@ -101691,7 +101875,6 @@ ${import_picocolors38.default.bold(import_picocolors38.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync65 } from "node:fs";
 import { rm as rm16 } from "node:fs/promises";
-import { homedir as homedir33 } from "node:os";
 import { join as join131 } from "node:path";
 var import_picocolors39 = __toESM(require_picocolors(), 1);
 
@@ -102243,6 +102426,9 @@ async function invokeClaude(options2) {
     "--allowedTools",
     tools
   ];
+  if (outputFormat === "stream-json") {
+    args.push("--verbose");
+  }
   const child = spawn10("claude", args, {
     cwd: options2.cwd,
     stdio: ["pipe", "pipe", "pipe"],
@@ -102288,7 +102474,7 @@ function collectClaudeOutput(child, timeoutSec, verbose = false) {
   });
 }
 function logStreamEvent(chunk) {
-  for (const line of chunk.split(`
+  for (const line of chunk.replace(/\r/g, "").split(`
 `).filter(Boolean)) {
     try {
       const event = JSON.parse(line);
@@ -102316,7 +102502,7 @@ function logStreamEvent(chunk) {
   }
 }
 function parseStreamJsonOutput(stdout2) {
-  const lines = stdout2.split(`
+  const lines = stdout2.replace(/\r/g, "").split(`
 `).filter(Boolean);
   for (let i = lines.length - 1;i >= 0; i--) {
     try {
@@ -103416,11 +103602,13 @@ async function watchCommand(options2) {
         process.removeListener("SIGINT", shutdown);
         process.removeListener("SIGTERM", shutdown);
       }
-    });
+    }, "long");
   } catch (error) {
     const err = error;
     if (err.message?.includes("Another ClaudeKit process")) {
       logger.error("Another ck watch instance is already running. Use --force to override.");
+    } else if (err.message?.includes("Lock was compromised")) {
+      logger.error("Lock was compromised (stale or externally removed). Use --force to restart.");
     } else {
       watchLog.error("Watch command failed", err);
       console.error(`[ck watch] Fatal: ${err.message}`);
@@ -103503,9 +103691,12 @@ async function resetState(state, projectDir, watchLog) {
   watchLog.info(`Watch state reset (--force) for ${projectDir}`);
 }
 async function forceRemoveLock(watchLog) {
-  const lockPath = join131(homedir33(), ".claudekit", "locks", `${LOCK_NAME}.lock`);
+  const { resource, lockfile: lockfile5 } = getLockPaths(LOCK_NAME);
   try {
-    await rm16(lockPath, { recursive: true, force: true });
+    await Promise.all([
+      rm16(resource, { recursive: true, force: true }),
+      rm16(lockfile5, { recursive: true, force: true })
+    ]);
     watchLog.info("Removed existing lock file (--force)");
   } catch {}
 }