claudekit-cli 4.5.0-dev.3 → 4.5.0-dev.5

package/dist/index.js

@@ -64421,7 +64421,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "claudekit-cli",
-    version: "4.5.0-dev.3",
+    version: "4.5.0-dev.5",
     description: "CLI tool for bootstrapping and updating ClaudeKit projects",
     type: "module",
     repository: {
@@ -65083,7 +65083,7 @@ import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync46, readFileSync as readFileSync14, readdirSync as readdirSync9, statSync as statSync10, writeFileSync as writeFileSync5 } from "node:fs";
 import { readdir as readdir17 } from "node:fs/promises";
 import { homedir as homedir40, tmpdir } from "node:os";
-import { dirname as dirname29, join as join65, resolve as resolve33 } from "node:path";
+import { dirname as dirname29, join as join65, resolve as resolve33, sep as sep11 } from "node:path";
 function resolveDoctorCkExecutable(platformName = process.platform) {
   return platformName === "win32" ? "ck.cmd" : "ck";
 }
@@ -66085,6 +66085,21 @@ async function countMissingHookFileReferences(projectDir = process.cwd()) {
   }
   return count;
 }
+async function countMissingHookFileReferencesForClaudeDir(claudeDir3, projectRoot = dirname29(claudeDir3)) {
+  const hooksDirPrefix = `${resolve33(claudeDir3, "hooks")}${sep11}`;
+  let count = 0;
+  for (const fileName of ["settings.json", "settings.local.json"]) {
+    const filePath = resolve33(claudeDir3, fileName);
+    if (!existsSync46(filePath))
+      continue;
+    const settings = await SettingsMerger.readSettingsFile(filePath);
+    if (!settings)
+      continue;
+    const descriptor = { path: filePath, label: fileName, root: "$HOME" };
+    count += collectMissingHookReferences(settings, descriptor, projectRoot).filter((finding) => finding.resolvedPath.startsWith(hooksDirPrefix)).length;
+  }
+  return count;
+}
 async function repairMissingHookFileReferences(projectDir = process.cwd()) {
   const result = await checkHookFileReferences(projectDir);
   if (result.status !== "fail" || !result.fix) {
@@ -66589,6 +66604,118 @@ This is a bug. Please open an issue at https://github.com/mrgoonie/claudekit-cli
   };
 });
 
+// src/domains/installation/plugin/codex-plugin-installer.ts
+import { execFile as execFile8 } from "node:child_process";
+import { promisify as promisify9 } from "node:util";
+function resolveCodexExecutable(platformName = process.platform) {
+  return platformName === "win32" ? "codex.cmd" : "codex";
+}
+function shouldRunCodexInShell(platformName = process.platform) {
+  return platformName === "win32";
+}
+
+class CodexPluginInstaller {
+  run;
+  codexHome;
+  constructor(run = defaultCodexRunner, codexHome) {
+    this.run = run;
+    this.codexHome = codexHome;
+  }
+  opts(timeoutMs) {
+    return { codexHome: this.codexHome, timeoutMs };
+  }
+  async isCodexAvailable() {
+    return (await this.run(["--version"], this.opts(15000))).ok;
+  }
+  async isPluginSupported() {
+    const r2 = await this.run(["plugin", "--help"], this.opts(15000));
+    return r2.ok && /marketplace/i.test(r2.stdout + r2.stderr);
+  }
+  async marketplaceAdd(source) {
+    return this.run(["plugin", "marketplace", "add", source], this.opts());
+  }
+  async add() {
+    return this.run(["plugin", "add", `${CK_PLUGIN_NAME}@${CK_MARKETPLACE_NAME}`], this.opts());
+  }
+  async listJson() {
+    return this.run(["plugin", "list", "--json"], this.opts(15000));
+  }
+  async verifyInstalled() {
+    const r2 = await this.listJson();
+    if (!r2.ok)
+      return false;
+    try {
+      const parsed = JSON.parse(r2.stdout);
+      return (parsed.installed ?? []).some((plugin) => plugin.pluginId === `${CK_PLUGIN_NAME}@${CK_MARKETPLACE_NAME}` && plugin.installed === true && plugin.enabled === true);
+    } catch {
+      return false;
+    }
+  }
+}
+async function installCodexPlugin(opts) {
+  const installer = opts.installer ?? new CodexPluginInstaller(undefined, opts.codexHome);
+  if (!await installer.isCodexAvailable() || !await installer.isPluginSupported()) {
+    return { action: "skipped-codex-unsupported", pluginVerified: false };
+  }
+  const added = await installer.marketplaceAdd(opts.pluginSourceDir);
+  if (!added.ok) {
+    return {
+      action: "install-failed",
+      pluginVerified: false,
+      error: `codex marketplace add failed: ${added.stderr.trim()}`
+    };
+  }
+  const installed = await installer.add();
+  if (!installed.ok) {
+    return {
+      action: "install-failed",
+      pluginVerified: false,
+      error: `codex plugin add failed: ${installed.stderr.trim()}`
+    };
+  }
+  const verified = await installer.verifyInstalled();
+  if (!verified) {
+    return {
+      action: "install-failed",
+      pluginVerified: false,
+      error: "codex plugin did not verify after install"
+    };
+  }
+  return { action: "installed", pluginVerified: true };
+}
+async function shouldRefreshCodexPlugin(installer = new CodexPluginInstaller) {
+  if (!await installer.isCodexAvailable() || !await installer.isPluginSupported()) {
+    return false;
+  }
+  return !await installer.verifyInstalled();
+}
+var execFileAsync6, DEFAULT_TIMEOUT_MS2 = 120000, defaultCodexRunner = async (args, opts) => {
+  const env2 = { ...process.env };
+  if (opts?.codexHome)
+    env2.CODEX_HOME = opts.codexHome;
+  try {
+    const { stdout, stderr } = await execFileAsync6(resolveCodexExecutable(), args, {
+      env: env2,
+      shell: shouldRunCodexInShell(),
+      timeout: opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+      maxBuffer: 10 * 1024 * 1024
+    });
+    return { ok: true, stdout: String(stdout), stderr: String(stderr), code: 0 };
+  } catch (err) {
+    const e2 = err;
+    return {
+      ok: false,
+      stdout: e2.stdout ? String(e2.stdout) : "",
+      stderr: e2.stderr ? String(e2.stderr) : e2.message ?? "",
+      code: typeof e2.code === "number" ? e2.code : null
+    };
+  }
+};
+var init_codex_plugin_installer = __esm(() => {
+  init_install_mode_detector();
+  execFileAsync6 = promisify9(execFile8);
+});
+
 // src/domains/migration/metadata-migration.ts
 import { join as join66 } from "node:path";
 async function detectMetadataFormat(claudeDir3) {
@@ -68358,7 +68485,7 @@ import { existsSync as existsSync48 } from "node:fs";
 import { readdir as readdir19 } from "node:fs/promises";
 import { builtinModules } from "node:module";
 import { dirname as dirname30, join as join69 } from "node:path";
-import { promisify as promisify9 } from "node:util";
+import { promisify as promisify10 } from "node:util";
 function selectKitForUpdate(params) {
   const { hasLocal, hasGlobal, localKits, globalKits } = params;
   const hasLocalKit = localKits.length > 0 || hasLocal;
@@ -68567,6 +68694,7 @@ async function promptKitUpdate(beta, yes, deps) {
     const findMissingHookDepsFn = deps?.findMissingHookDependenciesFn ?? findMissingHookDependencies;
     const detectInstallModeFn = deps?.detectInstallModeFn ?? detectInstallMode;
     const hasTrackedPluginSuppliedLegacyFilesFn = deps?.hasTrackedPluginSuppliedLegacyFilesFn ?? hasTrackedPluginSuppliedLegacyFiles;
+    const shouldRefreshCodexPluginFn = deps?.shouldRefreshCodexPluginFn ?? shouldRefreshCodexPlugin;
     const setup = await getSetupFn();
     const hasLocal = !!setup.project.metadata;
     const hasGlobal = !!setup.global.metadata;
@@ -68637,6 +68765,10 @@ async function promptKitUpdate(beta, yes, deps) {
             logger.warning(`Detected ${installMode.mode} global Engineer install; migrating to plugin format`);
             forceKitReinstall = true;
           }
+          if (await shouldRefreshCodexPluginFn()) {
+            logger.warning("Detected missing Codex ClaudeKit plugin; reinstalling global Engineer content");
+            forceKitReinstall = true;
+          }
         }
       } catch (error) {
         logger.verbose(`Plugin install-mode self-heal check skipped: ${error instanceof Error ? error.message : "unknown"}`);
@@ -68927,6 +69059,7 @@ var import_fs_extra8, execAsync2, SAFE_PROVIDER_NAME, HOOK_DEPENDENCY_EXTENSIONS
 var init_post_update_handler = __esm(() => {
   init_ck_config_manager();
   init_hook_health_checker();
+  init_codex_plugin_installer();
   init_install_mode_detector();
   init_metadata_migration();
   init_version_utils();
@@ -68937,7 +69070,7 @@ var init_post_update_handler = __esm(() => {
   init_codex_sync_notice();
   init_version_comparator();
   import_fs_extra8 = __toESM(require_lib(), 1);
-  execAsync2 = promisify9(exec2);
+  execAsync2 = promisify10(exec2);
   SAFE_PROVIDER_NAME = /^[a-z0-9-]+$/;
   HOOK_DEPENDENCY_EXTENSIONS = [".js", ".cjs", ".mjs", ".json"];
 });
@@ -68948,8 +69081,8 @@ function getDefaultUpdateCliCommandDeps() {
     currentVersion: package_default.version,
     execAsyncFn: async (cmd, opts) => {
       const { exec: exec3 } = await import("node:child_process");
-      const { promisify: promisify10 } = await import("node:util");
-      const result = await promisify10(exec3)(cmd, opts);
+      const { promisify: promisify11 } = await import("node:util");
+      const result = await promisify11(exec3)(cmd, opts);
       return { stdout: String(result.stdout ?? ""), stderr: String(result.stderr ?? "") };
     },
     packageManagerDetector: PackageManagerDetector,
@@ -69335,14 +69468,14 @@ var init_config_version_checker = __esm(() => {
 
 // src/domains/web-server/routes/system-routes.ts
 import { spawn as spawn3 } from "node:child_process";
-import { execFile as execFile8 } from "node:child_process";
+import { execFile as execFile9 } from "node:child_process";
 import { existsSync as existsSync49 } from "node:fs";
 import { readFile as readFile40 } from "node:fs/promises";
 import { cpus, homedir as homedir42, totalmem } from "node:os";
 import { join as join71 } from "node:path";
 function runCommand(cmd, args, fallback2) {
   return new Promise((resolve35) => {
-    execFile8(cmd, args, { timeout: 5000 }, (err, stdout) => {
+    execFile9(cmd, args, { timeout: 5000 }, (err, stdout) => {
       if (err) {
         resolve35(fallback2);
       } else {
@@ -74607,8 +74740,8 @@ var require_picomatch2 = __commonJS((exports, module) => {
 });
 
 // src/services/package-installer/process-executor.ts
-import { exec as exec7, execFile as execFile9, spawn as spawn4 } from "node:child_process";
-import { promisify as promisify14 } from "node:util";
+import { exec as exec7, execFile as execFile10, spawn as spawn4 } from "node:child_process";
+import { promisify as promisify15 } from "node:util";
 function executeInteractiveScript(command, args, options2) {
   return new Promise((resolve38, reject) => {
     const child = spawn4(command, args, {
@@ -74645,10 +74778,10 @@ function getNpmCommand() {
   const platform10 = process.platform;
   return platform10 === "win32" ? "npm.cmd" : "npm";
 }
-var execAsync7, execFileAsync6;
+var execAsync7, execFileAsync7;
 var init_process_executor = __esm(() => {
-  execAsync7 = promisify14(exec7);
-  execFileAsync6 = promisify14(execFile9);
+  execAsync7 = promisify15(exec7);
+  execFileAsync7 = promisify15(execFile10);
 });
 
 // src/services/package-installer/validators.ts
@@ -74879,14 +75012,14 @@ async function installOpenCode() {
     const tempScriptPath = join90(tmpdir4(), "opencode-install.sh");
     try {
       logger.info("Downloading OpenCode installation script...");
-      await execFileAsync6("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
+      await execFileAsync7("curl", ["-fsSL", "https://opencode.ai/install", "-o", tempScriptPath], {
         timeout: 30000
       });
-      await execFileAsync6("chmod", ["+x", tempScriptPath], {
+      await execFileAsync7("chmod", ["+x", tempScriptPath], {
         timeout: 5000
       });
       logger.info("Executing OpenCode installation script...");
-      await execFileAsync6("bash", [tempScriptPath], {
+      await execFileAsync7("bash", [tempScriptPath], {
         timeout: 120000
       });
     } finally {
@@ -75077,8 +75210,8 @@ async function checkNeedsSudoPackages() {
     return false;
   }
   const { exec: exec8 } = await import("node:child_process");
-  const { promisify: promisify15 } = await import("node:util");
-  const execAsync8 = promisify15(exec8);
+  const { promisify: promisify16 } = await import("node:util");
+  const execAsync8 = promisify16(exec8);
   try {
     await Promise.all([
       execAsync8("which ffmpeg", { timeout: WHICH_COMMAND_TIMEOUT_MS }),
@@ -75649,7 +75782,7 @@ __export(exports_package_installer, {
   getPackageVersion: () => getPackageVersion,
   getNpmCommand: () => getNpmCommand,
   executeInteractiveScript: () => executeInteractiveScript,
-  execFileAsync: () => execFileAsync6,
+  execFileAsync: () => execFileAsync7,
   execAsync: () => execAsync7,
   PARTIAL_INSTALL_VERSION: () => PARTIAL_INSTALL_VERSION,
   EXIT_CODE_PARTIAL_SUCCESS: () => EXIT_CODE_PARTIAL_SUCCESS,
@@ -77576,11 +77709,11 @@ var require_extract_zip = __commonJS((exports, module) => {
   var { createWriteStream: createWriteStream3, promises: fs19 } = __require("fs");
   var getStream = require_get_stream();
   var path15 = __require("path");
-  var { promisify: promisify15 } = __require("util");
+  var { promisify: promisify16 } = __require("util");
   var stream = __require("stream");
   var yauzl = require_yauzl();
-  var openZip = promisify15(yauzl.open);
-  var pipeline = promisify15(stream.pipeline);
+  var openZip = promisify16(yauzl.open);
+  var pipeline = promisify16(stream.pipeline);
 
   class Extractor {
     constructor(zipPath, opts) {
@@ -77665,7 +77798,7 @@ var require_extract_zip = __commonJS((exports, module) => {
       if (isDir2)
         return;
       debug("opening read stream", dest);
-      const readStream = await promisify15(this.zipfile.openReadStream.bind(this.zipfile))(entry);
+      const readStream = await promisify16(this.zipfile.openReadStream.bind(this.zipfile))(entry);
       if (symlink4) {
         const link = await getStream(readStream);
         debug("creating symlink", link, dest);
@@ -77950,10 +78083,10 @@ __export(exports_worktree_manager, {
   cleanupAllWorktrees: () => cleanupAllWorktrees
 });
 import { existsSync as existsSync77 } from "node:fs";
-import { readFile as readFile69, writeFile as writeFile40 } from "node:fs/promises";
-import { join as join158 } from "node:path";
+import { readFile as readFile70, writeFile as writeFile41 } from "node:fs/promises";
+import { join as join159 } from "node:path";
 async function createWorktree(projectDir, issueNumber, baseBranch) {
-  const worktreePath = join158(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join159(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   await spawnAndCollect("git", ["fetch", "origin", baseBranch], projectDir).catch(() => {
     logger.warning(`[worktree] Could not fetch origin/${baseBranch}, using local`);
@@ -77971,7 +78104,7 @@ async function createWorktree(projectDir, issueNumber, baseBranch) {
   return worktreePath;
 }
 async function removeWorktree(projectDir, issueNumber) {
-  const worktreePath = join158(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
+  const worktreePath = join159(projectDir, WORKTREE_DIR, `issue-${issueNumber}`);
   const branchName = `ck-watch/issue-${issueNumber}`;
   try {
     await spawnAndCollect("git", ["worktree", "remove", worktreePath, "--force"], projectDir);
@@ -77985,7 +78118,7 @@ async function listActiveWorktrees(projectDir) {
   try {
     const output2 = await spawnAndCollect("git", ["worktree", "list", "--porcelain"], projectDir);
     const issueNumbers = [];
-    const worktreePrefix = join158(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
+    const worktreePrefix = join159(projectDir, WORKTREE_DIR, "issue-").replace(/\\/g, "/");
     for (const line of output2.split(`
 `)) {
       if (line.startsWith("worktree ")) {
@@ -78013,16 +78146,16 @@ async function cleanupAllWorktrees(projectDir) {
   await spawnAndCollect("git", ["worktree", "prune"], projectDir).catch(() => {});
 }
 async function ensureGitignore(projectDir) {
-  const gitignorePath = join158(projectDir, ".gitignore");
+  const gitignorePath = join159(projectDir, ".gitignore");
   try {
-    const content = existsSync77(gitignorePath) ? await readFile69(gitignorePath, "utf-8") : "";
+    const content = existsSync77(gitignorePath) ? await readFile70(gitignorePath, "utf-8") : "";
     if (!content.includes(".worktrees")) {
       const newContent = content.endsWith(`
 `) ? `${content}.worktrees/
 ` : `${content}
 .worktrees/
 `;
-      await writeFile40(gitignorePath, newContent, "utf-8");
+      await writeFile41(gitignorePath, newContent, "utf-8");
       logger.info("[worktree] Added .worktrees/ to .gitignore");
     }
   } catch (err) {
@@ -78117,16 +78250,16 @@ var init_content_validator = __esm(() => {
 
 // src/commands/content/phases/context-cache-manager.ts
 import { createHash as createHash9 } from "node:crypto";
-import { existsSync as existsSync83, mkdirSync as mkdirSync7, readFileSync as readFileSync21, readdirSync as readdirSync14, statSync as statSync15 } from "node:fs";
-import { rename as rename16, writeFile as writeFile42 } from "node:fs/promises";
+import { existsSync as existsSync83, mkdirSync as mkdirSync7, readFileSync as readFileSync22, readdirSync as readdirSync14, statSync as statSync15 } from "node:fs";
+import { rename as rename16, writeFile as writeFile43 } from "node:fs/promises";
 import { homedir as homedir54 } from "node:os";
-import { basename as basename34, join as join165 } from "node:path";
+import { basename as basename34, join as join166 } from "node:path";
 function getCachedContext(repoPath) {
   const cachePath = getCacheFilePath(repoPath);
   if (!existsSync83(cachePath))
     return null;
   try {
-    const raw2 = readFileSync21(cachePath, "utf-8");
+    const raw2 = readFileSync22(cachePath, "utf-8");
     const cache5 = JSON.parse(raw2);
     const age = Date.now() - new Date(cache5.createdAt).getTime();
     if (age >= CACHE_TTL_MS5)
@@ -78145,7 +78278,7 @@ async function saveCachedContext(repoPath, cache5) {
   }
   const cachePath = getCacheFilePath(repoPath);
   const tmpPath = `${cachePath}.tmp`;
-  await writeFile42(tmpPath, JSON.stringify(cache5, null, 2), "utf-8");
+  await writeFile43(tmpPath, JSON.stringify(cache5, null, 2), "utf-8");
   await rename16(tmpPath, cachePath);
 }
 function computeSourceHash(repoPath) {
@@ -78163,25 +78296,25 @@ function computeSourceHash(repoPath) {
 }
 function getDocSourcePaths(repoPath) {
   const paths = [];
-  const docsDir = join165(repoPath, "docs");
+  const docsDir = join166(repoPath, "docs");
   if (existsSync83(docsDir)) {
     try {
       const files = readdirSync14(docsDir);
       for (const f3 of files) {
         if (f3.endsWith(".md"))
-          paths.push(join165(docsDir, f3));
+          paths.push(join166(docsDir, f3));
       }
     } catch {}
   }
-  const readme = join165(repoPath, "README.md");
+  const readme = join166(repoPath, "README.md");
   if (existsSync83(readme))
     paths.push(readme);
-  const stylesDir = join165(repoPath, "assets", "writing-styles");
+  const stylesDir = join166(repoPath, "assets", "writing-styles");
   if (existsSync83(stylesDir)) {
     try {
       const files = readdirSync14(stylesDir);
       for (const f3 of files) {
-        paths.push(join165(stylesDir, f3));
+        paths.push(join166(stylesDir, f3));
       }
     } catch {}
   }
@@ -78190,11 +78323,11 @@ function getDocSourcePaths(repoPath) {
 function getCacheFilePath(repoPath) {
   const repoName = basename34(repoPath).replace(/[^a-zA-Z0-9_-]/g, "_");
   const pathHash = createHash9("sha256").update(repoPath).digest("hex").slice(0, 8);
-  return join165(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
+  return join166(CACHE_DIR, `${repoName}-${pathHash}-context-cache.json`);
 }
 var CACHE_DIR, CACHE_TTL_MS5;
 var init_context_cache_manager = __esm(() => {
-  CACHE_DIR = join165(homedir54(), ".claudekit", "cache");
+  CACHE_DIR = join166(homedir54(), ".claudekit", "cache");
   CACHE_TTL_MS5 = 24 * 60 * 60 * 1000;
 });
 
@@ -78374,8 +78507,8 @@ function extractContentFromResponse(response) {
 
 // src/commands/content/phases/docs-summarizer.ts
 import { execSync as execSync7 } from "node:child_process";
-import { existsSync as existsSync84, readFileSync as readFileSync22, readdirSync as readdirSync15 } from "node:fs";
-import { join as join166 } from "node:path";
+import { existsSync as existsSync84, readFileSync as readFileSync23, readdirSync as readdirSync15 } from "node:fs";
+import { join as join167 } from "node:path";
 async function summarizeProjectDocs(repoPath, contentLogger) {
   const rawContent = collectRawDocs(repoPath);
   if (rawContent.total.length < 200) {
@@ -78423,18 +78556,18 @@ function collectRawDocs(repoPath) {
       return "";
     if (totalChars >= MAX_RAW_CONTENT_CHARS)
       return "";
-    const content = readFileSync22(filePath, "utf-8");
+    const content = readFileSync23(filePath, "utf-8");
     const capped = content.slice(0, Math.min(maxChars, MAX_RAW_CONTENT_CHARS - totalChars));
     totalChars += capped.length;
     return capped;
   };
   const docsContent = [];
-  const docsDir = join166(repoPath, "docs");
+  const docsDir = join167(repoPath, "docs");
   if (existsSync84(docsDir)) {
     try {
       const files = readdirSync15(docsDir).filter((f3) => f3.endsWith(".md")).sort();
       for (const f3 of files) {
-        const content = readCapped(join166(docsDir, f3), 5000);
+        const content = readCapped(join167(docsDir, f3), 5000);
         if (content) {
           docsContent.push(`### ${f3}
 ${content}`);
@@ -78448,21 +78581,21 @@ ${content}`);
   let brand = "";
   const brandCandidates = ["docs/brand-guidelines.md", "docs/design-guidelines.md"];
   for (const p of brandCandidates) {
-    brand = readCapped(join166(repoPath, p), 3000);
+    brand = readCapped(join167(repoPath, p), 3000);
     if (brand)
       break;
   }
   let styles3 = "";
-  const stylesDir = join166(repoPath, "assets", "writing-styles");
+  const stylesDir = join167(repoPath, "assets", "writing-styles");
   if (existsSync84(stylesDir)) {
     try {
       const files = readdirSync15(stylesDir).slice(0, 3);
-      styles3 = files.map((f3) => readCapped(join166(stylesDir, f3), 1000)).filter(Boolean).join(`
+      styles3 = files.map((f3) => readCapped(join167(stylesDir, f3), 1000)).filter(Boolean).join(`
 
 `);
     } catch {}
   }
-  const readme = readCapped(join166(repoPath, "README.md"), 3000);
+  const readme = readCapped(join167(repoPath, "README.md"), 3000);
   const total = [docs, brand, styles3, readme].join(`
 `);
   return { docs, brand, styles: styles3, readme, total };
@@ -78649,9 +78782,9 @@ IMPORTANT: Generate the image and output the path as JSON: {"imagePath": "/path/
 import { execSync as execSync8 } from "node:child_process";
 import { existsSync as existsSync85, mkdirSync as mkdirSync8, readdirSync as readdirSync16 } from "node:fs";
 import { homedir as homedir55 } from "node:os";
-import { join as join167 } from "node:path";
+import { join as join168 } from "node:path";
 async function generatePhoto(_content, context, config, platform18, contentId, contentLogger) {
-  const mediaDir = join167(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
+  const mediaDir = join168(config.contentDir.replace(/^~/, homedir55()), "media", String(contentId));
   if (!existsSync85(mediaDir)) {
     mkdirSync8(mediaDir, { recursive: true });
   }
@@ -78676,7 +78809,7 @@ async function generatePhoto(_content, context, config, platform18, contentId, c
     const imageFile = files.find((f3) => /\.(png|jpg|jpeg|webp)$/i.test(f3));
     if (imageFile) {
       const ext2 = imageFile.split(".").pop() ?? "png";
-      return { path: join167(mediaDir, imageFile), ...dimensions, format: ext2 };
+      return { path: join168(mediaDir, imageFile), ...dimensions, format: ext2 };
     }
     contentLogger.warn(`Photo generation produced no image for content ${contentId}`);
     return null;
@@ -78766,7 +78899,7 @@ var init_content_creator = __esm(() => {
 // src/commands/content/phases/content-logger.ts
 import { createWriteStream as createWriteStream4, existsSync as existsSync86, mkdirSync as mkdirSync9, statSync as statSync16 } from "node:fs";
 import { homedir as homedir56 } from "node:os";
-import { join as join168 } from "node:path";
+import { join as join169 } from "node:path";
 
 class ContentLogger {
   stream = null;
@@ -78774,7 +78907,7 @@ class ContentLogger {
   logDir;
   maxBytes;
   constructor(maxBytes = 0) {
-    this.logDir = join168(homedir56(), ".claudekit", "logs");
+    this.logDir = join169(homedir56(), ".claudekit", "logs");
     this.maxBytes = maxBytes;
   }
   init() {
@@ -78806,7 +78939,7 @@ class ContentLogger {
     }
   }
   getLogPath() {
-    return join168(this.logDir, `content-${this.getDateStr()}.log`);
+    return join169(this.logDir, `content-${this.getDateStr()}.log`);
   }
   write(level, message) {
     this.rotateIfNeeded();
@@ -78823,18 +78956,18 @@ class ContentLogger {
     if (dateStr !== this.currentDate) {
       this.close();
       this.currentDate = dateStr;
-      const logPath = join168(this.logDir, `content-${dateStr}.log`);
+      const logPath = join169(this.logDir, `content-${dateStr}.log`);
       this.stream = createWriteStream4(logPath, { flags: "a", mode: 384 });
       return;
     }
     if (this.maxBytes > 0 && this.stream) {
-      const logPath = join168(this.logDir, `content-${this.currentDate}.log`);
+      const logPath = join169(this.logDir, `content-${this.currentDate}.log`);
       try {
         const stat26 = statSync16(logPath);
         if (stat26.size >= this.maxBytes) {
           this.close();
           const suffix = Date.now();
-          const rotatedPath = join168(this.logDir, `content-${this.currentDate}-${suffix}.log`);
+          const rotatedPath = join169(this.logDir, `content-${this.currentDate}-${suffix}.log`);
           import("node:fs/promises").then(({ rename: rename17 }) => rename17(logPath, rotatedPath).catch(() => {}));
           this.stream = createWriteStream4(logPath, { flags: "w", mode: 384 });
         }
@@ -79104,8 +79237,8 @@ function isNoiseCommit(title, author) {
 
 // src/commands/content/phases/change-detector.ts
 import { execSync as execSync10, spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync88, readFileSync as readFileSync23, readdirSync as readdirSync17, statSync as statSync17 } from "node:fs";
-import { join as join169 } from "node:path";
+import { existsSync as existsSync88, readFileSync as readFileSync24, readdirSync as readdirSync17, statSync as statSync17 } from "node:fs";
+import { join as join170 } from "node:path";
 function detectCommits(repo, since) {
   try {
     const fetchUrl = sshToHttps(repo.remoteUrl);
@@ -79214,7 +79347,7 @@ function detectTags(repo, since) {
   }
 }
 function detectCompletedPlans(repo, since) {
-  const plansDir = join169(repo.path, "plans");
+  const plansDir = join170(repo.path, "plans");
   if (!existsSync88(plansDir))
     return [];
   const sinceMs = new Date(since).getTime();
@@ -79224,14 +79357,14 @@ function detectCompletedPlans(repo, since) {
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const planFile = join169(plansDir, entry.name, "plan.md");
+      const planFile = join170(plansDir, entry.name, "plan.md");
       if (!existsSync88(planFile))
         continue;
       try {
         const stat26 = statSync17(planFile);
         if (stat26.mtimeMs < sinceMs)
           continue;
-        const content = readFileSync23(planFile, "utf-8");
+        const content = readFileSync24(planFile, "utf-8");
         const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
         if (!frontmatterMatch)
           continue;
@@ -79302,7 +79435,7 @@ function classifyCommit(event) {
 // src/commands/content/phases/repo-discoverer.ts
 import { execSync as execSync11 } from "node:child_process";
 import { readdirSync as readdirSync18 } from "node:fs";
-import { join as join170 } from "node:path";
+import { join as join171 } from "node:path";
 function discoverRepos2(cwd2) {
   const repos = [];
   if (isGitRepoRoot(cwd2)) {
@@ -79315,7 +79448,7 @@ function discoverRepos2(cwd2) {
     for (const entry of entries) {
       if (!entry.isDirectory() || entry.name.startsWith("."))
         continue;
-      const dirPath = join170(cwd2, entry.name);
+      const dirPath = join171(cwd2, entry.name);
       if (isGitRepoRoot(dirPath)) {
         const info = getRepoInfo(dirPath);
         if (info)
@@ -79982,12 +80115,12 @@ var init_types6 = __esm(() => {
 });
 
 // src/commands/content/phases/state-manager.ts
-import { readFile as readFile71, rename as rename17, writeFile as writeFile43 } from "node:fs/promises";
-import { join as join171 } from "node:path";
+import { readFile as readFile72, rename as rename17, writeFile as writeFile44 } from "node:fs/promises";
+import { join as join172 } from "node:path";
 async function loadContentConfig(projectDir) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join172(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile71(configPath, "utf-8");
+    const raw2 = await readFile72(configPath, "utf-8");
     const json = JSON.parse(raw2);
     return ContentConfigSchema.parse(json.content ?? {});
   } catch {
@@ -79995,15 +80128,15 @@ async function loadContentConfig(projectDir) {
   }
 }
 async function saveContentConfig(projectDir, config) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
-  const json = await readJsonSafe3(configPath);
+  const configPath = join172(projectDir, CK_CONFIG_FILE2);
+  const json = await readJsonSafe4(configPath);
   json.content = { ...json.content, ...config };
   await atomicWrite3(configPath, json);
 }
 async function loadContentState(projectDir) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join172(projectDir, CK_CONFIG_FILE2);
   try {
-    const raw2 = await readFile71(configPath, "utf-8");
+    const raw2 = await readFile72(configPath, "utf-8");
     const json = JSON.parse(raw2);
     const contentBlock = json.content ?? {};
     return ContentStateSchema.parse(contentBlock.state ?? {});
@@ -80012,7 +80145,7 @@ async function loadContentState(projectDir) {
   }
 }
 async function saveContentState(projectDir, state) {
-  const configPath = join171(projectDir, CK_CONFIG_FILE2);
+  const configPath = join172(projectDir, CK_CONFIG_FILE2);
   const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
   for (const key of Object.keys(state.dailyPostCounts)) {
     const dateStr = key.slice(-10);
@@ -80021,16 +80154,16 @@ async function saveContentState(projectDir, state) {
     }
   }
   ContentStateSchema.parse(state);
-  const json = await readJsonSafe3(configPath);
+  const json = await readJsonSafe4(configPath);
   if (!json.content || typeof json.content !== "object") {
     json.content = {};
   }
   json.content.state = state;
   await atomicWrite3(configPath, json);
 }
-async function readJsonSafe3(filePath) {
+async function readJsonSafe4(filePath) {
   try {
-    const raw2 = await readFile71(filePath, "utf-8");
+    const raw2 = await readFile72(filePath, "utf-8");
     return JSON.parse(raw2);
   } catch {
     return {};
@@ -80038,7 +80171,7 @@ async function readJsonSafe3(filePath) {
 }
 async function atomicWrite3(filePath, data) {
   const tmpPath = `${filePath}.tmp`;
-  await writeFile43(tmpPath, JSON.stringify(data, null, 2), "utf-8");
+  await writeFile44(tmpPath, JSON.stringify(data, null, 2), "utf-8");
   await rename17(tmpPath, filePath);
 }
 var CK_CONFIG_FILE2 = ".ck.json";
@@ -80294,7 +80427,7 @@ var init_platform_setup_x = __esm(() => {
 
 // src/commands/content/phases/setup-wizard.ts
 import { existsSync as existsSync89 } from "node:fs";
-import { join as join172 } from "node:path";
+import { join as join173 } from "node:path";
 async function runSetupWizard2(cwd2, contentLogger) {
   console.log();
   oe(import_picocolors43.default.bgCyan(import_picocolors43.default.white(" CK Content — Multi-Channel Content Engine ")));
@@ -80362,8 +80495,8 @@ async function showRepoSummary(cwd2) {
 function detectBrandAssets(cwd2, contentLogger) {
   const repos = discoverRepos2(cwd2);
   for (const repo of repos) {
-    const hasGuidelines = existsSync89(join172(repo.path, "docs", "brand-guidelines.md"));
-    const hasStyles = existsSync89(join172(repo.path, "assets", "writing-styles"));
+    const hasGuidelines = existsSync89(join173(repo.path, "docs", "brand-guidelines.md"));
+    const hasStyles = existsSync89(join173(repo.path, "assets", "writing-styles"));
     if (!hasGuidelines) {
       f2.warning(`${repo.name}: No docs/brand-guidelines.md — content will use generic tone.`);
       contentLogger.warn(`${repo.name}: missing docs/brand-guidelines.md`);
@@ -80503,15 +80636,15 @@ __export(exports_content_subcommands, {
   logsContent: () => logsContent,
   approveContentCmd: () => approveContentCmd
 });
-import { existsSync as existsSync91, readFileSync as readFileSync24, unlinkSync as unlinkSync6 } from "node:fs";
+import { existsSync as existsSync91, readFileSync as readFileSync25, unlinkSync as unlinkSync6 } from "node:fs";
 import { homedir as homedir58 } from "node:os";
-import { join as join173 } from "node:path";
+import { join as join174 } from "node:path";
 function isDaemonRunning() {
-  const lockFile = join173(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join174(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync91(lockFile))
     return { running: false, pid: null };
   try {
-    const pidStr = readFileSync24(lockFile, "utf-8").trim();
+    const pidStr = readFileSync25(lockFile, "utf-8").trim();
     const pid = Number.parseInt(pidStr, 10);
     if (Number.isNaN(pid)) {
       unlinkSync6(lockFile);
@@ -80539,13 +80672,13 @@ async function startContent(options2) {
   await contentCommand(options2);
 }
 async function stopContent() {
-  const lockFile = join173(LOCK_DIR, `${LOCK_NAME2}.lock`);
+  const lockFile = join174(LOCK_DIR, `${LOCK_NAME2}.lock`);
   if (!existsSync91(lockFile)) {
     logger.info("Content daemon is not running.");
     return;
   }
   try {
-    const pidStr = readFileSync24(lockFile, "utf-8").trim();
+    const pidStr = readFileSync25(lockFile, "utf-8").trim();
     const pid = Number.parseInt(pidStr, 10);
     if (!Number.isNaN(pid)) {
       process.kill(pid, "SIGTERM");
@@ -80578,9 +80711,9 @@ async function statusContent() {
   } catch {}
 }
 async function logsContent(options2) {
-  const logDir = join173(homedir58(), ".claudekit", "logs");
+  const logDir = join174(homedir58(), ".claudekit", "logs");
   const dateStr = new Date().toISOString().slice(0, 10).replace(/-/g, "");
-  const logPath = join173(logDir, `content-${dateStr}.log`);
+  const logPath = join174(logDir, `content-${dateStr}.log`);
   if (!existsSync91(logPath)) {
     logger.info("No content logs found for today.");
     return;
@@ -80593,7 +80726,7 @@ async function logsContent(options2) {
       process.exit(0);
     });
   } else {
-    const content = readFileSync24(logPath, "utf-8");
+    const content = readFileSync25(logPath, "utf-8");
     console.log(content);
   }
 }
@@ -80612,13 +80745,13 @@ var init_content_subcommands = __esm(() => {
   init_setup_wizard();
   init_state_manager();
   init_content_review_commands();
-  LOCK_DIR = join173(homedir58(), ".claudekit", "locks");
+  LOCK_DIR = join174(homedir58(), ".claudekit", "locks");
 });
 
 // src/commands/content/content-command.ts
 import { existsSync as existsSync92, mkdirSync as mkdirSync11, unlinkSync as unlinkSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir59 } from "node:os";
-import { join as join174 } from "node:path";
+import { join as join175 } from "node:path";
 async function contentCommand(options2) {
   const cwd2 = process.cwd();
   const contentLogger = new ContentLogger;
@@ -80796,8 +80929,8 @@ var init_content_command = __esm(() => {
   init_publisher();
   init_review_manager();
   init_state_manager();
-  LOCK_DIR2 = join174(homedir59(), ".claudekit", "locks");
-  LOCK_FILE = join174(LOCK_DIR2, "ck-content.lock");
+  LOCK_DIR2 = join175(homedir59(), ".claudekit", "locks");
+  LOCK_FILE = join175(LOCK_DIR2, "ck-content.lock");
 });
 
 // src/commands/content/index.ts
@@ -87963,7 +88096,7 @@ class CheckRunner {
 }
 // src/domains/health-checks/system-checker.ts
 import { exec as exec6 } from "node:child_process";
-import { promisify as promisify13 } from "node:util";
+import { promisify as promisify14 } from "node:util";
 
 // src/domains/github/gh-cli-utils.ts
 init_environment();
@@ -88031,8 +88164,8 @@ function getGhUpgradeInstructions(currentVersion) {
 init_environment();
 init_logger();
 import { exec as exec3 } from "node:child_process";
-import { promisify as promisify10 } from "node:util";
-var execAsync3 = promisify10(exec3);
+import { promisify as promisify11 } from "node:util";
+var execAsync3 = promisify11(exec3);
 function getOSInfo() {
   const platform8 = process.platform;
   const arch2 = process.arch;
@@ -88253,7 +88386,7 @@ async function checkAllDependencies() {
 // src/services/package-installer/dependency-installer.ts
 init_logger();
 import { exec as exec5 } from "node:child_process";
-import { promisify as promisify12 } from "node:util";
+import { promisify as promisify13 } from "node:util";
 
 // src/services/package-installer/dependencies/node-installer.ts
 var NODEJS_INSTALLERS = [
@@ -88347,8 +88480,8 @@ var PYTHON_INSTALLERS = [
 init_logger();
 import { exec as exec4 } from "node:child_process";
 import * as fs7 from "node:fs";
-import { promisify as promisify11 } from "node:util";
-var execAsync4 = promisify11(exec4);
+import { promisify as promisify12 } from "node:util";
+var execAsync4 = promisify12(exec4);
 async function detectOS() {
   const platform8 = process.platform;
   const info = { platform: platform8 };
@@ -88418,7 +88551,7 @@ var CLAUDE_INSTALLERS = [
 ];
 
 // src/services/package-installer/dependency-installer.ts
-var execAsync5 = promisify12(exec5);
+var execAsync5 = promisify13(exec5);
 function getInstallerMethods(dependency, osInfo) {
   let installers = dependency === "claude" ? CLAUDE_INSTALLERS : dependency === "python" || dependency === "pip" ? PYTHON_INSTALLERS : dependency === "nodejs" ? NODEJS_INSTALLERS : [];
   installers = installers.filter((m2) => m2.platform === osInfo.platform);
@@ -88474,7 +88607,7 @@ async function installDependency(dependency, method) {
 
 // src/domains/health-checks/system-checker.ts
 init_logger();
-var execAsync6 = promisify13(exec6);
+var execAsync6 = promisify14(exec6);
 
 class SystemChecker {
   group = "system";
@@ -101939,10 +102072,10 @@ class TarExtractor {
 // src/domains/installation/extraction/zip-extractor.ts
 init_logger();
 var import_extract_zip = __toESM(require_extract_zip(), 1);
-import { execFile as execFile10 } from "node:child_process";
+import { execFile as execFile11 } from "node:child_process";
 import { copyFile as copyFile5, mkdir as mkdir29, readdir as readdir26, rm as rm12, stat as stat16 } from "node:fs/promises";
 import { join as join103 } from "node:path";
-import { promisify as promisify15 } from "node:util";
+import { promisify as promisify16 } from "node:util";
 
 // src/domains/installation/extraction/native-zip-commands.ts
 var NATIVE_EXTRACT_TIMEOUT_MS = 120000;
@@ -101981,7 +102114,7 @@ function getNativeZipCommands(archivePath, destDir, platformName = process.platf
 }
 
 // src/domains/installation/extraction/zip-extractor.ts
-var execFileAsync7 = promisify15(execFile10);
+var execFileAsync8 = promisify16(execFile11);
 
 class ZipExtractor {
   async tryNativeExtraction(archivePath, destDir) {
@@ -101993,7 +102126,7 @@ class ZipExtractor {
       try {
         await rm12(destDir, { recursive: true, force: true });
         await mkdir29(destDir, { recursive: true });
-        await execFileAsync7(nativeCommand.command, nativeCommand.args, {
+        await execFileAsync8(nativeCommand.command, nativeCommand.args, {
           timeout: NATIVE_EXTRACT_TIMEOUT_MS,
           windowsHide: true
         });
@@ -102631,7 +102764,7 @@ import { join as join122 } from "node:path";
 
 // src/domains/installation/deletion-handler.ts
 import { existsSync as existsSync66, lstatSync as lstatSync3, readdirSync as readdirSync10, rmSync as rmSync2, rmdirSync, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname38, join as join107, relative as relative21, resolve as resolve42, sep as sep11 } from "node:path";
+import { dirname as dirname38, join as join107, relative as relative21, resolve as resolve42, sep as sep12 } from "node:path";
 
 // src/services/file-operations/manifest/manifest-reader.ts
 init_metadata_migration();
@@ -102878,7 +103011,7 @@ function cleanupEmptyDirectories(filePath, claudeDir3) {
 function deletePath(fullPath, claudeDir3) {
   const normalizedPath = resolve42(fullPath);
   const normalizedClaudeDir = resolve42(claudeDir3);
-  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep11}`) && normalizedPath !== normalizedClaudeDir) {
+  if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep12}`) && normalizedPath !== normalizedClaudeDir) {
     throw new Error(`Path traversal detected: ${fullPath}`);
   }
   try {
@@ -102952,7 +103085,7 @@ async function handleDeletions(sourceMetadata, claudeDir3, kitType) {
     const fullPath = join107(claudeDir3, path16);
     const normalizedPath = resolve42(fullPath);
     const normalizedClaudeDir = resolve42(claudeDir3);
-    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep11}`)) {
+    if (!normalizedPath.startsWith(`${normalizedClaudeDir}${sep12}`)) {
       logger.warning(`Skipping invalid path: ${path16}`);
       result.errors.push(path16);
       continue;
@@ -104050,8 +104183,8 @@ var path16 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep12 = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
-minimatch.sep = sep12;
+var sep13 = defaultPlatform === "win32" ? path16.win32.sep : path16.posix.sep;
+minimatch.sep = sep13;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
 var qmark2 = "[^/]";
@@ -108818,7 +108951,8 @@ async function handlePostInstall(ctx) {
   };
 }
 // src/commands/init/phases/plugin-install-handler.ts
-import { cpSync as cpSync2, existsSync as existsSync69, mkdirSync as mkdirSync6, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
+init_codex_plugin_installer();
+import { cpSync as cpSync2, existsSync as existsSync69, mkdirSync as mkdirSync6, readFileSync as readFileSync21, rmSync as rmSync4, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join135 } from "node:path";
 
 // src/domains/installation/plugin/migrate-legacy-to-plugin.ts
@@ -108828,18 +108962,18 @@ import { dirname as dirname43, join as join134 } from "node:path";
 
 // src/domains/installation/plugin/plugin-installer.ts
 init_install_mode_detector();
-import { execFile as execFile11 } from "node:child_process";
-import { promisify as promisify16 } from "node:util";
-var execFileAsync8 = promisify16(execFile11);
-var DEFAULT_TIMEOUT_MS2 = 120000;
+import { execFile as execFile12 } from "node:child_process";
+import { promisify as promisify17 } from "node:util";
+var execFileAsync9 = promisify17(execFile12);
+var DEFAULT_TIMEOUT_MS3 = 120000;
 var defaultClaudeRunner = async (args, opts) => {
   const env2 = { ...process.env };
   if (opts?.configDir)
     env2.CLAUDE_CONFIG_DIR = opts.configDir;
   try {
-    const { stdout: stdout2, stderr } = await execFileAsync8("claude", args, {
+    const { stdout: stdout2, stderr } = await execFileAsync9("claude", args, {
       env: env2,
-      timeout: opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+      timeout: opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS3,
       maxBuffer: 10 * 1024 * 1024
     });
     return { ok: true, stdout: String(stdout2), stderr: String(stderr), code: 0 };
@@ -109065,12 +109199,23 @@ async function handlePluginInstall(ctx, deps = {}) {
     return ctx;
   }
   const migrate = deps.migrate ?? migrateLegacyToPlugin;
+  const installCodex = deps.installCodex ?? installCodexPlugin;
   try {
     const pluginSourceDir = stagePluginSource(ctx.extractDir, deps.stageBaseDir);
-    const result = await migrate({ pluginSourceDir, claudeDir: ctx.claudeDir });
-    logPluginResult(result);
+    try {
+      const result = await migrate({ pluginSourceDir, claudeDir: ctx.claudeDir });
+      logPluginResult(result);
+    } catch (err) {
+      logger.verbose(`Claude plugin install skipped (legacy copy retained): ${err.message}`);
+    }
+    try {
+      const result = await installCodex({ pluginSourceDir });
+      logCodexPluginResult(result);
+    } catch (err) {
+      logger.verbose(`Codex plugin install skipped: ${err.message}`);
+    }
   } catch (err) {
-    logger.verbose(`Plugin install skipped (legacy copy retained): ${err.message}`);
+    logger.verbose(`Plugin staging skipped (legacy copy retained): ${err.message}`);
   }
   return ctx;
 }
@@ -109082,17 +109227,88 @@ function stagePluginSource(extractDir, stageBaseDir) {
   }
   rmSync4(base2, { recursive: true, force: true });
   mkdirSync6(base2, { recursive: true });
-  cpSync2(payloadSrc, join135(base2, ".claude"), { recursive: true });
-  const marketplace = {
+  const stagedPayload = join135(base2, ".claude");
+  cpSync2(payloadSrc, stagedPayload, { recursive: true });
+  ensureCodexPluginManifest(stagedPayload);
+  const claudeMarketplace = {
     name: "claudekit",
     owner: { name: "ClaudeKit" },
     plugins: [{ name: "ck", source: "./.claude", description: "ClaudeKit Engineer" }]
   };
   mkdirSync6(join135(base2, ".claude-plugin"), { recursive: true });
-  writeFileSync8(join135(base2, ".claude-plugin", "marketplace.json"), `${JSON.stringify(marketplace, null, 2)}
+  writeFileSync8(join135(base2, ".claude-plugin", "marketplace.json"), `${JSON.stringify(claudeMarketplace, null, 2)}
+`, "utf-8");
+  const codexMarketplace = {
+    name: "claudekit",
+    interface: { displayName: "ClaudeKit" },
+    plugins: [
+      {
+        name: "ck",
+        source: { source: "local", path: "./.claude" },
+        policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
+        category: "Productivity"
+      }
+    ]
+  };
+  mkdirSync6(join135(base2, ".agents", "plugins"), { recursive: true });
+  writeFileSync8(join135(base2, ".agents", "plugins", "marketplace.json"), `${JSON.stringify(codexMarketplace, null, 2)}
 `, "utf-8");
   return base2;
 }
+function ensureCodexPluginManifest(pluginRoot) {
+  const manifestPath = join135(pluginRoot, ".codex-plugin", "plugin.json");
+  if (existsSync69(manifestPath))
+    return;
+  const claudeManifest = readJsonSafe3(join135(pluginRoot, ".claude-plugin", "plugin.json"));
+  const manifest = pruneUndefined({
+    name: stringField(claudeManifest, "name") ?? "ck",
+    version: stringField(claudeManifest, "version") ?? "0.0.0",
+    description: stringField(claudeManifest, "description") ?? "ClaudeKit Engineer — multi-agent planning, code review, debugging, and workflow skills for Codex.",
+    author: authorField(claudeManifest),
+    homepage: stringField(claudeManifest, "homepage"),
+    repository: stringField(claudeManifest, "repository"),
+    license: stringField(claudeManifest, "license"),
+    keywords: ["claudekit", "codex", "skills", "agents", "workflow"],
+    skills: "./skills/",
+    interface: {
+      displayName: "ClaudeKit Engineer",
+      shortDescription: "ClaudeKit planning, review, debugging, and workflow skills.",
+      longDescription: "ClaudeKit Engineer provides planning, code review, debugging, testing, browser workflow, and implementation skills for Codex.",
+      developerName: "ClaudeKit",
+      category: "Productivity",
+      capabilities: ["Skills"],
+      websiteURL: "https://github.com/claudekit/claudekit-engineer"
+    }
+  });
+  mkdirSync6(join135(pluginRoot, ".codex-plugin"), { recursive: true });
+  writeFileSync8(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf-8");
+}
+function readJsonSafe3(filePath) {
+  try {
+    const parsed = JSON.parse(readFileSync21(filePath, "utf-8"));
+    return isRecord3(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function stringField(source, key) {
+  const value = source?.[key];
+  return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+function authorField(source) {
+  const author = source?.author;
+  if (isRecord3(author) && typeof author.name === "string" && author.name.trim() !== "") {
+    return { name: author.name };
+  }
+  return { name: "ClaudeKit" };
+}
+function pruneUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function logPluginResult(result) {
   switch (result.action) {
     case "migrated-from-legacy":
@@ -109112,6 +109328,19 @@ function logPluginResult(result) {
       break;
   }
 }
+function logCodexPluginResult(result) {
+  switch (result.action) {
+    case "installed":
+      logger.info("Installed ClaudeKit Engineer as a Codex plugin.");
+      break;
+    case "skipped-codex-unsupported":
+      logger.verbose("Codex plugin support unavailable; skipped Codex plugin install.");
+      break;
+    case "install-failed":
+      logger.verbose(`Codex plugin install did not verify. ${result.error ?? ""}`);
+      break;
+  }
+}
 // src/commands/init/phases/selection-handler.ts
 init_config_manager();
 init_github_client();
@@ -109187,8 +109416,8 @@ async function detectAccessibleKits() {
 // src/domains/github/preflight-checker.ts
 init_logger();
 import { exec as exec8 } from "node:child_process";
-import { promisify as promisify17 } from "node:util";
-var execAsync8 = promisify17(exec8);
+import { promisify as promisify18 } from "node:util";
+var execAsync8 = promisify18(exec8);
 function createSuccessfulPreflightResult() {
   return {
     success: true,
@@ -109283,6 +109512,9 @@ async function runPreflightChecks() {
   return result;
 }
 
+// src/commands/init/phases/selection-handler.ts
+init_hook_health_checker();
+
 // src/domains/installation/fresh-installer.ts
 init_metadata_migration();
 import { existsSync as existsSync70, readdirSync as readdirSync11, rmSync as rmSync5, rmdirSync as rmdirSync2, unlinkSync as unlinkSync5 } from "node:fs";
@@ -110028,8 +110260,13 @@ async function handleSelection(ctx) {
       const existingMetadata = await readManifest(claudeDir3);
       const installedKitVersion = existingMetadata?.kits?.[kitType]?.version;
       if (installedKitVersion && versionsMatch(installedKitVersion, releaseTag)) {
-        logger.success(`Already at latest version (${kitType}@${installedKitVersion}), skipping reinstall`);
-        return { ...ctx, cancelled: true };
+        const missingHookFiles = await countMissingHookFileReferencesForClaudeDir(claudeDir3);
+        if (missingHookFiles > 0) {
+          logger.warning(`Detected ${missingHookFiles} registered hook(s) whose script is missing on disk; reinstalling to restore them`);
+        } else {
+          logger.success(`Already at latest version (${kitType}@${installedKitVersion}), skipping reinstall`);
+          return { ...ctx, cancelled: true };
+        }
       }
     } catch (error) {
       logger.verbose(`Metadata read failed, proceeding with installation: ${error instanceof Error ? error.message : "unknown"}`);
@@ -115778,11 +116015,11 @@ async function detectInstallations() {
 
 // src/commands/uninstall/removal-handler.ts
 import { readdirSync as readdirSync13, rmSync as rmSync8 } from "node:fs";
-import { basename as basename33, join as join157, resolve as resolve56, sep as sep13 } from "node:path";
+import { basename as basename33, join as join158, resolve as resolve56, sep as sep14 } from "node:path";
 init_logger();
 init_safe_prompts();
 init_safe_spinner();
-var import_fs_extra43 = __toESM(require_lib(), 1);
+var import_fs_extra44 = __toESM(require_lib(), 1);
 
 // src/commands/uninstall/analysis-handler.ts
 init_metadata_migration();
@@ -115934,10 +116171,170 @@ function displayDryRunPreview(analysis, installationType) {
   }
 }
 
+// src/commands/uninstall/settings-cleanup.ts
+init_settings_merger();
+init_command_normalizer();
+init_logger();
+var import_fs_extra43 = __toESM(require_lib(), 1);
+import { join as join157 } from "node:path";
+var CK_JSON_FILE2 = ".ck.json";
+var SETTINGS_FILE = "settings.json";
+var EMPTY_RESULT = {
+  hooksRemoved: 0,
+  mcpServersRemoved: 0,
+  settingsFileRemoved: false,
+  ckJsonRemoved: false
+};
+function resolveRemovalTargets(kits, removedKitNames, remainingKits) {
+  const retainedHooks = new Set;
+  const retainedServers = new Set;
+  for (const remainingKit of remainingKits) {
+    const installed = kits[remainingKit]?.installedSettings;
+    for (const command of installed?.hooks ?? []) {
+      const normalized = normalizeCommand(command);
+      if (normalized)
+        retainedHooks.add(normalized);
+    }
+    for (const server of installed?.mcpServers ?? []) {
+      retainedServers.add(server);
+    }
+  }
+  const hooks = new Set;
+  const servers = new Set;
+  for (const kitName of removedKitNames) {
+    const installed = kits[kitName]?.installedSettings;
+    for (const command of installed?.hooks ?? []) {
+      const normalized = normalizeCommand(command);
+      if (normalized && !retainedHooks.has(normalized))
+        hooks.add(normalized);
+    }
+    for (const server of installed?.mcpServers ?? []) {
+      if (!retainedServers.has(server))
+        servers.add(server);
+    }
+  }
+  return { hooks, servers };
+}
+function removeHooksFromSettings(settings, normalizedToRemove) {
+  if (!settings.hooks || normalizedToRemove.size === 0)
+    return 0;
+  let removed = 0;
+  const eventKeysToDelete = [];
+  for (const [eventName, entries] of Object.entries(settings.hooks)) {
+    const keptEntries = [];
+    for (const entry of entries) {
+      if (Array.isArray(entry.hooks)) {
+        const keptHooks = entry.hooks.filter((hook) => {
+          if (typeof hook.command === "string" && normalizedToRemove.has(normalizeCommand(hook.command))) {
+            removed++;
+            return false;
+          }
+          return true;
+        });
+        if (keptHooks.length > 0) {
+          keptEntries.push({ ...entry, hooks: keptHooks });
+        }
+        continue;
+      }
+      if (typeof entry.command === "string" && normalizedToRemove.has(normalizeCommand(entry.command))) {
+        removed++;
+        continue;
+      }
+      keptEntries.push(entry);
+    }
+    if (keptEntries.length > 0) {
+      settings.hooks[eventName] = keptEntries;
+    } else {
+      eventKeysToDelete.push(eventName);
+    }
+  }
+  for (const eventName of eventKeysToDelete) {
+    delete settings.hooks[eventName];
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    Reflect.deleteProperty(settings, "hooks");
+  }
+  return removed;
+}
+function removeMcpServersFromSettings(settings, serversToRemove) {
+  const servers = settings.mcp?.servers;
+  if (!servers || serversToRemove.size === 0)
+    return 0;
+  let removed = 0;
+  for (const name2 of serversToRemove) {
+    if (Object.hasOwn(servers, name2)) {
+      delete servers[name2];
+      removed++;
+    }
+  }
+  if (removed > 0 && settings.mcp) {
+    if (Object.keys(servers).length === 0) {
+      Reflect.deleteProperty(settings.mcp, "servers");
+    }
+    if (Object.keys(settings.mcp).length === 0) {
+      Reflect.deleteProperty(settings, "mcp");
+    }
+  }
+  return removed;
+}
+async function cleanupCkJson(ckJsonPath, data, removedKitNames, dryRun) {
+  if (!data.kits)
+    return false;
+  for (const kitName of removedKitNames) {
+    delete data.kits[kitName];
+  }
+  const noKitsLeft = Object.keys(data.kits).length === 0;
+  const otherTopLevelKeys = Object.keys(data).filter((key) => key !== "kits");
+  if (dryRun)
+    return noKitsLeft && otherTopLevelKeys.length === 0;
+  if (noKitsLeft && otherTopLevelKeys.length === 0) {
+    await import_fs_extra43.remove(ckJsonPath);
+    return true;
+  }
+  if (noKitsLeft) {
+    Reflect.deleteProperty(data, "kits");
+  }
+  await import_fs_extra43.writeFile(ckJsonPath, JSON.stringify(data, null, 2), "utf-8");
+  return false;
+}
+async function cleanupUninstalledSettings(installationPath, options2) {
+  const ckJsonPath = join157(installationPath, CK_JSON_FILE2);
+  if (!await import_fs_extra43.pathExists(ckJsonPath)) {
+    return { ...EMPTY_RESULT };
+  }
+  let data;
+  try {
+    data = parseJsonContent(await import_fs_extra43.readFile(ckJsonPath, "utf-8"));
+  } catch (error) {
+    logger.debug(`Settings cleanup: failed to parse ${ckJsonPath}: ${error instanceof Error ? error.message : "unknown error"}`);
+    return { ...EMPTY_RESULT };
+  }
+  const kits = data.kits ?? {};
+  const removedKitNames = options2.kit ? [options2.kit] : Object.keys(kits);
+  const { hooks, servers } = resolveRemovalTargets(kits, removedKitNames, options2.remainingKits);
+  const result = { ...EMPTY_RESULT };
+  const settingsPath = join157(installationPath, SETTINGS_FILE);
+  const settings = await SettingsMerger.readSettingsFile(settingsPath);
+  if (settings) {
+    result.hooksRemoved = removeHooksFromSettings(settings, hooks);
+    result.mcpServersRemoved = removeMcpServersFromSettings(settings, servers);
+    if (!options2.dryRun && (result.hooksRemoved > 0 || result.mcpServersRemoved > 0)) {
+      if (Object.keys(settings).length === 0) {
+        await import_fs_extra43.remove(settingsPath);
+        result.settingsFileRemoved = true;
+      } else {
+        await SettingsMerger.writeSettingsFile(settingsPath, settings);
+      }
+    }
+  }
+  result.ckJsonRemoved = await cleanupCkJson(ckJsonPath, data, removedKitNames, options2.dryRun ?? false);
+  return result;
+}
+
 // src/commands/uninstall/removal-handler.ts
 async function isDirectory2(filePath) {
   try {
-    const stats = await import_fs_extra43.lstat(filePath);
+    const stats = await import_fs_extra44.lstat(filePath);
     return stats.isDirectory();
   } catch {
     logger.debug(`Failed to check if path is directory: ${filePath}`);
@@ -115945,10 +116342,30 @@ async function isDirectory2(filePath) {
   }
 }
 function getUninstallMutatePaths(options2) {
+  const paths = [];
   if (options2.retainedManifestPaths.length > 0) {
-    return ["metadata.json"];
+    paths.push("metadata.json");
   }
-  return [];
+  if (options2.settingsFileExists) {
+    paths.push("settings.json");
+  }
+  if (options2.ckJsonExists) {
+    paths.push(".ck.json");
+  }
+  return paths;
+}
+function logSettingsCleanup(result, dryRun) {
+  if (result.hooksRemoved === 0 && result.mcpServersRemoved === 0)
+    return;
+  const parts = [];
+  if (result.hooksRemoved > 0) {
+    parts.push(`${result.hooksRemoved} hook${result.hooksRemoved === 1 ? "" : "s"}`);
+  }
+  if (result.mcpServersRemoved > 0) {
+    parts.push(`${result.mcpServersRemoved} MCP server${result.mcpServersRemoved === 1 ? "" : "s"}`);
+  }
+  const verb = dryRun ? "Would remove" : "Removed";
+  log.info(`${verb} ${parts.join(" and ")} from settings.json`);
 }
 async function restoreUninstallBackup(backup) {
   const restoreSpinner = createSpinner("Restoring installation from recovery backup...").start();
@@ -115964,15 +116381,15 @@ async function isPathSafeToRemove(filePath, baseDir) {
   try {
     const resolvedPath = resolve56(filePath);
     const resolvedBase = resolve56(baseDir);
-    if (!resolvedPath.startsWith(resolvedBase + sep13) && resolvedPath !== resolvedBase) {
+    if (!resolvedPath.startsWith(resolvedBase + sep14) && resolvedPath !== resolvedBase) {
       logger.debug(`Path outside installation directory: ${filePath}`);
       return false;
     }
-    const stats = await import_fs_extra43.lstat(filePath);
+    const stats = await import_fs_extra44.lstat(filePath);
     if (stats.isSymbolicLink()) {
-      const realPath = await import_fs_extra43.realpath(filePath);
+      const realPath = await import_fs_extra44.realpath(filePath);
       const resolvedReal = resolve56(realPath);
-      if (!resolvedReal.startsWith(resolvedBase + sep13) && resolvedReal !== resolvedBase) {
+      if (!resolvedReal.startsWith(resolvedBase + sep14) && resolvedReal !== resolvedBase) {
         logger.debug(`Symlink points outside installation directory: ${filePath} -> ${realPath}`);
         return false;
       }
@@ -115994,6 +116411,12 @@ async function removeInstallations(installations, options2) {
         const label = options2.kit ? `${installation.type} (${options2.kit} kit)` : installation.type;
         const legacyLabel2 = !installation.hasMetadata ? " [legacy]" : "";
         displayDryRunPreview(analysis, `${label}${legacyLabel2}`);
+        const settingsPreview = await cleanupUninstalledSettings(installation.path, {
+          kit: options2.kit,
+          remainingKits: analysis.remainingKits,
+          dryRun: true
+        });
+        logSettingsCleanup(settingsPreview, true);
         if (analysis.remainingKits.length > 0) {
           log.info(`Remaining kits after uninstall: ${analysis.remainingKits.join(", ")}`);
         }
@@ -116003,7 +116426,9 @@ async function removeInstallations(installations, options2) {
         continue;
       }
       const mutatePaths = getUninstallMutatePaths({
-        retainedManifestPaths: analysis.retainedManifestPaths
+        retainedManifestPaths: analysis.retainedManifestPaths,
+        settingsFileExists: await import_fs_extra44.pathExists(join158(installation.path, "settings.json")),
+        ckJsonExists: await import_fs_extra44.pathExists(join158(installation.path, ".ck.json"))
       });
       let backup = null;
       if (analysis.toDelete.length > 0 || mutatePaths.length > 0) {
@@ -116031,15 +116456,15 @@ async function removeInstallations(installations, options2) {
         let removedCount = 0;
         let cleanedDirs = 0;
         for (const item of analysis.toDelete) {
-          const filePath = join157(installation.path, item.path);
-          if (!await import_fs_extra43.pathExists(filePath))
+          const filePath = join158(installation.path, item.path);
+          if (!await import_fs_extra44.pathExists(filePath))
             continue;
           if (!await isPathSafeToRemove(filePath, installation.path)) {
             logger.debug(`Skipping unsafe path: ${item.path}`);
             continue;
           }
           const isDir2 = await isDirectory2(filePath);
-          await import_fs_extra43.remove(filePath);
+          await import_fs_extra44.remove(filePath);
           removedCount++;
           logger.debug(`Removed ${isDir2 ? "directory" : "file"}: ${item.path}`);
           if (!isDir2) {
@@ -116055,6 +116480,11 @@ async function removeInstallations(installations, options2) {
             throw new Error("Failed to update metadata.json after partial uninstall");
           }
         }
+        const settingsCleanup = await cleanupUninstalledSettings(installation.path, {
+          kit: options2.kit,
+          remainingKits: analysis.remainingKits
+        });
+        logSettingsCleanup(settingsCleanup, false);
         try {
           const remaining = readdirSync13(installation.path);
           if (remaining.length === 0) {
@@ -116453,7 +116883,7 @@ ${import_picocolors40.default.bold(import_picocolors40.default.cyan(result.kitCo
 init_logger();
 import { existsSync as existsSync82 } from "node:fs";
 import { rm as rm19 } from "node:fs/promises";
-import { join as join164 } from "node:path";
+import { join as join165 } from "node:path";
 var import_picocolors41 = __toESM(require_picocolors(), 1);
 
 // src/commands/watch/phases/implementation-runner.ts
@@ -116971,8 +117401,8 @@ function spawnAndCollect3(command, args) {
 }
 
 // src/commands/watch/phases/issue-processor.ts
-import { mkdir as mkdir40, writeFile as writeFile41 } from "node:fs/promises";
-import { join as join160 } from "node:path";
+import { mkdir as mkdir40, writeFile as writeFile42 } from "node:fs/promises";
+import { join as join161 } from "node:path";
 
 // src/commands/watch/phases/approval-detector.ts
 init_logger();
@@ -117350,9 +117780,9 @@ async function checkAwaitingApproval(state, setup, options2, watchLog, projectDi
 
 // src/commands/watch/phases/plan-dir-finder.ts
 import { readdir as readdir46, stat as stat24 } from "node:fs/promises";
-import { join as join159 } from "node:path";
+import { join as join160 } from "node:path";
 async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
-  const plansRoot = join159(cwd2, "plans");
+  const plansRoot = join160(cwd2, "plans");
   try {
     const entries = await readdir46(plansRoot);
     const tenMinAgo = Date.now() - 10 * 60 * 1000;
@@ -117361,14 +117791,14 @@ async function findRecentPlanDir(cwd2, issueNumber, watchLog) {
     for (const entry of entries) {
       if (entry === "watch" || entry === "reports" || entry === "visuals")
         continue;
-      const dirPath = join159(plansRoot, entry);
+      const dirPath = join160(plansRoot, entry);
       const dirStat = await stat24(dirPath);
       if (!dirStat.isDirectory())
         continue;
       if (dirStat.mtimeMs < tenMinAgo)
         continue;
       try {
-        await stat24(join159(dirPath, "plan.md"));
+        await stat24(join160(dirPath, "plan.md"));
       } catch {
         continue;
       }
@@ -117599,14 +118029,14 @@ async function handlePlanGeneration(issue, state, config, setup, options2, watch
     stats.plansCreated++;
     const detectedPlanDir = await findRecentPlanDir(projectDir, issue.number, watchLog);
     if (detectedPlanDir) {
-      state.activeIssues[numStr].planPath = join160(detectedPlanDir, "plan.md");
+      state.activeIssues[numStr].planPath = join161(detectedPlanDir, "plan.md");
       watchLog.info(`Plan directory detected: ${detectedPlanDir}`);
     } else {
       try {
-        const planDir = join160(projectDir, "plans", "watch");
+        const planDir = join161(projectDir, "plans", "watch");
         await mkdir40(planDir, { recursive: true });
-        const planFilePath = join160(planDir, `issue-${issue.number}-plan.md`);
-        await writeFile41(planFilePath, planResult.planText, "utf-8");
+        const planFilePath = join161(planDir, `issue-${issue.number}-plan.md`);
+        await writeFile42(planFilePath, planResult.planText, "utf-8");
         state.activeIssues[numStr].planPath = planFilePath;
         watchLog.info(`Plan saved (fallback) to ${planFilePath}`);
       } catch (err) {
@@ -117751,7 +118181,7 @@ init_ck_config_manager();
 init_file_io();
 init_logger();
 import { existsSync as existsSync78 } from "node:fs";
-import { mkdir as mkdir41, readFile as readFile70 } from "node:fs/promises";
+import { mkdir as mkdir41, readFile as readFile71 } from "node:fs/promises";
 import { dirname as dirname54 } from "node:path";
 var PROCESSED_ISSUES_CAP = 500;
 async function readCkJson(projectDir) {
@@ -117759,7 +118189,7 @@ async function readCkJson(projectDir) {
   try {
     if (!existsSync78(configPath))
       return {};
-    const content = await readFile70(configPath, "utf-8");
+    const content = await readFile71(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     logger.warning(`Failed to parse .ck.json: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -117912,18 +118342,18 @@ init_logger();
 import { spawnSync as spawnSync7 } from "node:child_process";
 import { existsSync as existsSync79 } from "node:fs";
 import { readdir as readdir47, stat as stat25 } from "node:fs/promises";
-import { join as join161 } from "node:path";
+import { join as join162 } from "node:path";
 async function scanForRepos(parentDir) {
   const repos = [];
   const entries = await readdir47(parentDir);
   for (const entry of entries) {
     if (entry.startsWith("."))
       continue;
-    const fullPath = join161(parentDir, entry);
+    const fullPath = join162(parentDir, entry);
     const entryStat = await stat25(fullPath);
     if (!entryStat.isDirectory())
       continue;
-    const gitDir = join161(fullPath, ".git");
+    const gitDir = join162(fullPath, ".git");
     if (!existsSync79(gitDir))
       continue;
     const result = spawnSync7("gh", ["repo", "view", "--json", "owner,name"], {
@@ -117950,7 +118380,7 @@ init_logger();
 import { spawnSync as spawnSync8 } from "node:child_process";
 import { existsSync as existsSync80 } from "node:fs";
 import { homedir as homedir53 } from "node:os";
-import { join as join162 } from "node:path";
+import { join as join163 } from "node:path";
 async function validateSetup(cwd2) {
   const workDir = cwd2 ?? process.cwd();
   const ghVersion = spawnSync8("gh", ["--version"], { encoding: "utf-8", timeout: 1e4 });
@@ -117981,7 +118411,7 @@ Run this command from a directory with a GitHub remote.`);
   } catch {
     throw new Error(`Failed to parse repository info: ${ghRepo.stdout}`);
   }
-  const skillsPath = join162(homedir53(), ".claude", "skills");
+  const skillsPath = join163(homedir53(), ".claude", "skills");
   const skillsAvailable = existsSync80(skillsPath);
   if (!skillsAvailable) {
     logger.warning(`ClaudeKit Engineer skills not found at ${skillsPath}`);
@@ -118000,7 +118430,7 @@ init_path_resolver();
 import { createWriteStream as createWriteStream3, statSync as statSync14 } from "node:fs";
 import { existsSync as existsSync81 } from "node:fs";
 import { mkdir as mkdir42, rename as rename15 } from "node:fs/promises";
-import { join as join163 } from "node:path";
+import { join as join164 } from "node:path";
 
 class WatchLogger {
   logStream = null;
@@ -118008,7 +118438,7 @@ class WatchLogger {
   logPath = null;
   maxBytes;
   constructor(logDir, maxBytes = 0) {
-    this.logDir = logDir ?? join163(PathResolver.getClaudeKitDir(), "logs");
+    this.logDir = logDir ?? join164(PathResolver.getClaudeKitDir(), "logs");
     this.maxBytes = maxBytes;
   }
   async init() {
@@ -118017,7 +118447,7 @@ class WatchLogger {
         await mkdir42(this.logDir, { recursive: true });
       }
       const dateStr = formatDate(new Date);
-      this.logPath = join163(this.logDir, `watch-${dateStr}.log`);
+      this.logPath = join164(this.logDir, `watch-${dateStr}.log`);
       this.logStream = createWriteStream3(this.logPath, { flags: "a", mode: 384 });
     } catch (error) {
       logger.warning(`Cannot create watch log file: ${error instanceof Error ? error.message : "Unknown"}`);
@@ -118199,7 +118629,7 @@ async function watchCommand(options2) {
 }
 async function discoverRepos(options2, watchLog) {
   const cwd2 = process.cwd();
-  const isGitRepo = existsSync82(join164(cwd2, ".git"));
+  const isGitRepo = existsSync82(join165(cwd2, ".git"));
   if (options2.force) {
     await forceRemoveLock(watchLog);
   }
@@ -118456,8 +118886,8 @@ function registerCommands(cli) {
 // src/cli/version-display.ts
 init_package();
 init_config_version_checker();
-import { existsSync as existsSync94, readFileSync as readFileSync25 } from "node:fs";
-import { join as join176 } from "node:path";
+import { existsSync as existsSync94, readFileSync as readFileSync26 } from "node:fs";
+import { join as join177 } from "node:path";
 
 // src/domains/versioning/version-checker.ts
 init_version_utils();
@@ -118471,15 +118901,15 @@ init_types3();
 init_logger();
 init_path_resolver();
 import { existsSync as existsSync93 } from "node:fs";
-import { mkdir as mkdir43, readFile as readFile72, writeFile as writeFile44 } from "node:fs/promises";
-import { join as join175 } from "node:path";
+import { mkdir as mkdir43, readFile as readFile73, writeFile as writeFile45 } from "node:fs/promises";
+import { join as join176 } from "node:path";
 
 class VersionCacheManager {
   static CACHE_FILENAME = "version-check.json";
   static CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
   static getCacheFile() {
     const cacheDir = PathResolver.getCacheDir(false);
-    return join175(cacheDir, VersionCacheManager.CACHE_FILENAME);
+    return join176(cacheDir, VersionCacheManager.CACHE_FILENAME);
   }
   static async load() {
     const cacheFile = VersionCacheManager.getCacheFile();
@@ -118488,7 +118918,7 @@ class VersionCacheManager {
         logger.debug("Version check cache not found");
         return null;
       }
-      const content = await readFile72(cacheFile, "utf-8");
+      const content = await readFile73(cacheFile, "utf-8");
       const cache5 = JSON.parse(content);
       if (!cache5.lastCheck || !cache5.currentVersion || !cache5.latestVersion) {
         logger.debug("Invalid cache structure, ignoring");
@@ -118508,7 +118938,7 @@ class VersionCacheManager {
       if (!existsSync93(cacheDir)) {
         await mkdir43(cacheDir, { recursive: true, mode: 448 });
       }
-      await writeFile44(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
+      await writeFile45(cacheFile, JSON.stringify(cache5, null, 2), "utf-8");
       logger.debug(`Version check cache saved to ${cacheFile}`);
     } catch (error) {
       logger.debug(`Failed to save version check cache: ${error}`);
@@ -118790,13 +119220,13 @@ async function displayVersion() {
   let localInstalledKits = [];
   let globalInstalledKits = [];
   const globalKitDir = PathResolver.getGlobalKitDir();
-  const globalMetadataPath = join176(globalKitDir, "metadata.json");
+  const globalMetadataPath = join177(globalKitDir, "metadata.json");
   const prefix = PathResolver.getPathPrefix(false);
-  const localMetadataPath = prefix ? join176(process.cwd(), prefix, "metadata.json") : join176(process.cwd(), "metadata.json");
+  const localMetadataPath = prefix ? join177(process.cwd(), prefix, "metadata.json") : join177(process.cwd(), "metadata.json");
   const isLocalSameAsGlobal = localMetadataPath === globalMetadataPath;
   if (!isLocalSameAsGlobal && existsSync94(localMetadataPath)) {
     try {
-      const rawMetadata = JSON.parse(readFileSync25(localMetadataPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync26(localMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {
@@ -118810,7 +119240,7 @@ async function displayVersion() {
   }
   if (existsSync94(globalMetadataPath)) {
     try {
-      const rawMetadata = JSON.parse(readFileSync25(globalMetadataPath, "utf-8"));
+      const rawMetadata = JSON.parse(readFileSync26(globalMetadataPath, "utf-8"));
       const metadata = MetadataSchema.parse(rawMetadata);
       const kitsDisplay = formatInstalledKits(metadata);
       if (kitsDisplay) {
@@ -119180,7 +119610,7 @@ var output2 = new OutputManager2;
 
 // src/shared/temp-cleanup.ts
 init_logger();
-var import_fs_extra44 = __toESM(require_lib(), 1);
+var import_fs_extra45 = __toESM(require_lib(), 1);
 import { rmSync as rmSync9 } from "node:fs";
 var tempDirs2 = new Set;
 async function cleanup() {
@@ -119189,7 +119619,7 @@ async function cleanup() {
   logger.debug(`Cleaning up ${tempDirs2.size} temporary director(ies)...`);
   for (const dir of tempDirs2) {
     try {
-      await import_fs_extra44.remove(dir);
+      await import_fs_extra45.remove(dir);
       logger.debug(`Cleaned up temp directory: ${dir}`);
     } catch (error) {
       logger.debug(`Failed to clean temp directory ${dir}: ${error}`);