thanh-kit 2.5.9 → 2.5.11

package/dist/index.js

@@ -175,9 +175,11 @@ function isAkProject(dir = process.cwd()) {
   const akConfig = join(dir, ".ak", "state.json");
   const claudeDir = join(dir, ".claude");
   const geminiDir = join(dir, ".gemini");
+  const codexDir = join(dir, ".codex");
+  const agentsDir = join(dir, ".agents");
   const opencodeDir = join(dir, ".opencode");
   const agentDir = join(dir, ".agent");
-  return existsSync(akConfig) || existsSync(claudeDir) || existsSync(geminiDir) || existsSync(opencodeDir) || existsSync(agentDir);
+  return existsSync(akConfig) || existsSync(claudeDir) || existsSync(geminiDir) || existsSync(codexDir) || existsSync(agentsDir) || existsSync(opencodeDir) || existsSync(agentDir);
 }
 function getTargetDir(projectDir, target = "claude") {
   const folder = TARGETS[target] || TARGETS.claude;
@@ -245,6 +247,8 @@ var init_paths = __esm({
     TARGETS = {
       claude: ".claude",
       gemini: ".gemini",
+      codex: ".agents",
+      // Codex uses .agents for skills, .codex for config
       discord: ".discord",
       opencode: ".opencode",
       generic: ".agent"
@@ -582,7 +586,7 @@ var init_claude_adapter = __esm({
 
 // src/targets/gemini-adapter.ts
 import fs3 from "fs-extra";
-import { join as join4, dirname as dirname3 } from "path";
+import { join as join4 } from "path";
 function parseFrontmatter(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match) {
@@ -590,9 +594,6 @@ function parseFrontmatter(content) {
   }
   return { frontmatter: match[1], body: match[2] };
 }
-function escapeTomlString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\t/g, "\\t");
-}
 function convertAgentToGemini(mdContent) {
   const { frontmatter, body } = parseFrontmatter(mdContent);
   if (!frontmatter) return mdContent;
@@ -614,20 +615,6 @@ ${converted.trim()}
 ---
 ${body}`;
 }
-function convertCommandToToml(mdContent) {
-  const { frontmatter, body } = parseFrontmatter(mdContent);
-  const descMatch = frontmatter.match(/description:\s*(.+)/);
-  const description = descMatch ? descMatch[1].trim() : "";
-  const prompt = body.trim().replace(/\$ARGUMENTS/g, "{{args}}");
-  const lines = [];
-  if (description) {
-    lines.push(`description = "${escapeTomlString(description)}"`);
-  }
-  lines.push(`prompt = '''
-${prompt}
-'''`);
-  return lines.join("\n");
-}
 var MODEL_MAP, GeminiAdapter;
 var init_gemini_adapter = __esm({
   "src/targets/gemini-adapter.ts"() {
@@ -648,7 +635,8 @@ var init_gemini_adapter = __esm({
         features: {
           agents: true,
           skills: true,
-          commands: true,
+          commands: false,
+          // Gemini uses skills, not commands
           workflows: false,
           router: false,
           hooks: false,
@@ -740,88 +728,210 @@ var init_gemini_adapter = __esm({
         }
         return { copied, skipped, errors };
       }
-      async copyCommands(items, sourceDir, targetDir, mergeMode) {
-        const typeDir = join4(sourceDir, "commands");
-        const destTypeDir = join4(targetDir, "commands");
-        if (!fs3.existsSync(typeDir)) {
+      // Commands not supported - Gemini uses skills instead
+      async copyCommands(_items, _sourceDir, _targetDir, _mergeMode) {
+        return { copied: [], skipped: [], errors: [] };
+      }
+      async copyBaseFiles(targetDir, mergeMode) {
+        const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+        const geminiTemplates = join4(CLI_ROOT2, "templates", "gemini");
+        const copied = [];
+        const projectRoot = join4(targetDir, "..");
+        const settingsFiles = ["settings.json", "settings.local.json"];
+        for (const file of settingsFiles) {
+          const srcPath = join4(geminiTemplates, file);
+          const destPath = join4(targetDir, file);
+          if (fs3.existsSync(srcPath)) {
+            if (!(mergeMode && fs3.existsSync(destPath))) {
+              await fs3.copy(srcPath, destPath, { overwrite: !mergeMode });
+              copied.push(file);
+            }
+          }
+        }
+        const geminiMdSrc = join4(geminiTemplates, "GEMINI.md");
+        const geminiMdDest = join4(projectRoot, "GEMINI.md");
+        if (fs3.existsSync(geminiMdSrc)) {
+          if (!(mergeMode && fs3.existsSync(geminiMdDest))) {
+            await fs3.copy(geminiMdSrc, geminiMdDest, { overwrite: !mergeMode });
+            copied.push("GEMINI.md (project root)");
+          }
+        }
+        return copied;
+      }
+    };
+  }
+});
+
+// src/targets/codex-adapter.ts
+import fs4 from "fs-extra";
+import { join as join5 } from "path";
+function parseFrontmatter2(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontmatter: "", body: content };
+  }
+  return { frontmatter: match[1], body: match[2] };
+}
+function convertAgentToCodex(mdContent) {
+  const { frontmatter, body } = parseFrontmatter2(mdContent);
+  if (!frontmatter) return mdContent;
+  let converted = frontmatter;
+  for (const [claudeModel, codexModel] of Object.entries(MODEL_MAP2)) {
+    const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
+    if (codexModel) {
+      converted = converted.replace(regex, `model: ${codexModel}`);
+    } else {
+      converted = converted.replace(regex, "");
+    }
+  }
+  converted = converted.replace(/^tools:\s*.+$/m, "");
+  return `---
+${converted.trim()}
+---
+${body}`;
+}
+var MODEL_MAP2, CodexAdapter;
+var init_codex_adapter = __esm({
+  "src/targets/codex-adapter.ts"() {
+    "use strict";
+    init_base_adapter();
+    MODEL_MAP2 = {
+      "opus": "o3",
+      "sonnet": "o4-mini",
+      "haiku": "gpt-4.1-mini",
+      "inherit": ""
+      // Remove inherit, let Codex use default
+    };
+    CodexAdapter = class extends BaseTargetAdapter {
+      config = {
+        name: "codex",
+        displayName: "Codex CLI",
+        directory: ".agents",
+        // Main directory for skills/agents
+        features: {
+          agents: true,
+          skills: true,
+          commands: false,
+          // Codex uses skills, not commands
+          workflows: false,
+          router: false,
+          hooks: false,
+          memory: false,
+          scripts: false,
+          "output-styles": false
+        }
+      };
+      async copyAgents(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "agents");
+        const destTypeDir = join5(targetDir, "agents");
+        if (!fs4.existsSync(typeDir)) {
           return { copied: [], skipped: [], errors: [] };
         }
-        await fs3.ensureDir(destTypeDir);
-        let itemList;
+        await fs4.ensureDir(destTypeDir);
+        let agentList;
         if (items === "all") {
-          const entries = fs3.readdirSync(typeDir);
-          itemList = [...new Set(entries.map((e) => e.replace(".md", "")))];
+          const entries = fs4.readdirSync(typeDir);
+          agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
         } else {
-          itemList = items;
+          agentList = items;
         }
         const copied = [];
         const skipped = [];
         const errors = [];
-        for (const item of itemList) {
+        for (const agent of agentList) {
           try {
-            const srcPathMd = join4(typeDir, item + ".md");
-            const srcPathDir = join4(typeDir, item);
-            let copiedSomething = false;
-            if (fs3.existsSync(srcPathMd) && fs3.statSync(srcPathMd).isFile()) {
-              const destPath = join4(destTypeDir, item + ".toml");
-              if (!(mergeMode && fs3.existsSync(destPath))) {
-                await fs3.ensureDir(dirname3(destPath));
-                const mdContent = fs3.readFileSync(srcPathMd, "utf-8");
-                const tomlContent = convertCommandToToml(mdContent);
-                await fs3.writeFile(destPath, tomlContent, "utf-8");
-                copiedSomething = true;
-              }
-            }
-            if (fs3.existsSync(srcPathDir) && fs3.statSync(srcPathDir).isDirectory()) {
-              await this.convertDirectoryToToml(srcPathDir, join4(destTypeDir, item), mergeMode);
-              copiedSomething = true;
+            const srcPath = join5(typeDir, agent + ".md");
+            if (!fs4.existsSync(srcPath)) {
+              skipped.push(agent);
+              continue;
             }
-            if (copiedSomething) {
-              copied.push(item);
-            } else {
-              skipped.push(item);
+            const destPath = join5(destTypeDir, agent + ".md");
+            if (mergeMode && fs4.existsSync(destPath)) {
+              skipped.push(agent);
+              continue;
             }
+            const mdContent = fs4.readFileSync(srcPath, "utf-8");
+            const convertedContent = convertAgentToCodex(mdContent);
+            await fs4.writeFile(destPath, convertedContent, "utf-8");
+            copied.push(agent);
           } catch (err) {
-            errors.push({ item, error: err.message });
+            errors.push({ item: agent, error: err.message });
           }
         }
         return { copied, skipped, errors };
       }
-      async convertDirectoryToToml(srcDir, destDir, mergeMode) {
-        await fs3.ensureDir(destDir);
-        const entries = fs3.readdirSync(srcDir);
-        for (const entry of entries) {
-          const srcPath = join4(srcDir, entry);
-          const stat = fs3.statSync(srcPath);
-          if (stat.isDirectory()) {
-            await this.convertDirectoryToToml(srcPath, join4(destDir, entry), mergeMode);
-          } else if (entry.endsWith(".md")) {
-            const destPath = join4(destDir, entry.replace(".md", ".toml"));
-            if (mergeMode && fs3.existsSync(destPath)) {
+      async copySkills(items, sourceDir, targetDir, mergeMode) {
+        const typeDir = join5(sourceDir, "skills");
+        const destTypeDir = join5(targetDir, "skills");
+        if (!fs4.existsSync(typeDir)) {
+          return { copied: [], skipped: [], errors: [] };
+        }
+        await fs4.ensureDir(destTypeDir);
+        let skillList;
+        if (items === "all") {
+          const entries = fs4.readdirSync(typeDir);
+          skillList = entries.filter((e) => {
+            const fullPath = join5(typeDir, e);
+            return fs4.statSync(fullPath).isDirectory() && fs4.existsSync(join5(fullPath, "SKILL.md"));
+          });
+        } else {
+          skillList = items;
+        }
+        const copied = [];
+        const skipped = [];
+        const errors = [];
+        for (const skill of skillList) {
+          try {
+            const srcPath = join5(typeDir, skill);
+            if (!fs4.existsSync(srcPath) || !fs4.statSync(srcPath).isDirectory()) {
+              skipped.push(skill);
               continue;
             }
-            const mdContent = fs3.readFileSync(srcPath, "utf-8");
-            const tomlContent = convertCommandToToml(mdContent);
-            await fs3.writeFile(destPath, tomlContent, "utf-8");
-          } else {
-            const destPath = join4(destDir, entry);
-            if (mergeMode && fs3.existsSync(destPath)) {
+            if (!fs4.existsSync(join5(srcPath, "SKILL.md"))) {
+              skipped.push(skill);
               continue;
             }
-            await fs3.copy(srcPath, destPath, { overwrite: !mergeMode });
+            const destPath = join5(destTypeDir, skill);
+            if (mergeMode && fs4.existsSync(destPath)) {
+              skipped.push(skill);
+              continue;
+            }
+            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            copied.push(skill);
+          } catch (err) {
+            errors.push({ item: skill, error: err.message });
           }
         }
+        return { copied, skipped, errors };
+      }
+      // Commands not supported - Codex uses skills instead
+      async copyCommands(_items, _sourceDir, _targetDir, _mergeMode) {
+        return { copied: [], skipped: [], errors: [] };
       }
       async copyBaseFiles(targetDir, mergeMode) {
         const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const geminiTemplates = join4(CLI_ROOT2, "templates", "gemini");
+        const codexTemplates = join5(CLI_ROOT2, "templates", "codex");
         const copied = [];
-        const settingsPath = join4(geminiTemplates, "settings.json");
-        const destSettingsPath = join4(targetDir, "settings.json");
-        if (fs3.existsSync(settingsPath)) {
-          if (!(mergeMode && fs3.existsSync(destSettingsPath))) {
-            await fs3.copy(settingsPath, destSettingsPath, { overwrite: !mergeMode });
-            copied.push("settings.json");
+        const projectRoot = join5(targetDir, "..");
+        const codexConfigDir = join5(projectRoot, ".codex");
+        await fs4.ensureDir(codexConfigDir);
+        const configFiles = ["config.toml", "config.local.toml"];
+        for (const file of configFiles) {
+          const srcPath = join5(codexTemplates, file);
+          const destPath = join5(codexConfigDir, file);
+          if (fs4.existsSync(srcPath)) {
+            if (!(mergeMode && fs4.existsSync(destPath))) {
+              await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+              copied.push(`.codex/${file}`);
+            }
+          }
+        }
+        const agentsMdSrc = join5(codexTemplates, "AGENTS.md");
+        const agentsMdDest = join5(projectRoot, "AGENTS.md");
+        if (fs4.existsSync(agentsMdSrc)) {
+          if (!(mergeMode && fs4.existsSync(agentsMdDest))) {
+            await fs4.copy(agentsMdSrc, agentsMdDest, { overwrite: !mergeMode });
+            copied.push("AGENTS.md");
           }
         }
         return copied;
@@ -831,9 +941,9 @@ var init_gemini_adapter = __esm({
 });
 
 // src/targets/discord-adapter.ts
-import fs4 from "fs-extra";
-import { join as join5, dirname as dirname4 } from "path";
-function parseFrontmatter2(content) {
+import fs5 from "fs-extra";
+import { join as join6, dirname as dirname3 } from "path";
+function parseFrontmatter3(content) {
   const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
   if (!match) {
     return { frontmatter: "", body: content, description: "", argumentHint: "" };
@@ -850,10 +960,10 @@ function parseFrontmatter2(content) {
   };
 }
 function convertAgentToDiscord(mdContent) {
-  const { frontmatter, body } = parseFrontmatter2(mdContent);
+  const { frontmatter, body } = parseFrontmatter3(mdContent);
   if (!frontmatter) return mdContent;
   let converted = frontmatter;
-  for (const [claudeModel, discordModel] of Object.entries(MODEL_MAP2)) {
+  for (const [claudeModel, discordModel] of Object.entries(MODEL_MAP3)) {
     const regex = new RegExp(`^model:\\s*${claudeModel}\\s*$`, "m");
     if (discordModel) {
       converted = converted.replace(regex, `model: ${discordModel}`);
@@ -891,7 +1001,7 @@ function extractKeywords(content, commandName) {
   return Array.from(keywords).slice(0, 10);
 }
 function convertCommandToSkill(mdContent, commandName) {
-  const { description, argumentHint, body } = parseFrontmatter2(mdContent);
+  const { description, argumentHint, body } = parseFrontmatter3(mdContent);
   const prompt = body.replace(/\$ARGUMENTS/g, "{{args}}");
   const keywords = extractKeywords(body, commandName);
   return `---
@@ -921,12 +1031,12 @@ ${prompt}
 Provide clear, actionable response based on the workflow above.
 `;
 }
-var MODEL_MAP2, DiscordAdapter;
+var MODEL_MAP3, DiscordAdapter;
 var init_discord_adapter = __esm({
   "src/targets/discord-adapter.ts"() {
     "use strict";
     init_base_adapter();
-    MODEL_MAP2 = {
+    MODEL_MAP3 = {
       "opus": "claude-3-opus",
       "sonnet": "claude-3-sonnet",
       "haiku": "claude-3-haiku",
@@ -950,15 +1060,15 @@ var init_discord_adapter = __esm({
         }
       };
       async copyAgents(items, sourceDir, targetDir, mergeMode) {
-        const typeDir = join5(sourceDir, "agents");
-        const destTypeDir = join5(targetDir, "agents");
-        if (!fs4.existsSync(typeDir)) {
+        const typeDir = join6(sourceDir, "agents");
+        const destTypeDir = join6(targetDir, "agents");
+        if (!fs5.existsSync(typeDir)) {
           return { copied: [], skipped: [], errors: [] };
         }
-        await fs4.ensureDir(destTypeDir);
+        await fs5.ensureDir(destTypeDir);
         let agentList;
         if (items === "all") {
-          const entries = fs4.readdirSync(typeDir);
+          const entries = fs5.readdirSync(typeDir);
           agentList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
         } else {
           agentList = items;
@@ -968,19 +1078,19 @@ var init_discord_adapter = __esm({
         const errors = [];
         for (const agent of agentList) {
           try {
-            const srcPath = join5(typeDir, agent + ".md");
-            if (!fs4.existsSync(srcPath)) {
+            const srcPath = join6(typeDir, agent + ".md");
+            if (!fs5.existsSync(srcPath)) {
               skipped.push(agent);
               continue;
             }
-            const destPath = join5(destTypeDir, agent + ".md");
-            if (mergeMode && fs4.existsSync(destPath)) {
+            const destPath = join6(destTypeDir, agent + ".md");
+            if (mergeMode && fs5.existsSync(destPath)) {
               skipped.push(agent);
               continue;
             }
-            const mdContent = fs4.readFileSync(srcPath, "utf-8");
+            const mdContent = fs5.readFileSync(srcPath, "utf-8");
             const convertedContent = convertAgentToDiscord(mdContent);
-            await fs4.writeFile(destPath, convertedContent, "utf-8");
+            await fs5.writeFile(destPath, convertedContent, "utf-8");
             copied.push(agent);
           } catch (err) {
             errors.push({ item: agent, error: err.message });
@@ -989,18 +1099,18 @@ var init_discord_adapter = __esm({
         return { copied, skipped, errors };
       }
       async copySkills(items, sourceDir, targetDir, mergeMode) {
-        const typeDir = join5(sourceDir, "skills");
-        const destTypeDir = join5(targetDir, "skills");
-        if (!fs4.existsSync(typeDir)) {
+        const typeDir = join6(sourceDir, "skills");
+        const destTypeDir = join6(targetDir, "skills");
+        if (!fs5.existsSync(typeDir)) {
           return { copied: [], skipped: [], errors: [] };
         }
-        await fs4.ensureDir(destTypeDir);
+        await fs5.ensureDir(destTypeDir);
         let skillList;
         if (items === "all") {
-          const entries = fs4.readdirSync(typeDir);
+          const entries = fs5.readdirSync(typeDir);
           skillList = entries.filter((e) => {
-            const fullPath = join5(typeDir, e);
-            return fs4.statSync(fullPath).isDirectory() && fs4.existsSync(join5(fullPath, "SKILL.md"));
+            const fullPath = join6(typeDir, e);
+            return fs5.statSync(fullPath).isDirectory() && fs5.existsSync(join6(fullPath, "SKILL.md"));
           });
         } else {
           skillList = items;
@@ -1010,21 +1120,21 @@ var init_discord_adapter = __esm({
         const errors = [];
         for (const skill of skillList) {
           try {
-            const srcPath = join5(typeDir, skill);
-            if (!fs4.existsSync(srcPath) || !fs4.statSync(srcPath).isDirectory()) {
+            const srcPath = join6(typeDir, skill);
+            if (!fs5.existsSync(srcPath) || !fs5.statSync(srcPath).isDirectory()) {
               skipped.push(skill);
               continue;
             }
-            if (!fs4.existsSync(join5(srcPath, "SKILL.md"))) {
+            if (!fs5.existsSync(join6(srcPath, "SKILL.md"))) {
               skipped.push(skill);
               continue;
             }
-            const destPath = join5(destTypeDir, skill);
-            if (mergeMode && fs4.existsSync(destPath)) {
+            const destPath = join6(destTypeDir, skill);
+            if (mergeMode && fs5.existsSync(destPath)) {
               skipped.push(skill);
               continue;
             }
-            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            await fs5.copy(srcPath, destPath, { overwrite: !mergeMode });
             copied.push(skill);
           } catch (err) {
             errors.push({ item: skill, error: err.message });
@@ -1035,21 +1145,21 @@ var init_discord_adapter = __esm({
         return { copied, skipped, errors };
       }
       async copyCommands(items, sourceDir, targetDir, mergeMode) {
-        const typeDir = join5(sourceDir, "commands");
-        const destTypeDir = join5(targetDir, "commands");
-        const destSkillsDir = join5(targetDir, "skills");
-        if (!fs4.existsSync(typeDir)) {
+        const typeDir = join6(sourceDir, "commands");
+        const destTypeDir = join6(targetDir, "commands");
+        const destSkillsDir = join6(targetDir, "skills");
+        if (!fs5.existsSync(typeDir)) {
           return { copied: [], skipped: [], errors: [] };
         }
-        await fs4.ensureDir(destTypeDir);
-        await fs4.ensureDir(destSkillsDir);
+        await fs5.ensureDir(destTypeDir);
+        await fs5.ensureDir(destSkillsDir);
         let itemList;
         if (items === "all") {
-          const entries = fs4.readdirSync(typeDir);
+          const entries = fs5.readdirSync(typeDir);
           itemList = entries.filter((e) => e.endsWith(".md") && e !== "README.md").map((e) => e.replace(".md", ""));
           const dirs = entries.filter((e) => {
-            const fullPath = join5(typeDir, e);
-            return fs4.statSync(fullPath).isDirectory();
+            const fullPath = join6(typeDir, e);
+            return fs5.statSync(fullPath).isDirectory();
           });
           itemList = [.../* @__PURE__ */ new Set([...itemList, ...dirs])];
         } else {
@@ -1061,22 +1171,22 @@ var init_discord_adapter = __esm({
         const commandsConfig = {};
         for (const item of itemList) {
           try {
-            const srcPathMd = join5(typeDir, item + ".md");
-            const srcPathDir = join5(typeDir, item);
-            if (fs4.existsSync(srcPathMd) && fs4.statSync(srcPathMd).isFile()) {
-              const destPath = join5(destTypeDir, item + ".md");
-              const skillDir = join5(destSkillsDir, item.replace(/\//g, "-"));
-              const skillPath = join5(skillDir, "SKILL.md");
-              if (!(mergeMode && fs4.existsSync(destPath))) {
-                await fs4.ensureDir(dirname4(destPath));
-                const mdContent = fs4.readFileSync(srcPathMd, "utf-8");
-                await fs4.copy(srcPathMd, destPath, { overwrite: !mergeMode });
-                if (!(mergeMode && fs4.existsSync(skillPath))) {
-                  await fs4.ensureDir(skillDir);
+            const srcPathMd = join6(typeDir, item + ".md");
+            const srcPathDir = join6(typeDir, item);
+            if (fs5.existsSync(srcPathMd) && fs5.statSync(srcPathMd).isFile()) {
+              const destPath = join6(destTypeDir, item + ".md");
+              const skillDir = join6(destSkillsDir, item.replace(/\//g, "-"));
+              const skillPath = join6(skillDir, "SKILL.md");
+              if (!(mergeMode && fs5.existsSync(destPath))) {
+                await fs5.ensureDir(dirname3(destPath));
+                const mdContent = fs5.readFileSync(srcPathMd, "utf-8");
+                await fs5.copy(srcPathMd, destPath, { overwrite: !mergeMode });
+                if (!(mergeMode && fs5.existsSync(skillPath))) {
+                  await fs5.ensureDir(skillDir);
                   const skillContent = convertCommandToSkill(mdContent, item);
-                  await fs4.writeFile(skillPath, skillContent, "utf-8");
+                  await fs5.writeFile(skillPath, skillContent, "utf-8");
                 }
-                const { description, body } = parseFrontmatter2(mdContent);
+                const { description, body } = parseFrontmatter3(mdContent);
                 commandsConfig[item] = {
                   description: description || `Execute ${item} command`,
                   prompt: body.replace(/\$ARGUMENTS/g, "{{args}}")
@@ -1086,7 +1196,7 @@ var init_discord_adapter = __esm({
                 skipped.push(item);
               }
             }
-            if (fs4.existsSync(srcPathDir) && fs4.statSync(srcPathDir).isDirectory()) {
+            if (fs5.existsSync(srcPathDir) && fs5.statSync(srcPathDir).isDirectory()) {
               await this.copyNestedCommands(srcPathDir, destTypeDir, destSkillsDir, item, mergeMode, commandsConfig);
               copied.push(item + "/*");
             }
@@ -1094,20 +1204,20 @@ var init_discord_adapter = __esm({
             errors.push({ item, error: err.message });
           }
         }
-        const configPath = join5(targetDir, "commands.json5");
-        if (Object.keys(commandsConfig).length > 0 && !(mergeMode && fs4.existsSync(configPath))) {
+        const configPath = join6(targetDir, "commands.json5");
+        if (Object.keys(commandsConfig).length > 0 && !(mergeMode && fs5.existsSync(configPath))) {
           const json5Content = this.generateCommandsJson5(commandsConfig);
-          await fs4.writeFile(configPath, json5Content, "utf-8");
+          await fs5.writeFile(configPath, json5Content, "utf-8");
         }
         return { copied, skipped, errors };
       }
       async copyNestedCommands(srcDir, destDir, destSkillsDir, parentName, mergeMode, commandsConfig) {
-        const destTypeDir = join5(destDir, parentName);
-        await fs4.ensureDir(destTypeDir);
-        const entries = fs4.readdirSync(srcDir);
+        const destTypeDir = join6(destDir, parentName);
+        await fs5.ensureDir(destTypeDir);
+        const entries = fs5.readdirSync(srcDir);
         for (const entry of entries) {
-          const srcPath = join5(srcDir, entry);
-          const stat = fs4.statSync(srcPath);
+          const srcPath = join6(srcDir, entry);
+          const stat = fs5.statSync(srcPath);
           if (stat.isDirectory()) {
             await this.copyNestedCommands(
               srcPath,
@@ -1118,22 +1228,22 @@ var init_discord_adapter = __esm({
               commandsConfig
             );
           } else if (entry.endsWith(".md") && entry !== "README.md") {
-            const destPath = join5(destTypeDir, entry);
+            const destPath = join6(destTypeDir, entry);
             const cmdName = `${parentName}/${entry.replace(".md", "")}`;
             const skillName = cmdName.replace(/\//g, "-");
-            const skillDir = join5(destSkillsDir, skillName);
-            const skillPath = join5(skillDir, "SKILL.md");
-            if (mergeMode && fs4.existsSync(destPath)) {
+            const skillDir = join6(destSkillsDir, skillName);
+            const skillPath = join6(skillDir, "SKILL.md");
+            if (mergeMode && fs5.existsSync(destPath)) {
               continue;
             }
-            const mdContent = fs4.readFileSync(srcPath, "utf-8");
-            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
-            if (!(mergeMode && fs4.existsSync(skillPath))) {
-              await fs4.ensureDir(skillDir);
+            const mdContent = fs5.readFileSync(srcPath, "utf-8");
+            await fs5.copy(srcPath, destPath, { overwrite: !mergeMode });
+            if (!(mergeMode && fs5.existsSync(skillPath))) {
+              await fs5.ensureDir(skillDir);
               const skillContent = convertCommandToSkill(mdContent, skillName);
-              await fs4.writeFile(skillPath, skillContent, "utf-8");
+              await fs5.writeFile(skillPath, skillContent, "utf-8");
             }
-            const { description, body } = parseFrontmatter2(mdContent);
+            const { description, body } = parseFrontmatter3(mdContent);
             commandsConfig[cmdName] = {
               description: description || `Execute ${cmdName} command`,
               prompt: body.replace(/\$ARGUMENTS/g, "{{args}}")
@@ -1163,22 +1273,22 @@ var init_discord_adapter = __esm({
       }
       async copyBundledSkills(targetDir, mergeMode) {
         const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const bundledSkillsDir = join5(CLI_ROOT2, "templates", "discord", "skills");
-        const destSkillsDir = join5(targetDir, "skills");
+        const bundledSkillsDir = join6(CLI_ROOT2, "templates", "discord", "skills");
+        const destSkillsDir = join6(targetDir, "skills");
         const copied = [];
-        if (!fs4.existsSync(bundledSkillsDir)) {
+        if (!fs5.existsSync(bundledSkillsDir)) {
           return copied;
         }
-        await fs4.ensureDir(destSkillsDir);
-        const skills = fs4.readdirSync(bundledSkillsDir);
+        await fs5.ensureDir(destSkillsDir);
+        const skills = fs5.readdirSync(bundledSkillsDir);
         for (const skill of skills) {
-          const srcPath = join5(bundledSkillsDir, skill);
-          const destPath = join5(destSkillsDir, skill);
-          if (fs4.statSync(srcPath).isDirectory()) {
-            if (mergeMode && fs4.existsSync(destPath)) {
+          const srcPath = join6(bundledSkillsDir, skill);
+          const destPath = join6(destSkillsDir, skill);
+          if (fs5.statSync(srcPath).isDirectory()) {
+            if (mergeMode && fs5.existsSync(destPath)) {
               continue;
             }
-            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            await fs5.copy(srcPath, destPath, { overwrite: !mergeMode });
             copied.push(`bundled:${skill}`);
           }
         }
@@ -1186,17 +1296,17 @@ var init_discord_adapter = __esm({
       }
       async copyBaseFiles(targetDir, mergeMode) {
         const { CLI_ROOT: CLI_ROOT2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
-        const discordTemplates = join5(CLI_ROOT2, "templates", "discord");
+        const discordTemplates = join6(CLI_ROOT2, "templates", "discord");
         const copied = [];
         const filesToCopy = ["config.json5", "README.md"];
         for (const file of filesToCopy) {
-          const srcPath = join5(discordTemplates, file);
-          const destPath = join5(targetDir, file);
-          if (fs4.existsSync(srcPath)) {
-            if (mergeMode && fs4.existsSync(destPath)) {
+          const srcPath = join6(discordTemplates, file);
+          const destPath = join6(targetDir, file);
+          if (fs5.existsSync(srcPath)) {
+            if (mergeMode && fs5.existsSync(destPath)) {
               continue;
             }
-            await fs4.copy(srcPath, destPath, { overwrite: !mergeMode });
+            await fs5.copy(srcPath, destPath, { overwrite: !mergeMode });
             copied.push(file);
           }
         }
@@ -1206,11 +1316,11 @@ var init_discord_adapter = __esm({
        * Update Discord config with bot token
        */
       async updateConfig(targetDir, token, guildId) {
-        const configPath = join5(targetDir, "config.json5");
-        if (!fs4.existsSync(configPath)) {
+        const configPath = join6(targetDir, "config.json5");
+        if (!fs5.existsSync(configPath)) {
           return;
         }
-        let content = await fs4.readFile(configPath, "utf-8");
+        let content = await fs5.readFile(configPath, "utf-8");
         content = content.replace(
           '"token": "${DISCORD_BOT_TOKEN}"',
           `"token": "${token}"`
@@ -1229,7 +1339,7 @@ var init_discord_adapter = __esm({
         // Example guild configuration`
           );
         }
-        await fs4.writeFile(configPath, content, "utf-8");
+        await fs5.writeFile(configPath, content, "utf-8");
       }
       /**
        * Setup OpenClaw CLI configuration
@@ -1277,13 +1387,16 @@ var init_targets = __esm({
     "use strict";
     init_claude_adapter();
     init_gemini_adapter();
+    init_codex_adapter();
     init_discord_adapter();
     init_claude_adapter();
     init_gemini_adapter();
+    init_codex_adapter();
     init_discord_adapter();
     adapters = {
       claude: new ClaudeAdapter(),
       gemini: new GeminiAdapter(),
+      codex: new CodexAdapter(),
       discord: new DiscordAdapter()
     };
   }
@@ -1291,23 +1404,23 @@ var init_targets = __esm({
 
 // src/utils/hash.ts
 import { createHash } from "crypto";
-import fs5 from "fs-extra";
-import { join as join6, relative } from "path";
+import fs6 from "fs-extra";
+import { join as join7, relative } from "path";
 function hashFile(filePath) {
-  if (!fs5.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     return null;
   }
-  const content = fs5.readFileSync(filePath);
+  const content = fs6.readFileSync(filePath);
   return createHash("md5").update(content).digest("hex");
 }
 async function hashDirectory(dirPath, baseDir = dirPath) {
   const hashes = {};
-  if (!fs5.existsSync(dirPath)) {
+  if (!fs6.existsSync(dirPath)) {
     return hashes;
   }
-  const items = await fs5.readdir(dirPath, { withFileTypes: true });
+  const items = await fs6.readdir(dirPath, { withFileTypes: true });
   for (const item of items) {
-    const itemPath = join6(dirPath, item.name);
+    const itemPath = join7(dirPath, item.name);
     const relativePath = relative(baseDir, itemPath);
     if (item.isDirectory()) {
       const subHashes = await hashDirectory(itemPath, baseDir);
@@ -1328,27 +1441,27 @@ var init_hash = __esm({
 });
 
 // src/utils/state.ts
-import fs6 from "fs-extra";
-import { join as join7 } from "path";
+import fs7 from "fs-extra";
+import { join as join8 } from "path";
 function getStatePath(projectDir) {
-  return join7(projectDir, STATE_DIR, STATE_FILE);
+  return join8(projectDir, STATE_DIR, STATE_FILE);
 }
 async function loadState(projectDir) {
   const statePath = getStatePath(projectDir);
-  if (!fs6.existsSync(statePath)) {
+  if (!fs7.existsSync(statePath)) {
     return null;
   }
   try {
-    return await fs6.readJson(statePath);
+    return await fs7.readJson(statePath);
   } catch {
     return null;
   }
 }
 async function saveState(projectDir, state) {
-  const stateDir = join7(projectDir, STATE_DIR);
-  const statePath = join7(stateDir, STATE_FILE);
-  await fs6.ensureDir(stateDir);
-  await fs6.writeJson(statePath, state, { spaces: 2 });
+  const stateDir = join8(projectDir, STATE_DIR);
+  const statePath = join8(stateDir, STATE_FILE);
+  await fs7.ensureDir(stateDir);
+  await fs7.writeJson(statePath, state, { spaces: 2 });
 }
 async function createInitialState(projectDir, options) {
   const { kit, source, target, targets, installed } = options;
@@ -1356,8 +1469,8 @@ async function createInitialState(projectDir, options) {
   const targetList = targets || [target.replace(".", "")];
   for (const t of targetList) {
     const targetDirName = t.startsWith(".") ? t : `.${t}`;
-    const targetDir = join7(projectDir, targetDirName);
-    if (fs6.existsSync(targetDir)) {
+    const targetDir = join8(projectDir, targetDirName);
+    if (fs7.existsSync(targetDir)) {
       const hashes = await hashDirectory(targetDir);
       for (const [path, hash] of Object.entries(hashes)) {
         allHashes[`${targetDirName}/${path}`] = hash;
@@ -1383,7 +1496,7 @@ async function updateState(projectDir, updates) {
   if (!state) {
     throw new Error("No state found. Is this an ak project?");
   }
-  const targetDir = join7(projectDir, state.target || ".claude");
+  const targetDir = join8(projectDir, state.target || ".claude");
   const newHashes = await hashDirectory(targetDir);
   const updatedState = {
     ...state,
@@ -1399,7 +1512,7 @@ async function getFileStatuses(projectDir) {
   if (!state) {
     return { error: "No state found" };
   }
-  const targetDir = join7(projectDir, state.target || ".claude");
+  const targetDir = join8(projectDir, state.target || ".claude");
   const currentHashes = await hashDirectory(targetDir);
   const originalHashes = state.originalHashes || {};
   const statuses = {
@@ -1439,38 +1552,38 @@ var init_state = __esm({
 });
 
 // src/utils/copy.ts
-import fs7 from "fs-extra";
-import { join as join8, dirname as dirname5 } from "path";
+import fs8 from "fs-extra";
+import { join as join9, dirname as dirname4 } from "path";
 async function copyItems(items, type, sourceDir, destDir, mergeMode = false) {
-  const typeDir = join8(sourceDir, type);
-  const destTypeDir = join8(destDir, type);
-  if (!fs7.existsSync(typeDir)) {
+  const typeDir = join9(sourceDir, type);
+  const destTypeDir = join9(destDir, type);
+  if (!fs8.existsSync(typeDir)) {
     return { copied: [], skipped: items, errors: [] };
   }
-  await fs7.ensureDir(destTypeDir);
+  await fs8.ensureDir(destTypeDir);
   const copied = [];
   const skipped = [];
   const errors = [];
   for (const item of items) {
     try {
-      const itemPath = join8(typeDir, item);
+      const itemPath = join9(typeDir, item);
       const itemPathMd = itemPath + ".md";
       let srcPath;
-      if (fs7.existsSync(itemPath)) {
+      if (fs8.existsSync(itemPath)) {
         srcPath = itemPath;
-      } else if (fs7.existsSync(itemPathMd)) {
+      } else if (fs8.existsSync(itemPathMd)) {
         srcPath = itemPathMd;
       } else {
         skipped.push(item);
         continue;
       }
-      const stat = fs7.statSync(srcPath);
+      const stat = fs8.statSync(srcPath);
       if (stat.isDirectory()) {
-        await fs7.copy(srcPath, join8(destTypeDir, item), { overwrite: !mergeMode });
+        await fs8.copy(srcPath, join9(destTypeDir, item), { overwrite: !mergeMode });
       } else {
-        const destPath = srcPath.endsWith(".md") ? join8(destTypeDir, item + ".md") : join8(destTypeDir, item);
-        await fs7.ensureDir(join8(destTypeDir, item.split("/").slice(0, -1).join("/")));
-        await fs7.copy(srcPath, destPath, { overwrite: !mergeMode });
+        const destPath = srcPath.endsWith(".md") ? join9(destTypeDir, item + ".md") : join9(destTypeDir, item);
+        await fs8.ensureDir(join9(destTypeDir, item.split("/").slice(0, -1).join("/")));
+        await fs8.copy(srcPath, destPath, { overwrite: !mergeMode });
       }
       copied.push(item);
     } catch (err) {
@@ -1480,25 +1593,25 @@ async function copyItems(items, type, sourceDir, destDir, mergeMode = false) {
   return { copied, skipped, errors };
 }
 async function copyAgentsMd(agentsMdPath, projectDir, mergeMode = false) {
-  if (!agentsMdPath || !fs7.existsSync(agentsMdPath)) {
+  if (!agentsMdPath || !fs8.existsSync(agentsMdPath)) {
     return false;
   }
-  const destPath = join8(projectDir, "AGENTS.md");
-  if (mergeMode && fs7.existsSync(destPath)) {
+  const destPath = join9(projectDir, "AGENTS.md");
+  if (mergeMode && fs8.existsSync(destPath)) {
     return false;
   }
-  await fs7.copy(agentsMdPath, destPath, { overwrite: !mergeMode });
+  await fs8.copy(agentsMdPath, destPath, { overwrite: !mergeMode });
   return true;
 }
 function listAvailable(type, sourceDir) {
-  const typeDir = join8(sourceDir, type);
-  if (!fs7.existsSync(typeDir)) {
+  const typeDir = join9(sourceDir, type);
+  if (!fs8.existsSync(typeDir)) {
     return [];
   }
-  const items = fs7.readdirSync(typeDir);
+  const items = fs8.readdirSync(typeDir);
   return items.map((item) => {
-    const itemPath = join8(typeDir, item);
-    const isDir = fs7.statSync(itemPath).isDirectory();
+    const itemPath = join9(typeDir, item);
+    const isDir = fs8.statSync(itemPath).isDirectory();
     const name = item.replace(/\.md$/, "");
     return { name, isDir, path: itemPath };
   });
@@ -1533,6 +1646,7 @@ async function promptCliTargets() {
     options: [
       { value: "claude", label: "Claude Code", hint: ".claude/" },
       { value: "gemini", label: "Gemini CLI", hint: ".gemini/" },
+      { value: "codex", label: "Codex CLI", hint: ".agents/ + .codex/" },
       { value: "discord", label: "Discord + Clawbot", hint: ".discord/" }
     ],
     initialValues: ["claude"],
@@ -1648,10 +1762,10 @@ function isGeminiCliInstalled() {
 }
 function isGeminiCliLoggedIn() {
   try {
-    const fs15 = __require("fs");
+    const fs16 = __require("fs");
     const path = __require("path");
     const credsPath = path.join(process.env.HOME || "", ".gemini", "oauth_creds.json");
-    return fs15.existsSync(credsPath);
+    return fs16.existsSync(credsPath);
   } catch {
     return false;
   }
@@ -1890,8 +2004,8 @@ var init_exports = {};
 __export(init_exports, {
   initCommand: () => initCommand
 });
-import fs8 from "fs-extra";
-import { join as join9, resolve as resolve2 } from "path";
+import fs9 from "fs-extra";
+import { join as join10, resolve as resolve2 } from "path";
 import pc2 from "picocolors";
 import ora from "ora";
 function filterComponents(list, exclude, only) {
@@ -1965,18 +2079,18 @@ async function initCommand(projectName, options) {
   let existingAction = null;
   const existingTargets = [];
   for (const target of cliTargets) {
-    const targetDir = join9(projectDir, getTargetDirectory(target));
-    if (options.fresh && fs8.existsSync(targetDir)) {
-      await fs8.remove(targetDir);
+    const targetDir = join10(projectDir, getTargetDirectory(target));
+    if (options.fresh && fs9.existsSync(targetDir)) {
+      await fs9.remove(targetDir);
       existingTargets.push(getTargetDisplayName(target));
-    } else if (fs8.existsSync(targetDir) && !options.force) {
+    } else if (fs9.existsSync(targetDir) && !options.force) {
       existingTargets.push(getTargetDisplayName(target));
     }
   }
   if (options.fresh && existingTargets.length > 0) {
-    const akDir = join9(projectDir, ".ak");
-    if (fs8.existsSync(akDir)) {
-      await fs8.remove(akDir);
+    const akDir = join10(projectDir, ".ak");
+    if (fs9.existsSync(akDir)) {
+      await fs9.remove(akDir);
     }
     console.log(pc2.cyan(`Fresh install: removed existing files (${existingTargets.join(", ")})`));
     existingAction = null;
@@ -1996,8 +2110,8 @@ async function initCommand(projectName, options) {
       }
     }
   }
-  if (!isCurrentDir && fs8.existsSync(projectDir) && !options.force) {
-    const files = fs8.readdirSync(projectDir);
+  if (!isCurrentDir && fs9.existsSync(projectDir) && !options.force) {
+    const files = fs9.readdirSync(projectDir);
     if (files.length > 0 && !existingAction) {
       console.log(pc2.red(`Directory "${projectName}" already exists and is not empty.`));
       console.log(pc2.gray("Use --force to overwrite."));
@@ -2078,22 +2192,22 @@ async function initCommand(projectName, options) {
   }
   const spinner = ora("Creating project...").start();
   try {
-    await fs8.ensureDir(projectDir);
+    await fs9.ensureDir(projectDir);
     for (const target of cliTargets) {
       const adapter = getAdapter(target);
-      const targetDir = join9(projectDir, adapter.config.directory);
-      await fs8.ensureDir(targetDir);
+      const targetDir = join10(projectDir, adapter.config.directory);
+      await fs9.ensureDir(targetDir);
       const targetLabel = adapter.config.displayName;
       if (kitName === "full" && target === "claude") {
         spinner.text = mergeMode ? `Merging full kit (${targetLabel})...` : `Copying full kit (${targetLabel})...`;
-        const items = await fs8.readdir(source.claudeDir);
+        const items = await fs9.readdir(source.claudeDir);
         for (const item of items) {
-          const srcPath = join9(source.claudeDir, item);
-          const destPath = join9(targetDir, item);
-          if (mergeMode && await fs8.pathExists(destPath)) {
+          const srcPath = join10(source.claudeDir, item);
+          const destPath = join10(targetDir, item);
+          if (mergeMode && await fs9.pathExists(destPath)) {
             continue;
           }
-          await fs8.copy(srcPath, destPath, { overwrite: !mergeMode });
+          await fs9.copy(srcPath, destPath, { overwrite: !mergeMode });
         }
         continue;
       }
@@ -2218,8 +2332,8 @@ var add_exports = {};
 __export(add_exports, {
   addCommand: () => addCommand
 });
-import fs9 from "fs-extra";
-import { join as join10 } from "path";
+import fs10 from "fs-extra";
+import { join as join11 } from "path";
 import pc3 from "picocolors";
 import ora2 from "ora";
 async function addCommand(item, options = {}) {
@@ -2274,10 +2388,10 @@ async function addCommand(item, options = {}) {
     return;
   }
   const targetFolder = state?.target || ".claude";
-  const targetDir = join10(projectDir, targetFolder);
-  const destPath = join10(targetDir, normalizedType, name);
+  const targetDir = join11(projectDir, targetFolder);
+  const destPath = join11(targetDir, normalizedType, name);
   const destPathMd = destPath + ".md";
-  if (fs9.existsSync(destPath) || fs9.existsSync(destPathMd)) {
+  if (fs10.existsSync(destPath) || fs10.existsSync(destPathMd)) {
     console.log(pc3.yellow(`${type} "${name}" already exists in project.`));
     console.log(pc3.gray('Use "tk update" to refresh from source.'));
     return;
@@ -2493,8 +2607,8 @@ var update_exports = {};
 __export(update_exports, {
   updateCommand: () => updateCommand
 });
-import fs10 from "fs-extra";
-import { join as join11 } from "path";
+import fs11 from "fs-extra";
+import { join as join12 } from "path";
 import pc5 from "picocolors";
 import ora3 from "ora";
 async function updateCommand(options = {}) {
@@ -2533,8 +2647,8 @@ async function updateCommand(options = {}) {
     if (options.commands) typesToUpdate = ["commands"];
     const sourceHashes = {};
     for (const type of typesToUpdate) {
-      const typeDir = join11(source.claudeDir, type);
-      if (fs10.existsSync(typeDir)) {
+      const typeDir = join12(source.claudeDir, type);
+      if (fs11.existsSync(typeDir)) {
         const hashes = await hashDirectory(typeDir);
         for (const [path, hash] of Object.entries(hashes)) {
           sourceHashes[`${type}/${path}`] = hash;
@@ -2545,9 +2659,9 @@ async function updateCommand(options = {}) {
     const skipped = [];
     const newFiles = [];
     for (const [path, sourceHash] of Object.entries(sourceHashes)) {
-      const currentPath = join11(targetDir, path);
+      const currentPath = join12(targetDir, path);
       const originalHash = state.originalHashes?.[path];
-      const currentHash = fs10.existsSync(currentPath) ? hashFile(currentPath) : null;
+      const currentHash = fs11.existsSync(currentPath) ? hashFile(currentPath) : null;
       if (!currentHash) {
         newFiles.push(path);
       } else if (currentHash === originalHash) {
@@ -2600,10 +2714,10 @@ async function updateCommand(options = {}) {
     let failed = 0;
     for (const path of [...toUpdate, ...newFiles]) {
       try {
-        const srcPath = join11(source.claudeDir, path);
-        const destPath = join11(targetDir, path);
-        await fs10.ensureDir(join11(targetDir, path.split("/").slice(0, -1).join("/")));
-        await fs10.copy(srcPath, destPath, { overwrite: true });
+        const srcPath = join12(source.claudeDir, path);
+        const destPath = join12(targetDir, path);
+        await fs11.ensureDir(join12(targetDir, path.split("/").slice(0, -1).join("/")));
+        await fs11.copy(srcPath, destPath, { overwrite: true });
         updated++;
       } catch (err) {
         failed++;
@@ -2653,7 +2767,7 @@ __export(status_exports, {
   statusCommand: () => statusCommand
 });
 import pc6 from "picocolors";
-import fs11 from "fs-extra";
+import fs12 from "fs-extra";
 async function statusCommand(options = {}) {
   const projectDir = process.cwd();
   if (!isAkProject(projectDir)) {
@@ -2734,7 +2848,7 @@ async function statusCommand(options = {}) {
     if (hooks) console.log(pc6.gray("  Hooks:     \u2713"));
     console.log("");
   }
-  if (state.source && !fs11.existsSync(state.source)) {
+  if (state.source && !fs12.existsSync(state.source)) {
     console.log(pc6.yellow("\u26A0 Source directory not found. Update may not work."));
     console.log(pc6.gray(`  Expected: ${state.source}`));
     console.log("");
@@ -2753,15 +2867,15 @@ var doctor_exports = {};
 __export(doctor_exports, {
   doctorCommand: () => doctorCommand
 });
-import fs12 from "fs-extra";
-import { join as join12 } from "path";
+import fs13 from "fs-extra";
+import { join as join13 } from "path";
 import pc7 from "picocolors";
 async function doctorCommand(options = {}) {
   const projectDir = process.cwd();
   let targetDir = null;
   for (const [name, folder] of Object.entries(TARGETS)) {
-    const dir = join12(projectDir, folder);
-    if (fs12.existsSync(dir)) {
+    const dir = join13(projectDir, folder);
+    if (fs13.existsSync(dir)) {
       targetDir = { name, folder, dir };
       break;
     }
@@ -2774,7 +2888,7 @@ async function doctorCommand(options = {}) {
       severity: "error",
       check: () => isAkProject(projectDir),
       fix: async () => {
-        await fs12.ensureDir(join12(projectDir, ".ak"));
+        await fs13.ensureDir(join13(projectDir, ".ak"));
       }
     },
     {
@@ -2790,9 +2904,9 @@ async function doctorCommand(options = {}) {
         if (targetDir) {
           const dirs = ["agents", "skills", "commands", "workflows"];
           for (const dir of dirs) {
-            const fullPath = join12(targetDir.dir, dir);
-            if (fs12.existsSync(fullPath)) {
-              const items = fs12.readdirSync(fullPath).filter((f) => !f.startsWith("."));
+            const fullPath = join13(targetDir.dir, dir);
+            if (fs13.existsSync(fullPath)) {
+              const items = fs13.readdirSync(fullPath).filter((f) => !f.startsWith("."));
               if (items.length > 0) {
                 installed[dir] = items;
               }
@@ -2814,7 +2928,7 @@ async function doctorCommand(options = {}) {
       name: "agents_md",
       label: "AGENTS.md exists",
       severity: "warning",
-      check: () => fs12.existsSync(join12(projectDir, "AGENTS.md"))
+      check: () => fs13.existsSync(join13(projectDir, "AGENTS.md"))
     },
     {
       name: "source",
@@ -2822,7 +2936,7 @@ async function doctorCommand(options = {}) {
       severity: "error",
       check: () => {
         if (!state || !state.source) return true;
-        return fs12.existsSync(state.source);
+        return fs13.existsSync(state.source);
       },
       getMeta: () => state && state.source ? { source: state.source } : {}
     },
@@ -2832,18 +2946,18 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs12.existsSync(join12(targetDir.dir, "agents"));
+        return fs13.existsSync(join13(targetDir.dir, "agents"));
       },
       fix: async () => {
         if (targetDir) {
-          await fs12.ensureDir(join12(targetDir.dir, "agents"));
+          await fs13.ensureDir(join13(targetDir.dir, "agents"));
         }
       },
       getMeta: () => {
         if (!targetDir) return {};
-        const fullPath = join12(targetDir.dir, "agents");
-        if (fs12.existsSync(fullPath)) {
-          const items = fs12.readdirSync(fullPath).length;
+        const fullPath = join13(targetDir.dir, "agents");
+        if (fs13.existsSync(fullPath)) {
+          const items = fs13.readdirSync(fullPath).length;
           return { items };
         }
         return {};
@@ -2855,18 +2969,18 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs12.existsSync(join12(targetDir.dir, "commands"));
+        return fs13.existsSync(join13(targetDir.dir, "commands"));
       },
       fix: async () => {
         if (targetDir) {
-          await fs12.ensureDir(join12(targetDir.dir, "commands"));
+          await fs13.ensureDir(join13(targetDir.dir, "commands"));
         }
       },
       getMeta: () => {
         if (!targetDir) return {};
-        const fullPath = join12(targetDir.dir, "commands");
-        if (fs12.existsSync(fullPath)) {
-          const items = fs12.readdirSync(fullPath).length;
+        const fullPath = join13(targetDir.dir, "commands");
+        if (fs13.existsSync(fullPath)) {
+          const items = fs13.readdirSync(fullPath).length;
           return { items };
         }
         return {};
@@ -2878,18 +2992,18 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs12.existsSync(join12(targetDir.dir, "skills"));
+        return fs13.existsSync(join13(targetDir.dir, "skills"));
       },
       fix: async () => {
         if (targetDir) {
-          await fs12.ensureDir(join12(targetDir.dir, "skills"));
+          await fs13.ensureDir(join13(targetDir.dir, "skills"));
         }
       },
       getMeta: () => {
         if (!targetDir) return {};
-        const fullPath = join12(targetDir.dir, "skills");
-        if (fs12.existsSync(fullPath)) {
-          const items = fs12.readdirSync(fullPath).length;
+        const fullPath = join13(targetDir.dir, "skills");
+        if (fs13.existsSync(fullPath)) {
+          const items = fs13.readdirSync(fullPath).length;
           return { items };
         }
         return {};
@@ -2901,7 +3015,7 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs12.existsSync(join12(targetDir.dir, "scripts"));
+        return fs13.existsSync(join13(targetDir.dir, "scripts"));
       }
     },
     {
@@ -2910,7 +3024,7 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs12.existsSync(join12(targetDir.dir, "hooks"));
+        return fs13.existsSync(join13(targetDir.dir, "hooks"));
       }
     },
     {
@@ -2919,7 +3033,7 @@ async function doctorCommand(options = {}) {
       severity: "warning",
       check: () => {
         if (!targetDir) return false;
-        return fs12.existsSync(join12(targetDir.dir, "statusline.cjs")) || fs12.existsSync(join12(targetDir.dir, "statusline.sh"));
+        return fs13.existsSync(join13(targetDir.dir, "statusline.cjs")) || fs13.existsSync(join13(targetDir.dir, "statusline.sh"));
       }
     }
   ];
@@ -3077,9 +3191,9 @@ async function outputReport(projectDir, results, options) {
       }
     }
   }
-  const reportPath = join12(projectDir, ".ak", "doctor-report.md");
-  await fs12.ensureDir(join12(projectDir, ".ak"));
-  await fs12.writeFile(reportPath, markdown, "utf-8");
+  const reportPath = join13(projectDir, ".ak", "doctor-report.md");
+  await fs13.ensureDir(join13(projectDir, ".ak"));
+  await fs13.writeFile(reportPath, markdown, "utf-8");
   if (!options.json) {
     console.log(pc7.green(`
 \u2713 Report saved to ${reportPath}
@@ -3152,7 +3266,7 @@ async function outputColored(projectDir, results, state, targetDir) {
     if (!hasState && isProject) {
       console.log(pc7.white('  \u2022 State file is missing. Re-run "tk init" or create manually'));
     }
-    if (state && state.source && !fs12.existsSync(state.source)) {
+    if (state && state.source && !fs13.existsSync(state.source)) {
       console.log(pc7.white("  \u2022 Update source path: tk update --source <new-path>"));
     }
     console.log("");
@@ -3193,8 +3307,8 @@ var uninstall_exports = {};
 __export(uninstall_exports, {
   uninstallCommand: () => uninstallCommand
 });
-import fs13 from "fs-extra";
-import { join as join13 } from "path";
+import fs14 from "fs-extra";
+import { join as join14 } from "path";
 import pc9 from "picocolors";
 import ora4 from "ora";
 import * as p2 from "@clack/prompts";
@@ -3223,13 +3337,13 @@ async function uninstallFromDir(type, dir, options) {
   const state = await loadState(dir);
   const existingTargets = [];
   for (const [name, folder] of Object.entries(TARGETS)) {
-    const targetPath = join13(dir, folder);
-    if (fs13.existsSync(targetPath)) {
+    const targetPath = join14(dir, folder);
+    if (fs14.existsSync(targetPath)) {
       existingTargets.push({ name, path: targetPath });
     }
   }
-  const akDir = join13(dir, ".ak");
-  const hasAkState = fs13.existsSync(akDir);
+  const akDir = join14(dir, ".ak");
+  const hasAkState = fs14.existsSync(akDir);
   if (existingTargets.length === 0 && !hasAkState) {
     spinner.warn(pc9.yellow(`No AK installation found in ${type}`));
     return 0;
@@ -3238,8 +3352,8 @@ async function uninstallFromDir(type, dir, options) {
   const removalList = [];
   for (const target of existingTargets) {
     for (const subdir of AK_SUBDIRS) {
-      const subdirPath = join13(target.path, subdir);
-      if (fs13.existsSync(subdirPath)) {
+      const subdirPath = join14(target.path, subdir);
+      if (fs14.existsSync(subdirPath)) {
         removalList.push(subdirPath);
       }
     }
@@ -3320,7 +3434,7 @@ async function removeItems(paths, baseDir) {
       continue;
     }
     try {
-      await fs13.remove(path);
+      await fs14.remove(path);
       result.removed.push(path);
     } catch (error) {
       result.errors.push({
@@ -3434,10 +3548,10 @@ import { execSync as execSync2 } from "child_process";
 import pc11 from "picocolors";
 import ora6 from "ora";
 import { readFileSync } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 function getCurrentVersion() {
   try {
-    const pkg = JSON.parse(readFileSync(join14(CLI_ROOT, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync(join15(CLI_ROOT, "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0";
@@ -3497,8 +3611,8 @@ __export(skills_exports, {
   skillsCommand: () => skillsCommand
 });
 import pc12 from "picocolors";
-import fs14 from "fs-extra";
-import { join as join15 } from "path";
+import fs15 from "fs-extra";
+import { join as join16 } from "path";
 import * as p3 from "@clack/prompts";
 async function skillsCommand(options) {
   const { name, agent, list, installed, uninstall, yes } = options;
@@ -3576,8 +3690,8 @@ async function installSkill(skillName, agents, skipConfirm) {
     console.log(pc12.red(`Error: ${source.error}`));
     process.exit(1);
   }
-  const skillPath = join15(source.claudeDir, "skills", skillName);
-  if (!fs14.existsSync(skillPath)) {
+  const skillPath = join16(source.claudeDir, "skills", skillName);
+  if (!fs15.existsSync(skillPath)) {
     console.log(pc12.red(`Error: Skill "${skillName}" not found in source`));
     console.log(pc12.gray(`Available skills: ak skills --list`));
     process.exit(1);
@@ -3594,9 +3708,9 @@ async function installSkill(skillName, agents, skipConfirm) {
   const results = [];
   for (const agent of agents) {
     try {
-      const targetPath = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
-      await fs14.ensureDir(join15(process.cwd(), AGENT_SKILL_PATHS[agent]));
-      await fs14.copy(skillPath, targetPath, { overwrite: true });
+      const targetPath = join16(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs15.ensureDir(join16(process.cwd(), AGENT_SKILL_PATHS[agent]));
+      await fs15.copy(skillPath, targetPath, { overwrite: true });
       results.push({ agent, success: true });
     } catch (err) {
       results.push({ agent, success: false, error: err.message });
@@ -3635,8 +3749,8 @@ async function uninstallSkill(skillName, agents, skipConfirm) {
   const results = [];
   for (const agent of installedIn) {
     try {
-      const targetPath = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
-      await fs14.remove(targetPath);
+      const targetPath = join16(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+      await fs15.remove(targetPath);
       results.push({ agent, success: true });
     } catch (err) {
       results.push({ agent, success: false, error: err.message });
@@ -3671,19 +3785,19 @@ function parseAgents(agentFlag) {
   return valid;
 }
 function isSkillInstalled(skillName, agent) {
-  const skillPath = join15(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
-  return fs14.existsSync(skillPath);
+  const skillPath = join16(process.cwd(), AGENT_SKILL_PATHS[agent], skillName);
+  return fs15.existsSync(skillPath);
 }
 function getInstalledSkills(agent) {
-  const skillsDir = join15(process.cwd(), AGENT_SKILL_PATHS[agent]);
-  if (!fs14.existsSync(skillsDir)) {
+  const skillsDir = join16(process.cwd(), AGENT_SKILL_PATHS[agent]);
+  if (!fs15.existsSync(skillsDir)) {
     return [];
   }
   try {
-    const items = fs14.readdirSync(skillsDir);
+    const items = fs15.readdirSync(skillsDir);
     return items.filter((item) => {
-      const itemPath = join15(skillsDir, item);
-      return fs14.statSync(itemPath).isDirectory();
+      const itemPath = join16(skillsDir, item);
+      return fs15.statSync(itemPath).isDirectory();
     });
   } catch {
     return [];
@@ -3707,7 +3821,7 @@ var init_skills = __esm({
 import cac from "cac";
 import { readFileSync as readFileSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { dirname as dirname6, join as join17 } from "path";
+import { dirname as dirname5, join as join18 } from "path";
 import pc13 from "picocolors";
 
 // src/cli/command-registry.ts
@@ -3763,11 +3877,11 @@ function registerCommands(cli2) {
 }
 
 // src/utils/version-check.ts
-import { join as join16 } from "path";
+import { join as join17 } from "path";
 import { homedir as homedir2 } from "os";
 import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync } from "fs";
-var CACHE_DIR = join16(homedir2(), ".thanh-kit");
-var CACHE_FILE = join16(CACHE_DIR, "version-check.json");
+var CACHE_DIR = join17(homedir2(), ".thanh-kit");
+var CACHE_FILE = join17(CACHE_DIR, "version-check.json");
 var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
 function getCachedVersionNoFetch() {
   try {
@@ -3791,10 +3905,10 @@ function isNewerVersion(current, latest) {
 
 // src/index.ts
 var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = dirname6(__filename2);
+var __dirname2 = dirname5(__filename2);
 function getVersion() {
   try {
-    const pkg = JSON.parse(readFileSync3(join17(__dirname2, "..", "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync3(join18(__dirname2, "..", "package.json"), "utf-8"));
     return pkg.version;
   } catch {
     return "0.0.0";